merge trunk

1 files changed, 505 insertions, 439 deletions

diff --git a/src/window.c b/src/window.c
index 7fd66057ad2..7874105df1e 100644
--- a/src/window.c
+++ b/src/window.c
@@ -51,7 +51,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "nsterm.h"
 #endif
 
-Lisp_Object Qwindowp, Qwindow_live_p;
+Lisp_Object Qwindowp, Qwindow_live_p, 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;
@@ -61,7 +61,6 @@ static Lisp_Object Qsafe, Qabove, Qbelow;
 static Lisp_Object Qauto_buffer_name, Qclone_of;
 
 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);
@@ -131,8 +130,8 @@ static int window_scroll_pixel_based_preserve_y;
 static EMACS_INT window_scroll_preserve_hpos;
 static EMACS_INT window_scroll_preserve_vpos;
 
-static struct window *
-decode_window (register Lisp_Object window)
+struct window *
+decode_live_window (register Lisp_Object window)
 {
   if (NILP (window))
     return XWINDOW (selected_window);
@@ -144,11 +143,27 @@ decode_window (register Lisp_Object window)
 static struct window *
 decode_any_window (register Lisp_Object window)
 {
+  struct window *w;
+
   if (NILP (window))
     return XWINDOW (selected_window);
 
   CHECK_WINDOW (window);
-  return XWINDOW (window);
+  w = XWINDOW (window);
+  return w;
+}
+
+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;
 }
 
 DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
@@ -158,6 +173,15 @@ DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
   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.
@@ -170,10 +194,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.
-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)
 {
-  return decode_any_window (window)->frame;
+  return decode_valid_window (window)->frame;
 }
 
 DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
@@ -187,8 +211,8 @@ With a window argument, return the root window of that window's frame.  */)
 
   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);
@@ -212,18 +236,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.
-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)
 {
-  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.
-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)
 {
@@ -231,7 +255,7 @@ the first window of that frame.  */)
 
   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
     {
@@ -256,16 +280,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.
-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;
-  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
     {
@@ -298,7 +322,7 @@ Return WINDOW.  */)
   if (EQ (frame, selected_frame))
     return Fselect_window (window, norecord);
   else
-    return XFRAME (frame)->selected_window = window;
+    return FSET (XFRAME (frame), selected_window, window);
 }
 
 DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
@@ -341,7 +365,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
   sf = SELECTED_FRAME ();
   if (XFRAME (WINDOW_FRAME (w)) != sf)
     {
-      XFRAME (WINDOW_FRAME (w))->selected_window = window;
+      FSET (XFRAME (WINDOW_FRAME (w)), selected_window, window);
       /* Use this rather than Fhandle_switch_frame
          so that FRAME_FOCUS_FRAME is moved appropriately as we
          move around in the state where a minibuffer in a separate
@@ -352,7 +376,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
       return window;
     }
   else
-    sf->selected_window = window;
+    FSET (sf, selected_window, window);
 
   /* Store the current buffer's actual point into the
      old selected window.  It belongs to that window,
@@ -370,7 +394,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
 
   Fset_buffer (w->buffer);
 
-  BVAR (XBUFFER (w->buffer), last_selected_window) = window;
+  BSET (XBUFFER (w->buffer), last_selected_window, window);
 
   /* Go to the point recorded in the window.
      This is important when the buffer is in more
@@ -418,92 +442,92 @@ Return nil for an internal window or a deleted 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 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.
+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 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.
+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 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.
-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 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.
-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 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.
+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)
 {
-  return 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.
+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)
 {
-  register struct window *w = decode_any_window (window);
-
-  w->combination_limit = limit;
-
-  return w->combination_limit;
+  return WSET (decode_valid_window (window), combination_limit, limit);
 }
 
 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)
 {
-  return make_number (decode_window (window)->use_time);
+  return make_number (decode_live_window (window)->use_time);
 }
 
 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
@@ -513,12 +537,12 @@ On a graphical display, this total height is reported as an
 integer multiple of the default character height.  */)
   (Lisp_Object window)
 {
-  return 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.
-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
@@ -528,35 +552,34 @@ On a graphical display, this total width is reported as an
 integer multiple of the default character width.  */)
   (Lisp_Object window)
 {
-  return 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.
-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)
 {
-  return 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.
-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 (NILP (horizontal))
-    return decode_any_window (window)->normal_lines;
-  else
-    return 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.
-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)
 {
-  return 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,
@@ -565,10 +588,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.
 
-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)
 {
-  return 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,
@@ -577,10 +600,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.
 
-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)
 {
-  return 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
@@ -634,8 +657,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.
-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
@@ -644,21 +666,20 @@ area is only partially visible, that counts as a whole line; to
 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.
-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)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   return make_number (window_body_cols (w));
 }
 
@@ -667,7 +688,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)
 {
-  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
@@ -694,7 +715,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.
-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.
 
@@ -702,7 +723,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)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
 
   CHECK_NUMBER (ncol);
   return set_window_hscroll (w, XINT (ncol));
@@ -711,44 +732,43 @@ 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.
-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)
 {
-  return 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.
-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 struct window *w;
-
-  w = decode_window (window);
-  w->redisplay_end_trigger = value;
-  return value;
+  return WSET (decode_live_window (window), redisplay_end_trigger, value);
 }
 
 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)
 {
-  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)),
@@ -759,8 +779,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.
-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.
@@ -769,7 +791,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)
 {
-  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)),
@@ -803,8 +825,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.
-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.
@@ -813,7 +837,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)
 {
-  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);
 
@@ -826,17 +850,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.
-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.
-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)
 {
-  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)
@@ -852,8 +878,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.
-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.
@@ -861,7 +889,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)
 {
-  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)
@@ -879,8 +907,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.
-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.
@@ -888,7 +918,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)
 {
-  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);
 
@@ -1067,7 +1097,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.
-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
@@ -1089,8 +1119,7 @@ If they are in the windows's left or right marginal areas, `left-margin'\n\
   int x, y;
   Lisp_Object lx, ly;
 
-  CHECK_LIVE_WINDOW (window);
-  w = XWINDOW (window);
+  w = decode_live_window (window);
   f = XFRAME (w->frame);
   CHECK_CONS (coordinates);
   lx = Fcar (coordinates);
@@ -1268,7 +1297,7 @@ of point, outside of any save-excursion forms.
 But that is hard to define.  */)
   (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 (w->buffer))
@@ -1282,7 +1311,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)
 {
-  return Fmarker_position (decode_window (window)->start);
+  return Fmarker_position (decode_live_window (window)->start);
 }
 
 /* This is text temporarily removed from the doc string below.
@@ -1309,7 +1338,7 @@ if it isn't already recorded.  */)
   (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;
 
@@ -1376,10 +1405,11 @@ if it isn't already recorded.  */)
 
 DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0,
        doc: /* Make point value in WINDOW be at position POS in WINDOW's buffer.
+WINDOW must be a live window and defaults to the selected one.
 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);
   if (w == XWINDOW (selected_window)
@@ -1398,12 +1428,12 @@ 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)
 {
-  register struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);
 
   CHECK_NUMBER_COERCE_MARKER (pos);
   set_marker_restricted (w->start, pos, w->buffer);
@@ -1423,12 +1453,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.
-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]),
@@ -1447,7 +1479,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
   int rtop, rbot, rowh, vpos, fully_p = 1;
   int x, y;
 
-  w = decode_window (window);
+  w = decode_live_window (window);
   buf = XBUFFER (w->buffer);
   SET_TEXT_POS_FROM_MARKER (top, w->start);
 
@@ -1489,7 +1521,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.
-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'.
@@ -1513,7 +1545,7 @@ Return nil if window display is not up-to-date.  In that case, use
   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;
@@ -1601,8 +1633,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
-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
@@ -1615,7 +1647,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)
 {
-  return decode_window (window)->dedicated;
+  return decode_live_window (window)->dedicated;
 }
 
 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p,
@@ -1639,10 +1671,7 @@ 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)
 {
-  register struct window *w = decode_window (window);
-
-  w->dedicated = flag;
-  return w->dedicated;
+  return WSET (decode_live_window (window), dedicated, flag);
 }
 
 DEFUN ("window-prev-buffers", Fwindow_prev_buffers, Swindow_prev_buffers,
@@ -1655,7 +1684,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)
 {
-  return decode_window (window)->prev_buffers;
+  return decode_live_window (window)->prev_buffers;
 }
 
 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers,
@@ -1668,7 +1697,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, Lisp_Object prev_buffers)
 {
-  return decode_window (window)->prev_buffers = prev_buffers;
+  return WSET (decode_live_window (window), prev_buffers, prev_buffers);
 }
 
 DEFUN ("window-next-buffers", Fwindow_next_buffers, Swindow_next_buffers,
@@ -1677,7 +1706,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)
 {
-  return decode_window (window)->next_buffers;
+  return decode_live_window (window)->next_buffers;
 }
 
 DEFUN ("set-window-next-buffers", Fset_window_next_buffers,
@@ -1687,43 +1716,45 @@ 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)
 {
-  return decode_window (window)->next_buffers = next_buffers;
+  return WSET (decode_live_window (window), next_buffers, next_buffers);
 }
 
 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)
 {
-  return Fcopy_alist (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.
-WINDOW defaults to the selected window.  */)
+WINDOW must be a valid window and defaults to the selected one.  */)
   (Lisp_Object window, Lisp_Object parameter)
 {
   Lisp_Object result;
 
-  result = Fassq (parameter, decode_any_window (window)->window_parameters);
+  result = Fassq (parameter, decode_valid_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.
-WINDOW defaults to the selected window.  Return VALUE.  */)
+WINDOW must be a valid 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);
+  register struct window *w = decode_valid_window (window);
   Lisp_Object old_alist_elt;
 
   old_alist_elt = Fassq (parameter, w->window_parameters);
   if (NILP (old_alist_elt))
-    w->window_parameters = Fcons (Fcons (parameter, value), w->window_parameters);
+    WSET (w, window_parameters,
+          Fcons (Fcons (parameter, value), w->window_parameters));
   else
     Fsetcdr (old_alist_elt, value);
   return value;
@@ -1732,10 +1763,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.
-WINDOW defaults to the selected window.  */)
+WINDOW must be a live window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return 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
@@ -1764,14 +1795,11 @@ window_display_table (struct window *w)
 }
 
 DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0,
-       doc: /* Set WINDOW's display-table to TABLE.  */)
+       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 struct window *w;
-
-  w = decode_window (window);
-  w->display_table = table;
-  return table;
+  return WSET (decode_live_window (window), display_table, table);
 }
 
 /* Record info on buffer window W is displaying
@@ -1820,7 +1848,7 @@ unshow_buffer (register struct window *w)
 
   if (WINDOWP (BVAR (b, last_selected_window))
       && w == XWINDOW (BVAR (b, last_selected_window)))
-    BVAR (b, last_selected_window) = Qnil;
+    BSET (b, last_selected_window, Qnil);
 }
 
 /* Put NEW into the window structure in place of OLD.  SETFLAG zero
@@ -1835,18 +1863,18 @@ 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 (EQ (old, FRAME_ROOT_WINDOW (XFRAME (o->frame))))
-    FRAME_ROOT_WINDOW (XFRAME (o->frame)) = new;
-
-  if (setflag)
-    {
-      n->left_col = o->left_col;
-      n->top_line = o->top_line;
-      n->total_cols = o->total_cols;
-      n->total_lines = o->total_lines;
-      n->normal_cols = o->normal_cols;
-      o->normal_cols = make_float (1.0);
-      n->normal_lines = o->normal_lines;
-      o->normal_lines = make_float (1.0);
+    FSET (XFRAME (o->frame), root_window, new);
+
+   if (setflag)
+     {
+      WSET (n, left_col, o->left_col);
+      WSET (n, top_line, o->top_line);
+      WSET (n, total_cols, o->total_cols);
+      WSET (n, total_lines, o->total_lines);
+      WSET (n, normal_cols, o->normal_cols);
+      WSET (o, normal_cols, make_float (1.0));
+      WSET (n, normal_lines, o->normal_lines);
+      WSET (o, normal_lines, make_float (1.0));
       n->desired_matrix = n->current_matrix = 0;
       n->vscroll = 0;
       memset (&n->cursor, 0, sizeof (n->cursor));
@@ -1856,27 +1884,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;
-      XSETFASTINT (n->window_end_vpos, 0);
-      XSETFASTINT (n->window_end_pos, 0);
-      n->window_end_valid = Qnil;
+      WSET (n, window_end_vpos, make_number (0));
+      WSET (n, window_end_pos, make_number (0));
+      WSET (n, window_end_valid, Qnil);
       n->frozen_window_start_p = 0;
     }
 
-  n->next = tem = o->next;
+  tem = o->next;
+  WSET (n, next, tem);
   if (!NILP (tem))
-    XWINDOW (tem)->prev = new;
+    WSET (XWINDOW (tem), prev, new);
 
-  n->prev = tem = o->prev;
+  tem = o->prev;
+  WSET (n, prev, tem);
   if (!NILP (tem))
-    XWINDOW (tem)->next = new;
+    WSET (XWINDOW (tem), next, new);
 
-  n->parent = tem = o->parent;
+  tem = o->parent;
+  WSET (n, parent, tem);
   if (!NILP (tem))
     {
       if (EQ (XWINDOW (tem)->vchild, old))
-        XWINDOW (tem)->vchild = new;
+        WSET (XWINDOW (tem), vchild, new);
       if (EQ (XWINDOW (tem)->hchild, old))
-        XWINDOW (tem)->hchild = new;
+        WSET (XWINDOW (tem), hchild, new);
     }
 }
 
@@ -1909,34 +1940,34 @@ recombine_windows (Lisp_Object window)
              assign new normal sizes.  */
           if (NILP (w->prev))
             if (horflag)
-              p->hchild = child;
+              WSET (p, hchild, child);
             else
-              p->vchild = child;
+              WSET (p, vchild, child);
           else
             {
-              c->prev = w->prev;
-              XWINDOW (w->prev)->next = child;
+              WSET (c, prev, w->prev);
+              WSET (XWINDOW (w->prev), next, child);
             }
 
           while (c)
             {
-              c->parent = parent;
+              WSET (c, parent, parent);
 
               if (horflag)
-                c->normal_cols
-                  = make_float (XFLOATINT (c->total_cols)
-                                / XFLOATINT (p->total_cols));
+                WSET (c, normal_cols,
+                      make_float (XFLOATINT (c->total_cols)
+                                  / XFLOATINT (p->total_cols)));
               else
-                c->normal_lines
-                  = make_float (XFLOATINT (c->total_lines)
-                                / XFLOATINT (p->total_lines));
+                WSET (c, normal_lines,
+                      make_float (XFLOATINT (c->total_lines)
+                                  / XFLOATINT (p->total_lines)));
 
               if (NILP (c->next))
                 {
                   if (!NILP (w->next))
                     {
-                      c->next = w->next;
-                      XWINDOW (c->next)->prev = child;
+                      WSET (c, next, w->next);
+                      WSET (XWINDOW (c->next), prev, child);
                     }
 
                   c = 0;
@@ -1949,7 +1980,8 @@ recombine_windows (Lisp_Object window)
             }
 
           /* WINDOW can be deleted now.  */
-          w->vchild = w->hchild = Qnil;
+          WSET (w, vchild, Qnil);
+          WSET (w, hchild, Qnil);
         }
     }
 }
@@ -2114,9 +2146,10 @@ 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 = (!EQ (*minibuf, Qlambda)
-                   ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window)->frame))
-                   : Qnil);
+    *all_frames 
+      = (!EQ (*minibuf, Qlambda)
+         ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window)->frame))
+         : Qnil);
   else if (EQ (*all_frames, Qvisible))
     ;
   else if (EQ (*all_frames, make_number (0)))
@@ -2469,7 +2502,7 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
             if (EQ (w->buffer, obj))
               {
                 /* Undedicate WINDOW.  */
-                w->dedicated = Qnil;
+                WSET (w, dedicated, Qnil);
                 /* Make WINDOW show the buffer returned by
                    other_buffer_safely, don't run any hooks.  */
                 set_window_buffer
@@ -2562,8 +2595,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.
-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
@@ -2582,7 +2615,7 @@ 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;
 
-  w = decode_any_window (window);
+  w = decode_valid_window (window);
   XSETWINDOW (window, w);
   f = XFRAME (w->frame);
 
@@ -2595,7 +2628,7 @@ window-start value is reasonable when this function is called.  */)
   else
     /* ROOT must be an ancestor of WINDOW.  */
     {
-      r = decode_any_window (root);
+      r = decode_valid_window (root);
       pwindow = XWINDOW (window)->parent;
       while (!NILP (pwindow))
         if (EQ (pwindow, root))
@@ -2626,7 +2659,7 @@ window-start value is reasonable when this function is called.  */)
           if (EQ (selected_frame, w->frame))
             Fselect_window (window, Qnil);
           else
-            FRAME_SELECTED_WINDOW (f) = window;
+            FSET (f, selected_window, window);
         }
     }
   else
@@ -2656,7 +2689,7 @@ window-start value is reasonable when this function is called.  */)
           if (EQ (selected_frame, w->frame))
             Fselect_window (swindow, Qnil);
           else
-            FRAME_SELECTED_WINDOW (f) = swindow;
+            FSET (f, selected_window, swindow);
         }
     }
 
@@ -2689,8 +2722,9 @@ window-start value is reasonable when this function is called.  */)
   if (NILP (w->buffer))
     {
       /* Resize child windows vertically.  */
-      XSETINT (delta, XINT (r->total_lines) - XINT (w->total_lines));
-      w->top_line = r->top_line;
+      XSETINT (delta, XINT (r->total_lines)
+               - XINT (w->total_lines));
+      WSET (w, top_line, r->top_line);
       resize_root_window (window, delta, Qnil, Qnil);
       if (window_resize_check (w, 0))
         window_resize_apply (w, 0);
@@ -2706,9 +2740,10 @@ window-start value is reasonable when this function is called.  */)
       /* Resize child windows horizontally.  */
       if (!resize_failed)
         {
-          w->left_col = r->left_col;
-          XSETINT (delta, XINT (r->total_cols) - XINT (w->total_cols));
-          w->left_col = r->left_col;
+          WSET (w, left_col, r->left_col);
+          XSETINT (delta, XINT (r->total_cols) 
+                   - XINT (w->total_cols));
+          WSET (w, left_col, r->left_col);
           resize_root_window (window, delta, Qt, Qnil);
           if (window_resize_check (w, 1))
             window_resize_apply (w, 1);
@@ -2736,32 +2771,32 @@ window-start value is reasonable when this function is called.  */)
     {
       sibling = w->prev;
       s = XWINDOW (sibling);
-      s->next = w->next;
+      WSET (s, next, w->next);
       if (!NILP (s->next))
-        XWINDOW (s->next)->prev = sibling;
+        WSET (XWINDOW (s->next), prev, sibling);
     }
   else
     /* Get SIBLING below (on the right of) WINDOW.  */
     {
       sibling = w->next;
       s = XWINDOW (sibling);
-      s->prev = Qnil;
+      WSET (s, prev, Qnil);
       if (!NILP (XWINDOW (w->parent)->vchild))
-        XWINDOW (w->parent)->vchild = sibling;
+        WSET (XWINDOW (w->parent), vchild, sibling);
       else
-        XWINDOW (w->parent)->hchild = sibling;
+        WSET (XWINDOW (w->parent), hchild, sibling);
     }
 
   /* Delete ROOT and all child windows of ROOT.  */
   if (!NILP (r->vchild))
     {
       delete_all_child_windows (r->vchild);
-      r->vchild = Qnil;
+      WSET (r, vchild, Qnil);
     }
   else if (!NILP (r->hchild))
     {
       delete_all_child_windows (r->hchild);
-      r->hchild = Qnil;
+      WSET (r, hchild, Qnil);
     }
 
   replace_window (root, window, 1);
@@ -2788,7 +2823,7 @@ window-start value is reasonable when this function is called.  */)
           pos = *vmotion (startpos, -top, w);
 
           set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
-          w->window_end_valid = Qnil;
+          WSET (w, window_end_valid, 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
@@ -2878,13 +2913,15 @@ adjust_window_margins (struct window *w)
   if (WINDOW_RIGHT_MARGIN_COLS (w) > 0)
     {
       if (WINDOW_LEFT_MARGIN_COLS (w) > 0)
-        w->left_margin_cols = w->right_margin_cols
-          = make_number (margin_cols/2);
+        {
+          WSET (w, left_margin_cols, make_number (margin_cols / 2));
+          WSET (w, right_margin_cols, make_number (margin_cols / 2));   
+        }
       else
-        w->right_margin_cols = make_number (margin_cols);
+        WSET (w, right_margin_cols, make_number (margin_cols));
     }
   else
-    w->left_margin_cols = make_number (margin_cols);
+    WSET (w, left_margin_cols, make_number (margin_cols));
   return 1;
 }
 
@@ -2984,23 +3021,23 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
   ptrdiff_t count = SPECPDL_INDEX ();
   int samebuf = EQ (buffer, w->buffer);
 
-  w->buffer = buffer;
+  WSET (w, buffer, buffer);
 
   if (EQ (window, selected_window))
-    BVAR (b, last_selected_window) = window;
+    BSET (b, last_selected_window, window);
 
   /* 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 (b, display_count, make_number (XINT (BVAR (b, display_count)) + 1));
+  BSET (b, display_time, Fcurrent_time ());
 
-  XSETFASTINT (w->window_end_pos, 0);
-  XSETFASTINT (w->window_end_vpos, 0);
+  WSET (w, window_end_pos, make_number (0));
+  WSET (w, window_end_vpos, make_number (0));
   memset (&w->last_cursor, 0, sizeof w->last_cursor);
-  w->window_end_valid = Qnil;
+  WSET (w, window_end_valid, 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
@@ -3045,7 +3082,8 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
       Lisp_Object save_left = w->left_margin_cols;
       Lisp_Object save_right = w->right_margin_cols;
 
-      w->left_margin_cols = w->right_margin_cols = Qnil;
+      WSET (w, left_margin_cols, Qnil);
+      WSET (w, right_margin_cols, Qnil);
 
       Fset_window_fringes (window,
                            BVAR (b, left_fringe_width), BVAR (b, right_fringe_width),
@@ -3055,8 +3093,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);
 
-      w->left_margin_cols = save_left;
-      w->right_margin_cols = save_right;
+      WSET (w, left_margin_cols, save_left);
+      WSET (w, right_margin_cols, save_right);
 
       Fset_window_margins (window,
                            BVAR (b, left_margin_cols), BVAR (b, right_margin_cols));
@@ -3075,7 +3113,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.
-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
@@ -3092,7 +3130,7 @@ 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 struct window *w = decode_window (window);
+  register struct window *w = decode_live_window (window);
 
   XSETWINDOW (window, w);
   buffer = Fget_buffer (buffer_or_name);
@@ -3115,7 +3153,7 @@ This function runs `window-scroll-functions' before running
           else
             /* WINDOW is weakly dedicated to its buffer, reset
                dedication.  */
-            w->dedicated = Qnil;
+            WSET (w, dedicated, Qnil);
 
           call1 (Qrecord_window_buffer, window);
         }
@@ -3185,7 +3223,7 @@ temp_output_buffer_show (register Lisp_Object buf)
   register Lisp_Object window;
   register struct window *w;
 
-  BVAR (XBUFFER (buf), directory) = BVAR (current_buffer, directory);
+  BSET (XBUFFER (buf), directory, BVAR (current_buffer, directory));
 
   Fset_buffer (buf);
   BUF_SAVE_MODIFF (XBUFFER (buf)) = MODIFF;
@@ -3254,24 +3292,24 @@ make_parent_window (Lisp_Object window, int horflag)
   p = allocate_window ();
   memcpy ((char *) p + sizeof (struct vectorlike_header),
           (char *) o + sizeof (struct vectorlike_header),
-          sizeof (Lisp_Object) * VECSIZE (struct window));
+          word_size * VECSIZE (struct window));
   XSETWINDOW (parent, p);
 
   p->sequence_number = ++sequence_number;
 
   replace_window (window, parent, 1);
 
-  o->next = Qnil;
-  o->prev = Qnil;
-  o->parent = parent;
+  WSET (o, next, Qnil);
+  WSET (o, prev, Qnil);
+  WSET (o, parent, parent);
 
-  p->hchild = horflag ? window : Qnil;
-  p->vchild = horflag ? Qnil : window;
-  p->start = Qnil;
-  p->pointm = Qnil;
-  p->buffer = Qnil;
-  p->combination_limit = Qnil;
-  p->window_parameters = Qnil;
+  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);
 }
 
 /* Make new window from scratch.  */
@@ -3284,19 +3322,19 @@ 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.  */
-  XSETFASTINT (w->left_col, 0);
-  XSETFASTINT (w->top_line, 0);
-  XSETFASTINT (w->total_lines, 0);
-  XSETFASTINT (w->total_cols, 0);
-  w->normal_lines = make_float (1.0);
-  w->normal_cols = make_float (1.0);
-  XSETFASTINT (w->new_total, 0);
-  XSETFASTINT (w->new_normal, 0);
-  w->start = Fmake_marker ();
-  w->pointm = Fmake_marker ();
-  w->vertical_scroll_bar_type = Qt;
-  XSETFASTINT (w->window_end_pos, 0);
-  XSETFASTINT (w->window_end_vpos, 0);
+  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));
 
   /* 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.  */
@@ -3314,6 +3352,7 @@ make_window (void)
 
 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
@@ -3322,28 +3361,26 @@ 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)
 {
-  struct window *w = decode_any_window (window);
+  struct window *w = decode_valid_window (window);
 
   CHECK_NUMBER (size);
   if (NILP (add))
-    XSETINT (w->new_total, XINT (size));
+    WSET (w, new_total, size);
   else
-    XSETINT (w->new_total, XINT (w->new_total) + XINT (size));
+    WSET (w, new_total, make_number (XINT (w->new_total) + XINT (size)));
 
   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.
+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)
 {
-  struct window *w = decode_any_window (window);
-
-  w->new_normal = size;
-  return w->new_normal;
+  return WSET (decode_valid_window (window), new_normal, size);
 }
 
 /* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
@@ -3444,17 +3481,17 @@ window_resize_apply (struct window *w, int horflag)
      parent window has been set *before*.  */
   if (horflag)
     {
-      w->total_cols = w->new_total;
+      WSET (w, total_cols, w->new_total);
       if (NUMBERP (w->new_normal))
-        w->normal_cols = w->new_normal;
+        WSET (w, normal_cols, w->new_normal);
 
       pos = XINT (w->left_col);
     }
   else
     {
-      w->total_lines = w->new_total;
+      WSET (w, total_lines, w->new_total);
       if (NUMBERP (w->new_normal))
-        w->normal_lines = w->new_normal;
+        WSET (w, normal_lines, w->new_normal);
 
       pos = XINT (w->top_line);
     }
@@ -3466,9 +3503,9 @@ window_resize_apply (struct window *w, int horflag)
       while (c)
         {
           if (horflag)
-            XSETFASTINT (c->left_col, pos);
+            WSET (c, left_col, make_number (pos));
           else
-            XSETFASTINT (c->top_line, pos);
+            WSET (c, top_line, make_number (pos));
           window_resize_apply (c, horflag);
           if (!horflag)
             pos = pos + XINT (c->total_lines);
@@ -3482,9 +3519,9 @@ window_resize_apply (struct window *w, int horflag)
       while (c)
         {
           if (horflag)
-            XSETFASTINT (c->left_col, pos);
+            WSET (c, left_col, make_number (pos));
           else
-            XSETFASTINT (c->top_line, pos);
+            WSET (c, top_line, make_number (pos));
           window_resize_apply (c, horflag);
           if (horflag)
             pos = pos + XINT (c->total_cols);
@@ -3524,7 +3561,8 @@ be applied on the Elisp level.  */)
   r = XWINDOW (FRAME_ROOT_WINDOW (f));
 
   if (!window_resize_check (r, horflag)
-      || ! EQ (r->new_total, (horflag ? r->total_cols : r->total_lines)))
+      || ! EQ (r->new_total,
+               (horflag ? r->total_cols : r->total_lines)))
     return Qnil;
 
   BLOCK_INPUT;
@@ -3564,23 +3602,25 @@ resize_frame_windows (struct frame *f, int size, int horflag)
                      - ((FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
                         ? 1 : 0)));
 
-  XSETFASTINT (r->top_line, FRAME_TOP_MARGIN (f));
+  WSET (r, top_line, make_number (FRAME_TOP_MARGIN (f)));
   if (NILP (r->vchild) && NILP (r->hchild))
     /* For a leaf root window just set the size.  */
     if (horflag)
-      XSETFASTINT (r->total_cols, new_size);
+      WSET (r, total_cols, make_number (new_size));
     else
-      XSETFASTINT (r->total_lines, new_size);
+      WSET (r, total_lines, make_number (new_size));
   else
     {
       /* old_size is the old size of the frame's root window.  */
-      int old_size = XFASTINT (horflag ? r->total_cols : 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) && new_size == XINT (r->new_total))
+      if (window_resize_check (r, horflag)
+          && new_size == XINT (r->new_total))
         window_resize_apply (r, horflag);
       else
         {
@@ -3603,9 +3643,9 @@ resize_frame_windows (struct frame *f, int size, int horflag)
                   root = f->selected_window;
                   Fdelete_other_windows_internal (root, Qnil);
                   if (horflag)
-                    XSETFASTINT (XWINDOW (root)->total_cols, new_size);
+                    WSET (XWINDOW (root), total_cols, make_number (new_size));
                   else
-                    XSETFASTINT (XWINDOW (root)->total_lines, new_size);
+                    WSET (XWINDOW (root), total_lines, make_number (new_size));
                 }
             }
         }
@@ -3615,12 +3655,13 @@ resize_frame_windows (struct frame *f, int size, int horflag)
     {
       m = XWINDOW (mini);
       if (horflag)
-        XSETFASTINT (m->total_cols, size);
+        WSET (m, total_cols, make_number (size));
       else
         {
           /* Are we sure we always want 1 line here?  */
-          XSETFASTINT (m->total_lines, 1);
-          XSETFASTINT (m->top_line, XINT (r->top_line) + XINT (r->total_lines));
+          WSET (m, total_lines, make_number (1));
+          WSET (m, top_line,
+                make_number (XINT (r->top_line) + XINT (r->total_lines)));
         }
     }
 }
@@ -3701,14 +3742,15 @@ set correctly.  See the code of `split-window' for how this is done.  */)
     {
       p = XWINDOW (o->parent);
       /* Temporarily pretend we split the parent window.  */
-      XSETINT (p->new_total,
-               XINT (horflag ? p->total_cols : p->total_lines)
-               - XINT (total_size));
+      WSET (p, new_total,
+            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.  */
-        p->new_total = horflag ? p->total_cols : p->total_lines;
+        WSET (p, new_total,
+              horflag ? p->total_cols : p->total_lines);
     }
   else
     {
@@ -3725,16 +3767,17 @@ set correctly.  See the code of `split-window' for how this is done.  */)
       /* Save the old value of o->normal_cols/lines.  It gets corrupted
          by make_parent_window and we need it below for assigning it to
          p->new_normal.  */
-      Lisp_Object new_normal = horflag ? o->normal_cols : o->normal_lines;
+      Lisp_Object new_normal
+        = horflag ? o->normal_cols : o->normal_lines;
 
       make_parent_window (old, horflag);
       p = XWINDOW (o->parent);
       /* Store value of `window-combination-limit' in new parent's
          combination_limit slot.  */
-      p->combination_limit = Vwindow_combination_limit;
+      WSET (p, combination_limit, Vwindow_combination_limit);
       /* These get applied below.  */
-      p->new_total = horflag ? o->total_cols : o->total_lines;
-      p->new_normal = new_normal;
+      WSET (p, new_total, horflag ? o->total_cols : o->total_lines);
+      WSET (p, new_normal, new_normal);
     }
   else
     p = XWINDOW (o->parent);
@@ -3743,61 +3786,62 @@ set correctly.  See the code of `split-window' for how this is done.  */)
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
   new = make_window ();
   n = XWINDOW (new);
-  n->frame = frame;
-  n->parent = o->parent;
-  n->vchild = n->hchild = Qnil;
+  WSET (n, frame, frame);
+  WSET (n, parent, o->parent);
+  WSET (n, vchild, Qnil);
+  WSET (n, hchild, Qnil);
 
   if (EQ (side, Qabove) || EQ (side, Qleft))
     {
-      n->prev = o->prev;
+      WSET (n, prev, o->prev);
       if (NILP (n->prev))
         if (horflag)
-          p->hchild = new;
+          WSET (p, hchild, new);
         else
-          p->vchild = new;
+          WSET (p, vchild, new);
       else
-        XWINDOW (n->prev)->next = new;
-      n->next = old;
-      o->prev = new;
+        WSET (XWINDOW (n->prev), next, new);
+      WSET (n, next, old);
+      WSET (o, prev, new);
     }
   else
     {
-      n->next = o->next;
+      WSET (n, next, o->next);
       if (!NILP (n->next))
-        XWINDOW (n->next)->prev = new;
-      n->prev = old;
-      o->next = new;
+        WSET (XWINDOW (n->next), prev, new);
+      WSET (n, prev, old);
+      WSET (o, next, new);
     }
 
-  n->buffer = Qt;
-  n->window_end_valid = Qnil;
+  WSET (n, buffer, Qt);
+  WSET (n, window_end_valid, Qnil);
   memset (&n->last_cursor, 0, sizeof n->last_cursor);
 
   /* Get special geometry settings from reference window.  */
-  n->left_margin_cols = r->left_margin_cols;
-  n->right_margin_cols = r->right_margin_cols;
-  n->left_fringe_width = r->left_fringe_width;
-  n->right_fringe_width = r->right_fringe_width;
+  WSET (n, left_margin_cols, r->left_margin_cols);
+  WSET (n, right_margin_cols, r->right_margin_cols);
+  WSET (n, left_fringe_width, r->left_fringe_width);
+  WSET (n, right_fringe_width, r->right_fringe_width);
   n->fringes_outside_margins = r->fringes_outside_margins;
-  n->scroll_bar_width = r->scroll_bar_width;
-  n->vertical_scroll_bar_type = r->vertical_scroll_bar_type;
+  WSET (n, scroll_bar_width, r->scroll_bar_width);
+  WSET (n, vertical_scroll_bar_type, r->vertical_scroll_bar_type);
 
   /* Directly assign orthogonal coordinates and sizes.  */
   if (horflag)
     {
-      n->top_line = o->top_line;
-      n->total_lines = o->total_lines;
+      WSET (n, top_line, o->top_line);
+      WSET (n, total_lines, o->total_lines);
     }
   else
     {
-      n->left_col = o->left_col;
-      n->total_cols = o->total_cols;
+      WSET (n, left_col, o->left_col);
+      WSET (n, total_cols, o->total_cols);
     }
 
   /* Iso-coordinates and sizes are assigned by window_resize_apply,
      get them ready here.  */
-  n->new_total = total_size;
-  n->new_normal = normal_size;
+  WSET (n, new_total, total_size);
+  WSET (n, new_normal, normal_size);
 
   BLOCK_INPUT;
   window_resize_apply (p, horflag);
@@ -3831,7 +3875,8 @@ Signal an error when WINDOW is the only window on its frame.  */)
 
   w = decode_any_window (window);
   XSETWINDOW (window, w);
-  if (NILP (w->buffer) && NILP (w->hchild) && NILP (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;
 
@@ -3862,24 +3907,25 @@ Signal an error when WINDOW is the only window on its frame.  */)
       before_sibling = 1;
       sibling = w->next;
       s = XWINDOW (sibling);
-      s->prev = Qnil;
+      WSET (s, prev, Qnil);
       if (horflag)
-        p->hchild = sibling;
+        WSET (p, hchild, sibling);
       else
-        p->vchild = sibling;
+        WSET (p, vchild, sibling);
     }
   else
     /* Get SIBLING above (on the left of) WINDOW.  */
     {
       sibling = w->prev;
       s = XWINDOW (sibling);
-      s->next = w->next;
+      WSET (s, next, w->next);
       if (!NILP (s->next))
-        XWINDOW (s->next)->prev = sibling;
+        WSET (XWINDOW (s->next), prev, sibling);
     }
 
   if (window_resize_check (r, horflag)
-      && EQ (r->new_total, (horflag ? r->total_cols : r->total_lines)))
+      && EQ (r->new_total,
+             (horflag ? r->total_cols : r->total_lines)))
     /* We can delete WINDOW now.  */
     {
 
@@ -3901,25 +3947,25 @@ Signal an error when WINDOW is the only window on its frame.  */)
       Vwindow_list = Qnil;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
-      w->next = Qnil;  /* Don't delete w->next too.  */
+      WSET (w, next, Qnil);  /* Don't delete w->next too.  */
       free_window_matrices (w);
 
       if (!NILP (w->vchild))
         {
           delete_all_child_windows (w->vchild);
-          w->vchild = Qnil;
+          WSET (w, vchild, Qnil);
         }
       else if (!NILP (w->hchild))
         {
           delete_all_child_windows (w->hchild);
-          w->hchild = Qnil;
+          WSET (w, hchild, Qnil);
         }
       else if (!NILP (w->buffer))
         {
           unshow_buffer (w);
           unchain_marker (XMARKER (w->pointm));
           unchain_marker (XMARKER (w->start));
-          w->buffer = Qnil;
+          WSET (w, buffer, Qnil);
         }
 
       if (NILP (s->prev) && NILP (s->next))
@@ -3930,10 +3976,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).  */
-          s->normal_cols = p->normal_cols;
-          s->normal_lines = p->normal_lines;
+          WSET (s, normal_cols, p->normal_cols);
+          WSET (s, normal_lines, p->normal_lines);
           /* Mark PARENT as deleted.  */
-          p->vchild = p->hchild = Qnil;
+          WSET (p, vchild, Qnil);
+          WSET (p, hchild, Qnil);
           /* Try to merge SIBLING into its new parent.  */
           recombine_windows (sibling);
         }
@@ -3953,7 +4000,7 @@ 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
-            FRAME_SELECTED_WINDOW (f) = new_selected_window;
+            FSET (f, selected_window, new_selected_window);
 
           UNBLOCK_INPUT;
 
@@ -3967,7 +4014,7 @@ 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, Qnil);
           else
-            FRAME_SELECTED_WINDOW (f) = new_selected_window;
+            FSET (f, selected_window, new_selected_window);
         }
       else
         UNBLOCK_INPUT;
@@ -3980,17 +4027,17 @@ Signal an error when WINDOW is the only window on its frame.  */)
     {
       if (before_sibling)
         {
-          s->prev = window;
+          WSET (s, prev, window);
           if (horflag)
-            p->hchild = window;
+            WSET (p, hchild, window);
           else
-            p->vchild = window;
+            WSET (p, vchild, window);
         }
       else
         {
-          s->next = window;
+          WSET (s, next, window);
           if (!NILP (w->next))
-            XWINDOW (w->next)->prev = window;
+            WSET (XWINDOW (w->next), prev, window);
         }
       error ("Deletion failed");
     }
@@ -4024,8 +4071,10 @@ grow_mini_window (struct window *w, int delta)
       window_resize_apply (r, 0);
 
       /* Grow the mini-window.  */
-      XSETFASTINT (w->top_line, XFASTINT (r->top_line) + XFASTINT (r->total_lines));
-      XSETFASTINT (w->total_lines, XFASTINT (w->total_lines) - XINT (value));
+      WSET (w, top_line,
+            make_number (XFASTINT (r->top_line) + XFASTINT (r->total_lines)));
+      WSET (w, total_lines,
+            make_number (XFASTINT (w->total_lines) - XINT (value)));
       w->last_modified = 0;
       w->last_overlay_modified = 0;
 
@@ -4059,8 +4108,9 @@ shrink_mini_window (struct window *w)
           window_resize_apply (r, 0);
 
           /* Shrink the mini-window.  */
-          XSETFASTINT (w->top_line, XFASTINT (r->top_line) + XFASTINT (r->total_lines));
-          XSETFASTINT (w->total_lines, 1);
+          WSET (w, top_line,
+                make_number (XFASTINT (r->top_line) + XFASTINT (r->total_lines)));
+          WSET (w, total_lines, make_number (1));
 
           w->last_modified = 0;
           w->last_overlay_modified = 0;
@@ -4101,8 +4151,9 @@ DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini
       BLOCK_INPUT;
       window_resize_apply (r, 0);
 
-      w->total_lines = w->new_total;
-      XSETFASTINT (w->top_line, XINT (r->top_line) + XINT (r->total_lines));
+      WSET (w, total_lines, w->new_total);
+      WSET (w, top_line,
+            make_number (XINT (r->top_line) + XINT (r->total_lines)));
 
       windows_or_buffers_changed++;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
@@ -4451,7 +4502,8 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
      This code wants current_y to be zero at the window start position
      even if there is a header line.  */
   this_scroll_margin = max (0, scroll_margin);
-  this_scroll_margin = min (this_scroll_margin, XFASTINT (w->total_lines) / 4);
+  this_scroll_margin
+    = min (this_scroll_margin, XFASTINT (w->total_lines) / 4);
   this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
 
   if (n > 0)
@@ -5169,7 +5221,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
 
   /* Set the new window start.  */
   set_marker_both (w->start, w->buffer, charpos, bytepos);
-  w->window_end_valid = Qnil;
+  WSET (w, window_end_valid, Qnil);
 
   w->optional_new_start = 1;
 
@@ -5183,13 +5235,13 @@ 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.
-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)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   int pixel_height = window_box_height (w);
   int line_height = pixel_height / FRAME_LINE_HEIGHT (XFRAME (w->frame));
   return make_number (line_height);
@@ -5487,34 +5539,34 @@ the return value is nil.  Otherwise the value is t.  */)
           p = SAVED_WINDOW_N (saved_windows, k);
           window = p->window;
           w = XWINDOW (window);
-          w->next = Qnil;
+          WSET (w, next, Qnil);
 
           if (!NILP (p->parent))
-            w->parent = SAVED_WINDOW_N (saved_windows,
-                                        XFASTINT (p->parent))->window;
+            WSET (w, parent, SAVED_WINDOW_N 
+                  (saved_windows, XFASTINT (p->parent))->window);
           else
-            w->parent = Qnil;
+            WSET (w, parent, Qnil);
 
           if (!NILP (p->prev))
             {
-              w->prev = SAVED_WINDOW_N (saved_windows,
-                                        XFASTINT (p->prev))->window;
-              XWINDOW (w->prev)->next = p->window;
+              WSET (w, prev, SAVED_WINDOW_N
+                    (saved_windows, XFASTINT (p->prev))->window);
+              WSET (XWINDOW (w->prev), next, p->window);
             }
           else
             {
-              w->prev = Qnil;
+              WSET (w, prev, Qnil);
               if (!NILP (w->parent))
                 {
                   if (EQ (p->total_cols, XWINDOW (w->parent)->total_cols))
                     {
-                      XWINDOW (w->parent)->vchild = p->window;
-                      XWINDOW (w->parent)->hchild = Qnil;
+                      WSET (XWINDOW (w->parent), vchild, p->window);
+                      WSET (XWINDOW (w->parent), hchild, Qnil);
                     }
                   else
                     {
-                      XWINDOW (w->parent)->hchild = p->window;
-                      XWINDOW (w->parent)->vchild = Qnil;
+                      WSET (XWINDOW (w->parent), hchild, p->window);
+                      WSET (XWINDOW (w->parent), vchild, Qnil);
                     }
                 }
             }
@@ -5522,25 +5574,25 @@ the return value is nil.  Otherwise the value is t.  */)
           /* If we squirreled away the buffer in the window's height,
              restore it now.  */
           if (BUFFERP (w->total_lines))
-            w->buffer = w->total_lines;
-          w->left_col = p->left_col;
-          w->top_line = p->top_line;
-          w->total_cols = p->total_cols;
-          w->total_lines = p->total_lines;
-          w->normal_cols = p->normal_cols;
-          w->normal_lines = p->normal_lines;
+            WSET (w, buffer, 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);
           w->hscroll = XFASTINT (p->hscroll);
           w->min_hscroll = XFASTINT (p->min_hscroll);
-          w->display_table = p->display_table;
-          w->left_margin_cols = p->left_margin_cols;
-          w->right_margin_cols = p->right_margin_cols;
-          w->left_fringe_width = p->left_fringe_width;
-          w->right_fringe_width = p->right_fringe_width;
+          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);
           w->fringes_outside_margins = !NILP (p->fringes_outside_margins);
-          w->scroll_bar_width = p->scroll_bar_width;
-          w->vertical_scroll_bar_type = p->vertical_scroll_bar_type;
-          w->dedicated = p->dedicated;
-          w->combination_limit = p->combination_limit;
+          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);
           /* 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))
@@ -5569,45 +5621,50 @@ 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.  */
-            w->buffer = p->buffer;
+            WSET (w, buffer, p->buffer);
           else if (!NILP (BVAR (XBUFFER (p->buffer), name)))
             /* If saved buffer is alive, install it.  */
             {
-              w->buffer = 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 (w->buffer) && !NILP (BVAR (XBUFFER (w->buffer), name)))
-            /* Keep window's old buffer; make sure the markers are
-               real.  */
-            {
-              /* Set window markers at start of visible range.  */
-              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;
-            }
-          else if (STRINGP (auto_buffer_name =
-                            Fwindow_parameter (window, Qauto_buffer_name))
-                   && SCHARS (auto_buffer_name) != 0
-                   && !NILP (w->buffer = Fget_buffer_create (auto_buffer_name)))
+              WSET (w, buffer, 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 (w->buffer)
+                    && !NILP (BVAR (XBUFFER (w->buffer), name)))
+             /* Keep window's old buffer; make sure the markers are
+                real.  */
+             {
+               /* Set window markers at start of visible range.  */
+               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;
+             }
+           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 (w->start, make_number (0), w->buffer);
-              set_marker_restricted (w->pointm, make_number (0), 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;
             }
           else
@@ -5617,21 +5674,23 @@ 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).  */
-              w->buffer = other_buffer_safely (Fcurrent_buffer ());
+              WSET (w, buffer, other_buffer_safely (Fcurrent_buffer ()));
               /* This will set the markers to beginning of visible
                  range.  */
-              set_marker_restricted (w->start, make_number (0), w->buffer);
-              set_marker_restricted (w->pointm, make_number (0), 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;
               if (!NILP (w->dedicated))
                 /* Record this window as dead.  */
                 dead_windows = Fcons (window, dead_windows);
               /* Make sure window is no more dedicated.  */
-              w->dedicated = Qnil;
+              WSET (w, dedicated, Qnil);
             }
         }
 
-      FRAME_ROOT_WINDOW (f) = data->root_window;
+      FSET (f, root_window, data->root_window);
       /* Arrange *not* to restore point in the buffer that was
          current when the window configuration was saved.  */
       if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer))
@@ -5727,24 +5786,24 @@ delete_all_child_windows (Lisp_Object window)
     /* Delete WINDOW's siblings (we traverse postorderly).  */
     delete_all_child_windows (w->next);
 
-  w->total_lines = w->buffer;       /* See Fset_window_configuration for excuse.  */
+  WSET (w, total_lines, w->buffer);       /* See Fset_window_configuration for excuse.  */
 
   if (!NILP (w->vchild))
     {
       delete_all_child_windows (w->vchild);
-      w->vchild = Qnil;
+      WSET (w, vchild, Qnil);
     }
   else if (!NILP (w->hchild))
     {
       delete_all_child_windows (w->hchild);
-      w->hchild = Qnil;
+      WSET (w, hchild, Qnil);
     }
   else if (!NILP (w->buffer))
     {
       unshow_buffer (w);
       unchain_marker (XMARKER (w->pointm));
       unchain_marker (XMARKER (w->start));
-      w->buffer = Qnil;
+      WSET (w, buffer, Qnil);
     }
 
   Vwindow_list = Qnil;
@@ -5836,7 +5895,7 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
       p = SAVED_WINDOW_N (vector, i);
       w = XWINDOW (window);
 
-      XSETFASTINT (w->temslot, i); i++;
+      WSET (w, temslot, make_number (i)); i++;
       p->window = window;
       p->buffer = w->buffer;
       p->left_col = w->left_col;
@@ -6009,14 +6068,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.
-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)
 {
-  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.  */
@@ -6038,8 +6098,8 @@ means no margin.  */)
   if (!EQ (w->left_margin_cols, left_width)
       || !EQ (w->right_margin_cols, right_width))
     {
-      w->left_margin_cols = left_width;
-      w->right_margin_cols = right_width;
+      WSET (w, left_margin_cols, left_width);
+      WSET (w, right_margin_cols, right_width);
 
       adjust_window_margins (w);
 
@@ -6054,13 +6114,14 @@ means no margin.  */)
 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)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   return Fcons (w->left_margin_cols, w->right_margin_cols);
 }
 
@@ -6073,8 +6134,8 @@ as nil.  */)
 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
@@ -6085,7 +6146,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)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
   int outside = !NILP (outside_margins);
 
   if (!NILP (left_width))
@@ -6099,14 +6160,14 @@ display marginal areas and the text area.  */)
           || !EQ (w->right_fringe_width, right_width)
           || w->fringes_outside_margins != outside))
     {
-      w->left_fringe_width = left_width;
-      w->right_fringe_width = right_width;
+      WSET (w, left_fringe_width, left_width);
+      WSET (w, right_fringe_width, right_width);
       w->fringes_outside_margins = outside;
 
       adjust_window_margins (w);
 
       clear_glyph_matrix (w->current_matrix);
-      w->window_end_valid = Qnil;
+      WSET (w, window_end_valid, Qnil);
 
       ++windows_or_buffers_changed;
       adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
@@ -6119,11 +6180,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.
-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)
 {
-  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)),
@@ -6140,7 +6202,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.
-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
@@ -6150,7 +6213,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)
 {
-  struct window *w = decode_window (window);
+  struct window *w = decode_live_window (window);
 
   if (!NILP (width))
     {
@@ -6169,13 +6232,13 @@ Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
   if (!EQ (w->scroll_bar_width, width)
       || !EQ (w->vertical_scroll_bar_type, vertical_type))
     {
-      w->scroll_bar_width = width;
-      w->vertical_scroll_bar_type = vertical_type;
+      WSET (w, scroll_bar_width, width);
+      WSET (w, vertical_scroll_bar_type, vertical_type);
 
       adjust_window_margins (w);
 
       clear_glyph_matrix (w->current_matrix);
-      w->window_end_valid = Qnil;
+      WSET (w, window_end_valid, Qnil);
 
       ++windows_or_buffers_changed;
       adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
@@ -6188,13 +6251,14 @@ 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.
-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)
 {
-  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))),
@@ -6488,6 +6552,7 @@ syms_of_window (void)
   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");
@@ -6640,6 +6705,7 @@ respectively are not installed by `window-state-put'.  */);
   defsubr (&Sminibuffer_window);
   defsubr (&Swindow_minibuffer_p);
   defsubr (&Swindowp);
+  defsubr (&Swindow_valid_p);
   defsubr (&Swindow_live_p);
   defsubr (&Swindow_frame);
   defsubr (&Sframe_root_window);