upstream

1 files changed, 105 insertions, 142 deletions

diff --git a/src/window.c b/src/window.c
index f1b19390cd0..03d08da042d 100644
--- a/src/window.c
+++ b/src/window.c
@@ -146,11 +146,16 @@ 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);
+  /* The following test throws up every time a tooltip frame is displayed.  */
+  /* CHECK_LIVE_FRAME (w->frame); */
+  return w;
 }
 
 DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
@@ -333,8 +338,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
 
   if (NILP (norecord))
     {
-      ++window_select_count;
-      XSETFASTINT (w->use_time, window_select_count);
+      w->use_time = ++window_select_count;
       record_buffer (w->buffer);
     }
 
@@ -487,9 +491,7 @@ 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;
 }
 
@@ -501,7 +503,7 @@ one.  The window with the lowest use time is the least recently
 selected one.  */)
   (Lisp_Object window)
 {
-  return decode_window (window)->use_time;
+  return make_number (decode_window (window)->use_time);
 }
 
 DEFUN ("window-total-height", Fwindow_total_height, Swindow_total_height, 0, 1, 0,
@@ -670,30 +672,45 @@ 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 decode_window (window)->hscroll;
+  return make_number (decode_window (window)->hscroll);
+}
+
+/* Set W's horizontal scroll amount to HSCROLL clipped to a reasonable
+   range, returning the new amount as a fixnum.  */
+static Lisp_Object
+set_window_hscroll (struct window *w, EMACS_INT hscroll)
+{
+  /* Horizontal scrolling has problems with large scroll amounts.
+     It's too slow with long lines, and even with small lines the
+     display can be messed up.  For now, though, impose only the limits
+     required by the internal representation: horizontal scrolling must
+     fit in fixnum (since it's visible to Elisp) and into ptrdiff_t
+     (since it's stored in a ptrdiff_t).  */
+  ptrdiff_t hscroll_max = min (MOST_POSITIVE_FIXNUM, PTRDIFF_MAX);
+  ptrdiff_t new_hscroll = clip_to_bounds (0, hscroll, hscroll_max);
+
+  /* Prevent redisplay shortcuts when changing the hscroll.  */
+  if (w->hscroll != new_hscroll)
+    XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
+
+  w->hscroll = new_hscroll;
+  return make_number (new_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.
-Return NCOL.  NCOL should be zero or positive.
+Clip the number to a reasonable value if out of range.
+Return the new number.  NCOL should be zero or positive.
 
 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);
-  ptrdiff_t hscroll;
 
   CHECK_NUMBER (ncol);
-  hscroll = clip_to_bounds (0, XINT (ncol), PTRDIFF_MAX);
-
-  /* Prevent redisplay shortcuts when changing the hscroll.  */
-  if (XINT (w->hscroll) != hscroll)
-    XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
-
-  w->hscroll = make_number (hscroll);
-  return ncol;
+  return set_window_hscroll (w, XINT (ncol));
 }
 
 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
@@ -1316,8 +1333,8 @@ if it isn't already recorded.  */)
 
   if (! NILP (update)
       && ! (! NILP (w->window_end_valid)
-            && XFASTINT (w->last_modified) >= BUF_MODIFF (b)
-            && XFASTINT (w->last_overlay_modified) >= BUF_OVERLAY_MODIFF (b))
+            && w->last_modified >= BUF_MODIFF (b)
+            && w->last_overlay_modified >= BUF_OVERLAY_MODIFF (b))
       && !noninteractive)
     {
       struct text_pos startp;
@@ -1400,8 +1417,8 @@ overriding motion of point in order to display at this exact start.  */)
   if (NILP (noforce))
     w->force_start = 1;
   w->update_mode_line = 1;
-  XSETFASTINT (w->last_modified, 0);
-  XSETFASTINT (w->last_overlay_modified, 0);
+  w->last_modified = 0;
+  w->last_overlay_modified = 0;
   if (!EQ (window, selected_window))
     windows_or_buffers_changed++;
 
@@ -1513,8 +1530,8 @@ Return nil if window display is not up-to-date.  In that case, use
   if (NILP (w->window_end_valid)
       || current_buffer->clip_changed
       || current_buffer->prevent_redisplay_optimizations_p
-      || XFASTINT (w->last_modified) < BUF_MODIFF (b)
-      || XFASTINT (w->last_overlay_modified) < BUF_OVERLAY_MODIFF (b))
+      || w->last_modified < BUF_MODIFF (b)
+      || w->last_overlay_modified < BUF_OVERLAY_MODIFF (b))
     return Qnil;
 
   if (NILP (line))
@@ -2037,7 +2054,7 @@ candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf
     candidate_p = 1;
   else if (NILP (all_frames))
     {
-      xassert (WINDOWP (owindow));
+      eassert (WINDOWP (owindow));
       candidate_p = EQ (w->frame, XWINDOW (owindow)->frame);
     }
   else if (EQ (all_frames, Qvisible))
@@ -2876,13 +2893,6 @@ adjust_window_margins (struct window *w)
   return 1;
 }
 
-static Lisp_Object Fset_window_margins (Lisp_Object, Lisp_Object, Lisp_Object);
-static Lisp_Object Fset_window_fringes (Lisp_Object, Lisp_Object, Lisp_Object,
-                                        Lisp_Object);
-static Lisp_Object Fset_window_scroll_bars (Lisp_Object, Lisp_Object,
-                                            Lisp_Object, Lisp_Object);
-static Lisp_Object Fset_window_vscroll (Lisp_Object, Lisp_Object, Lisp_Object);
-
 /* The following three routines are needed for running a window's
    configuration change hook.  */
 static void
@@ -3005,7 +3015,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
          Resetting hscroll and vscroll here is problematic for things like
          image-mode and doc-view-mode since it resets the image's position
          whenever we resize the frame.  */
-      w->hscroll = w->min_hscroll = make_number (0);
+      w->hscroll = w->min_hscroll = 0;
       w->vscroll = 0;
       set_marker_both (w->pointm, buffer, BUF_PT (b), BUF_PT_BYTE (b));
       set_marker_restricted (w->start,
@@ -3013,8 +3023,8 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
                              buffer);
       w->start_at_line_beg = 0;
       w->force_start = 0;
-      XSETFASTINT (w->last_modified, 0);
-      XSETFASTINT (w->last_overlay_modified, 0);
+      w->last_modified = 0;
+      w->last_overlay_modified = 0;
     }
   /* Maybe we could move this into the `if' but it's not obviously safe and
      I doubt it's worth the trouble.  */
@@ -3199,8 +3209,8 @@ temp_output_buffer_show (register Lisp_Object buf)
         Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window)));
       Vminibuf_scroll_window = window;
       w = XWINDOW (window);
-      XSETFASTINT (w->hscroll, 0);
-      XSETFASTINT (w->min_hscroll, 0);
+      w->hscroll = 0;
+      w->min_hscroll = 0;
       set_marker_restricted_both (w->start, buf, BEG, BEG);
       set_marker_restricted_both (w->pointm, buf, BEG, BEG);
 
@@ -3244,17 +3254,15 @@ make_parent_window (Lisp_Object window, int horflag)
 {
   Lisp_Object parent;
   register struct window *o, *p;
-  int i;
 
   o = XWINDOW (window);
   p = allocate_window ();
-  for (i = 0; i < VECSIZE (struct window); ++i)
-    ((struct Lisp_Vector *) p)->contents[i]
-      = ((struct Lisp_Vector *) o)->contents[i];
+  memcpy ((char *) p + sizeof (struct vectorlike_header),
+          (char *) o + sizeof (struct vectorlike_header),
+          sizeof (Lisp_Object) * VECSIZE (struct window));
   XSETWINDOW (parent, p);
 
-  ++sequence_number;
-  XSETFASTINT (p->sequence_number, sequence_number);
+  p->sequence_number = ++sequence_number;
 
   replace_window (window, parent, 1);
 
@@ -3279,10 +3287,8 @@ make_window (void)
   register struct window *w;
 
   w = allocate_window ();
-  /* Initialize all Lisp data.  */
-  w->frame = Qnil;
-  w->mini = 0;
-  w->next = w->prev = w->hchild = w->vchild = w->parent = Qnil;
+  /* 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);
@@ -3291,47 +3297,19 @@ make_window (void)
   w->normal_cols = make_float (1.0);
   XSETFASTINT (w->new_total, 0);
   XSETFASTINT (w->new_normal, 0);
-  w->buffer = Qnil;
   w->start = Fmake_marker ();
   w->pointm = Fmake_marker ();
-  w->force_start = w->optional_new_start = 0;
-  XSETFASTINT (w->hscroll, 0);
-  XSETFASTINT (w->min_hscroll, 0);
-  XSETFASTINT (w->use_time, 0);
-  ++sequence_number;
-  XSETFASTINT (w->sequence_number, sequence_number);
-  w->temslot = w->last_modified = w->last_overlay_modified = Qnil;
-  XSETFASTINT (w->last_point, 0);
-  w->last_had_star = 0;
-  w->vertical_scroll_bar = Qnil;
-  w->left_margin_cols = w->right_margin_cols = Qnil;
-  w->left_fringe_width = w->right_fringe_width = Qnil;
-  w->fringes_outside_margins = Qnil;
-  w->scroll_bar_width = Qnil;
   w->vertical_scroll_bar_type = Qt;
   XSETFASTINT (w->window_end_pos, 0);
   XSETFASTINT (w->window_end_vpos, 0);
-  w->window_end_valid = w->display_table = Qnil;
-  w->update_mode_line = w->start_at_line_beg = 0;
-  w->dedicated = Qnil;
-  w->base_line_number = w->base_line_pos = w->region_showing = Qnil;
-  w->column_number_displayed = w->redisplay_end_trigger = Qnil;
-  w->combination_limit = w->window_parameters = Qnil;
-  w->prev_buffers = w->next_buffers = Qnil;
-  /* Initialize non-Lisp data.  */
-  w->desired_matrix = w->current_matrix = 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.  */
   w->nrows_scale_factor = w->ncols_scale_factor = 1;
-  memset (&w->cursor, 0, sizeof (w->cursor));
-  memset (&w->last_cursor, 0, sizeof (w->last_cursor));
-  memset (&w->phys_cursor, 0, sizeof (w->phys_cursor));
   w->phys_cursor_type = -1;
   w->phys_cursor_width = -1;
-  w->phys_cursor_on_p = 0;
-  w->last_cursor_off_p = w->cursor_off_p = 0;
-  w->must_be_updated_p = 0;
-  w->pseudo_window_p = 0;
-  w->frozen_window_start_p = 0;
-  w->vscroll = 0;
+  w->sequence_number = ++sequence_number;
+
   /* Reset window_list.  */
   Vwindow_list = Qnil;
   /* Return window.  */
@@ -3520,8 +3498,8 @@ window_resize_apply (struct window *w, int horflag)
     }
 
   /* Clear out some redisplay caches.  */
-  XSETFASTINT (w->last_modified, 0);
-  XSETFASTINT (w->last_overlay_modified, 0);
+  w->last_modified = 0;
+  w->last_overlay_modified = 0;
 }
 
 
@@ -4041,8 +4019,8 @@ grow_mini_window (struct window *w, int delta)
   struct window *r;
   Lisp_Object root, value;
 
-  xassert (MINI_WINDOW_P (w));
-  xassert (delta >= 0);
+  eassert (MINI_WINDOW_P (w));
+  eassert (delta >= 0);
 
   root = FRAME_ROOT_WINDOW (f);
   r = XWINDOW (root);
@@ -4056,8 +4034,8 @@ grow_mini_window (struct window *w, int delta)
       /* 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));
-      XSETFASTINT (w->last_modified, 0);
-      XSETFASTINT (w->last_overlay_modified, 0);
+      w->last_modified = 0;
+      w->last_overlay_modified = 0;
 
       adjust_glyphs (f);
       UNBLOCK_INPUT;
@@ -4074,7 +4052,7 @@ shrink_mini_window (struct window *w)
   Lisp_Object root, value;
   EMACS_INT size;
 
-  xassert (MINI_WINDOW_P (w));
+  eassert (MINI_WINDOW_P (w));
 
   size = XINT (w->total_lines);
   if (size > 1)
@@ -4092,8 +4070,8 @@ shrink_mini_window (struct window *w)
           XSETFASTINT (w->top_line, XFASTINT (r->top_line) + XFASTINT (r->total_lines));
           XSETFASTINT (w->total_lines, 1);
 
-          XSETFASTINT (w->last_modified, 0);
-          XSETFASTINT (w->last_overlay_modified, 0);
+          w->last_modified = 0;
+          w->last_overlay_modified = 0;
 
           adjust_glyphs (f);
           UNBLOCK_INPUT;
@@ -4320,8 +4298,8 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
                                          w->buffer);
                   w->start_at_line_beg = 1;
                   w->update_mode_line = 1;
-                  XSETFASTINT (w->last_modified, 0);
-                  XSETFASTINT (w->last_overlay_modified, 0);
+                  w->last_modified = 0;
+                  w->last_overlay_modified = 0;
                   /* Set force_start so that redisplay_window will run the
                      window-scroll-functions.  */
                   w->force_start = 1;
@@ -4466,8 +4444,8 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
       bytepos = XMARKER (w->start)->bytepos;
       w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
       w->update_mode_line = 1;
-      XSETFASTINT (w->last_modified, 0);
-      XSETFASTINT (w->last_overlay_modified, 0);
+      w->last_modified = 0;
+      w->last_overlay_modified = 0;
       /* Set force_start so that redisplay_window will run the
          window-scroll-functions.  */
       w->force_start = 1;
@@ -4620,10 +4598,10 @@ window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
           struct position posit
             = *compute_motion (startpos, 0, 0, 0,
                                PT, ht, 0,
-                               -1, XINT (w->hscroll),
+                               -1, w->hscroll,
                                0, w);
           window_scroll_preserve_vpos = posit.vpos;
-          window_scroll_preserve_hpos = posit.hpos + XINT (w->hscroll);
+          window_scroll_preserve_hpos = posit.hpos + w->hscroll;
         }
 
       original_pos = Fcons (make_number (window_scroll_preserve_hpos),
@@ -4665,8 +4643,8 @@ window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
       set_marker_restricted_both (w->start, w->buffer, pos, pos_byte);
       w->start_at_line_beg = !NILP (bolp);
       w->update_mode_line = 1;
-      XSETFASTINT (w->last_modified, 0);
-      XSETFASTINT (w->last_overlay_modified, 0);
+      w->last_modified = 0;
+      w->last_overlay_modified = 0;
       /* Set force_start so that redisplay_window will run
          the window-scroll-functions.  */
       w->force_start = 1;
@@ -4752,7 +4730,7 @@ scroll_command (Lisp_Object n, int direction)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
 
-  xassert (eabs (direction) == 1);
+  eassert (eabs (direction) == 1);
 
   /* If selected window's buffer isn't current, make it current for
      the moment.  But don't screw up if window_scroll gets an error.  */
@@ -4884,7 +4862,7 @@ specifies the window to scroll.  This takes precedence over
   else
     {
       if (CONSP (arg))
-        arg = Fcar (arg);
+        arg = XCAR (arg);
       CHECK_NUMBER (arg);
       window_scroll (window, XINT (arg), 0, 1);
     }
@@ -4906,17 +4884,11 @@ will not scroll a window to a column less than the value returned
 by this function.  This happens in an interactive call.  */)
   (register Lisp_Object arg, Lisp_Object set_minimum)
 {
-  Lisp_Object result;
-  EMACS_INT hscroll;
   struct window *w = XWINDOW (selected_window);
-
-  if (NILP (arg))
-    XSETFASTINT (arg, window_body_cols (w) - 2);
-  else
-    arg = Fprefix_numeric_value (arg);
-
-  hscroll = XINT (w->hscroll) + XINT (arg);
-  result = Fset_window_hscroll (selected_window, make_number (hscroll));
+  EMACS_INT requested_arg = (NILP (arg)
+                             ? window_body_cols (w) - 2
+                             : XINT (Fprefix_numeric_value (arg)));
+  Lisp_Object result = set_window_hscroll (w, w->hscroll + requested_arg);
 
   if (!NILP (set_minimum))
     w->min_hscroll = w->hscroll;
@@ -4935,17 +4907,11 @@ will not scroll a window to a column less than the value returned
 by this function.  This happens in an interactive call.  */)
   (register Lisp_Object arg, Lisp_Object set_minimum)
 {
-  Lisp_Object result;
-  EMACS_INT hscroll;
   struct window *w = XWINDOW (selected_window);
-
-  if (NILP (arg))
-    XSETFASTINT (arg, window_body_cols (w) - 2);
-  else
-    arg = Fprefix_numeric_value (arg);
-
-  hscroll = XINT (w->hscroll) - XINT (arg);
-  result = Fset_window_hscroll (selected_window, make_number (hscroll));
+  EMACS_INT requested_arg = (NILP (arg)
+                             ? window_body_cols (w) - 2
+                             : XINT (Fprefix_numeric_value (arg)));
+  Lisp_Object result = set_window_hscroll (w, w->hscroll - requested_arg);
 
   if (!NILP (set_minimum))
     w->min_hscroll = w->hscroll;
@@ -5511,9 +5477,8 @@ the return value is nil.  Otherwise the value is t.  */)
          really like to do is to free only those matrices not reused
          below.  */
       root_window = XWINDOW (FRAME_ROOT_WINDOW (f));
-      leaf_windows
-        = (struct window **) alloca (count_windows (root_window)
-                                     * sizeof (struct window *));
+      leaf_windows = alloca (count_windows (root_window)
+                             * sizeof *leaf_windows);
       n_leaf_windows = get_leaf_windows (root_window, leaf_windows, 0);
 
       /* Kludge Alert!
@@ -5572,14 +5537,14 @@ the return value is nil.  Otherwise the value is t.  */)
           w->total_lines = p->total_lines;
           w->normal_cols = p->normal_cols;
           w->normal_lines = p->normal_lines;
-          w->hscroll = p->hscroll;
-          w->min_hscroll = p->min_hscroll;
+          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;
-          w->fringes_outside_margins = p->fringes_outside_margins;
+          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;
@@ -5606,8 +5571,8 @@ the return value is nil.  Otherwise the value is t.  */)
                 }
             }
 
-          XSETFASTINT (w->last_modified, 0);
-          XSETFASTINT (w->last_overlay_modified, 0);
+          w->last_modified = 0;
+          w->last_overlay_modified = 0;
 
           /* Reinstall the saved buffer and pointers into it.  */
           if (NILP (p->buffer))
@@ -5717,7 +5682,7 @@ the return value is nil.  Otherwise the value is t.  */)
           if (NILP (leaf_windows[i]->buffer))
             {
               /* Assert it's not reused as a combination.  */
-              xassert (NILP (leaf_windows[i]->hchild)
+              eassert (NILP (leaf_windows[i]->hchild)
                        && NILP (leaf_windows[i]->vchild));
               free_window_matrices (leaf_windows[i]);
             }
@@ -5846,7 +5811,7 @@ get_phys_cursor_glyph (struct window *w)
   if (!row->enabled_p)
     return NULL;
 
-  if (XINT (w->hscroll))
+  if (w->hscroll)
     {
       /* When the window is hscrolled, cursor hpos can legitimately be
          out of bounds, but we draw the cursor at the corresponding
@@ -5888,14 +5853,14 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
       p->total_lines = w->total_lines;
       p->normal_cols = w->normal_cols;
       p->normal_lines = w->normal_lines;
-      p->hscroll = w->hscroll;
-      p->min_hscroll = w->min_hscroll;
+      XSETFASTINT (p->hscroll, w->hscroll);
+      XSETFASTINT (p->min_hscroll, w->min_hscroll);
       p->display_table = w->display_table;
       p->left_margin_cols = w->left_margin_cols;
       p->right_margin_cols = w->right_margin_cols;
       p->left_fringe_width = w->left_fringe_width;
       p->right_fringe_width = w->right_fringe_width;
-      p->fringes_outside_margins = w->fringes_outside_margins;
+      p->fringes_outside_margins = w->fringes_outside_margins ? Qt : Qnil;
       p->scroll_bar_width = w->scroll_bar_width;
       p->vertical_scroll_bar_type = w->vertical_scroll_bar_type;
       p->dedicated = w->dedicated;
@@ -5954,12 +5919,9 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
              is the selected window, then get the value of point from
              the buffer; pointm is garbage in the selected window.  */
           if (EQ (window, selected_window))
-            {
-              p->pointm = Fmake_marker ();
-              set_marker_both (p->pointm, w->buffer,
-                               BUF_PT (XBUFFER (w->buffer)),
-                               BUF_PT_BYTE (XBUFFER (w->buffer)));
-            }
+            p->pointm = build_marker (XBUFFER (w->buffer),
+                                      BUF_PT (XBUFFER (w->buffer)),
+                                      BUF_PT_BYTE (XBUFFER (w->buffer)));
           else
             p->pointm = Fcopy_marker (w->pointm, Qnil);
           XMARKER (p->pointm)->insertion_type
@@ -6041,8 +6003,8 @@ saved by this function.  */)
   tem = Fmake_vector (make_number (n_windows), Qnil);
   data->saved_windows = tem;
   for (i = 0; i < n_windows; i++)
-    XVECTOR (tem)->contents[i]
-      = Fmake_vector (make_number (VECSIZE (struct saved_window)), Qnil);
+    ASET (tem, i,
+         Fmake_vector (make_number (VECSIZE (struct saved_window)), Qnil));
   save_window_save (FRAME_ROOT_WINDOW (f), XVECTOR (tem), 0);
   XSETWINDOW_CONFIGURATION (tem, data);
   return (tem);
@@ -6132,6 +6094,7 @@ 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);
+  int outside = !NILP (outside_margins);
 
   if (!NILP (left_width))
     CHECK_NATNUM (left_width);
@@ -6142,11 +6105,11 @@ display marginal areas and the text area.  */)
   if (FRAME_WINDOW_P (WINDOW_XFRAME (w))
       && (!EQ (w->left_fringe_width, left_width)
           || !EQ (w->right_fringe_width, right_width)
-          || !EQ (w->fringes_outside_margins, outside_margins)))
+          || w->fringes_outside_margins != outside))
     {
       w->left_fringe_width = left_width;
       w->right_fringe_width = right_width;
-      w->fringes_outside_margins = outside_margins;
+      w->fringes_outside_margins = outside;
 
       adjust_window_margins (w);
 
@@ -6199,7 +6162,7 @@ Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
 
   if (!NILP (width))
     {
-      CHECK_RANGED_INTEGER (0, width, INT_MAX);
+      CHECK_RANGED_INTEGER (width, 0, INT_MAX);
 
       if (XINT (width) == 0)
         vertical_type = Qnil;