bug in 23.2.92 with anything

bug in 23.2.92 with anything

[Thierry Volpiatto]

Hi,
in 23.2.92 of january 14, when i start anything and enter a character in
minibuffer, cursor switch to beginning of line in minibuffer.
In 23.2.91 (the last commit of the january 13) this doesn't happen.
In 24.0.50 of january 15 (today) this doesn't happen too.
So i wonder what changes have been made, possibly in minibuffer related
code, on the january 14 in emacs-23 branch.(couldn't find in changelog)
Even if you are not interested by anything, would be cool to answer to
this.
Thanks.

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[Chong Yidong]

Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:

> in 23.2.92 of january 14, when i start anything and enter a character in
> minibuffer, cursor switch to beginning of line in minibuffer.
> In 23.2.91 (the last commit of the january 13) this doesn't happen.
> In 24.0.50 of january 15 (today) this doesn't happen too.
> So i wonder what changes have been made, possibly in minibuffer related
> code, on the january 14 in emacs-23 branch.(couldn't find in changelog)
> Even if you are not interested by anything, would be cool to answer to

Could you check if the problem is caused by revision 100380, i.e. this
change:

	* window.c (inhibit_point_swap): New variable.
	(Fselect_window): If inhibit_point_swap is nonzero, avoid swapping
	point this time.
	(Fset_window_configuration): Set inhibit_point_swap to 1 instead
	of setting selected_window to nil (Bug#7728).

Re: bug in 23.2.92 with anything

[martin rudalics]

 > in 23.2.92 of january 14, when i start anything and enter a character in
 > minibuffer, cursor switch to beginning of line in minibuffer.
 > In 23.2.91 (the last commit of the january 13) this doesn't happen.
 > In 24.0.50 of january 15 (today) this doesn't happen too.
 > So i wonder what changes have been made, possibly in minibuffer related
 > code, on the january 14 in emacs-23 branch.(couldn't find in changelog)

In Fselect_window of window.c after the clause

   if (not_selected_before)
     {
       sf = SELECTED_FRAME ();
       if (XFRAME (WINDOW_FRAME (w)) != sf)
       ...
       selected_window = window;
     }

there should be the two lines

   else
     inhibit_point_swap = 0;

I don't have Emacs 23 here so I can't check whether they are but somehow
the diffs on emacs-diffs seem to miss them.  Could you please have a look
and, if they are missing, put them there, reinstall and try whether the
bug is gone?

Thanks, martin

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

Chong Yidong <cyd@stupidchicken.com> writes:

> Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:
>
>> in 23.2.92 of january 14, when i start anything and enter a character in
>> minibuffer, cursor switch to beginning of line in minibuffer.
>> In 23.2.91 (the last commit of the january 13) this doesn't happen.
>> In 24.0.50 of january 15 (today) this doesn't happen too.
>> So i wonder what changes have been made, possibly in minibuffer related
>> code, on the january 14 in emacs-23 branch.(couldn't find in changelog)
>> Even if you are not interested by anything, would be cool to answer to
>
> Could you check if the problem is caused by revision 100380, i.e. this
> change:
>
> 	* window.c (inhibit_point_swap): New variable.
> 	(Fselect_window): If inhibit_point_swap is nonzero, avoid swapping
> 	point this time.
> 	(Fset_window_configuration): Set inhibit_point_swap to 1 instead
> 	of setting selected_window to nil (Bug#7728).

Yes the problem is there.

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

>> in 23.2.92 of january 14, when i start anything and enter a character in
>> minibuffer, cursor switch to beginning of line in minibuffer.
>> In 23.2.91 (the last commit of the january 13) this doesn't happen.
>> In 24.0.50 of january 15 (today) this doesn't happen too.
>> So i wonder what changes have been made, possibly in minibuffer related
>> code, on the january 14 in emacs-23 branch.(couldn't find in changelog)
>
> In Fselect_window of window.c after the clause
>
>   if (not_selected_before)
>     {
>       sf = SELECTED_FRAME ();
>       if (XFRAME (WINDOW_FRAME (w)) != sf)
>       ...
>       selected_window = window;
>     }

Sorry, i can't find such code.

> there should be the two lines
>
>   else
>     inhibit_point_swap = 0;
>
> I don't have Emacs 23 here so I can't check whether they are but somehow
> the diffs on emacs-diffs seem to miss them.  Could you please have a look
> and, if they are missing, put them there, reinstall and try whether the
> bug is gone?
>
> Thanks, martin

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[Chong Yidong]

martin rudalics <rudalics@gmx.at> writes:

> In Fselect_window of window.c after the clause
>
>   if (not_selected_before)
>     {
>       sf = SELECTED_FRAME ();
>       if (XFRAME (WINDOW_FRAME (w)) != sf)
>       ...
>       selected_window = window;
>     }
>
> there should be the two lines
>
>   else
>     inhibit_point_swap = 0;

There is no `not_selected_before' variable on the branch, nor the trunk.
The code `sf = SELECTED_FRAME ()' etc. is not wrapped in any `if'
statement.

Re: bug in 23.2.92 with anything

[martin rudalics]

 > There is no `not_selected_before' variable on the branch, nor the trunk.
 > The code `sf = SELECTED_FRAME ()' etc. is not wrapped in any `if'
 > statement.

Arrgh, I'm confusing the trunk with my branch and so my patch was silly.
I suppose we miss a

       inhibit_point_swap = 0;

reset between the lines (maybe Thierry can check this)

       eassert (EQ (window, selected_window));
       return window;

but I suppose it's better to take the change out and test it on Emacs 24
first.

martin

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

>> There is no `not_selected_before' variable on the branch, nor the trunk.
>> The code `sf = SELECTED_FRAME ()' etc. is not wrapped in any `if'
>> statement.
>
> Arrgh, I'm confusing the trunk with my branch and so my patch was silly.
> I suppose we miss a
>
>       inhibit_point_swap = 0;
>
> reset between the lines (maybe Thierry can check this)
>
>       eassert (EQ (window, selected_window));
>       return window;

Here what i tried:

  if (XFRAME (WINDOW_FRAME (w)) != sf)
    {
      XFRAME (WINDOW_FRAME (w))->selected_window = window;
      /* Use this rather than Fhandle_switch_frame
	 so that FRAME_FOCUS_FRAME is moved appropriately as we
	 move around in the state where a minibuffer in a separate
	 frame is active.  */
      Fselect_frame (WINDOW_FRAME (w), norecord);
      /* Fselect_frame called us back so we've done all the work already.  */
      eassert (EQ (window, selected_window));
      inhibit_point_swap = 0;
      return window;
    }

Didn't work, bug still here.
But maybe what i did following your instructions is wrong?
If yes, be more explicit, as my C skill is around 0.
Thanks.

> but I suppose it's better to take the change out and test it on Emacs 24
> first.
>
> martin

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[martin rudalics]

 > But maybe what i did following your instructions is wrong?

Unfortunately no.  You did what I meant.

 > If yes, be more explicit, as my C skill is around 0.

As soon as I have found out why and how I changed the code in my branch
earlier.

Just to know: When I call `anything' here I get point after some prompt
like "nil" or "pattern" in the minibuffer.  Is this what is expected?

martin

Re: bug in 23.2.92 with anything

[Stefan Monnier]

> In Fselect_window of window.c after the clause

>   if (not_selected_before)
>     {
>       sf = SELECTED_FRAME ();
>       if (XFRAME (WINDOW_FRAME (w)) != sf)
>       ...
>       selected_window = window;
>     }

> there should be the two lines

>   else
>     inhibit_point_swap = 0;

Actually, using a global variable like this is butt-ugly.
Could some one rename Fselect_window to something else, add a third
parameter to it and create a new Fselect_window that calls it (and let
Fset_window_configuration call the new function with the new param), so
as to get rid of this global var?


        Stefan

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

>> But maybe what i did following your instructions is wrong?
>
> Unfortunately no.  You did what I meant.
>
>> If yes, be more explicit, as my C skill is around 0.
>
> As soon as I have found out why and how I changed the code in my branch
> earlier.
>
> Just to know: When I call `anything' here I get point after some prompt
> like "nil" or "pattern" in the minibuffer.  Is this what is expected?
Yes but after:

Here a cursor: !

the prompt is like this:

Pattern: !

i enter the letter a in prompt:

Pattern: !a

the cursor jump before the a

it should stay like this:

Pattern: a!


-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[Eli Zaretskii]

> From: Stefan Monnier <monnier@iro.umontreal.ca>
> Date: Sat, 15 Jan 2011 23:26:32 -0500
> Cc: emacs-devel@gnu.org, Thierry Volpiatto <thierry.volpiatto@gmail.com>
> 
> Actually, using a global variable like this is butt-ugly.

Agreed.

> Could some one rename Fselect_window to something else, add a third
> parameter to it and create a new Fselect_window that calls it (and let
> Fset_window_configuration call the new function with the new param), so
> as to get rid of this global var?

This is what I intended to do (I thought it was pretty clear from the
discussions that this is THE right solution), but I'm traveling now
and will be back only a week from now.  If no one beats me to it, I
will make this change.

Re: bug in 23.2.92 with anything

[martin rudalics]

[-- Attachment #1: Type: text/plain, Size: 414 bytes --]

 > Actually, using a global variable like this is butt-ugly.

Indeed.

 > Could some one rename Fselect_window to something else, add a third
 > parameter to it and create a new Fselect_window that calls it (and let
 > Fset_window_configuration call the new function with the new param), so
 > as to get rid of this global var?

Thierry could you try the attached patch against the trunk window.c?

Thanks, martin

[-- Attachment #2: window.c.diff --]
[-- Type: text/plain, Size: 4926 bytes --]

=== modified file 'src/window.c'
*** src/window.c	2011-01-15 23:16:57 +0000
--- src/window.c	2011-01-16 10:18:51 +0000
***************
*** 85,90 ****
--- 85,91 ----
                               int (* fn) (struct window *, void *),
                               void *);
  static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
+ static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
  
  /* This is the window in which the terminal's cursor should
     be left when nothing is being done with it.  This must
***************
*** 158,168 ****
  
  static int window_initialized;
  
- /* Set in `set-window-configuration' to prevent "swapping out point"
-    in the old selected window.  */
- 
- static int inhibit_point_swap;
- 
  /* Hook to run when window config changes.  */
  
  static Lisp_Object Qwindow_configuration_change_hook;
--- 159,164 ----
***************
*** 3550,3569 ****
    return Qnil;
  }
  
- /* Note that selected_window can be nil when this is called from
-    Fset_window_configuration.  */
  
! DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
!        doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
! If WINDOW is not already selected, make WINDOW's buffer current
! and make WINDOW the frame's selected window.  Return WINDOW.
! Optional second arg NORECORD non-nil means do not put this buffer
! at the front of the list of recently selected ones and do not
! make this window the most recently selected one.
  
! Note that the main editor command loop selects the buffer of the
! selected window before each command.  */)
!   (register Lisp_Object window, Lisp_Object norecord)
  {
    register struct window *w;
    register struct window *ow;
--- 3546,3560 ----
    return Qnil;
  }
  
  
! /* If select_window is called with inhibit_point_swap non-zero it will
!    not store point of the old selected window's buffer back into that
!    window's pointm slot.  This is needed by Fset_window_configuration to
!    avoid that the display routine is called with selected_window set to
!    Qnil causing a subsequent crash.  */
  
! static Lisp_Object
! select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
  {
    register struct window *w;
    register struct window *ow;
***************
*** 3603,3611 ****
    /* Store the current buffer's actual point into the
       old selected window.  It belongs to that window,
       and when the window is not selected, must be in the window.  */
!   if (inhibit_point_swap)
!     inhibit_point_swap = 0;
!   else
      {
        ow = XWINDOW (selected_window);
        if (! NILP (ow->buffer))
--- 3594,3600 ----
    /* Store the current buffer's actual point into the
       old selected window.  It belongs to that window,
       and when the window is not selected, must be in the window.  */
!   if (! inhibit_point_swap)
      {
        ow = XWINDOW (selected_window);
        if (! NILP (ow->buffer))
***************
*** 3639,3644 ****
--- 3628,3648 ----
    return window;
  }
  
+ DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
+        doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
+ If WINDOW is not already selected, make WINDOW's buffer current
+ and make WINDOW the frame's selected window.  Return WINDOW.
+ Optional second arg NORECORD non-nil means do not put this buffer
+ at the front of the list of recently selected ones and do not
+ make this window the most recently selected one.
+ 
+ Note that the main editor command loop selects the buffer of the
+ selected window before each command.  */)
+   (register Lisp_Object window, Lisp_Object norecord)
+ {
+   select_window (window, norecord, 0);
+ }
+ 
  static Lisp_Object
  select_window_norecord (Lisp_Object window)
  {
***************
*** 6167,6174 ****
  	 out point" in the old selected window using the buffer that
  	 has been restored into it.  We already swapped out that point
  	 from that window's old buffer.  */
!       inhibit_point_swap = 1;
!       Fselect_window (data->current_window, Qnil);
        XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
  	= selected_window;
  
--- 6171,6177 ----
  	 out point" in the old selected window using the buffer that
  	 has been restored into it.  We already swapped out that point
  	 from that window's old buffer.  */
!       select_window (data->current_window, Qnil, 1);
        XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
  	= selected_window;
  
***************
*** 7099,7106 ****
    window_scroll_preserve_hpos = -1;
    window_scroll_preserve_vpos = -1;
  
-   inhibit_point_swap = 0;
- 
    DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function,
  	       doc: /* Non-nil means call as function to display a help buffer.
  The function is called with one argument, the buffer to be displayed.
--- 7102,7107 ----

Re: bug in 23.2.92 with anything

[martin rudalics]

 > Here a cursor: !
 >
 > the prompt is like this:
 >
 > Pattern: !
 >
 > i enter the letter a in prompt:
 >
 > Pattern: !a
 >
 > the cursor jump before the a
 >
 > it should stay like this:
 >
 > Pattern: a!

I can't reproduce this with the current trunk (which includes the
change) and emacs -Q.  The cursor always stays after the letters I
entered.  Can you reproduce it with emacs -Q?

martin

Re: bug in 23.2.92 with anything

[martin rudalics]

 >> Could some one rename Fselect_window to something else, add a third
 >> parameter to it and create a new Fselect_window that calls it (and let
 >> Fset_window_configuration call the new function with the new param), so
 >> as to get rid of this global var?
 >
 > This is what I intended to do (I thought it was pretty clear from the
 > discussions that this is THE right solution), but I'm traveling now
 > and will be back only a week from now.  If no one beats me to it, I
 > will make this change.

I posted a patch along these lines - please tell me whether it is what
you had in mind.

I'm almost 100% convinced that it doesn't DTRT.  That parameter would
have to be passed on to Fselect_frame and from there back to
Fselect_window.  As I said earlier, the problem is that we temporarily
violate the invariant window_frame (selected_window) == selected_frame.
It's like having two routines for setting the character and byte
positions of point separately and calling a display routine in between.

martin

Re: bug in 23.2.92 with anything

[Eli Zaretskii]

> Date: Sun, 16 Jan 2011 12:35:55 +0100
> From: martin rudalics <rudalics@gmx.at>
> CC: Stefan Monnier <monnier@iro.umontreal.ca>, emacs-devel@gnu.org, 
>  thierry.volpiatto@gmail.com
> 
>  >> Could some one rename Fselect_window to something else, add a third
>  >> parameter to it and create a new Fselect_window that calls it (and let
>  >> Fset_window_configuration call the new function with the new param), so
>  >> as to get rid of this global var?
>  >
>  > This is what I intended to do (I thought it was pretty clear from the
>  > discussions that this is THE right solution), but I'm traveling now
>  > and will be back only a week from now.  If no one beats me to it, I
>  > will make this change.
> 
> I posted a patch along these lines - please tell me whether it is what
> you had in mind.

Yes, it is.  Thanks.

> I'm almost 100% convinced that it doesn't DTRT.  That parameter would
> have to be passed on to Fselect_frame and from there back to
> Fselect_window.  As I said earlier, the problem is that we temporarily
> violate the invariant window_frame (selected_window) == selected_frame.

IIUC, you are saying that there will be still additional problems left
even after this change.  If so, I might agree, but what we are trying
to do here is to avoid the situation whereby selected_window is nil,
because that bombs inside window_text_bottom_y.  Using the parameter
allows us to communicate to select-window that it should not swap out
point, without setting selected_window to nil.  Would you agree that
this part of the problem is fixed by the change you posted?  If not,
please explain why not.

Re: bug in 23.2.92 with anything

[Stefan Monnier]

> As I said earlier, the problem is that we temporarily violate the
> invariant window_frame (selected_window) == selected_frame.

No argument from me here.  BTW, there's another place in the redisplay
where we break this invariant, as mentioned in the corresponding
comment:

    /* When running redisplay, we play a bit fast-and-loose and allow e.g.
       selected_frame and selected_window to be temporarily out-of-sync so
       when we come back here via `goto retry', we need to resync because we
       may need to run Elisp code (via prepare_menu_bars).  */
    select_frame_for_redisplay (old_frame);

It would be good to get rid of such risky code.


        Stefan

Re: bug in 23.2.92 with anything

[martin rudalics]

 > IIUC, you are saying that there will be still additional problems left
 > even after this change.

The selected_window nil hack assures that point swapping is inhibited
until selected_window is set to some other value.  Our change assures
that point swapping is inhibited only for the first invocation of
Fselect_window.  If Fselect_window is called back via Fselect_frame,
point _is_ swapped.  This might even be TRT, but it does not preserve
the current behavior.

 > If so, I might agree, but what we are trying
 > to do here is to avoid the situation whereby selected_window is nil,
 > because that bombs inside window_text_bottom_y.  Using the parameter
 > allows us to communicate to select-window that it should not swap out
 > point, without setting selected_window to nil.  Would you agree that
 > this part of the problem is fixed by the change you posted?  If not,
 > please explain why not.

If selected_window is no more set to nil, the crash in its present form
will disappear.  The question is whether the change will change the
current behavior in the non-crashing case.  Using a global variable, one
can emulate the current behavior without running into the crash.

martin

Re: bug in 23.2.92 with anything

[martin rudalics]

 > No argument from me here.  BTW, there's another place in the redisplay
 > where we break this invariant, as mentioned in the corresponding
 > comment:
 >
 >     /* When running redisplay, we play a bit fast-and-loose and allow e.g.
 >        selected_frame and selected_window to be temporarily out-of-sync so
 >        when we come back here via `goto retry', we need to resync because we
 >        may need to run Elisp code (via prepare_menu_bars).  */
 >     select_frame_for_redisplay (old_frame);
 >
 > It would be good to get rid of such risky code.

Is there any reason why this should not select the window too?

martin

Re: bug in 23.2.92 with anything

[Eli Zaretskii]

> Date: Sun, 16 Jan 2011 18:51:24 +0100
> From: martin rudalics <rudalics@gmx.at>
> CC: Eli Zaretskii <eliz@gnu.org>, emacs-devel@gnu.org, 
>  thierry.volpiatto@gmail.com
> 
>  >     /* When running redisplay, we play a bit fast-and-loose and allow e.g.
>  >        selected_frame and selected_window to be temporarily out-of-sync so
>  >        when we come back here via `goto retry', we need to resync because we
>  >        may need to run Elisp code (via prepare_menu_bars).  */
>  >     select_frame_for_redisplay (old_frame);
>  >
>  > It would be good to get rid of such risky code.
> 
> Is there any reason why this should not select the window too?

By "this" you mean what?  IOW, who or what should "select the window
too"?

Re: bug in 23.2.92 with anything

[martin rudalics]

>>  >     /* When running redisplay, we play a bit fast-and-loose and allow e.g.
>>  >        selected_frame and selected_window to be temporarily out-of-sync so
>>  >        when we come back here via `goto retry', we need to resync because we
>>  >        may need to run Elisp code (via prepare_menu_bars).  */
>>  >     select_frame_for_redisplay (old_frame);
>>  >
>>  > It would be good to get rid of such risky code.
>>
>> Is there any reason why this should not select the window too?
> 
> By "this" you mean what?  IOW, who or what should "select the window
> too"?

This code.  That is, select_frame_for_redisplay.

martin

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

>> Here a cursor: !
>>
>> the prompt is like this:
>>
>> Pattern: !
>>
>> i enter the letter a in prompt:
>>
>> Pattern: !a
>>
>> the cursor jump before the a
>>
>> it should stay like this:
>>
>> Pattern: a!
>
> I can't reproduce this with the current trunk (which includes the
> change) and emacs -Q.  The cursor always stays after the letters I
> entered.  Can you reproduce it with emacs -Q?
No, sorry i should have check that.
I have parsed my .emacs.el, and that start to happen after loading elscreen.el.

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

>> Actually, using a global variable like this is butt-ugly.
>
> Indeed.
>
>> Could some one rename Fselect_window to something else, add a third
>> parameter to it and create a new Fselect_window that calls it (and let
>> Fset_window_configuration call the new function with the new param), so
>> as to get rid of this global var?
>
> Thierry could you try the attached patch against the trunk window.c?

Your patch don't apply correctly, could you make it with git and tell me
on which revision number it apply?

> Thanks, martin
> === modified file 'src/window.c'
> *** src/window.c	2011-01-15 23:16:57 +0000
> --- src/window.c	2011-01-16 10:18:51 +0000
> ***************
> *** 85,90 ****
> --- 85,91 ----
>                                int (* fn) (struct window *, void *),
>                                void *);
>   static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
> + static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
>   
>   /* This is the window in which the terminal's cursor should
>      be left when nothing is being done with it.  This must
> ***************
> *** 158,168 ****
>   
>   static int window_initialized;
>   
> - /* Set in `set-window-configuration' to prevent "swapping out point"
> -    in the old selected window.  */
> - 
> - static int inhibit_point_swap;
> - 
>   /* Hook to run when window config changes.  */
>   
>   static Lisp_Object Qwindow_configuration_change_hook;
> --- 159,164 ----
> ***************
> *** 3550,3569 ****
>     return Qnil;
>   }
>   
> - /* Note that selected_window can be nil when this is called from
> -    Fset_window_configuration.  */
>   
> ! DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
> !        doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
> ! If WINDOW is not already selected, make WINDOW's buffer current
> ! and make WINDOW the frame's selected window.  Return WINDOW.
> ! Optional second arg NORECORD non-nil means do not put this buffer
> ! at the front of the list of recently selected ones and do not
> ! make this window the most recently selected one.
>   
> ! Note that the main editor command loop selects the buffer of the
> ! selected window before each command.  */)
> !   (register Lisp_Object window, Lisp_Object norecord)
>   {
>     register struct window *w;
>     register struct window *ow;
> --- 3546,3560 ----
>     return Qnil;
>   }
>   
>   
> ! /* If select_window is called with inhibit_point_swap non-zero it will
> !    not store point of the old selected window's buffer back into that
> !    window's pointm slot.  This is needed by Fset_window_configuration to
> !    avoid that the display routine is called with selected_window set to
> !    Qnil causing a subsequent crash.  */
>   
> ! static Lisp_Object
> ! select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
>   {
>     register struct window *w;
>     register struct window *ow;
> ***************
> *** 3603,3611 ****
>     /* Store the current buffer's actual point into the
>        old selected window.  It belongs to that window,
>        and when the window is not selected, must be in the window.  */
> !   if (inhibit_point_swap)
> !     inhibit_point_swap = 0;
> !   else
>       {
>         ow = XWINDOW (selected_window);
>         if (! NILP (ow->buffer))
> --- 3594,3600 ----
>     /* Store the current buffer's actual point into the
>        old selected window.  It belongs to that window,
>        and when the window is not selected, must be in the window.  */
> !   if (! inhibit_point_swap)
>       {
>         ow = XWINDOW (selected_window);
>         if (! NILP (ow->buffer))
> ***************
> *** 3639,3644 ****
> --- 3628,3648 ----
>     return window;
>   }
>   
> + DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
> +        doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
> + If WINDOW is not already selected, make WINDOW's buffer current
> + and make WINDOW the frame's selected window.  Return WINDOW.
> + Optional second arg NORECORD non-nil means do not put this buffer
> + at the front of the list of recently selected ones and do not
> + make this window the most recently selected one.
> + 
> + Note that the main editor command loop selects the buffer of the
> + selected window before each command.  */)
> +   (register Lisp_Object window, Lisp_Object norecord)
> + {
> +   select_window (window, norecord, 0);
> + }
> + 
>   static Lisp_Object
>   select_window_norecord (Lisp_Object window)
>   {
> ***************
> *** 6167,6174 ****
>   	 out point" in the old selected window using the buffer that
>   	 has been restored into it.  We already swapped out that point
>   	 from that window's old buffer.  */
> !       inhibit_point_swap = 1;
> !       Fselect_window (data->current_window, Qnil);
>         XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
>   	= selected_window;
>   
> --- 6171,6177 ----
>   	 out point" in the old selected window using the buffer that
>   	 has been restored into it.  We already swapped out that point
>   	 from that window's old buffer.  */
> !       select_window (data->current_window, Qnil, 1);
>         XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
>   	= selected_window;
>   
> ***************
> *** 7099,7106 ****
>     window_scroll_preserve_hpos = -1;
>     window_scroll_preserve_vpos = -1;
>   
> -   inhibit_point_swap = 0;
> - 
>     DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function,
>   	       doc: /* Non-nil means call as function to display a help buffer.
>   The function is called with one argument, the buffer to be displayed.
> --- 7102,7107 ----
>

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[martin rudalics]

 >> I can't reproduce this with the current trunk (which includes the
 >> change) and emacs -Q.  The cursor always stays after the letters I
 >> entered.  Can you reproduce it with emacs -Q?
 > No, sorry i should have check that.
 > I have parsed my .emacs.el, and that start to happen after loading elscreen.el.

I downloaded Elscreen but it has a dependency on static.el which I can't
find.  Do these compile correctly with Emacs 24?

Also with current trunk could you try changing the following part of
Fselect_window

   if (EQ (window, selected_window))
     return window;

to

   if (EQ (window, selected_window))
     {
      inhibit_point_swap = 0;
      return window;
     }

and look whether the behavior changes back?

Thanks, martin

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

>>> I can't reproduce this with the current trunk (which includes the
>>> change) and emacs -Q.  The cursor always stays after the letters I
>>> entered.  Can you reproduce it with emacs -Q?
>> No, sorry i should have check that.
>> I have parsed my .emacs.el, and that start to happen after loading elscreen.el.
>
> I downloaded Elscreen but it has a dependency on static.el which I can't
> find.  Do these compile correctly with Emacs 24?
>
> Also with current trunk could you try changing the following part of
> Fselect_window
>
>   if (EQ (window, selected_window))
>     return window;
>
> to
>
>   if (EQ (window, selected_window))
>     {
>      inhibit_point_swap = 0;
>      return window;
>     }
>
> and look whether the behavior changes back?
Which behavior?
On Emacs24, all work fine.
But maybe you mean the head of 23.2.92 by trunk?

So where do you want i apply the changes?
on 23.2.92 or 24.0.50?
(just to be sure we don't misunderstand us)

> Thanks, martin

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[martin rudalics]

[-- Attachment #1: Type: text/plain, Size: 363 bytes --]

 > Your patch don't apply correctly, could you make it with git and tell me
 > on which revision number it apply?

For some reason it had CRLF line endings, maybe that's the cause.  I'll
attach it with a Unix line endings version I just applied to my trunk.
Generally, it should apply to latest Emacs 23 and 24 sources.  My bzr
revision number is 102868.

martin

[-- Attachment #2: window.c.diff --]
[-- Type: text/plain, Size: 4926 bytes --]

=== modified file 'src/window.c'
*** src/window.c	2011-01-15 23:16:57 +0000
--- src/window.c	2011-01-16 10:18:51 +0000
***************
*** 85,90 ****
--- 85,91 ----
                               int (* fn) (struct window *, void *),
                               void *);
  static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
+ static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
  
  /* This is the window in which the terminal's cursor should
     be left when nothing is being done with it.  This must
***************
*** 158,168 ****
  
  static int window_initialized;
  
- /* Set in `set-window-configuration' to prevent "swapping out point"
-    in the old selected window.  */
- 
- static int inhibit_point_swap;
- 
  /* Hook to run when window config changes.  */
  
  static Lisp_Object Qwindow_configuration_change_hook;
--- 159,164 ----
***************
*** 3550,3569 ****
    return Qnil;
  }
  
- /* Note that selected_window can be nil when this is called from
-    Fset_window_configuration.  */
  
! DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
!        doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
! If WINDOW is not already selected, make WINDOW's buffer current
! and make WINDOW the frame's selected window.  Return WINDOW.
! Optional second arg NORECORD non-nil means do not put this buffer
! at the front of the list of recently selected ones and do not
! make this window the most recently selected one.
  
! Note that the main editor command loop selects the buffer of the
! selected window before each command.  */)
!   (register Lisp_Object window, Lisp_Object norecord)
  {
    register struct window *w;
    register struct window *ow;
--- 3546,3560 ----
    return Qnil;
  }
  
  
! /* If select_window is called with inhibit_point_swap non-zero it will
!    not store point of the old selected window's buffer back into that
!    window's pointm slot.  This is needed by Fset_window_configuration to
!    avoid that the display routine is called with selected_window set to
!    Qnil causing a subsequent crash.  */
  
! static Lisp_Object
! select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
  {
    register struct window *w;
    register struct window *ow;
***************
*** 3603,3611 ****
    /* Store the current buffer's actual point into the
       old selected window.  It belongs to that window,
       and when the window is not selected, must be in the window.  */
!   if (inhibit_point_swap)
!     inhibit_point_swap = 0;
!   else
      {
        ow = XWINDOW (selected_window);
        if (! NILP (ow->buffer))
--- 3594,3600 ----
    /* Store the current buffer's actual point into the
       old selected window.  It belongs to that window,
       and when the window is not selected, must be in the window.  */
!   if (! inhibit_point_swap)
      {
        ow = XWINDOW (selected_window);
        if (! NILP (ow->buffer))
***************
*** 3639,3644 ****
--- 3628,3648 ----
    return window;
  }
  
+ DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
+        doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
+ If WINDOW is not already selected, make WINDOW's buffer current
+ and make WINDOW the frame's selected window.  Return WINDOW.
+ Optional second arg NORECORD non-nil means do not put this buffer
+ at the front of the list of recently selected ones and do not
+ make this window the most recently selected one.
+ 
+ Note that the main editor command loop selects the buffer of the
+ selected window before each command.  */)
+   (register Lisp_Object window, Lisp_Object norecord)
+ {
+   select_window (window, norecord, 0);
+ }
+ 
  static Lisp_Object
  select_window_norecord (Lisp_Object window)
  {
***************
*** 6167,6174 ****
  	 out point" in the old selected window using the buffer that
  	 has been restored into it.  We already swapped out that point
  	 from that window's old buffer.  */
!       inhibit_point_swap = 1;
!       Fselect_window (data->current_window, Qnil);
        XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
  	= selected_window;
  
--- 6171,6177 ----
  	 out point" in the old selected window using the buffer that
  	 has been restored into it.  We already swapped out that point
  	 from that window's old buffer.  */
!       select_window (data->current_window, Qnil, 1);
        XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
  	= selected_window;
  
***************
*** 7099,7106 ****
    window_scroll_preserve_hpos = -1;
    window_scroll_preserve_vpos = -1;
  
-   inhibit_point_swap = 0;
- 
    DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function,
  	       doc: /* Non-nil means call as function to display a help buffer.
  The function is called with one argument, the buffer to be displayed.
--- 7102,7107 ----

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

> I downloaded Elscreen but it has a dependency on static.el which I can't
> find.
You will find static.el in apel
http://dir.filewatcher.com/d/FreeBSD/3.5-release/i386/apel-emacs-10.2.tgz.101345.html

>Do these compile correctly with Emacs 24?
Yes.(with lot of warnings though)

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[martin rudalics]

 > Which behavior?
 > On Emacs24, all work fine.

Strange.  The change from Emacs 23 has been propagated to the trunk
in the meantime.

 > But maybe you mean the head of 23.2.92 by trunk?

Please try it there.

 > So where do you want i apply the changes?
 > on 23.2.92 or 24.0.50?
 > (just to be sure we don't misunderstand us)

I'm afraid you don't have the latest sources of the trunk.  So please
try everything on Emacs 23.2.92.

martin

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

> Also with current trunk could you try changing the following part of
> Fselect_window
>
>   if (EQ (window, selected_window))
>     return window;
>
> to
>
>   if (EQ (window, selected_window))
>     {
>      inhibit_point_swap = 0;
>      return window;
>     }
>
> and look whether the behavior changes back?
Here what i changed:

,----
|   if (NILP (norecord))
|     {
|       ++window_select_count;
|       XSETFASTINT (w->use_time, window_select_count);
|     }
| 
|   /* if (EQ (window, selected_window)) */
|   /*   return window; */
|   if (EQ (window, selected_window))
|     {
|      inhibit_point_swap = 0;
|      return window;
|     }
| 
`----

I have applied these changes on emacs-23 branch after this commit:

,----
| commit d0c73d59998f4686dbb2a0d7b05e16d7161fe75d
| Author: Stefan Monnier <monnier@iro.umontreal.ca>
| Date:   Sun Jan 16 10:40:47 2011 -0500
| 
|     * image.c (syms_of_image): Don't access XSYMBOL's internals directly.
`----

and it seem to work fine :-)
Thanks.

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[Eli Zaretskii]

> Date: Mon, 17 Jan 2011 00:23:12 +0100
> From: martin rudalics <rudalics@gmx.at>
> CC: monnier@iro.umontreal.ca, emacs-devel@gnu.org, 
>  thierry.volpiatto@gmail.com
> 
> >>  >     /* When running redisplay, we play a bit fast-and-loose and allow e.g.
> >>  >        selected_frame and selected_window to be temporarily out-of-sync so
> >>  >        when we come back here via `goto retry', we need to resync because we
> >>  >        may need to run Elisp code (via prepare_menu_bars).  */
> >>  >     select_frame_for_redisplay (old_frame);
> >>  >
> >>  > It would be good to get rid of such risky code.
> >>
> >> Is there any reason why this should not select the window too?
> > 
> > By "this" you mean what?  IOW, who or what should "select the window
> > too"?
> 
> This code.  That is, select_frame_for_redisplay.

What would be the utility of doing so?  The redisplay will next call
redisplay_windows, which walks the entire window tree and redisplays
each one of them (temporarily selecting its buffer in the process).
How would selecting the frame's selected window help anything in this
procedure?  I won't expect selected_window to play any significant
role in the redisplay process, because it redraws all windows.

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

>> Which behavior?
>> On Emacs24, all work fine.
>
> Strange.  The change from Emacs 23 has been propagated to the trunk
> in the meantime.
Sorry i was not up to date,
now i have updated the trunk to:
,----
| commit 43c8d47880f4103a5c8f8b2439cae0efa3338228
| Merge: 758a4ff c1c5267
| Author: Paul Eggert <eggert@cs.ucla.edu>
| Date:   Sun Jan 16 23:46:36 2011 -0800
| 
|     * xfns.c (x_real_positions): Fix signedness of local var 'ign'.
`----
and confirm the bug still here.

>> But maybe you mean the head of 23.2.92 by trunk?
>
> Please try it there.
>
>> So where do you want i apply the changes?
>> on 23.2.92 or 24.0.50?
>> (just to be sure we don't misunderstand us)
>
> I'm afraid you don't have the latest sources of the trunk.  
Yes i was not up to date.

>So please
> try everything on Emacs 23.2.92.
>
> martin

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[martin rudalics]

 > Here what i changed:
 >
 > ,----
 > |   if (NILP (norecord))
 > |     {
 > |       ++window_select_count;
 > |       XSETFASTINT (w->use_time, window_select_count);
 > |     }
 > |
 > |   /* if (EQ (window, selected_window)) */
 > |   /*   return window; */
 > |   if (EQ (window, selected_window))
 > |     {
 > |      inhibit_point_swap = 0;
 > |      return window;
 > |     }
 > |
 > `----
 >
 > I have applied these changes on emacs-23 branch after this commit:
 >
 > ,----
 > | commit d0c73d59998f4686dbb2a0d7b05e16d7161fe75d
 > | Author: Stefan Monnier <monnier@iro.umontreal.ca>
 > | Date:   Sun Jan 16 10:40:47 2011 -0500
 > |
 > |     * image.c (syms_of_image): Don't access XSYMBOL's internals directly.
 > `----
 >
 > and it seem to work fine :-)
 > Thanks.

So this should hopefully fix my initial proposal.  Could you also try
the other patch I sent you?  You would have to revert to the state of
the repository for that purpose.

martin

Re: bug in 23.2.92 with anything

[martin rudalics]

 >>>>  >     /* When running redisplay, we play a bit fast-and-loose and allow e.g.
 >>>>  >        selected_frame and selected_window to be temporarily out-of-sync so
 >>>>  >        when we come back here via `goto retry', we need to resync because we
 >>>>  >        may need to run Elisp code (via prepare_menu_bars).  */
 >>>>  >     select_frame_for_redisplay (old_frame);
 >>>>  >
 >>>>  > It would be good to get rid of such risky code.
 >>>>
 >>>> Is there any reason why this should not select the window too?
 >>> By "this" you mean what?  IOW, who or what should "select the window
 >>> too"?
 >> This code.  That is, select_frame_for_redisplay.
 >
 > What would be the utility of doing so?  The redisplay will next call
 > redisplay_windows, which walks the entire window tree and redisplays
 > each one of them (temporarily selecting its buffer in the process).
 > How would selecting the frame's selected window help anything in this
 > procedure?  I won't expect selected_window to play any significant
 > role in the redisplay process, because it redraws all windows.

I don't know enough about redisplay.  IIUC select_frame_for_redisplay is
used mainly to set up frame local variables for displaying all buffers
shown in that frame.  In display_mode_lines selected window and selected
frame are both temporarily deselected but in update_tool_bar only the
selected frame is deselected (just as in select_frame_for_redisplay).

If code is run in between, the fact that the selected window is not on
the selected frame might be surprising.  But I don't know what any code
run by update_tool_bar or redisplay_internal really needs in this
context.  So if you say it doesn't matter I take your word for it.

martin

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

>> Here what i changed:
>>
>> ,----
>> |   if (NILP (norecord))
>> |     {
>> |       ++window_select_count;
>> |       XSETFASTINT (w->use_time, window_select_count);
>> |     }
>> |
>> |   /* if (EQ (window, selected_window)) */
>> |   /*   return window; */
>> |   if (EQ (window, selected_window))
>> |     {
>> |      inhibit_point_swap = 0;
>> |      return window;
>> |     }
>> |
>> `----
>>
>> I have applied these changes on emacs-23 branch after this commit:
>>
>> ,----
>> | commit d0c73d59998f4686dbb2a0d7b05e16d7161fe75d
>> | Author: Stefan Monnier <monnier@iro.umontreal.ca>
>> | Date:   Sun Jan 16 10:40:47 2011 -0500
>> |
>> |     * image.c (syms_of_image): Don't access XSYMBOL's internals directly.
>> `----
>>
>> and it seem to work fine :-)
>> Thanks.
>
> So this should hopefully fix my initial proposal.  Could you also try
> the other patch I sent you?  You would have to revert to the state of
> the repository for that purpose.
It still doesn't apply correctly, could you make a patch in git style on
top of:(i use a git repo)

,----[ emacs-23 branch ]
| commit d0c73d59998f4686dbb2a0d7b05e16d7161fe75d
| Author: Stefan Monnier <monnier@iro.umontreal.ca>
| Date:   Sun Jan 16 10:40:47 2011 -0500
| 
|     * image.c (syms_of_image): Don't access XSYMBOL's internals directly.
`----

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[martin rudalics]

 > It still doesn't apply correctly, could you make a patch in git style on
 > top of:(i use a git repo)

If I knew how to do that :-(

I'll send you a gzipped copy of window.c separately.  So you can make a
git style patch, pass it back to me, and I might be able to figure out
what makes the difference.

martin

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

[-- Attachment #1: Type: text/plain, Size: 2153 bytes --]

martin rudalics <rudalics@gmx.at> writes:

>> It still doesn't apply correctly, could you make a patch in git style on
>> top of:(i use a git repo)
>
> If I knew how to do that :-(
See git-diff section generating patch with -p option and
git-format-patch.
I think bzr do that also but i don't know how.

Easier use a git repo and work with stgit (stg).
http://www.procode.org/stgit/doc/tutorial.html


> I'll send you a gzipped copy of window.c separately.  So you can make a
> git style patch, pass it back to me, and I might be able to figure out
> what makes the difference.
Thanks.
I have applied your changes, but now it fail to compile:

,----
| window.c:81: error: static declaration of ‘foreach_window’ follows non-static declaration
| window.h:799: note: previous declaration of ‘foreach_window’ was here
| window.c: In function ‘Fcoordinates_in_window_p’:
| window.c:1011: error: ‘Qleft_margin’ undeclared (first use in this function)
| window.c:1011: error: (Each undeclared identifier is reported only once
| window.c:1011: error: for each function it appears in.)
| window.c:1014: error: ‘Qright_margin’ undeclared (first use in this function)
| window.c: At top level:
| window.c:1080: error: conflicting types for ‘window_from_coordinates’
| window.h:787: note: previous declaration of ‘window_from_coordinates’ was here
| window.c:1436: error: static declaration of ‘delete_window’ follows non-static declaration
| window.h:786: note: previous declaration of ‘delete_window’ was here
| window.c:3982: error: static declaration of ‘window_height’ follows non-static declaration
| window.h:791: note: previous declaration of ‘window_height’ was here
| window.c:3989: error: static declaration of ‘window_width’ follows non-static declaration
| window.h:792: note: previous declaration of ‘window_width’ was here
| make[1]: *** [window.o] Erreur 1
| make[1]: quittant le répertoire « /home/thierry/download/emacs-23/src »
| make: *** [src] Erreur 2
`----

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: patch-martin-window.c.patch --]
[-- Type: text/x-diff, Size: 85371 bytes --]

patch-martin-window.c

From: Thierry Volpiatto <thierry.volpiatto@gmail.com>


---
 src/window.c | 1002 ++++++++++++++++++++++++++--------------------------------
 1 files changed, 444 insertions(+), 558 deletions(-)

diff --git a/src/window.c b/src/window.c
index 8b4324f..5e589af 100644
--- a/src/window.c
+++ b/src/window.c
@@ -51,40 +51,41 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "nsterm.h"
 #endif
 
-
 Lisp_Object Qwindowp, Qwindow_live_p, Qwindow_configuration_p;
 Lisp_Object Qdisplay_buffer;
-Lisp_Object Qscroll_up, Qscroll_down;
+Lisp_Object Qscroll_up, Qscroll_down, Qscroll_command;
 Lisp_Object Qwindow_size_fixed;
 
-extern Lisp_Object Qleft_margin, Qright_margin;
-
-static int displayed_window_lines P_ ((struct window *));
-static struct window *decode_window P_ ((Lisp_Object));
-static int count_windows P_ ((struct window *));
-static int get_leaf_windows P_ ((struct window *, struct window **, int));
-static void window_scroll P_ ((Lisp_Object, int, int, int));
-static void window_scroll_pixel_based P_ ((Lisp_Object, int, int, int));
-static void window_scroll_line_based P_ ((Lisp_Object, int, int, int));
-static int window_min_size_1 P_ ((struct window *, int, int));
-static int window_min_size_2 P_ ((struct window *, int, int));
-static int window_min_size P_ ((struct window *, int, int, int, int *));
-static void size_window P_ ((Lisp_Object, int, int, int, int, int));
-static int freeze_window_start P_ ((struct window *, void *));
-static int window_fixed_size_p P_ ((struct window *, int, int));
-static void enlarge_window P_ ((Lisp_Object, int, int));
-static Lisp_Object window_list P_ ((void));
-static int add_window_to_list P_ ((struct window *, void *));
-static int candidate_window_p P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
-				   Lisp_Object));
-static Lisp_Object next_window P_ ((Lisp_Object, Lisp_Object,
-				    Lisp_Object, int));
-static void decode_next_window_args P_ ((Lisp_Object *, Lisp_Object *,
-					 Lisp_Object *));
-static int foreach_window_1 P_ ((struct window *,
-				 int (* fn) (struct window *, void *),
-				 void *));
-static Lisp_Object window_list_1 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+static int displayed_window_lines (struct window *);
+static struct window *decode_window (Lisp_Object);
+static int count_windows (struct window *);
+static int get_leaf_windows (struct window *, struct window **, int);
+static void window_scroll (Lisp_Object, int, int, int);
+static void window_scroll_pixel_based (Lisp_Object, int, int, int);
+static void window_scroll_line_based (Lisp_Object, int, int, int);
+static int window_min_size_1 (struct window *, int, int);
+static int window_min_size_2 (struct window *, int, int);
+static int window_min_size (struct window *, int, int, int, int *);
+static void size_window (Lisp_Object, int, int, int, int, int);
+static int freeze_window_start (struct window *, void *);
+static int window_fixed_size_p (struct window *, int, int);
+static void enlarge_window (Lisp_Object, int, int);
+static Lisp_Object window_list (void);
+static int add_window_to_list (struct window *, void *);
+static int candidate_window_p (Lisp_Object, Lisp_Object, Lisp_Object,
+                               Lisp_Object);
+static Lisp_Object next_window (Lisp_Object, Lisp_Object,
+                                Lisp_Object, int);
+static void decode_next_window_args (Lisp_Object *, Lisp_Object *,
+                                     Lisp_Object *);
+static void foreach_window (struct frame *,
+                            int (* fn) (struct window *, void *),
+                            void *);
+static int foreach_window_1 (struct window *,
+                             int (* fn) (struct window *, void *),
+                             void *);
+static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
+static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
 
 /* This is the window in which the terminal's cursor should
    be left when nothing is being done with it.  This must
@@ -158,11 +159,6 @@ static int sequence_number;
 
 static int window_initialized;
 
-/* Set in `set-window-configuration' to prevent "swapping out point"
-   in the old selected window.  */
-
-static int inhibit_point_swap;
-
 /* Hook to run when window config changes.  */
 
 static Lisp_Object Qwindow_configuration_change_hook;
@@ -191,6 +187,11 @@ static int window_scroll_pixel_based_preserve_y;
 static int window_scroll_preserve_hpos;
 static int window_scroll_preserve_vpos;
 
+#if 0 /* This isn't used anywhere.  */
+/* Nonzero means we can split a frame even if it is "unsplittable".  */
+static int inhibit_frame_unsplittable;
+#endif /* 0 */
+
 extern EMACS_INT scroll_margin;
 
 extern Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
@@ -200,27 +201,24 @@ extern Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
    frame to be redrawn only if it is a tty frame.  */
 
 static Lisp_Object Vrecenter_redisplay;
-extern Lisp_Object Qtty;
 
 \f
 DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
        doc: /* Return t if OBJECT is a window.  */)
-     (object)
-     Lisp_Object object;
+  (Lisp_Object object)
 {
   return WINDOWP (object) ? Qt : Qnil;
 }
 
 DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a window which is currently visible.  */)
-     (object)
-     Lisp_Object object;
+  (Lisp_Object object)
 {
   return WINDOW_LIVE_P (object) ? Qt : Qnil;
 }
 
 Lisp_Object
-make_window ()
+make_window (void)
 {
   Lisp_Object val;
   register struct window *p;
@@ -243,9 +241,9 @@ make_window ()
   p->dedicated = Qnil;
   p->window_parameters = Qnil;
   p->pseudo_window_p = 0;
-  bzero (&p->cursor, sizeof (p->cursor));
-  bzero (&p->last_cursor, sizeof (p->last_cursor));
-  bzero (&p->phys_cursor, sizeof (p->phys_cursor));
+  memset (&p->cursor, 0, sizeof (p->cursor));
+  memset (&p->last_cursor, 0, sizeof (p->last_cursor));
+  memset (&p->phys_cursor, 0, sizeof (p->phys_cursor));
   p->desired_matrix = p->current_matrix = 0;
   p->nrows_scale_factor = p->ncols_scale_factor = 1;
   p->phys_cursor_type = -1;
@@ -274,7 +272,7 @@ make_window ()
 
 DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
        doc: /* Return the window that the cursor now appears in and commands apply to.  */)
-     ()
+  (void)
 {
   return selected_window;
 }
@@ -283,8 +281,7 @@ DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0,
        doc: /* Return the window used now for minibuffers.
 If the optional argument FRAME is specified, return the minibuffer window
 used by that frame.  */)
-     (frame)
-    Lisp_Object frame;
+  (Lisp_Object frame)
 {
   if (NILP (frame))
     frame = selected_frame;
@@ -295,8 +292,7 @@ used by that frame.  */)
 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, Swindow_minibuffer_p, 0, 1, 0,
        doc: /* Return non-nil if WINDOW is a minibuffer window.
 WINDOW defaults to the selected window.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   struct window *w = decode_window (window);
   return MINI_WINDOW_P (w) ? Qt : Qnil;
@@ -320,11 +316,10 @@ of the window.  The remaining elements are omitted if the character after
 POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
 off-window at the top and bottom of the row, ROWH is the height of the
 display row, and VPOS is the row number (0-based) containing POS.  */)
-     (pos, window, partially)
-     Lisp_Object pos, window, partially;
+  (Lisp_Object pos, Lisp_Object window, Lisp_Object partially)
 {
   register struct window *w;
-  register int posint;
+  register EMACS_INT posint;
   register struct buffer *buf;
   struct text_pos top;
   Lisp_Object in_window = Qnil;
@@ -389,8 +384,7 @@ of the (first) text line, YPOS is negative.
 
 Return nil if window display is not up-to-date.  In that case, use
 `pos-visible-in-window-p' to obtain the information.  */)
-     (line, window)
-     Lisp_Object line, window;
+  (Lisp_Object line, Lisp_Object window)
 {
   register struct window *w;
   register struct buffer *b;
@@ -483,8 +477,7 @@ Return nil if window display is not up-to-date.  In that case, use
 
 \f
 static struct window *
-decode_window (window)
-     register Lisp_Object window;
+decode_window (register Lisp_Object window)
 {
   if (NILP (window))
     return XWINDOW (selected_window);
@@ -494,8 +487,7 @@ decode_window (window)
 }
 
 static struct window *
-decode_any_window (window)
-     register Lisp_Object window;
+decode_any_window (register Lisp_Object window)
 {
   if (NILP (window))
     return XWINDOW (selected_window);
@@ -507,8 +499,7 @@ decode_any_window (window)
 DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
        doc: /* Return the buffer that WINDOW is displaying.
 WINDOW defaults to the selected window.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   return decode_window (window)->buffer;
 }
@@ -521,8 +512,7 @@ The return value includes WINDOW's mode line and header line, if any.
 
 Note: The function does not take into account the value of `line-spacing'
 when calculating the number of lines in WINDOW.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   return decode_any_window (window)->total_lines;
 }
@@ -534,8 +524,7 @@ WINDOW defaults to the selected window.
 Note: The return value is the number of columns available for text in
 WINDOW.  If you want to find out how many columns WINDOW takes up, use
 (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   return make_number (window_box_text_cols (decode_any_window (window)));
 }
@@ -543,8 +532,7 @@ WINDOW.  If you want to find out how many columns WINDOW takes up, use
 DEFUN ("window-full-width-p", Fwindow_full_width_p, Swindow_full_width_p, 0, 1, 0,
        doc: /* Return t if WINDOW is as wide as its frame.
 WINDOW defaults to the selected window.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   return WINDOW_FULL_WIDTH_P (decode_any_window (window)) ? Qt : Qnil;
 }
@@ -552,8 +540,7 @@ WINDOW defaults to the selected window.  */)
 DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
        doc: /* Return the number of columns by which WINDOW is scrolled from left margin.
 WINDOW defaults to the selected window.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   return decode_window (window)->hscroll;
 }
@@ -564,8 +551,7 @@ Return NCOL.  NCOL should be zero or positive.
 
 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
 window so that the location of point moves off-window.  */)
-     (window, ncol)
-     Lisp_Object window, ncol;
+  (Lisp_Object window, Lisp_Object ncol)
 {
   struct window *w = decode_window (window);
   int hscroll;
@@ -586,8 +572,7 @@ DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
        doc: /* Return WINDOW's redisplay end trigger value.
 WINDOW defaults to the selected window.
 See `set-window-redisplay-end-trigger' for more information.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   return decode_window (window)->redisplay_end_trigger;
 }
@@ -600,8 +585,7 @@ If it is a buffer position, then if redisplay in WINDOW reaches a position
 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
 with two arguments: WINDOW, and the end trigger value.
 Afterwards the end-trigger value is reset to nil.  */)
-     (window, value)
-     register Lisp_Object window, value;
+  (register Lisp_Object window, Lisp_Object value)
 {
   register struct window *w;
 
@@ -621,8 +605,7 @@ BOTTOM is one more than the bottommost row occupied by WINDOW.
 The edges include the space used by WINDOW's scroll bar, display
 margins, fringes, header line, and/or mode line.  For the edges of
 just the text area, use `window-inside-edges'.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   register struct window *w = decode_any_window (window);
 
@@ -643,8 +626,7 @@ BOTTOM is one more than the bottommost y position occupied by WINDOW.
 The pixel edges include the space used by WINDOW's scroll bar, display
 margins, fringes, header line, and/or mode line.  For the pixel edges
 of just the text area, use `window-inside-pixel-edges'.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   register struct window *w = decode_any_window (window);
 
@@ -655,6 +637,52 @@ of just the text area, use `window-inside-pixel-edges'.  */)
 		Qnil))));
 }
 
+static void
+calc_absolute_offset(struct window *w, int *add_x, int *add_y)
+{
+  struct frame *f = XFRAME (w->frame);
+  *add_y = f->top_pos;
+#ifdef FRAME_MENUBAR_HEIGHT
+  *add_y += FRAME_MENUBAR_HEIGHT (f);
+#endif
+#ifdef FRAME_TOOLBAR_TOP_HEIGHT
+  *add_y += FRAME_TOOLBAR_TOP_HEIGHT (f);
+#elif FRAME_TOOLBAR_HEIGHT
+  *add_y += FRAME_TOOLBAR_HEIGHT (f);
+#endif
+#ifdef FRAME_NS_TITLEBAR_HEIGHT
+  *add_y += FRAME_NS_TITLEBAR_HEIGHT (f);
+#endif
+  *add_x = f->left_pos;
+#ifdef FRAME_TOOLBAR_LEFT_WIDTH
+  *add_x += FRAME_TOOLBAR_LEFT_WIDTH (f);
+#endif
+}
+
+DEFUN ("window-absolute-pixel-edges", Fwindow_absolute_pixel_edges,
+       Swindow_absolute_pixel_edges, 0, 1, 0,
+       doc: /* Return a list of the edge pixel coordinates of WINDOW.
+The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
+the top left corner of the display.
+
+RIGHT is one more than the rightmost x position occupied by WINDOW.
+BOTTOM is one more than the bottommost y position occupied by WINDOW.
+The pixel edges include the space used by WINDOW's scroll bar, display
+margins, fringes, header line, and/or mode line.  For the pixel edges
+of just the text area, use `window-inside-absolute-pixel-edges'.  */)
+  (Lisp_Object window)
+{
+  register struct window *w = decode_any_window (window);
+  int add_x, add_y;
+  calc_absolute_offset (w, &add_x, &add_y);
+
+  return Fcons (make_number (WINDOW_LEFT_EDGE_X (w) + add_x),
+         Fcons (make_number (WINDOW_TOP_EDGE_Y (w) + add_y),
+	 Fcons (make_number (WINDOW_RIGHT_EDGE_X (w) + add_x),
+	 Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w) + add_y),
+		Qnil))));
+}
+
 DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
        doc: /* Return a list of the edge coordinates of WINDOW.
 The list has the form (LEFT TOP RIGHT BOTTOM).
@@ -665,8 +693,7 @@ RIGHT is one more than the rightmost column of WINDOW's text area.
 BOTTOM is one more than the bottommost row of WINDOW's text area.
 The inside edges do not include the space used by the WINDOW's scroll
 bar, display margins, fringes, header line, and/or mode line.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   register struct window *w = decode_any_window (window);
 
@@ -691,8 +718,7 @@ RIGHT is one more than the rightmost x position of WINDOW's text area.
 BOTTOM is one more than the bottommost y position of WINDOW's text area.
 The inside edges do not include the space used by WINDOW's scroll bar,
 display margins, fringes, header line, and/or mode line.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   register struct window *w = decode_any_window (window);
 
@@ -708,34 +734,55 @@ display margins, fringes, header line, and/or mode line.  */)
 			     - WINDOW_MODE_LINE_HEIGHT (w)));
 }
 
-/* Test if the character at column *X, row *Y is within window W.
+DEFUN ("window-inside-absolute-pixel-edges",
+       Fwindow_inside_absolute_pixel_edges,
+       Swindow_inside_absolute_pixel_edges, 0, 1, 0,
+       doc: /* Return a list of the edge pixel coordinates of WINDOW.
+The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
+the top left corner of the display.
+
+RIGHT is one more than the rightmost x position of WINDOW's text area.
+BOTTOM is one more than the bottommost y position of WINDOW's text area.
+The inside edges do not include the space used by WINDOW's scroll bar,
+display margins, fringes, header line, and/or mode line.  */)
+  (Lisp_Object window)
+{
+  register struct window *w = decode_any_window (window);
+  int add_x, add_y;
+  calc_absolute_offset (w, &add_x, &add_y);
+
+  return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w)
+			     + WINDOW_LEFT_MARGIN_WIDTH (w)
+			     + WINDOW_LEFT_FRINGE_WIDTH (w) + add_x),
+		make_number (WINDOW_TOP_EDGE_Y (w)
+			     + WINDOW_HEADER_LINE_HEIGHT (w) + add_y),
+		make_number (WINDOW_BOX_RIGHT_EDGE_X (w)
+			     - WINDOW_RIGHT_MARGIN_WIDTH (w)
+			     - WINDOW_RIGHT_FRINGE_WIDTH (w) + add_x),
+		make_number (WINDOW_BOTTOM_EDGE_Y (w)
+			     - WINDOW_MODE_LINE_HEIGHT (w) + add_y));
+}
+
+/* Test if the character at column X, row Y is within window W.
    If it is not, return ON_NOTHING;
-   if it is in the window's text area,
-      set *x and *y to its location relative to the upper left corner
-         of the window, and
-      return ON_TEXT;
+   if it is in the window's text area, return ON_TEXT;
    if it is on the window's modeline, return ON_MODE_LINE;
    if it is on the border between the window and its right sibling,
       return ON_VERTICAL_BORDER.
-   if it is on a scroll bar,
-      return ON_SCROLL_BAR.
+   if it is on a scroll bar, return ON_SCROLL_BAR.
    if it is on the window's top line, return ON_HEADER_LINE;
    if it is in left or right fringe of the window,
-      return ON_LEFT_FRINGE or ON_RIGHT_FRINGE, and convert *X and *Y
-      to window-relative coordinates;
+      return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
    if it is in the marginal area to the left/right of the window,
-      return ON_LEFT_MARGIN or ON_RIGHT_MARGIN, and convert *X and *Y
-      to window-relative coordinates.
+      return ON_LEFT_MARGIN or ON_RIGHT_MARGIN.
 
    X and Y are frame relative pixel coordinates.  */
 
 static enum window_part
-coordinates_in_window (w, x, y)
-     register struct window *w;
-     register int *x, *y;
+coordinates_in_window (register struct window *w, int x, int y)
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
-  int left_x, right_x, top_y, bottom_y;
+  int left_x, right_x;
   enum window_part part;
   int ux = FRAME_COLUMN_WIDTH (f);
   int x0 = WINDOW_LEFT_EDGE_X (w);
@@ -744,6 +791,12 @@ coordinates_in_window (w, x, y)
      (Between mode lines for instance.  */
   int grabbable_width = ux;
   int lmargin_width, rmargin_width, text_left, text_right;
+  int top_y = WINDOW_TOP_EDGE_Y (w);
+  int bottom_y = WINDOW_BOTTOM_EDGE_Y (w);
+
+  /* Outside any interesting row?  */
+  if (y < top_y || y >= bottom_y)
+    return ON_NOTHING;
 
   /* In what's below, we subtract 1 when computing right_x because we
      want the rightmost pixel, which is given by left_pixel+width-1.  */
@@ -751,21 +804,13 @@ coordinates_in_window (w, x, y)
     {
       left_x = 0;
       right_x = WINDOW_TOTAL_WIDTH (w) - 1;
-      top_y = WINDOW_TOP_EDGE_Y (w);
-      bottom_y = WINDOW_BOTTOM_EDGE_Y (w);
     }
   else
     {
       left_x = WINDOW_BOX_LEFT_EDGE_X (w);
       right_x = WINDOW_BOX_RIGHT_EDGE_X (w) - 1;
-      top_y = WINDOW_TOP_EDGE_Y (w);
-      bottom_y = WINDOW_BOTTOM_EDGE_Y (w);
     }
 
-  /* Outside any interesting row?  */
-  if (*y < top_y || *y >= bottom_y)
-    return ON_NOTHING;
-
   /* On the mode line or header line?  If it's near the start of
      the mode or header line of window that's has a horizontal
      sibling, say it's on the vertical line.  That's to be able
@@ -773,7 +818,7 @@ coordinates_in_window (w, x, y)
      scroll bars.  */
 
   if (WINDOW_WANTS_MODELINE_P (w)
-      && *y >= bottom_y - CURRENT_MODE_LINE_HEIGHT (w))
+      && y >= bottom_y - CURRENT_MODE_LINE_HEIGHT (w))
     {
       part = ON_MODE_LINE;
 
@@ -782,60 +827,37 @@ coordinates_in_window (w, x, y)
 	 between mode lines of horizontally adjacent mode lines
 	 as the vertical border.  If scroll bars on the left,
 	 return the right window.  */
-      if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
-	  || WINDOW_RIGHTMOST_P (w))
-	{
-	  if (!WINDOW_LEFTMOST_P (w) && eabs (*x - x0) < grabbable_width)
-	    {
-	      /* Convert X and Y to window relative coordinates.
-		 Vertical border is at the left edge of window.  */
-	      *x = max (0, *x - x0);
-	      *y -= top_y;
-	      return ON_VERTICAL_BORDER;
-	    }
-	}
-      else
-	{
-	  /* Make sure we're not at the rightmost position of a
-	     mode-/header-line and there's yet another window on
-	     the right.  (Bug#1372)  */
-	  if ((WINDOW_RIGHTMOST_P (w) || *x < x1)
-	      && eabs (*x - x1) < grabbable_width)
-	    {
-	      /* Convert X and Y to window relative coordinates.
-		 Vertical border is at the right edge of window.  */
-	      *x = min (x1, *x) - x0;
-	      *y -= top_y;
-	      return ON_VERTICAL_BORDER;
-	    }
-	}
-
-      if (*x < x0 || *x >= x1)
+      if ((WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
+	   || WINDOW_RIGHTMOST_P (w))
+	  && !WINDOW_LEFTMOST_P (w)
+	  && eabs (x - x0) < grabbable_width)
+	return ON_VERTICAL_BORDER;
+
+      /* Make sure we're not at the rightmost position of a
+	 mode-/header-line and there's yet another window on the
+	 right.  (Bug#1372)  */
+      else if ((WINDOW_RIGHTMOST_P (w) || x < x1)
+	       && eabs (x - x1) < grabbable_width)
+	return ON_VERTICAL_BORDER;
+
+      if (x < x0 || x >= x1)
 	return ON_NOTHING;
 
-      /* Convert X and Y to window relative coordinates.
-	 Mode line starts at left edge of window.  */
-      *x -= x0;
-      *y -= top_y;
       return part;
     }
 
   if (WINDOW_WANTS_HEADER_LINE_P (w)
-      && *y < top_y + CURRENT_HEADER_LINE_HEIGHT (w))
+      && y < top_y + CURRENT_HEADER_LINE_HEIGHT (w))
     {
       part = ON_HEADER_LINE;
       goto header_vertical_border_check;
     }
 
-  if (*x < x0 || *x >= x1)
-    return ON_NOTHING;
+  if (x < x0 || x >= x1) return ON_NOTHING;
 
   /* Outside any interesting column?  */
-  if (*x < left_x || *x > right_x)
-    {
-      *y -= top_y;
-      return ON_SCROLL_BAR;
-    }
+  if (x < left_x || x > right_x)
+    return ON_SCROLL_BAR;
 
   lmargin_width = window_box_width (w, LEFT_MARGIN_AREA);
   rmargin_width = window_box_width (w, RIGHT_MARGIN_AREA);
@@ -848,77 +870,79 @@ coordinates_in_window (w, x, y)
       if (!w->pseudo_window_p
 	  && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
 	  && !WINDOW_RIGHTMOST_P (w)
-	  && (eabs (*x - right_x) < grabbable_width))
-	{
-	  /* Convert X and Y to window relative coordinates.
-	     Vertical border is at the right edge of window.  */
-	  *x = min (right_x, *x) - left_x;
-	  *y -= top_y;
-	  return ON_VERTICAL_BORDER;
-	}
-    }
-  else
-    {
-      /* Need to say "*x > right_x" rather than >=, since on character
-	 terminals, the vertical line's x coordinate is right_x.  */
-      if (!w->pseudo_window_p
-	  && !WINDOW_RIGHTMOST_P (w)
-	  && *x > right_x - ux)
-	{
-	  /* On the border on the right side of the window?  Assume that
-	     this area begins at RIGHT_X minus a canonical char width.  */
-	  *x = min (right_x, *x) - left_x;
-	  *y -= top_y;
-	  return ON_VERTICAL_BORDER;
-	}
+	  && (eabs (x - right_x) < grabbable_width))
+	return ON_VERTICAL_BORDER;
     }
+  /* Need to say "x > right_x" rather than >=, since on character
+     terminals, the vertical line's x coordinate is right_x.  */
+  else if (!w->pseudo_window_p
+	   && !WINDOW_RIGHTMOST_P (w)
+	   && x > right_x - ux)
+    return ON_VERTICAL_BORDER;
 
-  if (*x < text_left)
+  if (x < text_left)
     {
       if (lmargin_width > 0
 	  && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-	      ? (*x >= left_x + WINDOW_LEFT_FRINGE_WIDTH (w))
-	      : (*x < left_x + lmargin_width)))
-	{
-	  *x -= left_x;
-	  if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
-	    *x -= WINDOW_LEFT_FRINGE_WIDTH (w);
-	  *y -= top_y;
-	  return ON_LEFT_MARGIN;
-	}
+	      ? (x >= left_x + WINDOW_LEFT_FRINGE_WIDTH (w))
+	      : (x < left_x + lmargin_width)))
+	return ON_LEFT_MARGIN;
 
-      /* Convert X and Y to window-relative pixel coordinates.  */
-      *x -= left_x;
-      *y -= top_y;
       return ON_LEFT_FRINGE;
     }
 
-  if (*x >= text_right)
+  if (x >= text_right)
     {
       if (rmargin_width > 0
 	  && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-	      ? (*x < right_x - WINDOW_RIGHT_FRINGE_WIDTH (w))
-	      : (*x >= right_x - rmargin_width)))
-	{
-	  *x -= right_x - rmargin_width;
-	  if (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
-	    *x += WINDOW_RIGHT_FRINGE_WIDTH (w);
-	  *y -= top_y;
-	  return ON_RIGHT_MARGIN;
-	}
+	      ? (x < right_x - WINDOW_RIGHT_FRINGE_WIDTH (w))
+	      : (x >= right_x - rmargin_width)))
+	return ON_RIGHT_MARGIN;
 
-      /* Convert X and Y to window-relative pixel coordinates.  */
-      *x -= left_x + WINDOW_LEFT_FRINGE_WIDTH (w);
-      *y -= top_y;
       return ON_RIGHT_FRINGE;
     }
 
   /* Everything special ruled out - must be on text area */
-  *x -= text_left;
-  *y -= top_y;
   return ON_TEXT;
 }
 
+/* Take X is the frame-relative pixel x-coordinate, and return the
+   x-coordinate relative to part PART of window W. */
+int
+window_relative_x_coord (struct window *w, enum window_part part, int x)
+{
+  int left_x = (w->pseudo_window_p) ? 0 : WINDOW_BOX_LEFT_EDGE_X (w);
+
+  switch (part)
+    {
+    case ON_TEXT:
+      return x - window_box_left (w, TEXT_AREA);
+
+    case ON_LEFT_FRINGE:
+      return x - left_x;
+
+    case ON_RIGHT_FRINGE:
+      return x - left_x - WINDOW_LEFT_FRINGE_WIDTH (w);
+
+    case ON_LEFT_MARGIN:
+      return (x - left_x
+	      - ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
+		 ? WINDOW_LEFT_FRINGE_WIDTH (w) : 0));
+
+    case ON_RIGHT_MARGIN:
+      return (x + 1
+	      - ((w->pseudo_window_p)
+		 ? WINDOW_TOTAL_WIDTH (w)
+		 : WINDOW_BOX_RIGHT_EDGE_X (w))
+	      + window_box_width (w, RIGHT_MARGIN_AREA)
+	      + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
+		 ? WINDOW_RIGHT_FRINGE_WIDTH (w) : 0));
+    }
+
+  /* ON_SCROLL_BAR, ON_NOTHING, and ON_VERTICAL_BORDER:  */
+  return 0;
+}
+
 
 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
        Scoordinates_in_window_p, 2, 2, 0,
@@ -937,8 +961,7 @@ If they are on the border between WINDOW and its right sibling,
   `vertical-line' is returned.
 If they are in the windows's left or right marginal areas, `left-margin'\n\
   or `right-margin' is returned.  */)
-     (coordinates, window)
-     register Lisp_Object coordinates, window;
+  (register Lisp_Object coordinates, Lisp_Object window)
 {
   struct window *w;
   struct frame *f;
@@ -956,14 +979,16 @@ If they are in the windows's left or right marginal areas, `left-margin'\n\
   x = FRAME_PIXEL_X_FROM_CANON_X (f, lx) + FRAME_INTERNAL_BORDER_WIDTH (f);
   y = FRAME_PIXEL_Y_FROM_CANON_Y (f, ly) + FRAME_INTERNAL_BORDER_WIDTH (f);
 
-  switch (coordinates_in_window (w, &x, &y))
+  switch (coordinates_in_window (w, x, y))
     {
     case ON_NOTHING:
       return Qnil;
 
     case ON_TEXT:
-      /* X and Y are now window relative pixel coordinates.  Convert
-	 them to canonical char units before returning them.  */
+      /* Convert X and Y to window relative pixel coordinates, and
+	 return the canonical char units.  */
+      x -= window_box_left (w, TEXT_AREA);
+      y -= WINDOW_TOP_EDGE_Y (w);
       return Fcons (FRAME_CANON_X_FROM_PIXEL_X (f, x),
 		    FRAME_CANON_Y_FROM_PIXEL_Y (f, y));
 
@@ -1010,14 +1035,12 @@ If they are in the windows's left or right marginal areas, `left-margin'\n\
 struct check_window_data
 {
   Lisp_Object *window;
-  int *x, *y;
+  int x, y;
   enum window_part *part;
 };
 
 static int
-check_window_containing (w, user_data)
-     struct window *w;
-     void *user_data;
+check_window_containing (struct window *w, void *user_data)
 {
   struct check_window_data *cw = (struct check_window_data *) user_data;
   enum window_part found;
@@ -1039,8 +1062,7 @@ check_window_containing (w, user_data)
    return it as a Lisp_Object.
 
    If X, Y is on one of the window's special `window_part' elements,
-   set *PART to the id of that element, and return X and Y converted
-   to window relative coordinates in WX and WY.
+   set *PART to the id of that element.
 
    If there is no window under X, Y return nil and leave *PART
    unmodified.  TOOL_BAR_P non-zero means detect tool-bar windows.
@@ -1055,12 +1077,8 @@ check_window_containing (w, user_data)
    case.  */
 
 Lisp_Object
-window_from_coordinates (f, x, y, part, wx, wy, tool_bar_p)
-     struct frame *f;
-     int x, y;
-     enum window_part *part;
-     int *wx, *wy;
-     int tool_bar_p;
+window_from_coordinates (struct frame *f, int x, int y,
+			 enum window_part *part, int tool_bar_p)
 {
   Lisp_Object window;
   struct check_window_data cw;
@@ -1070,7 +1088,7 @@ window_from_coordinates (f, x, y, part, wx, wy, tool_bar_p)
     part = &dummy;
 
   window = Qnil;
-  cw.window = &window, cw.x = &x, cw.y = &y; cw.part = part;
+  cw.window = &window, cw.x = x, cw.y = y; cw.part = part;
   foreach_window (f, check_window_containing, &cw);
 
   /* If not found above, see if it's in the tool bar window, if a tool
@@ -1079,16 +1097,13 @@ window_from_coordinates (f, x, y, part, wx, wy, tool_bar_p)
       && tool_bar_p
       && WINDOWP (f->tool_bar_window)
       && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0
-      && (coordinates_in_window (XWINDOW (f->tool_bar_window), &x, &y)
+      && (coordinates_in_window (XWINDOW (f->tool_bar_window), x, y)
 	  != ON_NOTHING))
     {
       *part = ON_TEXT;
       window = f->tool_bar_window;
     }
 
-  if (wx) *wx = x;
-  if (wy) *wy = y;
-
   return window;
 }
 
@@ -1097,8 +1112,7 @@ DEFUN ("window-at", Fwindow_at, Swindow_at, 2, 3, 0,
 If omitted, FRAME defaults to the currently selected frame.
 The top left corner of the frame is considered to be row 0,
 column 0.  */)
-     (x, y, frame)
-     Lisp_Object x, y, frame;
+  (Lisp_Object x, Lisp_Object y, Lisp_Object frame)
 {
   struct frame *f;
 
@@ -1116,7 +1130,7 @@ column 0.  */)
 				   + FRAME_INTERNAL_BORDER_WIDTH (f)),
 				  (FRAME_PIXEL_Y_FROM_CANON_Y (f, y)
 				   + FRAME_INTERNAL_BORDER_WIDTH (f)),
-				  0, 0, 0, 0);
+				  0, 0);
 }
 
 DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0,
@@ -1131,8 +1145,7 @@ is also currently selected, the value returned is the same as (point).
 It would be more strictly correct to return the `top-level' value
 of point, outside of any save-excursion forms.
 But that is hard to define.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   register struct window *w = decode_window (window);
 
@@ -1146,8 +1159,7 @@ DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0,
        doc: /* Return position at which display currently starts in WINDOW.
 WINDOW defaults to the selected window.
 This is updated by redisplay or by calling `set-window-start'.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   return Fmarker_position (decode_window (window)->start);
 }
@@ -1173,8 +1185,7 @@ Return nil if there is no recorded value.  \(This can happen if the
 last redisplay of WINDOW was preempted, and did not finish.)
 If UPDATE is non-nil, compute the up-to-date position
 if it isn't already recorded.  */)
-     (window, update)
-     Lisp_Object window, update;
+  (Lisp_Object window, Lisp_Object update)
 {
   Lisp_Object value;
   struct window *w = decode_window (window);
@@ -1242,8 +1253,7 @@ if it isn't already recorded.  */)
 DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0,
        doc: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
 Return POS.  */)
-     (window, pos)
-     Lisp_Object window, pos;
+  (Lisp_Object window, Lisp_Object pos)
 {
   register struct window *w = decode_window (window);
 
@@ -1267,8 +1277,7 @@ DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0,
 WINDOW defaults to the selected window.  Return POS.
 Optional third arg NOFORCE non-nil inhibits next redisplay from
 overriding motion of point in order to display at this exact start.  */)
-     (window, pos, noforce)
-     Lisp_Object window, pos, noforce;
+  (Lisp_Object window, Lisp_Object pos, Lisp_Object noforce)
 {
   register struct window *w = decode_window (window);
 
@@ -1306,8 +1315,7 @@ from displaying another buffer in it.  `get-lru-window' and
 Functions like `set-window-buffer' may change the buffer displayed by a
 window, unless that window is "strongly" dedicated to its buffer, that
 is the value returned by `window-dedicated-p' is t.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   return decode_window (window)->dedicated;
 }
@@ -1331,8 +1339,7 @@ its buffer.  Functions like `set-window-buffer' may change the buffer
 displayed by a window, unless that window is strongly dedicated to its
 buffer.  If and when `set-window-buffer' displays another buffer in a
 window, it also makes sure that the window is not marked as dedicated.  */)
-     (window, flag)
-     Lisp_Object window, flag;
+  (Lisp_Object window, Lisp_Object flag)
 {
   register struct window *w = decode_window (window);
 
@@ -1346,8 +1353,7 @@ DEFUN ("window-parameters", Fwindow_parameters, Swindow_parameters,
        doc: /* Return the parameters of WINDOW and their values.
 WINDOW defaults to the selected window.  The return value is a list of
 elements of the form (PARAMETER . VALUE). */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   return Fcopy_alist (decode_window (window)->window_parameters);
 }
@@ -1356,8 +1362,7 @@ DEFUN ("window-parameter", Fwindow_parameter, Swindow_parameter,
        2, 2, 0,
        doc:  /* Return WINDOW's value for PARAMETER.
 WINDOW defaults to the selected window.  */)
-     (window, parameter)
-     Lisp_Object window, parameter;
+  (Lisp_Object window, Lisp_Object parameter)
 {
   Lisp_Object result;
 
@@ -1369,8 +1374,7 @@ DEFUN ("set-window-parameter", Fset_window_parameter,
        Sset_window_parameter, 3, 3, 0,
        doc: /* Set WINDOW's value of PARAMETER to VALUE.
 WINDOW defaults to the selected window.  Return VALUE.  */)
-     (window, parameter, value)
-     Lisp_Object window, parameter, value;
+  (Lisp_Object window, Lisp_Object parameter, Lisp_Object value)
 {
   register struct window *w = decode_window (window);
   Lisp_Object old_alist_elt;
@@ -1388,8 +1392,7 @@ DEFUN ("window-display-table", Fwindow_display_table, Swindow_display_table,
        0, 1, 0,
        doc: /* Return the display-table that WINDOW is using.
 WINDOW defaults to the selected window.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   return decode_window (window)->display_table;
 }
@@ -1400,8 +1403,7 @@ WINDOW defaults to the selected window.  */)
    return 0.  */
 
 struct Lisp_Char_Table *
-window_display_table (w)
-     struct window *w;
+window_display_table (struct window *w)
 {
   struct Lisp_Char_Table *dp = NULL;
 
@@ -1422,8 +1424,7 @@ window_display_table (w)
 
 DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0,
        doc: /* Set WINDOW's display-table to TABLE.  */)
-     (window, table)
-     register Lisp_Object window, table;
+  (register Lisp_Object window, Lisp_Object table)
 {
   register struct window *w;
 
@@ -1432,11 +1433,12 @@ DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_displa
   return table;
 }
 \f
+static void delete_window (Lisp_Object);
+
 /* Record info on buffer window w is displaying
    when it is about to cease to display that buffer.  */
 static void
-unshow_buffer (w)
-     register struct window *w;
+unshow_buffer (register struct window *w)
 {
   Lisp_Object buf;
   struct buffer *b;
@@ -1484,8 +1486,7 @@ unshow_buffer (w)
 
 /* Put replacement into the window structure in place of old. */
 static void
-replace_window (old, replacement)
-     Lisp_Object old, replacement;
+replace_window (Lisp_Object old, Lisp_Object replacement)
 {
   register Lisp_Object tem;
   register struct window *o = XWINDOW (old), *p = XWINDOW (replacement);
@@ -1502,9 +1503,9 @@ replace_window (old, replacement)
   p->total_lines = o->total_lines;
   p->desired_matrix = p->current_matrix = 0;
   p->vscroll = 0;
-  bzero (&p->cursor, sizeof (p->cursor));
-  bzero (&p->last_cursor, sizeof (p->last_cursor));
-  bzero (&p->phys_cursor, sizeof (p->phys_cursor));
+  memset (&p->cursor, 0, sizeof (p->cursor));
+  memset (&p->last_cursor, 0, sizeof (p->last_cursor));
+  memset (&p->phys_cursor, 0, sizeof (p->phys_cursor));
   p->phys_cursor_type = -1;
   p->phys_cursor_width = -1;
   p->must_be_updated_p = 0;
@@ -1541,8 +1542,7 @@ DEFUN ("delete-window", Fdelete_window, Sdelete_window, 0, 1, "",
        doc: /* Remove WINDOW from its frame.
 WINDOW defaults to the selected window.  Return nil.
 Signal an error when WINDOW is the only window on its frame.  */)
-     (window)
-     register Lisp_Object window;
+  (register Lisp_Object window)
 {
   struct frame *f;
   if (NILP (window))
@@ -1558,9 +1558,8 @@ Signal an error when WINDOW is the only window on its frame.  */)
   return Qnil;
 }
 
-void
-delete_window (window)
-     register Lisp_Object window;
+static void
+delete_window (register Lisp_Object window)
 {
   register Lisp_Object tem, parent, sib;
   register struct window *p;
@@ -1774,9 +1773,7 @@ delete_window (window)
    function window_list.  */
 
 static int
-add_window_to_list (w, user_data)
-     struct window *w;
-     void *user_data;
+add_window_to_list (struct window *w, void *user_data)
 {
   Lisp_Object *list = (Lisp_Object *) user_data;
   Lisp_Object window;
@@ -1791,7 +1788,7 @@ add_window_to_list (w, user_data)
    list, cache it in Vwindow_list, and return that.  */
 
 static Lisp_Object
-window_list ()
+window_list (void)
 {
   if (!CONSP (Vwindow_list))
     {
@@ -1832,8 +1829,7 @@ window_list ()
 		a frame means consider windows on that frame, only.  */
 
 static int
-candidate_window_p (window, owindow, minibuf, all_frames)
-     Lisp_Object window, owindow, minibuf, all_frames;
+candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf, Lisp_Object all_frames)
 {
   struct window *w = XWINDOW (window);
   struct frame *f = XFRAME (w->frame);
@@ -1898,8 +1894,7 @@ candidate_window_p (window, owindow, minibuf, all_frames)
    ALL_FRAMES.  */
 
 static void
-decode_next_window_args (window, minibuf, all_frames)
-     Lisp_Object *window, *minibuf, *all_frames;
+decode_next_window_args (Lisp_Object *window, Lisp_Object *minibuf, Lisp_Object *all_frames)
 {
   if (NILP (*window))
     *window = selected_window;
@@ -1945,9 +1940,7 @@ decode_next_window_args (window, minibuf, all_frames)
    ALL_FRAMES.  */
 
 static Lisp_Object
-next_window (window, minibuf, all_frames, next_p)
-     Lisp_Object window, minibuf, all_frames;
-     int next_p;
+next_window (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames, int next_p)
 {
   decode_next_window_args (&window, &minibuf, &all_frames);
 
@@ -2046,8 +2039,7 @@ If you use consistent values for MINIBUF and ALL-FRAMES, you can use
 `next-window' to iterate through the entire cycle of acceptable
 windows, eventually ending up back at the window you started with.
 `previous-window' traverses the same cycle, in the reverse order.  */)
-     (window, minibuf, all_frames)
-     Lisp_Object window, minibuf, all_frames;
+  (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
 {
   return next_window (window, minibuf, all_frames, 1);
 }
@@ -2064,8 +2056,7 @@ use `previous-window' to iterate through the entire cycle of
 acceptable windows, eventually ending up back at the window you
 started with.  `next-window' traverses the same cycle, in the
 reverse order.  */)
-     (window, minibuf, all_frames)
-     Lisp_Object window, minibuf, all_frames;
+  (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
 {
   return next_window (window, minibuf, all_frames, 0);
 }
@@ -2084,8 +2075,7 @@ This function uses `next-window' for finding the window to select.
 The argument ALL-FRAMES has the same meaning as in `next-window',
 but the MINIBUF argument of `next-window' is always effectively
 nil.  */)
-     (count, all_frames)
-     Lisp_Object count, all_frames;
+  (Lisp_Object count, Lisp_Object all_frames)
 {
   Lisp_Object window;
   int i;
@@ -2111,8 +2101,7 @@ MINIBUF t means include the minibuffer window, even if it isn't active.
 MINIBUF nil or omitted means include the minibuffer window only
 if it's active.
 MINIBUF neither nil nor t means never include the minibuffer window.  */)
-     (frame, minibuf, window)
-     Lisp_Object frame, minibuf, window;
+  (Lisp_Object frame, Lisp_Object minibuf, Lisp_Object window)
 {
   if (NILP (window))
     window = FRAMEP (frame) ? XFRAME (frame)->selected_window : selected_window;
@@ -2131,8 +2120,7 @@ MINIBUF neither nil nor t means never include the minibuffer window.  */)
    for `next-window'.  */
 
 static Lisp_Object
-window_list_1 (window, minibuf, all_frames)
-     Lisp_Object window, minibuf, all_frames;
+window_list_1 (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
 {
   Lisp_Object tail, list, rest;
 
@@ -2180,10 +2168,7 @@ enum window_loop
 };
 
 static Lisp_Object
-window_loop (type, obj, mini, frames)
-     enum window_loop type;
-     Lisp_Object obj, frames;
-     int mini;
+window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frames)
 {
   Lisp_Object window, windows, best_window, frame_arg;
   struct frame *f;
@@ -2410,11 +2395,21 @@ window_loop (type, obj, mini, frames)
 /* Used for debugging.  Abort if any window has a dead buffer.  */
 
 void
-check_all_windows ()
+check_all_windows (void)
 {
   window_loop (CHECK_ALL_WINDOWS, Qnil, 1, Qt);
 }
 
+DEFUN ("window-use-time", Fwindow_use_time, Swindow_use_time, 0, 1, 0,
+       doc: /* Return WINDOW's use time.
+WINDOW defaults to the selected window.  The window with the highest use
+time is the most recently selected one.  The window with the lowest use
+time is the least recently selected one.  */)
+  (Lisp_Object window)
+{
+  return decode_window (window)->use_time;
+}
+
 DEFUN ("get-lru-window", Fget_lru_window, Sget_lru_window, 0, 2, 0,
        doc: /* Return the window least recently selected or used for display.
 \(LRU means Least Recently Used.)
@@ -2428,8 +2423,7 @@ If FRAME is 0, search all visible and iconified frames.
 If FRAME is t, search all frames.
 If FRAME is nil, search only the selected frame.
 If FRAME is a frame, search only that frame.  */)
-  (frame, dedicated)
-     Lisp_Object frame, dedicated;
+  (Lisp_Object frame, Lisp_Object dedicated)
 {
   register Lisp_Object w;
   /* First try for a window that is full-width */
@@ -2454,8 +2448,7 @@ If FRAME is 0, search all visible and iconified frames.
 If FRAME is t, search all frames.
 If FRAME is nil, search only the selected frame.
 If FRAME is a frame, search only that frame.  */)
-    (frame, dedicated)
-     Lisp_Object frame, dedicated;
+  (Lisp_Object frame, Lisp_Object dedicated)
 {
   return window_loop (GET_LARGEST_WINDOW, dedicated, 0,
 		      frame);
@@ -2470,8 +2463,7 @@ If optional argument FRAME is 0, search all visible and iconified frames.
 If FRAME is t, search all frames.
 If FRAME is nil, search only the selected frame.
 If FRAME is a frame, search only that frame.  */)
-     (buffer_or_name, frame)
-     Lisp_Object buffer_or_name, frame;
+  (Lisp_Object buffer_or_name, Lisp_Object frame)
 {
   Lisp_Object buffer;
 
@@ -2495,11 +2487,10 @@ previously visible in WINDOW in the same place on the frame.  Doing this
 depends on the value of (window-start WINDOW), so if calling this
 function in a program gives strange scrolling, make sure the
 window-start value is reasonable when this function is called.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   struct window *w;
-  int startpos;
+  EMACS_INT startpos;
   int top, new_top;
 
   if (NILP (window))
@@ -2563,8 +2554,7 @@ If FRAME is t, search only the selected frame.
 If FRAME is a frame, search only that frame.
 When a window showing BUFFER-OR-NAME is dedicated and the only window of
 its frame, that frame is deleted when there are other frames left.  */)
-     (buffer_or_name, frame)
-     Lisp_Object buffer_or_name, frame;
+  (Lisp_Object buffer_or_name, Lisp_Object frame)
 {
   Lisp_Object buffer;
 
@@ -2599,8 +2589,7 @@ When a window showing BUFFER-OR-NAME is dedicated that window is
 deleted.  If that window is the only window on its frame, that frame is
 deleted too when there are other frames left.  If there are no other
 frames left, some other buffer is displayed in that window.  */)
-     (buffer_or_name)
-     Lisp_Object buffer_or_name;
+  (Lisp_Object buffer_or_name)
 {
   Lisp_Object buffer;
 
@@ -2621,8 +2610,7 @@ frames left, some other buffer is displayed in that window.  */)
    of all frames, even those on other keyboards.  */
 
 void
-replace_buffer_in_all_windows (buffer)
-     Lisp_Object buffer;
+replace_buffer_in_all_windows (Lisp_Object buffer)
 {
   Lisp_Object tail, frame;
 
@@ -2651,9 +2639,7 @@ replace_buffer_in_all_windows (buffer)
    minimum allowable size.  */
 
 void
-check_frame_size (frame, rows, cols)
-     FRAME_PTR frame;
-     int *rows, *cols;
+check_frame_size (FRAME_PTR frame, int *rows, int *cols)
 {
   /* For height, we have to see:
      how many windows the frame has at minimum (one or two),
@@ -2679,9 +2665,7 @@ check_frame_size (frame, rows, cols)
    either.  */
 
 static int
-window_fixed_size_p (w, width_p, check_siblings_p)
-     struct window *w;
-     int width_p, check_siblings_p;
+window_fixed_size_p (struct window *w, int width_p, int check_siblings_p)
 {
   int fixed_p;
   struct window *c;
@@ -2781,9 +2765,7 @@ window_fixed_size_p (w, width_p, check_siblings_p)
    minibuffer window, always return 1.  */
 
 static int
-window_min_size_2 (w, width_p, safe_p)
-     struct window *w;
-     int width_p, safe_p;
+window_min_size_2 (struct window *w, int width_p, int safe_p)
 {
   /* We should consider buffer-local values of window_min_height and
      window_min_width here.  */
@@ -2817,9 +2799,7 @@ window_min_size_2 (w, width_p, safe_p)
    sizes of W's children.  */
 
 static int
-window_min_size_1 (w, width_p, safe_p)
-     struct window *w;
-     int width_p, safe_p;
+window_min_size_1 (struct window *w, int width_p, int safe_p)
 {
   struct window *c;
   int size;
@@ -2894,9 +2874,7 @@ window_min_size_1 (w, width_p, safe_p)
    to 1 if W is fixed-size unless FIXED is null.  */
 
 static int
-window_min_size (w, width_p, safe_p, ignore_fixed_p, fixed)
-     struct window *w;
-     int width_p, safe_p, ignore_fixed_p, *fixed;
+window_min_size (struct window *w, int width_p, int safe_p, int ignore_fixed_p, int *fixed)
 {
   int size, fixed_p;
 
@@ -2922,8 +2900,7 @@ window_min_size (w, width_p, safe_p, ignore_fixed_p, fixed)
    is still too narrow.  */
 
 static int
-adjust_window_margins (w)
-     struct window *w;
+adjust_window_margins (struct window *w)
 {
   int box_cols = (WINDOW_TOTAL_COLS (w)
 		  - WINDOW_FRINGE_COLS (w)
@@ -2977,11 +2954,8 @@ adjust_window_margins (w)
    a specific window, it will attempt to strictly resize that window
    proportionally, even at the expense of deleting smaller windows.  */
 static int *
-shrink_windows (total, size, nchildren, shrinkable, resize_fixed_p,
-		forward, width_p, safe_p)
-     int total, size, nchildren, shrinkable;
-     int resize_fixed_p, width_p, safe_p;
-     Lisp_Object forward;
+shrink_windows (int total, int size, int nchildren, int shrinkable,
+		int resize_fixed_p, Lisp_Object forward, int width_p, int safe_p)
 {
   int available_resize = 0;
   int *new_sizes, *min_sizes;
@@ -3121,10 +3095,7 @@ shrink_windows (total, size, nchildren, shrinkable, resize_fixed_p,
    This should give better behavior when resizing frames.  */
 
 static void
-size_window (window, size, width_p, nodelete_p, first_only, last_only)
-     Lisp_Object window;
-     int size, width_p, nodelete_p;
-     int first_only, last_only;
+size_window (Lisp_Object window, int size, int width_p, int nodelete_p, int first_only, int last_only)
 {
   struct window *w = XWINDOW (window);
   struct window *c;
@@ -3315,10 +3286,7 @@ size_window (window, size, width_p, nodelete_p, first_only, last_only)
    displayed correctly.  */
 
 void
-set_window_height (window, height, nodelete)
-     Lisp_Object window;
-     int height;
-     int nodelete;
+set_window_height (Lisp_Object window, int height, int nodelete)
 {
   size_window (window, height, 0, nodelete, 0, 0);
 }
@@ -3332,10 +3300,7 @@ set_window_height (window, height, nodelete)
    displayed correctly.  */
 
 void
-set_window_width (window, width, nodelete)
-     Lisp_Object window;
-     int width;
-     int nodelete;
+set_window_width (Lisp_Object window, int width, int nodelete)
 {
   size_window (window, width, 1, nodelete, 0, 0);
 }
@@ -3343,9 +3308,7 @@ set_window_width (window, width, nodelete)
 /* Change window heights in windows rooted in WINDOW by N lines.  */
 
 void
-change_window_heights (window, n)
-     Lisp_Object window;
-     int n;
+change_window_heights (Lisp_Object window, int n)
 {
   struct window *w = XWINDOW (window);
 
@@ -3441,9 +3404,7 @@ run_window_configuration_change_hook (struct frame *f)
    reset from the buffer's local settings.  */
 
 void
-set_window_buffer (window, buffer, run_hooks_p, keep_margins_p)
-     Lisp_Object window, buffer;
-     int run_hooks_p, keep_margins_p;
+set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int keep_margins_p)
 {
   struct window *w = XWINDOW (window);
   struct buffer *b = XBUFFER (buffer);
@@ -3465,7 +3426,7 @@ set_window_buffer (window, buffer, run_hooks_p, keep_margins_p)
 
   XSETFASTINT (w->window_end_pos, 0);
   XSETFASTINT (w->window_end_vpos, 0);
-  bzero (&w->last_cursor, sizeof w->last_cursor);
+  memset (&w->last_cursor, 0, sizeof w->last_cursor);
   w->window_end_valid = Qnil;
   if (!(keep_margins_p && samebuf))
     { /* If we're not actually changing the buffer, don't reset hscroll and
@@ -3554,8 +3515,7 @@ already display BUFFER-OR-NAME.
 
 This function runs `window-scroll-functions' before running
 `window-configuration-change-hook'.  */)
-     (window, buffer_or_name, keep_margins)
-     register Lisp_Object window, buffer_or_name, keep_margins;
+  (register Lisp_Object window, Lisp_Object buffer_or_name, Lisp_Object keep_margins)
 {
   register Lisp_Object tem, buffer;
   register struct window *w = decode_window (window);
@@ -3572,11 +3532,12 @@ This function runs `window-scroll-functions' before running
   else if (!EQ (tem, Qt))
     /* w->buffer is t when the window is first being set up.  */
     {
-      if (!EQ (tem, buffer))
-	if (EQ (w->dedicated, Qt))
-	  error ("Window is dedicated to `%s'", SDATA (XBUFFER (tem)->name));
-	else
-	  w->dedicated = Qnil;
+      if (EQ (tem, buffer))
+	return Qnil;
+      else if (EQ (w->dedicated, Qt))
+	error ("Window is dedicated to `%s'", SDATA (XBUFFER (tem)->name));
+      else
+	w->dedicated = Qnil;
 
       unshow_buffer (w);
     }
@@ -3585,21 +3546,15 @@ This function runs `window-scroll-functions' before running
   return Qnil;
 }
 
-/* Note that selected_window can be nil when this is called from
-   Fset_window_configuration.  */
 
-DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
-       doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
-If WINDOW is not already selected, make WINDOW's buffer current
-and make WINDOW the frame's selected window.  Return WINDOW.
-Optional second arg NORECORD non-nil means do not put this buffer
-at the front of the list of recently selected ones and do not
-make this window the most recently selected one.
+/* If select_window is called with inhibit_point_swap non-zero it will
+   not store point of the old selected window's buffer back into that
+   window's pointm slot.  This is needed by Fset_window_configuration to
+   avoid that the display routine is called with selected_window set to
+   Qnil causing a subsequent crash.  */
 
-Note that the main editor command loop selects the buffer of the
-selected window before each command.  */)
-     (window, norecord)
-     register Lisp_Object window, norecord;
+static Lisp_Object
+select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
 {
   register struct window *w;
   register struct window *ow;
@@ -3614,6 +3569,7 @@ selected window before each command.  */)
     {
       ++window_select_count;
       XSETFASTINT (w->use_time, window_select_count);
+      record_buffer (w->buffer);
     }
 
   if (EQ (window, selected_window))
@@ -3638,9 +3594,7 @@ selected window before each command.  */)
   /* Store the current buffer's actual point into the
      old selected window.  It belongs to that window,
      and when the window is not selected, must be in the window.  */
-  if (inhibit_point_swap)
-    inhibit_point_swap = 0;
-  else
+  if (! inhibit_point_swap)
     {
       ow = XWINDOW (selected_window);
       if (! NILP (ow->buffer))
@@ -3651,8 +3605,6 @@ selected window before each command.  */)
 
   selected_window = window;
 
-  if (NILP (norecord))
-    record_buffer (w->buffer);
   Fset_buffer (w->buffer);
 
   XBUFFER (w->buffer)->last_selected_window = window;
@@ -3663,7 +3615,7 @@ selected window before each command.  */)
      redisplay_window has altered point after scrolling,
      because it makes the change only in the window.  */
   {
-    register int new_point = marker_position (w->pointm);
+    register EMACS_INT new_point = marker_position (w->pointm);
     if (new_point < BEGV)
       SET_PT (BEGV);
     else if (new_point > ZV)
@@ -3676,25 +3628,37 @@ selected window before each command.  */)
   return window;
 }
 
+DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
+       doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
+If WINDOW is not already selected, make WINDOW's buffer current
+and make WINDOW the frame's selected window.  Return WINDOW.
+Optional second arg NORECORD non-nil means do not put this buffer
+at the front of the list of recently selected ones and do not
+make this window the most recently selected one.
+
+Note that the main editor command loop selects the buffer of the
+selected window before each command.  */)
+  (register Lisp_Object window, Lisp_Object norecord)
+{
+  select_window (window, norecord, 0);
+}
+
 static Lisp_Object
-select_window_norecord (window)
-     Lisp_Object window;
+select_window_norecord (Lisp_Object window)
 {
   return WINDOW_LIVE_P (window)
     ? Fselect_window (window, Qt) : selected_window;
 }
 
 static Lisp_Object
-select_frame_norecord (frame)
-     Lisp_Object frame;
+select_frame_norecord (Lisp_Object frame)
 {
   return FRAME_LIVE_P (XFRAME (frame))
     ? Fselect_frame (frame, Qt) : selected_frame;
 }
 \f
 Lisp_Object
-display_buffer (buffer, not_this_window_p, override_frame)
-     Lisp_Object buffer, not_this_window_p, override_frame;
+display_buffer (Lisp_Object buffer, Lisp_Object not_this_window_p, Lisp_Object override_frame)
 {
   return call3 (Qdisplay_buffer, buffer, not_this_window_p, override_frame);
 }
@@ -3705,8 +3669,7 @@ DEFUN ("force-window-update", Fforce_window_update, Sforce_window_update,
 If optional arg OBJECT is a window, force redisplay of that window only.
 If OBJECT is a buffer or buffer name, force redisplay of all windows
 displaying that buffer.  */)
-     (object)
-     Lisp_Object object;
+  (Lisp_Object object)
 {
   if (NILP (object))
     {
@@ -3745,8 +3708,7 @@ displaying that buffer.  */)
 
 
 void
-temp_output_buffer_show (buf)
-     register Lisp_Object buf;
+temp_output_buffer_show (register Lisp_Object buf)
 {
   register struct buffer *old = current_buffer;
   register Lisp_Object window;
@@ -3806,8 +3768,7 @@ temp_output_buffer_show (buf)
 }
 \f
 static void
-make_dummy_parent (window)
-     Lisp_Object window;
+make_dummy_parent (Lisp_Object window)
 {
   Lisp_Object new;
   register struct window *o, *p;
@@ -3849,8 +3810,7 @@ The upper or leftmost window is the original one, and remains selected
 if it was selected before.
 
 See Info node `(elisp)Splitting Windows' for more details and examples.  */)
-     (window, size, horizontal)
-     Lisp_Object window, size, horizontal;
+  (Lisp_Object window, Lisp_Object size, Lisp_Object horizontal)
 {
   register Lisp_Object new;
   register struct window *o, *p;
@@ -3940,7 +3900,7 @@ See Info node `(elisp)Splitting Windows' for more details and examples.  */)
   p->parent = o->parent;
   p->buffer = Qt;
   p->window_end_valid = Qnil;
-  bzero (&p->last_cursor, sizeof p->last_cursor);
+  memset (&p->last_cursor, 0, sizeof p->last_cursor);
 
   /* Duplicate special geometry settings.  */
 
@@ -3989,8 +3949,7 @@ window wider by SIZE columns.  If SIZE is negative, shrink the window by
 
 This function can delete windows if they get too small.  The size of
 fixed size windows is not altered by this function.  */)
-     (size, horizontal)
-     Lisp_Object size, horizontal;
+  (Lisp_Object size, Lisp_Object horizontal)
 {
   CHECK_NUMBER (size);
   enlarge_window (selected_window, XINT (size), !NILP (horizontal));
@@ -4009,8 +3968,7 @@ window by -SIZE lines or columns.  Return nil.
 
 This function can delete windows if they get too small.  The size of
 fixed size windows is not altered by this function. */)
-     (size, horizontal)
-     Lisp_Object size, horizontal;
+  (Lisp_Object size, Lisp_Object horizontal)
 {
   CHECK_NUMBER (size);
   enlarge_window (selected_window, -XINT (size), !NILP (horizontal));
@@ -4020,17 +3978,15 @@ fixed size windows is not altered by this function. */)
   return Qnil;
 }
 
-int
-window_height (window)
-     Lisp_Object window;
+static int
+window_height (Lisp_Object window)
 {
   register struct window *p = XWINDOW (window);
   return WINDOW_TOTAL_LINES (p);
 }
 
-int
-window_width (window)
-     Lisp_Object window;
+static int
+window_width (Lisp_Object window)
 {
   register struct window *p = XWINDOW (window);
   return WINDOW_TOTAL_COLS (p);
@@ -4052,17 +4008,15 @@ window_width (window)
    deleted.  */
 
 static void
-enlarge_window (window, delta, horiz_flag)
-     Lisp_Object window;
-     int delta, horiz_flag;
+enlarge_window (Lisp_Object window, int delta, int horiz_flag)
 {
   Lisp_Object parent, next, prev;
   struct window *p;
   Lisp_Object *sizep;
   int maximum;
-  int (*sizefun) P_ ((Lisp_Object))
+  int (*sizefun) (Lisp_Object)
     = horiz_flag ? window_width : window_height;
-  void (*setsizefun) P_ ((Lisp_Object, int, int))
+  void (*setsizefun) (Lisp_Object, int, int)
     = (horiz_flag ? set_window_width : set_window_height);
 
   /* Give up if this window cannot be resized.  */
@@ -4330,9 +4284,7 @@ enlarge_window (window, delta, horiz_flag)
    are not deleted; instead, we signal an error.  */
 
 static void
-adjust_window_trailing_edge (window, delta, horiz_flag)
-     Lisp_Object window;
-     int delta, horiz_flag;
+adjust_window_trailing_edge (Lisp_Object window, int delta, int horiz_flag)
 {
   Lisp_Object parent, child;
   struct window *p;
@@ -4468,8 +4420,7 @@ Otherwise, adjust the height, moving the bottom edge.
 Following siblings of the selected window are resized to fulfill
 the size request.  If they become too small in the process, they
 are not deleted; instead, we signal an error.  */)
-  (window, delta, horizontal)
-  Lisp_Object window, delta, horizontal;
+  (Lisp_Object window, Lisp_Object delta, Lisp_Object horizontal)
 {
   CHECK_NUMBER (delta);
   if (NILP (window))
@@ -4488,7 +4439,7 @@ are not deleted; instead, we signal an error.  */)
 			Resizing Mini-Windows
  ***********************************************************************/
 
-static void shrink_window_lowest_first P_ ((struct window *, int));
+static void shrink_window_lowest_first (struct window *, int);
 
 enum save_restore_action
 {
@@ -4497,16 +4448,14 @@ enum save_restore_action
     RESTORE_ORIG_SIZES
 };
 
-static int save_restore_orig_size P_ ((struct window *,
-                                       enum save_restore_action));
+static int save_restore_orig_size (struct window *,
+                                   enum save_restore_action);
 
 /* Shrink windows rooted in window W to HEIGHT.  Take the space needed
    from lowest windows first.  */
 
 static void
-shrink_window_lowest_first (w, height)
-     struct window *w;
-     int height;
+shrink_window_lowest_first (struct window *w, int height)
 {
   struct window *c;
   Lisp_Object child;
@@ -4588,9 +4537,7 @@ shrink_window_lowest_first (w, height)
    stored in orig_top_line and orig_total_lines for all windows.  */
 
 static int
-save_restore_orig_size (w, action)
-     struct window *w;
-     enum save_restore_action action;
+save_restore_orig_size (struct window *w, enum save_restore_action action)
 {
   int success_p = 1;
 
@@ -4645,9 +4592,7 @@ save_restore_orig_size (w, action)
    without deleting other windows.  */
 
 void
-grow_mini_window (w, delta)
-     struct window *w;
-     int delta;
+grow_mini_window (struct window *w, int delta)
 {
   struct frame *f = XFRAME (w->frame);
   struct window *root;
@@ -4696,8 +4641,7 @@ grow_mini_window (w, delta)
    line.  */
 
 void
-shrink_mini_window (w)
-     struct window *w;
+shrink_mini_window (struct window *w)
 {
   struct frame *f = XFRAME (w->frame);
   struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
@@ -4727,8 +4671,7 @@ shrink_mini_window (w)
    the frame are cleared.  */
 
 void
-mark_window_cursors_off (w)
-     struct window *w;
+mark_window_cursors_off (struct window *w)
 {
   while (w)
     {
@@ -4747,8 +4690,7 @@ mark_window_cursors_off (w)
 /* Return number of lines of text (not counting mode lines) in W.  */
 
 int
-window_internal_height (w)
-     struct window *w;
+window_internal_height (struct window *w)
 {
   int ht = XFASTINT (w->total_lines);
 
@@ -4775,8 +4717,7 @@ window_internal_height (w)
    separating W from the sibling to its right.  */
 
 int
-window_box_text_cols (w)
-     struct window *w;
+window_box_text_cols (struct window *w)
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   int width = XINT (w->total_cols);
@@ -4813,11 +4754,7 @@ window_box_text_cols (w)
    respectively.  */
 
 static void
-window_scroll (window, n, whole, noerror)
-     Lisp_Object window;
-     int n;
-     int whole;
-     int noerror;
+window_scroll (Lisp_Object window, int n, int whole, int noerror)
 {
   immediate_quit = 1;
 
@@ -4837,11 +4774,7 @@ window_scroll (window, n, whole, noerror)
    descriptions.  */
 
 static void
-window_scroll_pixel_based (window, n, whole, noerror)
-     Lisp_Object window;
-     int n;
-     int whole;
-     int noerror;
+window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
 {
   struct it it;
   struct window *w = XWINDOW (window);
@@ -4916,7 +4849,7 @@ window_scroll_pixel_based (window, n, whole, noerror)
 	      /* Maybe modify window start instead of scrolling.  */
 	      if (rbot > 0 || w->vscroll < 0)
 		{
-		  int spos;
+		  EMACS_INT spos;
 
 		  Fset_window_vscroll (window, make_number (0), Qt);
 		  /* If there are other text lines above the current row,
@@ -4947,12 +4880,13 @@ window_scroll_pixel_based (window, n, whole, noerror)
   if (!NILP (Vscroll_preserve_screen_position))
     {
       /* We preserve the goal pixel coordinate across consecutive
-	 calls to scroll-up or scroll-down.  This avoids the
+	 calls to scroll-up, scroll-down and other commands that
+	 have the `scroll-command' property.  This avoids the
 	 possibility of point becoming "stuck" on a tall line when
 	 scrolling by one line.  */
       if (window_scroll_pixel_based_preserve_y < 0
-	  || (!EQ (current_kboard->Vlast_command, Qscroll_up)
-	      && !EQ (current_kboard->Vlast_command, Qscroll_down)))
+	  || !SYMBOLP (current_kboard->Vlast_command)
+	  || NILP (Fget (current_kboard->Vlast_command, Qscroll_command)))
 	{
 	  start_display (&it, w, start);
 	  move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
@@ -4969,7 +4903,7 @@ window_scroll_pixel_based (window, n, whole, noerror)
   start_display (&it, w, start);
   if (whole)
     {
-      int start_pos = IT_CHARPOS (it);
+      EMACS_INT start_pos = IT_CHARPOS (it);
       int dy = WINDOW_FRAME_LINE_HEIGHT (w);
       dy = max ((window_box_height (w)
 		 - next_screen_context_lines * dy),
@@ -5048,8 +4982,8 @@ window_scroll_pixel_based (window, n, whole, noerror)
 
   if (! vscrolled)
     {
-      int pos = IT_CHARPOS (it);
-      int bytepos;
+      EMACS_INT pos = IT_CHARPOS (it);
+      EMACS_INT bytepos;
 
       /* If in the middle of a multi-glyph character move forward to
 	 the next character.  */
@@ -5119,7 +5053,7 @@ window_scroll_pixel_based (window, n, whole, noerror)
     }
   else if (n < 0)
     {
-      int charpos, bytepos;
+      EMACS_INT charpos, bytepos;
       int partial_p;
 
       /* Save our position, for the
@@ -5186,20 +5120,16 @@ window_scroll_pixel_based (window, n, whole, noerror)
    See the comment of window_scroll for parameter descriptions.  */
 
 static void
-window_scroll_line_based (window, n, whole, noerror)
-     Lisp_Object window;
-     int n;
-     int whole;
-     int noerror;
+window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
 {
   register struct window *w = XWINDOW (window);
-  register int opoint = PT, opoint_byte = PT_BYTE;
-  register int pos, pos_byte;
+  register EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
+  register EMACS_INT pos, pos_byte;
   register int ht = window_internal_height (w);
   register Lisp_Object tem;
   int lose;
   Lisp_Object bolp;
-  int startpos;
+  EMACS_INT startpos;
   Lisp_Object original_pos = Qnil;
 
   /* If scrolling screen-fulls, compute the number of lines to
@@ -5212,8 +5142,8 @@ window_scroll_line_based (window, n, whole, noerror)
   if (!NILP (Vscroll_preserve_screen_position))
     {
       if (window_scroll_preserve_vpos <= 0
-	  || (!EQ (current_kboard->Vlast_command, Qscroll_up)
-	      && !EQ (current_kboard->Vlast_command, Qscroll_down)))
+	  || !SYMBOLP (current_kboard->Vlast_command)
+	  || NILP (Fget (current_kboard->Vlast_command, Qscroll_command)))
 	{
 	  struct position posit
 	    = *compute_motion (startpos, 0, 0, 0,
@@ -5348,9 +5278,7 @@ window_scroll_line_based (window, n, whole, noerror)
    up.  This is the guts of Fscroll_up and Fscroll_down.  */
 
 static void
-scroll_command (n, direction)
-     Lisp_Object n;
-     int direction;
+scroll_command (Lisp_Object n, int direction)
 {
   int count = SPECPDL_INDEX ();
 
@@ -5387,8 +5315,7 @@ A near full screen is `next-screen-context-lines' less than a full screen.
 Negative ARG means scroll downward.
 If ARG is the atom `-', scroll downward by nearly full screen.
 When calling from a program, supply as argument a number, nil, or `-'.  */)
-     (arg)
-     Lisp_Object arg;
+  (Lisp_Object arg)
 {
   scroll_command (arg, 1);
   return Qnil;
@@ -5401,8 +5328,7 @@ A near full screen is `next-screen-context-lines' less than a full screen.
 Negative ARG means scroll upward.
 If ARG is the atom `-', scroll upward by nearly full screen.
 When calling from a program, supply as argument a number, nil, or `-'.  */)
-     (arg)
-     Lisp_Object arg;
+  (Lisp_Object arg)
 {
   scroll_command (arg, -1);
   return Qnil;
@@ -5415,7 +5341,7 @@ showing that buffer is used.
 If in the minibuffer, `minibuffer-scroll-window' if non-nil
 specifies the window.  This takes precedence over
 `other-window-scroll-buffer'.  */)
-     ()
+  (void)
 {
   Lisp_Object window;
 
@@ -5465,8 +5391,7 @@ showing that buffer, popping the buffer up if necessary.
 If in the minibuffer, `minibuffer-scroll-window' if non-nil
 specifies the window to scroll.  This takes precedence over
 `other-window-scroll-buffer'.  */)
-     (arg)
-     Lisp_Object arg;
+  (Lisp_Object arg)
 {
   Lisp_Object window;
   struct window *w;
@@ -5509,8 +5434,7 @@ If SET-MINIMUM is non-nil, the new scroll amount becomes the
 lower bound for automatic scrolling, i.e. automatic scrolling
 will not scroll a window to a column less than the value returned
 by this function.  This happens in an interactive call.  */)
-     (arg, set_minimum)
-     register Lisp_Object arg, set_minimum;
+  (register Lisp_Object arg, Lisp_Object set_minimum)
 {
   Lisp_Object result;
   int hscroll;
@@ -5539,8 +5463,7 @@ If SET-MINIMUM is non-nil, the new scroll amount becomes the
 lower bound for automatic scrolling, i.e. automatic scrolling
 will not scroll a window to a column less than the value returned
 by this function.  This happens in an interactive call.  */)
-     (arg, set_minimum)
-     register Lisp_Object arg, set_minimum;
+  (register Lisp_Object arg, Lisp_Object set_minimum)
 {
   Lisp_Object result;
   int hscroll;
@@ -5563,7 +5486,7 @@ by this function.  This happens in an interactive call.  */)
 DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window, Sminibuffer_selected_window, 0, 0, 0,
        doc: /* Return the window which was selected when entering the minibuffer.
 Returns nil, if selected window is not a minibuffer window.  */)
-     ()
+  (void)
 {
   if (minibuf_level > 0
       && MINI_WINDOW_P (XWINDOW (selected_window))
@@ -5577,8 +5500,7 @@ Returns nil, if selected window is not a minibuffer window.  */)
    as opposed to its height.  */
 
 static int
-displayed_window_lines (w)
-     struct window *w;
+displayed_window_lines (struct window *w)
 {
   struct it it;
   struct text_pos start;
@@ -5646,14 +5568,13 @@ then only tty frame are redrawn.
 
 Just C-u as prefix means put point in the center of the window
 and redisplay normally--don't erase and redraw the frame.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   struct window *w = XWINDOW (selected_window);
   struct buffer *buf = XBUFFER (w->buffer);
   struct buffer *obuf = current_buffer;
   int center_p = 0;
-  int charpos, bytepos;
+  EMACS_INT charpos, bytepos;
   int iarg;
   int this_scroll_margin;
 
@@ -5831,8 +5752,7 @@ WINDOW defaults to the selected window.
 
 The return value does not include the mode line, any header line, nor
 any partial-height lines in the text display area.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   struct window *w = decode_window (window);
   int pixel_height = window_box_height (w);
@@ -5848,8 +5768,7 @@ DEFUN ("move-to-window-line", Fmove_to_window_line, Smove_to_window_line,
 With no argument, position point at center of window.
 An argument specifies vertical position within the window;
 zero means top of window, negative means relative to bottom of window.  */)
-     (arg)
-     Lisp_Object arg;
+  (Lisp_Object arg)
 {
   struct window *w = XWINDOW (selected_window);
   int lines, start;
@@ -5968,16 +5887,14 @@ struct saved_window
 
 DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a window-configuration object.  */)
-     (object)
-     Lisp_Object object;
+  (Lisp_Object object)
 {
   return WINDOW_CONFIGURATIONP (object) ? Qt : Qnil;
 }
 
 DEFUN ("window-configuration-frame", Fwindow_configuration_frame, Swindow_configuration_frame, 1, 1, 0,
        doc: /* Return the frame that CONFIG, a window-configuration object, is about.  */)
-     (config)
-     Lisp_Object config;
+  (Lisp_Object config)
 {
   register struct save_window_data *data;
   struct Lisp_Vector *saved_windows;
@@ -5997,15 +5914,14 @@ by `current-window-configuration' (which see).
 If CONFIGURATION was made from a frame that is now deleted,
 only frame-independent values can be restored.  In this case,
 the return value is nil.  Otherwise the value is t.  */)
-     (configuration)
-     Lisp_Object configuration;
+  (Lisp_Object configuration)
 {
   register struct save_window_data *data;
   struct Lisp_Vector *saved_windows;
   Lisp_Object new_current_buffer;
   Lisp_Object frame;
   FRAME_PTR f;
-  int old_point = -1;
+  EMACS_INT old_point = -1;
 
   CHECK_WINDOW_CONFIGURATION (configuration);
 
@@ -6255,8 +6171,7 @@ the return value is nil.  Otherwise the value is t.  */)
 	 out point" in the old selected window using the buffer that
 	 has been restored into it.  We already swapped out that point
 	 from that window's old buffer.  */
-      inhibit_point_swap = 1;
-      Fselect_window (data->current_window, Qnil);
+      select_window (data->current_window, Qnil, 1);
       XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
 	= selected_window;
 
@@ -6323,8 +6238,7 @@ the return value is nil.  Otherwise the value is t.  */)
    by setting their buffers to nil.  */
 
 void
-delete_all_subwindows (w)
-     register struct window *w;
+delete_all_subwindows (register struct window *w)
 {
   if (!NILP (w->next))
     delete_all_subwindows (XWINDOW (w->next));
@@ -6350,8 +6264,7 @@ delete_all_subwindows (w)
 }
 \f
 static int
-count_windows (window)
-     register struct window *window;
+count_windows (register struct window *window)
 {
   register int count = 1;
   if (!NILP (window->next))
@@ -6368,10 +6281,7 @@ count_windows (window)
    Value is last index + 1.  */
 
 static int
-get_leaf_windows (w, flat, i)
-     struct window *w;
-     struct window **flat;
-     int i;
+get_leaf_windows (struct window *w, struct window **flat, int i)
 {
   while (w)
     {
@@ -6394,8 +6304,7 @@ get_leaf_windows (w, flat, i)
    can be returned.  */
 
 struct glyph *
-get_phys_cursor_glyph (w)
-     struct window *w;
+get_phys_cursor_glyph (struct window *w)
 {
   struct glyph_row *row;
   struct glyph *glyph;
@@ -6414,10 +6323,7 @@ get_phys_cursor_glyph (w)
 
 
 static int
-save_window_save (window, vector, i)
-     Lisp_Object window;
-     struct Lisp_Vector *vector;
-     int i;
+save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
 {
   register struct saved_window *p;
   register struct window *w;
@@ -6507,8 +6413,7 @@ point and mark.  An exception is made for point in the current buffer:
 its value is -not- saved.
 This also records the currently selected frame, and FRAME's focus
 redirection (see `redirect-frame-focus').  */)
-     (frame)
-     Lisp_Object frame;
+  (Lisp_Object frame)
 {
   register Lisp_Object tem;
   register int n_windows;
@@ -6556,8 +6461,7 @@ Also restore the choice of selected window.
 Also restore which buffer is current.
 Does not restore the value of point in current buffer.
 usage: (save-window-excursion BODY...)  */)
-     (args)
-     Lisp_Object args;
+  (Lisp_Object args)
 {
   register Lisp_Object val;
   register int count = SPECPDL_INDEX ();
@@ -6575,8 +6479,7 @@ usage: (save-window-excursion BODY...)  */)
  ***********************************************************************/
 
 static Lisp_Object
-window_tree (w)
-     struct window *w;
+window_tree (struct window *w)
 {
   Lisp_Object tail = Qnil;
   Lisp_Object result = Qnil;
@@ -6629,8 +6532,7 @@ EDGES is a list \(LEFT TOP RIGHT BOTTOM) as returned by `window-edges'.
 
 If FRAME is nil or omitted, return information on the currently
 selected frame.  */)
-     (frame)
-     Lisp_Object frame;
+  (Lisp_Object frame)
 {
   FRAME_PTR f;
 
@@ -6659,8 +6561,7 @@ Second arg LEFT-WIDTH specifies the number of character cells to
 reserve for the left marginal area.  Optional third arg RIGHT-WIDTH
 does the same for the right marginal area.  A nil width parameter
 means no margin.  */)
-     (window, left_width, right_width)
-     Lisp_Object window, left_width, right_width;
+  (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width)
 {
   struct window *w = decode_window (window);
 
@@ -6704,8 +6605,7 @@ If WINDOW is omitted or nil, use the currently selected window.
 Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
 If a marginal area does not exist, its width will be returned
 as nil.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   struct window *w = decode_window (window);
   return Fcons (w->left_margin_cols, w->right_margin_cols);
@@ -6730,8 +6630,7 @@ the command `set-fringe-style'.
 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
 outside of the display margins.  By default, fringes are drawn between
 display marginal areas and the text area.  */)
-     (window, left_width, right_width, outside_margins)
-     Lisp_Object window, left_width, right_width, outside_margins;
+  (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width, Lisp_Object outside_margins)
 {
   struct window *w = decode_window (window);
 
@@ -6768,8 +6667,7 @@ DEFUN ("window-fringes", Fwindow_fringes, Swindow_fringes,
        doc: /* Get width of fringes of window WINDOW.
 If WINDOW is omitted or nil, use the currently selected window.
 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   struct window *w = decode_window (window);
 
@@ -6796,8 +6694,7 @@ bar: left, right, or nil.
 If WIDTH is nil, use the frame's scroll-bar width.
 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
 Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
-     (window, width, vertical_type, horizontal_type)
-     Lisp_Object window, width, vertical_type, horizontal_type;
+  (Lisp_Object window, Lisp_Object width, Lisp_Object vertical_type, Lisp_Object horizontal_type)
 {
   struct window *w = decode_window (window);
 
@@ -6841,8 +6738,7 @@ If WINDOW is omitted or nil, use the currently selected window.
 Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE).
 If WIDTH is nil or TYPE is t, the window is using the frame's corresponding
 value.  */)
-     (window)
-     Lisp_Object window;
+  (Lisp_Object window)
 {
   struct window *w = decode_window (window);
   return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
@@ -6864,8 +6760,7 @@ DEFUN ("window-vscroll", Fwindow_vscroll, Swindow_vscroll, 0, 2, 0,
 Use the selected window if WINDOW is nil or omitted.
 Normally, value is a multiple of the canonical character height of WINDOW;
 optional second arg PIXELS-P means value is measured in pixels.  */)
-  (window, pixels_p)
-     Lisp_Object window, pixels_p;
+  (Lisp_Object window, Lisp_Object pixels_p)
 {
   Lisp_Object result;
   struct frame *f;
@@ -6898,8 +6793,7 @@ If PIXELS-P is nil, VSCROLL may have to be rounded so that it
 corresponds to an integral number of pixels.  The return value is the
 result of this rounding.
 If PIXELS-P is non-nil, the return value is VSCROLL.  */)
-  (window, vscroll, pixels_p)
-     Lisp_Object window, vscroll, pixels_p;
+  (Lisp_Object window, Lisp_Object vscroll, Lisp_Object pixels_p)
 {
   struct window *w;
   struct frame *f;
@@ -6942,11 +6836,9 @@ If PIXELS-P is non-nil, the return value is VSCROLL.  */)
    first argument being a pointer to the leaf window, and with
    additional argument USER_DATA.  Stops when FN returns 0.  */
 
-void
-foreach_window (f, fn, user_data)
-     struct frame *f;
-     int (* fn) P_ ((struct window *, void *));
-     void *user_data;
+static void
+foreach_window (struct frame *f, int (*fn) (struct window *, void *),
+		void *user_data)
 {
   /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil.  */
   if (WINDOWP (FRAME_ROOT_WINDOW (f)))
@@ -6960,10 +6852,7 @@ foreach_window (f, fn, user_data)
    Stop when FN returns 0.  Value is 0 if stopped by FN.  */
 
 static int
-foreach_window_1 (w, fn, user_data)
-     struct window *w;
-     int (* fn) P_ ((struct window *, void *));
-     void *user_data;
+foreach_window_1 (struct window *w, int (*fn) (struct window *, void *), void *user_data)
 {
   int cont;
 
@@ -6988,9 +6877,7 @@ foreach_window_1 (w, fn, user_data)
    the window start.  */
 
 static int
-freeze_window_start (w, freeze_p)
-     struct window *w;
-     void *freeze_p;
+freeze_window_start (struct window *w, void *freeze_p)
 {
   if (MINI_WINDOW_P (w)
       || (WINDOWP (selected_window) /* Can be nil in corner cases.  */
@@ -7010,9 +6897,7 @@ freeze_window_start (w, freeze_p)
    means freeze the window start.  */
 
 void
-freeze_window_starts (f, freeze_p)
-     struct frame *f;
-     int freeze_p;
+freeze_window_starts (struct frame *f, int freeze_p)
 {
   foreach_window (f, freeze_window_start, (void *) (freeze_p ? f : 0));
 }
@@ -7026,9 +6911,7 @@ freeze_window_starts (f, freeze_p)
    describe the same state of affairs.  This is used by Fequal.  */
 
 int
-compare_window_configurations (c1, c2, ignore_positions)
-     Lisp_Object c1, c2;
-     int ignore_positions;
+compare_window_configurations (Lisp_Object c1, Lisp_Object c2, int ignore_positions)
 {
   register struct save_window_data *d1, *d2;
   struct Lisp_Vector *sw1, *sw2;
@@ -7145,8 +7028,7 @@ DEFUN ("compare-window-configurations", Fcompare_window_configurations,
        doc: /* Compare two window configurations as regards the structure of windows.
 This function ignores details such as the values of point and mark
 and scrolling positions.  */)
-     (x, y)
-     Lisp_Object x, y;
+  (Lisp_Object x, Lisp_Object y)
 {
   if (compare_window_configurations (x, y, 1))
     return Qt;
@@ -7154,7 +7036,7 @@ and scrolling positions.  */)
 }
 \f
 void
-init_window_once ()
+init_window_once (void)
 {
   struct frame *f = make_initial_frame ();
   XSETFRAME (selected_frame, f);
@@ -7167,13 +7049,13 @@ init_window_once ()
 }
 
 void
-init_window ()
+init_window (void)
 {
   Vwindow_list = Qnil;
 }
 
 void
-syms_of_window ()
+syms_of_window (void)
 {
   Qscroll_up = intern_c_string ("scroll-up");
   staticpro (&Qscroll_up);
@@ -7181,6 +7063,12 @@ syms_of_window ()
   Qscroll_down = intern_c_string ("scroll-down");
   staticpro (&Qscroll_down);
 
+  Qscroll_command = intern_c_string ("scroll-command");
+  staticpro (&Qscroll_command);
+
+  Fput (Qscroll_up, Qscroll_command, Qt);
+  Fput (Qscroll_down, Qscroll_command, Qt);
+
   Qwindow_size_fixed = intern_c_string ("window-size-fixed");
   staticpro (&Qwindow_size_fixed);
   Fset (Qwindow_size_fixed, Qnil);
@@ -7214,8 +7102,6 @@ syms_of_window ()
   window_scroll_preserve_hpos = -1;
   window_scroll_preserve_vpos = -1;
 
-  inhibit_point_swap = 0;
-
   DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function,
 	       doc: /* Non-nil means call as function to display a help buffer.
 The function is called with one argument, the buffer to be displayed.
@@ -7272,7 +7158,9 @@ at the scroll margin or window boundary respectively.
 A value of t means point keeps its screen position if the scroll
 command moved it vertically out of the window, e.g. when scrolling
 by full screens.
-Any other value means point always keeps its screen position.  */);
+Any other value means point always keeps its screen position.
+Scroll commands should have the `scroll-command' property
+on their symbols to be controlled by this variable.  */);
   Vscroll_preserve_screen_position = Qnil;
 
   DEFVAR_LISP ("window-point-insertion-type", &Vwindow_point_insertion_type,
@@ -7289,7 +7177,7 @@ with the relevant frame selected.  */);
 
   DEFVAR_LISP ("recenter-redisplay", &Vrecenter_redisplay,
 	       doc: /* If non-nil, then the `recenter' command with a nil argument
-the entire frame to be redrawn; the special value `tty' causes the
+will redraw the entire frame; the special value `tty' causes the
 frame to be redrawn only if it is a tty frame.  */);
   Vrecenter_redisplay = Qtty;
 
@@ -7311,8 +7199,10 @@ frame to be redrawn only if it is a tty frame.  */);
   defsubr (&Sset_window_redisplay_end_trigger);
   defsubr (&Swindow_edges);
   defsubr (&Swindow_pixel_edges);
+  defsubr (&Swindow_absolute_pixel_edges);
   defsubr (&Swindow_inside_edges);
   defsubr (&Swindow_inside_pixel_edges);
+  defsubr (&Swindow_inside_absolute_pixel_edges);
   defsubr (&Scoordinates_in_window_p);
   defsubr (&Swindow_at);
   defsubr (&Swindow_point);
@@ -7328,6 +7218,7 @@ frame to be redrawn only if it is a tty frame.  */);
   defsubr (&Sprevious_window);
   defsubr (&Sother_window);
   defsubr (&Sget_lru_window);
+  defsubr (&Swindow_use_time);
   defsubr (&Sget_largest_window);
   defsubr (&Sget_buffer_window);
   defsubr (&Sdelete_other_windows);
@@ -7374,7 +7265,7 @@ frame to be redrawn only if it is a tty frame.  */);
 }
 
 void
-keys_of_window ()
+keys_of_window (void)
 {
   initial_define_key (control_x_map, '1', "delete-other-windows");
   initial_define_key (control_x_map, '2', "split-window");
@@ -7384,13 +7275,8 @@ keys_of_window ()
   initial_define_key (control_x_map, '<', "scroll-left");
   initial_define_key (control_x_map, '>', "scroll-right");
 
-  initial_define_key (global_map, Ctl ('V'), "scroll-up");
+  initial_define_key (global_map, Ctl ('V'), "scroll-up-command");
   initial_define_key (meta_map, Ctl ('V'), "scroll-other-window");
-  initial_define_key (meta_map, 'v', "scroll-down");
-
-  initial_define_key (global_map, Ctl('L'), "recenter");
-  initial_define_key (meta_map, 'r', "move-to-window-line");
+  initial_define_key (meta_map, 'v', "scroll-down-command");
 }
 
-/* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
-   (do not change this comment) */

Re: bug in 23.2.92 with anything

[martin rudalics]

> I have applied your changes, but now it fail to compile:
> 
> ,----
> | window.c:81: error: static declaration of ‘foreach_window’ follows non-static declaration
> | window.h:799: note: previous declaration of ‘foreach_window’ was here
> | window.c: In function ‘Fcoordinates_in_window_p’:
> | window.c:1011: error: ‘Qleft_margin’ undeclared (first use in this function)
> | window.c:1011: error: (Each undeclared identifier is reported only once
> | window.c:1011: error: for each function it appears in.)
> | window.c:1014: error: ‘Qright_margin’ undeclared (first use in this function)
> | window.c: At top level:
> | window.c:1080: error: conflicting types for ‘window_from_coordinates’
> | window.h:787: note: previous declaration of ‘window_from_coordinates’ was here
> | window.c:1436: error: static declaration of ‘delete_window’ follows non-static declaration
> | window.h:786: note: previous declaration of ‘delete_window’ was here
> | window.c:3982: error: static declaration of ‘window_height’ follows non-static declaration
> | window.h:791: note: previous declaration of ‘window_height’ was here
> | window.c:3989: error: static declaration of ‘window_width’ follows non-static declaration
> | window.h:792: note: previous declaration of ‘window_width’ was here
> | make[1]: *** [window.o] Erreur 1
> | make[1]: quittant le répertoire « /home/thierry/download/emacs-23/src »
> | make: *** [src] Erreur 2
> `----

Sorry, you can try this _only_ with the trunk.

martin

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

martin rudalics <rudalics@gmx.at> writes:

>> I have applied your changes, but now it fail to compile:
>>
>> ,----
>> | window.c:81: error: static declaration of ‘foreach_window’ follows non-static declaration
>> | window.h:799: note: previous declaration of ‘foreach_window’ was here
>> | window.c: In function ‘Fcoordinates_in_window_p’:
>> | window.c:1011: error: ‘Qleft_margin’ undeclared (first use in this function)
>> | window.c:1011: error: (Each undeclared identifier is reported only once
>> | window.c:1011: error: for each function it appears in.)
>> | window.c:1014: error: ‘Qright_margin’ undeclared (first use in this function)
>> | window.c: At top level:
>> | window.c:1080: error: conflicting types for ‘window_from_coordinates’
>> | window.h:787: note: previous declaration of ‘window_from_coordinates’ was here
>> | window.c:1436: error: static declaration of ‘delete_window’ follows non-static declaration
>> | window.h:786: note: previous declaration of ‘delete_window’ was here
>> | window.c:3982: error: static declaration of ‘window_height’ follows non-static declaration
>> | window.h:791: note: previous declaration of ‘window_height’ was here
>> | window.c:3989: error: static declaration of ‘window_width’ follows non-static declaration
>> | window.h:792: note: previous declaration of ‘window_width’ was here
>> | make[1]: *** [window.o] Erreur 1
>> | make[1]: quittant le répertoire « /home/thierry/download/emacs-23/src »
>> | make: *** [src] Erreur 2
>> `----
>
> Sorry, you can try this _only_ with the trunk.
Ah ok, so on the trunk it work fine.

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[Simon Leinen]

[-- Attachment #1: Type: text/plain, Size: 131 bytes --]

Here's a variant of Martin's patch adapted to emacs-23.2.92, i.e. the
current pretest.  From what I can tell, it works.
-- 
Simon.

[-- Attachment #2: martin-rudalics-src-window.c.diff --]
[-- Type: application/octet-stream, Size: 5041 bytes --]

*** src/window.c.orig	2011-01-15 03:53:58.000000000 +0100
--- src/window.c	2011-01-18 12:59:38.000000000 +0100
***************
*** 85,90 ****
--- 85,91 ----
  				 int (* fn) (struct window *, void *),
  				 void *));
  static Lisp_Object window_list_1 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+ static Lisp_Object select_window _P ((Lisp_Object, Lisp_Object, int));
  
  /* This is the window in which the terminal's cursor should
     be left when nothing is being done with it.  This must
***************
*** 158,168 ****
  
  static int window_initialized;
  
- /* Set in `set-window-configuration' to prevent "swapping out point"
-    in the old selected window.  */
- 
- static int inhibit_point_swap;
- 
  /* Hook to run when window config changes.  */
  
  static Lisp_Object Qwindow_configuration_change_hook;
--- 159,164 ----
***************
*** 3584,3605 ****
    set_window_buffer (window, buffer, 1, !NILP (keep_margins));
    return Qnil;
  }
  
! /* Note that selected_window can be nil when this is called from
!    Fset_window_configuration.  */
! 
! DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
!        doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
! If WINDOW is not already selected, make WINDOW's buffer current
! and make WINDOW the frame's selected window.  Return WINDOW.
! Optional second arg NORECORD non-nil means do not put this buffer
! at the front of the list of recently selected ones and do not
! make this window the most recently selected one.
! 
! Note that the main editor command loop selects the buffer of the
! selected window before each command.  */)
!      (window, norecord)
!      register Lisp_Object window, norecord;
  {
    register struct window *w;
    register struct window *ow;
--- 3580,3595 ----
    set_window_buffer (window, buffer, 1, !NILP (keep_margins));
    return Qnil;
  }
+   
+   
+ /* If select_window is called with inhibit_point_swap non-zero it will
+    not store point of the old selected window's buffer back into that
+    window's pointm slot.  This is needed by Fset_window_configuration to
+    avoid that the display routine is called with selected_window set to
+    Qnil causing a subsequent crash.  */
  
! static Lisp_Object
! select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
  {
    register struct window *w;
    register struct window *ow;
***************
*** 3638,3646 ****
    /* Store the current buffer's actual point into the
       old selected window.  It belongs to that window,
       and when the window is not selected, must be in the window.  */
!   if (inhibit_point_swap)
!     inhibit_point_swap = 0;
!   else
      {
        ow = XWINDOW (selected_window);
        if (! NILP (ow->buffer))
--- 3628,3634 ----
    /* Store the current buffer's actual point into the
       old selected window.  It belongs to that window,
       and when the window is not selected, must be in the window.  */
!   if (! inhibit_point_swap)
      {
        ow = XWINDOW (selected_window);
        if (! NILP (ow->buffer))
***************
*** 3676,3681 ****
--- 3664,3684 ----
    return window;
  }
  
+ DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
+        doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
+ If WINDOW is not already selected, make WINDOW's buffer current
+ and make WINDOW the frame's selected window.  Return WINDOW.
+ Optional second arg NORECORD non-nil means do not put this buffer
+ at the front of the list of recently selected ones and do not
+ make this window the most recently selected one.
+ 
+ Note that the main editor command loop selects the buffer of the
+ selected window before each command.  */)
+   (register Lisp_Object window, Lisp_Object norecord)
+ {
+   select_window (window, norecord, 0);
+ }
+ 
  static Lisp_Object
  select_window_norecord (window)
       Lisp_Object window;
***************
*** 6255,6262 ****
  	 out point" in the old selected window using the buffer that
  	 has been restored into it.  We already swapped out that point
  	 from that window's old buffer.  */
!       inhibit_point_swap = 1;
!       Fselect_window (data->current_window, Qnil);
        XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
  	= selected_window;
  
--- 6258,6264 ----
  	 out point" in the old selected window using the buffer that
  	 has been restored into it.  We already swapped out that point
  	 from that window's old buffer.  */
!       select_window (data->current_window, Qnil, 1);
        XBUFFER (XWINDOW (selected_window)->buffer)->last_selected_window
  	= selected_window;
  
***************
*** 7214,7221 ****
    window_scroll_preserve_hpos = -1;
    window_scroll_preserve_vpos = -1;
  
-   inhibit_point_swap = 0;
- 
    DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function,
  	       doc: /* Non-nil means call as function to display a help buffer.
  The function is called with one argument, the buffer to be displayed.
--- 7216,7221 ----

Re: bug in 23.2.92 with anything

[Eli Zaretskii]

> From: Thierry Volpiatto <thierry.volpiatto@gmail.com>
> Date: Tue, 18 Jan 2011 09:55:41 +0100
> Cc: Chong Yidong <cyd@stupidchicken.com>, emacs-devel@gnu.org
> 
> >> It still doesn't apply correctly, could you make a patch in git style on
> >> top of:(i use a git repo)
> >
> > If I knew how to do that :-(
> See git-diff section generating patch with -p option and
> git-format-patch.
> I think bzr do that also but i don't know how.

Maybe you should start using bzr?

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

Eli Zaretskii <eliz@gnu.org> writes:

>> From: Thierry Volpiatto <thierry.volpiatto@gmail.com>
>> Date: Tue, 18 Jan 2011 09:55:41 +0100
>> Cc: Chong Yidong <cyd@stupidchicken.com>, emacs-devel@gnu.org
>> 
>> >> It still doesn't apply correctly, could you make a patch in git style on
>> >> top of:(i use a git repo)
>> >
>> > If I knew how to do that :-(
>> See git-diff section generating patch with -p option and
>> git-format-patch.
>> I think bzr do that also but i don't know how.
>
> Maybe you should start using bzr?
No i prefer using hg or git.
I use mostly queued patchs with hg q extension or if needed stgit.
I don't think bzr have queued patchs extension, does it?
Anyway, i always had bad experience with bzr.

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[Eli Zaretskii]

> From: Thierry Volpiatto <thierry.volpiatto@gmail.com>
> Cc: rudalics@gmx.at,  cyd@stupidchicken.com,  emacs-devel@gnu.org
> Date: Tue, 18 Jan 2011 16:50:33 +0100
> 
> I use mostly queued patchs with hg q extension or if needed stgit.
> I don't think bzr have queued patchs extension, does it?

If you explain what that is, I (or someone else) might be able to
answer.

> Anyway, i always had bad experience with bzr.

When was the last time?  Maybe its time to try again?

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

Eli Zaretskii <eliz@gnu.org> writes:

>> From: Thierry Volpiatto <thierry.volpiatto@gmail.com>
>> Cc: rudalics@gmx.at,  cyd@stupidchicken.com,  emacs-devel@gnu.org
>> Date: Tue, 18 Jan 2011 16:50:33 +0100
>> 
>> I use mostly queued patchs with hg q extension or if needed stgit.
>> I don't think bzr have queued patchs extension, does it?
>
> If you explain what that is, I (or someone else) might be able to
> answer.
Better than a bad explanation, read this:
http://hgbook.red-bean.com/read/managing-change-with-mercurial-queues.html

>> Anyway, i always had bad experience with bzr.
>
> When was the last time?  Maybe its time to try again?
I tried to use it 2 years ago to work on DVC but finally i gave up and
start using hg qpatchs.
 
-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[David De La Harpe Golden]

On 18/01/11 15:52, Eli Zaretskii wrote:
>> From: Thierry Volpiatto<thierry.volpiatto@gmail.com>
>> Cc: rudalics@gmx.at,  cyd@stupidchicken.com,  emacs-devel@gnu.org
>> Date: Tue, 18 Jan 2011 16:50:33 +0100
>>
>> I use mostly queued patchs with hg q extension or if needed stgit.
>> I don't think bzr have queued patchs extension, does it?
>
> If you explain what that is, I (or someone else) might be able to
> answer.
>

He presumably means quilt [1] type functionality - management of a stack 
of patches.  The original quilt had no VCS integration in particular, so 
there are quilt work-sorta-alikes for various modern VCSs, such as stgit 
for git [2] and the mercurial queue extension [3]

Anyway, just searching, looks to me like bzr loom [4][5][6] is the 
bzr-land quilt-oid (or at least is usable as one). But I've never used 
it myself, don't really know how it compares or if there are any other 
alternatives.

[1] http://savannah.nongnu.org/projects/quilt
[2] http://www.procode.org/stgit/
[3] http://mercurial.selenic.com/wiki/MqExtension
[4] https://launchpad.net/bzr-loom
[5] http://wiki.bazaar.canonical.com/Documentation/LoomAsSmarterQuilt
[6] http://blogs.gnome.org/jamesh/2008/04/01/bzr-loom/

Re: bug in 23.2.92 with anything

[Thierry Volpiatto]

David De La Harpe Golden <david@harpegolden.net> writes:

> On 18/01/11 15:52, Eli Zaretskii wrote:
>>> From: Thierry Volpiatto<thierry.volpiatto@gmail.com>
>>> Cc: rudalics@gmx.at,  cyd@stupidchicken.com,  emacs-devel@gnu.org
>>> Date: Tue, 18 Jan 2011 16:50:33 +0100
>>>
>>> I use mostly queued patchs with hg q extension or if needed stgit.
>>> I don't think bzr have queued patchs extension, does it?
>>
>> If you explain what that is, I (or someone else) might be able to
>> answer.
>>
>
> He presumably means quilt [1] type functionality - management of a
> stack of patches.  The original quilt had no VCS integration in
> particular, so there are quilt work-sorta-alikes for various modern
> VCSs, such as stgit for git [2] and the mercurial queue extension [3]
Yes exactly.

> Anyway, just searching, looks to me like bzr loom [4][5][6] is the
> bzr-land quilt-oid (or at least is usable as one). But I've never used
> it myself, don't really know how it compares or if there are any other
> alternatives.
Thanks for the link.
After a quick look, it seem bzr-loom is quite different of hg qpatch or
stgit, more complex to use, and not as flexible as hg or stg.


> [1] http://savannah.nongnu.org/projects/quilt
> [2] http://www.procode.org/stgit/
> [3] http://mercurial.selenic.com/wiki/MqExtension
> [4] https://launchpad.net/bzr-loom
> [5] http://wiki.bazaar.canonical.com/Documentation/LoomAsSmarterQuilt
> [6] http://blogs.gnome.org/jamesh/2008/04/01/bzr-loom/
>

-- 
A+ Thierry
Get my Gnupg key:
gpg --keyserver pgp.mit.edu --recv-keys 59F29997 

Re: bug in 23.2.92 with anything

[Eli Zaretskii]

> From: Thierry Volpiatto <thierry.volpiatto@gmail.com>
> Cc: Eli Zaretskii <eliz@gnu.org>,  rudalics@gmx.at,  cyd@stupidchicken.com,  emacs-devel@gnu.org
> Date: Thu, 20 Jan 2011 08:37:38 +0100
> 
> After a quick look, it seem bzr-loom is quite different of hg qpatch or
> stgit, more complex to use, and not as flexible as hg or stg.

How predictable.

Re: bug in 23.2.92 with anything

[Stephen J. Turnbull]

Eli Zaretskii writes:
 > > From: Thierry Volpiatto <thierry.volpiatto@gmail.com>
 > > Cc: Eli Zaretskii <eliz@gnu.org>,  rudalics@gmx.at,  cyd@stupidchicken.com,  emacs-devel@gnu.org
 > > Date: Thu, 20 Jan 2011 08:37:38 +0100
 > > 
 > > After a quick look, it seem bzr-loom is quite different of hg qpatch or
 > > stgit, more complex to use, and not as flexible as hg or stg.
 > 
 > How predictable.

Besides looms (by Robert Collins), Aaron Bentley has something called
"pipelines" for bzr that look more like Mercurial queues.

FWIW, a few people I really really respect (besides Robert Collins, of
course he thinks it's great!) think looms are great, and easy to use
(once you get used to them, but I don't know how hard that is).  I
don't know much about pipelines, though.

ISTM that the big problem is "breaking the ice": if somebody learns
how to use them and writes a blog entry or two, you can achieve
critical mass.

Personally-I-love-and-strongly-prefer-to-use-git-ly y'rs,

Re: bug in 23.2.92 with anything

[Chong Yidong]

Simon Leinen <simon.leinen@gmail.com> writes:

> Here's a variant of Martin's patch adapted to emacs-23.2.92, i.e. the
> current pretest.  From what I can tell, it works.

Thanks, applied to the emacs-23 branch.