xdisp fix

author: Joakim Verona 2013-04-09 00:21:04 +0200
committer: Joakim Verona 2013-04-09 00:21:04 +0200
commit: e25d341cec1ebaee2b96d627d99d4d7b92dee6b0 (patch)
tree: a837c08c8ff2a6054964bd73469f6386368300e7 /src
parent: 9639da1e26683b6a54d255bb07a24dd6e0fae354 (diff)
parent: 6fcdab68b3e73354fb17f4c8c4f8199d6f63cf30 (diff)
download: emacs-e25d341cec1ebaee2b96d627d99d4d7b92dee6b0.tar.gz
emacs-e25d341cec1ebaee2b96d627d99d4d7b92dee6b0.zip
60 files changed, 1383 insertions, 1128 deletions
diff --git a/src/ChangeLog b/src/ChangeLog
index 6698cfe0fcf..cb6930f9acc 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,268 @@
+2013-04-07  Eli Zaretskii  <eliz@gnu.org>
+        * fileio.c (ACL_NOT_WELL_SUPPORTED): Define macro for WINDOWSNT.
+2013-04-07  Romain Francoise  <romain@orebokech.com>
+        Ignore additional platform-specific ACL errors (Bug#13702).
+        * fileio.c (ACL_NOT_WELL_SUPPORTED): New macro copied from gnulib.
+        (Fcopy_file, Fset_file_acl) [HAVE_POSIX_ACL]: Use it.
+2013-03-31  Jan Djärv  <jan.h.d@swipnet.se>
+        * nsterm.m (ns_mouse_position): Use NS_FRAME_P instead of checking
+        f->output_data.ns.
+2013-04-07  Paul Eggert  <eggert@cs.ucla.edu>
+        Fix --enable-profiling bug introduced by 2013-02-25 change (Bug#13783).
+        This bug was introduced by my 2013-02-25 change that simplified
+        data_start configuration.  Without this change, on GNU/Linux
+        an Emacs configured with --enable-profiling fails immediately
+        due to a profiler signal.
+        * Makefile.in: Compile with $(PROFILING_CFLAGS), but do not link
+        with these flags.  On platforms where special flags are needed
+        when linking temacs, the flags are now in LD_SWITCH_SYSTEM_TEMACS.
+        (ALL_CFLAGS): Remove $(PROFILING_CFLAGS).
+        (.c.o, .m.o): Compile with $(PROFILING_CFLAGS).
+2013-04-07  Dmitry Antipov  <dmantipov@yandex.ru>
+        Get rid of some platform-specific functions examining window
+        system and its capabilities.  This is a partial rework of the
+        2013-04-05 change.
+        * lisp.h (have_menus_p): Remove prototype.  This function is
+        replaced with platform-independent window_system_available.
+        (check_window_system): Move to...
+        * frame.h (decode_window_system_frame, window_system_available):
+        ...here, add new prototypes.
+        * frame.c (window_system_available, decode_window_system_frame):
+        New functions.
+        (check_window_system): Platform-independent now.
+        * xterm.h (x_in_use): Remove declaration.
+        (check_x_frame):
+        * w32term.h (check_x_frame):
+        * nsterm.h (check_x_frame): Remove prototypes.  This function
+        is replaced with platform-independent decode_window_system_frame.
+        * msdos.c (have_menus_p): Remove.
+        * nsfns.m (check_window_system, have_menus_p, check_ns_frame):
+        Remove platform-specific functions.  Use check_window_system,
+        decode_window_system_frame and check_ns_display_info where
+        appropriate.  Minor style and comment tweaks.
+        * w32fns.c (w32_in_use, check_window_system, have_menus_p)
+        (check_x_frame): Likewise.
+        * xfns.c (x_in_use, check_window_system, have_menus_p, check_x_frame):
+        Likewise.
+        * fileio.c, fns.c, font.c, fontset.c, image.c, menu.c, nsmenu.m:
+        * nsselect.m, nsterm.m, w32font.c, w32menu.c, xfaces.c, xgselect.c:
+        * xmenu.c, xselect.c: All related users changed.
+2013-04-03  Kenichi Handa  <handa@gnu.org>
+        The following changes is to optimize the code for reading UTF-8
+        files.
+        * coding.c (check_ascii): Renamed from detect_ascii.  Return value
+        changed.  Check EOL format.  Do not call adjust_coding_eol_type
+        here.
+        (check_utf_8): New function.
+        (adjust_coding_eol_type): Do nothing if already adjusted.
+        (detect_coding): Compare the return value of check_ascii with
+        coding->src_bytes.  Call adjust_coding_eol_type if necessary.
+        (decode_coding_gap): Optimize for valid UTF-8.
+2013-03-21  Kenichi Handa  <handa@gnu.org>
+        * coding.c (syms_of_coding): Cancel previous change.
+        * insdel.c (insert_from_gap): Fix previous change.
+2013-04-05  Dmitry Antipov  <dmantipov@yandex.ru>
+        Consistently use platform-specific function to detect window system.
+        * lisp.h (check_window_system): New prototype.  This function is
+        going to replace check_x, check_w32 and check_ns.
+        (have_menus_p): Mention msdos.c in comment.
+        * fontset.c (check_window_system_func): Remove.  Adjust all users.
+        * fontset.h (check_window_system_func): Remove prototype.
+        * nsterm.h (check_ns):
+        * xterm.h (check_x):
+        * w32term.h (check_w32): Likewise.
+        * menu.c (Fx_popup_menu): Use check_window_system.
+        * msdos.c (check_window_system): Define for MS-DOS.
+        * nsfns.m (check_window_system): Define for NS.  Adjust all users.
+        * w32fns.c (check_window_system): Likewise for MS-Windows.
+        * xfns.c (check_window_system): Likewise for X.
+        * font.c, frame.c, nsmenu.m, nsselect.m, nsterm.m, w32menu.c:
+        * xfaces.c, xmenu.c: Use check_window_system where appropriate.
+2013-04-02  Paul Eggert  <eggert@cs.ucla.edu>
+        Prefer < to > in range checks such as 0 <= i && i < N.
+        This makes it easier to visualize quantities on a number line.
+        This patch doesn't apply to all such range checks,
+        only to the range checks affected by the 2013-03-24 change.
+        This patch reverts most of the 2013-03-24 change.
+        * alloc.c (xpalloc, Fgarbage_collect):
+        * ccl.c (ccl_driver, resolve_symbol_ccl_program):
+        * character.c (string_escape_byte8):
+        * charset.c (read_hex):
+        * data.c (cons_to_unsigned):
+        * dispnew.c (update_frame_1):
+        * doc.c (Fsubstitute_command_keys):
+        * doprnt.c (doprnt):
+        * editfns.c (hi_time, decode_time_components):
+        * fileio.c (file_offset):
+        * fns.c (larger_vector, make_hash_table, Fmake_hash_table):
+        * font.c (font_intern_prop):
+        * frame.c (x_set_alpha):
+        * gtkutil.c (get_utf8_string):
+        * indent.c (check_display_width):
+        * keymap.c (Fkey_description):
+        * lisp.h (FIXNUM_OVERFLOW_P, vcopy):
+        * lread.c (read1):
+        * minibuf.c (read_minibuf_noninteractive):
+        * process.c (wait_reading_process_output):
+        * search.c (Freplace_match):
+        * window.c (get_phys_cursor_glyph):
+        * xdisp.c (redisplay_internal):
+        * xsmfns.c (smc_save_yourself_CB):
+        Prefer < to > for range checks.
+        * dispnew.c (sit_for): Don't mishandle NaNs.
+        This fixes a bug introduced in the 2013-03-24 change.
+        * editfns.c (decode_time_components): Don't hoist comparison.
+        This fixes another bug introduced in the 2013-03-24 change.
+2013-03-31  Dmitry Antipov  <dmantipov@yandex.ru>
+        * frame.h (struct frame): Drop scroll_bottom_vpos
+        member becaue all real users are dead long ago.
+        (FRAME_SCROLL_BOTTOM_VPOS): Remove.
+        * xdisp.c (redisplay_internal): Adjust user.
+2013-03-30  Darren Ho  <darren.hoo@gmail.com>  (tiny change)
+        * nsmenu.m (showAtX:Y:for:): setLevel to
+        NSPopUpMenuWindowLevel (Bug#13998).
+2013-03-30  Jan Djärv  <jan.h.d@swipnet.se>
+        * nsterm.h (ns_get_pending_menu_title, ns_check_menu_open)
+        (ns_check_pending_open_menu): Declare.
+        * nsmenu.m (ns_update_menubar): Correct NSTRACE.
+        (x_activate_menubar): Update the menu with title that matches
+        ns_get_pending_menu_title, and call
+        ns_check_pending_openmenu (Bug#12698).
+        (menuWillOpen:): New method.
+        (menuNeedsUpdate:): Add check for ! COCOA || OSX < 10.5 (Bug#12698).
+        * nsterm.m (menu_will_open_state, menu_mouse_point)
+        (menu_pending_title): New varaibles.
+        (ns_get_pending_menu_title, ns_check_menu_open)
+        (ns_check_pending_open_menu): New functions.
+2013-03-29  Dmitry Antipov  <dmantipov@yandex.ru>
+        * indent.c (current_column_bol_cache): Remove leftover which is not
+        used in Fmove_to_column any more.
+        (current_column, scan_for_column): Adjust users.
+        * keyboard.c (last_point_position_buffer, last_point_position_window):
+        Remove leftovers which are not used for recording undo any more.
+        (command_loop_1, syms_of_keyboard): Adjust users.
+        * xdisp.c (last_max_ascent): Remove leftover which is not used in
+        redisplay_window any more.
+        (move_it_to): Adjust user.
+2013-03-29  Juanma Barranquero  <lekktu@gmail.com>
+        * makefile.w32-in ($(BLD)/filelock.$(O), $(BLD)/filelock.$(O)):
+        Update dependencies.
+2013-03-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+        * lisp.h (save_type, XSAVE_POINTER, set_save_pointer, XSAVE_INTEGER)
+        (set_save_integer, XSAVE_OBJECT, XSAVE_VALUE): Move to avoid
+        forward references.
+2013-03-28  Dmitry Antipov  <dmantipov@yandex.ru>
+        * window.h (struct window): Replace hchild, vchild and buffer slots
+        with the only contents slot.  This is possible because each valid
+        window may have either the child window (in vertical or horizontal
+        combination) or buffer to display (for the leaf window).  Using that,
+        a lof of operations to traverse and/or change window hierarchies may
+        be simplified.  New member horizontal is used to distinguish between
+        horizontal and vertical combinations of internal windows.
+        (WINDOW_LEAF_P, WINDOW_HORIZONTAL_COMBINATION_P)
+        (WINDOW_VERTICAL_COMBINATION_P): New macros.
+        (WINDOW_VALID_P, WINDOW_LIVE_P): Adjust to match struct window changes.
+        * window.c (wset_hchild, wset_vchild): Remove.  Adjust all users.
+        Use contents slot, not buffer, where appropriate.
+        (wset_combination): New function.
+        (wset_buffer): Add eassert.
+        (Fframe_first_window): Simplify the loop reaching first window.
+        (Fwindow_buffer): Use WINDOW_LEAF_P.
+        (Fwindow_top_child): Use WINDOW_VERTICAL_COMBINATION_P.
+        (Fwindow_left_child): Use WINDOW_HORIZONTAL_COMBINATION_P.
+        (unshow_buffer): Convert initial debugging check to eassert.
+        (replace_window, recombine_windows, Fdelete_other_windows_internal)
+        (make_parent_window, window_resize_check, window_resize_apply)
+        (resize_frame_windows, Fsplit_window_internal, Fdelete_window_internal)
+        (Fset_window_configuration, delete_all_child_windows, save_window_save):
+        Adjust to match struct window changes.
+        (window_loop): Check for broken markers in CHECK_ALL_WINDOWS.
+        (mark_window_cursors_off, count_windows, get_leaf_windows)
+        (foreach_window_1): Simplify the loop.
+        * alloc.c (mark_object): Do not check for the leaf window because
+        internal windows has no glyph matrices anyway.
+        * dispnew.c (clear_window_matrices, showing_window_margins_p)
+        (allocate_matrices_for_window_redisplay, fake_current_matrices)
+        (allocate_matrices_for_frame_redisplay, free_window_matrices)
+        (build_frame_matrix_from_window_tree, mirror_make_current)
+        (frame_row_to_window, mirror_line_dance, check_window_matrix_pointers)
+        (update_window_tree, set_window_update_flags): Simplify the loop.
+        (sync_window_with_frame_matrix_rows): Enforce live window.
+        Use contents slot, not buffer, where appropriate.
+        * frame.c (set_menu_bar_lines_1): Use WINDOW_VERTICAL_COMBINATION_P
+        and WINDOW_HORIZONTAL_COMBINATION_P.
+        (make_frame_visible_1): Simplify the loop.
+        Use contents slot, not buffer, where appropriate.
+        * xdisp.c (hscroll_window_tree, mark_window_display_accurate)
+        (redisplay_windows, redisplay_mode_lines, update_cursor_in_window_tree)
+        (expose_window_tree): Likewise.
+        Use contents slot, not buffer, where appropriate.
+        * textprop.c (get_char_property_and_overlay): Add CHECK_LIVE_WINDOW
+        to avoid deleted windows.  Use contents slot instead of buffer.
+        * buffer.c, dispextern.h, editfns.c, fileio.c, font.c, fringe.c:
+        * indent.c, insdel.c, keyboard.c, keymap.c, minibuf.c, msdos.c:
+        * nsfns.m, nsmenu.m, nsterm.m, print.c, w32fns.c, w32menu.c, xfaces.c:
+        * xfns.c, xmenu.c: Use contents slot, not buffer, where appropriate.
+2013-03-28  Eli Zaretskii  <eliz@gnu.org>
+        * w32fns.c (w32_wnd_proc) [ENABLE_CHECKING]: Add code to help
+        identify the reasons for assertion violations in bug#14062 and
+        similar ones.
+        (Fx_show_tip): Fix compilation error under
+        "--enable-check-lisp-object-type".  (Bug#14073)
+        * image.c (g_error_free) [WINDOWSNT]: Add DEF_IMGLIB_FN.
+        Reported by <rzl24ozi@gmail.com>.
+2013-03-28  Dmitry Antipov  <dmantipov@yandex.ru>
+        * xdisp.c (with_echo_area_buffer_unwind_data): Save window
+        start marker...
+        (unwind_with_echo_area_buffer): ...to restore it here.  This
+        is needed to ensure that...
+        (redisplay_window): ...both window markers are valid here,
+        which is verified by eassert.
+        * editfns.c (save_excursion_save): Do not assume that
+        selected_window always displays the buffer.
+        * buffer.c (Fbuffer_swap_text): Adjust window start markers.
+        Fix comment.
 2013-03-27  Stefan Monnier  <monnier@iro.umontreal.ca>
        * casetab.c (init_casetab_once): Don't abuse the ascii eqv table for
@@ -298,7 +563,7 @@
        * coding.c (decode_coding_gap): Fix typo caught by static checking.
-2013-03-15  handa  <handa@gnu.org>
+2013-03-15  Kenichi Handa  <handa@gnu.org>
        * insdel.c (insert_from_gap): New arg text_at_gap_tail.
        (adjust_after_replace): Make it back to static.  Delete the third
diff --git a/src/ChangeLog.10 b/src/ChangeLog.10
index 508a2a9dd4c..57c1cbf1299 100644
--- a/src/ChangeLog.10
+++ b/src/ChangeLog.10
@@ -1865,7 +1865,7 @@
 2006-10-07  Ralf Angeli  <angeli@caeruleus.net>
-        * w32fns.c (w32_createwindow): Honour left and top positions if
+        * w32fns.c (w32_createwindow): Honor left and top positions if
        supplied explicitly.
 2006-10-06  Kim F. Storm  <storm@cua.dk>
diff --git a/src/Makefile.in b/src/Makefile.in
index 93d65867fa7..ac09d41858d 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -327,7 +327,7 @@ ALL_CFLAGS=-Demacs $(MYCPPFLAGS) -I. -I$(srcdir) \
  $(LIBXML2_CFLAGS) $(DBUS_CFLAGS) \
  $(WEBKIT_CFLAGS) $(CLUTTER_CFLAGS) $(GIR_CFLAGS) \
  $(SETTINGS_CFLAGS) $(FREETYPE_CFLAGS) $(FONTCONFIG_CFLAGS) \
-  $(LIBOTF_CFLAGS) $(M17N_FLT_CFLAGS) $(DEPFLAGS) $(PROFILING_CFLAGS) \
+  $(LIBOTF_CFLAGS) $(M17N_FLT_CFLAGS) $(DEPFLAGS) \
  $(LIBGNUTLS_CFLAGS) \
  $(WARN_CFLAGS) $(WERROR_CFLAGS) $(CFLAGS)
 ALL_OBJC_CFLAGS=$(ALL_CFLAGS) $(GNU_OBJC_CFLAGS)
@@ -335,10 +335,10 @@ ALL_OBJC_CFLAGS=$(ALL_CFLAGS) $(GNU_OBJC_CFLAGS)
 .SUFFIXES: .m
 .c.o:
        @$(MKDEPDIR)
-        $(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $<
+        $(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $(PROFILING_CFLAGS) $<
 .m.o:
        @$(MKDEPDIR)
-        $(CC) -c $(CPPFLAGS) $(ALL_OBJC_CFLAGS) $<
+        $(CC) -c $(CPPFLAGS) $(ALL_OBJC_CFLAGS) $(PROFILING_CFLAGS) $<
 ## lastfile must follow all files whose initialized data areas should
 ## be dumped as pure by dump-emacs.
diff --git a/src/alloc.c b/src/alloc.c
index ea833c62b94..7a56c78e2ba 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -779,7 +779,7 @@ xpalloc (void *pa, ptrdiff_t *nitems, ptrdiff_t nitems_incr_min,
  ptrdiff_t nitems_incr_max = n_max - n;
  ptrdiff_t incr = max (nitems_incr_min, min (incr_estimate, nitems_incr_max));
-  eassert (item_size > 0 && nitems_incr_min > 0 && n >= 0 && nitems_max >= -1);
+  eassert (0 < item_size && 0 < nitems_incr_min && 0 <= n && -1 <= nitems_max);
  if (! pa)
    *nitems = 0;
  if (nitems_incr_max < incr)
@@ -5376,7 +5376,7 @@ See Info node `(elisp)Garbage Collection'.  */)
      double tot = total_bytes_of_live_objects ();
      tot *= XFLOAT_DATA (Vgc_cons_percentage);
-      if (tot > 0)
+      if (0 < tot)
        {
          if (tot < TYPE_MAXIMUM (EMACS_INT))
            gc_relative_threshold = tot;
@@ -5810,14 +5810,13 @@ mark_object (Lisp_Object arg)
          case PVEC_WINDOW:
            {
              struct window *w = (struct window *) ptr;
-              bool leaf = NILP (w->hchild) && NILP (w->vchild);
              mark_vectorlike (ptr);
-              /* Mark glyphs for leaf windows.  Marking window
+              /* Mark glyph matrices, if any.  Marking window
                 matrices is sufficient because frame matrices
                 use the same glyph memory.  */
-              if (leaf && w->current_matrix)
+              if (w->current_matrix)
                {
                  mark_glyph_matrix (w->current_matrix);
                  mark_glyph_matrix (w->desired_matrix);
diff --git a/src/buffer.c b/src/buffer.c
index aa3fcf8c234..8728b418812 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1769,7 +1769,7 @@ cleaning up all windows currently displaying the buffer to be killed. */)
     since anything can happen within do_yes_or_no_p.  */
  /* Don't kill the minibuffer now current.  */
-  if (EQ (buffer, XWINDOW (minibuf_window)->buffer))
+  if (EQ (buffer, XWINDOW (minibuf_window)->contents))
    return Qnil;
  /* When we kill an ordinary buffer which shares it's buffer text
@@ -1820,7 +1820,7 @@ cleaning up all windows currently displaying the buffer to be killed. */)
  /* If the buffer now current is shown in the minibuffer and our buffer
     is the sole other buffer give up.  */
  XSETBUFFER (tem, current_buffer);
-  if (EQ (tem, XWINDOW (minibuf_window)->buffer)
+  if (EQ (tem, XWINDOW (minibuf_window)->contents)
      && EQ (buffer, Fother_buffer (buffer, Qnil, Qnil)))
    return Qnil;
@@ -2394,8 +2394,9 @@ DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text,
           BUF_MARKERS(buf) should either be for `buf' or dead.  */
        eassert (!m->buffer);
  }
-  { /* Some of the C code expects that w->buffer == w->pointm->buffer.
+  { /* Some of the C code expects that both window markers of a
-       So since we just swapped the markers between the two buffers, we need
+       live window points to that window's buffer.  So since we
+       just swapped the markers between the two buffers, we need
       to undo the effect of this swap for window markers.  */
    Lisp_Object w = Fselected_window (), ws = Qnil;
    Lisp_Object buf1, buf2;
@@ -2405,12 +2406,19 @@ DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text,
      {
        ws = Fcons (w, ws);
        if (MARKERP (XWINDOW (w)->pointm)
-            && (EQ (XWINDOW (w)->buffer, buf1)
+            && (EQ (XWINDOW (w)->contents, buf1)
-                || EQ (XWINDOW (w)->buffer, buf2)))
+                || EQ (XWINDOW (w)->contents, buf2)))
          Fset_marker (XWINDOW (w)->pointm,
                       make_number
-                       (BUF_BEGV (XBUFFER (XWINDOW (w)->buffer))),
+                       (BUF_BEGV (XBUFFER (XWINDOW (w)->contents))),
-                       XWINDOW (w)->buffer);
+                       XWINDOW (w)->contents);
+        if (MARKERP (XWINDOW (w)->start)
+            && (EQ (XWINDOW (w)->contents, buf1)
+                || EQ (XWINDOW (w)->contents, buf2)))
+          Fset_marker (XWINDOW (w)->start,
+                       make_number
+                       (XBUFFER (XWINDOW (w)->contents)->last_window_start),
+                       XWINDOW (w)->contents);
        w = Fnext_window (w, Qt, Qt);
      }
  }
@@ -3893,7 +3901,7 @@ modify_overlay (struct buffer *buf, ptrdiff_t start, ptrdiff_t end)
  if (buffer_window_count (buf) > 0)
    {
      /* ... it's visible in other window than selected,  */
-      if (buf != XBUFFER (XWINDOW (selected_window)->buffer))
+      if (buf != XBUFFER (XWINDOW (selected_window)->contents))
        windows_or_buffers_changed = 1;
      /* ... or if we modify an overlay at the end of the buffer
         and so we cannot be sure that window end is still valid.  */
diff --git a/src/ccl.c b/src/ccl.c
index c3b3f5486c4..8fec18296a6 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -1668,7 +1668,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                  }
                map = XCDR (map);
                if (! (VECTORP (map)
-                       && ASIZE (map) > 0
+                       && 0 < ASIZE (map)
                       && INTEGERP (AREF (map, 0))
                       && XINT (AREF (map, 0)) <= op
                       && op - XINT (AREF (map, 0)) + 1 < ASIZE (map)))
@@ -1867,7 +1867,7 @@ resolve_symbol_ccl_program (Lisp_Object ccl)
      return Qnil;
    }
-  if (! (XINT (AREF (result, CCL_HEADER_BUF_MAG)) >= 0
+  if (! (0 <= XINT (AREF (result, CCL_HEADER_BUF_MAG))
         && ASCENDING_ORDER (0, XINT (AREF (result, CCL_HEADER_EOF)),
                             ASIZE (ccl))))
    return Qnil;
diff --git a/src/character.c b/src/character.c
index 5a06c7f4d6c..b2caaa290af 100644
--- a/src/character.c
+++ b/src/character.c
@@ -833,8 +833,8 @@ string_escape_byte8 (Lisp_Object string)
  if (multibyte)
    {
-      if (byte8_count > (MOST_POSITIVE_FIXNUM - nchars) / 3
+      if ((MOST_POSITIVE_FIXNUM - nchars) / 3 < byte8_count
-          || byte8_count > (STRING_BYTES_BOUND - nbytes) / 2)
+          || (STRING_BYTES_BOUND - nbytes) / 2 < byte8_count)
        string_overflow ();
      /* Convert 2-byte sequence of byte8 chars to 4-byte octal.  */
@@ -843,7 +843,7 @@ string_escape_byte8 (Lisp_Object string)
    }
  else
    {
-      if (byte8_count > (STRING_BYTES_BOUND - nbytes) / 3)
+      if ((STRING_BYTES_BOUND - nbytes) / 3 < byte8_count)
        string_overflow ();
      /* Convert 1-byte sequence of byte8 chars to 4-byte octal.  */
diff --git a/src/charset.c b/src/charset.c
index 3d43d81877f..fdb8eebde8b 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -447,7 +447,7 @@ read_hex (FILE *fp, bool *eof, bool *overflow)
  n = 0;
  while (c_isxdigit (c = getc (fp)))
    {
-      if (n > UINT_MAX >> 4)
+      if (UINT_MAX >> 4 < n)
        *overflow = 1;
      n = ((n << 4)
           | (c - ('0' <= c && c <= '9' ? '0'
diff --git a/src/coding.c b/src/coding.c
index cb81375a043..f9799035b3c 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -6072,17 +6072,18 @@ complement_process_encoding_system (Lisp_Object coding_system)
 #define EOL_SEEN_CRLF   4
-static Lisp_Object adjust_coding_eol_type (struct coding_system *coding, int eol_seen);
+static Lisp_Object adjust_coding_eol_type (struct coding_system *coding,
+                                           int eol_seen);
-/* Return true iff all the source bytes are ASCII.
+/* Return the number of ASCII characters at the head of the source.
   By side effects, set coding->head_ascii and coding->eol_seen.  The
   value of coding->eol_seen is "logical or" of EOL_SEEN_LF,
   EOL_SEEN_CR, and EOL_SEEN_CRLF, but the value is reliable only when
   all the source bytes are ASCII.  */
-static bool
+static int
-detect_ascii (struct coding_system *coding)
+check_ascii (struct coding_system *coding)
 {
  const unsigned char *src, *end;
  Lisp_Object eol_type = CODING_ID_EOL_TYPE (coding->id);
@@ -6096,21 +6097,20 @@ detect_ascii (struct coding_system *coding)
  src = coding->source;
  end = src + coding->src_bytes;
-  if (inhibit_eol_conversion)
+  if (inhibit_eol_conversion
+      || eol_seen != EOL_SEEN_NONE)
    {
      /* We don't have to check EOL format.  */
      while (src < end && !( *src & 0x80)) src++;
-      eol_seen = EOL_SEEN_LF;
+      if (inhibit_eol_conversion)
-      adjust_coding_eol_type (coding, eol_seen);
+        {
-    }
+          eol_seen = EOL_SEEN_LF;
-  else if (eol_seen != EOL_SEEN_NONE)
+          adjust_coding_eol_type (coding, eol_seen);
-    {
+        }
-      /* We don't have to check EOL format either.  */
-      while (src < end && !(*src & 0x80)) src++;
    }
  else
    {
-      end--;                    /* We look ahead one byte.  */
+      end--;                /* We look ahead one byte for "CR LF".  */
      while (src < end)
        {
          int c = *src;
@@ -6118,6 +6118,69 @@ detect_ascii (struct coding_system *coding)
          if (c & 0x80)
            break;
          src++;
+          if (c == '\r')
+            {
+              if (*src == '\n')
+                {
+                  eol_seen |= EOL_SEEN_CRLF;
+                  src++;
+                }
+              else
+                eol_seen |= EOL_SEEN_CR;
+            }
+          else if (c == '\n')
+            eol_seen |= EOL_SEEN_LF;
+        }
+      if (src == end)
+        {
+          int c = *src;
+          /* All bytes but the last one C are ASCII.  */
+          if (! (c & 0x80))
+            {
+              if (c == '\r')
+                eol_seen |= EOL_SEEN_CR;
+              else if (c  == '\n')
+                eol_seen |= EOL_SEEN_LF;
+              src++;
+            }
+        }
+    }
+  coding->head_ascii = src - coding->source;
+  coding->eol_seen = eol_seen;
+  return (coding->head_ascii);
+}
+/* Return the number of characters at the source if all the bytes are
+   valid UTF-8 (of Unicode range).  Otherwise, return -1.  By side
+   effects, update coding->eol_seen.  The value of coding->eol_seen is
+   "logical or" of EOL_SEEN_LF, EOL_SEEN_CR, and EOL_SEEN_CRLF, but
+   the value is reliable only when all the source bytes are valid
+   UTF-8.  */
+static int
+check_utf_8 (struct coding_system *coding)
+{
+  const unsigned char *src, *end;
+  int eol_seen = coding->eol_seen;
+  int nchars = coding->head_ascii;
+  if (coding->head_ascii < 0)
+    check_ascii (coding);
+  else
+    coding_set_source (coding);
+  src = coding->source + coding->head_ascii;
+  /* We look ahead one byte for CR LF.  */
+  end = coding->source + coding->src_bytes - 1;
+  while (src < end)
+    {
+      int c = *src;
+      if (UTF_8_1_OCTET_P (*src))
+        {
+          src++;
          if (c < 0x20)
            {
              if (c == '\r')
@@ -6126,6 +6189,7 @@ detect_ascii (struct coding_system *coding)
                    {
                      eol_seen |= EOL_SEEN_CRLF;
                      src++;
+                      nchars++;
                    }
                  else
                    eol_seen |= EOL_SEEN_CR;
@@ -6134,27 +6198,58 @@ detect_ascii (struct coding_system *coding)
                eol_seen |= EOL_SEEN_LF;
            }
        }
-      if (src > end)
+      else if (UTF_8_2_OCTET_LEADING_P (c))
-        /* The last two bytes are CR LF, which means that we have
-           scanned all bytes. */
-        end++;
-      else if (src == end)
        {
-          end++;
+          if (c < 0xC2          /* overlong sequence */
-          if (! (*src & 0x80))
+              || src + 1 >= end
-            {
+              || ! UTF_8_EXTRA_OCTET_P (src[1]))
-              if (*src == '\r')
+            return -1;
-                eol_seen |= EOL_SEEN_CR;
+          src += 2;
-              else if (*src  == '\n')
-                eol_seen |= EOL_SEEN_LF;
-              src++;
-            }
        }
-      adjust_coding_eol_type (coding, eol_seen);
+      else if (UTF_8_3_OCTET_LEADING_P (c))
+        {
+          if (src + 2 >= end
+              || ! (UTF_8_EXTRA_OCTET_P (src[1])
+                    && UTF_8_EXTRA_OCTET_P (src[2])))
+            return -1;
+          c = (((c & 0xF) << 12)
+               | ((src[1] & 0x3F) << 6) | (src[2] & 0x3F));
+          if (c < 0x800                       /* overlong sequence */
+              || (c >= 0xd800 && c < 0xe000)) /* surrogates (invalid) */
+            return -1;
+          src += 3;
+        }
+      else if (UTF_8_4_OCTET_LEADING_P (c))
+        {
+          if (src + 3 >= end
+              || ! (UTF_8_EXTRA_OCTET_P (src[1])
+                    && UTF_8_EXTRA_OCTET_P (src[2])
+                    && UTF_8_EXTRA_OCTET_P (src[3])))
+            return -1;
+          c = (((c & 0x7) << 18) | ((src[1] & 0x3F) << 12)
+               | ((src[2] & 0x3F) << 6) | (src[3] & 0x3F));
+          if (c < 0x10000       /* overlong sequence */
+              || c >= 0x110000) /* non-Unicode character  */
+            return -1;
+          src += 4;
+        }
+      else
+        return -1;
+      nchars++;
+    }
+  if (src == end)
+    {
+      if (! UTF_8_1_OCTET_P (*src))
+        return -1;
+      nchars++;
+      if (*src == '\r')
+        eol_seen |= EOL_SEEN_CR;
+      else if (*src  == '\n')
+        eol_seen |= EOL_SEEN_LF;
    }
-  coding->head_ascii = src - coding->source;
  coding->eol_seen = eol_seen;
-  return (src == end);
+  return nchars;
 }
@@ -6269,6 +6364,9 @@ adjust_coding_eol_type (struct coding_system *coding, int eol_seen)
  Lisp_Object eol_type;
  eol_type = CODING_ID_EOL_TYPE (coding->id);
+  if (! VECTORP (eol_type))
+    /* Already adjusted.  */
+    return eol_type;
  if (eol_seen & EOL_SEEN_LF)
    {
      coding->id = CODING_SYSTEM_ID (AREF (eol_type, 0));
@@ -6360,7 +6458,8 @@ detect_coding (struct coding_system *coding)
                        {
                          coding->eol_seen |= EOL_SEEN_CRLF;
                          src++;
-                          coding->head_ascii++;
+                          if (! eight_bit_found)
+                            coding->head_ascii++;
                        }
                      else
                        coding->eol_seen |= EOL_SEEN_CR;
@@ -6461,9 +6560,14 @@ detect_coding (struct coding_system *coding)
      coding_systems
        = AREF (CODING_ID_ATTRS (coding->id), coding_attr_utf_bom);
      detect_info.found = detect_info.rejected = 0;
-      if (detect_ascii (coding))
+      if (check_ascii (coding) == coding->src_bytes)
        {
+          int head_ascii = coding->head_ascii;
+          if (coding->eol_seen != EOL_SEEN_NONE)
+            adjust_coding_eol_type (coding, coding->eol_seen);
          setup_coding_system (XCDR (coding_systems), coding);
+          coding->head_ascii = head_ascii;
        }
      else
        {
@@ -7620,15 +7724,27 @@ decode_coding_gap (struct coding_system *coding,
  if (CODING_REQUIRE_DETECTION (coding))
    detect_coding (coding);
  attrs = CODING_ID_ATTRS (coding->id);
-  if (! disable_ascii_optimization)
+  if (! disable_ascii_optimization
-    {
+      && ! coding->src_multibyte
-      if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs))
+      && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs))
-          && NILP (CODING_ATTR_POST_READ (attrs))
+      && NILP (CODING_ATTR_POST_READ (attrs))
-          && NILP (get_translation_table (attrs, 0, NULL))
+      && NILP (get_translation_table (attrs, 0, NULL)))
-          && (coding->head_ascii >= 0 /* We've already called detect_coding */
+    {
-              ? coding->head_ascii == bytes
+      chars = coding->head_ascii;
-              : detect_ascii (coding)))
+      if (chars < 0)
+        chars = check_ascii (coding);
+      if (chars != bytes)
+        {
+          if (EQ (CODING_ATTR_TYPE (attrs), Qutf_8))
+            chars = check_utf_8 (coding);
+          else
+            chars = -1;
+        }
+      if (chars >= 0)
        {
+          if (coding->eol_seen != EOL_SEEN_NONE)
+            adjust_coding_eol_type (coding, coding->eol_seen);
          if (coding->eol_seen == EOL_SEEN_CR)
            {
              unsigned char *src_end = GAP_END_ADDR;
@@ -7645,6 +7761,7 @@ decode_coding_gap (struct coding_system *coding,
              unsigned char *src = GAP_END_ADDR;
              unsigned char *src_beg = src - coding->src_bytes;
              unsigned char *dst = src;
+              ptrdiff_t diff;
              while (src_beg < src)
                {
@@ -7652,10 +7769,13 @@ decode_coding_gap (struct coding_system *coding,
                  if (*src == '\n')
                    src--;
                }
-              bytes -= dst - src;
+              diff = dst - src;
+              bytes -= diff;
+              chars -= diff;
            }
-          coding->produced_char = coding->produced = bytes;
+          coding->produced = bytes;
-          insert_from_gap (bytes, bytes, 1);
+          coding->produced_char = chars;
+          insert_from_gap (chars, bytes, 1);
          return;
        }
    }
@@ -10877,7 +10997,7 @@ decode text as usual.  */);
  DEFVAR_BOOL ("disable-ascii-optimization", disable_ascii_optimization,
               doc: /* If non-nil, Emacs does not optimize code decoder for ASCII files.
 Internal use only.  Removed after the experimental optimizer gets stable. */);
-  disable_ascii_optimization = 1;
+  disable_ascii_optimization = 0;
  DEFVAR_LISP ("translation-table-for-input", Vtranslation_table_for_input,
               doc: /* Char table for translating self-inserting characters.
diff --git a/src/data.c b/src/data.c
index b20d1b4c8af..6622088b648 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2337,13 +2337,13 @@ cons_to_unsigned (Lisp_Object c, uintmax_t max)
  uintmax_t val IF_LINT (= 0);
  if (INTEGERP (c))
    {
-      valid = XINT (c) >= 0;
+      valid = 0 <= XINT (c);
      val = XINT (c);
    }
  else if (FLOATP (c))
    {
      double d = XFLOAT_DATA (c);
-      if (d >= 0
+      if (0 <= d
          && d < (max == UINTMAX_MAX ? (double) UINTMAX_MAX + 1 : max + 1))
        {
          val = d;
diff --git a/src/dired.c b/src/dired.c
index ab48488966b..7bbfee7e5b0 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -517,8 +517,9 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
      QUIT;
      if (len < SCHARS (encoded_file)
-          || scmp (dp->d_name, SSDATA (encoded_file),
+          || (scmp (dp->d_name, SSDATA (encoded_file),
-                   SCHARS (encoded_file)) >= 0)
+                    SCHARS (encoded_file))
+              >= 0))
        continue;
      if (file_name_completion_stat (fd, dp, &st) < 0)
diff --git a/src/dispextern.h b/src/dispextern.h
index 9a03abf6766..0c35aff8285 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1422,25 +1422,24 @@ struct glyph_string
 /* Value is non-zero if window W wants a mode line.  */
-#define WINDOW_WANTS_MODELINE_P(W)                                      \
+#define WINDOW_WANTS_MODELINE_P(W)                              \
-     (!MINI_WINDOW_P ((W))                                              \
+  (!MINI_WINDOW_P ((W))                                         \
-      && !(W)->pseudo_window_p                                          \
+   && !(W)->pseudo_window_p                                     \
-      && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W))))           \
+   && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W))))      \
-      && BUFFERP (W->buffer)                                    \
+   && BUFFERP (W->contents)                                     \
-      && !NILP (BVAR (XBUFFER (W->buffer), mode_line_format))   \
+   && !NILP (BVAR (XBUFFER (W->contents), mode_line_format))    \
-      && WINDOW_TOTAL_LINES (W) > 1)
+   && WINDOW_TOTAL_LINES (W) > 1)
 /* Value is true if window W wants a header line.  */
-#define WINDOW_WANTS_HEADER_LINE_P(W)                                   \
+#define WINDOW_WANTS_HEADER_LINE_P(W)                           \
-     (!MINI_WINDOW_P ((W))                                              \
+  (!MINI_WINDOW_P ((W))                                         \
-      && !(W)->pseudo_window_p                                          \
+   && !(W)->pseudo_window_p                                     \
-      && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W))))           \
+   && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W))))      \
-      && BUFFERP (W->buffer)                                    \
+   && BUFFERP (W->contents)                                     \
-      && !NILP (BVAR (XBUFFER (W->buffer), header_line_format)) \
+   && !NILP (BVAR (XBUFFER (W->contents), header_line_format))  \
-      && WINDOW_TOTAL_LINES (W) > 1                                     \
+   && WINDOW_TOTAL_LINES (W) > 1                                \
-      + !NILP (BVAR (XBUFFER (W->buffer), mode_line_format)))
+   + !NILP (BVAR (XBUFFER (W->contents), mode_line_format)))
 /* Return proper value to be used as baseline offset of font that has
   ASCENT and DESCENT to draw characters by the font at the vertical
diff --git a/src/dispnew.c b/src/dispnew.c
index de1ca47ef60..ab73b6403ee 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -226,9 +226,9 @@ add_window_display_history (struct window *w, const char *msg, bool paused_p)
            "%"pMu": window %p (`%s')%s\n%s",
            history_tick++,
            w,
-            ((BUFFERP (w->buffer)
+            ((BUFFERP (w->contents)
-              && STRINGP (BVAR (XBUFFER (w->buffer), name)))
+              && STRINGP (BVAR (XBUFFER (w->contents), name)))
-             ? SSDATA (BVAR (XBUFFER (w->buffer), name))
+             ? SSDATA (BVAR (XBUFFER (w->contents), name))
             : "???"),
            paused_p ? " ***paused***" : "",
            msg);
@@ -844,16 +844,8 @@ clear_window_matrices (struct window *w, bool desired_p)
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        {
+        clear_window_matrices (XWINDOW (w->contents), desired_p);
-          eassert (WINDOWP (w->hchild));
-          clear_window_matrices (XWINDOW (w->hchild), desired_p);
-        }
-      else if (!NILP (w->vchild))
-        {
-          eassert (WINDOWP (w->vchild));
-          clear_window_matrices (XWINDOW (w->vchild), desired_p);
-        }
      else
        {
          if (desired_p)
@@ -1474,7 +1466,7 @@ check_matrix_invariants (struct window *w)
  struct glyph_row *row = matrix->rows;
  struct glyph_row *last_text_row = NULL;
  struct buffer *saved = current_buffer;
-  struct buffer *buffer = XBUFFER (w->buffer);
+  struct buffer *buffer = XBUFFER (w->contents);
  int c;
  /* This can sometimes happen for a fresh window.  */
@@ -1638,7 +1630,7 @@ allocate_matrices_for_frame_redisplay (Lisp_Object window, int x, int y,
     vertically below other windows.  */
  in_horz_combination_p
    = (!NILP (XWINDOW (window)->parent)
-       && !NILP (XWINDOW (XWINDOW (window)->parent)->hchild));
+       && WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (XWINDOW (window)->parent)));
  /* For WINDOW and all windows on the same level.  */
  do
@@ -1647,12 +1639,8 @@ allocate_matrices_for_frame_redisplay (Lisp_Object window, int x, int y,
      /* Get the dimension of the window sub-matrix for W, depending
         on whether this is a combination or a leaf window.  */
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        dim = allocate_matrices_for_frame_redisplay (w->hchild, x, y,
+        dim = allocate_matrices_for_frame_redisplay (w->contents, x, y,
-                                                     dim_only_p,
-                                                     window_change_flags);
-      else if (!NILP (w->vchild))
-        dim = allocate_matrices_for_frame_redisplay (w->vchild, x, y,
                                                     dim_only_p,
                                                     window_change_flags);
      else
@@ -1794,10 +1782,8 @@ allocate_matrices_for_window_redisplay (struct window *w)
 {
  while (w)
    {
-      if (!NILP (w->vchild))
+      if (WINDOWP (w->contents))
-        allocate_matrices_for_window_redisplay (XWINDOW (w->vchild));
+        allocate_matrices_for_window_redisplay (XWINDOW (w->contents));
-      else if (!NILP (w->hchild))
-        allocate_matrices_for_window_redisplay (XWINDOW (w->hchild));
      else
        {
          /* W is a leaf window.  */
@@ -1869,18 +1855,12 @@ showing_window_margins_p (struct window *w)
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
        {
-          if (showing_window_margins_p (XWINDOW (w->hchild)))
+          if (showing_window_margins_p (XWINDOW (w->contents)))
            return 1;
        }
-      else if (!NILP (w->vchild))
+      else if (!NILP (w->left_margin_cols) || !NILP (w->right_margin_cols))
-        {
-          if (showing_window_margins_p (XWINDOW (w->vchild)))
-            return 1;
-        }
-      else if (!NILP (w->left_margin_cols)
-               || !NILP (w->right_margin_cols))
        return 1;
      w = NILP (w->next) ? 0 : XWINDOW (w->next);
@@ -1901,10 +1881,8 @@ fake_current_matrices (Lisp_Object window)
    {
      w = XWINDOW (window);
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        fake_current_matrices (w->hchild);
+        fake_current_matrices (w->contents);
-      else if (!NILP (w->vchild))
-        fake_current_matrices (w->vchild);
      else
        {
          int i;
@@ -2244,10 +2222,8 @@ free_window_matrices (struct window *w)
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        free_window_matrices (XWINDOW (w->hchild));
+        free_window_matrices (XWINDOW (w->contents));
-      else if (!NILP (w->vchild))
-        free_window_matrices (XWINDOW (w->vchild));
      else
        {
          /* This is a leaf window.  Free its memory and reset fields
@@ -2380,10 +2356,8 @@ build_frame_matrix_from_window_tree (struct glyph_matrix *matrix, struct window
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        build_frame_matrix_from_window_tree (matrix, XWINDOW (w->hchild));
+        build_frame_matrix_from_window_tree (matrix, XWINDOW (w->contents));
-      else if (!NILP (w->vchild))
-        build_frame_matrix_from_window_tree (matrix, XWINDOW (w->vchild));
      else
        build_frame_matrix_from_leaf_window (matrix, w);
@@ -2647,10 +2621,8 @@ mirror_make_current (struct window *w, int frame_row)
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        mirror_make_current (XWINDOW (w->hchild), frame_row);
+        mirror_make_current (XWINDOW (w->contents), frame_row);
-      else if (!NILP (w->vchild))
-        mirror_make_current (XWINDOW (w->vchild), frame_row);
      else
        {
          /* Row relative to window W.  Don't use FRAME_TO_WINDOW_VPOS
@@ -2746,8 +2718,8 @@ sync_window_with_frame_matrix_rows (struct window *w)
  struct glyph_row *window_row, *window_row_end, *frame_row;
  int left, right, x, width;
-  /* Preconditions: W must be a leaf window on a tty frame.  */
+  /* Preconditions: W must be a live window on a tty frame.  */
-  eassert (NILP (w->hchild) && NILP (w->vchild));
+  eassert (BUFFERP (w->contents));
  eassert (!FRAME_WINDOW_P (f));
  left = margin_glyphs_to_reserve (w, 1, w->left_margin_cols);
@@ -2783,10 +2755,8 @@ frame_row_to_window (struct window *w, int row)
  while (w && !found)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        found = frame_row_to_window (XWINDOW (w->hchild), row);
+        found = frame_row_to_window (XWINDOW (w->contents), row);
-      else if (!NILP (w->vchild))
-        found = frame_row_to_window (XWINDOW (w->vchild), row);
      else if (row >= WINDOW_TOP_EDGE_LINE (w)
               && row < WINDOW_BOTTOM_EDGE_LINE (w))
        found = w;
@@ -2814,11 +2784,8 @@ mirror_line_dance (struct window *w, int unchanged_at_top, int nlines, int *copy
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        mirror_line_dance (XWINDOW (w->hchild), unchanged_at_top,
+        mirror_line_dance (XWINDOW (w->contents), unchanged_at_top,
-                           nlines, copy_from, retained_p);
-      else if (!NILP (w->vchild))
-        mirror_line_dance (XWINDOW (w->vchild), unchanged_at_top,
                           nlines, copy_from, retained_p);
      else
        {
@@ -2927,10 +2894,8 @@ check_window_matrix_pointers (struct window *w)
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        check_window_matrix_pointers (XWINDOW (w->hchild));
+        check_window_matrix_pointers (XWINDOW (w->contents));
-      else if (!NILP (w->vchild))
-        check_window_matrix_pointers (XWINDOW (w->vchild));
      else
        {
          struct frame *f = XFRAME (w->frame);
@@ -3196,10 +3161,8 @@ update_window_tree (struct window *w, bool force_p)
  while (w && !paused_p)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        paused_p |= update_window_tree (XWINDOW (w->hchild), force_p);
+        paused_p |= update_window_tree (XWINDOW (w->contents), force_p);
-      else if (!NILP (w->vchild))
-        paused_p |= update_window_tree (XWINDOW (w->vchild), force_p);
      else if (w->must_be_updated_p)
        paused_p |= update_window (w, force_p);
@@ -3980,10 +3943,8 @@ set_window_update_flags (struct window *w, bool on_p)
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        set_window_update_flags (XWINDOW (w->hchild), on_p);
+        set_window_update_flags (XWINDOW (w->contents), on_p);
-      else if (!NILP (w->vchild))
-        set_window_update_flags (XWINDOW (w->vchild), on_p);
      else
        w->must_be_updated_p = on_p;
@@ -4556,7 +4517,7 @@ update_frame_1 (struct frame *f, bool force_p, bool inhibit_id_p)
        }
    }
-  lint_assume (FRAME_LINES (f) >= 0);
+  lint_assume (0 <= FRAME_LINES (f));
  pause_p = 0 < i && i < FRAME_LINES (f) - 1;
  /* Now just clean up termcap drivers and set cursor, etc.  */
@@ -5136,7 +5097,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
  /* We used to set current_buffer directly here, but that does the
     wrong thing with `face-remapping-alist' (bug#2044).  */
-  Fset_buffer (w->buffer);
+  Fset_buffer (w->contents);
  itdata = bidi_shelve_cache ();
  SET_TEXT_POS_FROM_MARKER (startp, w->start);
  CHARPOS (startp) = min (ZV, max (BEGV, CHARPOS (startp)));
@@ -5182,7 +5143,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
  *dx = x0 + it.first_visible_x - it.current_x;
  *dy = *y - it.current_y;
-  string =  w->buffer;
+  string = w->contents;
  if (STRINGP (it.string))
    string = it.string;
  *pos = it.current;
@@ -5200,7 +5161,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
      if (STRINGP (it.string))
        BYTEPOS (pos->pos) = string_char_to_byte (string, CHARPOS (pos->pos));
      else
-        BYTEPOS (pos->pos) = buf_charpos_to_bytepos (XBUFFER (w->buffer),
+        BYTEPOS (pos->pos) = buf_charpos_to_bytepos (XBUFFER (w->contents),
                                                     CHARPOS (pos->pos));
    }
@@ -5822,7 +5783,7 @@ sit_for (Lisp_Object timeout, bool reading, int display_option)
  else if (FLOATP (timeout))
    {
      double seconds = XFLOAT_DATA (timeout);
-      if (seconds <= 0)
+      if (! (0 < seconds))
        return Qt;
      else
        {
diff --git a/src/doc.c b/src/doc.c
index 1ddaa117bba..7234fb38bf9 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -826,7 +826,7 @@ Otherwise, return a new string, without any text properties.  */)
          if (NILP (tem))       /* but not on any keys */
            {
              ptrdiff_t offset = bufp - buf;
-              if (bsize > STRING_BYTES_BOUND - 4)
+              if (STRING_BYTES_BOUND - 4 < bsize)
                string_overflow ();
              buf = xrealloc (buf, bsize += 4);
              bufp = buf + offset;
diff --git a/src/doprnt.c b/src/doprnt.c
index 087256ced2a..471e35c7b43 100644
--- a/src/doprnt.c
+++ b/src/doprnt.c
@@ -361,7 +361,7 @@ doprnt (char *buffer, ptrdiff_t bufsize, const char *format,
              /* Copy string into final output, truncating if no room.  */
            doit:
-              eassert (tem >= 0);
+              eassert (0 <= tem);
              /* Coming here means STRING contains ASCII only.  */
              if (STRING_BYTES_BOUND < tem)
                error ("Format width or precision too large");
diff --git a/src/editfns.c b/src/editfns.c
index 2d87b8e0064..e0b0347fe69 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -373,7 +373,7 @@ get_pos_property (Lisp_Object position, register Lisp_Object prop, Lisp_Object o
  if (NILP (object))
    XSETBUFFER (object, current_buffer);
  else if (WINDOWP (object))
-    object = XWINDOW (object)->buffer;
+    object = XWINDOW (object)->contents;
  if (!BUFFERP (object))
    /* pos-property only makes sense in buffers right now, since strings
@@ -846,7 +846,7 @@ save_excursion_save (void)
      ? Fcopy_marker (BVAR (current_buffer, mark), Qnil)
      : Qnil),
     /* Selected window if current buffer is shown in it, nil otherwise.  */
-     ((XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
+     (EQ (XWINDOW (selected_window)->contents, Fcurrent_buffer ())
      ? selected_window : Qnil),
     BVAR (current_buffer, mark_active));
 }
@@ -915,7 +915,7 @@ save_excursion_restore (Lisp_Object info)
  tem = XSAVE_OBJECT (info, 2);
  if (WINDOWP (tem)
      && !EQ (tem, selected_window)
-      && (tem1 = XWINDOW (tem)->buffer,
+      && (tem1 = XWINDOW (tem)->contents,
          (/* Window is live...  */
           BUFFERP (tem1)
           /* ...and it shows the current buffer.  */
@@ -1398,8 +1398,8 @@ hi_time (time_t t)
     no runtime check is needed, and taking care not to convert
     negative numbers to unsigned before comparing them.  */
  if (! ((! TYPE_SIGNED (time_t)
-          || TIME_T_MIN >> 16 >= MOST_NEGATIVE_FIXNUM
+          || MOST_NEGATIVE_FIXNUM <= TIME_T_MIN >> 16
-          || hi >= MOST_NEGATIVE_FIXNUM)
+          || MOST_NEGATIVE_FIXNUM <= hi)
         && (TIME_T_MAX >> 16 <= MOST_POSITIVE_FIXNUM
             || hi <= MOST_POSITIVE_FIXNUM)))
    time_overflow ();
@@ -1561,7 +1561,7 @@ decode_time_components (Lisp_Object high, Lisp_Object low, Lisp_Object usec,
  if (result)
    {
-      if (hi >= (TYPE_SIGNED (time_t) ? TIME_T_MIN >> 16 : 0)
+      if ((TYPE_SIGNED (time_t) ? TIME_T_MIN >> 16 <= hi : 0 <= hi)
          && hi <= TIME_T_MAX >> 16)
        {
          /* Return the greatest representable time that is not greater
diff --git a/src/fileio.c b/src/fileio.c
index 1919768d98a..1049522e5a9 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -81,6 +81,25 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define DRIVE_LETTER(x) c_tolower (x)
 #endif
+#ifdef HAVE_POSIX_ACL
+/* FIXME: this macro was copied from gnulib's private acl-internal.h
+   header file.  */
+/* Recognize some common errors such as from an NFS mount that does
+   not support ACLs, even when local drives do.  */
+#if defined __APPLE__ && defined __MACH__ /* Mac OS X */
+#define ACL_NOT_WELL_SUPPORTED(Err)                                     \
+  ((Err) == ENOTSUP || (Err) == ENOSYS || (Err) == EINVAL || (Err) == EBUSY || (Err) == ENOENT)
+#elif defined EOPNOTSUPP /* Tru64 NFS */
+#define ACL_NOT_WELL_SUPPORTED(Err)                                     \
+  ((Err) == ENOTSUP || (Err) == ENOSYS || (Err) == EINVAL || (Err) == EBUSY || (Err) == EOPNOTSUPP)
+#elif defined WINDOWSNT
+#define ACL_NOT_WELL_SUPPORTED(Err)  ((Err) == ENOTSUP)
+#else
+#define ACL_NOT_WELL_SUPPORTED(Err)                                     \
+  ((Err) == ENOTSUP || (Err) == ENOSYS || (Err) == EINVAL || (Err) == EBUSY)
+#endif
+#endif  /* HAVE_POSIX_ACL */
 #include "systime.h"
 #include <allocator.h>
 #include <careadlinkat.h>
@@ -2011,7 +2030,7 @@ entries (depending on how Emacs was built).  */)
    {
 #ifdef HAVE_POSIX_ACL
      acl = acl_get_file (SDATA (encoded_file), ACL_TYPE_ACCESS);
-      if (acl == NULL && errno != ENOTSUP)
+      if (acl == NULL && !ACL_NOT_WELL_SUPPORTED (errno))
        report_file_error ("Getting ACL", Fcons (file, Qnil));
 #endif
    }
@@ -2055,7 +2074,7 @@ entries (depending on how Emacs was built).  */)
    {
      bool fail =
        acl_set_file (SDATA (encoded_newname), ACL_TYPE_ACCESS, acl) != 0;
-      if (fail && errno != ENOTSUP)
+      if (fail && !ACL_NOT_WELL_SUPPORTED (errno))
        report_file_error ("Setting ACL", Fcons (newname, Qnil));
      acl_free (acl);
@@ -2087,7 +2106,7 @@ entries (depending on how Emacs was built).  */)
 #ifdef HAVE_POSIX_ACL
      acl = acl_get_fd (ifd);
-      if (acl == NULL && errno != ENOTSUP)
+      if (acl == NULL && !ACL_NOT_WELL_SUPPORTED (errno))
        report_file_error ("Getting ACL", Fcons (file, Qnil));
 #endif
    }
@@ -2176,7 +2195,7 @@ entries (depending on how Emacs was built).  */)
  if (acl != NULL)
    {
      bool fail = acl_set_fd (ofd, acl) != 0;
-      if (fail && errno != ENOTSUP)
+      if (fail && !ACL_NOT_WELL_SUPPORTED (errno))
        report_file_error ("Setting ACL", Fcons (newname, Qnil));
      acl_free (acl);
@@ -3174,7 +3193,7 @@ support.  */)
      fail = (acl_set_file (SSDATA (encoded_absname), ACL_TYPE_ACCESS,
                            acl)
              != 0);
-      if (fail && errno != ENOTSUP)
+      if (fail && !ACL_NOT_WELL_SUPPORTED (errno))
        report_file_error ("Setting ACL", Fcons (absname, Qnil));
      acl_free (acl);
@@ -3449,7 +3468,7 @@ file_offset (Lisp_Object val)
  if (FLOATP (val))
    {
      double v = XFLOAT_DATA (val);
-      if (v >= 0
+      if (0 <= v
          && (sizeof (off_t) < sizeof v
              ? v <= TYPE_MAXIMUM (off_t)
              : v < TYPE_MAXIMUM (off_t)))
@@ -3958,7 +3977,7 @@ by calling `format-decode', which see.  */)
          /* If display currently starts at beginning of line,
             keep it that way.  */
-          if (XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
+          if (XBUFFER (XWINDOW (selected_window)->contents) == current_buffer)
            XWINDOW (selected_window)->start_at_line_beg = !NILP (Fbolp ());
          replace_handled = 1;
@@ -4108,7 +4127,7 @@ by calling `format-decode', which see.  */)
      /* If display currently starts at beginning of line,
         keep it that way.  */
-      if (XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
+      if (XBUFFER (XWINDOW (selected_window)->contents) == current_buffer)
        XWINDOW (selected_window)->start_at_line_beg = !NILP (Fbolp ());
      /* Replace the chars that we need to replace,
@@ -5816,7 +5835,7 @@ before any other event (mouse or keypress) is handled.  */)
  if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
      && use_dialog_box
      && use_file_dialog
-      && have_menus_p ())
+      && window_system_available (SELECTED_FRAME ()))
    return Qt;
 #endif
  return Qnil;
diff --git a/src/fns.c b/src/fns.c
index 82ce933b25d..86bdc0250dc 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2443,10 +2443,9 @@ is nil, and `use-dialog-box' is non-nil.  */)
  CHECK_STRING (prompt);
 #ifdef HAVE_MENUS
-  if (FRAME_WINDOW_P (SELECTED_FRAME ())
+  if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
-      && (NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
      && use_dialog_box
-      && have_menus_p ())
+      && window_system_available (SELECTED_FRAME ()))
    {
      Lisp_Object pane, menu, obj;
      redisplay_preserve_echo_area (4);
@@ -3409,7 +3408,7 @@ larger_vector (Lisp_Object vec, ptrdiff_t incr_min, ptrdiff_t nitems_max)
  ptrdiff_t n_max = (0 <= nitems_max && nitems_max < C_language_max
                     ? nitems_max : C_language_max);
  eassert (VECTORP (vec));
-  eassert (incr_min > 0 && nitems_max >= -1);
+  eassert (0 < incr_min && -1 <= nitems_max);
  old_size = ASIZE (vec);
  incr_max = n_max - old_size;
  incr = max (incr_min, min (old_size >> 1, incr_max));
@@ -3574,9 +3573,9 @@ make_hash_table (struct hash_table_test test,
  eassert (SYMBOLP (test.name));
  eassert (INTEGERP (size) && XINT (size) >= 0);
  eassert ((INTEGERP (rehash_size) && XINT (rehash_size) > 0)
-           || (FLOATP (rehash_size) && XFLOAT_DATA (rehash_size) > 1));
+           || (FLOATP (rehash_size) && 1 < XFLOAT_DATA (rehash_size)));
  eassert (FLOATP (rehash_threshold)
-           && XFLOAT_DATA (rehash_threshold) > 0
+           && 0 < XFLOAT_DATA (rehash_threshold)
           && XFLOAT_DATA (rehash_threshold) <= 1.0);
  if (XFASTINT (size) == 0)
@@ -4312,15 +4311,15 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
  /* Look for `:rehash-size SIZE'.  */
  i = get_key_arg (QCrehash_size, nargs, args, used);
  rehash_size = i ? args[i] : make_float (DEFAULT_REHASH_SIZE);
-  if (! ((INTEGERP (rehash_size) && XINT (rehash_size) > 0)
+  if (! ((INTEGERP (rehash_size) && 0 < XINT (rehash_size))
-         || (FLOATP (rehash_size) && XFLOAT_DATA (rehash_size) > 1)))
+         || (FLOATP (rehash_size) && 1 < XFLOAT_DATA (rehash_size))))
    signal_error ("Invalid hash table rehash size", rehash_size);
  /* Look for `:rehash-threshold THRESHOLD'.  */
  i = get_key_arg (QCrehash_threshold, nargs, args, used);
  rehash_threshold = i ? args[i] : make_float (DEFAULT_REHASH_THRESHOLD);
  if (! (FLOATP (rehash_threshold)
-         && XFLOAT_DATA (rehash_threshold) > 0
+         && 0 < XFLOAT_DATA (rehash_threshold)
         && XFLOAT_DATA (rehash_threshold) <= 1))
    signal_error ("Invalid hash table rehash threshold", rehash_threshold);
diff --git a/src/font.c b/src/font.c
index 357f8483b14..6247eeca948 100644
--- a/src/font.c
+++ b/src/font.c
@@ -229,7 +229,7 @@ font_intern_prop (const char *str, ptrdiff_t len, bool force_symbol)
  if (len == 1 && *str == '*')
    return Qnil;
-  if (!force_symbol && len > 0 && '0' <= *str && *str <= '9')
+  if (!force_symbol && 0 < len && '0' <= *str && *str <= '9')
    {
      for (i = 1; i < len; i++)
        if (! ('0' <= str[i] && str[i] <= '9'))
@@ -243,7 +243,7 @@ font_intern_prop (const char *str, ptrdiff_t len, bool force_symbol)
            {
              if (i == len)
                return make_number (n);
-              if (n > MOST_POSITIVE_FIXNUM / 10)
+              if (MOST_POSITIVE_FIXNUM / 10 < n)
                break;
            }
@@ -4761,7 +4761,7 @@ character at index specified by POSITION.  */)
  if (NILP (string))
    {
-      if (XBUFFER (w->buffer) != current_buffer)
+      if (XBUFFER (w->contents) != current_buffer)
        error ("Specified window is not displaying the current buffer.");
      CHECK_NUMBER_COERCE_MARKER (position);
      if (! (BEGV <= XINT (position) && XINT (position) < ZV))
@@ -4844,11 +4844,9 @@ If the named font is not yet loaded, return nil.  */)
  Lisp_Object info;
  Lisp_Object font_object;
-  (*check_window_system_func) ();
  if (! FONTP (name))
    CHECK_STRING (name);
-  f = decode_live_frame (frame);
+  f = decode_window_system_frame (frame);
  if (STRINGP (name))
    {
diff --git a/src/fontset.c b/src/fontset.c
index 3578bc9403d..2f6313c4214 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -179,10 +179,6 @@ static int next_fontset_id;
   font for each character.  */
 static Lisp_Object Vdefault_fontset;
-/* Check if any window system is used now.  */
-void (*check_window_system_func) (void);
 /* Prototype declarations for static functions.  */
 static Lisp_Object make_fontset (Lisp_Object, Lisp_Object, Lisp_Object);
@@ -1213,7 +1209,7 @@ If REGEXPP is non-nil, PATTERN is a regular expression.  */)
  Lisp_Object fontset;
  int id;
-  (*check_window_system_func) ();
+  check_window_system (NULL);
  CHECK_STRING (pattern);
@@ -1919,8 +1915,7 @@ format is the same as above.  */)
  Lisp_Object val, elt;
  int c, i, j, k;
-  (*check_window_system_func) ();
+  check_window_system (NULL);
  fontset = check_fontset_name (fontset, &frame);
  /* Recode fontsets realized on FRAME from the base fontset FONTSET
diff --git a/src/fontset.h b/src/fontset.h
index 07ee5d65c25..926520c8001 100644
--- a/src/fontset.h
+++ b/src/fontset.h
@@ -26,9 +26,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifndef EMACS_FONTSET_H
 #define EMACS_FONTSET_H
-/* Check if any window system is used now.  */
-extern void (*check_window_system_func) (void);
 struct face;
 extern void free_face_fontset (FRAME_PTR, struct face *);
diff --git a/src/frame.c b/src/frame.c
index cea39144cef..2fe398296ed 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -149,6 +149,37 @@ decode_any_frame (register Lisp_Object frame)
  return XFRAME (frame);
 }
+bool
+window_system_available (struct frame *f)
+{
+  if (f)
+    return FRAME_WINDOW_P (f) || FRAME_MSDOS_P (f);
+  else
+#ifdef HAVE_WINDOW_SYSTEM
+    return x_display_list != NULL;
+#else
+    return 0;
+#endif
+}
+struct frame *
+decode_window_system_frame (Lisp_Object frame)
+{
+  struct frame *f = decode_live_frame (frame);
+  
+  if (!window_system_available (f))
+    error ("Window system frame should be used");
+  return f;
+}
+void
+check_window_system (struct frame *f)
+{
+  if (!window_system_available (f))
+    error (f ? "Window system frame should be used"
+           : "Window system is not in use or not initialized");
+}
 static void
 set_menu_bar_lines_1 (Lisp_Object window, int n)
 {
@@ -159,15 +190,15 @@ set_menu_bar_lines_1 (Lisp_Object window, int n)
  w->total_lines -= n;
  /* Handle just the top child in a vertical split.  */
-  if (!NILP (w->vchild))
+  if (WINDOW_VERTICAL_COMBINATION_P (w))
-    set_menu_bar_lines_1 (w->vchild, n);
+    set_menu_bar_lines_1 (w->contents, n);
+  else if (WINDOW_HORIZONTAL_COMBINATION_P (w))
-  /* Adjust all children in a horizontal split.  */
+    /* Adjust all children in a horizontal split.  */
-  for (window = w->hchild; !NILP (window); window = w->next)
+    for (window = w->contents; !NILP (window); window = w->next)
-    {
+      {
-      w = XWINDOW (window);
+        w = XWINDOW (window);
-      set_menu_bar_lines_1 (window, n);
+        set_menu_bar_lines_1 (window, n);
-    }
+      }
 }
 void
@@ -421,7 +452,7 @@ make_frame_without_minibuffer (register Lisp_Object mini_window, KBOARD *kb, Lis
  /* Make the chosen minibuffer window display the proper minibuffer,
     unless it is already showing a minibuffer.  */
-  if (NILP (Fmemq (XWINDOW (mini_window)->buffer, Vminibuffer_list)))
+  if (NILP (Fmemq (XWINDOW (mini_window)->contents, Vminibuffer_list)))
    /* Use set_window_buffer instead of Fset_window_buffer (see
       discussion of bug#11984, bug#12025, bug#12026).  */
    set_window_buffer (mini_window,
@@ -889,7 +920,7 @@ DEFUN ("frame-list", Fframe_list, Sframe_list,
 /* Return CANDIDATE if it can be used as 'other-than-FRAME' frame on the
   same tty (for tty frames) or among frames which uses FRAME's keyboard.
   If MINIBUF is nil, do not consider minibuffer-only candidate.
-   If MINIBUF is `visible', do not consider an invisible candidate. 
+   If MINIBUF is `visible', do not consider an invisible candidate.
   If MINIBUF is a window, consider only its own frame and candidate now
   using that window as the minibuffer.
   If MINIBUF is 0, consider candidate if it is visible or iconified.
@@ -1189,7 +1220,7 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
      /* Use set_window_buffer instead of Fset_window_buffer (see
         discussion of bug#11984, bug#12025, bug#12026).  */
      set_window_buffer (sf->minibuffer_window,
-                         XWINDOW (minibuf_window)->buffer, 0, 0);
+                         XWINDOW (minibuf_window)->contents, 0, 0);
      minibuf_window = sf->minibuffer_window;
      /* If the dying minibuffer window was selected,
@@ -1593,17 +1624,13 @@ make_frame_visible_1 (Lisp_Object window)
 {
  struct window *w;
-  for (;!NILP (window); window = w->next)
+  for (; !NILP (window); window = w->next)
    {
      w = XWINDOW (window);
+      if (WINDOWP (w->contents))
-      if (!NILP (w->buffer))
+        make_frame_visible_1 (w->contents);
-        bset_display_time (XBUFFER (w->buffer), Fcurrent_time ());
+      else
+        bset_display_time (XBUFFER (w->contents), Fcurrent_time ());
-      if (!NILP (w->vchild))
-        make_frame_visible_1 (w->vchild);
-      if (!NILP (w->hchild))
-        make_frame_visible_1 (w->hchild);
    }
 }
@@ -1634,7 +1661,7 @@ displayed in the terminal.  */)
      /* Use set_window_buffer instead of Fset_window_buffer (see
         discussion of bug#11984, bug#12025, bug#12026).  */
      set_window_buffer (sf->minibuffer_window,
-                         XWINDOW (minibuf_window)->buffer, 0, 0);
+                         XWINDOW (minibuf_window)->contents, 0, 0);
      minibuf_window = sf->minibuffer_window;
    }
@@ -1665,7 +1692,7 @@ If omitted, FRAME defaults to the currently selected frame.  */)
      /* Use set_window_buffer instead of Fset_window_buffer (see
         discussion of bug#11984, bug#12025, bug#12026).  */
      set_window_buffer (sf->minibuffer_window,
-                         XWINDOW (minibuf_window)->buffer, 0, 0);
+                         XWINDOW (minibuf_window)->contents, 0, 0);
      minibuf_window = sf->minibuffer_window;
    }
@@ -3315,16 +3342,15 @@ x_set_alpha (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
      else if (FLOATP (item))
        {
          alpha = XFLOAT_DATA (item);
-          if (alpha < 0.0 || alpha > 1.0)
+          if (! (0 <= alpha && alpha <= 1.0))
            args_out_of_range (make_float (0.0), make_float (1.0));
        }
      else if (INTEGERP (item))
        {
          EMACS_INT ialpha = XINT (item);
-          if (ialpha < 0 || ialpha > 100)
+          if (! (0 <= ialpha && alpha <= 100))
            args_out_of_range (make_number (0), make_number (100));
-          else
+          alpha = ialpha / 100.0;
-            alpha = ialpha / 100.0;
        }
      else
        wrong_type_argument (Qnumberp, item);
@@ -3498,9 +3524,7 @@ and the class is `Emacs.CLASS.SUBCLASS'.  */)
  (Lisp_Object attribute, Lisp_Object class, Lisp_Object component,
   Lisp_Object subclass)
 {
-#ifdef HAVE_X_WINDOWS
+  check_window_system (NULL);
-  check_x ();
-#endif
  return xrdb_get_resource (check_x_display_info (Qnil)->xrdb,
                            attribute, class, component, subclass);
diff --git a/src/frame.h b/src/frame.h
index 32a6954024e..b69f19b7ef8 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -427,10 +427,6 @@ struct frame
  /* Width of bar cursor (if we are using that) for blink-off state.  */
  int blink_off_cursor_width;
-  /* Nonnegative if current redisplay should not do scroll computation
-     for lines beyond a certain vpos.  This is the vpos.  */
-  int scroll_bottom_vpos;
  /* Configured width of the scroll bar, in pixels and in characters.
     config_scroll_bar_cols tracks config_scroll_bar_width if the
     latter is positive; a zero value in config_scroll_bar_width means
@@ -785,7 +781,6 @@ typedef struct frame *FRAME_PTR;
 #define FRAME_DELETE_COST(f) (f)->delete_line_cost
 #define FRAME_INSERTN_COST(f) (f)->insert_n_lines_cost
 #define FRAME_DELETEN_COST(f) (f)->delete_n_lines_cost
-#define FRAME_SCROLL_BOTTOM_VPOS(f) (f)->scroll_bottom_vpos
 #define FRAME_FOCUS_FRAME(f) f->focus_frame
 /* This frame slot says whether scroll bars are currently enabled for frame F,
@@ -963,6 +958,7 @@ extern Lisp_Object Qnoelisp;
 extern struct frame *last_nonminibuf_frame;
 extern void set_menu_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
+extern struct frame *decode_window_system_frame (Lisp_Object);
 extern struct frame *decode_live_frame (Lisp_Object);
 extern struct frame *decode_any_frame (Lisp_Object);
 extern struct frame *make_initial_frame (void);
@@ -973,6 +969,8 @@ extern struct frame *make_frame_without_minibuffer (Lisp_Object,
                                                    struct kboard *,
                                                    Lisp_Object);
 #endif /* HAVE_WINDOW_SYSTEM */
+extern bool window_system_available (struct frame *);
+extern void check_window_system (struct frame *);
 extern void frame_make_pointer_invisible (void);
 extern void frame_make_pointer_visible (void);
 extern Lisp_Object delete_frame (Lisp_Object, Lisp_Object);
diff --git a/src/fringe.c b/src/fringe.c
index fa6f889ba69..f728cd6d5ff 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -699,7 +699,7 @@ get_logical_cursor_bitmap (struct window *w, Lisp_Object cursor)
 {
  Lisp_Object cmap, bm = Qnil;
-  if ((cmap = BVAR (XBUFFER (w->buffer), fringe_cursor_alist)), !NILP (cmap))
+  if ((cmap = BVAR (XBUFFER (w->contents), fringe_cursor_alist)), !NILP (cmap))
    {
      bm = Fassq (cursor, cmap);
      if (CONSP (bm))
@@ -736,7 +736,7 @@ get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, in
     If partial, lookup partial bitmap in default value if not found here.
     If not partial, or no partial spec is present, use non-partial bitmap.  */
-  if ((cmap = BVAR (XBUFFER (w->buffer), fringe_indicator_alist)), !NILP (cmap))
+  if ((cmap = BVAR (XBUFFER (w->contents), fringe_indicator_alist)), !NILP (cmap))
    {
      bm1 = Fassq (bitmap, cmap);
      if (CONSP (bm1))
@@ -963,7 +963,7 @@ update_window_fringes (struct window *w, int keep_current_p)
    return 0;
  if (!MINI_WINDOW_P (w)
-      && (ind = BVAR (XBUFFER (w->buffer), indicate_buffer_boundaries), !NILP (ind)))
+      && (ind = BVAR (XBUFFER (w->contents), indicate_buffer_boundaries), !NILP (ind)))
    {
      if (EQ (ind, Qleft) || EQ (ind, Qright))
        boundary_top = boundary_bot = arrow_top = arrow_bot = ind;
@@ -1004,7 +1004,7 @@ update_window_fringes (struct window *w, int keep_current_p)
            {
              if (top_ind_rn < 0 && row->visible_height > 0)
                {
-                  if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->buffer))
+                  if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->contents))
                      && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w, row))
                    row->indicate_bob_p = !NILP (boundary_top);
                  else
@@ -1014,7 +1014,7 @@ update_window_fringes (struct window *w, int keep_current_p)
              if (bot_ind_rn < 0)
                {
-                  if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->buffer))
+                  if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->contents))
                      && !MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row))
                    row->indicate_eob_p = !NILP (boundary_bot), bot_ind_rn = rn;
                  else if (y + row->height >= yb)
@@ -1024,7 +1024,7 @@ update_window_fringes (struct window *w, int keep_current_p)
        }
    }
-  empty_pos = BVAR (XBUFFER (w->buffer), indicate_empty_lines);
+  empty_pos = BVAR (XBUFFER (w->contents), indicate_empty_lines);
  if (!NILP (empty_pos) && !EQ (empty_pos, Qright))
    empty_pos = WINDOW_LEFT_FRINGE_WIDTH (w) == 0 ? Qright : Qleft;
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 595a7427c21..f83d8660fcc 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -543,7 +543,7 @@ get_utf8_string (const char *str)
      if (cp) g_free (cp);
      len = strlen (str);
-      if (nr_bad > (min (PTRDIFF_MAX, SIZE_MAX) - len - 1) / 4)
+      if ((min (PTRDIFF_MAX, SIZE_MAX) - len - 1) / 4 < nr_bad)
        memory_full (SIZE_MAX);
      up = utf8_str = xmalloc (len + nr_bad * 4 + 1);
      p = (unsigned char *)str;
diff --git a/src/image.c b/src/image.c
index 6da430bee73..2dae63a294f 100644
--- a/src/image.c
+++ b/src/image.c
@@ -889,7 +889,7 @@ or omitted means use the selected frame.  */)
  size = Qnil;
  if (valid_image_p (spec))
    {
-      struct frame *f = check_x_frame (frame);
+      struct frame *f = decode_window_system_frame (frame);
      ptrdiff_t id = lookup_image (f, spec);
      struct image *img = IMAGE_FROM_ID (f, id);
      int width = img->width + 2 * img->hmargin;
@@ -919,7 +919,7 @@ or omitted means use the selected frame.  */)
  mask = Qnil;
  if (valid_image_p (spec))
    {
-      struct frame *f = check_x_frame (frame);
+      struct frame *f = decode_window_system_frame (frame);
      ptrdiff_t id = lookup_image (f, spec);
      struct image *img = IMAGE_FROM_ID (f, id);
      if (img->mask)
@@ -942,7 +942,7 @@ or omitted means use the selected frame.  */)
  ext = Qnil;
  if (valid_image_p (spec))
    {
-      struct frame *f = check_x_frame (frame);
+      struct frame *f = decode_window_system_frame (frame);
      ptrdiff_t id = lookup_image (f, spec);
      struct image *img = IMAGE_FROM_ID (f, id);
      ext = img->lisp_data;
@@ -1550,7 +1550,7 @@ which is then usually a filename.  */)
  if (!(EQ (filter, Qnil) || FRAMEP (filter)))
    clear_image_caches (filter);
  else
-    clear_image_cache (check_x_frame (filter), Qt);
+    clear_image_cache (decode_window_system_frame (filter), Qt);
  return Qnil;
 }
@@ -1581,7 +1581,7 @@ FRAME t means refresh the image on all frames.  */)
        }
    }
  else
-    uncache_image (check_x_frame (frame), spec);
+    uncache_image (decode_window_system_frame (frame), spec);
  return Qnil;
 }
@@ -8138,6 +8138,7 @@ DEF_IMGLIB_FN (int, gdk_pixbuf_get_bits_per_sample, (const GdkPixbuf *));
 DEF_IMGLIB_FN (void, g_type_init, (void));
 DEF_IMGLIB_FN (void, g_object_unref, (gpointer));
+DEF_IMGLIB_FN (void, g_error_free, (GError *));
 Lisp_Object Qgdk_pixbuf, Qglib, Qgobject;
diff --git a/src/indent.c b/src/indent.c
index ac448532dd4..67796ab8a8f 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -56,11 +56,6 @@ static EMACS_INT last_known_column_modified;
 static ptrdiff_t current_column_1 (void);
 static ptrdiff_t position_indentation (ptrdiff_t);
-/* Cache of beginning of line found by the last call of
-   current_column. */
-static ptrdiff_t current_column_bol_cache;
 /* Get the display table to use for the current buffer.  */
 struct Lisp_Char_Table *
@@ -254,7 +249,7 @@ skip_invisible (ptrdiff_t pos, ptrdiff_t *next_boundary_p, ptrdiff_t to, Lisp_Ob
     the next property change */
  prop = Fget_char_property (position, Qinvisible,
                             (!NILP (window)
-                              && EQ (XWINDOW (window)->buffer, buffer))
+                              && EQ (XWINDOW (window)->contents, buffer))
                             ? window : buffer);
  inv_p = TEXT_PROP_MEANS_INVISIBLE (prop);
  /* When counting columns (window == nil), don't skip over ellipsis text.  */
@@ -439,11 +434,6 @@ current_column (void)
      col += post_tab;
    }
-  if (ptr == BEGV_ADDR)
-    current_column_bol_cache = BEGV;
-  else
-    current_column_bol_cache = BYTE_TO_CHAR (PTR_BYTE_POS (ptr));
  last_known_column = col;
  last_known_column_point = PT;
  last_known_column_modified = MODIFF;
@@ -476,7 +466,7 @@ check_display_width (ptrdiff_t pos, ptrdiff_t col, ptrdiff_t *endpos)
      if ((prop = Fplist_get (plist, QCwidth),
           RANGED_INTEGERP (0, prop, INT_MAX)))
        width = XINT (prop);
-      else if (FLOATP (prop) && XFLOAT_DATA (prop) >= 0
+      else if (FLOATP (prop) && 0 <= XFLOAT_DATA (prop)
               && XFLOAT_DATA (prop) <= INT_MAX)
        width = (int)(XFLOAT_DATA (prop) + 0.5);
      else if ((prop = Fplist_get (plist, QCalign_to),
@@ -525,7 +515,6 @@ scan_for_column (ptrdiff_t *endpos, EMACS_INT *goalcol, ptrdiff_t *prevcol)
  {
  ptrdiff_t opoint = PT, opoint_byte = PT_BYTE;
  scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
-  current_column_bol_cache = PT;
  scan = PT, scan_byte = PT_BYTE;
  SET_PT_BOTH (opoint, opoint_byte);
  next_boundary = scan;
@@ -1088,8 +1077,8 @@ static struct position val_compute_motion;
            : (window_width + window_left != frame_cols))
        where
-          window_width is XFASTINT (w->total_cols),
+          window_width is w->total_cols,
-          window_left is XFASTINT (w->left_col),
+          window_left is w->left_col,
          has_vertical_scroll_bars is
            WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
          and frame_cols = FRAME_COLS (XFRAME (window->frame))
@@ -1826,7 +1815,7 @@ vmotion (register ptrdiff_t from, register ptrdiff_t from_byte,
  /* If the window contains this buffer, use it for getting text properties.
     Otherwise use the current buffer as arg for doing that.  */
-  if (EQ (w->buffer, Fcurrent_buffer ()))
+  if (EQ (w->contents, Fcurrent_buffer ()))
    text_prop_object = window;
  else
    text_prop_object = Fcurrent_buffer ();
@@ -1979,14 +1968,14 @@ whether or not it is currently displayed in some window.  */)
  old_buffer = Qnil;
  GCPRO1 (old_buffer);
-  if (XBUFFER (w->buffer) != current_buffer)
+  if (XBUFFER (w->contents) != current_buffer)
    {
      /* Set the window's buffer temporarily to the current buffer.  */
-      old_buffer = w->buffer;
+      old_buffer = w->contents;
      old_charpos = marker_position (w->pointm);
      old_bytepos = marker_byte_position (w->pointm);
      wset_buffer (w, Fcurrent_buffer ());
-      set_marker_both (w->pointm, w->buffer,
+      set_marker_both (w->pointm, w->contents,
                       BUF_PT (current_buffer), BUF_PT_BYTE (current_buffer));
    }
@@ -2139,7 +2128,7 @@ whether or not it is currently displayed in some window.  */)
  if (BUFFERP (old_buffer))
    {
      wset_buffer (w, old_buffer);
-      set_marker_both (w->pointm, w->buffer,
+      set_marker_both (w->pointm, w->contents,
                       old_charpos, old_bytepos);
    }
diff --git a/src/insdel.c b/src/insdel.c
index a60fed0c32e..8029291cd68 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -983,6 +983,9 @@ insert_from_string_1 (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
 void
 insert_from_gap (ptrdiff_t nchars, ptrdiff_t nbytes, bool text_at_gap_tail)
 {
+  int ins_charpos = GPT;
+  int ins_bytepos = GPT_BYTE;
  if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
    nchars = nbytes;
@@ -1003,18 +1006,18 @@ insert_from_gap (ptrdiff_t nchars, ptrdiff_t nbytes, bool text_at_gap_tail)
  eassert (GPT <= GPT_BYTE);
-  adjust_overlays_for_insert (GPT - nchars, nchars);
+  adjust_overlays_for_insert (ins_charpos, nchars);
-  adjust_markers_for_insert (GPT - nchars, GPT_BYTE - nbytes,
+  adjust_markers_for_insert (ins_charpos, ins_bytepos,
-                             GPT, GPT_BYTE, 0);
+                             ins_charpos + nchars, ins_bytepos + nbytes, 0);
  if (buffer_intervals (current_buffer))
    {
-      offset_intervals (current_buffer, GPT - nchars, nchars);
+      offset_intervals (current_buffer, ins_charpos, nchars);
-      graft_intervals_into_buffer (NULL, GPT - nchars, nchars,
+      graft_intervals_into_buffer (NULL, ins_charpos, nchars,
                                   current_buffer, 0);
    }
-  if (! text_at_gap_tail && GPT - nchars < PT)
+  if (ins_charpos < PT)
    adjust_point (nchars, nbytes);
  check_markers ();
@@ -1798,7 +1801,7 @@ prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
  /* If we're modifying the buffer other than shown in a selected window,
     let redisplay consider other windows if this buffer is visible.  */
-  if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer
+  if (XBUFFER (XWINDOW (selected_window)->contents) != current_buffer
      && buffer_window_count (current_buffer))
    ++windows_or_buffers_changed;
diff --git a/src/keyboard.c b/src/keyboard.c
index d373935f3e4..eb9f93a4c7d 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -210,12 +210,6 @@ static EMACS_INT last_auto_save;
 /* The value of point when the last command was started.  */
 static ptrdiff_t last_point_position;
-/* The buffer that was current when the last command was started.  */
-static Lisp_Object last_point_position_buffer;
-/* The window that was selected when the last command was started.  */
-static Lisp_Object last_point_position_window;
 /* The frame in which the last input event occurred, or Qmacro if the
   last event came from a macro.  We use this to determine when to
   generate switch-frame events.  This may be cleared by functions
@@ -836,7 +830,7 @@ This function is called by the editor initialization to begin editing.  */)
  update_mode_lines = 1;
  if (command_loop_level
-      && current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
+      && current_buffer != XBUFFER (XWINDOW (selected_window)->contents))
    buffer = Fcurrent_buffer ();
  else
    buffer = Qnil;
@@ -1398,7 +1392,7 @@ command_loop_1 (void)
        Fkill_emacs (Qnil);
      /* Make sure the current window's buffer is selected.  */
-      set_buffer_internal (XBUFFER (XWINDOW (selected_window)->buffer));
+      set_buffer_internal (XBUFFER (XWINDOW (selected_window)->contents));
      /* Display any malloc warning that just came out.  Use while because
         displaying one warning can cause another.  */
@@ -1464,7 +1458,7 @@ command_loop_1 (void)
      /* A filter may have run while we were reading the input.  */
      if (! FRAME_LIVE_P (XFRAME (selected_frame)))
        Fkill_emacs (Qnil);
-      set_buffer_internal (XBUFFER (XWINDOW (selected_window)->buffer));
+      set_buffer_internal (XBUFFER (XWINDOW (selected_window)->contents));
      ++num_input_keys;
@@ -1495,7 +1489,7 @@ command_loop_1 (void)
        {
          struct buffer *b;
          XWINDOW (selected_window)->force_start = 0;
-          b = XBUFFER (XWINDOW (selected_window)->buffer);
+          b = XBUFFER (XWINDOW (selected_window)->contents);
          BUF_BEG_UNCHANGED (b) = BUF_END_UNCHANGED (b) = 0;
        }
@@ -1515,8 +1509,6 @@ command_loop_1 (void)
      prev_buffer = current_buffer;
      prev_modiff = MODIFF;
      last_point_position = PT;
-      last_point_position_window = selected_window;
-      XSETBUFFER (last_point_position_buffer, prev_buffer);
      /* By default, we adjust point to a boundary of a region that
         has such a property that should be treated intangible
@@ -5152,7 +5144,7 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
          if (STRINGP (string))
            string_info = Fcons (string, make_number (charpos));
          textpos = (w == XWINDOW (selected_window)
-                     && current_buffer == XBUFFER (w->buffer))
+                     && current_buffer == XBUFFER (w->contents))
            ? PT : marker_position (w->pointm);
          xret = wx;
@@ -9164,9 +9156,9 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                {
                  if (! FRAME_LIVE_P (XFRAME (selected_frame)))
                    Fkill_emacs (Qnil);
-                  if (XBUFFER (XWINDOW (selected_window)->buffer)
+                  if (XBUFFER (XWINDOW (selected_window)->contents)
                      != current_buffer)
-                    Fset_buffer (XWINDOW (selected_window)->buffer);
+                    Fset_buffer (XWINDOW (selected_window)->contents);
                }
              goto replay_sequence;
@@ -9214,9 +9206,9 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                 special-event-map, ...) might have switched the current buffer
                 or the selected window from under us in the mean time.  */
              if (fix_current_buffer
-                  && (XBUFFER (XWINDOW (selected_window)->buffer)
+                  && (XBUFFER (XWINDOW (selected_window)->contents)
                      != current_buffer))
-                Fset_buffer (XWINDOW (selected_window)->buffer);
+                Fset_buffer (XWINDOW (selected_window)->contents);
              current_binding = active_maps (first_event);
            }
@@ -9265,8 +9257,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                     not the current buffer.  If we're at the
                     beginning of a key sequence, switch buffers.  */
                  if (WINDOWP (window)
-                      && BUFFERP (XWINDOW (window)->buffer)
+                      && BUFFERP (XWINDOW (window)->contents)
-                      && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+                      && XBUFFER (XWINDOW (window)->contents) != current_buffer)
                    {
                      ASET (raw_keybuf, raw_keybuf_count, key);
                      raw_keybuf_count++;
@@ -9287,7 +9279,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                      if (! FRAME_LIVE_P (XFRAME (selected_frame)))
                        Fkill_emacs (Qnil);
-                      set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
+                      set_buffer_internal (XBUFFER (XWINDOW (window)->contents));
                      goto replay_sequence;
                    }
                }
@@ -11070,9 +11062,6 @@ syms_of_keyboard (void)
  Fset (Qinput_method_exit_on_first_char, Qnil);
  Fset (Qinput_method_use_echo_area, Qnil);
-  last_point_position_buffer = Qnil;
-  last_point_position_window = Qnil;
  {
    int i;
    int len = sizeof (head_table) / sizeof (head_table[0]);
diff --git a/src/keymap.c b/src/keymap.c
index 110c8f43729..c43d528b25b 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1556,8 +1556,8 @@ like in the respective argument of `key-binding'.  */)
      window = POSN_WINDOW (position);
      if (WINDOWP (window)
-          && BUFFERP (XWINDOW (window)->buffer)
+          && BUFFERP (XWINDOW (window)->contents)
-          && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+          && XBUFFER (XWINDOW (window)->contents) != current_buffer)
        {
          /* Arrange to go back to the original buffer once we're done
             processing the key sequence.  We don't use
@@ -1567,7 +1567,7 @@ like in the respective argument of `key-binding'.  */)
             things the same.
          */
          record_unwind_current_buffer ();
-          set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
+          set_buffer_internal (XBUFFER (XWINDOW (window)->contents));
        }
    }
@@ -2063,7 +2063,7 @@ For an approximate inverse of this, see `kbd'.  */)
    size += XINT (Flength (prefix));
  /* This has one extra element at the end that we don't pass to Fconcat.  */
-  if (size > min (PTRDIFF_MAX, SIZE_MAX) / word_size / 4)
+  if (min (PTRDIFF_MAX, SIZE_MAX) / word_size / 4 < size)
    memory_full (SIZE_MAX);
  SAFE_ALLOCA_LISP (args, size * 4);
diff --git a/src/lisp.h b/src/lisp.h
index 8187f7da993..175ec828c97 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -548,7 +548,7 @@ static EMACS_INT const VALMASK
   type or if I is a NaN.  */
 #define FIXNUM_OVERFLOW_P(i) \
-  (! (((i) >= 0 || (i) >= MOST_NEGATIVE_FIXNUM) && (i) <= MOST_POSITIVE_FIXNUM))
+  (! ((0 <= (i) || MOST_NEGATIVE_FIXNUM <= (i)) && (i) <= MOST_POSITIVE_FIXNUM))
 LISP_INLINE ptrdiff_t
 clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
@@ -557,11 +557,6 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
 }
-/* Forward declarations.  */
-LISP_INLINE bool SAVE_VALUEP (Lisp_Object);
-LISP_INLINE struct Lisp_Save_Value *XSAVE_VALUE (Lisp_Object);
 /* Extract a value or address from a Lisp_Object.  */
 #define XCONS(a)   (eassert (CONSP (a)), \
@@ -1492,53 +1487,6 @@ struct Lisp_Save_Value
    } data[SAVE_VALUE_SLOTS];
  };
-/* Return the type of V's Nth saved value.  */
-LISP_INLINE int
-save_type (struct Lisp_Save_Value *v, int n)
-{
-  eassert (0 <= n && n < SAVE_VALUE_SLOTS);
-  return (v->save_type >> (SAVE_SLOT_BITS * n) & ((1 << SAVE_SLOT_BITS) - 1));
-}
-/* Get and set the Nth saved pointer.  */
-LISP_INLINE void *
-XSAVE_POINTER (Lisp_Object obj, int n)
-{
-  eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_POINTER);
-  return XSAVE_VALUE (obj)->data[n].pointer;;
-}
-LISP_INLINE void
-set_save_pointer (Lisp_Object obj, int n, void *val)
-{
-  eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_POINTER);
-  XSAVE_VALUE (obj)->data[n].pointer = val;
-}
-/* Likewise for the saved integer.  */
-LISP_INLINE ptrdiff_t
-XSAVE_INTEGER (Lisp_Object obj, int n)
-{
-  eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_INTEGER);
-  return XSAVE_VALUE (obj)->data[n].integer;
-}
-LISP_INLINE void
-set_save_integer (Lisp_Object obj, int n, ptrdiff_t val)
-{
-  eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_INTEGER);
-  XSAVE_VALUE (obj)->data[n].integer = val;
-}
-/* Extract Nth saved object.  */
-LISP_INLINE Lisp_Object
-XSAVE_OBJECT (Lisp_Object obj, int n)
-{
-  eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_OBJECT);
-  return XSAVE_VALUE (obj)->data[n].object;
-}
 /* A miscellaneous object, when it's on the free list.  */
 struct Lisp_Free
  {
@@ -1560,13 +1508,6 @@ union Lisp_Misc
    struct Lisp_Save_Value u_save_value;
  };
-LISP_INLINE struct Lisp_Save_Value *
-XSAVE_VALUE (Lisp_Object a)
-{
-  eassert (SAVE_VALUEP (a));
-  return & XMISC (a)->u_save_value;
-}
 /* Forwarding pointer to an int variable.
   This is allowed only in the value cell of a symbol,
   and it means that the symbol's value really lives in the
@@ -1859,6 +1800,60 @@ SAVE_VALUEP (Lisp_Object x)
  return MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Save_Value;
 }
+LISP_INLINE struct Lisp_Save_Value *
+XSAVE_VALUE (Lisp_Object a)
+{
+  eassert (SAVE_VALUEP (a));
+  return & XMISC (a)->u_save_value;
+}
+/* Return the type of V's Nth saved value.  */
+LISP_INLINE int
+save_type (struct Lisp_Save_Value *v, int n)
+{
+  eassert (0 <= n && n < SAVE_VALUE_SLOTS);
+  return (v->save_type >> (SAVE_SLOT_BITS * n) & ((1 << SAVE_SLOT_BITS) - 1));
+}
+/* Get and set the Nth saved pointer.  */
+LISP_INLINE void *
+XSAVE_POINTER (Lisp_Object obj, int n)
+{
+  eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_POINTER);
+  return XSAVE_VALUE (obj)->data[n].pointer;;
+}
+LISP_INLINE void
+set_save_pointer (Lisp_Object obj, int n, void *val)
+{
+  eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_POINTER);
+  XSAVE_VALUE (obj)->data[n].pointer = val;
+}
+/* Likewise for the saved integer.  */
+LISP_INLINE ptrdiff_t
+XSAVE_INTEGER (Lisp_Object obj, int n)
+{
+  eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_INTEGER);
+  return XSAVE_VALUE (obj)->data[n].integer;
+}
+LISP_INLINE void
+set_save_integer (Lisp_Object obj, int n, ptrdiff_t val)
+{
+  eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_INTEGER);
+  XSAVE_VALUE (obj)->data[n].integer = val;
+}
+/* Extract Nth saved object.  */
+LISP_INLINE Lisp_Object
+XSAVE_OBJECT (Lisp_Object obj, int n)
+{
+  eassert (save_type (XSAVE_VALUE (obj), n) == SAVE_OBJECT);
+  return XSAVE_VALUE (obj)->data[n].object;
+}
 #define AUTOLOADP(x) (CONSP (x) && EQ (Qautoload, XCAR (x)))
 #define INTFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Int)
@@ -2570,7 +2565,7 @@ gc_aset (Lisp_Object array, ptrdiff_t idx, Lisp_Object val)
 LISP_INLINE void
 vcopy (Lisp_Object v, ptrdiff_t offset, Lisp_Object *args, ptrdiff_t count)
 {
-  eassert (offset >= 0 && count >= 0 && offset + count <= ASIZE (v));
+  eassert (0 <= offset && 0 <= count && offset + count <= ASIZE (v));
  memcpy (XVECTOR (v)->contents + offset, args, count * sizeof *args);
 }
@@ -3781,11 +3776,6 @@ extern void syms_of_xml (void);
 extern void xml_cleanup_parser (void);
 #endif
-#ifdef HAVE_MENUS
-/* Defined in (x|w32)fns.c, nsfns.m...  */
-extern int have_menus_p (void);
-#endif
 #ifdef HAVE_DBUS
 /* Defined in dbusbind.c.  */
 void syms_of_dbusbind (void);
diff --git a/src/lread.c b/src/lread.c
index d7a16f813c8..8e623e838c7 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -2636,7 +2636,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
            nskip--;
          else
            UNREAD (c);
-            
          if (load_force_doc_strings
              && (FROM_FILE_P (readcharfun)))
            {
@@ -2731,8 +2731,8 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
          /* Read a non-negative integer.  */
          while (c >= '0' && c <= '9')
            {
-              if (n > MOST_POSITIVE_FIXNUM / 10
+              if (MOST_POSITIVE_FIXNUM / 10 < n
-                  || n * 10 + c - '0' > MOST_POSITIVE_FIXNUM)
+                  || MOST_POSITIVE_FIXNUM < n * 10 + c - '0')
                n = MOST_POSITIVE_FIXNUM + 1;
              else
                n = n * 10 + c - '0';
@@ -2930,7 +2930,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
            if (end - p < MAX_MULTIBYTE_LENGTH)
              {
                ptrdiff_t offset = p - read_buffer;
-                if (read_buffer_size > min (PTRDIFF_MAX, SIZE_MAX) / 2)
+                if (min (PTRDIFF_MAX, SIZE_MAX) / 2 < read_buffer_size)
                  memory_full (SIZE_MAX);
                read_buffer = xrealloc (read_buffer, read_buffer_size * 2);
                read_buffer_size *= 2;
@@ -3064,7 +3064,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
              if (end - p < MAX_MULTIBYTE_LENGTH)
                {
                  ptrdiff_t offset = p - read_buffer;
-                  if (read_buffer_size > min (PTRDIFF_MAX, SIZE_MAX) / 2)
+                  if (min (PTRDIFF_MAX, SIZE_MAX) / 2 < read_buffer_size)
                    memory_full (SIZE_MAX);
                  read_buffer = xrealloc (read_buffer, read_buffer_size * 2);
                  read_buffer_size *= 2;
@@ -3094,7 +3094,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
          if (p == end)
            {
              ptrdiff_t offset = p - read_buffer;
-              if (read_buffer_size > min (PTRDIFF_MAX, SIZE_MAX) / 2)
+              if (min (PTRDIFF_MAX, SIZE_MAX) / 2 < read_buffer_size)
                memory_full (SIZE_MAX);
              read_buffer = xrealloc (read_buffer, read_buffer_size * 2);
              read_buffer_size *= 2;
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index 93f12900dde..aacc258cd11 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -873,6 +873,7 @@ $(BLD)/filelock.$(O) : \
        $(CHARACTER_H) \
        $(CODING_H) \
        $(CONFIG_H) \
+        $(C_CTYPE_H) \
        $(LISP_H) \
        $(SYSTIME_H)
@@ -1398,6 +1399,7 @@ $(BLD)/sysdep.$(O) : \
        $(NT_INC)/netdb.h \
        $(NT_INC)/pwd.h \
        $(NT_INC)/sys/file.h \
+        $(NT_INC)/sys/param.h \
        $(NT_INC)/sys/stat.h \
        $(NT_INC)/unistd.h \
        $(GNU_LIB)/execinfo.h \
diff --git a/src/menu.c b/src/menu.c
index ffb5c3bc936..58558d5aedd 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -1085,7 +1085,8 @@ no quit occurs and `x-popup-menu' returns nil.  */)
 #ifdef HAVE_MENUS
  {
    bool get_current_pos_p = 0;
-    /* FIXME!!  check_w32 (); or check_x (); or check_ns (); */
+    check_window_system (SELECTED_FRAME ());
    /* Decode the first argument: find the window and the coordinates.  */
    if (EQ (position, Qt)
diff --git a/src/minibuf.c b/src/minibuf.c
index 56459353714..68c39310f01 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -114,7 +114,7 @@ choose_minibuf_frame (void)
      /* Under X, we come here with minibuf_window being the
         minibuffer window of the unused termcap window created in
         init_window_once.  That window doesn't have a buffer.  */
-      buffer = XWINDOW (minibuf_window)->buffer;
+      buffer = XWINDOW (minibuf_window)->contents;
      if (BUFFERP (buffer))
        /* Use set_window_buffer instead of Fset_window_buffer (see
           discussion of bug#11984, bug#12025, bug#12026).  */
@@ -251,7 +251,7 @@ read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
        {
          if (len == size)
            {
-              if (size > STRING_BYTES_BOUND / 2)
+              if (STRING_BYTES_BOUND / 2 < size)
                memory_full (SIZE_MAX);
              size *= 2;
              line = xrealloc (line, size);
@@ -844,7 +844,7 @@ read_minibuf_unwind (Lisp_Object data)
  window = minibuf_window;
  /* To keep things predictable, in case it matters, let's be in the
     minibuffer when we reset the relevant variables.  */
-  Fset_buffer (XWINDOW (window)->buffer);
+  Fset_buffer (XWINDOW (window)->contents);
  /* Restore prompt, etc, from outer minibuffer level.  */
  minibuf_prompt = Fcar (minibuf_save_list);
diff --git a/src/msdos.c b/src/msdos.c
index ee47109d5f2..a2bcc06ac17 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -1261,7 +1261,7 @@ IT_update_begin (struct frame *f)
          /* If the mouse highlight is in the window that was deleted
             (e.g., if it was popped by completion), clear highlight
             unconditionally.  */
-          if (NILP (w->buffer))
+          if (NILP (w->contents))
            hlinfo->mouse_face_window = Qnil;
          else
            {
@@ -1271,7 +1271,7 @@ IT_update_begin (struct frame *f)
                  break;
            }
-          if (NILP (w->buffer) || i < w->desired_matrix->nrows)
+          if (NILP (w->contents) || i < w->desired_matrix->nrows)
            clear_mouse_face (hlinfo);
        }
    }
@@ -1321,7 +1321,7 @@ IT_frame_up_to_date (struct frame *f)
    new_cursor = frame_desired_cursor;
  else
    {
-      struct buffer *b = XBUFFER (sw->buffer);
+      struct buffer *b = XBUFFER (sw->contents);
      if (EQ (BVAR (b,cursor_type), Qt))
        new_cursor = frame_desired_cursor;
@@ -1920,7 +1920,7 @@ dos_get_saved_screen (char **screen, int *rows, int *cols)
 /* We are not X, but we can emulate it well enough for our needs... */
 void
-check_x (void)
+check_window_system (void)
 {
  if (! FRAME_MSDOS_P (SELECTED_FRAME ()))
    error ("Not running under a window system");
@@ -2983,11 +2983,6 @@ IT_menu_display (XMenu *menu, int y, int x, int pn, int *faces, int disp_help)
 /* --------------------------- X Menu emulation ---------------------- */
-/* Report availability of menus.  */
-int
-have_menus_p (void) {  return 1; }
 /* Create a brand new menu structure.  */
 XMenu *
diff --git a/src/nsfns.m b/src/nsfns.m
index 9c3051a8c6a..a483f847dec 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -107,43 +107,6 @@ static ptrdiff_t image_cache_refcount;
   ========================================================================== */
-void
-check_ns (void)
-{
- if (NSApp == nil)
-   error ("OpenStep is not in use or not initialized");
-}
-/* Nonzero if we can use mouse menus. */
-int
-have_menus_p (void)
-{
-  return NSApp != nil;
-}
-/* Extract a frame as a FRAME_PTR, defaulting to the selected frame
-   and checking validity for NS.  */
-static FRAME_PTR
-check_ns_frame (Lisp_Object frame)
-{
-  FRAME_PTR f;
-  if (NILP (frame))
-      f = SELECTED_FRAME ();
-  else
-    {
-      CHECK_LIVE_FRAME (frame);
-      f = XFRAME (frame);
-    }
-  if (! FRAME_NS_P (f))
-    error ("non-Nextstep frame used");
-  return f;
-}
 /* Let the user specify an Nextstep display with a frame.
   nil stands for the selected frame--or, if that is not an Nextstep frame,
   the first Nextstep display on the list.  */
@@ -619,7 +582,7 @@ ns_set_name_as_filename (struct frame *f)
 {
  NSView *view;
  Lisp_Object name, filename;
-  Lisp_Object buf = XWINDOW (f->selected_window)->buffer;
+  Lisp_Object buf = XWINDOW (f->selected_window)->contents;
  const char *title;
  NSAutoreleasePool *pool;
  struct gcpro gcpro1;
@@ -1145,8 +1108,6 @@ This function is an internal primitive--use `make-frame' instead.  */)
  Lisp_Object tfont, tfontsize;
  static int desc_ctr = 1;
-  check_ns ();
  /* x_get_arg modifies parms.  */
  parms = Fcopy_alist (parms);
@@ -1418,7 +1379,7 @@ DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
 FRAME nil means use the selected frame.  */)
     (Lisp_Object frame)
 {
-  struct frame *f = check_ns_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (f);
  if (dpyinfo->x_focus_frame != f)
@@ -1439,18 +1400,8 @@ DEFUN ("ns-popup-font-panel", Fns_popup_font_panel, Sns_popup_font_panel,
       doc: /* Pop up the font panel. */)
     (Lisp_Object frame)
 {
-  id fm;
+  struct frame *f = decode_window_system_frame (frame);
-  struct frame *f;
+  id fm = [NSFontManager sharedFontManager];
-  check_ns ();
-  fm = [NSFontManager sharedFontManager];
-  if (NILP (frame))
-    f = SELECTED_FRAME ();
-  else
-    {
-      CHECK_FRAME (frame);
-      f = XFRAME (frame);
-    }
  [fm setSelectedFont: ((struct nsfont_info *)f->output_data.ns->font)->nsfont
           isMultiple: NO];
@@ -1464,17 +1415,7 @@ DEFUN ("ns-popup-color-panel", Fns_popup_color_panel, Sns_popup_color_panel,
       doc: /* Pop up the color panel.  */)
     (Lisp_Object frame)
 {
-  struct frame *f;
+  check_window_system (NULL);
-  check_ns ();
-  if (NILP (frame))
-    f = SELECTED_FRAME ();
-  else
-    {
-      CHECK_FRAME (frame);
-      f = XFRAME (frame);
-    }
  [NSApp orderFrontColorPanel: NSApp];
  return Qnil;
 }
@@ -1503,7 +1444,7 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
  NSString *initS = NILP (init) || !STRINGP (init) ? nil :
    [NSString stringWithUTF8String: SSDATA (init)];
-  check_ns ();
+  check_window_system (NULL);
  if (fileDelegate == nil)
    fileDelegate = [EmacsFileDelegate new];
@@ -1594,11 +1535,10 @@ If OWNER is nil, Emacs is assumed.  */)
 {
  const char *value;
-  check_ns ();
+  check_window_system (NULL);
  if (NILP (owner))
    owner = build_string([ns_app_name UTF8String]);
  CHECK_STRING (name);
-/*fprintf (stderr, "ns-get-resource checking resource '%s'\n", SSDATA (name)); */
  value = ns_get_defaults_value (SSDATA (name));
@@ -1614,7 +1554,7 @@ If OWNER is nil, Emacs is assumed.
 If VALUE is nil, the default is removed.  */)
     (Lisp_Object owner, Lisp_Object name, Lisp_Object value)
 {
-  check_ns ();
+  check_window_system (NULL);
  if (NILP (owner))
    owner = build_string ([ns_app_name UTF8String]);
  CHECK_STRING (name);
@@ -1642,7 +1582,7 @@ DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
       doc: /* This function is a no-op.  It is only present for completeness.  */)
     (Lisp_Object display)
 {
-  check_ns ();
+  check_ns_display_info (display);
  /* This function has no real equivalent under NeXTstep.  Return nil to
     indicate this. */
  return Qnil;
@@ -1692,7 +1632,7 @@ If omitted or nil, the selected frame's display is used.  */)
 {
  int num;
-  check_ns ();
+  check_ns_display_info (display);
  num = [[NSScreen screens] count];
  return (num != 0) ? make_number (num) : Qnil;
@@ -1706,7 +1646,7 @@ DISPLAY should be a frame, the display name as a string, or a terminal ID.
 If omitted or nil, the selected frame's display is used.  */)
     (Lisp_Object display)
 {
-  check_ns ();
+  check_ns_display_info (display);
  return make_number ((int)
                     ([ns_get_screen (display) frame].size.height/(92.0/25.4)));
 }
@@ -1719,7 +1659,7 @@ DISPLAY should be a frame, the display name as a string, or a terminal ID.
 If omitted or nil, the selected frame's display is used.  */)
     (Lisp_Object display)
 {
-  check_ns ();
+  check_ns_display_info (display);
  return make_number ((int)
                     ([ns_get_screen (display) frame].size.width/(92.0/25.4)));
 }
@@ -1733,7 +1673,7 @@ DISPLAY should be a frame, the display name as a string, or a terminal ID.
 If omitted or nil, the selected frame's display is used.  */)
     (Lisp_Object display)
 {
-  check_ns ();
+  check_ns_display_info (display);
  switch ([ns_get_window (display) backingType])
    {
    case NSBackingStoreBuffered:
@@ -1759,7 +1699,8 @@ If omitted or nil, the selected frame's display is used.  */)
     (Lisp_Object display)
 {
  NSWindowDepth depth;
-  check_ns ();
+  
+  check_ns_display_info (display);
  depth = [ns_get_screen (display) depth];
  if ( depth == NSBestDepth (NSCalibratedWhiteColorSpace, 2, 2, YES, NULL))
@@ -1786,7 +1727,7 @@ DISPLAY should be a frame, the display name as a string, or a terminal ID.
 If omitted or nil, the selected frame's display is used.  */)
     (Lisp_Object display)
 {
-  check_ns ();
+  check_ns_display_info (display);
  switch ([ns_get_window (display) backingType])
    {
    case NSBackingStoreBuffered:
@@ -1836,11 +1777,10 @@ terminate Emacs if we can't open the connection.
 DEFUN ("x-close-connection", Fx_close_connection, Sx_close_connection,
       1, 1, 0,
       doc: /* Close the connection to the current Nextstep display server.
-The argument DISPLAY is currently ignored.  */)
+DISPLAY should be a frame, the display name as a string, or a terminal ID.  */)
     (Lisp_Object display)
 {
-  check_ns ();
+  check_ns_display_info (display);
-  /*ns_delete_terminal (dpyinfo->terminal); */
  [NSApp terminate: NSApp];
  return Qnil;
 }
@@ -1865,7 +1805,7 @@ DEFUN ("ns-hide-others", Fns_hide_others, Sns_hide_others,
       doc: /* Hides all applications other than Emacs.  */)
     (void)
 {
-  check_ns ();
+  check_window_system (NULL);
  [NSApp hideOtherApplications: NSApp];
  return Qnil;
 }
@@ -1878,7 +1818,7 @@ If ON is equal to `activate', Emacs is unhidden and becomes
 the active application.  */)
     (Lisp_Object on)
 {
-  check_ns ();
+  check_window_system (NULL);
  if (EQ (on, intern ("activate")))
    {
      [NSApp unhide: NSApp];
@@ -1897,7 +1837,7 @@ DEFUN ("ns-emacs-info-panel", Fns_emacs_info_panel, Sns_emacs_info_panel,
       doc: /* Shows the 'Info' or 'About' panel for Emacs.  */)
     (void)
 {
-  check_ns ();
+  check_window_system (NULL);
  [NSApp orderFrontStandardAboutPanel: nil];
  return Qnil;
 }
@@ -1975,7 +1915,7 @@ DEFUN ("ns-list-services", Fns_list_services, Sns_list_services, 0, 0, 0,
  NSMenu *svcs;
  id delegate;
-  check_ns ();
+  check_window_system (NULL);
  svcs = [[NSMenu alloc] initWithTitle: @"Services"];
  [NSApp setServicesMenu: svcs];
  [NSApp registerServicesMenuSendTypes: ns_send_types
@@ -2028,7 +1968,7 @@ there was no result.  */)
  char *utfStr;
  CHECK_STRING (service);
-  check_ns ();
+  check_window_system (NULL);
  utfStr = SSDATA (service);
  svcName = [NSString stringWithUTF8String: utfStr];
@@ -2152,7 +2092,7 @@ In case the execution fails, an error is signaled. */)
  NSEvent *nxev;
  CHECK_STRING (script);
-  check_ns ();
+  check_window_system (NULL);
  block_input ();
@@ -2201,15 +2141,6 @@ In case the execution fails, an error is signaled. */)
   ========================================================================== */
-/* called from image.c */
-FRAME_PTR
-check_x_frame (Lisp_Object frame)
-{
-  return check_ns_frame (frame);
-}
 /* called from frame.c */
 struct ns_display_info *
 check_x_display_info (Lisp_Object frame)
@@ -2235,7 +2166,7 @@ x_get_string_resource (XrmDatabase rdb, char *name, char *class)
  /* remove appname prefix; TODO: allow for !="Emacs" */
  char *toCheck = class + (!strncmp (class, "Emacs.", 6) ? 6 : 0);
  const char *res;
-  check_ns ();
+  check_window_system (NULL);
  if (inhibit_x_resources)
    /* --quick was passed, so this is a no-op.  */
@@ -2305,7 +2236,7 @@ DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
     (Lisp_Object color, Lisp_Object frame)
 {
  NSColor * col;
-  check_ns ();
+  check_window_system (NULL);
  return ns_lisp_to_color (color, &col) ? Qnil : Qt;
 }
@@ -2317,7 +2248,7 @@ DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
  NSColor * col;
  CGFloat red, green, blue, alpha;
-  check_ns ();
+  check_window_system (NULL);
  CHECK_STRING (color);
  if (ns_lisp_to_color (color, &col))
@@ -2336,7 +2267,8 @@ DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
 {
  NSWindowDepth depth;
  NSString *colorSpace;
-  check_ns ();
+  
+  check_ns_display_info (display);
  depth = [ns_get_screen (display) depth];
  colorSpace = NSColorSpaceFromDepth (depth);
@@ -2356,7 +2288,8 @@ If omitted or nil, that stands for the selected frame's display. */)
     (Lisp_Object display)
 {
  NSWindowDepth depth;
-  check_ns ();
+  check_ns_display_info (display);
  depth = [ns_get_screen (display) depth];
  return NSBitsPerPixelFromDepth (depth) > 1 ? Qt : Qnil;
@@ -2371,7 +2304,7 @@ DISPLAY should be either a frame, a display name (a string), or terminal ID.
 If omitted or nil, that stands for the selected frame's display.  */)
     (Lisp_Object display)
 {
-  check_ns ();
+  check_ns_display_info (display);
  return make_number ((int) [ns_get_screen (display) frame].size.width);
 }
@@ -2384,7 +2317,7 @@ DISPLAY should be either a frame, a display name (a string), or terminal ID.
 If omitted or nil, that stands for the selected frame's display.  */)
     (Lisp_Object display)
 {
-  check_ns ();
+  check_ns_display_info (display);
  return make_number ((int) [ns_get_screen (display) frame].size.height);
 }
@@ -2404,7 +2337,7 @@ that stands for the selected frame's display. */)
  NSScreen *screen;
  NSRect vScreen;
-  check_ns ();
+  check_ns_display_info (display);
  screen = ns_get_screen (display);
  if (!screen)
    return Qnil;
@@ -2428,7 +2361,7 @@ DISPLAY should be either a frame, a display name (a string), or terminal ID.
 If omitted or nil, that stands for the selected frame's display.  */)
     (Lisp_Object display)
 {
-  check_ns ();
+  check_ns_display_info (display);
  return make_number
    (NSBitsPerPixelFromDepth ([ns_get_screen (display) depth]));
 }
@@ -2442,10 +2375,7 @@ DISPLAY should be either a frame, a display name (a string), or terminal ID.
 If omitted or nil, that stands for the selected frame's display.  */)
     (Lisp_Object display)
 {
-  struct ns_display_info *dpyinfo;
+  struct ns_display_info *dpyinfo = check_ns_display_info (display);
-  check_ns ();
-  dpyinfo = check_ns_display_info (display);
  /* We force 24+ bit depths to 24-bit to prevent an overflow.  */
  return make_number (1 << min (dpyinfo->n_planes, 24));
 }
@@ -2558,7 +2488,7 @@ Text larger than the specified size is clipped.  */)
  CHECK_STRING (string);
  str = SSDATA (string);
-  f = check_x_frame (frame);
+  f = decode_window_system_frame (frame);
  if (NILP (timeout))
    timeout = make_number (5);
  else
@@ -2787,9 +2717,6 @@ be used as the image of the icon representing the frame.  */);
  defsubr (&Sx_show_tip);
  defsubr (&Sx_hide_tip);
-  /* used only in fontset.c */
-  check_window_system_func = check_ns;
  as_status = 0;
  as_script = Qnil;
  as_result = 0;
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 22ff4dd0b53..648b568d180 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -88,14 +88,6 @@ static int trackingMenu;
   ========================================================================== */
-/* FIXME: not currently used, but should normalize with other terms. */
-void
-x_activate_menubar (struct frame *f)
-{
-    fprintf (stderr, "XXX: Received x_activate_menubar event.\n");
-}
 /* Supposed to discard menubar and free storage.  Since we share the
   menubar among frames and update its context for the focused window,
   there is nothing to do here. */
@@ -138,7 +130,7 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
  long t;
 #endif
-  NSTRACE (set_frame_menubar);
+  NSTRACE (ns_update_menubar);
  if (f != SELECTED_FRAME ())
      return;
@@ -191,7 +183,7 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
        = alloca (previous_menu_items_used * sizeof *previous_items);
      /* lisp preliminaries */
-      buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer;
+      buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->contents;
      specbind (Qinhibit_quit, Qt);
      specbind (Qdebug_on_next_call, Qnil);
      record_unwind_save_match_data ();
@@ -512,6 +504,29 @@ set_frame_menubar (struct frame *f, bool first_time, bool deep_p)
  ns_update_menubar (f, deep_p, nil);
 }
+void
+x_activate_menubar (struct frame *f)
+{
+  NSArray *a = [[NSApp mainMenu] itemArray];
+  /* Update each submenu separately so ns_update_menubar doesn't reset
+     the delegate.  */
+  int i = 0;
+  while (i < [a count])
+    {
+      EmacsMenu *menu = (EmacsMenu *)[[a objectAtIndex:i] submenu];
+      const char *title = [[menu title] UTF8String];
+      if (strcmp (title, ns_get_pending_menu_title ()) == 0)
+        {
+          ns_update_menubar (f, true, menu);
+          break;
+        }
+      ++i;
+    }
+  ns_check_pending_open_menu ();
+}
 /* ==========================================================================
@@ -564,6 +579,14 @@ extern NSString *NSMenuDidBeginTrackingNotification;
  trackingMenu = ([notification name] == NSMenuDidBeginTrackingNotification
                  ? 1 : 0);
 }
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+- (void)menuWillOpen:(NSMenu *)menu
+{
+  ns_check_menu_open (menu);
+}
+#endif
 #endif
 /* delegate method called when a submenu is being opened: run a 'deep' call
@@ -591,7 +614,12 @@ extern NSString *NSMenuDidBeginTrackingNotification;
  if (trackingMenu == 0)
    return;
 /*fprintf (stderr, "Updating menu '%s'\n", [[self title] UTF8String]); NSLog (@"%@\n", event); */
-  ns_update_menubar (frame, 1, self);
+#if ! defined(NS_IMPL_COCOA) || \
+  MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5
+  /* Don't know how to do this for anything other than OSX >= 10.5
+     This is wrong, as it might run Lisp code in the event loop.  */
+  ns_update_menubar (frame, true, self);
+#endif
 }
@@ -1300,6 +1328,7 @@ update_frame_tool_bar (FRAME_PTR f)
  wr.size = [textField frame].size;
  [win setFrame: wr display: YES];
+  [win setLevel: NSPopUpMenuWindowLevel];
  [win orderFront: self];
  [win display];
  timer = [NSTimer scheduledTimerWithTimeInterval: (float)seconds target: self
@@ -1380,8 +1409,6 @@ ns_popup_dialog (Lisp_Object position, Lisp_Object contents, Lisp_Object header)
  NSTRACE (x-popup-dialog);
-  check_ns ();
  isQ = NILP (header);
  if (EQ (position, Qt)
@@ -1419,6 +1446,8 @@ ns_popup_dialog (Lisp_Object position, Lisp_Object contents, Lisp_Object header)
  else
    CHECK_WINDOW (window);
+  check_window_system (f);
  p.x = (int)f->left_pos + ((int)FRAME_COLUMN_WIDTH (f) * f->text_cols)/2;
  p.y = (int)f->top_pos + (FRAME_LINE_HEIGHT (f) * f->text_lines)/2;
diff --git a/src/nsselect.m b/src/nsselect.m
index 49380f87945..bb9eacd23cd 100644
--- a/src/nsselect.m
+++ b/src/nsselect.m
@@ -354,8 +354,7 @@ On Nextstep, FRAME is unused.  */)
  Lisp_Object successful_p = Qnil, rest;
  Lisp_Object target_symbol, data;
+  check_window_system (NULL);
-  check_ns ();
  CHECK_SYMBOL (selection);
  if (NILP (value))
      error ("selection value may not be nil.");
@@ -409,7 +408,7 @@ On MS-DOS, all this does is return non-nil if we own the selection.  */)
  (Lisp_Object selection, Lisp_Object time_object, Lisp_Object terminal)
 {
  id pb;
-  check_ns ();
+  check_window_system (NULL);
  CHECK_SYMBOL (selection);
  if (NILP (assq_no_quit (selection, Vselection_alist))) return Qnil;
@@ -436,7 +435,7 @@ On Nextstep, TERMINAL is unused.  */)
  id pb;
  NSArray *types;
-  check_ns ();
+  check_window_system (NULL);
  CHECK_SYMBOL (selection);
  if (EQ (selection, Qnil)) selection = QPRIMARY;
  if (EQ (selection, Qt)) selection = QSECONDARY;
@@ -464,7 +463,7 @@ frame's display, or the first available X display.
 On Nextstep, TERMINAL is unused.  */)
     (Lisp_Object selection, Lisp_Object terminal)
 {
-  check_ns ();
+  check_window_system (NULL);
  CHECK_SYMBOL (selection);
  if (EQ (selection, Qnil)) selection = QPRIMARY;
  if (EQ (selection, Qt)) selection = QSECONDARY;
@@ -492,7 +491,7 @@ On Nextstep, TIME-STAMP and TERMINAL are unused.  */)
 {
  Lisp_Object val;
-  check_ns ();
+  check_window_system (NULL);
  CHECK_SYMBOL (selection_name);
  CHECK_SYMBOL (target_type);
  val = ns_get_local_selection (selection_name, target_type);
@@ -516,7 +515,7 @@ SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'. */)
     (Lisp_Object selection)
 {
  id pb;
-  check_ns ();
+  check_window_system (NULL);
  pb = ns_symbol_to_pb (selection);
  return pb != nil ? ns_string_from_pasteboard (pb) : Qnil;
 }
@@ -529,7 +528,7 @@ SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'. */)
     (Lisp_Object selection, Lisp_Object string)
 {
  id pb;
-  check_ns ();
+  check_window_system (NULL);
  pb = ns_symbol_to_pb (selection);
  if (pb != nil) ns_string_to_pasteboard (pb, string);
  return Qnil;
diff --git a/src/nsterm.h b/src/nsterm.h
index 6bd04b96684..07cfc2e022e 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -577,8 +577,6 @@ extern Lisp_Object ns_display_name_list;
 extern struct ns_display_info *ns_display_info_for_name (Lisp_Object name);
 struct ns_display_info *check_x_display_info (Lisp_Object frame);
-FRAME_PTR check_x_frame (Lisp_Object frame);
 struct ns_output
 {
@@ -764,7 +762,6 @@ extern void ns_clear_frame (struct frame *f);
 extern const char *ns_xlfd_to_fontname (const char *xlfd);
-extern void check_ns (void);
 extern Lisp_Object ns_map_event_to_object (void);
 #ifdef __OBJC__
 extern Lisp_Object ns_string_from_pasteboard (id pb);
@@ -792,6 +789,9 @@ extern int ns_lisp_to_color (Lisp_Object color, NSColor **col);
 extern NSColor *ns_lookup_indexed_color (unsigned long idx, struct frame *f);
 extern unsigned long ns_index_color (NSColor *color, struct frame *f);
 extern void ns_free_indexed_color (unsigned long idx, struct frame *f);
+extern const char *ns_get_pending_menu_title ();
+extern void ns_check_menu_open (NSMenu *menu);
+extern void ns_check_pending_open_menu ();
 #endif
 /* C access to ObjC functionality */
diff --git a/src/nsterm.m b/src/nsterm.m
index 40e506eab27..f5b48ee4b11 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -228,6 +228,25 @@ static struct {
  NULL, 0, 0
 };
+/*
+ * State for pending menu activation:
+ * MENU_NONE     Normal state
+ * MENU_PENDING  A menu has been clicked on, but has been canceled so we can
+ *               run lisp to update the menu.
+ * MENU_OPENING  Menu is up to date, and the click event is redone so the menu
+ *               will open.
+ */
+#define MENU_NONE 0
+#define MENU_PENDING 1
+#define MENU_OPENING 2
+static int menu_will_open_state = MENU_NONE;
+/* Saved position for menu click.  */
+static CGPoint menu_mouse_point;
+/* Title for the menu to open.  */
+static char *menu_pending_title = 0;
 /* Convert modifiers in a NeXTstep event to emacs style modifiers.  */
 #define NS_FUNCTION_KEY_MASK 0x800000
 #define NSLeftControlKeyMask    (0x000001 | NSControlKeyMask)
@@ -993,8 +1012,9 @@ ns_raise_frame (struct frame *f)
     Bring window to foreground and make it active
   -------------------------------------------------------------------------- */
 {
-  NSView *view = FRAME_NS_VIEW (f);
+  NSView *view;
-  check_ns ();
+  check_window_system (f);
+  view = FRAME_NS_VIEW (f);
  block_input ();
  if (FRAME_VISIBLE_P (f))
    [[view window] makeKeyAndOrderFront: NSApp];
@@ -1008,8 +1028,9 @@ ns_lower_frame (struct frame *f)
     Send window to back
   -------------------------------------------------------------------------- */
 {
-  NSView *view = FRAME_NS_VIEW (f);
+  NSView *view;
-  check_ns ();
+  check_window_system (f);
+  view = FRAME_NS_VIEW (f);
  block_input ();
  [[view window] orderBack: NSApp];
  unblock_input ();
@@ -1112,9 +1133,10 @@ x_make_frame_invisible (struct frame *f)
     External: Hide the window (X11 semantics)
   -------------------------------------------------------------------------- */
 {
-  NSView * view = FRAME_NS_VIEW (f);
+  NSView *view;
  NSTRACE (x_make_frame_invisible);
-  check_ns ();
+  check_window_system (f);
+  view = FRAME_NS_VIEW (f);
  [[view window] orderOut: NSApp];
  SET_FRAME_VISIBLE (f, 0);
  SET_FRAME_ICONIFIED (f, 0);
@@ -1127,10 +1149,13 @@ x_iconify_frame (struct frame *f)
     External: Iconify window
   -------------------------------------------------------------------------- */
 {
-  NSView * view = FRAME_NS_VIEW (f);
+  NSView *view;
-  struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (f);
+  struct ns_display_info *dpyinfo;
  NSTRACE (x_iconify_frame);
-  check_ns ();
+  check_window_system (f);
+  view = FRAME_NS_VIEW (f);
+  dpyinfo = FRAME_NS_DISPLAY_INFO (f);
  if (dpyinfo->x_highlight_frame == f)
    dpyinfo->x_highlight_frame = 0;
@@ -1155,11 +1180,15 @@ x_iconify_frame (struct frame *f)
 void
 x_free_frame_resources (struct frame *f)
 {
-  NSView *view = FRAME_NS_VIEW (f);
+  NSView *view;
-  struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (f);
+  struct ns_display_info *dpyinfo;
-  Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
+  Mouse_HLInfo *hlinfo;
  NSTRACE (x_free_frame_resources);
-  check_ns ();
+  check_window_system (f);
+  view = FRAME_NS_VIEW (f);
+  dpyinfo = FRAME_NS_DISPLAY_INFO (f);
+  hlinfo = MOUSE_HL_INFO (f);
  [(EmacsView *)view setWindowClosing: YES]; /* may not have been informed */
@@ -1200,7 +1229,7 @@ x_destroy_window (struct frame *f)
   -------------------------------------------------------------------------- */
 {
  NSTRACE (x_destroy_window);
-  check_ns ();
+  check_window_system (f);
  x_free_frame_resources (f);
  ns_window_num--;
 }
@@ -1854,7 +1883,7 @@ ns_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
        f = dpyinfo->x_focus_frame ? dpyinfo->x_focus_frame
                                    : SELECTED_FRAME ();
-      if (f && f->output_data.ns)  /* TODO: 2nd check no longer needed? */
+      if (f && FRAME_NS_P (f))
        {
          view = FRAME_NS_VIEW (*fp);
@@ -3388,6 +3417,77 @@ check_native_fs ()
 }
 #endif
+const char *
+ns_get_pending_menu_title ()
+{
+  return menu_pending_title;
+}
+/* Check if menu open should be cancelled or continued as normal.  */
+void
+ns_check_menu_open (NSMenu *menu)
+{
+  /* GNUStep and OSX <= 10.4 does not have cancelTracking.  */
+#if defined(NS_IMPL_COCOA) && \
+  MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+  /* Click in menu bar? */
+  NSArray *a = [[NSApp mainMenu] itemArray];
+  int i;
+  BOOL found = NO;
+  for (i = 0; ! found && i < [a count]; i++)
+    found = menu == [[a objectAtIndex:i] submenu];
+  if (found)
+    {
+      if (menu_will_open_state == MENU_NONE && emacs_event)
+        {
+          NSEvent *theEvent = [NSApp currentEvent];
+          struct frame *emacsframe = SELECTED_FRAME ();
+          [menu cancelTracking];
+          menu_will_open_state = MENU_PENDING;
+          emacs_event->kind = MENU_BAR_ACTIVATE_EVENT;
+          EV_TRAILER (theEvent);
+          CGEventRef ourEvent = CGEventCreate (NULL);
+          menu_mouse_point = CGEventGetLocation (ourEvent);
+          CFRelease (ourEvent);
+          xfree (menu_pending_title);
+          menu_pending_title = xstrdup ([[menu title] UTF8String]);
+        }
+      else if (menu_will_open_state == MENU_OPENING)
+        {
+          menu_will_open_state = MENU_NONE;
+        }
+    }
+#endif
+}
+/* Redo saved menu click if state is MENU_PENDING.  */
+void
+ns_check_pending_open_menu ()
+{
+#ifdef NS_IMPL_COCOA
+  if (menu_will_open_state == MENU_PENDING)
+    {
+      CGEventSourceRef source
+        = CGEventSourceCreate (kCGEventSourceStateHIDSystemState);
+      CGEventRef event = CGEventCreateMouseEvent (source,
+                                                  kCGEventLeftMouseDown,
+                                                  menu_mouse_point,
+                                                  kCGMouseButtonLeft);
+      CGEventSetType (event, kCGEventLeftMouseDown);
+      CGEventPost (kCGHIDEventTap, event);
+      CFRelease (event);
+      CFRelease (source);
+      menu_will_open_state = MENU_OPENING;
+    }
+#endif
+}
 static int
 ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
 /* --------------------------------------------------------------------------
@@ -6532,7 +6632,7 @@ not_in_argv (NSString *arg)
 {
  Lisp_Object str = Qnil;
  struct frame *f = SELECTED_FRAME ();
-  struct buffer *curbuf = XBUFFER (XWINDOW (f->selected_window)->buffer);
+  struct buffer *curbuf = XBUFFER (XWINDOW (f->selected_window)->contents);
  if ([attribute isEqualToString:NSAccessibilityRoleAttribute])
    return NSAccessibilityTextFieldRole;
diff --git a/src/print.c b/src/print.c
index 8498a758a21..eb1f9cba82d 100644
--- a/src/print.c
+++ b/src/print.c
@@ -1778,10 +1778,10 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
          strout ("#<window ", -1, -1, printcharfun);
          len = sprintf (buf, "%p", XWINDOW (obj));
          strout (buf, len, len, printcharfun);
-          if (!NILP (XWINDOW (obj)->buffer))
+          if (BUFFERP (XWINDOW (obj)->contents))
            {
              strout (" on ", -1, -1, printcharfun);
-              print_string (BVAR (XBUFFER (XWINDOW (obj)->buffer), name),
+              print_string (BVAR (XBUFFER (XWINDOW (obj)->contents), name),
                            printcharfun);
            }
          PRINTCHAR ('>');
diff --git a/src/process.c b/src/process.c
index 6a14a536707..911a30bc808 100644
--- a/src/process.c
+++ b/src/process.c
@@ -4236,7 +4236,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
      time_limit = 0;
      nsecs = -1;
    }
-  else if (time_limit > TYPE_MAXIMUM (time_t))
+  else if (TYPE_MAXIMUM (time_t) < time_limit)
    time_limit = TYPE_MAXIMUM (time_t);
  /* Since we may need to wait several times,
diff --git a/src/search.c b/src/search.c
index ece346ecd06..ea36133deb7 100644
--- a/src/search.c
+++ b/src/search.c
@@ -2533,9 +2533,9 @@ since only regular expressions have distinguished subexpressions.  */)
      bool str_multibyte = STRING_MULTIBYTE (newtext);
      bool really_changed = 0;
-      substed_alloc_size = (length > (STRING_BYTES_BOUND - 100) / 2
+      substed_alloc_size = (length <= (STRING_BYTES_BOUND - 100) / 2
-                            ? STRING_BYTES_BOUND
+                            ? length * 2 + 100
-                            : length * 2 + 100);
+                            : STRING_BYTES_BOUND);
      substed = xmalloc (substed_alloc_size);
      substed_len = 0;
diff --git a/src/textprop.c b/src/textprop.c
index 2b454485370..cc364d5a38c 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -597,8 +597,9 @@ get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop,
  if (WINDOWP (object))
    {
+      CHECK_LIVE_WINDOW (object);
      w = XWINDOW (object);
-      object = w->buffer;
+      object = w->contents;
    }
  if (BUFFERP (object))
    {
diff --git a/src/w32fns.c b/src/w32fns.c
index 88141893445..5d3a78f8b95 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -95,10 +95,6 @@ static HWND hourglass_hwnd = NULL;
 #define IDC_HAND MAKEINTRESOURCE(32649)
 #endif
-/* Nonzero if using Windows.  */
-static int w32_in_use;
 Lisp_Object Qsuppress_icon;
 Lisp_Object Qundefined_color;
 Lisp_Object Qcancel_timer;
@@ -239,37 +235,6 @@ HINSTANCE hinst = NULL;
 static unsigned int sound_type = 0xFFFFFFFF;
 #define MB_EMACS_SILENT (0xFFFFFFFF - 1)
-/* Error if we are not connected to MS-Windows.  */
-void
-check_w32 (void)
-{
-  if (! w32_in_use)
-    error ("MS-Windows not in use or not initialized");
-}
-/* Nonzero if we can use mouse menus.
-   You should not call this unless HAVE_MENUS is defined.  */
-int
-have_menus_p (void)
-{
-  return w32_in_use;
-}
-/* Extract a frame as a FRAME_PTR, defaulting to the selected frame
-   and checking validity for W32.  */
-FRAME_PTR
-check_x_frame (Lisp_Object frame)
-{
-  struct frame *f = decode_live_frame (frame);
-  if (! FRAME_W32_P (f))
-    error ("Non-W32 frame used");
-  return f;
-}
 /* Let the user specify a display with a frame.
   nil stands for the selected frame--or, if that is not a w32 frame,
   the first display on the list.  */
@@ -3155,8 +3120,26 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
          form.ptCurrentPos.y = w32_system_caret_y;
          form.rcArea.left = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, 0);
+#ifdef ENABLE_CHECKING
+          /* Temporary code to catch crashes in computing form.rcArea.top.  */
+          {
+            int wmbp = WINDOW_MENU_BAR_P (w);
+            int wtbp = WINDOW_TOOL_BAR_P (w);
+            struct frame *wf = WINDOW_XFRAME (w);
+            int fibw = FRAME_INTERNAL_BORDER_WIDTH (wf);
+            int wtel = WINDOW_TOP_EDGE_LINE (w);
+            int wflh = FRAME_LINE_HEIGHT (wf);
+            int wwhlp= WINDOW_WANTS_HEADER_LINE_P (w);
+            int chlh = CURRENT_HEADER_LINE_HEIGHT (w);
+            int whlh = (wwhlp ? chlh : 0);
+            form.rcArea.top = ((wmbp || wtbp) ? 0 : fibw) + wtel * wflh + whlh;
+          }
+#else
          form.rcArea.top = (WINDOW_TOP_EDGE_Y (w)
                             + WINDOW_HEADER_LINE_HEIGHT (w));
+#endif
          form.rcArea.right = (WINDOW_BOX_RIGHT_EDGE_X (w)
                               - WINDOW_RIGHT_MARGIN_WIDTH (w)
                               - WINDOW_RIGHT_FRINGE_WIDTH (w));
@@ -4549,7 +4532,7 @@ DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
       doc: /* Give FRAME input focus, raising to foreground if necessary.  */)
  (Lisp_Object frame)
 {
-  x_focus_on_frame (check_x_frame (frame));
+  x_focus_on_frame (decode_window_system_frame (frame));
  return Qnil;
 }
@@ -4560,7 +4543,7 @@ DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
  (Lisp_Object color, Lisp_Object frame)
 {
  XColor foo;
-  FRAME_PTR f = check_x_frame (frame);
+  FRAME_PTR f = decode_window_system_frame (frame);
  CHECK_STRING (color);
@@ -4575,7 +4558,7 @@ DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
  (Lisp_Object color, Lisp_Object frame)
 {
  XColor foo;
-  FRAME_PTR f = check_x_frame (frame);
+  FRAME_PTR f = decode_window_system_frame (frame);
  CHECK_STRING (color);
@@ -4893,7 +4876,6 @@ x_display_info_for_name (Lisp_Object name)
  if (dpyinfo == 0)
    error ("Cannot connect to server %s", SDATA (name));
-  w32_in_use = 1;
  XSETFASTINT (Vwindow_system_version, w32_major_version);
  return dpyinfo;
@@ -4923,7 +4905,7 @@ terminate Emacs if we can't open the connection.
  /* If initialization has already been done, return now to avoid
     overwriting critical parts of one_w32_display_info.  */
-  if (w32_in_use)
+  if (window_system_available (NULL))
    return Qnil;
  if (! NILP (xrm_string))
@@ -4992,8 +4974,6 @@ terminate Emacs if we can't open the connection.
        error ("Cannot connect to server %s", SDATA (display));
    }
-  w32_in_use = 1;
  XSETFASTINT (Vwindow_system_version, w32_major_version);
  return Qnil;
 }
@@ -5077,7 +5057,7 @@ FRAME.  Default is to change on the edit X window.  */)
  (Lisp_Object prop, Lisp_Object value, Lisp_Object frame,
   Lisp_Object type, Lisp_Object format, Lisp_Object outer_p)
 {
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  Atom prop_atom;
  CHECK_STRING (prop);
@@ -5103,7 +5083,7 @@ DEFUN ("x-delete-window-property", Fx_delete_window_property,
 FRAME nil or omitted means use the selected frame.  Value is PROP.  */)
  (Lisp_Object prop, Lisp_Object frame)
 {
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  Atom prop_atom;
  CHECK_STRING (prop);
@@ -5139,7 +5119,7 @@ no value of TYPE (always string in the MS Windows case).  */)
  (Lisp_Object prop, Lisp_Object frame, Lisp_Object type,
   Lisp_Object source, Lisp_Object delete_p, Lisp_Object vector_ret_p)
 {
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  Atom prop_atom;
  int rc;
  Lisp_Object prop_value = Qnil;
@@ -5340,8 +5320,6 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
  Lisp_Object buffer;
  struct buffer *old_buffer;
-  check_w32 ();
  /* Use this general default value to start with until we know if
     this frame has a specified name.  */
  Vx_resource_name = Vinvocation_name;
@@ -5685,7 +5663,7 @@ Text larger than the specified size is clipped.  */)
  GCPRO4 (string, parms, frame, timeout);
  CHECK_STRING (string);
-  f = check_x_frame (frame);
+  f = decode_window_system_frame (frame);
  if (NILP (timeout))
    timeout = make_number (5);
  else
@@ -5792,13 +5770,13 @@ Text larger than the specified size is clipped.  */)
      w->total_lines = 40;
    }
-  FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
+  FRAME_TOTAL_COLS (f) = WINDOW_TOTAL_COLS (w);
  adjust_glyphs (f);
  w->pseudo_window_p = 1;
  /* Display the tooltip text in a temporary buffer.  */
  old_buffer = current_buffer;
-  set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
+  set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->contents));
  bset_truncate_lines (current_buffer, Qnil);
  clear_glyph_matrix (w->desired_matrix);
  clear_glyph_matrix (w->current_matrix);
@@ -6336,7 +6314,7 @@ screen saver if defined.
 If optional parameter FRAME is not specified, use selected frame.  */)
  (Lisp_Object command, Lisp_Object frame)
 {
-  FRAME_PTR f = check_x_frame (frame);
+  FRAME_PTR f = decode_window_system_frame (frame);
  CHECK_NUMBER (command);
@@ -7294,8 +7272,6 @@ void
 syms_of_w32fns (void)
 {
  globals_of_w32fns ();
-  /* This is zero if not using MS-Windows.  */
-  w32_in_use = 0;
  track_mouse_window = NULL;
  w32_visible_system_caret_hwnd = NULL;
@@ -7617,8 +7593,6 @@ only be necessary if the default setting causes problems.  */);
  defsubr (&Sdefault_printer_name);
  defsubr (&Sset_message_beep);
-  check_window_system_func = check_w32;
  hourglass_hwnd = NULL;
  defsubr (&Sx_show_tip);
diff --git a/src/w32font.c b/src/w32font.c
index fb52376b9e1..105daa06365 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -2467,7 +2467,7 @@ If EXCLUDE-PROPORTIONAL is non-nil, exclude proportional fonts
 in the font selection dialog. */)
  (Lisp_Object frame, Lisp_Object exclude_proportional)
 {
-  FRAME_PTR f = check_x_frame (frame);
+  FRAME_PTR f = decode_window_system_frame (frame);
  CHOOSEFONT cf;
  LOGFONT lf;
  TEXTMETRIC tm;
diff --git a/src/w32menu.c b/src/w32menu.c
index 03904cf20b8..346402b7c6b 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -140,8 +140,6 @@ otherwise it is "Question". */)
  FRAME_PTR f = NULL;
  Lisp_Object window;
-  check_w32 ();
  /* Decode the first argument: find the window or frame to use.  */
  if (EQ (position, Qt)
      || (CONSP (position) && (EQ (XCAR (position), Qmenu_bar)
@@ -194,6 +192,8 @@ otherwise it is "Question". */)
       but I don't want to make one now.  */
    CHECK_WINDOW (window);
+  check_window_system (f);
 #ifndef HAVE_DIALOGS
  {
@@ -396,7 +396,7 @@ set_frame_menubar (FRAME_PTR f, bool first_time, bool deep_p)
      if (! menubar_widget)
        previous_menu_items_used = 0;
-      buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer;
+      buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->contents;
      specbind (Qinhibit_quit, Qt);
      /* Don't let the debugger step into this code
         because it is not reentrant.  */
diff --git a/src/w32term.c b/src/w32term.c
index 5f7952c2ec2..d249d6e3252 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -5694,7 +5694,7 @@ w32fullscreen_hook (FRAME_PTR f)
      /* Need to send SC_RESTORE to the window, in case we are
         resizing from FULLSCREEN_MAXIMIZED.  Otherwise, the mouse
         resize hints will not be shown by the window manager when the
-         mouse pointer hovers over the window edges, becaise the WM
+         mouse pointer hovers over the window edges, because the WM
         will still think the window is maximized.  */
      if (f->want_fullscreen != FULLSCREEN_BOTH)
        SendMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, SC_RESTORE, 0);
diff --git a/src/w32term.h b/src/w32term.h
index b319f0ca592..9bb37b31ef5 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -203,7 +203,6 @@ extern void x_focus_on_frame (struct frame *f);
 extern struct w32_display_info *w32_term_init (Lisp_Object,
                                               char *, char *);
-extern void check_w32 (void);
 extern int w32_defined_color (FRAME_PTR f, const char *color,
                              XColor *color_def, int alloc);
 extern void x_set_window_size (struct frame *f, int change_grav,
@@ -740,7 +739,6 @@ struct image;
 struct face;
 XGCValues *XCreateGC (void *, Window, unsigned long, XGCValues *);
-struct frame * check_x_frame (Lisp_Object);
 typedef DWORD (WINAPI * ClipboardSequence_Proc) (void);
 typedef BOOL (WINAPI * AppendMenuW_Proc) (
diff --git a/src/window.c b/src/window.c
index a2e6a5a0602..77604f4ee19 100644
--- a/src/window.c
+++ b/src/window.c
@@ -148,11 +148,6 @@ wset_display_table (struct window *w, Lisp_Object val)
  w->display_table = val;
 }
 static void
-wset_hchild (struct window *w, Lisp_Object val)
-{
-  w->hchild = val;
-}
-static void
 wset_left_fringe_width (struct window *w, Lisp_Object val)
 {
  w->left_fringe_width = val;
@@ -218,11 +213,6 @@ wset_temslot (struct window *w, Lisp_Object val)
  w->temslot = val;
 }
 static void
-wset_vchild (struct window *w, Lisp_Object val)
-{
-  w->vchild = val;
-}
-static void
 wset_vertical_scroll_bar_type (struct window *w, Lisp_Object val)
 {
  w->vertical_scroll_bar_type = val;
@@ -232,6 +222,18 @@ wset_window_parameters (struct window *w, Lisp_Object val)
 {
  w->window_parameters = val;
 }
+static void
+wset_combination (struct window *w, bool horflag, Lisp_Object val)
+{
+  /* Since leaf windows never becomes non-leaf, there should
+     be no buffer and markers in start and pointm fields of W.  */
+  eassert (!BUFFERP (w->contents) && NILP (w->start) && NILP (w->pointm));
+  w->contents = val;
+  /* When an internal window is deleted and VAL is nil, HORFLAG
+     is meaningless.  */
+  if (!NILP (val))
+    w->horizontal = horflag;
+}
 struct window *
 decode_live_window (register Lisp_Object window)
@@ -276,9 +278,9 @@ static void
 adjust_window_count (struct window *w, int arg)
 {
  eassert (eabs (arg) == 1);
-  if (BUFFERP (w->buffer))
+  if (BUFFERP (w->contents))
    {
-      struct buffer *b = XBUFFER (w->buffer);
+      struct buffer *b = XBUFFER (w->contents);
      if (b->base_buffer)
        b = b->base_buffer;
@@ -297,7 +299,11 @@ void
 wset_buffer (struct window *w, Lisp_Object val)
 {
  adjust_window_count (w, -1);
-  w->buffer = val;
+  if (BUFFERP (val))
+    /* Make sure that we do not assign the buffer
+       to an internal window.  */
+    eassert (MARKERP (w->start) && MARKERP (w->pointm));
+  w->contents = val;
  adjust_window_count (w, 1);
 }
@@ -395,15 +401,8 @@ the first window of that frame.  */)
      window = XFRAME (frame_or_window)->root_window;
    }
-  while (NILP (XWINDOW (window)->buffer))
+  while (WINDOWP (XWINDOW (window)->contents))
-    {
+    window = XWINDOW (window)->contents;
-      if (! NILP (XWINDOW (window)->hchild))
-        window = XWINDOW (window)->hchild;
-      else if (! NILP (XWINDOW (window)->vchild))
-        window = XWINDOW (window)->vchild;
-      else
-        emacs_abort ();
-    }
  return window;
 }
@@ -490,11 +489,11 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
  if (NILP (norecord))
    {
      w->use_time = ++window_select_count;
-      record_buffer (w->buffer);
+      record_buffer (w->contents);
    }
  /* Make the selected window's buffer current.  */
-  Fset_buffer (w->buffer);
+  Fset_buffer (w->contents);
  if (EQ (window, selected_window) && !inhibit_point_swap)
    return window;
@@ -517,7 +516,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
  select_window_1 (window, inhibit_point_swap);
-  bset_last_selected_window (XBUFFER (w->buffer), window);
+  bset_last_selected_window (XBUFFER (w->contents), window);
  windows_or_buffers_changed++;
  return window;
 }
@@ -534,10 +533,10 @@ select_window_1 (Lisp_Object window, bool inhibit_point_swap)
  if (!inhibit_point_swap)
    {
      struct window *ow = XWINDOW (selected_window);
-      if (! NILP (ow->buffer))
+      if (BUFFERP (ow->contents))
-        set_marker_both (ow->pointm, ow->buffer,
+        set_marker_both (ow->pointm, ow->contents,
-                         BUF_PT (XBUFFER (ow->buffer)),
+                         BUF_PT (XBUFFER (ow->contents)),
-                         BUF_PT_BYTE (XBUFFER (ow->buffer)));
+                         BUF_PT_BYTE (XBUFFER (ow->contents)));
    }
  selected_window = window;
@@ -582,7 +581,8 @@ If WINDOW is omitted or nil, it defaults to the selected window.
 Return nil for an internal window or a deleted window.  */)
  (Lisp_Object window)
 {
-  return decode_any_window (window)->buffer;
+  struct window *w = decode_any_window (window);
+  return WINDOW_LEAF_P (w) ? w->contents : Qnil;
 }
 DEFUN ("window-parent", Fwindow_parent, Swindow_parent, 0, 1, 0,
@@ -602,7 +602,8 @@ Return nil if WINDOW is an internal window whose children form a
 horizontal combination.  */)
  (Lisp_Object window)
 {
-  return decode_valid_window (window)->vchild;
+  struct window *w = decode_valid_window (window);
+  return WINDOW_VERTICAL_COMBINATION_P (w) ? w->contents : Qnil;
 }
 DEFUN ("window-left-child", Fwindow_left_child, Swindow_left_child, 0, 1, 0,
@@ -613,7 +614,8 @@ Return nil if WINDOW is an internal window whose children form a
 vertical combination.  */)
  (Lisp_Object window)
 {
-  return decode_valid_window (window)->hchild;
+  struct window *w = decode_valid_window (window);
+  return WINDOW_HORIZONTAL_COMBINATION_P (w) ? w->contents : Qnil;
 }
 DEFUN ("window-next-sibling", Fwindow_next_sibling, Swindow_next_sibling, 0, 1, 0,
@@ -646,9 +648,9 @@ WINDOW are never \(re-)combined with WINDOW's siblings.  */)
  CHECK_VALID_WINDOW (window);
  w = XWINDOW (window);
-  if (!NILP (w->buffer))
+  if (WINDOW_LEAF_P (w))
    error ("Combination limit is meaningful for internal windows only");
-  return XWINDOW (window)->combination_limit;
+  return w->combination_limit;
 }
 DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
@@ -664,7 +666,7 @@ future use.  */)
  CHECK_VALID_WINDOW (window);
  w = XWINDOW (window);
-  if (!NILP (w->buffer))
+  if (WINDOW_LEAF_P (w))
    error ("Combination limit is meaningful for internal windows only");
  wset_combination_limit (w, limit);
  return limit;
@@ -861,7 +863,7 @@ set_window_hscroll (struct window *w, EMACS_INT hscroll)
  /* Prevent redisplay shortcuts when changing the hscroll.  */
  if (w->hscroll != new_hscroll)
-    XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
+    XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
  w->hscroll = new_hscroll;
  return make_number (new_hscroll);
@@ -1442,7 +1444,7 @@ correct to return the top-level value of `point', outside of any
  register struct window *w = decode_live_window (window);
  if (w == XWINDOW (selected_window))
-    return make_number (BUF_PT (XBUFFER (w->buffer)));
+    return make_number (BUF_PT (XBUFFER (w->contents)));
  else
    return Fmarker_position (w->pointm);
 }
@@ -1484,7 +1486,7 @@ if it isn't already recorded.  */)
  Lisp_Object buf;
  struct buffer *b;
-  buf = w->buffer;
+  buf = w->contents;
  CHECK_BUFFER (buf);
  b = XBUFFER (buf);
@@ -1547,7 +1549,7 @@ Return POS.  */)
  if (w == XWINDOW (selected_window))
    {
-      if (XBUFFER (w->buffer) == current_buffer)
+      if (XBUFFER (w->contents) == current_buffer)
        Fgoto_char (pos);
      else
        {
@@ -1555,14 +1557,14 @@ Return POS.  */)
          /* ... but here we want to catch type error before buffer change.  */
          CHECK_NUMBER_COERCE_MARKER (pos);
-          set_buffer_internal (XBUFFER (w->buffer));
+          set_buffer_internal (XBUFFER (w->contents));
          Fgoto_char (pos);
          set_buffer_internal (old_buffer);
        }
    }
  else
    {
-      set_marker_restricted (w->pointm, pos, w->buffer);
+      set_marker_restricted (w->pointm, pos, w->contents);
      /* We have to make sure that redisplay updates the window to show
         the new value of point.  */
      ++windows_or_buffers_changed;
@@ -1580,7 +1582,7 @@ overriding motion of point in order to display at this exact start.  */)
 {
  register struct window *w = decode_live_window (window);
-  set_marker_restricted (w->start, pos, w->buffer);
+  set_marker_restricted (w->start, pos, w->contents);
  /* This is not right, but much easier than doing what is right.  */
  w->start_at_line_beg = 0;
  if (NILP (noforce))
@@ -1624,7 +1626,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
  int x, y;
  w = decode_live_window (window);
-  buf = XBUFFER (w->buffer);
+  buf = XBUFFER (w->contents);
  SET_TEXT_POS_FROM_MARKER (top, w->start);
  if (EQ (pos, Qt))
@@ -1693,8 +1695,8 @@ Return nil if window display is not up-to-date.  In that case, use
  if (noninteractive || w->pseudo_window_p)
    return Qnil;
-  CHECK_BUFFER (w->buffer);
+  CHECK_BUFFER (w->contents);
-  b = XBUFFER (w->buffer);
+  b = XBUFFER (w->contents);
  /* Fail if current matrix is not up-to-date.  */
  if (!w->window_end_valid
@@ -1920,9 +1922,9 @@ window_display_table (struct window *w)
  if (DISP_TABLE_P (w->display_table))
    dp = XCHAR_TABLE (w->display_table);
-  else if (BUFFERP (w->buffer))
+  else if (BUFFERP (w->contents))
    {
-      struct buffer *b = XBUFFER (w->buffer);
+      struct buffer *b = XBUFFER (w->contents);
      if (DISP_TABLE_P (BVAR (b, display_table)))
        dp = XCHAR_TABLE (BVAR (b, display_table));
@@ -1947,17 +1949,14 @@ WINDOW must be a live window and defaults to the selected one.  */)
 static void
 unshow_buffer (register struct window *w)
 {
-  Lisp_Object buf;
+  Lisp_Object buf = w->contents;
-  struct buffer *b;
+  struct buffer *b = XBUFFER (buf);
-  buf = w->buffer;
+  eassert (b == XMARKER (w->pointm)->buffer);
-  b = XBUFFER (buf);
-  if (b != XMARKER (w->pointm)->buffer)
-    emacs_abort ();
 #if 0
  if (w == XWINDOW (selected_window)
-      || ! EQ (buf, XWINDOW (selected_window)->buffer))
+      || ! EQ (buf, XWINDOW (selected_window)->contents))
    /* Do this except when the selected window's buffer
       is being removed from some other window.  */
 #endif
@@ -1973,14 +1972,14 @@ unshow_buffer (register struct window *w)
  /* Point in the selected window's buffer
     is actually stored in that buffer, and the window's pointm isn't used.
     So don't clobber point in that buffer.  */
-  if (! EQ (buf, XWINDOW (selected_window)->buffer)
+  if (! EQ (buf, XWINDOW (selected_window)->contents)
      /* Don't clobber point in current buffer either (this could be
         useful in connection with bug#12208).
      && XBUFFER (buf) != current_buffer  */
      /* This line helps to fix Horsley's testbug.el bug.  */
      && !(WINDOWP (BVAR (b, last_selected_window))
           && w != XWINDOW (BVAR (b, last_selected_window))
-           && EQ (buf, XWINDOW (BVAR (b, last_selected_window))->buffer)))
+           && EQ (buf, XWINDOW (BVAR (b, last_selected_window))->contents)))
    temp_set_point_both (b,
                         clip_to_bounds (BUF_BEGV (b),
                                         marker_position (w->pointm),
@@ -2045,13 +2044,8 @@ replace_window (Lisp_Object old, Lisp_Object new, int setflag)
  tem = o->parent;
  wset_parent (n, tem);
-  if (!NILP (tem))
+  if (!NILP (tem) && EQ (XWINDOW (tem)->contents, old))
-    {
+    wset_combination (XWINDOW (tem), XWINDOW (tem)->horizontal, new);
-      if (EQ (XWINDOW (tem)->vchild, old))
-        wset_vchild (XWINDOW (tem), new);
-      if (EQ (XWINDOW (tem)->hchild, old))
-        wset_hchild (XWINDOW (tem), new);
-    }
 }
 /* If window WINDOW and its parent window are iso-combined, merge
@@ -2070,22 +2064,19 @@ recombine_windows (Lisp_Object window)
  if (!NILP (parent) && NILP (w->combination_limit))
    {
      p = XWINDOW (parent);
-      if (((!NILP (p->vchild) && !NILP (w->vchild))
+      if (WINDOWP (p->contents) && WINDOWP (w->contents)
-           || (!NILP (p->hchild) && !NILP (w->hchild))))
+          && p->horizontal == w->horizontal)
        /* WINDOW and PARENT are both either a vertical or a horizontal
           combination.  */
        {
-          horflag = NILP (w->vchild);
+          horflag = WINDOW_HORIZONTAL_COMBINATION_P (w);
-          child = horflag ? w->hchild : w->vchild;
+          child = w->contents;
          c = XWINDOW (child);
          /* Splice WINDOW's children into its parent's children and
             assign new normal sizes.  */
          if (NILP (w->prev))
-            if (horflag)
+            wset_combination (p, horflag, child);
-              wset_hchild (p, child);
-            else
-              wset_vchild (p, child);
          else
            {
              wset_prev (c, w->prev);
@@ -2123,8 +2114,7 @@ recombine_windows (Lisp_Object window)
            }
          /* WINDOW can be deleted now.  */
-          wset_vchild (w, Qnil);
+          wset_combination (w, 0, Qnil);
-          wset_hchild (w, Qnil);
        }
    }
 }
@@ -2210,7 +2200,7 @@ candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf
  struct frame *f = XFRAME (w->frame);
  int candidate_p = 1;
-  if (!BUFFERP (w->buffer))
+  if (!BUFFERP (w->contents))
    candidate_p = 0;
  else if (MINI_WINDOW_P (w)
           && (EQ (minibuf, Qlambda)
@@ -2550,7 +2540,7 @@ enum window_loop
  GET_BUFFER_WINDOW,                /* Arg is buffer */
  REPLACE_BUFFER_IN_WINDOWS_SAFELY, /* Arg is buffer */
  REDISPLAY_BUFFER_WINDOWS,         /* Arg is buffer */
-  CHECK_ALL_WINDOWS
+  CHECK_ALL_WINDOWS                 /* Arg is ignored */
 };
 static Lisp_Object
@@ -2614,7 +2604,7 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
        switch (type)
          {
          case GET_BUFFER_WINDOW:
-            if (EQ (w->buffer, obj)
+            if (EQ (w->contents, obj)
                /* Don't find any minibuffer window except the one that
                   is currently in use.  */
                && (MINI_WINDOW_P (w) ? EQ (window, minibuf_window) : 1))
@@ -2638,25 +2628,25 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
          case REPLACE_BUFFER_IN_WINDOWS_SAFELY:
            /* We could simply check whether the buffer shown by window
               is live, and show another buffer in case it isn't.  */
-            if (EQ (w->buffer, obj))
+            if (EQ (w->contents, obj))
              {
                /* Undedicate WINDOW.  */
                wset_dedicated (w, Qnil);
                /* Make WINDOW show the buffer returned by
                   other_buffer_safely, don't run any hooks.  */
                set_window_buffer
-                  (window, other_buffer_safely (w->buffer), 0, 0);
+                  (window, other_buffer_safely (w->contents), 0, 0);
                /* If WINDOW is the selected window, make its buffer
                   current.  But do so only if the window shows the
                   current buffer (Bug#6454).  */
                if (EQ (window, selected_window)
-                    && XBUFFER (w->buffer) == current_buffer)
+                    && XBUFFER (w->contents) == current_buffer)
-                  Fset_buffer (w->buffer);
+                  Fset_buffer (w->contents);
              }
            break;
          case REDISPLAY_BUFFER_WINDOWS:
-            if (EQ (w->buffer, obj))
+            if (EQ (w->contents, obj))
              {
                mark_window_display_accurate (window, 0);
                w->update_mode_line = 1;
@@ -2666,11 +2656,20 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
              }
            break;
-            /* Check for a window that has a killed buffer.  */
+            /* Check for a leaf window that has a killed buffer
+               or broken markers.  */
          case CHECK_ALL_WINDOWS:
-            if (! NILP (w->buffer)
+            if (BUFFERP (w->contents))
-                && !BUFFER_LIVE_P (XBUFFER (w->buffer)))
+              {
-              emacs_abort ();
+                struct buffer *b = XBUFFER (w->contents);
+                if (!BUFFER_LIVE_P (b))
+                  emacs_abort ();
+                if (!MARKERP (w->start) || XMARKER (w->start)->buffer != b)
+                  emacs_abort ();
+                if (!MARKERP (w->pointm) || XMARKER (w->pointm)->buffer != b)
+                  emacs_abort ();
+              }
            break;
          case WINDOW_LOOP_UNUSED:
@@ -2787,7 +2786,7 @@ window-start value is reasonable when this function is called.  */)
  else if (MINI_WINDOW_P (w)) /* && top > 0) */
    error ("Can't expand minibuffer to full frame");
-  if (!NILP (w->buffer))
+  if (BUFFERP (w->contents))
    {
      startpos = marker_position (w->start);
      startbyte = marker_byte_position (w->start);
@@ -2859,7 +2858,7 @@ window-start value is reasonable when this function is called.  */)
  FRAME_WINDOW_SIZES_CHANGED (f) = 1;
  resize_failed = 0;
-  if (NILP (w->buffer))
+  if (!WINDOW_LEAF_P (w))
    {
      /* Resize child windows vertically.  */
      XSETINT (delta, r->total_lines - w->total_lines);
@@ -2918,28 +2917,21 @@ window-start value is reasonable when this function is called.  */)
      sibling = w->next;
      s = XWINDOW (sibling);
      wset_prev (s, Qnil);
-      if (!NILP (XWINDOW (w->parent)->vchild))
+      wset_combination (XWINDOW (w->parent),
-        wset_vchild (XWINDOW (w->parent), sibling);
+                        XWINDOW (w->parent)->horizontal, sibling);
-      else
-        wset_hchild (XWINDOW (w->parent), sibling);
    }
  /* Delete ROOT and all child windows of ROOT.  */
-  if (!NILP (r->vchild))
+  if (WINDOWP (r->contents))
    {
-      delete_all_child_windows (r->vchild);
+      delete_all_child_windows (r->contents);
-      wset_vchild (r, Qnil);
+      wset_combination (r, 0, Qnil);
-    }
-  else if (!NILP (r->hchild))
-    {
-      delete_all_child_windows (r->hchild);
-      wset_hchild (r, Qnil);
    }
  replace_window (root, window, 1);
  /* This must become SWINDOW anyway ....... */
-  if (!NILP (w->buffer) && !resize_failed)
+  if (BUFFERP (w->contents) && !resize_failed)
    {
      /* Try to minimize scrolling, by setting the window start to the
         point will cause the text at the old window start to be at the
@@ -2948,18 +2940,18 @@ window-start value is reasonable when this function is called.  */)
         when the display is not current, due to typeahead).  */
      new_top = WINDOW_TOP_EDGE_LINE (w) - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
      if (new_top != top
-          && startpos >= BUF_BEGV (XBUFFER (w->buffer))
+          && startpos >= BUF_BEGV (XBUFFER (w->contents))
-          && startpos <= BUF_ZV (XBUFFER (w->buffer)))
+          && startpos <= BUF_ZV (XBUFFER (w->contents)))
        {
          struct position pos;
          struct buffer *obuf = current_buffer;
-          Fset_buffer (w->buffer);
+          Fset_buffer (w->contents);
          /* This computation used to temporarily move point, but that
             can have unwanted side effects due to text properties.  */
          pos = *vmotion (startpos, startbyte, -top, w);
-          set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
+          set_marker_both (w->start, w->contents, pos.bufpos, pos.bytepos);
          w->window_end_valid = 0;
          w->start_at_line_beg = (pos.bytepos == BEGV_BYTE
                                    || FETCH_BYTE (pos.bytepos - 1) == '\n');
@@ -3159,7 +3151,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
  struct window *w = XWINDOW (window);
  struct buffer *b = XBUFFER (buffer);
  ptrdiff_t count = SPECPDL_INDEX ();
-  int samebuf = EQ (buffer, w->buffer);
+  int samebuf = EQ (buffer, w->contents);
  wset_buffer (w, buffer);
@@ -3278,7 +3270,7 @@ This function runs `window-scroll-functions' before running
  if (!BUFFER_LIVE_P (XBUFFER (buffer)))
    error ("Attempt to display deleted buffer");
-  tem = w->buffer;
+  tem = w->contents;
  if (NILP (tem))
    error ("Window is deleted");
  else
@@ -3331,8 +3323,8 @@ displaying that buffer.  */)
      struct window *w = XWINDOW (object);
      mark_window_display_accurate (object, 0);
      w->update_mode_line = 1;
-      if (BUFFERP (w->buffer))
+      if (BUFFERP (w->contents))
-        XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
+        XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
      ++update_mode_lines;
      return Qt;
    }
@@ -3401,7 +3393,7 @@ temp_output_buffer_show (register Lisp_Object buf)
        record_unwind_protect (Fset_buffer, prev_buffer);
        record_unwind_protect (select_window_norecord, prev_window);
        Fselect_window (window, Qt);
-        Fset_buffer (w->buffer);
+        Fset_buffer (w->contents);
        Frun_hooks (1, &Qtemp_buffer_show_hook);
        unbind_to (count, Qnil);
      }
@@ -3422,7 +3414,7 @@ make_parent_window (Lisp_Object window, bool horflag)
  memcpy ((char *) p + sizeof (struct vectorlike_header),
          (char *) o + sizeof (struct vectorlike_header),
          word_size * VECSIZE (struct window));
-  /* P's buffer slot may change from nil to a buffer.  */
+  /* P's buffer slot may change from nil to a buffer...  */
  adjust_window_count (p, 1);
  XSETWINDOW (parent, p);
@@ -3431,12 +3423,11 @@ make_parent_window (Lisp_Object window, bool horflag)
  wset_next (o, Qnil);
  wset_prev (o, Qnil);
  wset_parent (o, parent);
+  /* ...but now P becomes an internal window.  */
-  wset_hchild (p, horflag ? window : Qnil);
-  wset_vchild (p, horflag ? Qnil : window);
  wset_start (p, Qnil);
  wset_pointm (p, Qnil);
  wset_buffer (p, Qnil);
+  wset_combination (p, horflag, window);
  wset_combination_limit (p, Qnil);
  wset_window_parameters (p, Qnil);
 }
@@ -3525,10 +3516,10 @@ window_resize_check (struct window *w, bool horflag)
 {
  struct window *c;
-  if (!NILP (w->vchild))
+  if (WINDOW_VERTICAL_COMBINATION_P (w))
    /* W is a vertical combination.  */
    {
-      c = XWINDOW (w->vchild);
+      c = XWINDOW (w->contents);
      if (horflag)
        /* All child windows of W must have the same width as W.  */
        {
@@ -3556,10 +3547,10 @@ window_resize_check (struct window *w, bool horflag)
          return (sum_of_sizes == XINT (w->new_total));
        }
    }
-  else if (!NILP (w->hchild))
+  else if (WINDOW_HORIZONTAL_COMBINATION_P (w))
    /* W is a horizontal combination.  */
    {
-      c = XWINDOW (w->hchild);
+      c = XWINDOW (w->contents);
      if (horflag)
        /* The sum of the widths of the child windows of W must equal W's
           width.  */
@@ -3626,10 +3617,10 @@ window_resize_apply (struct window *w, bool horflag)
      pos = w->top_line;
    }
-  if (!NILP (w->vchild))
+  if (WINDOW_VERTICAL_COMBINATION_P (w))
    /* W is a vertical combination.  */
    {
-      c = XWINDOW (w->vchild);
+      c = XWINDOW (w->contents);
      while (c)
        {
          if (horflag)
@@ -3642,10 +3633,10 @@ window_resize_apply (struct window *w, bool horflag)
          c = NILP (c->next) ? 0 : XWINDOW (c->next);
        }
    }
-  else if (!NILP (w->hchild))
+  else if (WINDOW_HORIZONTAL_COMBINATION_P (w))
    /* W is a horizontal combination.  */
    {
-      c = XWINDOW (w->hchild);
+      c = XWINDOW (w->contents);
      while (c)
        {
          if (horflag)
@@ -3728,7 +3719,7 @@ resize_frame_windows (struct frame *f, int size, bool horflag)
                        ? 1 : 0)));
  r->top_line = FRAME_TOP_MARGIN (f);
-  if (NILP (r->vchild) && NILP (r->hchild))
+  if (WINDOW_LEAF_P (r))
    /* For a leaf root window just set the size.  */
    if (horflag)
      r->total_cols = new_size;
@@ -3843,9 +3834,9 @@ set correctly.  See the code of `split-window' for how this is done.  */)
  combination_limit =
    EQ (Vwindow_combination_limit, Qt)
    || NILP (o->parent)
-    || NILP (horflag
+    || (horflag
-             ? (XWINDOW (o->parent)->hchild)
+        ? WINDOW_VERTICAL_COMBINATION_P (XWINDOW (o->parent))
-             : (XWINDOW (o->parent)->vchild));
+        : WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (o->parent)));
  /* We need a live reference window to initialize some parameters.  */
  if (WINDOW_LIVE_P (old))
@@ -3915,17 +3906,12 @@ set correctly.  See the code of `split-window' for how this is done.  */)
  n = XWINDOW (new);
  wset_frame (n, frame);
  wset_parent (n, o->parent);
-  wset_vchild (n, Qnil);
-  wset_hchild (n, Qnil);
  if (EQ (side, Qabove) || EQ (side, Qleft))
    {
      wset_prev (n, o->prev);
      if (NILP (n->prev))
-        if (horflag)
+        wset_combination (p, horflag, new);
-          wset_hchild (p, new);
-        else
-          wset_vchild (p, new);
      else
        wset_next (XWINDOW (n->prev), new);
      wset_next (n, old);
@@ -3974,7 +3960,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
  adjust_glyphs (f);
  /* Set buffer of NEW to buffer of reference window.  Don't run
     any hooks.  */
-  set_window_buffer (new, r->buffer, 0, 1);
+  set_window_buffer (new, r->contents, 0, 1);
  unblock_input ();
  /* Maybe we should run the scroll functions in Elisp (which already
@@ -3996,13 +3982,11 @@ Signal an error when WINDOW is the only window on its frame.  */)
  register Lisp_Object parent, sibling, frame, root;
  struct window *w, *p, *s, *r;
  struct frame *f;
-  bool horflag;
+  bool horflag, before_sibling = 0;
-  int before_sibling = 0;
  w = decode_any_window (window);
  XSETWINDOW (window, w);
-  if (NILP (w->buffer)
+  if (NILP (w->contents))
-      && NILP (w->hchild) && NILP (w->vchild))
    /* It's a no-op to delete an already deleted window.  */
    return Qnil;
@@ -4016,7 +4000,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
    error ("Attempt to delete sole window of parent");
  p = XWINDOW (parent);
-  horflag = NILP (p->vchild);
+  horflag = WINDOW_HORIZONTAL_COMBINATION_P (p);
  frame = WINDOW_FRAME (w);
  f = XFRAME (frame);
@@ -4034,10 +4018,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
      sibling = w->next;
      s = XWINDOW (sibling);
      wset_prev (s, Qnil);
-      if (horflag)
+      wset_combination (p, horflag, sibling);
-        wset_hchild (p, sibling);
-      else
-        wset_vchild (p, sibling);
    }
  else
    /* Get SIBLING above (on the left of) WINDOW.  */
@@ -4079,17 +4060,12 @@ Signal an error when WINDOW is the only window on its frame.  */)
      wset_next (w, Qnil);  /* Don't delete w->next too.  */
      free_window_matrices (w);
-      if (!NILP (w->vchild))
+      if (WINDOWP (w->contents))
        {
-          delete_all_child_windows (w->vchild);
+          delete_all_child_windows (w->contents);
-          wset_vchild (w, Qnil);
+          wset_combination (w, 0, Qnil);
        }
-      else if (!NILP (w->hchild))
+      else
-        {
-          delete_all_child_windows (w->hchild);
-          wset_hchild (w, Qnil);
-        }
-      else if (!NILP (w->buffer))
        {
          unshow_buffer (w);
          unchain_marker (XMARKER (w->pointm));
@@ -4108,8 +4084,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
          wset_normal_cols (s, p->normal_cols);
          wset_normal_lines (s, p->normal_lines);
          /* Mark PARENT as deleted.  */
-          wset_vchild (p, Qnil);
+          wset_combination (p, 0, Qnil);
-          wset_hchild (p, Qnil);
          /* Try to merge SIBLING into its new parent.  */
          recombine_windows (sibling);
        }
@@ -4157,10 +4132,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
      if (before_sibling)
        {
          wset_prev (s, window);
-          if (horflag)
+          wset_combination (p, horflag, window);
-            wset_hchild (p, window);
-          else
-            wset_vchild (p, window);
        }
      else
        {
@@ -4303,10 +4275,8 @@ mark_window_cursors_off (struct window *w)
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        mark_window_cursors_off (XWINDOW (w->hchild));
+        mark_window_cursors_off (XWINDOW (w->contents));
-      else if (!NILP (w->vchild))
-        mark_window_cursors_off (XWINDOW (w->vchild));
      else
        w->phys_cursor_on_p = 0;
@@ -4325,8 +4295,7 @@ window_internal_height (struct window *w)
  if (!MINI_WINDOW_P (w))
    {
      if (!NILP (w->parent)
-          || !NILP (w->vchild)
+          || WINDOWP (w->contents)
-          || !NILP (w->hchild)
          || !NILP (w->next)
          || !NILP (w->prev)
          || WINDOW_WANTS_MODELINE_P (w))
@@ -4465,7 +4434,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
                  else
                    spos = min (XINT (Fline_end_position (Qnil)) + 1, ZV);
                  set_marker_restricted (w->start, make_number (spos),
-                                         w->buffer);
+                                         w->contents);
                  w->start_at_line_beg = 1;
                  w->update_mode_line = 1;
                  w->last_modified = 0;
@@ -4589,7 +4558,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
      /* If control gets here, then we vscrolled.  */
-      XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
+      XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
      /* Don't try to change the window start below.  */
      vscrolled = 1;
@@ -4609,7 +4578,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
        }
      /* Set the window start, and set up the window for redisplay.  */
-      set_marker_restricted_both (w->start, w->buffer, IT_CHARPOS (it),
+      set_marker_restricted_both (w->start, w->contents, IT_CHARPOS (it),
                                  IT_BYTEPOS (it));
      bytepos = marker_byte_position (w->start);
      w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
@@ -4809,7 +4778,7 @@ window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
      int this_scroll_margin =
        max (0, min (scroll_margin, w->total_lines / 4));
-      set_marker_restricted_both (w->start, w->buffer, pos, pos_byte);
+      set_marker_restricted_both (w->start, w->contents, pos, pos_byte);
      w->start_at_line_beg = !NILP (bolp);
      w->update_mode_line = 1;
      w->last_modified = 0;
@@ -4903,10 +4872,10 @@ scroll_command (Lisp_Object n, int direction)
  /* If selected window's buffer isn't current, make it current for
     the moment.  But don't screw up if window_scroll gets an error.  */
-  if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
+  if (XBUFFER (XWINDOW (selected_window)->contents) != current_buffer)
    {
      record_unwind_protect (save_excursion_restore, save_excursion_save ());
-      Fset_buffer (XWINDOW (selected_window)->buffer);
+      Fset_buffer (XWINDOW (selected_window)->contents);
      /* Make redisplay consider other windows than just selected_window.  */
      ++windows_or_buffers_changed;
@@ -5021,7 +4990,7 @@ specifies the window to scroll.  This takes precedence over
  record_unwind_protect (save_excursion_restore, save_excursion_save ());
  ++windows_or_buffers_changed;
-  Fset_buffer (w->buffer);
+  Fset_buffer (w->contents);
  SET_PT_BOTH (marker_position (w->pointm), marker_byte_position (w->pointm));
  if (NILP (arg))
@@ -5115,10 +5084,10 @@ displayed_window_lines (struct window *w)
  int bottom_y;
  void *itdata = NULL;
-  if (XBUFFER (w->buffer) != current_buffer)
+  if (XBUFFER (w->contents) != current_buffer)
    {
      old_buffer = current_buffer;
-      set_buffer_internal (XBUFFER (w->buffer));
+      set_buffer_internal (XBUFFER (w->contents));
    }
  else
    old_buffer = NULL;
@@ -5180,7 +5149,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
  (register Lisp_Object arg)
 {
  struct window *w = XWINDOW (selected_window);
-  struct buffer *buf = XBUFFER (w->buffer);
+  struct buffer *buf = XBUFFER (w->contents);
  struct buffer *obuf = current_buffer;
  int center_p = 0;
  ptrdiff_t charpos, bytepos;
@@ -5346,7 +5315,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);
+  set_marker_both (w->start, w->contents, charpos, bytepos);
  w->window_end_valid = 0;
  w->optional_new_start = 1;
@@ -5390,9 +5359,8 @@ zero means top of window, negative means relative to bottom of window.  */)
  int this_scroll_margin;
 #endif
-  if (!(BUFFERP (w->buffer)
+  if (!(BUFFERP (w->contents) && XBUFFER (w->contents) == current_buffer))
-        && XBUFFER (w->buffer) == current_buffer))
+    /* This test is needed to make sure PT/PT_BYTE make sense in w->contents
-    /* This test is needed to make sure PT/PT_BYTE make sense in w->buffer
       when passed below to set_marker_both.  */
    error ("move-to-window-line called from unrelated buffer");
@@ -5402,7 +5370,7 @@ zero means top of window, negative means relative to bottom of window.  */)
    {
      int height = window_internal_height (w);
      Fvertical_motion (make_number (- (height / 2)), window);
-      set_marker_both (w->start, w->buffer, PT, PT_BYTE);
+      set_marker_both (w->start, w->contents, PT, PT_BYTE);
      w->start_at_line_beg = !NILP (Fbolp ());
      w->force_start = 1;
    }
@@ -5552,9 +5520,9 @@ the return value is nil.  Otherwise the value is t.  */)
           window-point of the final-selected-window to the window-point of
           the current-selected-window.  So we have to be careful which
           point of the current-buffer we copy into old_point.  */
-        if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer)
+        if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer)
            && WINDOWP (selected_window)
-            && EQ (XWINDOW (selected_window)->buffer, new_current_buffer)
+            && EQ (XWINDOW (selected_window)->contents, new_current_buffer)
            && !EQ (selected_window, data->current_window))
          old_point = marker_position (XWINDOW (data->current_window)->pointm);
        else
@@ -5568,7 +5536,7 @@ the return value is nil.  Otherwise the value is t.  */)
           So if possible we want this arbitrary choice of "which point" to
           be the one from the to-be-selected-window so as to prevent this
           window's cursor from being copied from another window.  */
-        if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer)
+        if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer)
            /* If current_window = selected_window, its point is in BUF_PT.  */
            && !EQ (selected_window, data->current_window))
          old_point = marker_position (XWINDOW (data->current_window)->pointm);
@@ -5610,8 +5578,8 @@ the return value is nil.  Otherwise the value is t.  */)
          p = SAVED_WINDOW_N (saved_windows, k);
          window = p->window;
          w = XWINDOW (window);
-          if (!NILP (w->buffer)
+          if (BUFFERP (w->contents)
-              && !EQ (w->buffer, p->buffer)
+              && !EQ (w->contents, p->buffer)
              && BUFFER_LIVE_P (XBUFFER (p->buffer)))
            /* If a window we restore gets another buffer, record the
               window's old buffer.  */
@@ -5644,13 +5612,13 @@ the return value is nil.  Otherwise the value is t.  */)
         window holds garbage.)  We do this now, before
         restoring the window contents, and prevent it from
         being done later on when we select a new window.  */
-      if (! NILP (XWINDOW (selected_window)->buffer))
+      if (! NILP (XWINDOW (selected_window)->contents))
        {
          w = XWINDOW (selected_window);
          set_marker_both (w->pointm,
-                           w->buffer,
+                           w->contents,
-                           BUF_PT (XBUFFER (w->buffer)),
+                           BUF_PT (XBUFFER (w->contents)),
-                           BUF_PT_BYTE (XBUFFER (w->buffer)));
+                           BUF_PT_BYTE (XBUFFER (w->contents)));
        }
      windows_or_buffers_changed++;
@@ -5697,18 +5665,10 @@ the return value is nil.  Otherwise the value is t.  */)
            {
              wset_prev (w, Qnil);
              if (!NILP (w->parent))
-                {
+                wset_combination (XWINDOW (w->parent),
-                  if (XINT (p->total_cols) == XWINDOW (w->parent)->total_cols)
+                                  (XINT (p->total_cols)
-                    {
+                                   != XWINDOW (w->parent)->total_cols),
-                      wset_vchild (XWINDOW (w->parent), p->window);
+                                  p->window);
-                      wset_hchild (XWINDOW (w->parent), Qnil);
-                    }
-                  else
-                    {
-                      wset_hchild (XWINDOW (w->parent), p->window);
-                      wset_vchild (XWINDOW (w->parent), Qnil);
-                    }
-                }
            }
          /* If we squirreled away the buffer, restore it now.  */
@@ -5757,20 +5717,16 @@ the return value is nil.  Otherwise the value is t.  */)
          w->last_modified = 0;
          w->last_overlay_modified = 0;
-          /* Reinstall the saved buffer and pointers into it.  */
+          if (BUFFERP (p->buffer) && BUFFER_LIVE_P (XBUFFER (p->buffer)))
-          if (NILP (p->buffer))
-            /* An internal window.  */
-            wset_buffer (w, p->buffer);
-          else if (BUFFER_LIVE_P (XBUFFER (p->buffer)))
            /* If saved buffer is alive, install it.  */
            {
              wset_buffer (w, p->buffer);
              w->start_at_line_beg = !NILP (p->start_at_line_beg);
-              set_marker_restricted (w->start, p->start, w->buffer);
+              set_marker_restricted (w->start, p->start, w->contents);
              set_marker_restricted (w->pointm, p->pointm,
-                                     w->buffer);
+                                     w->contents);
-              Fset_marker (BVAR (XBUFFER (w->buffer), mark),
+              Fset_marker (BVAR (XBUFFER (w->contents), mark),
-                           p->mark, w->buffer);
+                           p->mark, w->contents);
              /* As documented in Fcurrent_window_configuration, don't
                 restore the location of point in the buffer which was
@@ -5779,23 +5735,21 @@ the return value is nil.  Otherwise the value is t.  */)
                  && XBUFFER (p->buffer) == current_buffer)
                Fgoto_char (w->pointm);
             }
-           else if (!NILP (w->buffer)
+          else if (BUFFERP (w->contents) && BUFFER_LIVE_P (XBUFFER (w->contents)))
-                    && BUFFER_LIVE_P (XBUFFER (w->buffer)))
+            /* Keep window's old buffer; make sure the markers are real.  */
-             /* 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 window markers at start of visible range.  */
+                set_marker_restricted_both (w->start, w->contents, 0, 0);
-               if (XMARKER (w->start)->buffer == 0)
+              if (XMARKER (w->pointm)->buffer == 0)
-                 set_marker_restricted_both (w->start, w->buffer, 0, 0);
+                set_marker_restricted_both
-               if (XMARKER (w->pointm)->buffer == 0)
+                  (w->pointm, w->contents,
-                 set_marker_restricted_both
+                   BUF_PT (XBUFFER (w->contents)),
-                   (w->pointm, w->buffer,
+                   BUF_PT_BYTE (XBUFFER (w->contents)));
-                    BUF_PT (XBUFFER (w->buffer)),
+              w->start_at_line_beg = 1;
-                    BUF_PT_BYTE (XBUFFER (w->buffer)));
+            }
-               w->start_at_line_beg = 1;
+          else if (!NILP (w->start))
-             }
+            /* Leaf window has no live buffer, get one.  */
-          else
-            /* Window has no live buffer, get one.  */
            {
              /* Get the buffer via other_buffer_safely in order to
              avoid showing an unimportant buffer and, if necessary, to
@@ -5804,8 +5758,8 @@ the return value is nil.  Otherwise the value is t.  */)
              wset_buffer (w, other_buffer_safely (Fcurrent_buffer ()));
              /* This will set the markers to beginning of visible
                 range.  */
-              set_marker_restricted_both (w->start, w->buffer, 0, 0);
+              set_marker_restricted_both (w->start, w->contents, 0, 0);
-              set_marker_restricted_both (w->pointm, w->buffer, 0, 0);
+              set_marker_restricted_both (w->pointm, w->contents, 0, 0);
              w->start_at_line_beg = 1;
              if (!NILP (w->dedicated))
                /* Record this window as dead.  */
@@ -5818,17 +5772,17 @@ the return value is nil.  Otherwise the value is t.  */)
      fset_root_window (f, 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))
+      if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer))
        set_marker_restricted (XWINDOW (data->current_window)->pointm,
                               make_number (old_point),
-                               XWINDOW (data->current_window)->buffer);
+                               XWINDOW (data->current_window)->contents);
      /* In the following call to `select-window', prevent "swapping out
         point" in the old selected window using the buffer that has
         been restored into it.  We already swapped out that point from
         that window's old buffer.  */
      select_window (data->current_window, Qnil, 1);
-      BVAR (XBUFFER (XWINDOW (selected_window)->buffer), last_selected_window)
+      BVAR (XBUFFER (XWINDOW (selected_window)->contents), last_selected_window)
        = selected_window;
      if (NILP (data->focus_frame)
@@ -5855,14 +5809,9 @@ the return value is nil.  Otherwise the value is t.  */)
      /* Now, free glyph matrices in windows that were not reused.  */
      for (i = n = 0; i < n_leaf_windows; ++i)
        {
-          if (NILP (leaf_windows[i]->buffer))
+          if (NILP (leaf_windows[i]->contents))
-            {
+            free_window_matrices (leaf_windows[i]);
-              /* Assert it's not reused as a combination.  */
+          else if (EQ (leaf_windows[i]->contents, new_current_buffer))
-              eassert (NILP (leaf_windows[i]->hchild)
-                       && NILP (leaf_windows[i]->vchild));
-              free_window_matrices (leaf_windows[i]);
-            }
-          else if (EQ (leaf_windows[i]->buffer, new_current_buffer))
            ++n;
        }
@@ -5893,7 +5842,7 @@ the return value is nil.  Otherwise the value is t.  */)
      Fset_buffer (new_current_buffer);
      /* If the new current buffer doesn't appear in the selected
         window, go to its old point (see bug#12208).  */
-      if (!EQ (XWINDOW (data->current_window)->buffer, new_current_buffer))
+      if (!EQ (XWINDOW (data->current_window)->contents, new_current_buffer))
        Fgoto_char (make_number (old_point));
    }
@@ -5904,8 +5853,10 @@ the return value is nil.  Otherwise the value is t.  */)
 }
-/* Recursively delete all child windows reachable via the next, vchild,
+/* If WINDOW is an internal window, recursively delete all child windows
-   and hchild slots of WINDOW.  */
+   reachable via the next and contents slots of WINDOW.  Otherwise setup
+   WINDOW to not show any buffer.  */
 void
 delete_all_child_windows (Lisp_Object window)
 {
@@ -5917,17 +5868,12 @@ delete_all_child_windows (Lisp_Object window)
    /* Delete WINDOW's siblings (we traverse postorderly).  */
    delete_all_child_windows (w->next);
-  if (!NILP (w->vchild))
+  if (WINDOWP (w->contents))
-    {
-      delete_all_child_windows (w->vchild);
-      wset_vchild (w, Qnil);
-    }
-  else if (!NILP (w->hchild))
    {
-      delete_all_child_windows (w->hchild);
+      delete_all_child_windows (w->contents);
-      wset_hchild (w, Qnil);
+      wset_combination (w, 0, Qnil);
    }
-  else if (!NILP (w->buffer))
+  else if (BUFFERP (w->contents))
    {
      unshow_buffer (w);
      unchain_marker (XMARKER (w->pointm));
@@ -5935,7 +5881,7 @@ delete_all_child_windows (Lisp_Object window)
      /* Since combination limit makes sense for an internal windows
         only, we use this slot to save the buffer for the sake of
         possible resurrection in Fset_window_configuration.  */
-      wset_combination_limit (w, w->buffer);
+      wset_combination_limit (w, w->contents);
      wset_buffer (w, Qnil);
    }
@@ -5948,10 +5894,8 @@ count_windows (register struct window *window)
  register int count = 1;
  if (!NILP (window->next))
    count += count_windows (XWINDOW (window->next));
-  if (!NILP (window->vchild))
+  if (WINDOWP (window->contents))
-    count += count_windows (XWINDOW (window->vchild));
+    count += count_windows (XWINDOW (window->contents));
-  if (!NILP (window->hchild))
-    count += count_windows (XWINDOW (window->hchild));
  return count;
 }
@@ -5963,10 +5907,8 @@ get_leaf_windows (struct window *w, struct window **flat, int i)
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        i = get_leaf_windows (XWINDOW (w->hchild), flat, i);
+        i = get_leaf_windows (XWINDOW (w->contents), flat, i);
-      else if (!NILP (w->vchild))
-        i = get_leaf_windows (XWINDOW (w->vchild), flat, i);
      else
        flat[i++] = w;
@@ -6006,7 +5948,7 @@ get_phys_cursor_glyph (struct window *w)
        hpos = row->used[TEXT_AREA] - 1;
    }
-  if (hpos >= 0 && hpos < row->used[TEXT_AREA])
+  if (0 <= hpos && hpos < row->used[TEXT_AREA])
    glyph = row->glyphs[TEXT_AREA] + hpos;
  else
    glyph = NULL;
@@ -6022,14 +5964,14 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
  register struct window *w;
  register Lisp_Object tem, pers, par;
-  for (;!NILP (window); window = w->next)
+  for (; !NILP (window); window = w->next)
    {
      p = SAVED_WINDOW_N (vector, i);
      w = XWINDOW (window);
      wset_temslot (w, make_number (i)); i++;
      p->window = window;
-      p->buffer = w->buffer;
+      p->buffer = (WINDOW_LEAF_P (w) ? w->contents : Qnil);
      p->left_col = make_number (w->left_col);
      p->top_line = make_number (w->top_line);
      p->total_cols = make_number (w->total_cols);
@@ -6096,15 +6038,15 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
            }
        }
-      if (!NILP (w->buffer))
+      if (BUFFERP (w->contents))
        {
          /* Save w's value of point in the window configuration.  If w
             is the selected window, then get the value of point from
             the buffer; pointm is garbage in the selected window.  */
          if (EQ (window, selected_window))
-            p->pointm = build_marker (XBUFFER (w->buffer),
+            p->pointm = build_marker (XBUFFER (w->contents),
-                                      BUF_PT (XBUFFER (w->buffer)),
+                                      BUF_PT (XBUFFER (w->contents)),
-                                      BUF_PT_BYTE (XBUFFER (w->buffer)));
+                                      BUF_PT_BYTE (XBUFFER (w->contents)));
          else
            p->pointm = Fcopy_marker (w->pointm, Qnil);
          XMARKER (p->pointm)->insertion_type
@@ -6113,7 +6055,7 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
          p->start = Fcopy_marker (w->start, Qnil);
          p->start_at_line_beg = w->start_at_line_beg ? Qt : Qnil;
-          tem = BVAR (XBUFFER (w->buffer), mark);
+          tem = BVAR (XBUFFER (w->contents), mark);
          p->mark = Fcopy_marker (tem, Qnil);
        }
      else
@@ -6134,10 +6076,8 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
      else
        p->prev = XWINDOW (w->prev)->temslot;
-      if (!NILP (w->vchild))
+      if (WINDOWP (w->contents))
-        i = save_window_save (w->vchild, vector, i);
+        i = save_window_save (w->contents, vector, i);
-      if (!NILP (w->hchild))
-        i = save_window_save (w->hchild, vector, i);
    }
  return i;
@@ -6454,7 +6394,7 @@ If PIXELS-P is non-nil, the return value is VSCROLL.  */)
            adjust_glyphs (f);
          /* Prevent redisplay shortcuts.  */
-          XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
+          XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
        }
    }
@@ -6488,10 +6428,8 @@ foreach_window_1 (struct window *w, int (*fn) (struct window *, void *), void *u
  for (cont = 1; w && cont;)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        cont = foreach_window_1 (XWINDOW (w->hchild), fn, user_data);
+        cont = foreach_window_1 (XWINDOW (w->contents), fn, user_data);
-      else if (!NILP (w->vchild))
-        cont = foreach_window_1 (XWINDOW (w->vchild), fn, user_data);
      else
        cont = fn (w, user_data);
diff --git a/src/window.h b/src/window.h
index 71c438ff7f2..411756f045e 100644
--- a/src/window.h
+++ b/src/window.h
@@ -41,14 +41,13 @@ They are deleted only by calling delete-window on them (but
 this can be done implicitly).  Combination windows can be created
 and deleted at any time.
-A leaf window has a non-nil buffer field, and also
+A leaf window has a buffer stored in contents field and markers in its start
- has markers in its start and pointm fields.  Non-leaf windows
+and pointm fields.  Non-leaf windows have nil in the latter two fields.
- have nil in these fields.
 Non-leaf windows are either vertical or horizontal combinations.
 A vertical combination window has children that are arranged on the frame
-one above the next.  Its vchild field points to the uppermost child.
+one above the next.  Its contents field points to the uppermost child.
 The parent field of each of the children points to the vertical
 combination window.  The next field of each child points to the
 child below it, or is nil for the lowest child.  The prev field
@@ -56,7 +55,7 @@ of each child points to the child above it, or is nil for the
 highest child.
 A horizontal combination window has children that are side by side.
-Its hchild field points to the leftmost child.  In each child
+Its contents field points to the leftmost child.  In each child
 the next field points to the child to the right and the prev field
 points to the child to the left.
@@ -78,7 +77,7 @@ the root window is the minibuf window.  On minibufferless screens or
 minibuffer-only screens, the root window and the minibuffer window are
 one and the same, so its prev and next members are nil.
-A dead window has its buffer, hchild, and vchild windows all nil.  */
+A dead window has its contents field set to nil.  */
 struct cursor_pos
 {
@@ -102,13 +101,6 @@ struct window
    Lisp_Object next;
    Lisp_Object prev;
-    /* First child of this window: vchild is used if this is a vertical
-       combination, hchild if this is a horizontal combination.  Of the
-       fields vchild, hchild and buffer, one and only one is non-nil
-       unless the window is dead.  */
-    Lisp_Object hchild;
-    Lisp_Object vchild;
    /* The window this one is a child of.  */
    Lisp_Object parent;
@@ -123,10 +115,8 @@ struct window
    Lisp_Object new_total;
    Lisp_Object new_normal;
-    /* The buffer displayed in this window.  Of the fields vchild,
+    /* May be buffer, window, or nil.  */
-       hchild and buffer, one and only one is non-nil unless the window
+    Lisp_Object contents;
-       is dead.  */
-    Lisp_Object buffer;
    /* A marker pointing to where in the text to start displaying.
       BIDI Note: This is the _logical-order_ start, i.e. the smallest
@@ -282,6 +272,10 @@ struct window
    /* Non-zero if this window is a minibuffer window.  */
    unsigned mini : 1;
+    /* Meaningful only if contents is a window, non-zero if this
+       internal window is used in horizontal combination.  */
+    unsigned horizontal : 1;
    /* Non-zero means must regenerate mode line of this window.  */
    unsigned update_mode_line : 1;
@@ -428,6 +422,21 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 /* A handy macro.  */
+/* Non-zero if W is leaf (carry the buffer).  */
+#define WINDOW_LEAF_P(W) \
+  (BUFFERP ((W)->contents))
+/* Non-zero if W is a member of horizontal combination.  */
+#define WINDOW_HORIZONTAL_COMBINATION_P(W) \
+  (WINDOWP ((W)->contents) && (W)->horizontal)
+/* Non-zero if W is a member of vertical combination.  */
+#define WINDOW_VERTICAL_COMBINATION_P(W) \
+  (WINDOWP ((W)->contents) && !(W)->horizontal)
 #define WINDOW_XFRAME(W) \
  (XFRAME (WINDOW_FRAME ((W))))
@@ -931,20 +940,17 @@ extern void check_frame_size (struct frame *frame, int *rows, int *cols);
 struct glyph *get_phys_cursor_glyph (struct window *w);
 /* Value is non-zero if WINDOW is a valid window.  */
-#define WINDOW_VALID_P(WINDOW)                          \
+#define WINDOW_VALID_P(WINDOW)                                  \
-  (WINDOWP (WINDOW)                                     \
+  (WINDOWP (WINDOW) && !NILP (XWINDOW (WINDOW)->contents))      \
-   && (!NILP (XWINDOW (WINDOW)->buffer)                 \
-       || !NILP (XWINDOW (WINDOW)->vchild)              \
+/* A window of any sort, leaf or interior, is "valid" if its
-       || !NILP (XWINDOW (WINDOW)->hchild)))
+   contents slot is non-nil.  */
-/* A window of any sort, leaf or interior, is "valid" if one
-   of its buffer, vchild, or hchild members is non-nil.  */
 #define CHECK_VALID_WINDOW(WINDOW)                              \
  CHECK_TYPE (WINDOW_VALID_P (WINDOW), Qwindow_valid_p, WINDOW)
 /* Value is non-zero if WINDOW is a live window.  */
 #define WINDOW_LIVE_P(WINDOW)                                   \
-  (WINDOWP (WINDOW) && !NILP (XWINDOW (WINDOW)->buffer))
+  (WINDOWP (WINDOW) && BUFFERP (XWINDOW (WINDOW)->contents))
 /* A window is "live" if and only if it shows a buffer.  */
 #define CHECK_LIVE_WINDOW(WINDOW)                               \
diff --git a/src/xdisp.c b/src/xdisp.c
index bd68b286f4e..f8a9fd57dc1 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -582,7 +582,7 @@ static struct glyph scratch_glyphs[MAX_SCRATCH_GLYPHS];
 /* Ascent and height of the last line processed by move_it_to.  */
-static int last_max_ascent, last_height;
+static int last_height;
 /* Non-zero if there's a help-echo in the echo area.  */
@@ -1288,10 +1288,10 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
  if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w))))
    return visible_p;
-  if (XBUFFER (w->buffer) != current_buffer)
+  if (XBUFFER (w->contents) != current_buffer)
    {
      old_buffer = current_buffer;
-      set_buffer_internal_1 (XBUFFER (w->buffer));
+      set_buffer_internal_1 (XBUFFER (w->contents));
    }
  SET_TEXT_POS_FROM_MARKER (top, w->start);
@@ -4463,7 +4463,7 @@ handle_display_prop (struct it *it)
     if it was a text property.  */
  if (!STRINGP (it->string))
-    object = it->w->buffer;
+    object = it->w->contents;
  display_replaced_p = handle_display_spec (it, propval, object, overlay,
                                            position, bufpos,
@@ -4874,7 +4874,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
          it->what = IT_IMAGE;
          it->image_id = -1; /* no image */
          it->position = start_pos;
-          it->object = NILP (object) ? it->w->buffer : object;
+          it->object = NILP (object) ? it->w->contents : object;
          it->method = GET_FROM_IMAGE;
          it->from_overlay = Qnil;
          it->face_id = face_id;
@@ -5025,7 +5025,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
          it->what = IT_XWIDGET;
          it->method = GET_FROM_XWIDGET;
          it->position = start_pos;
-          it->object = NILP (object) ? it->w->buffer : object;
+          it->object = NILP (object) ? it->w->contents : object;
          *position = start_pos;
          it->xwidget = lookup_xwidget(value);
@@ -5037,7 +5037,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
          it->what = IT_IMAGE;
          it->image_id = lookup_image (it->f, value);
          it->position = start_pos;
-          it->object = NILP (object) ? it->w->buffer : object;
+          it->object = NILP (object) ? it->w->contents : object;
          it->method = GET_FROM_IMAGE;
          /* Say that we haven't consumed the characters with
@@ -5871,7 +5871,7 @@ pop_it (struct it *it)
      it->object = p->u.stretch.object;
      break;
    case GET_FROM_BUFFER:
-      it->object = it->w->buffer;
+      it->object = it->w->contents;
      break;
    case GET_FROM_STRING:
      it->object = it->string;
@@ -5884,7 +5884,7 @@ pop_it (struct it *it)
      else
        {
          it->method = GET_FROM_BUFFER;
-          it->object = it->w->buffer;
+          it->object = it->w->contents;
        }
    }
  it->end_charpos = p->end_charpos;
@@ -6325,7 +6325,7 @@ reseat_1 (struct it *it, struct text_pos pos, int set_stop_p)
  IT_STRING_BYTEPOS (*it) = -1;
  it->string = Qnil;
  it->method = GET_FROM_BUFFER;
-  it->object = it->w->buffer;
+  it->object = it->w->contents;
  it->area = TEXT_AREA;
  it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
  it->sp = 0;
@@ -7179,7 +7179,7 @@ set_iterator_to_next (struct it *it, int reseat_p)
          else
            {
              it->method = GET_FROM_BUFFER;
-              it->object = it->w->buffer;
+              it->object = it->w->contents;
            }
          it->dpvec = NULL;
@@ -7755,7 +7755,7 @@ next_element_from_ellipsis (struct it *it)
         setting face_before_selective_p.  */
      it->saved_face_id = it->face_id;
      it->method = GET_FROM_BUFFER;
-      it->object = it->w->buffer;
+      it->object = it->w->contents;
      reseat_at_next_visible_line_start (it, 1);
      it->face_before_selective_p = 1;
    }
@@ -8032,7 +8032,7 @@ next_element_from_buffer (struct it *it)
      /* Record what we have and where it came from.  */
      it->what = IT_CHARACTER;
-      it->object = it->w->buffer;
+      it->object = it->w->contents;
      it->position = it->current.pos;
      /* Normally we return the character found above, except when we
@@ -8138,7 +8138,7 @@ next_element_from_composition (struct it *it)
          return 0;
        }
      it->position = it->current.pos;
-      it->object = it->w->buffer;
+      it->object = it->w->contents;
      it->c = composition_update_it (&it->cmp_it, IT_CHARPOS (*it),
                                     IT_BYTEPOS (*it), Qnil);
    }
@@ -8979,7 +8979,6 @@ move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos
      it->current_y += it->max_ascent + it->max_descent;
      ++it->vpos;
      last_height = it->max_ascent + it->max_descent;
-      last_max_ascent = it->max_ascent;
      it->max_ascent = it->max_descent = 0;
    }
@@ -9006,7 +9005,6 @@ move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos
      it->current_y += it->max_ascent + it->max_descent;
      ++it->vpos;
      last_height = it->max_ascent + it->max_descent;
-      last_max_ascent = it->max_ascent;
    }
  if (backup_data)
@@ -10048,7 +10046,7 @@ with_echo_area_buffer_unwind_data (struct window *w)
  Vwith_echo_area_save_vector = Qnil;
  if (NILP (vector))
-    vector = Fmake_vector (make_number (7), Qnil);
+    vector = Fmake_vector (make_number (9), Qnil);
  XSETBUFFER (tmp, current_buffer); ASET (vector, i, tmp); ++i;
  ASET (vector, i, Vdeactivate_mark); ++i;
@@ -10057,13 +10055,15 @@ with_echo_area_buffer_unwind_data (struct window *w)
  if (w)
    {
      XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
-      ASET (vector, i, w->buffer); ++i;
+      ASET (vector, i, w->contents); ++i;
      ASET (vector, i, make_number (marker_position (w->pointm))); ++i;
      ASET (vector, i, make_number (marker_byte_position (w->pointm))); ++i;
+      ASET (vector, i, make_number (marker_position (w->start))); ++i;
+      ASET (vector, i, make_number (marker_byte_position (w->start))); ++i;
    }
  else
    {
-      int end = i + 4;
+      int end = i + 6;
      for (; i < end; ++i)
        ASET (vector, i, Qnil);
    }
@@ -10086,16 +10086,18 @@ unwind_with_echo_area_buffer (Lisp_Object vector)
  if (WINDOWP (AREF (vector, 3)))
    {
      struct window *w;
-      Lisp_Object buffer, charpos, bytepos;
+      Lisp_Object buffer;
      w = XWINDOW (AREF (vector, 3));
      buffer = AREF (vector, 4);
-      charpos = AREF (vector, 5);
-      bytepos = AREF (vector, 6);
      wset_buffer (w, buffer);
      set_marker_both (w->pointm, buffer,
-                       XFASTINT (charpos), XFASTINT (bytepos));
+                       XFASTINT (AREF (vector, 5)),
+                       XFASTINT (AREF (vector, 6)));
+      set_marker_both (w->start, buffer,
+                       XFASTINT (AREF (vector, 7)),
+                       XFASTINT (AREF (vector, 8)));
    }
  Vwith_echo_area_save_vector = vector;
@@ -10309,9 +10311,9 @@ resize_mini_window (struct window *w, int exact_p)
  eassert (MINI_WINDOW_P (w));
  /* By default, start display at the beginning.  */
-  set_marker_both (w->start, w->buffer,
+  set_marker_both (w->start, w->contents,
-                   BUF_BEGV (XBUFFER (w->buffer)),
+                   BUF_BEGV (XBUFFER (w->contents)),
-                   BUF_BEGV_BYTE (XBUFFER (w->buffer)));
+                   BUF_BEGV_BYTE (XBUFFER (w->contents)));
  /* Don't resize windows while redisplaying a window; it would
     confuse redisplay functions when the size of the window they are
@@ -10338,10 +10340,10 @@ resize_mini_window (struct window *w, int exact_p)
      struct text_pos start;
      struct buffer *old_current_buffer = NULL;
-      if (current_buffer != XBUFFER (w->buffer))
+      if (current_buffer != XBUFFER (w->contents))
        {
          old_current_buffer = current_buffer;
-          set_buffer_internal (XBUFFER (w->buffer));
+          set_buffer_internal (XBUFFER (w->contents));
        }
      init_iterator (&it, w, BEGV, BEGV_BYTE, NULL, DEFAULT_FACE_ID);
@@ -10790,7 +10792,7 @@ buffer_shared_and_changed (void)
 /* Nonzero if W doesn't reflect the actual state of current buffer due
   to its text or overlays change.  FIXME: this may be called when
-   XBUFFER (w->buffer) != current_buffer, which looks suspicious.  */
+   XBUFFER (w->contents) != current_buffer, which looks suspicious.  */
 static int
 window_outdated (struct window *w)
@@ -10805,7 +10807,7 @@ window_outdated (struct window *w)
 static int
 window_buffer_changed (struct window *w)
 {
-  struct buffer *b = XBUFFER (w->buffer);
+  struct buffer *b = XBUFFER (w->contents);
  eassert (BUFFER_LIVE_P (b));
@@ -11059,7 +11061,7 @@ x_consider_frame_title (Lisp_Object frame)
      Fselect_window (f->selected_window, Qt);
      set_buffer_internal_1
-        (XBUFFER (XWINDOW (f->selected_window)->buffer));
+        (XBUFFER (XWINDOW (f->selected_window)->contents));
      fmt = FRAME_ICONIFIED_P (f) ? Vicon_title_format : Vframe_title_format;
      mode_line_target = MODE_LINE_TITLE;
@@ -11178,7 +11180,7 @@ prepare_menu_bars (void)
          if (windows_or_buffers_changed
              && FRAME_NS_P (f))
            ns_set_doc_edited
-              (f, Fbuffer_modified_p (XWINDOW (f->selected_window)->buffer));
+              (f, Fbuffer_modified_p (XWINDOW (f->selected_window)->contents));
 #endif
          UNGCPRO;
        }
@@ -11250,7 +11252,7 @@ update_menu_bar (struct frame *f, int save_match_data, int hooks_run)
          specbind (Qinhibit_menubar_update, Qt);
-          set_buffer_internal_1 (XBUFFER (w->buffer));
+          set_buffer_internal_1 (XBUFFER (w->contents));
          if (save_match_data)
            record_unwind_save_match_data ();
          if (NILP (Voverriding_local_map_menu_flag))
@@ -11454,7 +11456,7 @@ update_tool_bar (struct frame *f, int save_match_data)
          /* Set current_buffer to the buffer of the selected
             window of the frame, so that we get the right local
             keymaps.  */
-          set_buffer_internal_1 (XBUFFER (w->buffer));
+          set_buffer_internal_1 (XBUFFER (w->contents));
          /* Save match data, if we must.  */
          if (save_match_data)
@@ -12321,10 +12323,8 @@ hscroll_window_tree (Lisp_Object window)
    {
      struct window *w = XWINDOW (window);
-      if (WINDOWP (w->hchild))
+      if (WINDOWP (w->contents))
-        hscrolled_p |= hscroll_window_tree (w->hchild);
+        hscrolled_p |= hscroll_window_tree (w->contents);
-      else if (WINDOWP (w->vchild))
-        hscrolled_p |= hscroll_window_tree (w->vchild);
      else if (w->cursor.vpos >= 0)
        {
          int h_margin;
@@ -12344,7 +12344,7 @@ hscroll_window_tree (Lisp_Object window)
          /* Scroll when cursor is inside this scroll margin.  */
          h_margin = hscroll_margin * WINDOW_FRAME_COLUMN_WIDTH (w);
-          if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->buffer))
+          if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->contents))
              /* For left-to-right rows, hscroll when cursor is either
                 (i) inside the right hscroll margin, or (ii) if it is
                 inside the left margin and the window is already
@@ -12379,7 +12379,7 @@ hscroll_window_tree (Lisp_Object window)
              /* Find point in a display of infinite width.  */
              saved_current_buffer = current_buffer;
-              current_buffer = XBUFFER (w->buffer);
+              current_buffer = XBUFFER (w->contents);
              if (w == XWINDOW (selected_window))
                pt = PT;
@@ -12432,7 +12432,7 @@ hscroll_window_tree (Lisp_Object window)
                 redisplay.  */
              if (w->hscroll != hscroll)
                {
-                  XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
+                  XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
                  w->hscroll = hscroll;
                  hscrolled_p = 1;
                }
@@ -12521,9 +12521,9 @@ debug_method_add (struct window *w, char const *fmt, ...)
  if (trace_redisplay_p)
    fprintf (stderr, "%p (%s): %s\n",
             w,
-             ((BUFFERP (w->buffer)
+             ((BUFFERP (w->contents)
-               && STRINGP (BVAR (XBUFFER (w->buffer), name)))
+               && STRINGP (BVAR (XBUFFER (w->contents), name)))
-              ? SSDATA (BVAR (XBUFFER (w->buffer), name))
+              ? SSDATA (BVAR (XBUFFER (w->contents), name))
              : "no buffer"),
             method + len);
 }
@@ -12587,8 +12587,8 @@ text_outside_line_unchanged_p (struct window *w,
         require to redisplay the whole paragraph.  It might be worthwhile
         to find the paragraph limits and widen the range of redisplayed
         lines to that, but for now just give up this optimization.  */
-      if (!NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering))
+      if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
-          && NILP (BVAR (XBUFFER (w->buffer), bidi_paragraph_direction)))
+          && NILP (BVAR (XBUFFER (w->contents), bidi_paragraph_direction)))
        unchanged_p = 0;
    }
@@ -12811,7 +12811,7 @@ reconsider_clip_changes (struct window *w, struct buffer *b)
     we set b->clip_changed to 1 to force updating the screen.  If
     b->clip_changed has already been set to 1, we can skip this
     check.  */
-  if (!b->clip_changed && BUFFERP (w->buffer) && w->window_end_valid)
+  if (!b->clip_changed && BUFFERP (w->contents) && w->window_end_valid)
    {
      ptrdiff_t pt;
@@ -12820,11 +12820,11 @@ reconsider_clip_changes (struct window *w, struct buffer *b)
      else
        pt = marker_position (w->pointm);
-      if ((w->current_matrix->buffer != XBUFFER (w->buffer)
+      if ((w->current_matrix->buffer != XBUFFER (w->contents)
           || pt != w->last_point)
          && check_point_in_composition (w->current_matrix->buffer,
                                         w->last_point,
-                                         XBUFFER (w->buffer), pt))
+                                         XBUFFER (w->contents), pt))
        b->clip_changed = 1;
    }
 }
@@ -13002,8 +13002,6 @@ redisplay_internal (void)
  unbind_to (count1, Qnil);
-  FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w->frame)) = -1;
  consider_all_windows_p = (update_mode_lines
                            || buffer_shared_and_changed ()
                            || cursor_type_changed);
@@ -13079,11 +13077,11 @@ redisplay_internal (void)
     the whole window.  The assignment to this_line_start_pos prevents
     the optimization directly below this if-statement.  */
  if (((!NILP (Vtransient_mark_mode)
-        && !NILP (BVAR (XBUFFER (w->buffer), mark_active)))
+        && !NILP (BVAR (XBUFFER (w->contents), mark_active)))
       != (w->region_showing > 0))
      || (w->region_showing
          && w->region_showing
-          != XINT (Fmarker_position (BVAR (XBUFFER (w->buffer), mark)))))
+          != XINT (Fmarker_position (BVAR (XBUFFER (w->contents), mark)))))
    CHARPOS (this_line_start_pos) = 0;
  /* Optimize the case that only the line containing the cursor in the
@@ -13101,7 +13099,7 @@ redisplay_internal (void)
      && !FRAME_OBSCURED_P (XFRAME (w->frame))
      /* Make sure recorded data applies to current buffer, etc.  */
      && this_line_buffer == current_buffer
-      && current_buffer == XBUFFER (w->buffer)
+      && current_buffer == XBUFFER (w->contents)
      && !w->force_start
      && !w->optional_new_start
      /* Point must be on the line that we have info recorded about.  */
@@ -13231,7 +13229,7 @@ redisplay_internal (void)
               PT == w->last_point
               /* Make sure the cursor was last displayed
                  in this window.  Otherwise we have to reposition it.  */
-               && w->cursor.vpos >= 0
+               && 0 <= w->cursor.vpos
               && w->cursor.vpos < WINDOW_TOTAL_LINES (w))
        {
          if (!must_finish)
@@ -13399,7 +13397,7 @@ redisplay_internal (void)
      Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
      struct frame *mini_frame;
-      displayed_buffer = XBUFFER (XWINDOW (selected_window)->buffer);
+      displayed_buffer = XBUFFER (XWINDOW (selected_window)->contents);
      /* Use list_of_error, not Qerror, so that
         we catch only errors and don't run the debugger.  */
      internal_condition_case_1 (redisplay_window_1, selected_window,
@@ -13609,7 +13607,7 @@ unwind_redisplay (Lisp_Object old_frame)
 static void
 mark_window_display_accurate_1 (struct window *w, int accurate_p)
 {
-  struct buffer *b = XBUFFER (w->buffer);
+  struct buffer *b = XBUFFER (w->contents);
  w->last_modified = accurate_p ? BUF_MODIFF (b) : 0;
  w->last_overlay_modified = accurate_p ? BUF_OVERLAY_MODIFF (b) : 0;
@@ -13656,11 +13654,9 @@ mark_window_display_accurate (Lisp_Object window, int accurate_p)
  for (; !NILP (window); window = w->next)
    {
      w = XWINDOW (window);
-      if (!NILP (w->vchild))
+      if (WINDOWP (w->contents))
-        mark_window_display_accurate (w->vchild, accurate_p);
+        mark_window_display_accurate (w->contents, accurate_p);
-      else if (!NILP (w->hchild))
+      else
-        mark_window_display_accurate (w->hchild, accurate_p);
-      else if (BUFFERP (w->buffer))
        mark_window_display_accurate_1 (w, accurate_p);
    }
@@ -13717,13 +13713,11 @@ redisplay_windows (Lisp_Object window)
    {
      struct window *w = XWINDOW (window);
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        redisplay_windows (w->hchild);
+        redisplay_windows (w->contents);
-      else if (!NILP (w->vchild))
+      else if (BUFFERP (w->contents))
-        redisplay_windows (w->vchild);
-      else if (!NILP (w->buffer))
        {
-          displayed_buffer = XBUFFER (w->buffer);
+          displayed_buffer = XBUFFER (w->contents);
          /* Use list_of_error, not Qerror, so that
             we catch only errors and don't run the debugger.  */
          internal_condition_case_1 (redisplay_window_0, window,
@@ -14370,7 +14364,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
          && !MATRIX_ROW_CONTINUATION_LINE_P (row)
          && row->x == 0)
        {
-          this_line_buffer = XBUFFER (w->buffer);
+          this_line_buffer = XBUFFER (w->contents);
          CHARPOS (this_line_start_pos)
            = MATRIX_ROW_START_CHARPOS (row) + delta;
@@ -14406,7 +14400,7 @@ run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
  struct window *w = XWINDOW (window);
  SET_MARKER_FROM_TEXT_POS (w->start, startp);
-  if (current_buffer != XBUFFER (w->buffer))
+  if (current_buffer != XBUFFER (w->contents))
    emacs_abort ();
  if (!NILP (Vwindow_scroll_functions))
@@ -14415,7 +14409,7 @@ run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
                            make_number (CHARPOS (startp)));
      SET_TEXT_POS_FROM_MARKER (startp, w->start);
      /* In case the hook functions switch buffers.  */
-      set_buffer_internal (XBUFFER (w->buffer));
+      set_buffer_internal (XBUFFER (w->contents));
    }
  return startp;
@@ -15066,7 +15060,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
              must_scroll = 1;
            }
          else if (rc != CURSOR_MOVEMENT_SUCCESS
-                   && !NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering)))
+                   && !NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
            {
              struct glyph_row *row1;
@@ -15129,7 +15123,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
          else if (scroll_p)
            rc = CURSOR_MOVEMENT_MUST_SCROLL;
          else if (rc != CURSOR_MOVEMENT_SUCCESS
-                   && !NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering)))
+                   && !NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
            {
              /* With bidi-reordered rows, there could be more than
                 one candidate row whose start and end positions
@@ -15236,7 +15230,7 @@ set_vertical_scroll_bar (struct window *w)
      || (w == XWINDOW (minibuf_window)
          && NILP (echo_area_buffer[0])))
    {
-      struct buffer *buf = XBUFFER (w->buffer);
+      struct buffer *buf = XBUFFER (w->contents);
      whole = BUF_ZV (buf) - BUF_BEGV (buf);
      start = marker_position (w->start) - BUF_BEGV (buf);
      /* I don't think this is guaranteed to be right.  For the
@@ -15270,7 +15264,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 {
  struct window *w = XWINDOW (window);
  struct frame *f = XFRAME (w->frame);
-  struct buffer *buffer = XBUFFER (w->buffer);
+  struct buffer *buffer = XBUFFER (w->contents);
  struct buffer *old = current_buffer;
  struct text_pos lpoint, opoint, startp;
  int update_mode_line;
@@ -15292,12 +15286,14 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
  SET_TEXT_POS (lpoint, PT, PT_BYTE);
  opoint = lpoint;
-  /* W must be a leaf window here.  */
-  eassert (!NILP (w->buffer));
 #ifdef GLYPH_DEBUG
  *w->desired_matrix->method = 0;
 #endif
+  /* Make sure that both W's markers are valid.  */
+  eassert (XMARKER (w->start)->buffer == buffer);
+  eassert (XMARKER (w->pointm)->buffer == buffer);
 restart:
  reconsider_clip_changes (w, buffer);
@@ -15323,10 +15319,10 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
      else if ((w != XWINDOW (minibuf_window)
                || minibuf_level == 0)
               /* When buffer is nonempty, redisplay window normally. */
-               && BUF_Z (XBUFFER (w->buffer)) == BUF_BEG (XBUFFER (w->buffer))
+               && BUF_Z (XBUFFER (w->contents)) == BUF_BEG (XBUFFER (w->contents))
               /* Quail displays non-mini buffers in minibuffer window.
                  In that case, redisplay the window normally.  */
-               && !NILP (Fmemq (w->buffer, Vminibuffer_list)))
+               && !NILP (Fmemq (w->contents, Vminibuffer_list)))
        {
          /* W is a mini-buffer window, but it's not active, so clear
             it.  */
@@ -15348,7 +15344,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
     value.  */
  /* Really select the buffer, for the sake of buffer-local
     variables.  */
-  set_buffer_internal_1 (XBUFFER (w->buffer));
+  set_buffer_internal_1 (XBUFFER (w->contents));
  current_matrix_up_to_date_p
    = (w->window_end_valid
@@ -16653,7 +16649,7 @@ try_window_reusing_current_matrix (struct window *w)
                 bidi-reordered glyph rows.  Let set_cursor_from_row
                 figure out where to put the cursor, and if it fails,
                 give up.  */
-              if (!NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering)))
+              if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
                {
                  if (!set_cursor_from_row (w, row, w->current_matrix,
                                            0, 0, 0, 0))
@@ -16904,7 +16900,7 @@ sync_frame_with_window_matrix_rows (struct window *w)
  /* Preconditions: W must be a leaf window and full-width.  Its frame
     must have a frame matrix.  */
-  eassert (NILP (w->hchild) && NILP (w->vchild));
+  eassert (BUFFERP (w->contents));
  eassert (WINDOW_FULL_WIDTH_P (w));
  eassert (!FRAME_WINDOW_P (f));
@@ -16946,7 +16942,7 @@ row_containing_pos (struct window *w, ptrdiff_t charpos,
 {
  struct glyph_row *row = start;
  struct glyph_row *best_row = NULL;
-  ptrdiff_t mindif = BUF_ZV (XBUFFER (w->buffer)) + 1;
+  ptrdiff_t mindif = BUF_ZV (XBUFFER (w->contents)) + 1;
  int last_y;
  /* If we happen to start on a header-line, skip that.  */
@@ -16982,7 +16978,7 @@ row_containing_pos (struct window *w, ptrdiff_t charpos,
        {
          struct glyph *g;
-          if (NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering))
+          if (NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
              || (!best_row && !row->continued_p))
            return row;
          /* In bidi-reordered rows, there could be several rows
@@ -17155,7 +17151,7 @@ try_window_id (struct window *w)
     wrapped line can change the wrap position, altering the line
     above it.  It might be worthwhile to handle this more
     intelligently, but for now just redisplay from scratch.  */
-  if (!NILP (BVAR (XBUFFER (w->buffer), word_wrap)))
+  if (!NILP (BVAR (XBUFFER (w->contents), word_wrap)))
    GIVE_UP (21);
  /* Under bidi reordering, adding or deleting a character in the
@@ -17166,8 +17162,8 @@ try_window_id (struct window *w)
     to find the paragraph limits and widen the range of redisplayed
     lines to that, but for now just give up this optimization and
     redisplay from scratch.  */
-  if (!NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering))
+  if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
-      && NILP (BVAR (XBUFFER (w->buffer), bidi_paragraph_direction)))
+      && NILP (BVAR (XBUFFER (w->contents), bidi_paragraph_direction)))
    GIVE_UP (22);
  /* Make sure beg_unchanged and end_unchanged are up to date.  Do it
@@ -18055,7 +18051,7 @@ glyphs in short form, otherwise show glyphs in long form.  */)
  (Lisp_Object glyphs)
 {
  struct window *w = XWINDOW (selected_window);
-  struct buffer *buffer = XBUFFER (w->buffer);
+  struct buffer *buffer = XBUFFER (w->contents);
  fprintf (stderr, "PT = %"pI"d, BEGV = %"pI"d. ZV = %"pI"d\n",
           BUF_PT (buffer), BUF_BEGV (buffer), BUF_ZV (buffer));
@@ -18161,7 +18157,7 @@ static struct glyph_row *
 get_overlay_arrow_glyph_row (struct window *w, Lisp_Object overlay_arrow_string)
 {
  struct frame *f = XFRAME (WINDOW_FRAME (w));
-  struct buffer *buffer = XBUFFER (w->buffer);
+  struct buffer *buffer = XBUFFER (w->contents);
  struct buffer *old = current_buffer;
  const unsigned char *arrow_string = SDATA (overlay_arrow_string);
  int arrow_len = SCHARS (overlay_arrow_string);
@@ -19368,7 +19364,7 @@ display_line (struct it *it)
              row->glyphs[TEXT_AREA]->charpos = -1;
              row->displays_text_p = 0;
-              if (!NILP (BVAR (XBUFFER (it->w->buffer), indicate_empty_lines))
+              if (!NILP (BVAR (XBUFFER (it->w->contents), indicate_empty_lines))
                  && (!MINI_WINDOW_P (it->w)
                      || (minibuf_level && EQ (it->window, minibuf_window))))
                row->indicate_empty_line_p = 1;
@@ -20183,10 +20179,8 @@ redisplay_mode_lines (Lisp_Object window, int force)
    {
      struct window *w = XWINDOW (window);
-      if (WINDOWP (w->hchild))
+      if (WINDOWP (w->contents))
-        nwindows += redisplay_mode_lines (w->hchild, force);
+        nwindows += redisplay_mode_lines (w->contents, force);
-      else if (WINDOWP (w->vchild))
-        nwindows += redisplay_mode_lines (w->vchild, force);
      else if (force
               || FRAME_GARBAGED_P (XFRAME (w->frame))
               || !MATRIX_MODE_LINE_ROW (w->current_matrix)->enabled_p)
@@ -20196,7 +20190,7 @@ redisplay_mode_lines (Lisp_Object window, int force)
          /* Set the window's buffer for the mode line display.  */
          SET_TEXT_POS (lpoint, PT, PT_BYTE);
-          set_buffer_internal_1 (XBUFFER (w->buffer));
+          set_buffer_internal_1 (XBUFFER (w->contents));
          /* Point refers normally to the selected window.  For any
             other window, set up appropriate value.  */
@@ -20978,7 +20972,7 @@ are the selected window and the WINDOW's buffer).  */)
  XSETWINDOW (window, w);
  if (NILP (buffer))
-    buffer = w->buffer;
+    buffer = w->contents;
  CHECK_BUFFER (buffer);
  /* Make formatting the modeline a non-op when noninteractive, otherwise
@@ -22284,7 +22278,7 @@ calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop,
            return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w));
        }
-      prop = buffer_local_value_1 (prop, it->w->buffer);
+      prop = buffer_local_value_1 (prop, it->w->contents);
      if (EQ (prop, Qunbound))
        prop = Qnil;
    }
@@ -22343,7 +22337,7 @@ calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop,
              return OK_PIXELS (pixels);
            }
-          car = buffer_local_value_1 (car, it->w->buffer);
+          car = buffer_local_value_1 (car, it->w->contents);
          if (EQ (car, Qunbound))
            car = Qnil;
        }
@@ -24325,7 +24319,7 @@ produce_stretch_glyph (struct it *it)
      int n = width;
      if (!STRINGP (object))
-        object = it->w->buffer;
+        object = it->w->contents;
 #ifdef HAVE_WINDOW_SYSTEM
      if (FRAME_WINDOW_P (it->f))
        append_stretch_glyph (it, object, width, height, ascent);
@@ -25724,7 +25718,7 @@ get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
                        int *active_cursor)
 {
  struct frame *f = XFRAME (w->frame);
-  struct buffer *b = XBUFFER (w->buffer);
+  struct buffer *b = XBUFFER (w->contents);
  int cursor_type = DEFAULT_CURSOR;
  Lisp_Object alt_cursor;
  int non_selected = 0;
@@ -26282,10 +26276,8 @@ update_cursor_in_window_tree (struct window *w, int on_p)
 {
  while (w)
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        update_cursor_in_window_tree (XWINDOW (w->hchild), on_p);
+        update_cursor_in_window_tree (XWINDOW (w->contents), on_p);
-      else if (!NILP (w->vchild))
-        update_cursor_in_window_tree (XWINDOW (w->vchild), on_p);
      else
        update_window_cursor (w, on_p);
@@ -27531,7 +27523,7 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
                {
                  help_echo_string = help;
                  XSETWINDOW (help_echo_window, w);
-                  help_echo_object = w->buffer;
+                  help_echo_object = w->contents;
                  help_echo_pos = charpos;
                }
            }
@@ -27567,7 +27559,7 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
            {
              Lisp_Object default_help
                = buffer_local_value_1 (Qmode_line_default_help_echo,
-                                        w->buffer);
+                                        w->contents);
              if (STRINGP (default_help))
                {
@@ -27842,7 +27834,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
  /* Are we in a window whose display is up to date?
     And verify the buffer's text has not changed.  */
-  b = XBUFFER (w->buffer);
+  b = XBUFFER (w->contents);
  if (part == ON_TEXT
      && w->window_end_valid
      && w->last_modified == BUF_MODIFF (b)
@@ -28051,8 +28043,8 @@ note_mouse_highlight (struct frame *f, int x, int y)
                  if (pos > 0)
                    {
                      mouse_face = get_char_property_and_overlay
-                        (make_number (pos), Qmouse_face, w->buffer, &overlay);
+                        (make_number (pos), Qmouse_face, w->contents, &overlay);
-                      buffer = w->buffer;
+                      buffer = w->contents;
                      disp_string = object;
                    }
                }
@@ -28165,11 +28157,11 @@ note_mouse_highlight (struct frame *f, int x, int y)
                    if (p > 0)
                      {
                        help = Fget_char_property (make_number (p),
-                                                   Qhelp_echo, w->buffer);
+                                                   Qhelp_echo, w->contents);
                        if (!NILP (help))
                          {
                            charpos = p;
-                            obj = w->buffer;
+                            obj = w->contents;
                          }
                      }
                  }
@@ -28220,7 +28212,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
                      ptrdiff_t p = string_buffer_position (obj, start);
                      if (p > 0)
                        pointer = Fget_char_property (make_number (p),
-                                                      Qpointer, w->buffer);
+                                                      Qpointer, w->contents);
                    }
                }
              else if (BUFFERP (obj)
@@ -28663,12 +28655,9 @@ expose_window_tree (struct window *w, XRectangle *r)
  while (w && !FRAME_GARBAGED_P (f))
    {
-      if (!NILP (w->hchild))
+      if (WINDOWP (w->contents))
-        mouse_face_overwritten_p
-          |= expose_window_tree (XWINDOW (w->hchild), r);
-      else if (!NILP (w->vchild))
        mouse_face_overwritten_p
-          |= expose_window_tree (XWINDOW (w->vchild), r);
+          |= expose_window_tree (XWINDOW (w->contents), r);
      else
        mouse_face_overwritten_p |= expose_window (w, r);
diff --git a/src/xfaces.c b/src/xfaces.c
index 6db6ac7683f..b2ace1be14e 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -231,7 +231,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #undef FRAME_X_DISPLAY_INFO
 #define FRAME_X_DISPLAY_INFO FRAME_W32_DISPLAY_INFO
 #define x_display_info w32_display_info
-#define check_x check_w32
 #define GCGraphicsExposures 0
 #endif /* HAVE_NTGUI */
@@ -239,7 +238,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #undef FRAME_X_DISPLAY_INFO
 #define FRAME_X_DISPLAY_INFO FRAME_NS_DISPLAY_INFO
 #define x_display_info ns_display_info
-#define check_x check_ns
 #define GCGraphicsExposures 0
 #endif /* HAVE_NS */
 #endif /* HAVE_WINDOW_SYSTEM */
@@ -1636,7 +1634,7 @@ the WIDTH times as wide as FACE on FRAME.  */)
  struct frame *f;
  int size, avgwidth IF_LINT (= 0);
-  check_x ();
+  check_window_system (NULL);
  CHECK_STRING (pattern);
  if (! NILP (maximum))
@@ -1645,8 +1643,8 @@ the WIDTH times as wide as FACE on FRAME.  */)
  if (!NILP (width))
    CHECK_NUMBER (width);
-  /* We can't simply call check_x_frame because this function may be
+  /* We can't simply call decode_window_system_frame because
-     called before any frame is created.  */
+     this function may be called before any frame is created.  */
  f = decode_live_frame (frame);
  if (! FRAME_WINDOW_P (f))
    {
@@ -3925,8 +3923,8 @@ If FRAME is omitted or nil, use the selected frame.  */)
  struct frame *f;
  Lisp_Object lface1, lface2;
-  /* Don't use check_x_frame here because this function is called
+  /* Don't use decode_window_system_frame here because this function
-     before X frames exist.  At that time, if FRAME is nil,
+     is called before X frames exist.  At that time, if FRAME is nil,
     selected_frame will be used which is the frame dumped with
     Emacs.  That frame is not an X frame.  */
  f = EQ (frame, Qt) ? NULL : decode_live_frame (frame);
@@ -5964,7 +5962,7 @@ face_at_buffer_position (struct window *w, ptrdiff_t pos,
  /* W must display the current buffer.  We could write this function
     to use the frame and buffer of W, but right now it doesn't.  */
-  /* eassert (XBUFFER (w->buffer) == current_buffer); */
+  /* eassert (XBUFFER (w->contents) == current_buffer); */
  XSETFASTINT (position, pos);
@@ -5974,9 +5972,9 @@ face_at_buffer_position (struct window *w, ptrdiff_t pos,
  /* Get the `face' or `mouse_face' text property at POS, and
     determine the next position at which the property changes.  */
-  prop = Fget_text_property (position, propname, w->buffer);
+  prop = Fget_text_property (position, propname, w->contents);
  XSETFASTINT (limit1, (limit < endpos ? limit : endpos));
-  end = Fnext_single_property_change (position, propname, w->buffer, limit1);
+  end = Fnext_single_property_change (position, propname, w->contents, limit1);
  if (INTEGERP (end))
    endpos = XINT (end);
@@ -6072,7 +6070,7 @@ face_for_overlay_string (struct window *w, ptrdiff_t pos,
  /* W must display the current buffer.  We could write this function
     to use the frame and buffer of W, but right now it doesn't.  */
-  /* eassert (XBUFFER (w->buffer) == current_buffer); */
+  /* eassert (XBUFFER (w->contents) == current_buffer); */
  XSETFASTINT (position, pos);
@@ -6082,9 +6080,9 @@ face_for_overlay_string (struct window *w, ptrdiff_t pos,
  /* Get the `face' or `mouse_face' text property at POS, and
     determine the next position at which the property changes.  */
-  prop = Fget_text_property (position, propname, w->buffer);
+  prop = Fget_text_property (position, propname, w->contents);
  XSETFASTINT (limit1, (limit < endpos ? limit : endpos));
-  end = Fnext_single_property_change (position, propname, w->buffer, limit1);
+  end = Fnext_single_property_change (position, propname, w->contents, limit1);
  if (INTEGERP (end))
    endpos = XINT (end);
diff --git a/src/xfns.c b/src/xfns.c
index e24d3981a09..f4c24cb09a0 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -123,10 +123,6 @@ extern LWLIB_ID widget_id_tick;
 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
-/* Nonzero if using X.  */
-int x_in_use;
 static Lisp_Object Qsuppress_icon;
 static Lisp_Object Qundefined_color;
 static Lisp_Object Qcompound_text, Qcancel_timer;
@@ -139,38 +135,6 @@ static int dpyinfo_refcount;
 static struct x_display_info *x_display_info_for_name (Lisp_Object);
-/* Error if we are not connected to X.  */
-void
-check_x (void)
-{
-  if (! x_in_use)
-    error ("X windows are not in use or not initialized");
-}
-/* Nonzero if we can use mouse menus.
-   You should not call this unless HAVE_MENUS is defined.  */
-int
-have_menus_p (void)
-{
-  return x_in_use;
-}
-/* Extract a frame as a FRAME_PTR, defaulting to the selected frame
-   and checking validity for X.  */
-FRAME_PTR
-check_x_frame (Lisp_Object frame)
-{
-  struct frame *f = decode_live_frame (frame);
-  if (! FRAME_X_P (f))
-    error ("Non-X frame used");
-  return f;
-}
 /* Let the user specify an X display with a Lisp object.
   OBJECT may be nil, a frame or a terminal object.
   nil stands for the selected frame--or, if that is not an X frame,
@@ -205,7 +169,7 @@ check_x_display_info (Lisp_Object object)
    dpyinfo = x_display_info_for_name (object);
  else
    {
-      FRAME_PTR f = check_x_frame (object);
+      FRAME_PTR f = decode_window_system_frame (object);
      dpyinfo = FRAME_X_DISPLAY_INFO (f);
    }
@@ -2992,7 +2956,7 @@ If FRAME is omitted or nil, use the selected frame.
 Signal error if FRAME is not an X frame.  */)
  (Lisp_Object frame)
 {
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  block_input ();
  x_wm_set_size_hint (f, 0, 0);
@@ -3483,7 +3447,7 @@ DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
 FRAME nil means use the selected frame.  */)
  (Lisp_Object frame)
 {
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  Display *dpy = FRAME_X_DISPLAY (f);
  block_input ();
@@ -3516,7 +3480,7 @@ DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
  (Lisp_Object color, Lisp_Object frame)
 {
  XColor foo;
-  FRAME_PTR f = check_x_frame (frame);
+  FRAME_PTR f = decode_window_system_frame (frame);
  CHECK_STRING (color);
@@ -3531,7 +3495,7 @@ DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
  (Lisp_Object color, Lisp_Object frame)
 {
  XColor foo;
-  FRAME_PTR f = check_x_frame (frame);
+  FRAME_PTR f = decode_window_system_frame (frame);
  CHECK_STRING (color);
@@ -3996,7 +3960,6 @@ x_display_info_for_name (Lisp_Object name)
  if (dpyinfo == 0)
    error ("Cannot connect to X server %s", SDATA (name));
-  x_in_use = 1;
  XSETFASTINT (Vwindow_system_version, 11);
  return dpyinfo;
@@ -4050,8 +4013,6 @@ An insecure way to solve the problem may be to use `xhost'.\n",
        error ("Cannot connect to X server %s", SDATA (display));
    }
-  x_in_use = 1;
  XSETFASTINT (Vwindow_system_version, 11);
  return Qnil;
 }
@@ -4143,7 +4104,7 @@ FRAME.  Default is to change on the edit X window.  */)
  (Lisp_Object prop, Lisp_Object value, Lisp_Object frame,
   Lisp_Object type, Lisp_Object format, Lisp_Object outer_p)
 {
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  Atom prop_atom;
  Atom target_type = XA_STRING;
  int element_format = 8;
@@ -4221,7 +4182,7 @@ DEFUN ("x-delete-window-property", Fx_delete_window_property,
 FRAME nil or omitted means use the selected frame.  Value is PROP.  */)
  (Lisp_Object prop, Lisp_Object frame)
 {
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  Atom prop_atom;
  CHECK_STRING (prop);
@@ -4257,7 +4218,7 @@ no value of TYPE (always string in the MS Windows case).  */)
  (Lisp_Object prop, Lisp_Object frame, Lisp_Object type,
   Lisp_Object source, Lisp_Object delete_p, Lisp_Object vector_ret_p)
 {
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  Atom prop_atom;
  int rc;
  Lisp_Object prop_value = Qnil;
@@ -4525,8 +4486,6 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
  Lisp_Object buffer;
  struct buffer *old_buffer;
-  check_x ();
  if (!dpyinfo->terminal->name)
    error ("Terminal is not live, can't create new frames on it");
@@ -4923,7 +4882,7 @@ Text larger than the specified size is clipped.  */)
  if (SCHARS (string) == 0)
    string = make_unibyte_string (" ", 1);
-  f = check_x_frame (frame);
+  f = decode_window_system_frame (frame);
  if (NILP (timeout))
    timeout = make_number (5);
  else
@@ -5043,7 +5002,7 @@ Text larger than the specified size is clipped.  */)
  /* Display the tooltip text in a temporary buffer.  */
  old_buffer = current_buffer;
-  set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
+  set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->contents));
  bset_truncate_lines (current_buffer, Qnil);
  clear_glyph_matrix (w->desired_matrix);
  clear_glyph_matrix (w->current_matrix);
@@ -5246,7 +5205,7 @@ DEFUN ("x-uses-old-gtk-dialog", Fx_uses_old_gtk_dialog,
 #ifdef USE_GTK
  if (use_dialog_box
      && use_file_dialog
-      && have_menus_p ()
+      && window_system_available (SELECTED_FRAME ())
      && xg_uses_old_file_dialog ())
    return Qt;
 #endif
@@ -5316,7 +5275,7 @@ Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories.  */)
  ptrdiff_t count = SPECPDL_INDEX ();
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
-  check_x ();
+  check_window_system (f);
  GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
@@ -5486,7 +5445,7 @@ Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories.  */)
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
  char *cdef_file;
-  check_x ();
+  check_window_system (f);
  GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
@@ -5541,15 +5500,13 @@ FRAME is the frame on which to pop up the font chooser.  If omitted or
 nil, it defaults to the selected frame. */)
  (Lisp_Object frame, Lisp_Object ignored)
 {
-  FRAME_PTR f = check_x_frame (frame);
+  FRAME_PTR f = decode_window_system_frame (frame);
  Lisp_Object font;
  Lisp_Object font_param;
  char *default_name = NULL;
  struct gcpro gcpro1, gcpro2;
  ptrdiff_t count = SPECPDL_INDEX ();
-  check_x ();
  if (popup_activated ())
    error ("Trying to use a menu from within a menu-entry");
@@ -5609,7 +5566,7 @@ present and mapped to the usual X keysyms.  */)
  return Qlambda;
 #else
  XkbDescPtr kb;
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  Display *dpy = FRAME_X_DISPLAY (f);
  Lisp_Object have_keys;
  int major, minor, op, event, error_code;
@@ -5737,9 +5694,6 @@ frame_parm_handler x_frame_parm_handlers[] =
 void
 syms_of_xfns (void)
 {
-  /* This is zero if not using X windows.  */
-  x_in_use = 0;
  /* The section below is built by the lisp expression at the top of the file,
     just above where these variables are declared.  */
  /*&&& init symbols here &&&*/
@@ -5919,9 +5873,6 @@ When using Gtk+ tooltips, the tooltip face is not used.  */);
  defsubr (&Sx_focus_frame);
  defsubr (&Sx_backspace_delete_keys_p);
-  /* Setting callback functions for fontset handler.  */
-  check_window_system_func = check_x;
  defsubr (&Sx_show_tip);
  defsubr (&Sx_hide_tip);
  tip_timer = Qnil;
diff --git a/src/xgselect.c b/src/xgselect.c
index 2c8e9671abb..0b5ad6ae70d 100644
--- a/src/xgselect.c
+++ b/src/xgselect.c
@@ -26,6 +26,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <glib.h>
 #include <errno.h>
 #include "xterm.h"
+#include "frame.h"
 int
 xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
@@ -43,7 +44,7 @@ xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
  int i, nfds, tmo_in_millisec;
  USE_SAFE_ALLOCA;
-  if (! (x_in_use
+  if (! (window_system_available (NULL)
         && g_main_context_pending (context = g_main_context_default ())))
    return pselect (fds_lim, rfds, wfds, efds, timeout, sigmask);
diff --git a/src/xmenu.c b/src/xmenu.c
index af08eeb657c..9993bd87d5b 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -223,8 +223,6 @@ for instance using the window manager, then this produces a quit and
  FRAME_PTR f = NULL;
  Lisp_Object window;
-  check_x ();
  /* Decode the first argument: find the window or frame to use.  */
  if (EQ (position, Qt)
      || (CONSP (position) && (EQ (XCAR (position), Qmenu_bar)
@@ -277,8 +275,7 @@ for instance using the window manager, then this produces a quit and
       but I don't want to make one now.  */
    CHECK_WINDOW (window);
-  if (! FRAME_X_P (f) && ! FRAME_MSDOS_P (f))
+  check_window_system (f);
-    error ("Can not put X dialog on this terminal");
  /* Force a redisplay before showing the dialog.  If a frame is created
     just before showing the dialog, its contents may not have been fully
@@ -485,7 +482,7 @@ If FRAME is nil or not given, use the selected frame.  */)
  (Lisp_Object frame)
 {
  XEvent ev;
-  FRAME_PTR f = check_x_frame (frame);
+  FRAME_PTR f = decode_window_system_frame (frame);
  Widget menubar;
  block_input ();
@@ -569,7 +566,7 @@ If FRAME is nil or not given, use the selected frame.  */)
     block_input ().  */
  block_input ();
-  f = check_x_frame (frame);
+  f = decode_window_system_frame (frame);
  if (FRAME_EXTERNAL_MENU_BAR (f))
    set_frame_menubar (f, 0, 1);
@@ -976,7 +973,7 @@ set_frame_menubar (FRAME_PTR f, bool first_time, bool deep_p)
      if (! menubar_widget)
        previous_menu_items_used = 0;
-      buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer;
+      buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->contents;
      specbind (Qinhibit_quit, Qt);
      /* Don't let the debugger step into this code
         because it is not reentrant.  */
diff --git a/src/xselect.c b/src/xselect.c
index cca1a47212b..b422a22d68b 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -2450,7 +2450,7 @@ Use the display for FRAME or the current frame if FRAME is not given or nil.
 If the value is 0 or the atom is not known, return the empty string.  */)
  (Lisp_Object value, Lisp_Object frame)
 {
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  char *name = 0;
  char empty[] = "";
  Lisp_Object ret = Qnil;
@@ -2485,7 +2485,7 @@ FRAME is on.  If FRAME is nil, the selected frame is used.  */)
  (Lisp_Object atom, Lisp_Object frame)
 {
  Atom x_atom;
-  struct frame *f = check_x_frame (frame);
+  struct frame *f = decode_window_system_frame (frame);
  ptrdiff_t i;
  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
@@ -2618,7 +2618,7 @@ x_send_client_event (Lisp_Object display, Lisp_Object dest, Lisp_Object from,
  struct x_display_info *dpyinfo = check_x_display_info (display);
  Window wdest;
  XEvent event;
-  struct frame *f = check_x_frame (from);
+  struct frame *f = decode_window_system_frame (from);
  int to_root;
  CHECK_NUMBER (format);
@@ -2635,7 +2635,7 @@ x_send_client_event (Lisp_Object display, Lisp_Object dest, Lisp_Object from,
  if (FRAMEP (dest) || NILP (dest))
    {
-      struct frame *fdest = check_x_frame (dest);
+      struct frame *fdest = decode_window_system_frame (dest);
      wdest = FRAME_OUTER_WINDOW (fdest);
    }
  else if (STRINGP (dest))
diff --git a/src/xsmfns.c b/src/xsmfns.c
index 0af196d2160..cb7122202df 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -221,7 +221,7 @@ smc_save_yourself_CB (SmcConn smcConn,
  props[props_idx]->name = xstrdup (SmRestartCommand);
  props[props_idx]->type = xstrdup (SmLISTofARRAY8);
  /* /path/to/emacs, --smid=xxx --no-splash --chdir=dir ... */
-  if (initial_argc > INT_MAX - 3)
+  if (INT_MAX - 3 < initial_argc)
    memory_full (SIZE_MAX);
  i = 3 + initial_argc;
  props[props_idx]->num_vals = i;
diff --git a/src/xterm.h b/src/xterm.h
index b241ff23559..16effc5c9ea 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -366,10 +366,6 @@ struct x_display_info
 extern int use_xim;
 #endif
-/* This checks to make sure we have a display.  */
-extern void check_x (void);
 extern struct frame *x_window_to_frame (struct x_display_info *, int);
 extern struct frame *x_any_window_to_frame (struct x_display_info *, int);
 extern struct frame *x_menubar_window_to_frame (struct x_display_info *,
@@ -927,7 +923,6 @@ void x_handle_property_notify (XPropertyEvent *);
 /* From xfns.c.  */
-struct frame *check_x_frame (Lisp_Object);
 extern void x_free_gcs (struct frame *);
 /* From xrdb.c.  */
@@ -1012,7 +1007,6 @@ extern void x_clipboard_manager_save_all (void);
 extern struct x_display_info * check_x_display_info (Lisp_Object);
 extern Lisp_Object x_get_focus_frame (struct frame *);
-extern int x_in_use;
 #ifdef USE_GTK
 extern int xg_set_icon (struct frame *, Lisp_Object);
author	Joakim Verona	2013-04-09 00:21:04 +0200
committer	Joakim Verona	2013-04-09 00:21:04 +0200
commit	e25d341cec1ebaee2b96d627d99d4d7b92dee6b0 (patch)
tree	a837c08c8ff2a6054964bd73469f6386368300e7 /src
parent	9639da1e26683b6a54d255bb07a24dd6e0fae354 (diff)
parent	6fcdab68b3e73354fb17f4c8c4f8199d6f63cf30 (diff)
download	emacs-e25d341cec1ebaee2b96d627d99d4d7b92dee6b0.tar.gz emacs-e25d341cec1ebaee2b96d627d99d4d7b92dee6b0.zip