Handle window-height and window-width alist entries in `display-buffer'.

[gnu-emacs] / src / window.c

diff --git a/src/window.c b/src/window.c
index 912eb04f489cc4a5571be640a5aaf917f3a51186..bb3b73f9acdd662eb8c3b3307719ab5d3294d03a 100644 (file)
--- a/src/window.c
+++ b/src/window.c
@@ -19,8 +19,10 @@ You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>

+
+#define WINDOW_INLINE EXTERN_INLINE
+

 #include <stdio.h>
 #include <stdio.h>

-#include <setjmp.h>

 
 #include "lisp.h"
 #include "character.h"
 
 #include "lisp.h"
 #include "character.h"


@@ -52,16 +54,15 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 Lisp_Object Qwindowp, Qwindow_live_p;
 #endif
 
 Lisp_Object Qwindowp, Qwindow_live_p;

+static Lisp_Object Qwindow_valid_p;

 static Lisp_Object Qwindow_configuration_p, Qrecord_window_buffer;
 static Lisp_Object Qwindow_deletable_p, Qdelete_window, Qdisplay_buffer;
 static Lisp_Object Qreplace_buffer_in_windows, Qget_mru_window;
 static Lisp_Object Qwindow_resize_root_window, Qwindow_resize_root_window_vertically;
 static Lisp_Object Qscroll_up, Qscroll_down, Qscroll_command;
 static Lisp_Object Qwindow_configuration_p, Qrecord_window_buffer;
 static Lisp_Object Qwindow_deletable_p, Qdelete_window, Qdisplay_buffer;
 static Lisp_Object Qreplace_buffer_in_windows, Qget_mru_window;
 static Lisp_Object Qwindow_resize_root_window, Qwindow_resize_root_window_vertically;
 static Lisp_Object Qscroll_up, Qscroll_down, Qscroll_command;

-static Lisp_Object Qsafe, Qabove, Qbelow;
-static Lisp_Object Qauto_buffer_name, Qclone_of;
+static Lisp_Object Qsafe, Qabove, Qbelow, Qwindow_size, Qclone_of;

 
 static int displayed_window_lines (struct window *);
 
 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, EMACS_INT, int, int);
 static int count_windows (struct window *);
 static int get_leaf_windows (struct window *, struct window **, int);
 static void window_scroll (Lisp_Object, EMACS_INT, int, int);


@@ -131,8 +132,110 @@ static int window_scroll_pixel_based_preserve_y;
 static EMACS_INT window_scroll_preserve_hpos;
 static EMACS_INT window_scroll_preserve_vpos;
 \f
 static EMACS_INT window_scroll_preserve_hpos;
 static EMACS_INT window_scroll_preserve_vpos;
 \f

-static struct window *
-decode_window (register Lisp_Object window)
+/* These setters are used only in this file, so they can be private.  */
+static inline void
+wset_combination_limit (struct window *w, Lisp_Object val)
+{
+  w->combination_limit = val;
+}
+static inline void
+wset_dedicated (struct window *w, Lisp_Object val)
+{
+  w->dedicated = val;
+}
+static inline void
+wset_display_table (struct window *w, Lisp_Object val)
+{
+  w->display_table = val;
+}
+static inline void
+wset_hchild (struct window *w, Lisp_Object val)
+{
+  w->hchild = val;
+}
+static inline void
+wset_left_fringe_width (struct window *w, Lisp_Object val)
+{
+  w->left_fringe_width = val;
+}
+static inline void
+wset_left_margin_cols (struct window *w, Lisp_Object val)
+{
+  w->left_margin_cols = val;
+}
+static inline void
+wset_new_normal (struct window *w, Lisp_Object val)
+{
+  w->new_normal = val;
+}
+static inline void
+wset_new_total (struct window *w, Lisp_Object val)
+{
+  w->new_total = val;
+}
+static inline void
+wset_normal_cols (struct window *w, Lisp_Object val)
+{
+  w->normal_cols = val;
+}
+static inline void
+wset_normal_lines (struct window *w, Lisp_Object val)
+{
+  w->normal_lines = val;
+}
+static inline void
+wset_parent (struct window *w, Lisp_Object val)
+{
+  w->parent = val;
+}
+static inline void
+wset_pointm (struct window *w, Lisp_Object val)
+{
+  w->pointm = val;
+}
+static inline void
+wset_right_fringe_width (struct window *w, Lisp_Object val)
+{
+  w->right_fringe_width = val;
+}
+static inline void
+wset_right_margin_cols (struct window *w, Lisp_Object val)
+{
+  w->right_margin_cols = val;
+}
+static inline void
+wset_scroll_bar_width (struct window *w, Lisp_Object val)
+{
+  w->scroll_bar_width = val;
+}
+static inline void
+wset_start (struct window *w, Lisp_Object val)
+{
+  w->start = val;
+}
+static inline void
+wset_temslot (struct window *w, Lisp_Object val)
+{
+  w->temslot = val;
+}
+static inline void
+wset_vchild (struct window *w, Lisp_Object val)
+{
+  w->vchild = val;
+}
+static inline void
+wset_vertical_scroll_bar_type (struct window *w, Lisp_Object val)
+{
+  w->vertical_scroll_bar_type = val;
+}
+static inline void
+wset_window_parameters (struct window *w, Lisp_Object val)
+{
+  w->window_parameters = val;
+}
+
+struct window *
+decode_live_window (register Lisp_Object window)

 {
   if (NILP (window))
     return XWINDOW (selected_window);
 {
   if (NILP (window))
     return XWINDOW (selected_window);


@@ -151,8 +254,19 @@ decode_any_window (register Lisp_Object window)
 
   CHECK_WINDOW (window);
   w = XWINDOW (window);
 
   CHECK_WINDOW (window);
   w = XWINDOW (window);

-  /* The following test throws up every time a tooltip frame is displayed.  */
-  /* CHECK_LIVE_FRAME (w->frame); */
+  return w;
+}
+
+static struct window *
+decode_valid_window (register Lisp_Object window)
+{
+  struct window *w;
+
+  if (NILP (window))
+    return XWINDOW (selected_window);
+
+  CHECK_VALID_WINDOW (window);
+  w = XWINDOW (window);

   return w;
 }
 
   return w;
 }
 


@@ -163,6 +277,15 @@ DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
   return WINDOWP (object) ? Qt : Qnil;
 }
 
   return WINDOWP (object) ? Qt : Qnil;
 }
 

+DEFUN ("window-valid-p", Fwindow_valid_p, Swindow_valid_p, 1, 1, 0,
+       doc: /* Return t if OBJECT is a valid window and nil otherwise.
+A valid window is either a window that displays a buffer or an internal
+window.  Deleted windows are not live.  */)
+  (Lisp_Object object)
+{
+  return WINDOW_VALID_P (object) ? Qt : Qnil;
+}
+

 DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a live window and nil otherwise.
 A live window is a window that displays a buffer.
 DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a live window and nil otherwise.
 A live window is a window that displays a buffer.


@@ -175,10 +298,10 @@ Internal windows and deleted windows are not live.  */)
 /* Frames and windows.  */
 DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
        doc: /* Return the frame that window WINDOW is on.
 /* Frames and windows.  */
 DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
        doc: /* Return the frame that window WINDOW is on.

-If WINDOW is omitted or nil, it defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), frame);
+  return decode_valid_window (window)->frame;

 }
 
 DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
 }
 
 DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,


@@ -192,8 +315,8 @@ With a window argument, return the root window of that window's frame.  */)
 
   if (NILP (frame_or_window))
     window = SELECTED_FRAME ()->root_window;
 
   if (NILP (frame_or_window))
     window = SELECTED_FRAME ()->root_window;

-  else if (WINDOWP (frame_or_window))
-    window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->root_window;
+  else if (WINDOW_VALID_P (frame_or_window))
+      window = XFRAME (XWINDOW (frame_or_window)->frame)->root_window;

   else
     {
       CHECK_LIVE_FRAME (frame_or_window);
   else
     {
       CHECK_LIVE_FRAME (frame_or_window);


@@ -217,18 +340,18 @@ If FRAME is omitted or nil, it defaults to the selected frame.  */)
 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p,
        Swindow_minibuffer_p, 0, 1, 0,
        doc: /* Return non-nil if WINDOW is a minibuffer window.
 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p,
        Swindow_minibuffer_p, 0, 1, 0,
        doc: /* Return non-nil if WINDOW is a minibuffer window.

-If WINDOW is omitted or nil, it defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  return MINI_WINDOW_P (decode_any_window (window)) ? Qt : Qnil;
+  return MINI_WINDOW_P (decode_valid_window (window)) ? Qt : Qnil;

 }
 
 /* Don't move this to window.el - this must be a safe routine.  */
 DEFUN ("frame-first-window", Fframe_first_window, Sframe_first_window, 0, 1, 0,
        doc: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
 }
 
 /* Don't move this to window.el - this must be a safe routine.  */
 DEFUN ("frame-first-window", Fframe_first_window, Sframe_first_window, 0, 1, 0,
        doc: /* Return the topmost, leftmost live window on FRAME-OR-WINDOW.
 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.

-Else if FRAME-OR-WINDOW denotes any window, return the first window of
-that window's frame.  If FRAME-OR-WINDOW denotes a live frame, return
+Else if FRAME-OR-WINDOW denotes a valid window, return the first window
+of that window's frame.  If FRAME-OR-WINDOW denotes a live frame, return

 the first window of that frame.  */)
   (Lisp_Object frame_or_window)
 {
 the first window of that frame.  */)
   (Lisp_Object frame_or_window)
 {


@@ -236,7 +359,7 @@ the first window of that frame.  */)
 
   if (NILP (frame_or_window))
     window = SELECTED_FRAME ()->root_window;
 
   if (NILP (frame_or_window))
     window = SELECTED_FRAME ()->root_window;

-  else if (WINDOWP (frame_or_window))
+  else if (WINDOW_VALID_P (frame_or_window))

     window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->root_window;
   else
     {
     window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->root_window;
   else
     {


@@ -244,14 +367,14 @@ the first window of that frame.  */)
       window = XFRAME (frame_or_window)->root_window;
     }
 
       window = XFRAME (frame_or_window)->root_window;
     }
 

-  while (NILP (WGET (XWINDOW (window), buffer)))
+  while (NILP (XWINDOW (window)->buffer))

     {
     {

-      if (! NILP (WGET (XWINDOW (window), hchild)))
-       window = WGET (XWINDOW (window), hchild);
-      else if (! NILP (WGET (XWINDOW (window), vchild)))
-       window = WGET (XWINDOW (window), vchild);
+      if (! NILP (XWINDOW (window)->hchild))
+       window = XWINDOW (window)->hchild;
+      else if (! NILP (XWINDOW (window)->vchild))
+       window = XWINDOW (window)->vchild;

       else
       else

-       abort ();
+       emacs_abort ();

     }
 
   return window;
     }
 
   return window;


@@ -261,16 +384,16 @@ DEFUN ("frame-selected-window", Fframe_selected_window,
        Sframe_selected_window, 0, 1, 0,
        doc: /* Return the selected window of FRAME-OR-WINDOW.
 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
        Sframe_selected_window, 0, 1, 0,
        doc: /* Return the selected window of FRAME-OR-WINDOW.
 If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.

-Else if FRAME-OR-WINDOW denotes any window, return the selected window
-of that window's frame.  If FRAME-OR-WINDOW denotes a live frame, return
-the selected window of that frame.  */)
+Else if FRAME-OR-WINDOW denotes a valid window, return the selected
+window of that window's frame.  If FRAME-OR-WINDOW denotes a live frame,
+return the selected window of that frame.  */)

   (Lisp_Object frame_or_window)
 {
   Lisp_Object window;
 
   if (NILP (frame_or_window))
     window = SELECTED_FRAME ()->selected_window;
   (Lisp_Object frame_or_window)
 {
   Lisp_Object window;
 
   if (NILP (frame_or_window))
     window = SELECTED_FRAME ()->selected_window;

-  else if (WINDOWP (frame_or_window))
+  else if (WINDOW_VALID_P (frame_or_window))

     window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->selected_window;
   else
     {
     window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->selected_window;
   else
     {


@@ -303,7 +426,10 @@ Return WINDOW.  */)
   if (EQ (frame, selected_frame))
     return Fselect_window (window, norecord);
   else
   if (EQ (frame, selected_frame))
     return Fselect_window (window, norecord);
   else

-    return FSET (XFRAME (frame), selected_window, window);
+    {
+      fset_selected_window (XFRAME (frame), window);
+      return window;
+    }

 }
 
 DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
 }
 
 DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,


@@ -337,16 +463,19 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
   if (NILP (norecord))
     {
       w->use_time = ++window_select_count;
   if (NILP (norecord))
     {
       w->use_time = ++window_select_count;

-      record_buffer (WGET (w, buffer));
+      record_buffer (w->buffer);

     }
 
     }
 

+  /* Make the selected window's buffer current.  */
+  Fset_buffer (w->buffer);
+

   if (EQ (window, selected_window) && !inhibit_point_swap)
     return window;
 
   sf = SELECTED_FRAME ();
   if (XFRAME (WINDOW_FRAME (w)) != sf)
     {
   if (EQ (window, selected_window) && !inhibit_point_swap)
     return window;
 
   sf = SELECTED_FRAME ();
   if (XFRAME (WINDOW_FRAME (w)) != sf)
     {

-      FSET (XFRAME (WINDOW_FRAME (w)), selected_window, window);
+      fset_selected_window (XFRAME (WINDOW_FRAME (w)), 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
       /* 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


@@ -357,25 +486,22 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
       return window;
     }
   else
       return window;
     }
   else

-    FSET (sf, selected_window, window);
+    fset_selected_window (sf, window);

 
 

-  /* 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.  */
+  /* Store the old selected window's buffer's point in pointm of 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 (!inhibit_point_swap)
     {
       ow = XWINDOW (selected_window);

-      if (! NILP (WGET (ow, buffer)))
-       set_marker_both (WGET (ow, pointm), WGET (ow, buffer),
-                        BUF_PT (XBUFFER (WGET (ow, buffer))),
-                        BUF_PT_BYTE (XBUFFER (WGET (ow, buffer))));
+      if (! NILP (ow->buffer))
+       set_marker_both (ow->pointm, ow->buffer,
+                        BUF_PT (XBUFFER (ow->buffer)),
+                        BUF_PT_BYTE (XBUFFER (ow->buffer)));

     }
 
   selected_window = window;
     }
 
   selected_window = window;

-
-  Fset_buffer (WGET (w, buffer));
-
-  BVAR (XBUFFER (WGET (w, buffer)), last_selected_window) = window;
+  bset_last_selected_window (XBUFFER (w->buffer), window);

 
   /* Go to the point recorded in the window.
      This is important when the buffer is in more
 
   /* Go to the point recorded in the window.
      This is important when the buffer is in more


@@ -383,7 +509,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
      redisplay_window has altered point after scrolling,
      because it makes the change only in the window.  */
   {
      redisplay_window has altered point after scrolling,
      because it makes the change only in the window.  */
   {

-    register ptrdiff_t new_point = marker_position (WGET (w, pointm));
+    register ptrdiff_t new_point = marker_position (w->pointm);

     if (new_point < BEGV)
       SET_PT (BEGV);
     else if (new_point > ZV)
     if (new_point < BEGV)
       SET_PT (BEGV);
     else if (new_point > ZV)


@@ -418,93 +544,98 @@ If WINDOW is omitted or nil, it defaults to the selected window.
 Return nil for an internal window or a deleted window.  */)
   (Lisp_Object window)
 {
 Return nil for an internal window or a deleted window.  */)
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), buffer);
+  return decode_any_window (window)->buffer;

 }
 
 DEFUN ("window-parent", Fwindow_parent, Swindow_parent, 0, 1, 0,
        doc: /* Return the parent window of window WINDOW.
 }
 
 DEFUN ("window-parent", Fwindow_parent, Swindow_parent, 0, 1, 0,
        doc: /* Return the parent window of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.

 Return nil for a window with no parent (e.g. a root window).  */)
   (Lisp_Object window)
 {
 Return nil for a window with no parent (e.g. a root window).  */)
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), parent);
+  return decode_valid_window (window)->parent;

 }
 
 DEFUN ("window-top-child", Fwindow_top_child, Swindow_top_child, 1, 1, 0,
        doc: /* Return the topmost child window of window WINDOW.
 }
 
 DEFUN ("window-top-child", Fwindow_top_child, Swindow_top_child, 1, 1, 0,
        doc: /* Return the topmost child window of window WINDOW.

+WINDOW must be a valid window and defaults to the selected one.

 Return nil if WINDOW is a live window (live windows have no children).
 Return nil if WINDOW is an internal window whose children form a
 horizontal combination.  */)
   (Lisp_Object window)
 {
   CHECK_WINDOW (window);
 Return nil if WINDOW is a live window (live windows have no children).
 Return nil if WINDOW is an internal window whose children form a
 horizontal combination.  */)
   (Lisp_Object window)
 {
   CHECK_WINDOW (window);

-  return WGET (decode_any_window (window), vchild);
+  return decode_valid_window (window)->vchild;

 }
 
 DEFUN ("window-left-child", Fwindow_left_child, Swindow_left_child, 1, 1, 0,
        doc: /* Return the leftmost child window of window WINDOW.
 }
 
 DEFUN ("window-left-child", Fwindow_left_child, Swindow_left_child, 1, 1, 0,
        doc: /* Return the leftmost child window of window WINDOW.

+WINDOW must be a valid window and defaults to the selected one.

 Return nil if WINDOW is a live window (live windows have no children).
 Return nil if WINDOW is an internal window whose children form a
 vertical combination.  */)
   (Lisp_Object window)
 {
   CHECK_WINDOW (window);
 Return nil if WINDOW is a live window (live windows have no children).
 Return nil if WINDOW is an internal window whose children form a
 vertical combination.  */)
   (Lisp_Object window)
 {
   CHECK_WINDOW (window);

-  return WGET (decode_any_window (window), hchild);
+  return decode_valid_window (window)->hchild;

 }
 
 DEFUN ("window-next-sibling", Fwindow_next_sibling, Swindow_next_sibling, 0, 1, 0,
        doc: /* Return the next sibling window of window WINDOW.
 }
 
 DEFUN ("window-next-sibling", Fwindow_next_sibling, Swindow_next_sibling, 0, 1, 0,
        doc: /* Return the next sibling window of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.

 Return nil if WINDOW has no next sibling.  */)
   (Lisp_Object window)
 {
 Return nil if WINDOW has no next sibling.  */)
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), next);
+  return decode_valid_window (window)->next;

 }
 
 DEFUN ("window-prev-sibling", Fwindow_prev_sibling, Swindow_prev_sibling, 0, 1, 0,
        doc: /* Return the previous sibling window of window WINDOW.
 }
 
 DEFUN ("window-prev-sibling", Fwindow_prev_sibling, Swindow_prev_sibling, 0, 1, 0,
        doc: /* Return the previous sibling window of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.

 Return nil if WINDOW has no previous sibling.  */)
   (Lisp_Object window)
 {
 Return nil if WINDOW has no previous sibling.  */)
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), prev);
+  return decode_valid_window (window)->prev;

 }
 
 DEFUN ("window-combination-limit", Fwindow_combination_limit, Swindow_combination_limit, 1, 1, 0,
        doc: /* Return combination limit of window WINDOW.
 }
 
 DEFUN ("window-combination-limit", Fwindow_combination_limit, Swindow_combination_limit, 1, 1, 0,
        doc: /* Return combination limit of window WINDOW.

+WINDOW must be a valid window and defaults to the selected one.

 If the return value is nil, child windows of WINDOW can be recombined with
 WINDOW's siblings.  A return value of t means that child windows of
 WINDOW are never \(re-)combined with WINDOW's siblings.  */)
   (Lisp_Object window)
 {
 If the return value is nil, child windows of WINDOW can be recombined with
 WINDOW's siblings.  A return value of t means that child windows of
 WINDOW are never \(re-)combined with WINDOW's siblings.  */)
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), combination_limit);
+  return decode_valid_window (window)->combination_limit;

 }
 
 DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
        doc: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
 }
 
 DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
        doc: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.

-If LIMIT is nil, child windows of WINDOW can be recombined with
-WINDOW's siblings.  LIMIT t means that child windows of WINDOW are
-never \(re-)combined with WINDOW's siblings.  Other values are reserved
-for future use.  */)
+WINDOW must be a valid window and defaults to the selected one.
+If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
+siblings.  LIMIT t means that child windows of WINDOW are never
+\(re-)combined with WINDOW's siblings.  Other values are reserved for
+future use.  */)

   (Lisp_Object window, Lisp_Object limit)
 {
   (Lisp_Object window, Lisp_Object limit)
 {

-  return WSET (decode_any_window (window), combination_limit, limit);
+  wset_combination_limit (decode_valid_window (window), limit);
+  return limit;

 }
 
 DEFUN ("window-use-time", Fwindow_use_time, Swindow_use_time, 0, 1, 0,
        doc: /* Return the use time of window WINDOW.
 }
 
 DEFUN ("window-use-time", Fwindow_use_time, Swindow_use_time, 0, 1, 0,
        doc: /* Return the use time of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.

 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)
 {
 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 make_number (decode_window (window)->use_time);
+  return make_number (decode_live_window (window)->use_time);

 }
 \f
 DEFUN ("window-total-height", Fwindow_total_height, Swindow_total_height, 0, 1, 0,
        doc: /* Return the total height, in lines, of window WINDOW.
 }
 \f
 DEFUN ("window-total-height", Fwindow_total_height, Swindow_total_height, 0, 1, 0,
        doc: /* Return the total height, in lines, of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.

 
 The return value includes the mode line and header line, if any.
 If WINDOW is an internal window, the total height is the height
 
 The return value includes the mode line and header line, if any.
 If WINDOW is an internal window, the total height is the height


@@ -514,12 +645,12 @@ On a graphical display, this total height is reported as an
 integer multiple of the default character height.  */)
   (Lisp_Object window)
 {
 integer multiple of the default character height.  */)
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), total_lines);
+  return decode_valid_window (window)->total_lines;

 }
 
 DEFUN ("window-total-width", Fwindow_total_width, Swindow_total_width, 0, 1, 0,
        doc: /* Return the total width, in columns, of window WINDOW.
 }
 
 DEFUN ("window-total-width", Fwindow_total_width, Swindow_total_width, 0, 1, 0,
        doc: /* Return the total width, in columns, of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.

 
 The return value includes any vertical dividers or scroll bars
 belonging to WINDOW.  If WINDOW is an internal window, the total width
 
 The return value includes any vertical dividers or scroll bars
 belonging to WINDOW.  If WINDOW is an internal window, the total width


@@ -529,35 +660,34 @@ On a graphical display, this total width is reported as an
 integer multiple of the default character width.  */)
   (Lisp_Object window)
 {
 integer multiple of the default character width.  */)
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), total_cols);
+  return decode_valid_window (window)->total_cols;

 }
 
 DEFUN ("window-new-total", Fwindow_new_total, Swindow_new_total, 0, 1, 0,
        doc: /* Return the new total size of window WINDOW.
 }
 
 DEFUN ("window-new-total", Fwindow_new_total, Swindow_new_total, 0, 1, 0,
        doc: /* Return the new total size of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.   */)
+WINDOW must be a valid window and defaults to the selected one.  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), new_total);
+  return decode_valid_window (window)->new_total;

 }
 
 DEFUN ("window-normal-size", Fwindow_normal_size, Swindow_normal_size, 0, 2, 0,
        doc: /* Return the normal height of window WINDOW.
 }
 
 DEFUN ("window-normal-size", Fwindow_normal_size, Swindow_normal_size, 0, 2, 0,
        doc: /* Return the normal height of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a valid window and defaults to the selected one.

 If HORIZONTAL is non-nil, return the normal width of WINDOW.  */)
   (Lisp_Object window, Lisp_Object horizontal)
 {
 If HORIZONTAL is non-nil, return the normal width of WINDOW.  */)
   (Lisp_Object window, Lisp_Object horizontal)
 {

-  if (NILP (horizontal))
-    return WGET (decode_any_window (window), normal_lines);
-  else
-    return WGET (decode_any_window (window), normal_cols);
+  struct window *w = decode_valid_window (window);
+
+  return NILP (horizontal) ? w->normal_lines : w->normal_cols;

 }
 
 DEFUN ("window-new-normal", Fwindow_new_normal, Swindow_new_normal, 0, 1, 0,
        doc: /* Return new normal size of window WINDOW.
 }
 
 DEFUN ("window-new-normal", Fwindow_new_normal, Swindow_new_normal, 0, 1, 0,
        doc: /* Return new normal size of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), new_normal);
+  return decode_valid_window (window)->new_normal;

 }
 
 DEFUN ("window-left-column", Fwindow_left_column, Swindow_left_column, 0, 1, 0,
 }
 
 DEFUN ("window-left-column", Fwindow_left_column, Swindow_left_column, 0, 1, 0,


@@ -566,10 +696,10 @@ This is the distance, in columns, between the left edge of WINDOW and
 the left edge of the frame's window area.  For instance, the return
 value is 0 if there is no window to the left of WINDOW.
 
 the left edge of the frame's window area.  For instance, the return
 value is 0 if there is no window to the left of WINDOW.
 

-If WINDOW is omitted or nil, it defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), left_col);
+  return decode_valid_window (window)->left_col;

 }
 
 DEFUN ("window-top-line", Fwindow_top_line, Swindow_top_line, 0, 1, 0,
 }
 
 DEFUN ("window-top-line", Fwindow_top_line, Swindow_top_line, 0, 1, 0,


@@ -578,10 +708,10 @@ This is the distance, in lines, between the top of WINDOW and the top
 of the frame's window area.  For instance, the return value is 0 if
 there is no window above WINDOW.
 
 of the frame's window area.  For instance, the return value is 0 if
 there is no window above WINDOW.
 

-If WINDOW is omitted or nil, it defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  return WGET (decode_any_window (window), top_line);
+  return decode_valid_window (window)->top_line;

 }
 
 /* Return the number of lines of W's body.  Don't count any mode or
 }
 
 /* Return the number of lines of W's body.  Don't count any mode or


@@ -590,7 +720,7 @@ If WINDOW is omitted or nil, it defaults to the selected window.  */)
 static int
 window_body_lines (struct window *w)
 {
 static int
 window_body_lines (struct window *w)
 {

-  int height = XFASTINT (WGET (w, total_lines));
+  int height = XFASTINT (w->total_lines);

 
   if (!MINI_WINDOW_P (w))
     {
 
   if (!MINI_WINDOW_P (w))
     {


@@ -612,7 +742,7 @@ int
 window_body_cols (struct window *w)
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
 window_body_cols (struct window *w)
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));

-  int width = XINT (WGET (w, total_cols));
+  int width = XINT (w->total_cols);

 
   if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
     /* Scroll bars occupy a few columns.  */
 
   if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
     /* Scroll bars occupy a few columns.  */


@@ -635,8 +765,7 @@ window_body_cols (struct window *w)
 
 DEFUN ("window-body-height", Fwindow_body_height, Swindow_body_height, 0, 1, 0,
        doc: /* Return the height, in lines, of WINDOW's text area.
 
 DEFUN ("window-body-height", Fwindow_body_height, Swindow_body_height, 0, 1, 0,
        doc: /* Return the height, in lines, of WINDOW's text area.

-If WINDOW is omitted or nil, it defaults to the selected window.
-Signal an error if the window is not live.
+WINDOW must be a live window and defaults to the selected one.

 
 The returned height does not include the mode line or header line.
 On a graphical display, the height is expressed as an integer multiple
 
 The returned height does not include the mode line or header line.
 On a graphical display, the height is expressed as an integer multiple


@@ -645,21 +774,20 @@ area is only partially visible, that counts as a whole line; to
 exclude partially-visible lines, use `window-text-height'.  */)
   (Lisp_Object window)
 {
 exclude partially-visible lines, use `window-text-height'.  */)
   (Lisp_Object window)
 {

-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);

   return make_number (window_body_lines (w));
 }
 
 DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 1, 0,
        doc: /* Return the width, in columns, of WINDOW's text area.
   return make_number (window_body_lines (w));
 }
 
 DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 1, 0,
        doc: /* Return the width, in columns, of WINDOW's text area.

-If WINDOW is omitted or nil, it defaults to the selected window.
-Signal an error if the window is not live.
+WINDOW must be a live window and defaults to the selected one.

 
 The return value does not include any vertical dividers, fringe or
 marginal areas, or scroll bars.  On a graphical display, the width is
 expressed as an integer multiple of the default character width.  */)
   (Lisp_Object window)
 {
 
 The return value does not include any vertical dividers, fringe or
 marginal areas, or scroll bars.  On a graphical display, the width is
 expressed as an integer multiple of the default character width.  */)
   (Lisp_Object window)
 {

-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);

   return make_number (window_body_cols (w));
 }
 
   return make_number (window_body_cols (w));
 }
 


@@ -668,7 +796,7 @@ DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
 WINDOW must be a live window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
 WINDOW must be a live window and defaults to the selected one.  */)
   (Lisp_Object window)
 {

-  return make_number (decode_window (window)->hscroll);
+  return make_number (decode_live_window (window)->hscroll);

 }
 
 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
 }
 
 /* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable


@@ -687,7 +815,7 @@ set_window_hscroll (struct window *w, EMACS_INT hscroll)
 
   /* Prevent redisplay shortcuts when changing the hscroll.  */
   if (w->hscroll != new_hscroll)
 
   /* Prevent redisplay shortcuts when changing the hscroll.  */
   if (w->hscroll != new_hscroll)

-    XBUFFER (WGET (w, buffer))->prevent_redisplay_optimizations_p = 1;
+    XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;

 
   w->hscroll = new_hscroll;
   return make_number (new_hscroll);
 
   w->hscroll = new_hscroll;
   return make_number (new_hscroll);


@@ -695,7 +823,7 @@ set_window_hscroll (struct window *w, EMACS_INT hscroll)
 
 DEFUN ("set-window-hscroll", Fset_window_hscroll, Sset_window_hscroll, 2, 2, 0,
        doc: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
 
 DEFUN ("set-window-hscroll", Fset_window_hscroll, Sset_window_hscroll, 2, 2, 0,
        doc: /* Set number of columns WINDOW is scrolled from left margin to NCOL.

-If WINDOW is nil, the selected window is used.
+WINDOW must be a live window and defaults to the selected one.

 Clip the number to a reasonable value if out of range.
 Return the new number.  NCOL should be zero or positive.
 
 Clip the number to a reasonable value if out of range.
 Return the new number.  NCOL should be zero or positive.
 


@@ -703,7 +831,7 @@ Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
 window so that the location of point moves off-window.  */)
   (Lisp_Object window, Lisp_Object ncol)
 {
 window so that the location of point moves off-window.  */)
   (Lisp_Object window, Lisp_Object ncol)
 {

-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);

 
   CHECK_NUMBER (ncol);
   return set_window_hscroll (w, XINT (ncol));
 
   CHECK_NUMBER (ncol);
   return set_window_hscroll (w, XINT (ncol));


@@ -712,40 +840,44 @@ window so that the location of point moves off-window.  */)
 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
        Swindow_redisplay_end_trigger, 0, 1, 0,
        doc: /* Return WINDOW's redisplay end trigger value.
 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
        Swindow_redisplay_end_trigger, 0, 1, 0,
        doc: /* Return WINDOW's redisplay end trigger value.

-WINDOW defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.

 See `set-window-redisplay-end-trigger' for more information.  */)
   (Lisp_Object window)
 {
 See `set-window-redisplay-end-trigger' for more information.  */)
   (Lisp_Object window)
 {

-  return WGET (decode_window (window), redisplay_end_trigger);
+  return decode_live_window (window)->redisplay_end_trigger;

 }
 
 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger,
        Sset_window_redisplay_end_trigger, 2, 2, 0,
        doc: /* Set WINDOW's redisplay end trigger value to VALUE.
 }
 
 DEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger,
        Sset_window_redisplay_end_trigger, 2, 2, 0,
        doc: /* Set WINDOW's redisplay end trigger value to VALUE.

-VALUE should be a buffer position (typically a marker) or nil.
-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 must be a live window and defaults to the selected one.  VALUE
+should be a buffer position (typically a marker) or nil.  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.  */)

   (register Lisp_Object window, Lisp_Object value)
 {
   (register Lisp_Object window, Lisp_Object value)
 {

-  return WSET (decode_window (window), redisplay_end_trigger, value);
+  wset_redisplay_end_trigger (decode_live_window (window), value);
+  return value;

 }
 
 DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
        doc: /* Return a list of the edge coordinates of WINDOW.
 }
 
 DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
        doc: /* Return a list of the edge coordinates of WINDOW.

-The list has the form (LEFT TOP RIGHT BOTTOM).
-TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
-all relative to 0, 0 at top left corner of frame.
-
-RIGHT is one more than the rightmost column occupied by WINDOW.
-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 must be a valid window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM).  TOP and BOTTOM
+count by lines, and LEFT and RIGHT count by columns, all relative to 0,
+0 at top left corner of frame.
+
+RIGHT is one more than the rightmost column occupied by WINDOW.  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'.  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  register struct window *w = decode_any_window (window);
+  register struct window *w = decode_valid_window (window);

 
   return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w)),
         Fcons (make_number (WINDOW_TOP_EDGE_LINE (w)),
 
   return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w)),
         Fcons (make_number (WINDOW_TOP_EDGE_LINE (w)),


@@ -756,8 +888,10 @@ just the text area, use `window-inside-edges'.  */)
 
 DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges, 0, 1, 0,
        doc: /* Return a list of the edge pixel coordinates of WINDOW.
 
 DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_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 frame.
+WINDOW must be a valid window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
+0, 0 at the top left corner of the frame.

 
 RIGHT is one more than the rightmost x position occupied by WINDOW.
 BOTTOM is one more than the bottommost y position occupied by WINDOW.
 
 RIGHT is one more than the rightmost x position occupied by WINDOW.
 BOTTOM is one more than the bottommost y position occupied by WINDOW.


@@ -766,7 +900,7 @@ margins, fringes, header line, and/or mode line.  For the pixel edges
 of just the text area, use `window-inside-pixel-edges'.  */)
   (Lisp_Object window)
 {
 of just the text area, use `window-inside-pixel-edges'.  */)
   (Lisp_Object window)
 {

-  register struct window *w = decode_any_window (window);
+  register struct window *w = decode_valid_window (window);

 
   return Fcons (make_number (WINDOW_LEFT_EDGE_X (w)),
         Fcons (make_number (WINDOW_TOP_EDGE_Y (w)),
 
   return Fcons (make_number (WINDOW_LEFT_EDGE_X (w)),
         Fcons (make_number (WINDOW_TOP_EDGE_Y (w)),


@@ -778,7 +912,7 @@ of just the text area, use `window-inside-pixel-edges'.  */)
 static void
 calc_absolute_offset (struct window *w, int *add_x, int *add_y)
 {
 static void
 calc_absolute_offset (struct window *w, int *add_x, int *add_y)
 {

-  struct frame *f = XFRAME (WGET (w, frame));
+  struct frame *f = XFRAME (w->frame);

   *add_y = f->top_pos;
 #ifdef FRAME_MENUBAR_HEIGHT
   *add_y += FRAME_MENUBAR_HEIGHT (f);
   *add_y = f->top_pos;
 #ifdef FRAME_MENUBAR_HEIGHT
   *add_y += FRAME_MENUBAR_HEIGHT (f);


@@ -800,8 +934,10 @@ calc_absolute_offset (struct window *w, int *add_x, int *add_y)
 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.
 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.
+WINDOW must be a valid window and defaults to the selected one.
+
+The returned 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.
 
 RIGHT is one more than the rightmost x position occupied by WINDOW.
 BOTTOM is one more than the bottommost y position occupied by WINDOW.


@@ -810,7 +946,7 @@ 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)
 {
 of just the text area, use `window-inside-absolute-pixel-edges'.  */)
   (Lisp_Object window)
 {

-  register struct window *w = decode_any_window (window);
+  register struct window *w = decode_valid_window (window);

   int add_x, add_y;
   calc_absolute_offset (w, &add_x, &add_y);
 
   int add_x, add_y;
   calc_absolute_offset (w, &add_x, &add_y);
 


@@ -823,17 +959,19 @@ of just the text area, use `window-inside-absolute-pixel-edges'.  */)
 
 DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
        doc: /* Return a list of the edge coordinates of WINDOW.
 
 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).
-TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
-all relative to 0, 0 at top left corner of frame.
+WINDOW must be a live window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM).  TOP and BOTTOM
+count by lines, and LEFT and RIGHT count by columns, all relative to 0,
+0 at top left corner of frame.

 
 RIGHT is one more than the rightmost column of WINDOW's text area.
 
 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.  */)
+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.  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);

 
   return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w)
                             + WINDOW_LEFT_MARGIN_COLS (w)
 
   return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w)
                             + WINDOW_LEFT_MARGIN_COLS (w)


@@ -849,8 +987,10 @@ bar, display margins, fringes, header line, and/or mode line.  */)
 
 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
        doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.
 
 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
        doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.

-The list has the form (LEFT TOP RIGHT BOTTOM), all relative to (0,0)
-at the top left corner of the frame's window area.
+WINDOW must be a live window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
+(0,0) at the top left corner of the frame's window area.

 
 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.
 
 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.


@@ -858,7 +998,7 @@ 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)
 {
 display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {

-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);

 
   return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w)
                             + WINDOW_LEFT_MARGIN_WIDTH (w)
 
   return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w)
                             + WINDOW_LEFT_MARGIN_WIDTH (w)


@@ -876,8 +1016,10 @@ 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's text area.
        Fwindow_inside_absolute_pixel_edges,
        Swindow_inside_absolute_pixel_edges, 0, 1, 0,
        doc: /* Return a list of the edge pixel coordinates of WINDOW's text area.

-The list has the form (LEFT TOP RIGHT BOTTOM), all relative to (0,0)
-at the top left corner of the frame's window area.
+WINDOW must be a live window and defaults to the selected one.
+
+The returned list has the form (LEFT TOP RIGHT BOTTOM), all relative to
+(0,0) at the top left corner of the frame's window area.

 
 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.
 
 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.


@@ -885,7 +1027,7 @@ 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)
 {
 display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {

-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);

   int add_x, add_y;
   calc_absolute_offset (w, &add_x, &add_y);
 
   int add_x, add_y;
   calc_absolute_offset (w, &add_x, &add_y);
 


@@ -1064,7 +1206,7 @@ window_relative_x_coord (struct window *w, enum window_part part, int x)
 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
        Scoordinates_in_window_p, 2, 2, 0,
        doc: /* Return non-nil if COORDINATES are in WINDOW.
 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
        Scoordinates_in_window_p, 2, 2, 0,
        doc: /* Return non-nil if COORDINATES are in WINDOW.

-WINDOW must be a live window.
+WINDOW must be a live window and defaults to the selected one.

 COORDINATES is a cons of the form (X . Y), X and Y being distances
 measured in characters from the upper-left corner of the frame.
 \(0 . 0) denotes the character in the upper left corner of the
 COORDINATES is a cons of the form (X . Y), X and Y being distances
 measured in characters from the upper-left corner of the frame.
 \(0 . 0) denotes the character in the upper left corner of the


@@ -1086,9 +1228,8 @@ If they are in the windows's left or right marginal areas, `left-margin'\n\
   int x, y;
   Lisp_Object lx, ly;
 
   int x, y;
   Lisp_Object lx, ly;
 

-  CHECK_LIVE_WINDOW (window);
-  w = XWINDOW (window);
-  f = XFRAME (WGET (w, frame));
+  w = decode_live_window (window);
+  f = XFRAME (w->frame);

   CHECK_CONS (coordinates);
   lx = Fcar (coordinates);
   ly = Fcdr (coordinates);
   CHECK_CONS (coordinates);
   lx = Fcar (coordinates);
   ly = Fcdr (coordinates);


@@ -1136,7 +1277,7 @@ If they are in the windows's left or right marginal areas, `left-margin'\n\
       return Qnil;
 
     default:
       return Qnil;
 
     default:

-      abort ();
+      emacs_abort ();

     }
 }
 
     }
 }
 


@@ -1255,22 +1396,21 @@ DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0,
        doc: /* Return current value of point in WINDOW.
 WINDOW must be a live window and defaults to the selected one.
 
        doc: /* Return current value of point in WINDOW.
 WINDOW must be a live window and defaults to the selected one.
 

-For a nonselected window, this is the value point would have
-if that window were selected.
+For a nonselected window, this is the value point would have if that
+window were selected.

 
 

-Note that, when WINDOW is the selected window and its buffer
-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.  */)
+Note that, when WINDOW is selected, the value returned is the same as
+that returned by `point' for WINDOW's buffer.  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.  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);

 
 

-  if (w == XWINDOW (selected_window)
-      && current_buffer == XBUFFER (WGET (w, buffer)))
-    return Fpoint ();
-  return Fmarker_position (WGET (w, pointm));
+  if (w == XWINDOW (selected_window))
+    return make_number (BUF_PT (XBUFFER (w->buffer)));
+  else
+    return Fmarker_position (w->pointm);

 }
 
 DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0,
 }
 
 DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0,


@@ -1279,7 +1419,7 @@ WINDOW must be a live window and defaults to the selected one.
 This is updated by redisplay or by calling `set-window-start'.  */)
   (Lisp_Object window)
 {
 This is updated by redisplay or by calling `set-window-start'.  */)
   (Lisp_Object window)
 {

-  return Fmarker_position (WGET (decode_window (window), start));
+  return Fmarker_position (decode_live_window (window)->start);

 }
 
 /* This is text temporarily removed from the doc string below.
 }
 
 /* This is text temporarily removed from the doc string below.


@@ -1306,11 +1446,11 @@ if it isn't already recorded.  */)
   (Lisp_Object window, Lisp_Object update)
 {
   Lisp_Object value;
   (Lisp_Object window, Lisp_Object update)
 {
   Lisp_Object value;

-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);

   Lisp_Object buf;
   struct buffer *b;
 
   Lisp_Object buf;
   struct buffer *b;
 

-  buf = WGET (w, buffer);
+  buf = w->buffer;

   CHECK_BUFFER (buf);
   b = XBUFFER (buf);
 
   CHECK_BUFFER (buf);
   b = XBUFFER (buf);
 


@@ -1319,12 +1459,12 @@ if it isn't already recorded.  */)
      The user can compute it with vertical-motion if he wants to.
      It would be nicer to do it automatically,
      but that's so slow that it would probably bother people.  */
      The user can compute it with vertical-motion if he wants to.
      It would be nicer to do it automatically,
      but that's so slow that it would probably bother people.  */

-  if (NILP (WGET (w, window_end_valid)))
+  if (NILP (w->window_end_valid))

     return Qnil;
 #endif
 
   if (! NILP (update)
     return Qnil;
 #endif
 
   if (! NILP (update)

-      && ! (! NILP (WGET (w, window_end_valid))
+      && ! (! NILP (w->window_end_valid)

            && w->last_modified >= BUF_MODIFF (b)
            && w->last_overlay_modified >= BUF_OVERLAY_MODIFF (b))
       && !noninteractive)
            && w->last_modified >= BUF_MODIFF (b)
            && w->last_overlay_modified >= BUF_OVERLAY_MODIFF (b))
       && !noninteractive)


@@ -1347,12 +1487,12 @@ if it isn't already recorded.  */)
          `-l' containing a call to `rmail' with subsequent other
          commands.  At the end, W->start happened to be BEG, while
          rmail had already narrowed the buffer.  */
          `-l' containing a call to `rmail' with subsequent other
          commands.  At the end, W->start happened to be BEG, while
          rmail had already narrowed the buffer.  */

-      if (XMARKER (WGET (w, start))->charpos < BEGV)
+      if (XMARKER (w->start)->charpos < BEGV)

        SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
        SET_TEXT_POS (startp, BEGV, BEGV_BYTE);

-      else if (XMARKER (WGET (w, start))->charpos > ZV)
+      else if (XMARKER (w->start)->charpos > ZV)

        SET_TEXT_POS (startp, ZV, ZV_BYTE);
       else
        SET_TEXT_POS (startp, ZV, ZV_BYTE);
       else

-       SET_TEXT_POS_FROM_MARKER (startp, WGET (w, start));
+       SET_TEXT_POS_FROM_MARKER (startp, w->start);

 
       itdata = bidi_shelve_cache ();
       start_display (&it, w, startp);
 
       itdata = bidi_shelve_cache ();
       start_display (&it, w, startp);


@@ -1366,44 +1506,56 @@ if it isn't already recorded.  */)
        set_buffer_internal (old_buffer);
     }
   else
        set_buffer_internal (old_buffer);
     }
   else

-    XSETINT (value, BUF_Z (b) - XFASTINT (WGET (w, window_end_pos)));
+    XSETINT (value, BUF_Z (b) - XFASTINT (w->window_end_pos));

 
   return value;
 }
 
 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 value;
 }
 
 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.

+WINDOW must be a live window and defaults to the selected one.

 Return POS.  */)
   (Lisp_Object window, Lisp_Object pos)
 {
 Return POS.  */)
   (Lisp_Object window, Lisp_Object pos)
 {

-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);

 
   CHECK_NUMBER_COERCE_MARKER (pos);
 
   CHECK_NUMBER_COERCE_MARKER (pos);

-  if (w == XWINDOW (selected_window)
-      && XBUFFER (WGET (w, buffer)) == current_buffer)
-    Fgoto_char (pos);
-  else
-    set_marker_restricted (WGET (w, pointm), pos, WGET (w, buffer));

 
 

-  /* We have to make sure that redisplay updates the window to show
-     the new value of point.  */
-  if (!EQ (window, selected_window))
-    ++windows_or_buffers_changed;
+  if (w == XWINDOW (selected_window))
+    {
+      if (XBUFFER (w->buffer) == current_buffer)
+       Fgoto_char (pos);
+      else
+       {
+         struct buffer *old_buffer = current_buffer;
+
+         set_buffer_internal (XBUFFER (w->buffer));
+         Fgoto_char (pos);
+         set_buffer_internal (old_buffer);
+       }
+    }
+  else
+    {
+      set_marker_restricted (w->pointm, pos, w->buffer);
+      /* We have to make sure that redisplay updates the window to show
+        the new value of point.  */
+      ++windows_or_buffers_changed;
+    }

 
   return pos;
 }
 
 DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0,
        doc: /* Make display in WINDOW start at position POS in WINDOW's buffer.
 
   return pos;
 }
 
 DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0,
        doc: /* Make display in WINDOW start at position POS in WINDOW's buffer.

-If WINDOW is nil, the selected window is used.  Return POS.
-Optional third arg NOFORCE non-nil inhibits next redisplay from
+WINDOW must be a live window and defaults to the selected one.  Return
+POS.  Optional third arg NOFORCE non-nil inhibits next redisplay from

 overriding motion of point in order to display at this exact start.  */)
   (Lisp_Object window, Lisp_Object pos, Lisp_Object noforce)
 {
 overriding motion of point in order to display at this exact start.  */)
   (Lisp_Object window, Lisp_Object pos, Lisp_Object noforce)
 {

-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);

 
   CHECK_NUMBER_COERCE_MARKER (pos);
 
   CHECK_NUMBER_COERCE_MARKER (pos);

-  set_marker_restricted (WGET (w, start), pos, WGET (w, buffer));
+  set_marker_restricted (w->start, pos, w->buffer);

   /* this is not right, but much easier than doing what is right. */
   w->start_at_line_beg = 0;
   if (NILP (noforce))
   /* this is not right, but much easier than doing what is right. */
   w->start_at_line_beg = 0;
   if (NILP (noforce))


@@ -1420,12 +1572,14 @@ overriding motion of point in order to display at this exact start.  */)
 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
        Spos_visible_in_window_p, 0, 3, 0,
        doc: /* Return non-nil if position POS is currently on the frame in WINDOW.
 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
        Spos_visible_in_window_p, 0, 3, 0,
        doc: /* Return non-nil if position POS is currently on the frame in WINDOW.

-Return nil if that position is scrolled vertically out of view.
-If a character is only partially visible, nil is returned, unless the
-optional argument PARTIALLY is non-nil.
-If POS is only out of view because of horizontal scrolling, return non-nil.
-If POS is t, it specifies the position of the last visible glyph in WINDOW.
-POS defaults to point in WINDOW; WINDOW defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
+
+Return nil if that position is scrolled vertically out of view.  If a
+character is only partially visible, nil is returned, unless the
+optional argument PARTIALLY is non-nil.  If POS is only out of view
+because of horizontal scrolling, return non-nil.  If POS is t, it
+specifies the position of the last visible glyph in WINDOW.  POS
+defaults to point in WINDOW; WINDOW defaults to the selected window.

 
 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
 
 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
 return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),


@@ -1444,9 +1598,9 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
   int rtop, rbot, rowh, vpos, fully_p = 1;
   int x, y;
 
   int rtop, rbot, rowh, vpos, fully_p = 1;
   int x, y;
 

-  w = decode_window (window);
-  buf = XBUFFER (WGET (w, buffer));
-  SET_TEXT_POS_FROM_MARKER (top, WGET (w, start));
+  w = decode_live_window (window);
+  buf = XBUFFER (w->buffer);
+  SET_TEXT_POS_FROM_MARKER (top, w->start);

 
   if (EQ (pos, Qt))
     posint = -1;
 
   if (EQ (pos, Qt))
     posint = -1;


@@ -1458,7 +1612,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
   else if (w == XWINDOW (selected_window))
     posint = PT;
   else
   else if (w == XWINDOW (selected_window))
     posint = PT;
   else

-    posint = XMARKER (WGET (w, pointm))->charpos;
+    posint = XMARKER (w->pointm)->charpos;

 
   /* If position is above window start or outside buffer boundaries,
      or if window start is out of range, position is not visible.  */
 
   /* If position is above window start or outside buffer boundaries,
      or if window start is out of range, position is not visible.  */


@@ -1486,7 +1640,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
 DEFUN ("window-line-height", Fwindow_line_height,
        Swindow_line_height, 0, 2, 0,
        doc: /* Return height in pixels of text line LINE in window WINDOW.
 DEFUN ("window-line-height", Fwindow_line_height,
        Swindow_line_height, 0, 2, 0,
        doc: /* Return height in pixels of text line LINE in window WINDOW.

-WINDOW defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.

 
 Return height of current line if LINE is omitted or nil.  Return height of
 header or mode line if LINE is `header-line' or `mode-line'.
 
 Return height of current line if LINE is omitted or nil.  Return height of
 header or mode line if LINE is `header-line' or `mode-line'.


@@ -1510,16 +1664,16 @@ Return nil if window display is not up-to-date.  In that case, use
   int max_y, crop, i;
   EMACS_INT n;
 
   int max_y, crop, i;
   EMACS_INT n;
 

-  w = decode_window (window);
+  w = decode_live_window (window);

 
   if (noninteractive || w->pseudo_window_p)
     return Qnil;
 
 
   if (noninteractive || w->pseudo_window_p)
     return Qnil;
 

-  CHECK_BUFFER (WGET (w, buffer));
-  b = XBUFFER (WGET (w, buffer));
+  CHECK_BUFFER (w->buffer);
+  b = XBUFFER (w->buffer);

 
   /* Fail if current matrix is not up-to-date.  */
 
   /* Fail if current matrix is not up-to-date.  */

-  if (NILP (WGET (w, window_end_valid))
+  if (NILP (w->window_end_valid)

       || current_buffer->clip_changed
       || current_buffer->prevent_redisplay_optimizations_p
       || w->last_modified < BUF_MODIFF (b)
       || current_buffer->clip_changed
       || current_buffer->prevent_redisplay_optimizations_p
       || w->last_modified < BUF_MODIFF (b)


@@ -1598,8 +1752,8 @@ DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
 More precisely, return the value assigned by the last call of
 `set-window-dedicated-p' for WINDOW.  Return nil if that function was
 never called with WINDOW as its argument, or the value set by that
 More precisely, return the value assigned by the last call of
 `set-window-dedicated-p' for WINDOW.  Return nil if that function was
 never called with WINDOW as its argument, or the value set by that

-function was internally reset since its last call.  WINDOW defaults to
-the selected window.
+function was internally reset since its last call.  WINDOW must be a
+live window and defaults to the selected one.

 
 When a window is dedicated to its buffer, `display-buffer' will refrain
 from displaying another buffer in it.  `get-lru-window' and
 
 When a window is dedicated to its buffer, `display-buffer' will refrain
 from displaying another buffer in it.  `get-lru-window' and


@@ -1612,7 +1766,7 @@ window, unless that window is "strongly" dedicated to its buffer, that
 is the value returned by `window-dedicated-p' is t.  */)
   (Lisp_Object window)
 {
 is the value returned by `window-dedicated-p' is t.  */)
   (Lisp_Object window)
 {

-  return WGET (decode_window (window), dedicated);
+  return decode_live_window (window)->dedicated;

 }
 
 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p,
 }
 
 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p,


@@ -1636,7 +1790,8 @@ buffer.  If and when `set-window-buffer' displays another buffer in a
 window, it also makes sure that the window is no more dedicated.  */)
   (Lisp_Object window, Lisp_Object flag)
 {
 window, it also makes sure that the window is no more dedicated.  */)
   (Lisp_Object window, Lisp_Object flag)
 {

-  return WSET (decode_window (window), dedicated, flag);
+  wset_dedicated (decode_live_window (window), flag);
+  return flag;

 }
 
 DEFUN ("window-prev-buffers", Fwindow_prev_buffers, Swindow_prev_buffers,
 }
 
 DEFUN ("window-prev-buffers", Fwindow_prev_buffers, Swindow_prev_buffers,


@@ -1649,7 +1804,7 @@ where BUFFER is a buffer, WINDOW-START is the start position of the
 window for that buffer, and POS is a window-specific point value.  */)
   (Lisp_Object window)
 {
 window for that buffer, and POS is a window-specific point value.  */)
   (Lisp_Object window)
 {

-  return WGET (decode_window (window), prev_buffers);
+  return decode_live_window (window)->prev_buffers;

 }
 
 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers,
 }
 
 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers,


@@ -1662,7 +1817,8 @@ where BUFFER is a buffer, WINDOW-START is the start position of the
 window for that buffer, and POS is a window-specific point value.  */)
      (Lisp_Object window, Lisp_Object prev_buffers)
 {
 window for that buffer, and POS is a window-specific point value.  */)
      (Lisp_Object window, Lisp_Object prev_buffers)
 {

-  return WSET (decode_window (window), prev_buffers, prev_buffers);
+  wset_prev_buffers (decode_live_window (window), prev_buffers);
+  return prev_buffers;

 }
 
 DEFUN ("window-next-buffers", Fwindow_next_buffers, Swindow_next_buffers,
 }
 
 DEFUN ("window-next-buffers", Fwindow_next_buffers, Swindow_next_buffers,


@@ -1671,7 +1827,7 @@ DEFUN ("window-next-buffers", Fwindow_next_buffers, Swindow_next_buffers,
 WINDOW must be a live window and defaults to the selected one.  */)
      (Lisp_Object window)
 {
 WINDOW must be a live window and defaults to the selected one.  */)
      (Lisp_Object window)
 {

-  return WGET (decode_window (window), next_buffers);
+  return decode_live_window (window)->next_buffers;

 }
 
 DEFUN ("set-window-next-buffers", Fset_window_next_buffers,
 }
 
 DEFUN ("set-window-next-buffers", Fset_window_next_buffers,


@@ -1681,45 +1837,46 @@ WINDOW must be a live window and defaults to the selected one.
 NEXT-BUFFERS should be a list of buffers.  */)
      (Lisp_Object window, Lisp_Object next_buffers)
 {
 NEXT-BUFFERS should be a list of buffers.  */)
      (Lisp_Object window, Lisp_Object next_buffers)
 {

-  return WSET (decode_window (window), next_buffers, next_buffers);
+  wset_next_buffers (decode_live_window (window), next_buffers);
+  return next_buffers;

 }
 
 DEFUN ("window-parameters", Fwindow_parameters, Swindow_parameters,
        0, 1, 0,
        doc: /* Return the parameters of WINDOW and their values.
 }
 
 DEFUN ("window-parameters", Fwindow_parameters, Swindow_parameters,
        0, 1, 0,
        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 must be a valid window and defaults to the selected one.  The
+return value is a list of elements of the form (PARAMETER . VALUE).  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  return Fcopy_alist (WGET (decode_any_window (window), window_parameters));
+  return Fcopy_alist (decode_valid_window (window)->window_parameters);

 }
 
 DEFUN ("window-parameter", Fwindow_parameter, Swindow_parameter,
        2, 2, 0,
        doc:  /* Return WINDOW's value for PARAMETER.
 }
 
 DEFUN ("window-parameter", Fwindow_parameter, Swindow_parameter,
        2, 2, 0,
        doc:  /* Return WINDOW's value for PARAMETER.

-WINDOW defaults to the selected window.  */)
+WINDOW can be any window and defaults to the selected one.  */)

   (Lisp_Object window, Lisp_Object parameter)
 {
   Lisp_Object result;
 
   (Lisp_Object window, Lisp_Object parameter)
 {
   Lisp_Object result;
 

-  result = Fassq (parameter, WGET (decode_any_window (window),
-                                  window_parameters));
+  result = Fassq (parameter, decode_any_window (window)->window_parameters);

   return CDR_SAFE (result);
 }
 
 DEFUN ("set-window-parameter", Fset_window_parameter,
        Sset_window_parameter, 3, 3, 0,
        doc: /* Set WINDOW's value of PARAMETER to VALUE.
   return CDR_SAFE (result);
 }
 
 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 can be any window and defaults to the selected one.
+Return VALUE.  */)

   (Lisp_Object window, Lisp_Object parameter, Lisp_Object value)
 {
   register struct window *w = decode_any_window (window);
   Lisp_Object old_alist_elt;
 
   (Lisp_Object window, Lisp_Object parameter, Lisp_Object value)
 {
   register struct window *w = decode_any_window (window);
   Lisp_Object old_alist_elt;
 

-  old_alist_elt = Fassq (parameter, WGET (w, window_parameters));
+  old_alist_elt = Fassq (parameter, w->window_parameters);

   if (NILP (old_alist_elt))
   if (NILP (old_alist_elt))

-    WSET (w, window_parameters,
-         Fcons (Fcons (parameter, value), WGET (w, window_parameters)));
+    wset_window_parameters
+      (w, Fcons (Fcons (parameter, value), w->window_parameters));

   else
     Fsetcdr (old_alist_elt, value);
   return value;
   else
     Fsetcdr (old_alist_elt, value);
   return value;


@@ -1728,10 +1885,10 @@ WINDOW defaults to the selected window.  Return VALUE.  */)
 DEFUN ("window-display-table", Fwindow_display_table, Swindow_display_table,
        0, 1, 0,
        doc: /* Return the display-table that WINDOW is using.
 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 must be a live window and defaults to the selected one.  */)

   (Lisp_Object window)
 {
   (Lisp_Object window)
 {

-  return WGET (decode_window (window), display_table);
+  return decode_live_window (window)->display_table;

 }
 
 /* Get the display table for use on window W.  This is either W's
 }
 
 /* Get the display table for use on window W.  This is either W's


@@ -1744,11 +1901,11 @@ window_display_table (struct window *w)
 {
   struct Lisp_Char_Table *dp = NULL;
 
 {
   struct Lisp_Char_Table *dp = NULL;
 

-  if (DISP_TABLE_P (WGET (w, display_table)))
-    dp = XCHAR_TABLE (WGET (w, display_table));
-  else if (BUFFERP (WGET (w, buffer)))
+  if (DISP_TABLE_P (w->display_table))
+    dp = XCHAR_TABLE (w->display_table);
+  else if (BUFFERP (w->buffer))

     {
     {

-      struct buffer *b = XBUFFER (WGET (w, buffer));
+      struct buffer *b = XBUFFER (w->buffer);

 
       if (DISP_TABLE_P (BVAR (b, display_table)))
        dp = XCHAR_TABLE (BVAR (b, display_table));
 
       if (DISP_TABLE_P (BVAR (b, display_table)))
        dp = XCHAR_TABLE (BVAR (b, display_table));


@@ -1760,10 +1917,12 @@ window_display_table (struct window *w)
 }
 
 DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0,
 }
 
 DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0,

-       doc: /* Set WINDOW's display-table to TABLE.  */)
+       doc: /* Set WINDOW's display-table to TABLE.
+WINDOW must be a live window and defaults to the selected one.  */)

   (register Lisp_Object window, Lisp_Object table)
 {
   (register Lisp_Object window, Lisp_Object table)
 {

-  return WSET (decode_window (window), display_table, table);
+  wset_display_table (decode_live_window (window), table);
+  return table;

 }
 \f
 /* Record info on buffer window W is displaying
 }
 \f
 /* Record info on buffer window W is displaying


@@ -1774,14 +1933,14 @@ unshow_buffer (register struct window *w)
   Lisp_Object buf;
   struct buffer *b;
 
   Lisp_Object buf;
   struct buffer *b;
 

-  buf = WGET (w, buffer);
+  buf = w->buffer;

   b = XBUFFER (buf);
   b = XBUFFER (buf);

-  if (b != XMARKER (WGET (w, pointm))->buffer)
-    abort ();
+  if (b != XMARKER (w->pointm)->buffer)
+    emacs_abort ();

 
 #if 0
   if (w == XWINDOW (selected_window)
 
 #if 0
   if (w == XWINDOW (selected_window)

-      || ! EQ (buf, WGET (XWINDOW (selected_window), buffer)))
+      || ! EQ (buf, XWINDOW (selected_window)->buffer))

     /* Do this except when the selected window's buffer
        is being removed from some other window.  */
 #endif
     /* Do this except when the selected window's buffer
        is being removed from some other window.  */
 #endif


@@ -1792,27 +1951,30 @@ unshow_buffer (register struct window *w)
        selected window, while last_window_start reflects another
        window which was recently showing the same buffer.
        Some people might say that might be a good thing.  Let's see.  */
        selected window, while last_window_start reflects another
        window which was recently showing the same buffer.
        Some people might say that might be a good thing.  Let's see.  */

-    b->last_window_start = marker_position (WGET (w, start));
+    b->last_window_start = marker_position (w->start);

 
   /* Point in the selected window's buffer
      is actually stored in that buffer, and the window's pointm isn't used.
      So don't clobber point in that buffer.  */
 
   /* Point in the selected window's buffer
      is actually stored in that buffer, and the window's pointm isn't used.
      So don't clobber point in that buffer.  */

-  if (! EQ (buf, WGET (XWINDOW (selected_window), buffer))
+  if (! EQ (buf, XWINDOW (selected_window)->buffer)
+      /* Don't clobber point in current buffer either (this could be
+        useful in connection with bug#12208).
+      && XBUFFER (buf) != current_buffer  */

       /* This line helps to fix Horsley's testbug.el bug.  */
       && !(WINDOWP (BVAR (b, last_selected_window))
           && w != XWINDOW (BVAR (b, last_selected_window))
       /* This line helps to fix Horsley's testbug.el bug.  */
       && !(WINDOWP (BVAR (b, last_selected_window))
           && w != XWINDOW (BVAR (b, last_selected_window))

-          && EQ (buf, WGET (XWINDOW (BVAR (b, last_selected_window)), buffer))))
+          && EQ (buf, XWINDOW (BVAR (b, last_selected_window))->buffer)))

     temp_set_point_both (b,
                         clip_to_bounds (BUF_BEGV (b),
     temp_set_point_both (b,
                         clip_to_bounds (BUF_BEGV (b),

-                                        XMARKER (WGET (w, pointm))->charpos,
+                                        XMARKER (w->pointm)->charpos,

                                         BUF_ZV (b)),
                         clip_to_bounds (BUF_BEGV_BYTE (b),
                                         BUF_ZV (b)),
                         clip_to_bounds (BUF_BEGV_BYTE (b),

-                                        marker_byte_position (WGET (w, pointm)),
+                                        marker_byte_position (w->pointm),

                                         BUF_ZV_BYTE (b)));
 
   if (WINDOWP (BVAR (b, last_selected_window))
       && w == XWINDOW (BVAR (b, last_selected_window)))
                                         BUF_ZV_BYTE (b)));
 
   if (WINDOWP (BVAR (b, last_selected_window))
       && w == XWINDOW (BVAR (b, last_selected_window)))

-    BVAR (b, last_selected_window) = Qnil;
+    bset_last_selected_window (b, Qnil);

 }
 
 /* Put NEW into the window structure in place of OLD.  SETFLAG zero
 }
 
 /* Put NEW into the window structure in place of OLD.  SETFLAG zero


@@ -1826,19 +1988,19 @@ replace_window (Lisp_Object old, Lisp_Object new, int setflag)
 
   /* If OLD is its frame's root window, then NEW is the new
      root window for that frame.  */
 
   /* If OLD is its frame's root window, then NEW is the new
      root window for that frame.  */

-  if (EQ (old, FRAME_ROOT_WINDOW (XFRAME (WGET (o, frame)))))
-    FSET (XFRAME (WGET (o, frame)), root_window, new);
+  if (EQ (old, FRAME_ROOT_WINDOW (XFRAME (o->frame))))
+    fset_root_window (XFRAME (o->frame), new);

 
    if (setflag)
      {
 
    if (setflag)
      {

-      WSET (n, left_col, WGET (o, left_col));
-      WSET (n, top_line, WGET (o, top_line));
-      WSET (n, total_cols, WGET (o, total_cols));
-      WSET (n, total_lines, WGET (o, total_lines));
-      WSET (n, normal_cols, WGET (o, normal_cols));
-      WSET (o, normal_cols, make_float (1.0));
-      WSET (n, normal_lines, WGET (o, normal_lines));
-      WSET (o, normal_lines, make_float (1.0));
+      wset_left_col (n, o->left_col);
+      wset_top_line (n, o->top_line);
+      wset_total_cols (n, o->total_cols);
+      wset_total_lines (n, o->total_lines);
+      wset_normal_cols (n, o->normal_cols);
+      wset_normal_cols (o, make_float (1.0));
+      wset_normal_lines (n, o->normal_lines);
+      wset_normal_lines (o, make_float (1.0));

       n->desired_matrix = n->current_matrix = 0;
       n->vscroll = 0;
       memset (&n->cursor, 0, sizeof (n->cursor));
       n->desired_matrix = n->current_matrix = 0;
       n->vscroll = 0;
       memset (&n->cursor, 0, sizeof (n->cursor));


@@ -1848,30 +2010,30 @@ replace_window (Lisp_Object old, Lisp_Object new, int setflag)
       n->phys_cursor_width = -1;
       n->must_be_updated_p = 0;
       n->pseudo_window_p = 0;
       n->phys_cursor_width = -1;
       n->must_be_updated_p = 0;
       n->pseudo_window_p = 0;

-      WSET (n, window_end_vpos, make_number (0));
-      WSET (n, window_end_pos, make_number (0));
-      WSET (n, window_end_valid, Qnil);
+      wset_window_end_vpos (n, make_number (0));
+      wset_window_end_pos (n, make_number (0));
+      wset_window_end_valid (n, Qnil);

       n->frozen_window_start_p = 0;
     }
 
       n->frozen_window_start_p = 0;
     }
 

-  tem = WGET (o, next);
-  WSET (n, next, tem);
+  tem = o->next;
+  wset_next (n, tem);

   if (!NILP (tem))
   if (!NILP (tem))

-    WSET (XWINDOW (tem), prev, new);
+    wset_prev (XWINDOW (tem), new);

 
 

-  tem = WGET (o, prev);
-  WSET (n, prev, tem);
+  tem = o->prev;
+  wset_prev (n, tem);

   if (!NILP (tem))
   if (!NILP (tem))

-    WSET (XWINDOW (tem), next, new);
+    wset_next (XWINDOW (tem), new);

 
 

-  tem = WGET (o, parent);
-  WSET (n, parent, tem);
+  tem = o->parent;
+  wset_parent (n, tem);

   if (!NILP (tem))
     {
   if (!NILP (tem))
     {

-      if (EQ (WGET (XWINDOW (tem), vchild), old))
-       WSET (XWINDOW (tem), vchild, new);
-      if (EQ (WGET (XWINDOW (tem), hchild), old))
-       WSET (XWINDOW (tem), hchild, new);
+      if (EQ (XWINDOW (tem)->vchild, old))
+       wset_vchild (XWINDOW (tem), new);
+      if (EQ (XWINDOW (tem)->hchild, old))
+       wset_hchild (XWINDOW (tem), new);

     }
 }
 
     }
 }
 


@@ -1887,65 +2049,65 @@ recombine_windows (Lisp_Object window)
   int horflag;
 
   w = XWINDOW (window);
   int horflag;
 
   w = XWINDOW (window);

-  parent = WGET (w, parent);
-  if (!NILP (parent) && NILP (WGET (w, combination_limit)))
+  parent = w->parent;
+  if (!NILP (parent) && NILP (w->combination_limit))

     {
       p = XWINDOW (parent);
     {
       p = XWINDOW (parent);

-      if (((!NILP (WGET (p, vchild)) && !NILP (WGET (w, vchild)))
-          || (!NILP (WGET (p, hchild)) && !NILP (WGET (w, hchild)))))
+      if (((!NILP (p->vchild) && !NILP (w->vchild))
+          || (!NILP (p->hchild) && !NILP (w->hchild))))

        /* WINDOW and PARENT are both either a vertical or a horizontal
           combination.  */
        {
        /* WINDOW and PARENT are both either a vertical or a horizontal
           combination.  */
        {

-         horflag = NILP (WGET (w, vchild));
-         child = horflag ? WGET (w, hchild) : WGET (w, vchild);
+         horflag = NILP (w->vchild);
+         child = horflag ? w->hchild : w->vchild;

          c = XWINDOW (child);
 
          /* Splice WINDOW's children into its parent's children and
             assign new normal sizes.  */
          c = XWINDOW (child);
 
          /* Splice WINDOW's children into its parent's children and
             assign new normal sizes.  */

-         if (NILP (WGET (w, prev)))
+         if (NILP (w->prev))

            if (horflag)
            if (horflag)

-             WSET (p, hchild, child);
+             wset_hchild (p, child);

            else
            else

-             WSET (p, vchild, child);
+             wset_vchild (p, child);

          else
            {
          else
            {

-             WSET (c, prev, WGET (w, prev));
-             WSET (XWINDOW (WGET (w, prev)), next, child);
+             wset_prev (c, w->prev);
+             wset_next (XWINDOW (w->prev), child);

            }
 
          while (c)
            {
            }
 
          while (c)
            {

-             WSET (c, parent, parent);
+             wset_parent (c, parent);

 
              if (horflag)
 
              if (horflag)

-               WSET (c, normal_cols,
-                     make_float (XFLOATINT (WGET (c, total_cols))
-                                 / XFLOATINT (WGET (p, total_cols))));
+               wset_normal_cols (c,
+                                 make_float (XFLOATINT (c->total_cols)
+                                             / XFLOATINT (p->total_cols)));

              else
              else

-               WSET (c, normal_lines,
-                     make_float (XFLOATINT (WGET (c, total_lines))
-                                 / XFLOATINT (WGET (p, total_lines))));
+               wset_normal_lines (c,
+                                  make_float (XFLOATINT (c->total_lines)
+                                              / XFLOATINT (p->total_lines)));

 
 

-             if (NILP (WGET (c, next)))
+             if (NILP (c->next))

                {
                {

-                 if (!NILP (WGET (w, next)))
+                 if (!NILP (w->next))

                    {
                    {

-                     WSET (c, next, WGET (w, next));
-                     WSET (XWINDOW (WGET (c, next)), prev, child);
+                     wset_next (c, w->next);
+                     wset_prev (XWINDOW (c->next), child);

                    }
 
                  c = 0;
                }
              else
                {
                    }
 
                  c = 0;
                }
              else
                {

-                 child = WGET (c, next);
+                 child = c->next;

                  c = XWINDOW (child);
                }
            }
 
          /* WINDOW can be deleted now.  */
                  c = XWINDOW (child);
                }
            }
 
          /* WINDOW can be deleted now.  */

-         WSET (w, vchild, Qnil);
-         WSET (w, hchild, Qnil);
+         wset_vchild (w, Qnil);
+         wset_hchild (w, Qnil);

        }
     }
 }
        }
     }
 }


@@ -2028,10 +2190,10 @@ static int
 candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf, Lisp_Object all_frames)
 {
   struct window *w = XWINDOW (window);
 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 (WGET (w, frame));
+  struct frame *f = XFRAME (w->frame);

   int candidate_p = 1;
 
   int candidate_p = 1;
 

-  if (!BUFFERP (WGET (w, buffer)))
+  if (!BUFFERP (w->buffer))

     candidate_p = 0;
   else if (MINI_WINDOW_P (w)
            && (EQ (minibuf, Qlambda)
     candidate_p = 0;
   else if (MINI_WINDOW_P (w)
            && (EQ (minibuf, Qlambda)


@@ -2046,13 +2208,13 @@ candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf
   else if (NILP (all_frames))
     {
       eassert (WINDOWP (owindow));
   else if (NILP (all_frames))
     {
       eassert (WINDOWP (owindow));

-      candidate_p = EQ (WGET (w, frame), WGET (XWINDOW (owindow), frame));
+      candidate_p = EQ (w->frame, XWINDOW (owindow)->frame);

     }
   else if (EQ (all_frames, Qvisible))
     {
       FRAME_SAMPLE_VISIBILITY (f);
       candidate_p = FRAME_VISIBLE_P (f)
     }
   else if (EQ (all_frames, Qvisible))
     {
       FRAME_SAMPLE_VISIBILITY (f);
       candidate_p = FRAME_VISIBLE_P (f)

-       && (FRAME_TERMINAL (XFRAME (WGET (w, frame)))
+       && (FRAME_TERMINAL (XFRAME (w->frame))

            == FRAME_TERMINAL (XFRAME (selected_frame)));
 
     }
            == FRAME_TERMINAL (XFRAME (selected_frame)));
 
     }


@@ -2071,15 +2233,15 @@ candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf
                         && !f->output_data.x->has_been_visible)
 #endif
                     )
                         && !f->output_data.x->has_been_visible)
 #endif
                     )

-       && (FRAME_TERMINAL (XFRAME (WGET (w, frame)))
+       && (FRAME_TERMINAL (XFRAME (w->frame))

            == FRAME_TERMINAL (XFRAME (selected_frame)));
     }
   else if (WINDOWP (all_frames))
     candidate_p = (EQ (FRAME_MINIBUF_WINDOW (f), all_frames)
            == FRAME_TERMINAL (XFRAME (selected_frame)));
     }
   else if (WINDOWP (all_frames))
     candidate_p = (EQ (FRAME_MINIBUF_WINDOW (f), all_frames)

-                  || EQ (WGET (XWINDOW (all_frames), frame), WGET (w, frame))
-                  || EQ (WGET (XWINDOW (all_frames), frame), FRAME_FOCUS_FRAME (f)));
+                  || EQ (XWINDOW (all_frames)->frame, w->frame)
+                  || EQ (XWINDOW (all_frames)->frame, FRAME_FOCUS_FRAME (f)));

   else if (FRAMEP (all_frames))
   else if (FRAMEP (all_frames))

-    candidate_p = EQ (all_frames, WGET (w, frame));
+    candidate_p = EQ (all_frames, w->frame);

 
   return candidate_p;
 }
 
   return candidate_p;
 }


@@ -2110,9 +2272,9 @@ decode_next_window_args (Lisp_Object *window, Lisp_Object *minibuf, Lisp_Object
 
   /* ALL_FRAMES nil doesn't specify which frames to include.  */
   if (NILP (*all_frames))
 
   /* ALL_FRAMES nil doesn't specify which frames to include.  */
   if (NILP (*all_frames))

-    *all_frames 
+    *all_frames

       = (!EQ (*minibuf, Qlambda)
       = (!EQ (*minibuf, Qlambda)

-        ? FRAME_MINIBUF_WINDOW (XFRAME (WGET (XWINDOW (*window), frame)))
+        ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window)->frame))

         : Qnil);
   else if (EQ (*all_frames, Qvisible))
     ;
         : Qnil);
   else if (EQ (*all_frames, Qvisible))
     ;


@@ -2138,7 +2300,7 @@ next_window (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames, in
   /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
      return the first window on the frame.  */
   if (FRAMEP (all_frames)
   /* If ALL_FRAMES is a frame, and WINDOW isn't on that frame, just
      return the first window on the frame.  */
   if (FRAMEP (all_frames)

-      && !EQ (all_frames, WGET (XWINDOW (window), frame)))
+      && !EQ (all_frames, XWINDOW (window)->frame))

     return Fframe_first_window (all_frames);
 
   if (next_p)
     return Fframe_first_window (all_frames);
 
   if (next_p)


@@ -2318,7 +2480,7 @@ MINIBUF neither nil nor t means never include the minibuffer window.  */)
   if (NILP (frame))
     frame = selected_frame;
 
   if (NILP (frame))
     frame = selected_frame;
 

-  if (!EQ (frame, WGET (XWINDOW (window), frame)))
+  if (!EQ (frame, XWINDOW (window)->frame))

     error ("Window is on a different frame");
 
   return window_list_1 (window, minibuf, frame);
     error ("Window is on a different frame");
 
   return window_list_1 (window, minibuf, frame);


@@ -2439,7 +2601,7 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
        switch (type)
          {
          case GET_BUFFER_WINDOW:
        switch (type)
          {
          case GET_BUFFER_WINDOW:

-           if (EQ (WGET (w, buffer), obj)
+           if (EQ (w->buffer, obj)

                /* Don't find any minibuffer window except the one that
                   is currently in use.  */
                && (MINI_WINDOW_P (w) ? EQ (window, minibuf_window) : 1))
                /* Don't find any minibuffer window except the one that
                   is currently in use.  */
                && (MINI_WINDOW_P (w) ? EQ (window, minibuf_window) : 1))


@@ -2447,7 +2609,7 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
                if (EQ (window, selected_window))
                  /* Preferably return the selected window.  */
                  RETURN_UNGCPRO (window);
                if (EQ (window, selected_window))
                  /* Preferably return the selected window.  */
                  RETURN_UNGCPRO (window);

-               else if (EQ (WGET (XWINDOW (window), frame), selected_frame)
+               else if (EQ (XWINDOW (window)->frame, selected_frame)

                         && !frame_best_window_flag)
                  /* Prefer windows on the current frame (but don't
                     choose another one if we have one already).  */
                         && !frame_best_window_flag)
                  /* Prefer windows on the current frame (but don't
                     choose another one if we have one already).  */


@@ -2463,25 +2625,25 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
          case REPLACE_BUFFER_IN_WINDOWS_SAFELY:
            /* We could simply check whether the buffer shown by window
               is live, and show another buffer in case it isn't.  */
          case REPLACE_BUFFER_IN_WINDOWS_SAFELY:
            /* We could simply check whether the buffer shown by window
               is live, and show another buffer in case it isn't.  */

-           if (EQ (WGET (w, buffer), obj))
+           if (EQ (w->buffer, obj))

              {
                /* Undedicate WINDOW.  */
              {
                /* Undedicate WINDOW.  */

-               WSET (w, dedicated, Qnil);
+               wset_dedicated (w, Qnil);

                /* Make WINDOW show the buffer returned by
                   other_buffer_safely, don't run any hooks.  */
                set_window_buffer
                /* Make WINDOW show the buffer returned by
                   other_buffer_safely, don't run any hooks.  */
                set_window_buffer

-                 (window, other_buffer_safely (WGET (w, buffer)), 0, 0);
+                 (window, other_buffer_safely (w->buffer), 0, 0);

                /* If WINDOW is the selected window, make its buffer
                   current.  But do so only if the window shows the
                   current buffer (Bug#6454).  */
                if (EQ (window, selected_window)
                /* If WINDOW is the selected window, make its buffer
                   current.  But do so only if the window shows the
                   current buffer (Bug#6454).  */
                if (EQ (window, selected_window)

-                   && XBUFFER (WGET (w, buffer)) == current_buffer)
-                 Fset_buffer (WGET (w, buffer));
+                   && XBUFFER (w->buffer) == current_buffer)
+                 Fset_buffer (w->buffer);

              }
            break;
 
          case REDISPLAY_BUFFER_WINDOWS:
              }
            break;
 
          case REDISPLAY_BUFFER_WINDOWS:

-           if (EQ (WGET (w, buffer), obj))
+           if (EQ (w->buffer, obj))

              {
                mark_window_display_accurate (window, 0);
                w->update_mode_line = 1;
              {
                mark_window_display_accurate (window, 0);
                w->update_mode_line = 1;


@@ -2493,9 +2655,9 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
 
            /* Check for a window that has a killed buffer.  */
          case CHECK_ALL_WINDOWS:
 
            /* Check for a window that has a killed buffer.  */
          case CHECK_ALL_WINDOWS:

-           if (! NILP (WGET (w, buffer))
-               && NILP (BVAR (XBUFFER (WGET (w, buffer)), name)))
-             abort ();
+           if (! NILP (w->buffer)
+               && !BUFFER_LIVE_P (XBUFFER (w->buffer)))
+             emacs_abort ();

            break;
 
          case WINDOW_LOOP_UNUSED:
            break;
 
          case WINDOW_LOOP_UNUSED:


@@ -2559,8 +2721,8 @@ resize_root_window (Lisp_Object window, Lisp_Object delta, Lisp_Object horizonta
 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal,
        Sdelete_other_windows_internal, 0, 2, "",
        doc: /* Make WINDOW fill its frame.
 DEFUN ("delete-other-windows-internal", Fdelete_other_windows_internal,
        Sdelete_other_windows_internal, 0, 2, "",
        doc: /* Make WINDOW fill its frame.

-Only the frame WINDOW is on is affected.  WINDOW may be any window and
-defaults to the selected one.
+Only the frame WINDOW is on is affected.  WINDOW must be a valid window
+and defaults to the selected one.

 
 Optional argument ROOT, if non-nil, must specify an internal window such
 that WINDOW is in its window subtree.  If this is the case, replace ROOT
 
 Optional argument ROOT, if non-nil, must specify an internal window such
 that WINDOW is in its window subtree.  If this is the case, replace ROOT


@@ -2579,9 +2741,9 @@ window-start value is reasonable when this function is called.  */)
   ptrdiff_t startpos IF_LINT (= 0);
   int top IF_LINT (= 0), new_top, resize_failed;
 
   ptrdiff_t startpos IF_LINT (= 0);
   int top IF_LINT (= 0), new_top, resize_failed;
 

-  w = decode_any_window (window);
+  w = decode_valid_window (window);

   XSETWINDOW (window, w);
   XSETWINDOW (window, w);

-  f = XFRAME (WGET (w, frame));
+  f = XFRAME (w->frame);

 
   if (NILP (root))
     /* ROOT is the frame's root window.  */
 
   if (NILP (root))
     /* ROOT is the frame's root window.  */


@@ -2592,13 +2754,13 @@ window-start value is reasonable when this function is called.  */)
   else
     /* ROOT must be an ancestor of WINDOW.  */
     {
   else
     /* ROOT must be an ancestor of WINDOW.  */
     {

-      r = decode_any_window (root);
-      pwindow = WGET (XWINDOW (window), parent);
+      r = decode_valid_window (root);
+      pwindow = XWINDOW (window)->parent;

       while (!NILP (pwindow))
        if (EQ (pwindow, root))
          break;
        else
       while (!NILP (pwindow))
        if (EQ (pwindow, root))
          break;
        else

-         pwindow = WGET (XWINDOW (pwindow), parent);
+         pwindow = XWINDOW (pwindow)->parent;

       if (!EQ (pwindow, root))
        error ("Specified root is not an ancestor of specified window");
     }
       if (!EQ (pwindow, root))
        error ("Specified root is not an ancestor of specified window");
     }


@@ -2612,18 +2774,18 @@ window-start value is reasonable when this function is called.  */)
   else if (MINI_WINDOW_P (w)) /* && top > 0) */
     error ("Can't expand minibuffer to full frame");
 
   else if (MINI_WINDOW_P (w)) /* && top > 0) */
     error ("Can't expand minibuffer to full frame");
 

-  if (!NILP (WGET (w, buffer)))
+  if (!NILP (w->buffer))

     {
     {

-      startpos = marker_position (WGET (w, start));
+      startpos = marker_position (w->start);

       top = WINDOW_TOP_EDGE_LINE (w)
        - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
       /* Make sure WINDOW is the frame's selected window.  */
       if (!EQ (window, FRAME_SELECTED_WINDOW (f)))
        {
       top = WINDOW_TOP_EDGE_LINE (w)
        - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
       /* Make sure WINDOW is the frame's selected window.  */
       if (!EQ (window, FRAME_SELECTED_WINDOW (f)))
        {

-         if (EQ (selected_frame, WGET (w, frame)))
+         if (EQ (selected_frame, w->frame))

            Fselect_window (window, Qnil);
          else
            Fselect_window (window, Qnil);
          else

-           FSET (f, selected_window, window);
+           fset_selected_window (f, window);

        }
     }
   else
        }
     }
   else


@@ -2637,7 +2799,7 @@ window-start value is reasonable when this function is called.  */)
        {
          pwindow = swindow;
          while (!NILP (pwindow) && !EQ (window, pwindow))
        {
          pwindow = swindow;
          while (!NILP (pwindow) && !EQ (window, pwindow))

-           pwindow = WGET (XWINDOW (pwindow), parent);
+           pwindow = XWINDOW (pwindow)->parent;

 
          if (EQ (window, pwindow))
            /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok
 
          if (EQ (window, pwindow))
            /* If WINDOW is an ancestor of SWINDOW, then SWINDOW is ok


@@ -2650,14 +2812,14 @@ window-start value is reasonable when this function is called.  */)
 
       if (!EQ (swindow, FRAME_SELECTED_WINDOW (f)))
        {
 
       if (!EQ (swindow, FRAME_SELECTED_WINDOW (f)))
        {

-         if (EQ (selected_frame, WGET (w, frame)))
+         if (EQ (selected_frame, w->frame))

            Fselect_window (swindow, Qnil);
          else
            Fselect_window (swindow, Qnil);
          else

-           FSET (f, selected_window, swindow);
+           fset_selected_window (f, swindow);

        }
     }
 
        }
     }
 

-  BLOCK_INPUT;
+  block_input ();

   if (!FRAME_INITIAL_P (f))
     {
         Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
   if (!FRAME_INITIAL_P (f))
     {
         Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);


@@ -2683,12 +2845,12 @@ window-start value is reasonable when this function is called.  */)
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
   resize_failed = 0;
 
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
   resize_failed = 0;
 

-  if (NILP (WGET (w, buffer)))
+  if (NILP (w->buffer))

     {
       /* Resize child windows vertically.  */
     {
       /* Resize child windows vertically.  */

-      XSETINT (delta, XINT (WGET (r, total_lines))
-              - XINT (WGET (w, total_lines)));
-      WSET (w, top_line, WGET (r, top_line));
+      XSETINT (delta, XINT (r->total_lines)
+              - XINT (w->total_lines));
+      wset_top_line (w, r->top_line);

       resize_root_window (window, delta, Qnil, Qnil);
       if (window_resize_check (w, 0))
        window_resize_apply (w, 0);
       resize_root_window (window, delta, Qnil, Qnil);
       if (window_resize_check (w, 0))
        window_resize_apply (w, 0);


@@ -2704,10 +2866,10 @@ window-start value is reasonable when this function is called.  */)
       /* Resize child windows horizontally.  */
       if (!resize_failed)
        {
       /* Resize child windows horizontally.  */
       if (!resize_failed)
        {

-         WSET (w, left_col, WGET (r, left_col));
-         XSETINT (delta, XINT (WGET (r, total_cols)) 
-                  - XINT (WGET (w, total_cols)));
-         WSET (w, left_col, WGET (r, left_col));
+         wset_left_col (w, r->left_col);
+         XSETINT (delta,
+                  XINT (r->total_cols) - XINT (w->total_cols));
+         wset_left_col (w, r->left_col);

          resize_root_window (window, delta, Qt, Qnil);
          if (window_resize_check (w, 1))
            window_resize_apply (w, 1);
          resize_root_window (window, delta, Qt, Qnil);
          if (window_resize_check (w, 1))
            window_resize_apply (w, 1);


@@ -2730,43 +2892,43 @@ window-start value is reasonable when this function is called.  */)
     }
 
   /* Cleanly unlink WINDOW from window-tree.  */
     }
 
   /* Cleanly unlink WINDOW from window-tree.  */

-  if (!NILP (WGET (w, prev)))
+  if (!NILP (w->prev))

     /* Get SIBLING above (on the left of) WINDOW.  */
     {
     /* Get SIBLING above (on the left of) WINDOW.  */
     {

-      sibling = WGET (w, prev);
+      sibling = w->prev;

       s = XWINDOW (sibling);
       s = XWINDOW (sibling);

-      WSET (s, next, WGET (w, next));
-      if (!NILP (WGET (s, next)))
-       WSET (XWINDOW (WGET (s, next)), prev, sibling);
+      wset_next (s, w->next);
+      if (!NILP (s->next))
+       wset_prev (XWINDOW (s->next), sibling);

     }
   else
     /* Get SIBLING below (on the right of) WINDOW.  */
     {
     }
   else
     /* Get SIBLING below (on the right of) WINDOW.  */
     {

-      sibling = WGET (w, next);
+      sibling = w->next;

       s = XWINDOW (sibling);
       s = XWINDOW (sibling);

-      WSET (s, prev, Qnil);
-      if (!NILP (WGET (XWINDOW (WGET (w, parent)), vchild)))
-       WSET (XWINDOW (WGET (w, parent)), vchild, sibling);
+      wset_prev (s, Qnil);
+      if (!NILP (XWINDOW (w->parent)->vchild))
+       wset_vchild (XWINDOW (w->parent), sibling);

       else
       else

-       WSET (XWINDOW (WGET (w, parent)), hchild, sibling);
+       wset_hchild (XWINDOW (w->parent), sibling);

     }
 
   /* Delete ROOT and all child windows of ROOT.  */
     }
 
   /* Delete ROOT and all child windows of ROOT.  */

-  if (!NILP (WGET (r, vchild)))
+  if (!NILP (r->vchild))

     {
     {

-      delete_all_child_windows (WGET (r, vchild));
-      WSET (r, vchild, Qnil);
+      delete_all_child_windows (r->vchild);
+      wset_vchild (r, Qnil);

     }
     }

-  else if (!NILP (WGET (r, hchild)))
+  else if (!NILP (r->hchild))

     {
     {

-      delete_all_child_windows (WGET (r, hchild));
-      WSET (r, hchild, Qnil);
+      delete_all_child_windows (r->hchild);
+      wset_hchild (r, Qnil);

     }
 
   replace_window (root, window, 1);
 
   /* This must become SWINDOW anyway ....... */
     }
 
   replace_window (root, window, 1);
 
   /* This must become SWINDOW anyway ....... */

-  if (!NILP (WGET (w, buffer)) && !resize_failed)
+  if (!NILP (w->buffer) && !resize_failed)

     {
       /* Try to minimize scrolling, by setting the window start to the
         point will cause the text at the old window start to be at the
     {
       /* Try to minimize scrolling, by setting the window start to the
         point will cause the text at the old window start to be at the


@@ -2775,19 +2937,19 @@ window-start value is reasonable when this function is called.  */)
         when the display is not current, due to typeahead).  */
       new_top = WINDOW_TOP_EDGE_LINE (w) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
       if (new_top != top
         when the display is not current, due to typeahead).  */
       new_top = WINDOW_TOP_EDGE_LINE (w) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
       if (new_top != top

-         && startpos >= BUF_BEGV (XBUFFER (WGET (w, buffer)))
-         && startpos <= BUF_ZV (XBUFFER (WGET (w, buffer))))
+         && startpos >= BUF_BEGV (XBUFFER (w->buffer))
+         && startpos <= BUF_ZV (XBUFFER (w->buffer)))

        {
          struct position pos;
          struct buffer *obuf = current_buffer;
 
        {
          struct position pos;
          struct buffer *obuf = current_buffer;
 

-         Fset_buffer (WGET (w, buffer));
+         Fset_buffer (w->buffer);

          /* This computation used to temporarily move point, but that
             can have unwanted side effects due to text properties.  */
          pos = *vmotion (startpos, -top, w);
 
          /* This computation used to temporarily move point, but that
             can have unwanted side effects due to text properties.  */
          pos = *vmotion (startpos, -top, w);
 

-         set_marker_both (WGET (w, start), WGET (w, buffer), pos.bufpos, pos.bytepos);
-         WSET (w, window_end_valid, Qnil);
+         set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
+         wset_window_end_valid (w, Qnil);

          w->start_at_line_beg = (pos.bytepos == BEGV_BYTE
                                    || FETCH_BYTE (pos.bytepos - 1) == '\n');
          /* We need to do this, so that the window-scroll-functions
          w->start_at_line_beg = (pos.bytepos == BEGV_BYTE
                                    || FETCH_BYTE (pos.bytepos - 1) == '\n');
          /* We need to do this, so that the window-scroll-functions


@@ -2799,7 +2961,7 @@ window-start value is reasonable when this function is called.  */)
     }
 
   adjust_glyphs (f);
     }
 
   adjust_glyphs (f);

-  UNBLOCK_INPUT;
+  unblock_input ();

 
   run_window_configuration_change_hook (f);
 
 
   run_window_configuration_change_hook (f);
 


@@ -2878,14 +3040,14 @@ adjust_window_margins (struct window *w)
     {
       if (WINDOW_LEFT_MARGIN_COLS (w) > 0)
        {
     {
       if (WINDOW_LEFT_MARGIN_COLS (w) > 0)
        {

-         WSET (w, left_margin_cols, make_number (margin_cols / 2));
-         WSET (w, right_margin_cols, make_number (margin_cols / 2));   
+         wset_left_margin_cols (w, make_number (margin_cols / 2));
+         wset_right_margin_cols (w, make_number (margin_cols / 2));

        }
       else
        }
       else

-       WSET (w, right_margin_cols, make_number (margin_cols));
+       wset_right_margin_cols (w, make_number (margin_cols));

     }
   else
     }
   else

-    WSET (w, left_margin_cols, make_number (margin_cols));
+    wset_left_margin_cols (w, make_number (margin_cols));

   return 1;
 }
 \f
   return 1;
 }
 \f


@@ -2927,7 +3089,7 @@ run_window_configuration_change_hook (struct frame *f)
   /* Use the right buffer.  Matters when running the local hooks.  */
   if (current_buffer != XBUFFER (Fwindow_buffer (Qnil)))
     {
   /* Use the right buffer.  Matters when running the local hooks.  */
   if (current_buffer != XBUFFER (Fwindow_buffer (Qnil)))
     {

-      record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+      record_unwind_current_buffer ();

       Fset_buffer (Fwindow_buffer (Qnil));
     }
 
       Fset_buffer (Fwindow_buffer (Qnil));
     }
 


@@ -2964,7 +3126,7 @@ run_window_configuration_change_hook (struct frame *f)
 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook,
        Srun_window_configuration_change_hook, 1, 1, 0,
        doc: /* Run `window-configuration-change-hook' for FRAME.  */)
 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook,
        Srun_window_configuration_change_hook, 1, 1, 0,
        doc: /* Run `window-configuration-change-hook' for FRAME.  */)

-     (Lisp_Object frame)
+  (Lisp_Object frame)

 {
   CHECK_LIVE_FRAME (frame);
   run_window_configuration_change_hook (XFRAME (frame));
 {
   CHECK_LIVE_FRAME (frame);
   run_window_configuration_change_hook (XFRAME (frame));


@@ -2983,25 +3145,25 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
   struct window *w = XWINDOW (window);
   struct buffer *b = XBUFFER (buffer);
   ptrdiff_t count = SPECPDL_INDEX ();
   struct window *w = XWINDOW (window);
   struct buffer *b = XBUFFER (buffer);
   ptrdiff_t count = SPECPDL_INDEX ();

-  int samebuf = EQ (buffer, WGET (w, buffer));
+  int samebuf = EQ (buffer, w->buffer);

 
 

-  WSET (w, buffer, buffer);
+  wset_buffer (w, buffer);

 
   if (EQ (window, selected_window))
 
   if (EQ (window, selected_window))

-    BVAR (b, last_selected_window) = window;
+    bset_last_selected_window (b, window);

 
   /* Let redisplay errors through.  */
   b->display_error_modiff = 0;
 
   /* Update time stamps of buffer display.  */
   if (INTEGERP (BVAR (b, display_count)))
 
   /* Let redisplay errors through.  */
   b->display_error_modiff = 0;
 
   /* Update time stamps of buffer display.  */
   if (INTEGERP (BVAR (b, display_count)))

-    XSETINT (BVAR (b, display_count), XINT (BVAR (b, display_count)) + 1);
-  BVAR (b, display_time) = Fcurrent_time ();
+    bset_display_count (b, make_number (XINT (BVAR (b, display_count)) + 1));
+  bset_display_time (b, Fcurrent_time ());

 
 

-  WSET (w, window_end_pos, make_number (0));
-  WSET (w, window_end_vpos, make_number (0));
+  wset_window_end_pos (w, make_number (0));
+  wset_window_end_vpos (w, make_number (0));

   memset (&w->last_cursor, 0, sizeof w->last_cursor);
   memset (&w->last_cursor, 0, sizeof w->last_cursor);

-  WSET (w, window_end_valid, Qnil);
+  wset_window_end_valid (w, Qnil);

   if (!(keep_margins_p && samebuf))
     { /* If we're not actually changing the buffer, don't reset hscroll and
         vscroll.  This case happens for example when called from
   if (!(keep_margins_p && samebuf))
     { /* If we're not actually changing the buffer, don't reset hscroll and
         vscroll.  This case happens for example when called from


@@ -3013,8 +3175,8 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
         whenever we resize the frame.  */
       w->hscroll = w->min_hscroll = 0;
       w->vscroll = 0;
         whenever we resize the frame.  */
       w->hscroll = w->min_hscroll = 0;
       w->vscroll = 0;

-      set_marker_both (WGET (w, pointm), buffer, BUF_PT (b), BUF_PT_BYTE (b));
-      set_marker_restricted (WGET (w, start),
+      set_marker_both (w->pointm, buffer, BUF_PT (b), BUF_PT_BYTE (b));
+      set_marker_restricted (w->start,

                             make_number (b->last_window_start),
                             buffer);
       w->start_at_line_beg = 0;
                             make_number (b->last_window_start),
                             buffer);
       w->start_at_line_beg = 0;


@@ -3031,11 +3193,11 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
      because that might itself be a local variable.  */
   if (window_initialized)
     {
      because that might itself be a local variable.  */
   if (window_initialized)
     {

-      record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+      record_unwind_current_buffer ();

       Fset_buffer (buffer);
     }
 
       Fset_buffer (buffer);
     }
 

-  XMARKER (WGET (w, pointm))->insertion_type = !NILP (Vwindow_point_insertion_type);
+  XMARKER (w->pointm)->insertion_type = !NILP (Vwindow_point_insertion_type);

 
   if (!keep_margins_p)
     {
 
   if (!keep_margins_p)
     {


@@ -3043,11 +3205,11 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
 
       /* This may call adjust_window_margins three times, so
         temporarily disable window margins.  */
 
       /* This may call adjust_window_margins three times, so
         temporarily disable window margins.  */

-      Lisp_Object save_left = WGET (w, left_margin_cols);
-      Lisp_Object save_right = WGET (w, right_margin_cols);
+      Lisp_Object save_left = w->left_margin_cols;
+      Lisp_Object save_right = w->right_margin_cols;

 
 

-      WSET (w, left_margin_cols, Qnil);
-      WSET (w, right_margin_cols, Qnil);
+      wset_left_margin_cols (w, Qnil);
+      wset_right_margin_cols (w, Qnil);

 
       Fset_window_fringes (window,
                           BVAR (b, left_fringe_width), BVAR (b, right_fringe_width),
 
       Fset_window_fringes (window,
                           BVAR (b, left_fringe_width), BVAR (b, right_fringe_width),


@@ -3057,8 +3219,8 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
                               BVAR (b, scroll_bar_width),
                               BVAR (b, vertical_scroll_bar_type), Qnil);
 
                               BVAR (b, scroll_bar_width),
                               BVAR (b, vertical_scroll_bar_type), Qnil);
 

-      WSET (w, left_margin_cols, save_left);
-      WSET (w, right_margin_cols, save_right);
+      wset_left_margin_cols (w, save_left);
+      wset_right_margin_cols (w, save_right);

 
       Fset_window_margins (window,
                           BVAR (b, left_margin_cols), BVAR (b, right_margin_cols));
 
       Fset_window_margins (window,
                           BVAR (b, left_margin_cols), BVAR (b, right_margin_cols));


@@ -3068,7 +3230,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
     {
       if (! NILP (Vwindow_scroll_functions))
        run_hook_with_args_2 (Qwindow_scroll_functions, window,
     {
       if (! NILP (Vwindow_scroll_functions))
        run_hook_with_args_2 (Qwindow_scroll_functions, window,

-                             Fmarker_position (WGET (w, start)));
+                             Fmarker_position (w->start));

       run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w)));
     }
 
       run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w)));
     }
 


@@ -3077,7 +3239,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
 
 DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 3, 0,
        doc: /* Make WINDOW display BUFFER-OR-NAME as its contents.
 
 DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 3, 0,
        doc: /* Make WINDOW display BUFFER-OR-NAME as its contents.

-WINDOW has to be a live window and defaults to the selected one.
+WINDOW must be a live window and defaults to the selected one.

 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
 
 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current
 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
 
 Optional third argument KEEP-MARGINS non-nil means that WINDOW's current


@@ -3094,15 +3256,15 @@ This function runs `window-scroll-functions' before running
   (register Lisp_Object window, Lisp_Object buffer_or_name, Lisp_Object keep_margins)
 {
   register Lisp_Object tem, buffer;
   (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);
+  register struct window *w = decode_live_window (window);

 
   XSETWINDOW (window, w);
   buffer = Fget_buffer (buffer_or_name);
   CHECK_BUFFER (buffer);
 
   XSETWINDOW (window, w);
   buffer = Fget_buffer (buffer_or_name);
   CHECK_BUFFER (buffer);

-  if (NILP (BVAR (XBUFFER (buffer), name)))
+  if (!BUFFER_LIVE_P (XBUFFER (buffer)))

     error ("Attempt to display deleted buffer");
 
     error ("Attempt to display deleted buffer");
 

-  tem = WGET (w, buffer);
+  tem = w->buffer;

   if (NILP (tem))
     error ("Window is deleted");
   else if (!EQ (tem, Qt))
   if (NILP (tem))
     error ("Window is deleted");
   else if (!EQ (tem, Qt))


@@ -3110,14 +3272,14 @@ This function runs `window-scroll-functions' before running
     {
       if (!EQ (tem, buffer))
        {
     {
       if (!EQ (tem, buffer))
        {

-         if (EQ (WGET (w, dedicated), Qt))
+         if (EQ (w->dedicated, Qt))

            /* WINDOW is strongly dedicated to its buffer, signal an
               error.  */
            error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem), name)));
          else
            /* WINDOW is weakly dedicated to its buffer, reset
               dedication.  */
            /* WINDOW is strongly dedicated to its buffer, signal an
               error.  */
            error ("Window is dedicated to `%s'", SDATA (BVAR (XBUFFER (tem), name)));
          else
            /* WINDOW is weakly dedicated to its buffer, reset
               dedication.  */

-           WSET (w, dedicated, Qnil);
+           wset_dedicated (w, Qnil);

 
          call1 (Qrecord_window_buffer, window);
        }
 
          call1 (Qrecord_window_buffer, window);
        }


@@ -3156,15 +3318,15 @@ displaying that buffer.  */)
       struct window *w = XWINDOW (object);
       mark_window_display_accurate (object, 0);
       w->update_mode_line = 1;
       struct window *w = XWINDOW (object);
       mark_window_display_accurate (object, 0);
       w->update_mode_line = 1;

-      if (BUFFERP (WGET (w, buffer)))
-       XBUFFER (WGET (w, buffer))->prevent_redisplay_optimizations_p = 1;
+      if (BUFFERP (w->buffer))
+       XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;

       ++update_mode_lines;
       return Qt;
     }
 
   if (STRINGP (object))
     object = Fget_buffer (object);
       ++update_mode_lines;
       return Qt;
     }
 
   if (STRINGP (object))
     object = Fget_buffer (object);

-  if (BUFFERP (object) && !NILP (BVAR (XBUFFER (object), name)))
+  if (BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)))

     {
       /* Walk all windows looking for buffer, and force update
         of each of those windows.  */
     {
       /* Walk all windows looking for buffer, and force update
         of each of those windows.  */


@@ -3187,7 +3349,7 @@ temp_output_buffer_show (register Lisp_Object buf)
   register Lisp_Object window;
   register struct window *w;
 
   register Lisp_Object window;
   register struct window *w;
 

-  BVAR (XBUFFER (buf), directory) = BVAR (current_buffer, directory);
+  bset_directory (XBUFFER (buf), BVAR (current_buffer, directory));

 
   Fset_buffer (buf);
   BUF_SAVE_MODIFF (XBUFFER (buf)) = MODIFF;
 
   Fset_buffer (buf);
   BUF_SAVE_MODIFF (XBUFFER (buf)) = MODIFF;


@@ -3202,14 +3364,14 @@ temp_output_buffer_show (register Lisp_Object buf)
     {
       window = display_buffer (buf, Qnil, Qnil);
 
     {
       window = display_buffer (buf, Qnil, Qnil);
 

-      if (!EQ (WGET (XWINDOW (window), frame), selected_frame))
+      if (!EQ (XWINDOW (window)->frame, selected_frame))

        Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window)));
       Vminibuf_scroll_window = window;
       w = XWINDOW (window);
       w->hscroll = 0;
       w->min_hscroll = 0;
        Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window)));
       Vminibuf_scroll_window = window;
       w = XWINDOW (window);
       w->hscroll = 0;
       w->min_hscroll = 0;

-      set_marker_restricted_both (WGET (w, start), buf, BEG, BEG);
-      set_marker_restricted_both (WGET (w, pointm), buf, BEG, BEG);
+      set_marker_restricted_both (w->start, buf, BEG, BEG);
+      set_marker_restricted_both (w->pointm, buf, BEG, BEG);

 
       /* Run temp-buffer-show-hook, with the chosen window selected
         and its buffer current.  */
 
       /* Run temp-buffer-show-hook, with the chosen window selected
         and its buffer current.  */


@@ -3226,7 +3388,7 @@ temp_output_buffer_show (register Lisp_Object buf)
         record_unwind_protect (Fset_buffer, prev_buffer);
         record_unwind_protect (select_window_norecord, prev_window);
         Fselect_window (window, Qt);
         record_unwind_protect (Fset_buffer, prev_buffer);
         record_unwind_protect (select_window_norecord, prev_window);
         Fselect_window (window, Qt);

-        Fset_buffer (WGET (w, buffer));
+        Fset_buffer (w->buffer);

         Frun_hooks (1, &Qtemp_buffer_show_hook);
         unbind_to (count, Qnil);
       }
         Frun_hooks (1, &Qtemp_buffer_show_hook);
         unbind_to (count, Qnil);
       }


@@ -3263,17 +3425,17 @@ make_parent_window (Lisp_Object window, int horflag)
 
   replace_window (window, parent, 1);
 
 
   replace_window (window, parent, 1);
 

-  WSET (o, next, Qnil);
-  WSET (o, prev, Qnil);
-  WSET (o, parent, parent);
+  wset_next (o, Qnil);
+  wset_prev (o, Qnil);
+  wset_parent (o, parent);

 
 

-  WSET (p, hchild, horflag ? window : Qnil);
-  WSET (p, vchild, horflag ? Qnil : window);
-  WSET (p, start, Qnil);
-  WSET (p, pointm, Qnil);
-  WSET (p, buffer, Qnil);
-  WSET (p, combination_limit, Qnil);
-  WSET (p, window_parameters, Qnil);
+  wset_hchild (p, horflag ? window : Qnil);
+  wset_vchild (p, horflag ? Qnil : window);
+  wset_start (p, Qnil);
+  wset_pointm (p, Qnil);
+  wset_buffer (p, Qnil);
+  wset_combination_limit (p, Qnil);
+  wset_window_parameters (p, Qnil);

 }
 
 /* Make new window from scratch.  */
 }
 
 /* Make new window from scratch.  */


@@ -3286,19 +3448,23 @@ make_window (void)
   w = allocate_window ();
   /* Initialize Lisp data.  Note that allocate_window initializes all
      Lisp data to nil, so do it only for slots which should not be nil.  */
   w = allocate_window ();
   /* Initialize Lisp data.  Note that allocate_window initializes all
      Lisp data to nil, so do it only for slots which should not be nil.  */

-  WSET (w, left_col, make_number (0));
-  WSET (w, top_line, make_number (0));
-  WSET (w, total_lines, make_number (0));
-  WSET (w, total_cols, make_number (0));
-  WSET (w, normal_lines, make_float (1.0));
-  WSET (w, normal_cols, make_float (1.0));
-  WSET (w, new_total, make_number (0));
-  WSET (w, new_normal, make_number (0));
-  WSET (w, start, Fmake_marker ());
-  WSET (w, pointm, Fmake_marker ());
-  WSET (w, vertical_scroll_bar_type, Qt);
-  WSET (w, window_end_pos, make_number (0));
-  WSET (w, window_end_vpos, make_number (0));
+  wset_left_col (w, make_number (0));
+  wset_top_line (w, make_number (0));
+  wset_total_lines (w, make_number (0));
+  wset_total_cols (w, make_number (0));
+  wset_normal_lines (w, make_float (1.0));
+  wset_normal_cols (w, make_float (1.0));
+  wset_new_total (w, make_number (0));
+  wset_new_normal (w, make_number (0));
+  wset_start (w, Fmake_marker ());
+  wset_pointm (w, Fmake_marker ());
+  wset_vertical_scroll_bar_type (w, Qt);
+  wset_window_end_pos (w, make_number (0));
+  wset_window_end_vpos (w, make_number (0));
+  /* These Lisp fields are marked specially so they're not set to nil by
+     allocate_window.  */
+  wset_prev_buffers (w, Qnil);
+  wset_next_buffers (w, Qnil);

 
   /* Initialize non-Lisp data.  Note that allocate_window zeroes out all
      non-Lisp data, so do it only for slots which should not be zero.  */
 
   /* Initialize non-Lisp data.  Note that allocate_window zeroes out all
      non-Lisp data, so do it only for slots which should not be zero.  */


@@ -3316,6 +3482,7 @@ make_window (void)
 \f
 DEFUN ("set-window-new-total", Fset_window_new_total, Sset_window_new_total, 2, 3, 0,
        doc: /* Set new total size of WINDOW to SIZE.
 \f
 DEFUN ("set-window-new-total", Fset_window_new_total, Sset_window_new_total, 2, 3, 0,
        doc: /* Set new total size of WINDOW to SIZE.

+WINDOW must be a valid window and defaults to the selected one.

 Return SIZE.
 
 Optional argument ADD non-nil means add SIZE to the new total size of
 Return SIZE.
 
 Optional argument ADD non-nil means add SIZE to the new total size of


@@ -3324,25 +3491,27 @@ WINDOW and return the sum.
 Note: This function does not operate on any child windows of WINDOW.  */)
      (Lisp_Object window, Lisp_Object size, Lisp_Object add)
 {
 Note: This function does not operate on any child windows of WINDOW.  */)
      (Lisp_Object window, Lisp_Object size, Lisp_Object add)
 {

-  struct window *w = decode_any_window (window);
+  struct window *w = decode_valid_window (window);

 
   CHECK_NUMBER (size);
   if (NILP (add))
 
   CHECK_NUMBER (size);
   if (NILP (add))

-    WSET (w, new_total, size);
+    wset_new_total (w, size);

   else
   else

-    WSET (w, new_total, make_number (XINT (WGET (w, new_total)) + XINT (size)));
+    wset_new_total (w, make_number (XINT (w->new_total) + XINT (size)));

 
 

-  return WGET (w, new_total);
+  return w->new_total;

 }
 
 DEFUN ("set-window-new-normal", Fset_window_new_normal, Sset_window_new_normal, 1, 2, 0,
        doc: /* Set new normal size of WINDOW to SIZE.
 }
 
 DEFUN ("set-window-new-normal", Fset_window_new_normal, Sset_window_new_normal, 1, 2, 0,
        doc: /* Set new normal size of WINDOW to SIZE.

+WINDOW must be a valid window and defaults to the selected one.

 Return SIZE.
 
 Note: This function does not operate on any child windows of WINDOW.  */)
      (Lisp_Object window, Lisp_Object size)
 {
 Return SIZE.
 
 Note: This function does not operate on any child windows of WINDOW.  */)
      (Lisp_Object window, Lisp_Object size)
 {

-  return WSET (decode_any_window (window), new_normal, size);
+  wset_new_normal (decode_valid_window (window), size);
+  return size;

 }
 
 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
 }
 
 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is


@@ -3357,19 +3526,19 @@ window_resize_check (struct window *w, int horflag)
 {
   struct window *c;
 
 {
   struct window *c;
 

-  if (!NILP (WGET (w, vchild)))
+  if (!NILP (w->vchild))

     /* W is a vertical combination.  */
     {
     /* W is a vertical combination.  */
     {

-      c = XWINDOW (WGET (w, vchild));
+      c = XWINDOW (w->vchild);

       if (horflag)
        /* All child windows of W must have the same width as W.  */
        {
          while (c)
            {
       if (horflag)
        /* All child windows of W must have the same width as W.  */
        {
          while (c)
            {

-             if ((XINT (WGET (c, new_total)) != XINT (WGET (w, new_total)))
+             if ((XINT (c->new_total) != XINT (w->new_total))

                  || !window_resize_check (c, horflag))
                return 0;
                  || !window_resize_check (c, horflag))
                return 0;

-             c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
+             c = NILP (c->next) ? 0 : XWINDOW (c->next);

            }
          return 1;
        }
            }
          return 1;
        }


@@ -3382,16 +3551,16 @@ window_resize_check (struct window *w, int horflag)
            {
              if (!window_resize_check (c, horflag))
                return 0;
            {
              if (!window_resize_check (c, horflag))
                return 0;

-             sum_of_sizes = sum_of_sizes + XINT (WGET (c, new_total));
-             c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
+             sum_of_sizes = sum_of_sizes + XINT (c->new_total);
+             c = NILP (c->next) ? 0 : XWINDOW (c->next);

            }
            }

-         return (sum_of_sizes == XINT (WGET (w, new_total)));
+         return (sum_of_sizes == XINT (w->new_total));

        }
     }
        }
     }

-  else if (!NILP (WGET (w, hchild)))
+  else if (!NILP (w->hchild))

     /* W is a horizontal combination.  */
     {
     /* W is a horizontal combination.  */
     {

-      c = XWINDOW (WGET (w, hchild));
+      c = XWINDOW (w->hchild);

       if (horflag)
        /* The sum of the widths of the child windows of W must equal W's
           width.  */
       if (horflag)
        /* The sum of the widths of the child windows of W must equal W's
           width.  */


@@ -3401,20 +3570,20 @@ window_resize_check (struct window *w, int horflag)
            {
              if (!window_resize_check (c, horflag))
                return 0;
            {
              if (!window_resize_check (c, horflag))
                return 0;

-             sum_of_sizes = sum_of_sizes + XINT (WGET (c, new_total));
-             c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
+             sum_of_sizes = sum_of_sizes + XINT (c->new_total);
+             c = NILP (c->next) ? 0 : XWINDOW (c->next);

            }
            }

-         return (sum_of_sizes == XINT (WGET (w, new_total)));
+         return (sum_of_sizes == XINT (w->new_total));

        }
       else
        /* All child windows of W must have the same height as W.  */
        {
          while (c)
            {
        }
       else
        /* All child windows of W must have the same height as W.  */
        {
          while (c)
            {

-             if ((XINT (WGET (c, new_total)) != XINT (WGET (w, new_total)))
+             if ((XINT (c->new_total) != XINT (w->new_total))

                  || !window_resize_check (c, horflag))
                return 0;
                  || !window_resize_check (c, horflag))
                return 0;

-             c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
+             c = NILP (c->next) ? 0 : XWINDOW (c->next);

            }
          return 1;
        }
            }
          return 1;
        }


@@ -3423,7 +3592,7 @@ window_resize_check (struct window *w, int horflag)
     /* A leaf window.  Make sure it's not too small.  The following
        hardcodes the values of `window-safe-min-width' (2) and
        `window-safe-min-height' (1) which are defined in window.el.  */
     /* A leaf window.  Make sure it's not too small.  The following
        hardcodes the values of `window-safe-min-width' (2) and
        `window-safe-min-height' (1) which are defined in window.el.  */

-    return XINT (WGET (w, new_total)) >= (horflag ? 2 : 1);
+    return XINT (w->new_total) >= (horflag ? 2 : 1);

 }
 
 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
 }
 
 /* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to


@@ -3443,51 +3612,51 @@ window_resize_apply (struct window *w, int horflag)
      parent window has been set *before*.  */
   if (horflag)
     {
      parent window has been set *before*.  */
   if (horflag)
     {

-      WSET (w, total_cols, WGET (w, new_total));
-      if (NUMBERP (WGET (w, new_normal)))
-       WSET (w, normal_cols, WGET (w, new_normal));
+      wset_total_cols (w, w->new_total);
+      if (NUMBERP (w->new_normal))
+       wset_normal_cols (w, w->new_normal);

 
 

-      pos = XINT (WGET (w, left_col));
+      pos = XINT (w->left_col);

     }
   else
     {
     }
   else
     {

-      WSET (w, total_lines, WGET (w, new_total));
-      if (NUMBERP (WGET (w, new_normal)))
-       WSET (w, normal_lines, WGET (w, new_normal));
+      wset_total_lines (w, w->new_total);
+      if (NUMBERP (w->new_normal))
+       wset_normal_lines (w, w->new_normal);

 
 

-      pos = XINT (WGET (w, top_line));
+      pos = XINT (w->top_line);

     }
 
     }
 

-  if (!NILP (WGET (w, vchild)))
+  if (!NILP (w->vchild))

     /* W is a vertical combination.  */
     {
     /* W is a vertical combination.  */
     {

-      c = XWINDOW (WGET (w, vchild));
+      c = XWINDOW (w->vchild);

       while (c)
        {
          if (horflag)
       while (c)
        {
          if (horflag)

-           WSET (c, left_col, make_number (pos));
+           wset_left_col (c, make_number (pos));

          else
          else

-           WSET (c, top_line, make_number (pos));
+           wset_top_line (c, make_number (pos));

          window_resize_apply (c, horflag);
          if (!horflag)
          window_resize_apply (c, horflag);
          if (!horflag)

-           pos = pos + XINT (WGET (c, total_lines));
-         c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
+           pos = pos + XINT (c->total_lines);
+         c = NILP (c->next) ? 0 : XWINDOW (c->next);

        }
     }
        }
     }

-  else if (!NILP (WGET (w, hchild)))
+  else if (!NILP (w->hchild))

     /* W is a horizontal combination.  */
     {
     /* W is a horizontal combination.  */
     {

-      c = XWINDOW (WGET (w, hchild));
+      c = XWINDOW (w->hchild);

       while (c)
        {
          if (horflag)
       while (c)
        {
          if (horflag)

-           WSET (c, left_col, make_number (pos));
+           wset_left_col (c, make_number (pos));

          else
          else

-           WSET (c, top_line, make_number (pos));
+           wset_top_line (c, make_number (pos));

          window_resize_apply (c, horflag);
          if (horflag)
          window_resize_apply (c, horflag);
          if (horflag)

-           pos = pos + XINT (WGET (c, total_cols));
-         c = NILP (WGET (c, next)) ? 0 : XWINDOW (WGET (c, next));
+           pos = pos + XINT (c->total_cols);
+         c = NILP (c->next) ? 0 : XWINDOW (c->next);

        }
     }
 
        }
     }
 


@@ -3523,18 +3692,18 @@ be applied on the Elisp level.  */)
   r = XWINDOW (FRAME_ROOT_WINDOW (f));
 
   if (!window_resize_check (r, horflag)
   r = XWINDOW (FRAME_ROOT_WINDOW (f));
 
   if (!window_resize_check (r, horflag)

-      || ! EQ (WGET (r, new_total),
-              (horflag ? WGET (r, total_cols) : WGET (r, total_lines))))
+      || ! EQ (r->new_total,
+              (horflag ? r->total_cols : r->total_lines)))

     return Qnil;
 
     return Qnil;
 

-  BLOCK_INPUT;
+  block_input ();

   window_resize_apply (r, horflag);
 
   windows_or_buffers_changed++;
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
   adjust_glyphs (f);
   window_resize_apply (r, horflag);
 
   windows_or_buffers_changed++;
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
   adjust_glyphs (f);

-  UNBLOCK_INPUT;
+  unblock_input ();

 
   run_window_configuration_change_hook (f);
 
 
   run_window_configuration_change_hook (f);
 


@@ -3564,39 +3733,39 @@ resize_frame_windows (struct frame *f, int size, int horflag)
                     - ((FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
                        ? 1 : 0)));
 
                     - ((FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
                        ? 1 : 0)));
 

-  WSET (r, top_line, make_number (FRAME_TOP_MARGIN (f)));
-  if (NILP (WGET (r, vchild)) && NILP (WGET (r, hchild)))
+  wset_top_line (r, make_number (FRAME_TOP_MARGIN (f)));
+  if (NILP (r->vchild) && NILP (r->hchild))

     /* For a leaf root window just set the size.  */
     if (horflag)
     /* For a leaf root window just set the size.  */
     if (horflag)

-      WSET (r, total_cols, make_number (new_size));
+      wset_total_cols (r, make_number (new_size));

     else
     else

-      WSET (r, total_lines, make_number (new_size));
+      wset_total_lines (r, make_number (new_size));

   else
     {
       /* old_size is the old size of the frame's root window.  */
   else
     {
       /* old_size is the old size of the frame's root window.  */

-      int old_size = XFASTINT (horflag ? WGET (r, total_cols) 
-                              : WGET (r, total_lines));
+      int old_size = XFASTINT (horflag ? r->total_cols
+                              : r->total_lines);

       Lisp_Object delta;
 
       XSETINT (delta, new_size - old_size);
       /* Try a "normal" resize first.  */
       resize_root_window (root, delta, horflag ? Qt : Qnil, Qnil);
       if (window_resize_check (r, horflag)
       Lisp_Object delta;
 
       XSETINT (delta, new_size - old_size);
       /* Try a "normal" resize first.  */
       resize_root_window (root, delta, horflag ? Qt : Qnil, Qnil);
       if (window_resize_check (r, horflag)

-         && new_size == XINT (WGET (r, new_total)))
+         && new_size == XINT (r->new_total))

        window_resize_apply (r, horflag);
       else
        {
          /* Try with "reasonable" minimum sizes next.  */
          resize_root_window (root, delta, horflag ? Qt : Qnil, Qt);
          if (window_resize_check (r, horflag)
        window_resize_apply (r, horflag);
       else
        {
          /* Try with "reasonable" minimum sizes next.  */
          resize_root_window (root, delta, horflag ? Qt : Qnil, Qt);
          if (window_resize_check (r, horflag)

-             && new_size == XINT (WGET (r, new_total)))
+             && new_size == XINT (r->new_total))

            window_resize_apply (r, horflag);
          else
            {
              /* Finally, try with "safe" minimum sizes.  */
              resize_root_window (root, delta, horflag ? Qt : Qnil, Qsafe);
              if (window_resize_check (r, horflag)
            window_resize_apply (r, horflag);
          else
            {
              /* Finally, try with "safe" minimum sizes.  */
              resize_root_window (root, delta, horflag ? Qt : Qnil, Qsafe);
              if (window_resize_check (r, horflag)

-                 && new_size == XINT (WGET (r, new_total)))
+                 && new_size == XINT (r->new_total))

                window_resize_apply (r, horflag);
              else
                {
                window_resize_apply (r, horflag);
              else
                {


@@ -3605,9 +3774,9 @@ resize_frame_windows (struct frame *f, int size, int horflag)
                  root = f->selected_window;
                  Fdelete_other_windows_internal (root, Qnil);
                  if (horflag)
                  root = f->selected_window;
                  Fdelete_other_windows_internal (root, Qnil);
                  if (horflag)

-                   WSET (XWINDOW (root), total_cols, make_number (new_size));
+                   wset_total_cols (XWINDOW (root), make_number (new_size));

                  else
                  else

-                   WSET (XWINDOW (root), total_lines, make_number (new_size));
+                   wset_total_lines (XWINDOW (root), make_number (new_size));

                }
            }
        }
                }
            }
        }


@@ -3617,13 +3786,13 @@ resize_frame_windows (struct frame *f, int size, int horflag)
     {
       m = XWINDOW (mini);
       if (horflag)
     {
       m = XWINDOW (mini);
       if (horflag)

-       WSET (m, total_cols, make_number (size));
+       wset_total_cols (m, make_number (size));

       else
        {
          /* Are we sure we always want 1 line here?  */
       else
        {
          /* Are we sure we always want 1 line here?  */

-         WSET (m, total_lines, make_number (1));
-         WSET (m, top_line,
-               make_number (XINT (WGET (r, top_line)) + XINT (WGET (r, total_lines))));
+         wset_total_lines (m, make_number (1));
+         wset_top_line
+           (m, make_number (XINT (r->top_line) + XINT (r->total_lines)));

        }
     }
 }
        }
     }
 }


@@ -3678,11 +3847,11 @@ set correctly.  See the code of `split-window' for how this is done.  */)
      We do that if either `window-combination-limit' is t, or OLD has no
      parent, or OLD is ortho-combined.  */
   combination_limit =
      We do that if either `window-combination-limit' is t, or OLD has no
      parent, or OLD is ortho-combined.  */
   combination_limit =

-    !NILP (Vwindow_combination_limit)
-    || NILP (WGET (o, parent))
+    EQ (Vwindow_combination_limit, Qt)
+    || NILP (o->parent)

     || NILP (horflag
     || NILP (horflag

-            ? (WGET (XWINDOW (WGET (o, parent)), hchild))
-            : (WGET (XWINDOW (WGET (o, parent)), vchild)));
+            ? (XWINDOW (o->parent)->hchild)
+            : (XWINDOW (o->parent)->vchild));

 
   /* We need a live reference window to initialize some parameters.  */
   if (WINDOW_LIVE_P (old))
 
   /* We need a live reference window to initialize some parameters.  */
   if (WINDOW_LIVE_P (old))


@@ -3702,24 +3871,23 @@ set correctly.  See the code of `split-window' for how this is done.  */)
     /* `window-combination-resize' non-nil means try to resize OLD's siblings
        proportionally.  */
     {
     /* `window-combination-resize' non-nil means try to resize OLD's siblings
        proportionally.  */
     {

-      p = XWINDOW (WGET (o, parent));
+      p = XWINDOW (o->parent);

       /* Temporarily pretend we split the parent window.  */
       /* Temporarily pretend we split the parent window.  */

-      WSET (p, new_total,
-           make_number (XINT (horflag ? WGET (p, total_cols) : WGET (p, total_lines))
+      wset_new_total
+       (p, make_number (XINT (horflag ? p->total_cols : p->total_lines)

                         - XINT (total_size)));
       if (!window_resize_check (p, horflag))
        error ("Window sizes don't fit");
       else
        /* Undo the temporary pretension.  */
                         - XINT (total_size)));
       if (!window_resize_check (p, horflag))
        error ("Window sizes don't fit");
       else
        /* Undo the temporary pretension.  */

-       WSET (p, new_total,
-             horflag ? WGET (p, total_cols) : WGET (p, total_lines));
+       wset_new_total (p, horflag ? p->total_cols : p->total_lines);

     }
   else
     {
       if (!window_resize_check (o, horflag))
        error ("Resizing old window failed");
     }
   else
     {
       if (!window_resize_check (o, horflag))
        error ("Resizing old window failed");

-      else if (XINT (total_size) + XINT (WGET (o, new_total))
-              != XINT (horflag ? WGET (o, total_cols) : WGET (o, total_lines)))
+      else if (XINT (total_size) + XINT (o->new_total)
+              != XINT (horflag ? o->total_cols : o->total_lines))

        error ("Sum of sizes of old and new window don't fit");
     }
 
        error ("Sum of sizes of old and new window don't fit");
     }
 


@@ -3730,95 +3898,94 @@ set correctly.  See the code of `split-window' for how this is done.  */)
         by make_parent_window and we need it below for assigning it to
         p->new_normal.  */
       Lisp_Object new_normal
         by make_parent_window and we need it below for assigning it to
         p->new_normal.  */
       Lisp_Object new_normal

-       = horflag ? WGET (o, normal_cols) : WGET (o, normal_lines);
+       = horflag ? o->normal_cols : o->normal_lines;

 
       make_parent_window (old, horflag);
 
       make_parent_window (old, horflag);

-      p = XWINDOW (WGET (o, parent));
-      /* Store value of `window-combination-limit' in new parent's
-        combination_limit slot.  */
-      WSET (p, combination_limit, Vwindow_combination_limit);
+      p = XWINDOW (o->parent);
+      /* Store t in the new parent's combination_limit slot to avoid
+       that its children get merged into another window.  */
+      wset_combination_limit (p, Qt);

       /* These get applied below.  */
       /* These get applied below.  */

-      WSET (p, new_total,
-           horflag ? WGET (o, total_cols) : WGET (o, total_lines));
-      WSET (p, new_normal, new_normal);
+      wset_new_total (p, horflag ? o->total_cols : o->total_lines);
+      wset_new_normal (p, new_normal);

     }
   else
     }
   else

-    p = XWINDOW (WGET (o, parent));
+    p = XWINDOW (o->parent);

 
   windows_or_buffers_changed++;
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
   new = make_window ();
   n = XWINDOW (new);
 
   windows_or_buffers_changed++;
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
   new = make_window ();
   n = XWINDOW (new);

-  WSET (n, frame, frame);
-  WSET (n, parent, WGET (o, parent));
-  WSET (n, vchild, Qnil);
-  WSET (n, hchild, Qnil);
+  wset_frame (n, frame);
+  wset_parent (n, o->parent);
+  wset_vchild (n, Qnil);
+  wset_hchild (n, Qnil);

 
   if (EQ (side, Qabove) || EQ (side, Qleft))
     {
 
   if (EQ (side, Qabove) || EQ (side, Qleft))
     {

-      WSET (n, prev, WGET (o, prev));
-      if (NILP (WGET (n, prev)))
+      wset_prev (n, o->prev);
+      if (NILP (n->prev))

        if (horflag)
        if (horflag)

-         WSET (p, hchild, new);
+         wset_hchild (p, new);

        else
        else

-         WSET (p, vchild, new);
+         wset_vchild (p, new);

       else
       else

-       WSET (XWINDOW (WGET (n, prev)), next, new);
-      WSET (n, next, old);
-      WSET (o, prev, new);
+       wset_next (XWINDOW (n->prev), new);
+      wset_next (n, old);
+      wset_prev (o, new);

     }
   else
     {
     }
   else
     {

-      WSET (n, next, WGET (o, next));
-      if (!NILP (WGET (n, next)))
-       WSET (XWINDOW (WGET (n, next)), prev, new);
-      WSET (n, prev, old);
-      WSET (o, next, new);
+      wset_next (n, o->next);
+      if (!NILP (n->next))
+       wset_prev (XWINDOW (n->next), new);
+      wset_prev (n, old);
+      wset_next (o, new);

     }
 
     }
 

-  WSET (n, buffer, Qt);
-  WSET (n, window_end_valid, Qnil);
+  wset_buffer (n, Qt);
+  wset_window_end_valid (n, Qnil);

   memset (&n->last_cursor, 0, sizeof n->last_cursor);
 
   /* Get special geometry settings from reference window.  */
   memset (&n->last_cursor, 0, sizeof n->last_cursor);
 
   /* Get special geometry settings from reference window.  */

-  WSET (n, left_margin_cols, WGET (r, left_margin_cols));
-  WSET (n, right_margin_cols, WGET (r, right_margin_cols));
-  WSET (n, left_fringe_width, WGET (r, left_fringe_width));
-  WSET (n, right_fringe_width, WGET (r, right_fringe_width));
+  wset_left_margin_cols (n, r->left_margin_cols);
+  wset_right_margin_cols (n, r->right_margin_cols);
+  wset_left_fringe_width (n, r->left_fringe_width);
+  wset_right_fringe_width (n, r->right_fringe_width);

   n->fringes_outside_margins = r->fringes_outside_margins;
   n->fringes_outside_margins = r->fringes_outside_margins;

-  WSET (n, scroll_bar_width, WGET (r, scroll_bar_width));
-  WSET (n, vertical_scroll_bar_type, WGET (r, vertical_scroll_bar_type));
+  wset_scroll_bar_width (n, r->scroll_bar_width);
+  wset_vertical_scroll_bar_type (n, r->vertical_scroll_bar_type);

 
   /* Directly assign orthogonal coordinates and sizes.  */
   if (horflag)
     {
 
   /* Directly assign orthogonal coordinates and sizes.  */
   if (horflag)
     {

-      WSET (n, top_line, WGET (o, top_line));
-      WSET (n, total_lines, WGET (o, total_lines));
+      wset_top_line (n, o->top_line);
+      wset_total_lines (n, o->total_lines);

     }
   else
     {
     }
   else
     {

-      WSET (n, left_col, WGET (o, left_col));
-      WSET (n, total_cols, WGET (o, total_cols));
+      wset_left_col (n, o->left_col);
+      wset_total_cols (n, o->total_cols);

     }
 
   /* Iso-coordinates and sizes are assigned by window_resize_apply,
      get them ready here.  */
     }
 
   /* Iso-coordinates and sizes are assigned by window_resize_apply,
      get them ready here.  */

-  WSET (n, new_total, total_size);
-  WSET (n, new_normal, normal_size);
+  wset_new_total (n, total_size);
+  wset_new_normal (n, normal_size);

 
 

-  BLOCK_INPUT;
+  block_input ();

   window_resize_apply (p, horflag);
   adjust_glyphs (f);
   /* Set buffer of NEW to buffer of reference window.  Don't run
      any hooks.  */
   window_resize_apply (p, horflag);
   adjust_glyphs (f);
   /* Set buffer of NEW to buffer of reference window.  Don't run
      any hooks.  */

-  set_window_buffer (new, WGET (r, buffer), 0, 1);
-  UNBLOCK_INPUT;
+  set_window_buffer (new, r->buffer, 0, 1);
+  unblock_input ();

 
   /* Maybe we should run the scroll functions in Elisp (which already
      runs the configuration change hook).  */
   if (! NILP (Vwindow_scroll_functions))
     run_hook_with_args_2 (Qwindow_scroll_functions, new,
 
   /* Maybe we should run the scroll functions in Elisp (which already
      runs the configuration change hook).  */
   if (! NILP (Vwindow_scroll_functions))
     run_hook_with_args_2 (Qwindow_scroll_functions, new,

-                         Fmarker_position (WGET (n, start)));
+                         Fmarker_position (n->start));

   /* Return NEW.  */
   return new;
 }
   /* Return NEW.  */
   return new;
 }


@@ -3838,22 +4005,22 @@ Signal an error when WINDOW is the only window on its frame.  */)
 
   w = decode_any_window (window);
   XSETWINDOW (window, w);
 
   w = decode_any_window (window);
   XSETWINDOW (window, w);

-  if (NILP (WGET (w, buffer))
-      && NILP (WGET (w, hchild)) && NILP (WGET (w, vchild)))
+  if (NILP (w->buffer)
+      && NILP (w->hchild) && NILP (w->vchild))

     /* It's a no-op to delete an already deleted window.  */
     return Qnil;
 
     /* It's a no-op to delete an already deleted window.  */
     return Qnil;
 

-  parent = WGET (w, parent);
+  parent = w->parent;

   if (NILP (parent))
     /* Never delete a minibuffer or frame root window.  */
     error ("Attempt to delete minibuffer or sole ordinary window");
   if (NILP (parent))
     /* Never delete a minibuffer or frame root window.  */
     error ("Attempt to delete minibuffer or sole ordinary window");

-  else if (NILP (WGET (w, prev)) && NILP (WGET (w, next)))
+  else if (NILP (w->prev) && NILP (w->next))

     /* Rather bow out here, this case should be handled on the Elisp
        level.  */
     error ("Attempt to delete sole window of parent");
 
   p = XWINDOW (parent);
     /* Rather bow out here, this case should be handled on the Elisp
        level.  */
     error ("Attempt to delete sole window of parent");
 
   p = XWINDOW (parent);

-  horflag = NILP (WGET (p, vchild));
+  horflag = NILP (p->vchild);

 
   frame = WINDOW_FRAME (w);
   f = XFRAME (frame);
 
   frame = WINDOW_FRAME (w);
   f = XFRAME (frame);


@@ -3862,38 +4029,38 @@ Signal an error when WINDOW is the only window on its frame.  */)
   r = XWINDOW (root);
 
   /* Unlink WINDOW from window tree.  */
   r = XWINDOW (root);
 
   /* Unlink WINDOW from window tree.  */

-  if (NILP (WGET (w, prev)))
+  if (NILP (w->prev))

     /* Get SIBLING below (on the right of) WINDOW.  */
     {
       /* before_sibling 1 means WINDOW is the first child of its
         parent and thus before the sibling.  */
       before_sibling = 1;
     /* Get SIBLING below (on the right of) WINDOW.  */
     {
       /* before_sibling 1 means WINDOW is the first child of its
         parent and thus before the sibling.  */
       before_sibling = 1;

-      sibling = WGET (w, next);
+      sibling = w->next;

       s = XWINDOW (sibling);
       s = XWINDOW (sibling);

-      WSET (s, prev, Qnil);
+      wset_prev (s, Qnil);

       if (horflag)
       if (horflag)

-       WSET (p, hchild, sibling);
+       wset_hchild (p, sibling);

       else
       else

-       WSET (p, vchild, sibling);
+       wset_vchild (p, sibling);

     }
   else
     /* Get SIBLING above (on the left of) WINDOW.  */
     {
     }
   else
     /* Get SIBLING above (on the left of) WINDOW.  */
     {

-      sibling = WGET (w, prev);
+      sibling = w->prev;

       s = XWINDOW (sibling);
       s = XWINDOW (sibling);

-      WSET (s, next, WGET (w, next));
-      if (!NILP (WGET (s, next)))
-       WSET (XWINDOW (WGET (s, next)), prev, sibling);
+      wset_next (s, w->next);
+      if (!NILP (s->next))
+       wset_prev (XWINDOW (s->next), sibling);

     }
 
   if (window_resize_check (r, horflag)
     }
 
   if (window_resize_check (r, horflag)

-      && EQ (WGET (r, new_total),
-            (horflag ? WGET (r, total_cols) : WGET (r, total_lines))))
+      && EQ (r->new_total,
+            (horflag ? r->total_cols : r->total_lines)))

     /* We can delete WINDOW now.  */
     {
 
       /* Block input.  */
     /* We can delete WINDOW now.  */
     {
 
       /* Block input.  */

-      BLOCK_INPUT;
+      block_input ();

       window_resize_apply (p, horflag);
 
       /* If this window is referred to by the dpyinfo's mouse
       window_resize_apply (p, horflag);
 
       /* If this window is referred to by the dpyinfo's mouse


@@ -3910,28 +4077,28 @@ Signal an error when WINDOW is the only window on its frame.  */)
       Vwindow_list = Qnil;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
       Vwindow_list = Qnil;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 

-      WSET (w, next, Qnil);  /* Don't delete w->next too.  */
+      wset_next (w, Qnil);  /* Don't delete w->next too.  */

       free_window_matrices (w);
 
       free_window_matrices (w);
 

-      if (!NILP (WGET (w, vchild)))
+      if (!NILP (w->vchild))

        {
        {

-         delete_all_child_windows (WGET (w, vchild));
-         WSET (w, vchild, Qnil);
+         delete_all_child_windows (w->vchild);
+         wset_vchild (w, Qnil);

        }
        }

-      else if (!NILP (WGET (w, hchild)))
+      else if (!NILP (w->hchild))

        {
        {

-         delete_all_child_windows (WGET (w, hchild));
-         WSET (w, hchild, Qnil);
+         delete_all_child_windows (w->hchild);
+         wset_hchild (w, Qnil);

        }
        }

-      else if (!NILP (WGET (w, buffer)))
+      else if (!NILP (w->buffer))

        {
          unshow_buffer (w);
        {
          unshow_buffer (w);

-         unchain_marker (XMARKER (WGET (w, pointm)));
-         unchain_marker (XMARKER (WGET (w, start)));
-         WSET (w, buffer, Qnil);
+         unchain_marker (XMARKER (w->pointm));
+         unchain_marker (XMARKER (w->start));
+         wset_buffer (w, Qnil);

        }
 
        }
 

-      if (NILP (WGET (s, prev)) && NILP (WGET (s, next)))
+      if (NILP (s->prev) && NILP (s->next))

          /* A matrjoshka where SIBLING has become the only child of
             PARENT.  */
        {
          /* A matrjoshka where SIBLING has become the only child of
             PARENT.  */
        {


@@ -3939,11 +4106,11 @@ Signal an error when WINDOW is the only window on its frame.  */)
          replace_window (parent, sibling, 0);
          /* Have SIBLING inherit the following three slot values from
             PARENT (the combination_limit slot is not inherited).  */
          replace_window (parent, sibling, 0);
          /* Have SIBLING inherit the following three slot values from
             PARENT (the combination_limit slot is not inherited).  */

-         WSET (s, normal_cols, WGET (p, normal_cols));
-         WSET (s, normal_lines, WGET (p, normal_lines));
+         wset_normal_cols (s, p->normal_cols);
+         wset_normal_lines (s, p->normal_lines);

          /* Mark PARENT as deleted.  */
          /* Mark PARENT as deleted.  */

-         WSET (p, vchild, Qnil);
-         WSET (p, hchild, Qnil);
+         wset_vchild (p, Qnil);
+         wset_hchild (p, Qnil);

          /* Try to merge SIBLING into its new parent.  */
          recombine_windows (sibling);
        }
          /* Try to merge SIBLING into its new parent.  */
          recombine_windows (sibling);
        }


@@ -3963,24 +4130,24 @@ Signal an error when WINDOW is the only window on its frame.  */)
          if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
            Fselect_window (new_selected_window, Qt);
          else
          if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
            Fselect_window (new_selected_window, Qt);
          else

-           FSET (f, selected_window, new_selected_window);
+           fset_selected_window (f, new_selected_window);

 
 

-         UNBLOCK_INPUT;
+         unblock_input ();

 
          /* Now look whether `get-mru-window' gets us something.  */
          mru_window = call1 (Qget_mru_window, frame);
          if (WINDOW_LIVE_P (mru_window)
 
          /* Now look whether `get-mru-window' gets us something.  */
          mru_window = call1 (Qget_mru_window, frame);
          if (WINDOW_LIVE_P (mru_window)

-             && EQ (WGET (XWINDOW (mru_window), frame), frame))
+             && EQ (XWINDOW (mru_window)->frame, frame))

            new_selected_window = mru_window;
 
          /* If all ended up well, we now promote the mru window.  */
          if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
            Fselect_window (new_selected_window, Qnil);
          else
            new_selected_window = mru_window;
 
          /* If all ended up well, we now promote the mru window.  */
          if (EQ (FRAME_SELECTED_WINDOW (f), selected_window))
            Fselect_window (new_selected_window, Qnil);
          else

-           FSET (f, selected_window, new_selected_window);
+           fset_selected_window (f, new_selected_window);

        }
       else
        }
       else

-       UNBLOCK_INPUT;
+       unblock_input ();

 
       /* Must be run by the caller:
         run_window_configuration_change_hook (f);  */
 
       /* Must be run by the caller:
         run_window_configuration_change_hook (f);  */


@@ -3990,17 +4157,17 @@ Signal an error when WINDOW is the only window on its frame.  */)
     {
       if (before_sibling)
        {
     {
       if (before_sibling)
        {

-         WSET (s, prev, window);
+         wset_prev (s, window);

          if (horflag)
          if (horflag)

-           WSET (p, hchild, window);
+           wset_hchild (p, window);

          else
          else

-           WSET (p, vchild, window);
+           wset_vchild (p, window);

        }
       else
        {
        }
       else
        {

-         WSET (s, next, window);
-         if (!NILP (WGET (w, next)))
-           WSET (XWINDOW (WGET (w, next)), prev, window);
+         wset_next (s, window);
+         if (!NILP (w->next))
+           wset_prev (XWINDOW (w->next), window);

        }
       error ("Deletion failed");
     }
        }
       error ("Deletion failed");
     }


@@ -4017,7 +4184,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
 void
 grow_mini_window (struct window *w, int delta)
 {
 void
 grow_mini_window (struct window *w, int delta)
 {

-  struct frame *f = XFRAME (WGET (w, frame));
+  struct frame *f = XFRAME (w->frame);

   struct window *r;
   Lisp_Object root, value;
 
   struct window *r;
   Lisp_Object root, value;
 


@@ -4030,19 +4197,19 @@ grow_mini_window (struct window *w, int delta)
                 root, make_number (- delta));
   if (INTEGERP (value) && window_resize_check (r, 0))
     {
                 root, make_number (- delta));
   if (INTEGERP (value) && window_resize_check (r, 0))
     {

-      BLOCK_INPUT;
+      block_input ();

       window_resize_apply (r, 0);
 
       /* Grow the mini-window.  */
       window_resize_apply (r, 0);
 
       /* Grow the mini-window.  */

-      WSET (w, top_line,
-           make_number (XFASTINT (WGET (r, top_line)) + XFASTINT (WGET (r, total_lines))));
-      WSET (w, total_lines,
-           make_number (XFASTINT (WGET (w, total_lines)) - XINT (value)));
+      wset_top_line
+       (w, make_number (XFASTINT (r->top_line) + XFASTINT (r->total_lines)));
+      wset_total_lines
+       (w, make_number (XFASTINT (w->total_lines) - XINT (value)));

       w->last_modified = 0;
       w->last_overlay_modified = 0;
 
       adjust_glyphs (f);
       w->last_modified = 0;
       w->last_overlay_modified = 0;
 
       adjust_glyphs (f);

-      UNBLOCK_INPUT;
+      unblock_input ();

     }
 }
 
     }
 }
 


@@ -4051,14 +4218,14 @@ grow_mini_window (struct window *w, int delta)
 void
 shrink_mini_window (struct window *w)
 {
 void
 shrink_mini_window (struct window *w)
 {

-  struct frame *f = XFRAME (WGET (w, frame));
+  struct frame *f = XFRAME (w->frame);

   struct window *r;
   Lisp_Object root, value;
   EMACS_INT size;
 
   eassert (MINI_WINDOW_P (w));
 
   struct window *r;
   Lisp_Object root, value;
   EMACS_INT size;
 
   eassert (MINI_WINDOW_P (w));
 

-  size = XINT (WGET (w, total_lines));
+  size = XINT (w->total_lines);

   if (size > 1)
     {
       root = FRAME_ROOT_WINDOW (f);
   if (size > 1)
     {
       root = FRAME_ROOT_WINDOW (f);


@@ -4067,19 +4234,19 @@ shrink_mini_window (struct window *w)
                     root, make_number (size - 1));
       if (INTEGERP (value) && window_resize_check (r, 0))
        {
                     root, make_number (size - 1));
       if (INTEGERP (value) && window_resize_check (r, 0))
        {

-         BLOCK_INPUT;
+         block_input ();

          window_resize_apply (r, 0);
 
          /* Shrink the mini-window.  */
          window_resize_apply (r, 0);
 
          /* Shrink the mini-window.  */

-         WSET (w, top_line,
-               make_number (XFASTINT (WGET (r, top_line)) + XFASTINT (WGET (r, total_lines))));
-         WSET (w, total_lines, make_number (1));
+         wset_top_line (w, make_number (XFASTINT (r->top_line)
+                                        + XFASTINT (r->total_lines)));
+         wset_total_lines (w, make_number (1));

 
          w->last_modified = 0;
          w->last_overlay_modified = 0;
 
          adjust_glyphs (f);
 
          w->last_modified = 0;
          w->last_overlay_modified = 0;
 
          adjust_glyphs (f);

-         UNBLOCK_INPUT;
+         unblock_input ();

        }
       /* If the above failed for whatever strange reason we must make a
         one window frame here.  The same routine will be needed when
        }
       /* If the above failed for whatever strange reason we must make a
         one window frame here.  The same routine will be needed when


@@ -4098,30 +4265,30 @@ DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini
   int height;
 
   CHECK_WINDOW (window);
   int height;
 
   CHECK_WINDOW (window);

-  f = XFRAME (WGET (w, frame));
+  f = XFRAME (w->frame);

 
 

-  if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (WGET (w, frame))), window))
+  if (!EQ (FRAME_MINIBUF_WINDOW (XFRAME (w->frame)), window))

     error ("Not a valid minibuffer window");
   else if (FRAME_MINIBUF_ONLY_P (f))
     error ("Cannot resize a minibuffer-only frame");
 
   r = XWINDOW (FRAME_ROOT_WINDOW (f));
     error ("Not a valid minibuffer window");
   else if (FRAME_MINIBUF_ONLY_P (f))
     error ("Cannot resize a minibuffer-only frame");
 
   r = XWINDOW (FRAME_ROOT_WINDOW (f));

-  height = XINT (WGET (r, total_lines)) + XINT (WGET (w, total_lines));
+  height = XINT (r->total_lines) + XINT (w->total_lines);

   if (window_resize_check (r, 0)
   if (window_resize_check (r, 0)

-      && XINT (WGET (w, new_total)) > 0
-      && height == XINT (WGET (r, new_total)) + XINT (WGET (w, new_total)))
+      && XINT (w->new_total) > 0
+      && height == XINT (r->new_total) + XINT (w->new_total))

     {
     {

-      BLOCK_INPUT;
+      block_input ();

       window_resize_apply (r, 0);
 
       window_resize_apply (r, 0);
 

-      WSET (w, total_lines, WGET (w, new_total));
-      WSET (w, top_line,
-           make_number (XINT (WGET (r, top_line)) + XINT (WGET (r, total_lines))));
+      wset_total_lines (w, w->new_total);
+      wset_top_line (w, make_number (XINT (r->top_line)
+                                    + XINT (r->total_lines)));

 
       windows_or_buffers_changed++;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
       adjust_glyphs (f);
 
       windows_or_buffers_changed++;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
       adjust_glyphs (f);

-      UNBLOCK_INPUT;
+      unblock_input ();

 
       run_window_configuration_change_hook (f);
       return Qt;
 
       run_window_configuration_change_hook (f);
       return Qt;


@@ -4139,14 +4306,14 @@ mark_window_cursors_off (struct window *w)
 {
   while (w)
     {
 {
   while (w)
     {

-      if (!NILP (WGET (w, hchild)))
-       mark_window_cursors_off (XWINDOW (WGET (w, hchild)));
-      else if (!NILP (WGET (w, vchild)))
-       mark_window_cursors_off (XWINDOW (WGET (w, vchild)));
+      if (!NILP (w->hchild))
+       mark_window_cursors_off (XWINDOW (w->hchild));
+      else if (!NILP (w->vchild))
+       mark_window_cursors_off (XWINDOW (w->vchild));

       else
        w->phys_cursor_on_p = 0;
 
       else
        w->phys_cursor_on_p = 0;
 

-      w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
+      w = NILP (w->next) ? 0 : XWINDOW (w->next);

     }
 }
 
     }
 }
 


@@ -4156,15 +4323,15 @@ mark_window_cursors_off (struct window *w)
 int
 window_internal_height (struct window *w)
 {
 int
 window_internal_height (struct window *w)
 {

-  int ht = XFASTINT (WGET (w, total_lines));
+  int ht = XFASTINT (w->total_lines);

 
   if (!MINI_WINDOW_P (w))
     {
 
   if (!MINI_WINDOW_P (w))
     {

-      if (!NILP (WGET (w, parent))
-         || !NILP (WGET (w, vchild))
-         || !NILP (WGET (w, hchild))
-         || !NILP (WGET (w, next))
-         || !NILP (WGET (w, prev))
+      if (!NILP (w->parent)
+         || !NILP (w->vchild)
+         || !NILP (w->hchild)
+         || !NILP (w->next)
+         || !NILP (w->prev)

          || WINDOW_WANTS_MODELINE_P (w))
        --ht;
 
          || WINDOW_WANTS_MODELINE_P (w))
        --ht;
 


@@ -4194,7 +4361,7 @@ window_scroll (Lisp_Object window, EMACS_INT n, int whole, int noerror)
 
   /* If we must, use the pixel-based version which is much slower than
      the line-based one but can handle varying line heights.  */
 
   /* If we must, use the pixel-based version which is much slower than
      the line-based one but can handle varying line heights.  */

-  if (FRAME_WINDOW_P (XFRAME (WGET (XWINDOW (window), frame))))
+  if (FRAME_WINDOW_P (XFRAME (XWINDOW (window)->frame)))

     window_scroll_pixel_based (window, n, whole, noerror);
   else
     window_scroll_line_based (window, n, whole, noerror);
     window_scroll_pixel_based (window, n, whole, noerror);
   else
     window_scroll_line_based (window, n, whole, noerror);


@@ -4219,7 +4386,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
   int x, y, rtop, rbot, rowh, vpos;
   void *itdata = NULL;
 
   int x, y, rtop, rbot, rowh, vpos;
   void *itdata = NULL;
 

-  SET_TEXT_POS_FROM_MARKER (start, WGET (w, start));
+  SET_TEXT_POS_FROM_MARKER (start, w->start);

   /* Scrolling a minibuffer window via scroll bar when the echo area
      shows long text sometimes resets the minibuffer contents behind
      our backs.  */
   /* Scrolling a minibuffer window via scroll bar when the echo area
      shows long text sometimes resets the minibuffer contents behind
      our backs.  */


@@ -4300,8 +4467,8 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
                    spos = XINT (Fline_beginning_position (Qnil));
                  else
                    spos = min (XINT (Fline_end_position (Qnil)) + 1, ZV);
                    spos = XINT (Fline_beginning_position (Qnil));
                  else
                    spos = min (XINT (Fline_end_position (Qnil)) + 1, ZV);

-                 set_marker_restricted (WGET (w, start), make_number (spos),
-                                        WGET (w, buffer));
+                 set_marker_restricted (w->start, make_number (spos),
+                                        w->buffer);

                  w->start_at_line_beg = 1;
                  w->update_mode_line = 1;
                  w->last_modified = 0;
                  w->start_at_line_beg = 1;
                  w->update_mode_line = 1;
                  w->last_modified = 0;


@@ -4425,7 +4592,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
 
       /* If control gets here, then we vscrolled.  */
 
 
       /* If control gets here, then we vscrolled.  */
 

-      XBUFFER (WGET (w, buffer))->prevent_redisplay_optimizations_p = 1;
+      XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;

 
       /* Don't try to change the window start below.  */
       vscrolled = 1;
 
       /* Don't try to change the window start below.  */
       vscrolled = 1;


@@ -4445,9 +4612,9 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
        }
 
       /* Set the window start, and set up the window for redisplay.  */
        }
 
       /* Set the window start, and set up the window for redisplay.  */

-      set_marker_restricted (WGET (w, start), make_number (pos),
-                            WGET (w, buffer));
-      bytepos = XMARKER (WGET (w, start))->bytepos;
+      set_marker_restricted (w->start, make_number (pos),
+                            w->buffer);
+      bytepos = XMARKER (w->start)->bytepos;

       w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
       w->update_mode_line = 1;
       w->last_modified = 0;
       w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
       w->update_mode_line = 1;
       w->last_modified = 0;


@@ -4466,7 +4633,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
      even if there is a header line.  */
   this_scroll_margin = max (0, scroll_margin);
   this_scroll_margin
      even if there is a header line.  */
   this_scroll_margin = max (0, scroll_margin);
   this_scroll_margin

-    = min (this_scroll_margin, XFASTINT (WGET (w, total_lines)) / 4);
+    = min (this_scroll_margin, XFASTINT (w->total_lines) / 4);

   this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
 
   if (n > 0)
   this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
 
   if (n > 0)


@@ -4540,7 +4707,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
        ;
       else if (window_scroll_pixel_based_preserve_y >= 0)
        {
        ;
       else if (window_scroll_pixel_based_preserve_y >= 0)
        {

-         SET_TEXT_POS_FROM_MARKER (start, WGET (w, start));
+         SET_TEXT_POS_FROM_MARKER (start, w->start);

          start_display (&it, w, start);
          /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
             here because we called start_display again and did not
          start_display (&it, w, start);
          /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
             here because we called start_display again and did not


@@ -4594,7 +4761,7 @@ window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
   if (whole)
     n *= max (1, ht - next_screen_context_lines);
 
   if (whole)
     n *= max (1, ht - next_screen_context_lines);
 

-  startpos = marker_position (WGET (w, start));
+  startpos = marker_position (w->start);

 
   if (!NILP (Vscroll_preserve_screen_position))
     {
 
   if (!NILP (Vscroll_preserve_screen_position))
     {


@@ -4645,9 +4812,9 @@ window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
     {
       /* Don't use a scroll margin that is negative or too large.  */
       int this_scroll_margin =
     {
       /* Don't use a scroll margin that is negative or too large.  */
       int this_scroll_margin =

-       max (0, min (scroll_margin, XINT (WGET (w, total_lines)) / 4));
+       max (0, min (scroll_margin, XINT (w->total_lines) / 4));

 
 

-      set_marker_restricted_both (WGET (w, start), WGET (w, buffer), pos, pos_byte);
+      set_marker_restricted_both (w->start, w->buffer, pos, pos_byte);

       w->start_at_line_beg = !NILP (bolp);
       w->update_mode_line = 1;
       w->last_modified = 0;
       w->start_at_line_beg = !NILP (bolp);
       w->update_mode_line = 1;
       w->last_modified = 0;


@@ -4741,10 +4908,10 @@ scroll_command (Lisp_Object n, int direction)
 
   /* If selected window's buffer isn't current, make it current for
      the moment.  But don't screw up if window_scroll gets an error.  */
 
   /* If selected window's buffer isn't current, make it current for
      the moment.  But don't screw up if window_scroll gets an error.  */

-  if (XBUFFER (WGET (XWINDOW (selected_window), buffer)) != current_buffer)
+  if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)

     {
       record_unwind_protect (save_excursion_restore, save_excursion_save ());
     {
       record_unwind_protect (save_excursion_restore, save_excursion_save ());

-      Fset_buffer (WGET (XWINDOW (selected_window), buffer));
+      Fset_buffer (XWINDOW (selected_window)->buffer);

 
       /* Make redisplay consider other windows than just selected_window.  */
       ++windows_or_buffers_changed;
 
       /* Make redisplay consider other windows than just selected_window.  */
       ++windows_or_buffers_changed;


@@ -4859,8 +5026,8 @@ specifies the window to scroll.  This takes precedence over
   record_unwind_protect (save_excursion_restore, save_excursion_save ());
   ++windows_or_buffers_changed;
 
   record_unwind_protect (save_excursion_restore, save_excursion_save ());
   ++windows_or_buffers_changed;
 

-  Fset_buffer (WGET (w, buffer));
-  SET_PT (marker_position (WGET (w, pointm)));
+  Fset_buffer (w->buffer);
+  SET_PT (marker_position (w->pointm));

 
   if (NILP (arg))
     window_scroll (window, 1, 1, 1);
 
   if (NILP (arg))
     window_scroll (window, 1, 1, 1);


@@ -4874,7 +5041,7 @@ specifies the window to scroll.  This takes precedence over
       window_scroll (window, XINT (arg), 0, 1);
     }
 
       window_scroll (window, XINT (arg), 0, 1);
     }
 

-  set_marker_both (WGET (w, pointm), Qnil, PT, PT_BYTE);
+  set_marker_both (w->pointm, Qnil, PT, PT_BYTE);

   unbind_to (count, Qnil);
 
   return Qnil;
   unbind_to (count, Qnil);
 
   return Qnil;


@@ -4952,10 +5119,10 @@ displayed_window_lines (struct window *w)
   int bottom_y;
   void *itdata = NULL;
 
   int bottom_y;
   void *itdata = NULL;
 

-  if (XBUFFER (WGET (w, buffer)) != current_buffer)
+  if (XBUFFER (w->buffer) != current_buffer)

     {
       old_buffer = current_buffer;
     {
       old_buffer = current_buffer;

-      set_buffer_internal (XBUFFER (WGET (w, buffer)));
+      set_buffer_internal (XBUFFER (w->buffer));

     }
   else
     old_buffer = NULL;
     }
   else
     old_buffer = NULL;


@@ -4963,12 +5130,12 @@ displayed_window_lines (struct window *w)
   /* In case W->start is out of the accessible range, do something
      reasonable.  This happens in Info mode when Info-scroll-down
      calls (recenter -1) while W->start is 1.  */
   /* In case W->start is out of the accessible range, do something
      reasonable.  This happens in Info mode when Info-scroll-down
      calls (recenter -1) while W->start is 1.  */

-  if (XMARKER (WGET (w, start))->charpos < BEGV)
+  if (XMARKER (w->start)->charpos < BEGV)

     SET_TEXT_POS (start, BEGV, BEGV_BYTE);
     SET_TEXT_POS (start, BEGV, BEGV_BYTE);

-  else if (XMARKER (WGET (w, start))->charpos > ZV)
+  else if (XMARKER (w->start)->charpos > ZV)

     SET_TEXT_POS (start, ZV, ZV_BYTE);
   else
     SET_TEXT_POS (start, ZV, ZV_BYTE);
   else

-    SET_TEXT_POS_FROM_MARKER (start, WGET (w, start));
+    SET_TEXT_POS_FROM_MARKER (start, w->start);

 
   itdata = bidi_shelve_cache ();
   start_display (&it, w, start);
 
   itdata = bidi_shelve_cache ();
   start_display (&it, w, start);


@@ -4982,7 +5149,7 @@ displayed_window_lines (struct window *w)
      This kludge fixes a bug whereby (move-to-window-line -1)
      when ZV is on the last screen line
      moves to the previous screen line instead of the last one.  */
      This kludge fixes a bug whereby (move-to-window-line -1)
      when ZV is on the last screen line
      moves to the previous screen line instead of the last one.  */

-  if (! FRAME_WINDOW_P (XFRAME (WGET (w, frame))))
+  if (! FRAME_WINDOW_P (XFRAME (w->frame)))

     height++;
 
   /* Add in empty lines at the bottom of the window.  */
     height++;
 
   /* Add in empty lines at the bottom of the window.  */


@@ -5017,7 +5184,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
   (register Lisp_Object arg)
 {
   struct window *w = XWINDOW (selected_window);
   (register Lisp_Object arg)
 {
   struct window *w = XWINDOW (selected_window);

-  struct buffer *buf = XBUFFER (WGET (w, buffer));
+  struct buffer *buf = XBUFFER (w->buffer);

   struct buffer *obuf = current_buffer;
   int center_p = 0;
   ptrdiff_t charpos, bytepos;
   struct buffer *obuf = current_buffer;
   int center_p = 0;
   ptrdiff_t charpos, bytepos;


@@ -5061,12 +5228,12 @@ and redisplay normally--don't erase and redraw the frame.  */)
   /* Do this after making BUF current
      in case scroll_margin is buffer-local.  */
   this_scroll_margin =
   /* Do this after making BUF current
      in case scroll_margin is buffer-local.  */
   this_scroll_margin =

-    max (0, min (scroll_margin, XFASTINT (WGET (w, total_lines)) / 4));
+    max (0, min (scroll_margin, XFASTINT (w->total_lines) / 4));

 
   /* Handle centering on a graphical frame specially.  Such frames can
      have variable-height lines and centering point on the basis of
      line counts would lead to strange effects.  */
 
   /* Handle centering on a graphical frame specially.  Such frames can
      have variable-height lines and centering point on the basis of
      line counts would lead to strange effects.  */

-  if (FRAME_WINDOW_P (XFRAME (WGET (w, frame))))
+  if (FRAME_WINDOW_P (XFRAME (w->frame)))

     {
       if (center_p)
        {
     {
       if (center_p)
        {


@@ -5183,8 +5350,8 @@ and redisplay normally--don't erase and redraw the frame.  */)
     }
 
   /* Set the new window start.  */
     }
 
   /* Set the new window start.  */

-  set_marker_both (WGET (w, start), WGET (w, buffer), charpos, bytepos);
-  WSET (w, window_end_valid, Qnil);
+  set_marker_both (w->start, w->buffer, charpos, bytepos);
+  wset_window_end_valid (w, Qnil);

 
   w->optional_new_start = 1;
 
 
   w->optional_new_start = 1;
 


@@ -5198,15 +5365,15 @@ and redisplay normally--don't erase and redraw the frame.  */)
 DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
        0, 1, 0,
        doc: /* Return the height in lines of the text display area of WINDOW.
 DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
        0, 1, 0,
        doc: /* Return the height in lines of the text display area of WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.

 
 The returned height does not include the mode line, any header line,
 nor any partial-height lines at the bottom of the text area.  */)
   (Lisp_Object window)
 {
 
 The returned height does not include the mode line, any header line,
 nor any partial-height lines at the bottom of the text area.  */)
   (Lisp_Object window)
 {

-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);

   int pixel_height = window_box_height (w);
   int pixel_height = window_box_height (w);

-  int line_height = pixel_height / FRAME_LINE_HEIGHT (XFRAME (WGET (w, frame)));
+  int line_height = pixel_height / FRAME_LINE_HEIGHT (XFRAME (w->frame));

   return make_number (line_height);
 }
 
   return make_number (line_height);
 }
 


@@ -5227,24 +5394,24 @@ zero means top of window, negative means relative to bottom of window.  */)
   int this_scroll_margin;
 #endif
 
   int this_scroll_margin;
 #endif
 

-  if (!(BUFFERP (WGET (w, buffer))
-       && XBUFFER (WGET (w, buffer)) == current_buffer))
+  if (!(BUFFERP (w->buffer)
+       && XBUFFER (w->buffer) == current_buffer))

     /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
        when passed below to set_marker_both.  */
     error ("move-to-window-line called from unrelated buffer");
 
   window = selected_window;
     /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
        when passed below to set_marker_both.  */
     error ("move-to-window-line called from unrelated buffer");
 
   window = selected_window;

-  start = marker_position (WGET (w, start));
+  start = marker_position (w->start);

   if (start < BEGV || start > ZV)
     {
       int height = window_internal_height (w);
       Fvertical_motion (make_number (- (height / 2)), window);
   if (start < BEGV || start > ZV)
     {
       int height = window_internal_height (w);
       Fvertical_motion (make_number (- (height / 2)), window);

-      set_marker_both (WGET (w, start), WGET (w, buffer), PT, PT_BYTE);
+      set_marker_both (w->start, w->buffer, PT, PT_BYTE);

       w->start_at_line_beg = !NILP (Fbolp ());
       w->force_start = 1;
     }
   else
       w->start_at_line_beg = !NILP (Fbolp ());
       w->force_start = 1;
     }
   else

-    Fgoto_char (WGET (w, start));
+    Fgoto_char (w->start);

 
   lines = displayed_window_lines (w);
 
 
   lines = displayed_window_lines (w);
 


@@ -5348,7 +5515,7 @@ DEFUN ("window-configuration-frame", Fwindow_configuration_frame, Swindow_config
 
   data = (struct save_window_data *) XVECTOR (config);
   saved_windows = XVECTOR (data->saved_windows);
 
   data = (struct save_window_data *) XVECTOR (config);
   saved_windows = XVECTOR (data->saved_windows);

-  return WGET (XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window), frame);
+  return XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;

 }
 
 DEFUN ("set-window-configuration", Fset_window_configuration,
 }
 
 DEFUN ("set-window-configuration", Fset_window_configuration,


@@ -5365,7 +5532,6 @@ the return value is nil.  Otherwise the value is t.  */)
   struct Lisp_Vector *saved_windows;
   Lisp_Object new_current_buffer;
   Lisp_Object frame;
   struct Lisp_Vector *saved_windows;
   Lisp_Object new_current_buffer;
   Lisp_Object frame;

-  Lisp_Object auto_buffer_name;

   FRAME_PTR f;
   ptrdiff_t old_point = -1;
 
   FRAME_PTR f;
   ptrdiff_t old_point = -1;
 


@@ -5375,7 +5541,7 @@ the return value is nil.  Otherwise the value is t.  */)
   saved_windows = XVECTOR (data->saved_windows);
 
   new_current_buffer = data->current_buffer;
   saved_windows = XVECTOR (data->saved_windows);
 
   new_current_buffer = data->current_buffer;

-  if (NILP (BVAR (XBUFFER (new_current_buffer), name)))
+  if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer)))

     new_current_buffer = Qnil;
   else
     {
     new_current_buffer = Qnil;
   else
     {


@@ -5390,11 +5556,11 @@ the return value is nil.  Otherwise the value is t.  */)
           window-point of the final-selected-window to the window-point of
           the current-selected-window.  So we have to be careful which
           point of the current-buffer we copy into old_point.  */
           window-point of the final-selected-window to the window-point of
           the current-selected-window.  So we have to be careful which
           point of the current-buffer we copy into old_point.  */

-       if (EQ (WGET (XWINDOW (data->current_window), buffer), new_current_buffer)
+       if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer)

            && WINDOWP (selected_window)
            && WINDOWP (selected_window)

-           && EQ (WGET (XWINDOW (selected_window), buffer), new_current_buffer)
+           && EQ (XWINDOW (selected_window)->buffer, new_current_buffer)

            && !EQ (selected_window, data->current_window))
            && !EQ (selected_window, data->current_window))

-         old_point = XMARKER (WGET (XWINDOW (data->current_window), pointm))->charpos;
+         old_point = XMARKER (XWINDOW (data->current_window)->pointm)->charpos;

        else
          old_point = PT;
       else
        else
          old_point = PT;
       else


@@ -5406,15 +5572,15 @@ the return value is nil.  Otherwise the value is t.  */)
           So if possible we want this arbitrary choice of "which point" to
           be the one from the to-be-selected-window so as to prevent this
           window's cursor from being copied from another window.  */
           So if possible we want this arbitrary choice of "which point" to
           be the one from the to-be-selected-window so as to prevent this
           window's cursor from being copied from another window.  */

-       if (EQ (WGET (XWINDOW (data->current_window), buffer), new_current_buffer)
+       if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer)

            /* If current_window = selected_window, its point is in BUF_PT.  */
            && !EQ (selected_window, data->current_window))
            /* If current_window = selected_window, its point is in BUF_PT.  */
            && !EQ (selected_window, data->current_window))

-         old_point = XMARKER (WGET (XWINDOW (data->current_window), pointm))->charpos;
+         old_point = XMARKER (XWINDOW (data->current_window)->pointm)->charpos;

        else
          old_point = BUF_PT (XBUFFER (new_current_buffer));
     }
 
        else
          old_point = BUF_PT (XBUFFER (new_current_buffer));
     }
 

-  frame = WGET (XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window), frame);
+  frame = XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;

   f = XFRAME (frame);
 
   /* If f is a dead frame, don't bother rebuilding its window tree.
   f = XFRAME (frame);
 
   /* If f is a dead frame, don't bother rebuilding its window tree.


@@ -5441,9 +5607,24 @@ the return value is nil.  Otherwise the value is t.  */)
       int previous_frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
       int previous_frame_tool_bar_lines = FRAME_TOOL_BAR_LINES (f);
 
       int previous_frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
       int previous_frame_tool_bar_lines = FRAME_TOOL_BAR_LINES (f);
 

+      /* Don't do this within the main loop below: This may call Lisp
+        code and is thus potentially unsafe while input is blocked.  */
+      for (k = 0; k < saved_windows->header.size; k++)
+       {
+         p = SAVED_WINDOW_N (saved_windows, k);
+         window = p->window;
+         w = XWINDOW (window);
+         if (!NILP (w->buffer)
+             && !EQ (w->buffer, p->buffer)
+             && BUFFER_LIVE_P (XBUFFER (p->buffer)))
+           /* If a window we restore gets another buffer, record the
+              window's old buffer.  */
+           call1 (Qrecord_window_buffer, window);
+       }
+

       /* The mouse highlighting code could get screwed up
         if it runs during this.  */
       /* The mouse highlighting code could get screwed up
         if it runs during this.  */

-      BLOCK_INPUT;
+      block_input ();

 
       if (data->frame_lines != previous_frame_lines
          || data->frame_cols != previous_frame_cols)
 
       if (data->frame_lines != previous_frame_lines
          || data->frame_cols != previous_frame_cols)


@@ -5467,13 +5648,13 @@ the return value is nil.  Otherwise the value is t.  */)
         window holds garbage.)  We do this now, before
         restoring the window contents, and prevent it from
         being done later on when we select a new window.  */
         window holds garbage.)  We do this now, before
         restoring the window contents, and prevent it from
         being done later on when we select a new window.  */

-      if (! NILP (WGET (XWINDOW (selected_window), buffer)))
+      if (! NILP (XWINDOW (selected_window)->buffer))

        {
          w = XWINDOW (selected_window);
        {
          w = XWINDOW (selected_window);

-         set_marker_both (WGET (w, pointm),
-                          WGET (w, buffer),
-                          BUF_PT (XBUFFER (WGET (w, buffer))),
-                          BUF_PT_BYTE (XBUFFER (WGET (w, buffer))));
+         set_marker_both (w->pointm,
+                          w->buffer,
+                          BUF_PT (XBUFFER (w->buffer)),
+                          BUF_PT_BYTE (XBUFFER (w->buffer)));

        }
 
       windows_or_buffers_changed++;
        }
 
       windows_or_buffers_changed++;


@@ -5502,60 +5683,60 @@ the return value is nil.  Otherwise the value is t.  */)
          p = SAVED_WINDOW_N (saved_windows, k);
          window = p->window;
          w = XWINDOW (window);
          p = SAVED_WINDOW_N (saved_windows, k);
          window = p->window;
          w = XWINDOW (window);

-         WSET (w, next, Qnil);
+         wset_next (w, Qnil);

 
          if (!NILP (p->parent))
 
          if (!NILP (p->parent))

-           WSET (w, parent, SAVED_WINDOW_N (saved_windows,
-                                            XFASTINT (p->parent))->window);
+           wset_parent
+             (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->parent))->window);

          else
          else

-           WSET (w, parent, Qnil);
+           wset_parent (w, Qnil);

 
          if (!NILP (p->prev))
            {
 
          if (!NILP (p->prev))
            {

-             WSET (w, prev, SAVED_WINDOW_N (saved_windows,
-                                            XFASTINT (p->prev))->window);
-             WSET (XWINDOW (WGET (w, prev)), next, p->window);
+             wset_prev
+               (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->prev))->window);
+             wset_next (XWINDOW (w->prev), p->window);

            }
          else
            {
            }
          else
            {

-             WSET (w, prev, Qnil);
-             if (!NILP (WGET (w, parent)))
+             wset_prev (w, Qnil);
+             if (!NILP (w->parent))

                {
                {

-                 if (EQ (p->total_cols, WGET (XWINDOW (WGET (w, parent)), total_cols)))
+                 if (EQ (p->total_cols, XWINDOW (w->parent)->total_cols))

                    {
                    {

-                     WSET (XWINDOW (WGET (w, parent)), vchild, p->window);
-                     WSET (XWINDOW (WGET (w, parent)), hchild, Qnil);
+                     wset_vchild (XWINDOW (w->parent), p->window);
+                     wset_hchild (XWINDOW (w->parent), Qnil);

                    }
                  else
                    {
                    }
                  else
                    {

-                     WSET (XWINDOW (WGET (w, parent)), hchild, p->window);
-                     WSET (XWINDOW (WGET (w, parent)), vchild, Qnil);
+                     wset_hchild (XWINDOW (w->parent), p->window);
+                     wset_vchild (XWINDOW (w->parent), Qnil);

                    }
                }
            }
 
          /* If we squirreled away the buffer in the window's height,
             restore it now.  */
                    }
                }
            }
 
          /* If we squirreled away the buffer in the window's height,
             restore it now.  */

-         if (BUFFERP (WGET (w, total_lines)))
-           WSET (w, buffer, WGET (w, total_lines));
-         WSET (w, left_col, p->left_col);
-         WSET (w, top_line, p->top_line);
-         WSET (w, total_cols, p->total_cols);
-         WSET (w, total_lines, p->total_lines);
-         WSET (w, normal_cols, p->normal_cols);
-         WSET (w, normal_lines, p->normal_lines);
+         if (BUFFERP (w->total_lines))
+           wset_buffer (w, w->total_lines);
+         wset_left_col (w, p->left_col);
+         wset_top_line (w, p->top_line);
+         wset_total_cols (w, p->total_cols);
+         wset_total_lines (w, p->total_lines);
+         wset_normal_cols (w, p->normal_cols);
+         wset_normal_lines (w, p->normal_lines);

          w->hscroll = XFASTINT (p->hscroll);
          w->min_hscroll = XFASTINT (p->min_hscroll);
          w->hscroll = XFASTINT (p->hscroll);
          w->min_hscroll = XFASTINT (p->min_hscroll);

-         WSET (w, display_table, p->display_table);
-         WSET (w, left_margin_cols, p->left_margin_cols);
-         WSET (w, right_margin_cols, p->right_margin_cols);
-         WSET (w, left_fringe_width, p->left_fringe_width);
-         WSET (w, right_fringe_width, p->right_fringe_width);
+         wset_display_table (w, p->display_table);
+         wset_left_margin_cols (w, p->left_margin_cols);
+         wset_right_margin_cols (w, p->right_margin_cols);
+         wset_left_fringe_width (w, p->left_fringe_width);
+         wset_right_fringe_width (w, p->right_fringe_width);

          w->fringes_outside_margins = !NILP (p->fringes_outside_margins);
          w->fringes_outside_margins = !NILP (p->fringes_outside_margins);

-         WSET (w, scroll_bar_width, p->scroll_bar_width);
-         WSET (w, vertical_scroll_bar_type, p->vertical_scroll_bar_type);
-         WSET (w, dedicated, p->dedicated);
-         WSET (w, combination_limit, p->combination_limit);
+         wset_scroll_bar_width (w, p->scroll_bar_width);
+         wset_vertical_scroll_bar_type (w, p->vertical_scroll_bar_type);
+         wset_dedicated (w, p->dedicated);
+         wset_combination_limit (w, p->combination_limit);

          /* Restore any window parameters that have been saved.
             Parameters that have not been saved are left alone.  */
          for (tem = p->window_parameters; CONSP (tem); tem = XCDR (tem))
          /* Restore any window parameters that have been saved.
             Parameters that have not been saved are left alone.  */
          for (tem = p->window_parameters; CONSP (tem); tem = XCDR (tem))


@@ -5565,7 +5746,7 @@ the return value is nil.  Otherwise the value is t.  */)
                {
                  if (NILP (XCDR (pers)))
                    {
                {
                  if (NILP (XCDR (pers)))
                    {

-                     par = Fassq (XCAR (pers), WGET (w, window_parameters));
+                     par = Fassq (XCAR (pers), w->window_parameters);

                      if (CONSP (par) && !NILP (XCDR (par)))
                        /* Reset a parameter to nil if and only if it
                           has a non-nil association.  Don't make new
                      if (CONSP (par) && !NILP (XCDR (par)))
                        /* Reset a parameter to nil if and only if it
                           has a non-nil association.  Don't make new


@@ -5584,52 +5765,41 @@ the return value is nil.  Otherwise the value is t.  */)
          /* Reinstall the saved buffer and pointers into it.  */
          if (NILP (p->buffer))
            /* An internal window.  */
          /* Reinstall the saved buffer and pointers into it.  */
          if (NILP (p->buffer))
            /* An internal window.  */

-           WSET (w, buffer, p->buffer);
-         else if (!NILP (BVAR (XBUFFER (p->buffer), name)))
+           wset_buffer (w, p->buffer);
+         else if (BUFFER_LIVE_P (XBUFFER (p->buffer)))

            /* If saved buffer is alive, install it.  */
            {
            /* If saved buffer is alive, install it.  */
            {

-             WSET (w, buffer, p->buffer);
-              w->start_at_line_beg = !NILP (p->start_at_line_beg);
-              set_marker_restricted (WGET (w, start), p->start, WGET (w, buffer));
-              set_marker_restricted (WGET (w, pointm), p->pointm,
-                                     WGET (w, buffer));
-              Fset_marker (BVAR (XBUFFER (WGET (w, buffer)), mark),
-                           p->mark, WGET (w, buffer));
-
-              /* As documented in Fcurrent_window_configuration, don't
-                 restore the location of point in the buffer which was
-                 current when the window configuration was recorded.  */
-              if (!EQ (p->buffer, new_current_buffer)
-                  && XBUFFER (p->buffer) == current_buffer)
-                Fgoto_char (WGET (w, pointm));
+             wset_buffer (w, p->buffer);
+             w->start_at_line_beg = !NILP (p->start_at_line_beg);
+             set_marker_restricted (w->start, p->start, w->buffer);
+             set_marker_restricted (w->pointm, p->pointm,
+                                    w->buffer);
+             Fset_marker (BVAR (XBUFFER (w->buffer), mark),
+                          p->mark, w->buffer);
+
+             /* As documented in Fcurrent_window_configuration, don't
+                restore the location of point in the buffer which was
+                current when the window configuration was recorded.  */
+             if (!EQ (p->buffer, new_current_buffer)
+                 && XBUFFER (p->buffer) == current_buffer)
+               Fgoto_char (w->pointm);

             }
             }

-          else if (!NILP (WGET (w, buffer))
-                   && !NILP (BVAR (XBUFFER (WGET (w, buffer)), name)))
+          else if (!NILP (w->buffer)
+                   && BUFFER_LIVE_P (XBUFFER (w->buffer)))

             /* Keep window's old buffer; make sure the markers are
                real.  */
             {
               /* Set window markers at start of visible range.  */
             /* Keep window's old buffer; make sure the markers are
                real.  */
             {
               /* Set window markers at start of visible range.  */

-              if (XMARKER (WGET (w, start))->buffer == 0)
-                set_marker_restricted (WGET (w, start), make_number (0),
-                                       WGET (w, buffer));
-              if (XMARKER (WGET (w, pointm))->buffer == 0)
-                set_marker_restricted_both 
-                  (WGET (w, pointm), WGET (w, buffer),
-                   BUF_PT (XBUFFER (WGET (w, buffer))),
-                   BUF_PT_BYTE (XBUFFER (WGET (w, buffer))));
+              if (XMARKER (w->start)->buffer == 0)
+                set_marker_restricted (w->start, make_number (0),
+                                       w->buffer);
+              if (XMARKER (w->pointm)->buffer == 0)
+                set_marker_restricted_both
+                  (w->pointm, w->buffer,
+                   BUF_PT (XBUFFER (w->buffer)),
+                   BUF_PT_BYTE (XBUFFER (w->buffer)));

               w->start_at_line_beg = 1;
             }
               w->start_at_line_beg = 1;
             }

-          else if (STRINGP (auto_buffer_name =
-                            Fwindow_parameter (window, Qauto_buffer_name))
-                   && SCHARS (auto_buffer_name) != 0
-                   && !NILP (WSET (w, buffer, Fget_buffer_create (auto_buffer_name))))
-           {
-             set_marker_restricted (WGET (w, start),
-                                    make_number (0), WGET (w, buffer));
-             set_marker_restricted (WGET (w, pointm),
-                                    make_number (0), WGET (w, buffer));
-             w->start_at_line_beg = 1;
-           }

          else
            /* Window has no live buffer, get one.  */
            {
          else
            /* Window has no live buffer, get one.  */
            {


@@ -5637,36 +5807,36 @@ the return value is nil.  Otherwise the value is t.  */)
              avoid showing an unimportant buffer and, if necessary, to
              recreate *scratch* in the course (part of Juanma's bs-show
              scenario from March 2011).  */
              avoid showing an unimportant buffer and, if necessary, to
              recreate *scratch* in the course (part of Juanma's bs-show
              scenario from March 2011).  */

-             WSET (w, buffer, other_buffer_safely (Fcurrent_buffer ()));
+             wset_buffer (w, other_buffer_safely (Fcurrent_buffer ()));

              /* This will set the markers to beginning of visible
                 range.  */
              /* This will set the markers to beginning of visible
                 range.  */

-             set_marker_restricted (WGET (w, start),
-                                    make_number (0), WGET (w, buffer));
-             set_marker_restricted (WGET (w, pointm),
-                                    make_number (0), WGET (w, buffer));
+             set_marker_restricted (w->start,
+                                    make_number (0), w->buffer);
+             set_marker_restricted (w->pointm,
+                                    make_number (0), w->buffer);

              w->start_at_line_beg = 1;
              w->start_at_line_beg = 1;

-             if (!NILP (WGET (w, dedicated)))
+             if (!NILP (w->dedicated))

                /* Record this window as dead.  */
                dead_windows = Fcons (window, dead_windows);
              /* Make sure window is no more dedicated.  */
                /* Record this window as dead.  */
                dead_windows = Fcons (window, dead_windows);
              /* Make sure window is no more dedicated.  */

-             WSET (w, dedicated, Qnil);
+             wset_dedicated (w, Qnil);

            }
        }
 
            }
        }
 

-      FSET (f, root_window, data->root_window);
+      fset_root_window (f, data->root_window);

       /* Arrange *not* to restore point in the buffer that was
         current when the window configuration was saved.  */
       /* Arrange *not* to restore point in the buffer that was
         current when the window configuration was saved.  */

-      if (EQ (WGET (XWINDOW (data->current_window), buffer), new_current_buffer))
-       set_marker_restricted (WGET (XWINDOW (data->current_window), pointm),
+      if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer))
+       set_marker_restricted (XWINDOW (data->current_window)->pointm,

                               make_number (old_point),
                               make_number (old_point),

-                              WGET (XWINDOW (data->current_window), buffer));
+                              XWINDOW (data->current_window)->buffer);

 
       /* In the following call to `select-window', prevent "swapping 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);
 
       /* In the following call to `select-window', prevent "swapping 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);

-      BVAR (XBUFFER (WGET (XWINDOW (selected_window), buffer)), last_selected_window)
+      BVAR (XBUFFER (XWINDOW (selected_window)->buffer), last_selected_window)

        = selected_window;
 
       if (NILP (data->focus_frame)
        = selected_window;
 
       if (NILP (data->focus_frame)


@@ -5693,19 +5863,19 @@ the return value is nil.  Otherwise the value is t.  */)
       /* Now, free glyph matrices in windows that were not reused.  */
       for (i = n = 0; i < n_leaf_windows; ++i)
        {
       /* Now, free glyph matrices in windows that were not reused.  */
       for (i = n = 0; i < n_leaf_windows; ++i)
        {

-         if (NILP (WGET (leaf_windows[i], buffer)))
+         if (NILP (leaf_windows[i]->buffer))

            {
              /* Assert it's not reused as a combination.  */
            {
              /* Assert it's not reused as a combination.  */

-             eassert (NILP (WGET (leaf_windows[i], hchild))
-                      && NILP (WGET (leaf_windows[i], vchild)));
+             eassert (NILP (leaf_windows[i]->hchild)
+                      && NILP (leaf_windows[i]->vchild));

              free_window_matrices (leaf_windows[i]);
            }
              free_window_matrices (leaf_windows[i]);
            }

-         else if (EQ (WGET (leaf_windows[i], buffer), new_current_buffer))
+         else if (EQ (leaf_windows[i]->buffer, new_current_buffer))

            ++n;
        }
 
       adjust_glyphs (f);
            ++n;
        }
 
       adjust_glyphs (f);

-      UNBLOCK_INPUT;
+      unblock_input ();

 
       /* Scan dead buffer windows.  */
       for (; CONSP (dead_windows); dead_windows = XCDR (dead_windows))
 
       /* Scan dead buffer windows.  */
       for (; CONSP (dead_windows); dead_windows = XCDR (dead_windows))


@@ -5727,7 +5897,13 @@ the return value is nil.  Otherwise the value is t.  */)
     }
 
   if (!NILP (new_current_buffer))
     }
 
   if (!NILP (new_current_buffer))

-    Fset_buffer (new_current_buffer);
+    {
+      Fset_buffer (new_current_buffer);
+      /* If the new current buffer doesn't appear in the selected
+        window, go to its old point (see bug#12208).  */
+      if (!EQ (XWINDOW (data->current_window)->buffer, new_current_buffer))
+       Fgoto_char (make_number (old_point));
+    }

 
   Vminibuf_scroll_window = data->minibuf_scroll_window;
   minibuf_selected_window = data->minibuf_selected_window;
 
   Vminibuf_scroll_window = data->minibuf_scroll_window;
   minibuf_selected_window = data->minibuf_selected_window;


@@ -5745,28 +5921,29 @@ delete_all_child_windows (Lisp_Object window)
 
   w = XWINDOW (window);
 
 
   w = XWINDOW (window);
 

-  if (!NILP (WGET (w, next)))
+  if (!NILP (w->next))

     /* Delete WINDOW's siblings (we traverse postorderly).  */
     /* Delete WINDOW's siblings (we traverse postorderly).  */

-    delete_all_child_windows (WGET (w, next));
+    delete_all_child_windows (w->next);

 
 

-  WSET (w, total_lines, WGET (w, buffer));       /* See Fset_window_configuration for excuse.  */
+  /* See Fset_window_configuration for excuse.  */
+  wset_total_lines (w, w->buffer);

 
 

-  if (!NILP (WGET (w, vchild)))
+  if (!NILP (w->vchild))

     {
     {

-      delete_all_child_windows (WGET (w, vchild));
-      WSET (w, vchild, Qnil);
+      delete_all_child_windows (w->vchild);
+      wset_vchild (w, Qnil);

     }
     }

-  else if (!NILP (WGET (w, hchild)))
+  else if (!NILP (w->hchild))

     {
     {

-      delete_all_child_windows (WGET (w, hchild));
-      WSET (w, hchild, Qnil);
+      delete_all_child_windows (w->hchild);
+      wset_hchild (w, Qnil);

     }
     }

-  else if (!NILP (WGET (w, buffer)))
+  else if (!NILP (w->buffer))

     {
       unshow_buffer (w);
     {
       unshow_buffer (w);

-      unchain_marker (XMARKER (WGET (w, pointm)));
-      unchain_marker (XMARKER (WGET (w, start)));
-      WSET (w, buffer, Qnil);
+      unchain_marker (XMARKER (w->pointm));
+      unchain_marker (XMARKER (w->start));
+      wset_buffer (w, Qnil);

     }
 
   Vwindow_list = Qnil;
     }
 
   Vwindow_list = Qnil;


@@ -5776,12 +5953,12 @@ static int
 count_windows (register struct window *window)
 {
   register int count = 1;
 count_windows (register struct window *window)
 {
   register int count = 1;

-  if (!NILP (WGET (window, next)))
-    count += count_windows (XWINDOW (WGET (window, next)));
-  if (!NILP (WGET (window, vchild)))
-    count += count_windows (XWINDOW (WGET (window, vchild)));
-  if (!NILP (WGET (window, hchild)))
-    count += count_windows (XWINDOW (WGET (window, hchild)));
+  if (!NILP (window->next))
+    count += count_windows (XWINDOW (window->next));
+  if (!NILP (window->vchild))
+    count += count_windows (XWINDOW (window->vchild));
+  if (!NILP (window->hchild))
+    count += count_windows (XWINDOW (window->hchild));

   return count;
 }
 
   return count;
 }
 


@@ -5793,14 +5970,14 @@ get_leaf_windows (struct window *w, struct window **flat, int i)
 {
   while (w)
     {
 {
   while (w)
     {

-      if (!NILP (WGET (w, hchild)))
-       i = get_leaf_windows (XWINDOW (WGET (w, hchild)), flat, i);
-      else if (!NILP (WGET (w, vchild)))
-       i = get_leaf_windows (XWINDOW (WGET (w, vchild)), flat, i);
+      if (!NILP (w->hchild))
+       i = get_leaf_windows (XWINDOW (w->hchild), flat, i);
+      else if (!NILP (w->vchild))
+       i = get_leaf_windows (XWINDOW (w->vchild), flat, i);

       else
        flat[i++] = w;
 
       else
        flat[i++] = w;
 

-      w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
+      w = NILP (w->next) ? 0 : XWINDOW (w->next);

     }
 
   return i;
     }
 
   return i;


@@ -5853,32 +6030,32 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
   register struct window *w;
   register Lisp_Object tem, pers, par;
 
   register struct window *w;
   register Lisp_Object tem, pers, par;
 

-  for (;!NILP (window); window = WGET (w, next))
+  for (;!NILP (window); window = w->next)

     {
       p = SAVED_WINDOW_N (vector, i);
       w = XWINDOW (window);
 
     {
       p = SAVED_WINDOW_N (vector, i);
       w = XWINDOW (window);
 

-      WSET (w, temslot, make_number (i)); i++;
+      wset_temslot (w, make_number (i)); i++;

       p->window = window;
       p->window = window;

-      p->buffer = WGET (w, buffer);
-      p->left_col = WGET (w, left_col);
-      p->top_line = WGET (w, top_line);
-      p->total_cols = WGET (w, total_cols);
-      p->total_lines = WGET (w, total_lines);
-      p->normal_cols = WGET (w, normal_cols);
-      p->normal_lines = WGET (w, normal_lines);
+      p->buffer = w->buffer;
+      p->left_col = w->left_col;
+      p->top_line = w->top_line;
+      p->total_cols = w->total_cols;
+      p->total_lines = w->total_lines;
+      p->normal_cols = w->normal_cols;
+      p->normal_lines = w->normal_lines;

       XSETFASTINT (p->hscroll, w->hscroll);
       XSETFASTINT (p->min_hscroll, w->min_hscroll);
       XSETFASTINT (p->hscroll, w->hscroll);
       XSETFASTINT (p->min_hscroll, w->min_hscroll);

-      p->display_table = WGET (w, display_table);
-      p->left_margin_cols = WGET (w, left_margin_cols);
-      p->right_margin_cols = WGET (w, right_margin_cols);
-      p->left_fringe_width = WGET (w, left_fringe_width);
-      p->right_fringe_width = WGET (w, right_fringe_width);
+      p->display_table = w->display_table;
+      p->left_margin_cols = w->left_margin_cols;
+      p->right_margin_cols = w->right_margin_cols;
+      p->left_fringe_width = w->left_fringe_width;
+      p->right_fringe_width = w->right_fringe_width;

       p->fringes_outside_margins = w->fringes_outside_margins ? Qt : Qnil;
       p->fringes_outside_margins = w->fringes_outside_margins ? Qt : Qnil;

-      p->scroll_bar_width = WGET (w, scroll_bar_width);
-      p->vertical_scroll_bar_type = WGET (w, vertical_scroll_bar_type);
-      p->dedicated = WGET (w, dedicated);
-      p->combination_limit = WGET (w, combination_limit);
+      p->scroll_bar_width = w->scroll_bar_width;
+      p->vertical_scroll_bar_type = w->vertical_scroll_bar_type;
+      p->dedicated = w->dedicated;
+      p->combination_limit = w->combination_limit;

       p->window_parameters = Qnil;
 
       if (!NILP (Vwindow_persistent_parameters))
       p->window_parameters = Qnil;
 
       if (!NILP (Vwindow_persistent_parameters))


@@ -5911,7 +6088,7 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
              /* Save values for persistent window parameters. */
              if (CONSP (pers) && !NILP (XCDR (pers)))
                {
              /* Save values for persistent window parameters. */
              if (CONSP (pers) && !NILP (XCDR (pers)))
                {

-                 par = Fassq (XCAR (pers), WGET (w, window_parameters));
+                 par = Fassq (XCAR (pers), w->window_parameters);

                  if (NILP (par))
                    /* If the window has no value for the parameter,
                       make one.  */
                  if (NILP (par))
                    /* If the window has no value for the parameter,
                       make one.  */


@@ -5927,24 +6104,24 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
            }
        }
 
            }
        }
 

-      if (!NILP (WGET (w, buffer)))
+      if (!NILP (w->buffer))

        {
          /* Save w's value of point in the window configuration.  If w
             is the selected window, then get the value of point from
             the buffer; pointm is garbage in the selected window.  */
          if (EQ (window, selected_window))
        {
          /* Save w's value of point in the window configuration.  If w
             is the selected window, then get the value of point from
             the buffer; pointm is garbage in the selected window.  */
          if (EQ (window, selected_window))

-           p->pointm = build_marker (XBUFFER (WGET (w, buffer)),
-                                     BUF_PT (XBUFFER (WGET (w, buffer))),
-                                     BUF_PT_BYTE (XBUFFER (WGET (w, buffer))));
+           p->pointm = build_marker (XBUFFER (w->buffer),
+                                     BUF_PT (XBUFFER (w->buffer)),
+                                     BUF_PT_BYTE (XBUFFER (w->buffer)));

          else
          else

-           p->pointm = Fcopy_marker (WGET (w, pointm), Qnil);
+           p->pointm = Fcopy_marker (w->pointm, Qnil);

          XMARKER (p->pointm)->insertion_type
            = !NILP (Vwindow_point_insertion_type);
 
          XMARKER (p->pointm)->insertion_type
            = !NILP (Vwindow_point_insertion_type);
 

-         p->start = Fcopy_marker (WGET (w, start), Qnil);
+         p->start = Fcopy_marker (w->start, Qnil);

          p->start_at_line_beg = w->start_at_line_beg ? Qt : Qnil;
 
          p->start_at_line_beg = w->start_at_line_beg ? Qt : Qnil;
 

-         tem = BVAR (XBUFFER (WGET (w, buffer)), mark);
+         tem = BVAR (XBUFFER (w->buffer), mark);

          p->mark = Fcopy_marker (tem, Qnil);
        }
       else
          p->mark = Fcopy_marker (tem, Qnil);
        }
       else


@@ -5955,20 +6132,20 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
          p->start_at_line_beg = Qnil;
        }
 
          p->start_at_line_beg = Qnil;
        }
 

-      if (NILP (WGET (w, parent)))
+      if (NILP (w->parent))

        p->parent = Qnil;
       else
        p->parent = Qnil;
       else

-       p->parent = WGET (XWINDOW (WGET (w, parent)), temslot);
+       p->parent = XWINDOW (w->parent)->temslot;

 
 

-      if (NILP (WGET (w, prev)))
+      if (NILP (w->prev))

        p->prev = Qnil;
       else
        p->prev = Qnil;
       else

-       p->prev = WGET (XWINDOW (WGET (w, prev)), temslot);
+       p->prev = XWINDOW (w->prev)->temslot;

 
 

-      if (!NILP (WGET (w, vchild)))
-       i = save_window_save (WGET (w, vchild), vector, i);
-      if (!NILP (WGET (w, hchild)))
-       i = save_window_save (WGET (w, hchild), vector, i);
+      if (!NILP (w->vchild))
+       i = save_window_save (w->vchild, vector, i);
+      if (!NILP (w->hchild))
+       i = save_window_save (w->hchild, vector, i);

     }
 
   return i;
     }
 
   return i;


@@ -6031,14 +6208,15 @@ saved by this function.  */)
 DEFUN ("set-window-margins", Fset_window_margins, Sset_window_margins,
        2, 3, 0,
        doc: /* Set width of marginal areas of window WINDOW.
 DEFUN ("set-window-margins", Fset_window_margins, Sset_window_margins,
        2, 3, 0,
        doc: /* Set width of marginal areas of window WINDOW.

-If WINDOW is nil, set margins of the currently selected window.
+WINDOW must be a live window and defaults to the selected one.
+

 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.  */)
   (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width)
 {
 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.  */)
   (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width)
 {

-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);

 
   /* Translate negative or zero widths to nil.
      Margins that are too wide have to be checked elsewhere.  */
 
   /* Translate negative or zero widths to nil.
      Margins that are too wide have to be checked elsewhere.  */


@@ -6057,11 +6235,11 @@ means no margin.  */)
        right_width = Qnil;
     }
 
        right_width = Qnil;
     }
 

-  if (!EQ (WGET (w, left_margin_cols), left_width)
-      || !EQ (WGET (w, right_margin_cols), right_width))
+  if (!EQ (w->left_margin_cols, left_width)
+      || !EQ (w->right_margin_cols, right_width))

     {
     {

-      WSET (w, left_margin_cols, left_width);
-      WSET (w, right_margin_cols, right_width);
+      wset_left_margin_cols (w, left_width);
+      wset_right_margin_cols (w, right_width);

 
       adjust_window_margins (w);
 
 
       adjust_window_margins (w);
 


@@ -6076,14 +6254,15 @@ means no margin.  */)
 DEFUN ("window-margins", Fwindow_margins, Swindow_margins,
        0, 1, 0,
        doc: /* Get width of marginal areas of window WINDOW.
 DEFUN ("window-margins", Fwindow_margins, Swindow_margins,
        0, 1, 0,
        doc: /* Get width of marginal areas of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
+

 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.  */)
   (Lisp_Object 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.  */)
   (Lisp_Object window)
 {

-  struct window *w = decode_window (window);
-  return Fcons (WGET (w, left_margin_cols), WGET (w, right_margin_cols));
+  struct window *w = decode_live_window (window);
+  return Fcons (w->left_margin_cols, w->right_margin_cols);

 }
 
 
 }
 
 


@@ -6095,8 +6274,8 @@ as nil.  */)
 DEFUN ("set-window-fringes", Fset_window_fringes, Sset_window_fringes,
        2, 4, 0,
        doc: /* Set the fringe widths of window WINDOW.
 DEFUN ("set-window-fringes", Fset_window_fringes, Sset_window_fringes,
        2, 4, 0,
        doc: /* Set the fringe widths of window WINDOW.

-If WINDOW is nil, set the fringe widths of the currently selected
-window.
+WINDOW must be a live window and defaults to the selected one.
+

 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
 the left fringe.  Optional third arg RIGHT-WIDTH specifies the right
 fringe width.  If a fringe width arg is nil, that means to use the
 Second arg LEFT-WIDTH specifies the number of pixels to reserve for
 the left fringe.  Optional third arg RIGHT-WIDTH specifies the right
 fringe width.  If a fringe width arg is nil, that means to use the


@@ -6107,7 +6286,7 @@ outside of the display margins.  By default, fringes are drawn between
 display marginal areas and the text area.  */)
   (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width, Lisp_Object outside_margins)
 {
 display marginal areas and the text area.  */)
   (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width, Lisp_Object outside_margins)
 {

-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);

   int outside = !NILP (outside_margins);
 
   if (!NILP (left_width))
   int outside = !NILP (outside_margins);
 
   if (!NILP (left_width))


@@ -6117,18 +6296,18 @@ display marginal areas and the text area.  */)
 
   /* Do nothing on a tty.  */
   if (FRAME_WINDOW_P (WINDOW_XFRAME (w))
 
   /* Do nothing on a tty.  */
   if (FRAME_WINDOW_P (WINDOW_XFRAME (w))

-      && (!EQ (WGET (w, left_fringe_width), left_width)
-         || !EQ (WGET (w, right_fringe_width), right_width)
+      && (!EQ (w->left_fringe_width, left_width)
+         || !EQ (w->right_fringe_width, right_width)

          || w->fringes_outside_margins != outside))
     {
          || w->fringes_outside_margins != outside))
     {

-      WSET (w, left_fringe_width, left_width);
-      WSET (w, right_fringe_width, right_width);
+      wset_left_fringe_width (w, left_width);
+      wset_right_fringe_width (w, right_width);

       w->fringes_outside_margins = outside;
 
       adjust_window_margins (w);
 
       clear_glyph_matrix (w->current_matrix);
       w->fringes_outside_margins = outside;
 
       adjust_window_margins (w);
 
       clear_glyph_matrix (w->current_matrix);

-      WSET (w, window_end_valid, Qnil);
+      wset_window_end_valid (w, Qnil);

 
       ++windows_or_buffers_changed;
       adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
 
       ++windows_or_buffers_changed;
       adjust_glyphs (XFRAME (WINDOW_FRAME (w)));


@@ -6141,11 +6320,12 @@ display marginal areas and the text area.  */)
 DEFUN ("window-fringes", Fwindow_fringes, Swindow_fringes,
        0, 1, 0,
        doc: /* Get width of fringes of window WINDOW.
 DEFUN ("window-fringes", Fwindow_fringes, Swindow_fringes,
        0, 1, 0,
        doc: /* Get width of fringes of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
+

 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).  */)
   (Lisp_Object window)
 {
 Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).  */)
   (Lisp_Object window)
 {

-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);

 
   return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w)),
                Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w)),
 
   return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w)),
                Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w)),


@@ -6162,7 +6342,8 @@ Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).  */)
 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars,
        Sset_window_scroll_bars, 2, 4, 0,
        doc: /* Set width and type of scroll bars of window WINDOW.
 DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars,
        Sset_window_scroll_bars, 2, 4, 0,
        doc: /* Set width and type of scroll bars of window WINDOW.

-If window is nil, set scroll bars of the currently selected window.
+WINDOW must be a live window and defaults to the selected one.
+

 Second parameter WIDTH specifies the pixel width for the scroll bar;
 this is automatically adjusted to a multiple of the frame column width.
 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
 Second parameter WIDTH specifies the pixel width for the scroll bar;
 this is automatically adjusted to a multiple of the frame column width.
 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll


@@ -6172,7 +6353,7 @@ If VERTICAL-TYPE is t, use the frame's scroll-bar type.
 Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
   (Lisp_Object window, Lisp_Object width, Lisp_Object vertical_type, Lisp_Object horizontal_type)
 {
 Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
   (Lisp_Object window, Lisp_Object width, Lisp_Object vertical_type, Lisp_Object horizontal_type)
 {

-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);

 
   if (!NILP (width))
     {
 
   if (!NILP (width))
     {


@@ -6188,16 +6369,16 @@ Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
        || EQ (vertical_type, Qt)))
     error ("Invalid type of vertical scroll bar");
 
        || EQ (vertical_type, Qt)))
     error ("Invalid type of vertical scroll bar");
 

-  if (!EQ (WGET (w, scroll_bar_width), width)
-      || !EQ (WGET (w, vertical_scroll_bar_type), vertical_type))
+  if (!EQ (w->scroll_bar_width, width)
+      || !EQ (w->vertical_scroll_bar_type, vertical_type))

     {
     {

-      WSET (w, scroll_bar_width, width);
-      WSET (w, vertical_scroll_bar_type, vertical_type);
+      wset_scroll_bar_width (w, width);
+      wset_vertical_scroll_bar_type (w, vertical_type);

 
       adjust_window_margins (w);
 
       clear_glyph_matrix (w->current_matrix);
 
       adjust_window_margins (w);
 
       clear_glyph_matrix (w->current_matrix);

-      WSET (w, window_end_valid, Qnil);
+      wset_window_end_valid (w, Qnil);

 
       ++windows_or_buffers_changed;
       adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
 
       ++windows_or_buffers_changed;
       adjust_glyphs (XFRAME (WINDOW_FRAME (w)));


@@ -6210,18 +6391,19 @@ Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
 DEFUN ("window-scroll-bars", Fwindow_scroll_bars, Swindow_scroll_bars,
        0, 1, 0,
        doc: /* Get width and type of scroll bars of window WINDOW.
 DEFUN ("window-scroll-bars", Fwindow_scroll_bars, Swindow_scroll_bars,
        0, 1, 0,
        doc: /* Get width and type of scroll bars of window WINDOW.

-If WINDOW is omitted or nil, it defaults to the selected window.
+WINDOW must be a live window and defaults to the selected one.
+

 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.  */)
   (Lisp_Object 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.  */)
   (Lisp_Object window)
 {

-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);

   return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
                              ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
                              : WINDOW_SCROLL_BAR_AREA_WIDTH (w))),
                Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w)),
   return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
                              ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
                              : WINDOW_SCROLL_BAR_AREA_WIDTH (w))),
                Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w)),

-                      Fcons (WGET (w, vertical_scroll_bar_type),
+                      Fcons (w->vertical_scroll_bar_type,

                              Fcons (Qnil, Qnil))));
 }
 
                              Fcons (Qnil, Qnil))));
 }
 


@@ -6247,7 +6429,7 @@ optional second arg PIXELS-P means value is measured in pixels.  */)
   else
     CHECK_WINDOW (window);
   w = XWINDOW (window);
   else
     CHECK_WINDOW (window);
   w = XWINDOW (window);

-  f = XFRAME (WGET (w, frame));
+  f = XFRAME (w->frame);

 
   if (FRAME_WINDOW_P (f))
     result = (NILP (pixels_p)
 
   if (FRAME_WINDOW_P (f))
     result = (NILP (pixels_p)


@@ -6281,7 +6463,7 @@ If PIXELS-P is non-nil, the return value is VSCROLL.  */)
   CHECK_NUMBER_OR_FLOAT (vscroll);
 
   w = XWINDOW (window);
   CHECK_NUMBER_OR_FLOAT (vscroll);
 
   w = XWINDOW (window);

-  f = XFRAME (WGET (w, frame));
+  f = XFRAME (w->frame);

 
   if (FRAME_WINDOW_P (f))
     {
 
   if (FRAME_WINDOW_P (f))
     {


@@ -6300,7 +6482,7 @@ If PIXELS-P is non-nil, the return value is VSCROLL.  */)
            adjust_glyphs (f);
 
          /* Prevent redisplay shortcuts.  */
            adjust_glyphs (f);
 
          /* Prevent redisplay shortcuts.  */

-         XBUFFER (WGET (w, buffer))->prevent_redisplay_optimizations_p = 1;
+         XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;

        }
     }
 
        }
     }
 


@@ -6334,14 +6516,14 @@ foreach_window_1 (struct window *w, int (*fn) (struct window *, void *), void *u
 
   for (cont = 1; w && cont;)
     {
 
   for (cont = 1; w && cont;)
     {

-      if (!NILP (WGET (w, hchild)))
-       cont = foreach_window_1 (XWINDOW (WGET (w, hchild)), fn, user_data);
-      else if (!NILP (WGET (w, vchild)))
-       cont = foreach_window_1 (XWINDOW (WGET (w, vchild)), fn, user_data);
+      if (!NILP (w->hchild))
+       cont = foreach_window_1 (XWINDOW (w->hchild), fn, user_data);
+      else if (!NILP (w->vchild))
+       cont = foreach_window_1 (XWINDOW (w->vchild), fn, user_data);

       else
        cont = fn (w, user_data);
 
       else
        cont = fn (w, user_data);
 

-      w = NILP (WGET (w, next)) ? 0 : XWINDOW (WGET (w, next));
+      w = NILP (w->next) ? 0 : XWINDOW (w->next);

     }
 
   return cont;
     }
 
   return cont;


@@ -6386,15 +6568,17 @@ freeze_window_starts (struct frame *f, int freeze_p)
 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
    describe the same state of affairs.  This is used by Fequal.
 
 /* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
    describe the same state of affairs.  This is used by Fequal.
 

-   ignore_positions non-zero means ignore non-matching scroll positions
+   IGNORE_POSITIONS means ignore non-matching scroll positions

    and the like.
 
    This ignores a couple of things like the dedication status of
    window, combination_limit and the like.  This might have to be
    fixed.  */
 
    and the like.
 
    This ignores a couple of things like the dedication status of
    window, combination_limit and the like.  This might have to be
    fixed.  */
 

-int
-compare_window_configurations (Lisp_Object configuration1, Lisp_Object configuration2, int ignore_positions)
+bool
+compare_window_configurations (Lisp_Object configuration1,
+                              Lisp_Object configuration2,
+                              bool ignore_positions)

 {
   register struct save_window_data *d1, *d2;
   struct Lisp_Vector *sws1, *sws2;
 {
   register struct save_window_data *d1, *d2;
   struct Lisp_Vector *sws1, *sws2;


@@ -6510,6 +6694,7 @@ syms_of_window (void)
   DEFSYM (Qwindowp, "windowp");
   DEFSYM (Qwindow_configuration_p, "window-configuration-p");
   DEFSYM (Qwindow_live_p, "window-live-p");
   DEFSYM (Qwindowp, "windowp");
   DEFSYM (Qwindow_configuration_p, "window-configuration-p");
   DEFSYM (Qwindow_live_p, "window-live-p");

+  DEFSYM (Qwindow_valid_p, "window-valid-p");

   DEFSYM (Qwindow_deletable_p, "window-deletable-p");
   DEFSYM (Qdelete_window, "delete-window");
   DEFSYM (Qwindow_resize_root_window, "window--resize-root-window");
   DEFSYM (Qwindow_deletable_p, "window-deletable-p");
   DEFSYM (Qdelete_window, "delete-window");
   DEFSYM (Qwindow_resize_root_window, "window--resize-root-window");


@@ -6519,10 +6704,10 @@ syms_of_window (void)
   DEFSYM (Qreplace_buffer_in_windows, "replace-buffer-in-windows");
   DEFSYM (Qrecord_window_buffer, "record-window-buffer");
   DEFSYM (Qget_mru_window, "get-mru-window");
   DEFSYM (Qreplace_buffer_in_windows, "replace-buffer-in-windows");
   DEFSYM (Qrecord_window_buffer, "record-window-buffer");
   DEFSYM (Qget_mru_window, "get-mru-window");

+  DEFSYM (Qwindow_size, "window-size");

   DEFSYM (Qtemp_buffer_show_hook, "temp-buffer-show-hook");
   DEFSYM (Qabove, "above");
   DEFSYM (Qbelow, "below");
   DEFSYM (Qtemp_buffer_show_hook, "temp-buffer-show-hook");
   DEFSYM (Qabove, "above");
   DEFSYM (Qbelow, "below");

-  DEFSYM (Qauto_buffer_name, "auto-buffer-name");

   DEFSYM (Qclone_of, "clone-of");
 
   staticpro (&Vwindow_list);
   DEFSYM (Qclone_of, "clone-of");
 
   staticpro (&Vwindow_list);


@@ -6615,23 +6800,36 @@ This variable takes no effect if `window-combination-limit' is non-nil.  */);
   Vwindow_combination_resize = Qnil;
 
   DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit,
   Vwindow_combination_resize = Qnil;
 
   DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit,

-              doc: /* If t, splitting a window makes a new parent window.
-If this variable is nil, splitting a window will create a new parent
-window only if the window has no parent window or the window shall
-become a combination orthogonal to the one it is part of.
+              doc: /* If non-nil, splitting a window makes a new parent window.
+The following values are recognized:

 
 

-If this variable is t, splitting a window always creates a new parent
-window.  If all splits behave this way, each frame's window tree is a
-binary tree and every window but the frame's root window has exactly one
-sibling.
+nil means splitting a window will create a new parent window only if the
+    window has no parent window or the window shall become part of a
+    combination orthogonal to the one it is part of.

 
 

-Other values are reserved for future use.
+`window-size' means that splitting a window for displaying a buffer
+    makes a new parent window provided `display-buffer' is supposed to
+    explicitly set the window's size due to the presence of a
+    `window-height' or `window-width' entry in the alist used by
+    `display-buffer'.  Otherwise, this value is handled like nil.
+
+`temp-buffer' means that splitting a window for displaying a temporary
+    buffer always makes a new parent window.  Otherwise, this value is
+    handled like nil.
+
+`display-buffer' means that splitting a window for displaying a buffer
+    always makes a new parent window.  Since temporary buffers are
+    displayed by the function `display-buffer', this value is stronger
+    than `temp-buffer'.  Splitting a window for other purpose makes a
+    new parent window only if needed.
+
+t means that splitting a window always creates a new parent window.  If
+    all splits behave this way, each frame's window tree is a binary
+    tree and every window but the frame's root window has exactly one
+    sibling.

 
 

-The value of this variable is also assigned to the combination limit of
-the new parent window.  The combination limit of a window can be
-retrieved via the function `window-combination-limit' and altered by the
-function `set-window-combination-limit'.  */);
-  Vwindow_combination_limit = Qnil;
+Other values are reserved for future use.  */);
+  Vwindow_combination_limit = Qwindow_size;

 
   DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters,
               doc: /* Alist of persistent window parameters.
 
   DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters,
               doc: /* Alist of persistent window parameters.


@@ -6662,6 +6860,7 @@ respectively are not installed by `window-state-put'.  */);
   defsubr (&Sminibuffer_window);
   defsubr (&Swindow_minibuffer_p);
   defsubr (&Swindowp);
   defsubr (&Sminibuffer_window);
   defsubr (&Swindow_minibuffer_p);
   defsubr (&Swindowp);

+  defsubr (&Swindow_valid_p);

   defsubr (&Swindow_live_p);
   defsubr (&Swindow_frame);
   defsubr (&Sframe_root_window);
   defsubr (&Swindow_live_p);
   defsubr (&Swindow_frame);
   defsubr (&Sframe_root_window);