merge trunk

author: Kenichi Handa 2013-04-05 23:17:55 +0900
committer: Kenichi Handa 2013-04-05 23:17:55 +0900
commit: b7a6f9f7919b7fc0871ae768b58f8e746aa7dd9f (patch)
tree: f32c8cce416e346d2953f063a0f22e95382cf57e /src
parent: 251e91474c91e16b101502c2ed7c05fc13e4ecea (diff)
parent: 73931ad14ad7a51d91f10b19ae9ca8cadb256916 (diff)
download: emacs-b7a6f9f7919b7fc0871ae768b58f8e746aa7dd9f.tar.gz
emacs-b7a6f9f7919b7fc0871ae768b58f8e746aa7dd9f.zip
67 files changed, 1618 insertions, 1110 deletions
diff --git a/src/ChangeLog b/src/ChangeLog
index 6b3ca9d3ff3..70e342dfb2f 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -18,6 +18,407 @@
        * 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
+        the upcase table.
+2013-03-27  rzl24ozi  <rzl24ozi@gmail.com>  (tiny changes)
+        * image.c [WINDOWSNT]: Fix calls to DEF_IMGLIB_FN for SVG function.
+2013-03-27  Eli Zaretskii  <eliz@gnu.org>
+        * w32proc.c (IsValidLocale) [__GNUC__]: Don't declare prototype,
+        since MinGW's w32api headers do.  This avoids compiler warnings.
+        * w32.c (FSCTL_GET_REPARSE_POINT) [_MSC_VER || _W64]: Don't define
+        if already defined.
+2013-03-26  Eli Zaretskii  <eliz@gnu.org>
+        * w32.c (_REPARSE_DATA_BUFFER): Condition by _MSVC and _W64.
+2013-03-26  Jan Djärv  <jan.h.d@swipnet.se>
+        * gtkutil.c (style_changed_cb): Check if frame is live and an
+        X frame (Bug#14038).
+2013-03-26  Eli Zaretskii  <eliz@gnu.org>
+        * w32.c (_PROCESS_MEMORY_COUNTERS_EX) [_WIN32_WINNT < 0x0500]:
+        Define only for _WIN32_WINNT less than 0x0500.
+        (_ANONYMOUS_UNION, _ANONYMOUS_STRUCT) [!_W64]: Don't define for
+        MinGW64.
+        Move inclusion of time.h before sys/time.h, so that MinGW64 could
+        see its own definitions of 'struct timeval' and 'struct timezone'.
+        Fix incompatibilities between MinGW.org and MinGW64 headers.
+        * w32term.c (WCRANGE, GLYPHSET): Don't define if _W64 is defined.
+        * w32.c (REPARSE_DATA_BUFFER): Guard with
+        MAXIMUM_REPARSE_DATA_BUFFER_SIZE being defined.
+2013-03-25  Jan Djärv  <jan.h.d@swipnet.se>
+        * xterm.c: Include X11/XKBlib.h
+        (XTring_bell): Use XkbBell if HAVE_XKB (Bug#14041).
+2013-03-24  Andreas Schwab  <schwab@linux-m68k.org>
+        * alloc.c (xpalloc, Fgarbage_collect): Reorder conditions that are
+        written backwards.
+        * blockinput.h (input_blocked_p): Likewise.
+        * bytecode.c (exec_byte_code): Likewise.
+        * callproc.c (call_process_kill, call_process_cleanup)
+        (Fcall_process): Likewise.
+        * ccl.c (ccl_driver, resolve_symbol_ccl_program)
+        (Fccl_execute_on_string): Likewise.
+        * character.c (string_escape_byte8): Likewise.
+        * charset.c (read_hex): Likewise.
+        * cm.c (calccost): Likewise.
+        * data.c (cons_to_unsigned): Likewise.
+        * dired.c (directory_files_internal, file_name_completion):
+        Likewise.
+        * dispnew.c (scrolling_window, update_frame_1, Fsleep_for)
+        (sit_for): Likewise.
+        * doc.c (Fsubstitute_command_keys): Likewise.
+        * doprnt.c (doprnt): Likewise.
+        * editfns.c (hi_time, decode_time_components, Fformat): Likewise.
+        * emacsgtkfixed.c: Likewise.
+        * fileio.c (file_offset, Fwrite_region): Likewise.
+        * floatfns.c (Fexpt, fmod_float): Likewise.
+        * fns.c (larger_vector, make_hash_table, Fmake_hash_table):
+        Likewise.
+        * font.c (font_intern_prop): Likewise.
+        * frame.c (x_set_alpha): Likewise.
+        * gtkutil.c (get_utf8_string): Likewise.
+        * indent.c (check_display_width): Likewise.
+        * intervals.c (create_root_interval, rotate_right, rotate_left)
+        (split_interval_right, split_interval_left)
+        (adjust_intervals_for_insertion, delete_node)
+        (interval_deletion_adjustment, adjust_intervals_for_deletion)
+        (merge_interval_right, merge_interval_left, copy_intervals)
+        (set_intervals_multibyte_1): Likewise.
+        * keyboard.c (gobble_input, append_tool_bar_item): Likewise.
+        * keymap.c (Fkey_description): Likewise.
+        * lisp.h (FIXNUM_OVERFLOW_P, vcopy): Likewise.
+        * lread.c (openp, read_integer, read1, string_to_number):
+        Likewise.
+        * menu.c (ensure_menu_items): Likewise.
+        * minibuf.c (read_minibuf_noninteractive): Likewise.
+        * print.c (printchar, strout): Likewise.
+        * process.c (create_process, Faccept_process_output)
+        (wait_reading_process_output, read_process_output, send_process)
+        (wait_reading_process_output): Likewise.
+        * profiler.c (make_log, handle_profiler_signal): Likewise.
+        * regex.c (re_exec): Likewise.
+        * regex.h: Likewise.
+        * search.c (looking_at_1, Freplace_match): Likewise.
+        * sysdep.c (get_child_status, procfs_ttyname)
+        (procfs_get_total_memory): Likewise.
+        * systime.h (EMACS_TIME_VALID_P): Likewise.
+        * term.c (dissociate_if_controlling_tty): Likewise.
+        * window.c (get_phys_cursor_glyph): Likewise.
+        * xdisp.c (init_iterator, redisplay_internal, redisplay_window)
+        (try_window_reusing_current_matrix, try_window_id, pint2hrstr):
+        Likewise.
+        * xfns.c (Fx_window_property): Likewise.
+        * xmenu.c (set_frame_menubar): Likewise.
+        * xselect.c (x_get_window_property, x_handle_dnd_message):
+        Likewise.
+        * xsmfns.c (smc_save_yourself_CB): Likewise.
+        * xterm.c (x_scroll_bar_set_handle): Likewise.
+2013-03-24  Dmitry Antipov  <dmantipov@yandex.ru>
+        * xfaces.c (Finternal_face_x_get_resource): Allow 3rd (frame) argument
+        to be optional or nil.  Adjust comment and convert it to docstring.
+        * xselect.c (Fx_send_client_event): Rename to Fx_send_client_message.
+        * frame.c (display_x_get_resource, Fx_get_resource): Break long line.
+2013-03-24  Paul Eggert  <eggert@cs.ucla.edu>
+        Static checking by GCC 4.8-20130319.
+        * image.c (gif_load): Assume pass < 3 to pacify GCC.
+        * process.c (Fset_process_datagram_address)
+        (Fmake_network_process): Check get_lisp_to_sockaddr_size return value.
+        * xdisp.c (get_char_face_and_encoding):
+        (get_glyph_face_and_encoding): Ensure that *CHAR2B is initialized.
+        (get_glyph_face_and_encoding): Prepare face before possibly using it.
+        (get_per_char_metric): Don't use CHAR2B if it might not be initialized.
+2013-03-24  Ken Brown  <kbrown@cornell.edu>
+        * w32fns.c (emacs_abort) [CYGWIN]: Define `_open' as a macro to
+        fix compilation on 64-bit Cygwin, where underscores are not
+        automatically prepended.
+        * w32term.c (w32_initialize): Silence compiler warning.
+2013-03-23  Eli Zaretskii  <eliz@gnu.org>
+        * w32term.c (w32fullscreen_hook): Use FRAME_NORMAL_WIDTH,
+        FRAME_NORMAL_HEIGHT, and FRAME_PREV_FSMODE, instead of static
+        variables, to save and restore frame dimensions.  Use
+        FRAME_NORMAL_LEFT and FRAME_NORMAL_TOP to restore frame position
+        after returning from a 'fullscreen' configuration.  use
+        SendMessage instead of PostMessage to send the SC_RESTORE message,
+        to avoid races between the main thread and the input thread.
+        * w32term.h (struct w32_output): New members normal_width,
+        normal_height, normal_top, normal_left, and prev_fsmode.
+        (FRAME_NORMAL_WIDTH, FRAME_NORMAL_HEIGHT, FRAME_NORMAL_TOP)
+        (FRAME_NORMAL_LEFT, FRAME_PREV_FSMODE): New macros to access these
+        members of a frame.
+        * w32term.c (w32fullscreen_hook): Record last value of the frame's
+        'fullscreen' parameter.  Always record previous width and height
+        of the frame, except when switching out of maximized modes, so
+        that they could be restored correctly, instead of resetting to the
+        default frame dimensions.  Send SC_RESTORE command to the frame,
+        unless we are going to send SC_MAXIMIZE, to restore the frame
+        resize hints in the mouse pointer shown by the window manager.
+        (Bug#14032)
+        * frame.c (get_frame_param): Now extern for WINDOWSNT as well.
+        * lisp.h (get_frame_param): Adjust conditions for prototype
+        declaration.
+2013-03-22  Ken Brown  <kbrown@cornell.edu>
+        * unexcw.c: Drop unneeded inclusion of w32common.h.
+        (report_sheap_usage): Declare.
+        (read_exe_header): Add magic numbers for x86_64.
+        (fixup_executable): Fix printf format specifier for unsigned long
+        argument.
+2013-03-22  Dmitry Antipov  <dmantipov@yandex.ru>
+        * frame.h (struct frame): Put menu_bar_window under #ifdef
+        because this member is not needed when X toolkit is in use.
+        (fset_menu_bar_window):
+        * dispnew.c (clear_current_matrices, clear_desired_matrices)
+        (free_glyphs, update_frame):
+        * xdisp.c (expose_frame): Likewise.
+        (display_menu_bar): Likewise.  Remove redundant eassert.
+        * window.h (WINDOW_MENU_BAR_P): Always define to 0 if X
+        toolkit is in use.
+2013-03-21  Paul Eggert  <eggert@cs.ucla.edu>
+        Use functions and constants to manipulate Lisp_Save_Value objects.
+        This replaces code that used macros and strings and token-pasting.
+        The change makes the C source a bit easier to follow,
+        and shrinks the Emacs executable a bit.
+        * alloc.c: Verify some properties of Lisp_Save_Value's representation.
+        (make_save_value): Change 1st arg from string to enum.  All callers
+        changed.
+        (INTX): Remove.
+        (mark_object): Use if, not #if, for GC_MARK_STACK.
+        * lisp.h (SAVE_VALUEP, XSAVE_VALUE, XSAVE_POINTER, XSAVE_INTEGER)
+        (XSAVE_OBJECT): Now functions, not macros.
+        (STRING_BYTES_BOUND): Now just a macro, not a constant too;
+        the constant was never used.
+        (SAVE_SLOT_BITS, SAVE_VALUE_SLOTS, SAVE_TYPE_BITS, SAVE_TYPE_INT_INT)
+        (SAVE_TYPE_INT_INT_INT, SAVE_TYPE_OBJ_OBJ, SAVE_TYPE_OBJ_OBJ_OBJ)
+        (SAVE_TYPE_OBJ_OBJ_OBJ_OBJ, SAVE_TYPE_PTR_INT, SAVE_TYPE_PTR_OBJ)
+        (SAVE_TYPE_PTR_PTR, SAVE_TYPE_PTR_PTR_OBJ, SAVE_TYPE_MEMORY):
+        New constants.
+        (struct Lisp_Save_Value): Replace members area, type0, type1, type2,
+        type3 with a single member save_type.  All uses changed.
+        (save_type, set_save_pointer, set_save_integer): New functions.
+        * print.c (PRINTX): Remove.
+        * alloc.c: Remove redundant static declarations.
 2013-03-20  Dmitry Antipov  <dmantipov@yandex.ru>
        * window.h (struct window): Convert left_col, top_line, total_lines
@@ -5190,8 +5591,8 @@
        a public macro and no need to inline by hand.
 2012-09-26  Tomohiro Matsuyama  <tomo@cx4a.org>
-            Stefan Monnier  <monnier@iro.umontreal.ca>
+            Stefan Monnier  <monnier@iro.umontreal.ca>
-            Juanma Barranquero  <lekktu@gmail.com>
+            Juanma Barranquero  <lekktu@gmail.com>
        * profiler.c: New file.
        * Makefile.in (base_obj): Add profiler.o.
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/alloc.c b/src/alloc.c
index 5e30c1b20ad..7a56c78e2ba 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -323,20 +323,7 @@ static void *min_heap_address, *max_heap_address;
 static struct mem_node mem_z;
 #define MEM_NIL &mem_z
-static struct Lisp_Vector *allocate_vectorlike (ptrdiff_t);
-static void lisp_free (void *);
-static void mark_stack (void);
-static bool live_vector_p (struct mem_node *, void *);
-static bool live_buffer_p (struct mem_node *, void *);
-static bool live_string_p (struct mem_node *, void *);
-static bool live_cons_p (struct mem_node *, void *);
-static bool live_symbol_p (struct mem_node *, void *);
-static bool live_float_p (struct mem_node *, void *);
-static bool live_misc_p (struct mem_node *, void *);
-static void mark_maybe_object (Lisp_Object);
-static void mark_memory (void *, void *);
 #if GC_MARK_STACK || defined GC_MALLOC_CHECK
-static void mem_init (void);
 static struct mem_node *mem_insert (void *, void *, enum mem_type);
 static void mem_insert_fixup (struct mem_node *);
 static void mem_rotate_left (struct mem_node *);
@@ -346,11 +333,6 @@ static void mem_delete_fixup (struct mem_node *);
 static struct mem_node *mem_find (void *);
 #endif
-#if GC_MARK_STACK == GC_MARK_STACK_CHECK_GCPROS
-static void check_gcpros (void);
-#endif
 #endif /* GC_MARK_STACK || GC_MALLOC_CHECK */
 #ifndef DEADP
@@ -3344,56 +3326,50 @@ free_misc (Lisp_Object misc)
  total_free_markers++;
 }
+/* Verify properties of Lisp_Save_Value's representation
+   that are assumed here and elsewhere.  */
+verify (SAVE_UNUSED == 0);
+verify ((SAVE_INTEGER | SAVE_POINTER | SAVE_OBJECT) >> SAVE_SLOT_BITS == 0);
 /* Return a Lisp_Save_Value object with the data saved according to
-   FMT.  Format specifiers are `i' for an integer, `p' for a pointer
+   DATA_TYPE.  DATA_TYPE should be one of SAVE_TYPE_INT_INT, etc.  */
-   and `o' for Lisp_Object.  Up to 4 objects can be specified.  */
 Lisp_Object
-make_save_value (const char *fmt, ...)
+make_save_value (enum Lisp_Save_Type save_type, ...)
 {
  va_list ap;
-  int len = strlen (fmt);
+  int i;
  Lisp_Object val = allocate_misc (Lisp_Misc_Save_Value);
  struct Lisp_Save_Value *p = XSAVE_VALUE (val);
-  eassert (0 < len && len < 5);
+  eassert (0 < save_type
-  va_start (ap, fmt);
+           && (save_type < 1 << (SAVE_TYPE_BITS - 1)
+               || save_type == SAVE_TYPE_MEMORY));
-#define INITX(index)                                           \
+  p->save_type = save_type;
-  do {                                                         \
+  va_start (ap, save_type);
-    if (len <= index)                                          \
+  save_type &= ~ (1 << (SAVE_TYPE_BITS - 1));
-      p->type ## index = SAVE_UNUSED;                          \
-    else                                                       \
+  for (i = 0; save_type; i++, save_type >>= SAVE_SLOT_BITS)
-      {                                                        \
+    switch (save_type & ((1 << SAVE_SLOT_BITS) - 1))
-        if (fmt[index] == 'i')                                 \
+      {
-         {                                                     \
+      case SAVE_POINTER:
-           p->type ## index = SAVE_INTEGER;                    \
+        p->data[i].pointer = va_arg (ap, void *);
-           p->data[index].integer = va_arg (ap, ptrdiff_t);    \
+        break;
-         }                                                     \
-       else if (fmt[index] == 'p')                             \
-         {                                                     \
-           p->type ## index = SAVE_POINTER;                    \
-           p->data[index].pointer = va_arg (ap, void *);       \
-         }                                                     \
-       else if (fmt[index] == 'o')                             \
-         {                                                     \
-           p->type ## index = SAVE_OBJECT;                     \
-           p->data[index].object = va_arg (ap, Lisp_Object);   \
-         }                                                     \
-       else                                                    \
-         emacs_abort ();                                       \
-      }                                                        \
-  } while (0)
-  INITX (0);
+      case SAVE_INTEGER:
-  INITX (1);
+        p->data[i].integer = va_arg (ap, ptrdiff_t);
-  INITX (2);
+        break;
-  INITX (3);
-#undef INITX
+      case SAVE_OBJECT:
+        p->data[i].object = va_arg (ap, Lisp_Object);
+        break;
+      default:
+        emacs_abort ();
+      }
  va_end (ap);
-  p->area = 0;
  return val;
 }
@@ -3404,11 +3380,8 @@ make_save_pointer (void *pointer)
 {
  Lisp_Object val = allocate_misc (Lisp_Misc_Save_Value);
  struct Lisp_Save_Value *p = XSAVE_VALUE (val);
+  p->save_type = SAVE_POINTER;
-  p->area = 0;
-  p->type0 = SAVE_POINTER;
  p->data[0].pointer = pointer;
-  p->type1 = p->type2 = p->type3 = SAVE_UNUSED;
  return val;
 }
@@ -5837,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);
@@ -5976,12 +5948,11 @@ mark_object (Lisp_Object arg)
        case Lisp_Misc_Save_Value:
          XMISCANY (obj)->gcmarkbit = 1;
          {
-            register struct Lisp_Save_Value *ptr = XSAVE_VALUE (obj);
+            struct Lisp_Save_Value *ptr = XSAVE_VALUE (obj);
-            /* If `area' is nonzero, `data[0].pointer' is the address
+            /* If `save_type' is zero, `data[0].pointer' is the address
               of a memory area containing `data[1].integer' potential
               Lisp_Objects.  */
-#if GC_MARK_STACK
+            if (GC_MARK_STACK && ptr->save_type == SAVE_TYPE_MEMORY)
-            if (ptr->area)
              {
                Lisp_Object *p = ptr->data[0].pointer;
                ptrdiff_t nelt;
@@ -5989,17 +5960,12 @@ mark_object (Lisp_Object arg)
                  mark_maybe_object (*p);
              }
            else
-#endif /* GC_MARK_STACK */
              {
                /* Find Lisp_Objects in `data[N]' slots and mark them.  */
-                if (ptr->type0 == SAVE_OBJECT)
+                int i;
-                  mark_object (ptr->data[0].object);
+                for (i = 0; i < SAVE_VALUE_SLOTS; i++)
-                if (ptr->type1 == SAVE_OBJECT)
+                  if (save_type (ptr, i) == SAVE_OBJECT)
-                  mark_object (ptr->data[1].object);
+                    mark_object (ptr->data[i].object);
-                if (ptr->type2 == SAVE_OBJECT)
-                  mark_object (ptr->data[2].object);
-                if (ptr->type3 == SAVE_OBJECT)
-                  mark_object (ptr->data[3].object);
              }
          }
          break;
diff --git a/src/blockinput.h b/src/blockinput.h
index 192c813073d..6dc22c6f5dd 100644
--- a/src/blockinput.h
+++ b/src/blockinput.h
@@ -67,7 +67,7 @@ extern void unblock_input_to (int);
 BLOCKINPUT_INLINE bool
 input_blocked_p (void)
 {
-  return 0 < interrupt_input_blocked;
+  return interrupt_input_blocked > 0;
 }
 INLINE_HEADER_END
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/bytecode.c b/src/bytecode.c
index acb96c1e61b..7676c8550a4 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -660,7 +660,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
         the table clearer.  */
 #define LABEL(OP) [OP] = &&insn_ ## OP
-#if (__GNUC__ == 4 && 6 <= __GNUC_MINOR__) || 4 < __GNUC__
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
 # pragma GCC diagnostic push
 # pragma GCC diagnostic ignored "-Woverride-init"
 #endif
@@ -676,7 +676,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 #undef DEFINE
        };
-#if (__GNUC__ == 4 && 6 <= __GNUC_MINOR__) || 4 < __GNUC__
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
 # pragma GCC diagnostic pop
 #endif
diff --git a/src/callproc.c b/src/callproc.c
index 9132c0dd976..46a37701a40 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -1,5 +1,5 @@
 /* Synchronous subprocess invocation for GNU Emacs.
-   Copyright (C) 1985-1988, 1993-1995, 1999-2012
+   Copyright (C) 1985-1988, 1993-1995, 1999-2013
                 Free Software Foundation, Inc.
 This file is part of GNU Emacs.
@@ -125,7 +125,7 @@ record_kill_process (struct Lisp_Process *p)
 static Lisp_Object
 call_process_kill (Lisp_Object ignored)
 {
-  if (0 <= synch_process_fd)
+  if (synch_process_fd >= 0)
    emacs_close (synch_process_fd);
  if (synch_process_pid)
@@ -173,7 +173,7 @@ call_process_cleanup (Lisp_Object arg)
    }
 #endif
-  if (0 <= synch_process_fd)
+  if (synch_process_fd >= 0)
    emacs_close (synch_process_fd);
 #ifdef MSDOS
@@ -682,7 +682,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
    child_errno = errno;
-    if (0 < pid)
+    if (pid > 0)
      {
        if (INTEGERP (buffer))
          record_deleted_pid (pid);
diff --git a/src/casetab.c b/src/casetab.c
index 76f72b26db3..13bed64e4b2 100644
--- a/src/casetab.c
+++ b/src/casetab.c
@@ -246,7 +246,7 @@ void
 init_casetab_once (void)
 {
  register int i;
-  Lisp_Object down, up;
+  Lisp_Object down, up, eqv;
  DEFSYM (Qcase_table, "case-table");
  /* Intern this now in case it isn't already done.
@@ -275,13 +275,21 @@ init_casetab_once (void)
  for (i = 0; i < 128; i++)
    {
+      int c = (i >= 'a' && i <= 'z') ? i + ('A' - 'a') : i;
+      CHAR_TABLE_SET (up, i, make_number (c));
+    }
+  eqv = Fmake_char_table (Qcase_table, Qnil);
+   for (i = 0; i < 128; i++)
+     {
      int c = ((i >= 'A' && i <= 'Z') ? i + ('a' - 'A')
               : ((i >= 'a' && i <= 'z') ? i + ('A' - 'a')
                  : i));
      CHAR_TABLE_SET (up, i, make_number (c));
    }
-  set_char_table_extras (down, 2, Fcopy_sequence (up));
+  set_char_table_extras (down, 2, eqv);
  /* Fill in what isn't filled in.  */
  set_case_table (down, 1);
diff --git a/src/ccl.c b/src/ccl.c
index 7f77e1d22fa..8fec18296a6 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -2130,7 +2130,7 @@ usage: (ccl-execute-on-string CCL-PROGRAM STATUS STRING &optional CONTINUE UNIBY
          produced_chars += ccl.produced;
          offset = outp - outbuf;
          shortfall = ccl.produced * max_expansion - (outbufsize - offset);
-          if (0 < shortfall)
+          if (shortfall > 0)
            {
              outbuf = xpalloc (outbuf, &outbufsize, shortfall, -1, 1);
              outp = outbuf + offset;
diff --git a/src/cm.c b/src/cm.c
index 3a5f927eda3..481ac15e435 100644
--- a/src/cm.c
+++ b/src/cm.c
@@ -214,7 +214,7 @@ calccost (struct tty_display_info *tty,
    if (doit)
      do
          emacs_tputs (tty, p, 1, cmputc);
-      while (0 < --deltay);
+      while (--deltay > 0);
 x:
    if ((deltax = dstx - srcx) == 0)
        goto done;
@@ -297,7 +297,7 @@ fail:
    if (doit)
      do
          emacs_tputs (tty, p, 1, cmputc);
-      while (0 < --deltax);
+      while (--deltax > 0);
 done:
    return totalcost;
 }
diff --git a/src/dired.c b/src/dired.c
index 0e37568f211..7bbfee7e5b0 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -258,7 +258,7 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
      QUIT;
      if (NILP (match)
-          || (0 <= re_search (bufp, SSDATA (name), len, 0, len, 0)))
+          || re_search (bufp, SSDATA (name), len, 0, len, 0) >= 0)
        wanted = 1;
      immediate_quit = 0;
@@ -517,8 +517,9 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
      QUIT;
      if (len < SCHARS (encoded_file)
-          || 0 <= scmp (dp->d_name, SSDATA (encoded_file),
+          || (scmp (dp->d_name, SSDATA (encoded_file),
-                        SCHARS (encoded_file)))
+                    SCHARS (encoded_file))
+              >= 0))
        continue;
      if (file_name_completion_stat (fd, dp, &st) < 0)
@@ -580,7 +581,7 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
                    if (skip < 0)
                      continue;
-                    if (0 <= scmp (dp->d_name + skip, p1, elt_len))
+                    if (scmp (dp->d_name + skip, p1, elt_len) >= 0)
                      continue;
                    break;
                  }
@@ -602,9 +603,8 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
                    skip = len - SCHARS (elt);
                    if (skip < 0) continue;
-                    if (0 <= scmp (dp->d_name + skip,
+                    if (scmp (dp->d_name + skip, SSDATA (elt), SCHARS (elt))
-                                   SSDATA (elt),
+                        >= 0)
-                                   SCHARS (elt)))
                      continue;
                    break;
                  }
diff --git a/src/dispextern.h b/src/dispextern.h
index 1f269902435..cb2e944d1cc 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1412,25 +1412,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 bc65050605a..b4ca654a8f7 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -223,9 +223,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);
@@ -794,11 +794,13 @@ clear_current_matrices (register struct frame *f)
  if (f->current_matrix)
    clear_glyph_matrix (f->current_matrix);
+#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
  /* Clear the matrix of the menu bar window, if such a window exists.
     The menu bar window is currently used to display menus on X when
     no toolkit support is compiled in.  */
  if (WINDOWP (f->menu_bar_window))
    clear_glyph_matrix (XWINDOW (f->menu_bar_window)->current_matrix);
+#endif
  /* Clear the matrix of the tool-bar window, if any.  */
  if (WINDOWP (f->tool_bar_window))
@@ -818,8 +820,10 @@ clear_desired_matrices (register struct frame *f)
  if (f->desired_matrix)
    clear_glyph_matrix (f->desired_matrix);
+#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
  if (WINDOWP (f->menu_bar_window))
    clear_glyph_matrix (XWINDOW (f->menu_bar_window)->desired_matrix);
+#endif
  if (WINDOWP (f->tool_bar_window))
    clear_glyph_matrix (XWINDOW (f->tool_bar_window)->desired_matrix);
@@ -838,16 +842,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)
@@ -1468,7 +1464,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.  */
@@ -1632,7 +1628,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
@@ -1641,12 +1637,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
@@ -1788,10 +1780,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.  */
@@ -1863,18 +1853,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)))
-            return 1;
-        }
-      else if (!NILP (w->vchild))
        {
-          if (showing_window_margins_p (XWINDOW (w->vchild)))
+          if (showing_window_margins_p (XWINDOW (w->contents)))
            return 1;
        }
-      else if (!NILP (w->left_margin_cols)
+      else if (!NILP (w->left_margin_cols) || !NILP (w->right_margin_cols))
-               || !NILP (w->right_margin_cols))
        return 1;
      w = NILP (w->next) ? 0 : XWINDOW (w->next);
@@ -1895,10 +1879,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;
@@ -2184,6 +2166,7 @@ free_glyphs (struct frame *f)
      if (!NILP (f->root_window))
        free_window_matrices (XWINDOW (f->root_window));
+#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
      /* Free the dummy window for menu bars without X toolkit and its
         glyph matrices.  */
      if (!NILP (f->menu_bar_window))
@@ -2194,6 +2177,7 @@ free_glyphs (struct frame *f)
          w->desired_matrix = w->current_matrix = NULL;
          fset_menu_bar_window (f, Qnil);
        }
+#endif
      /* Free the tool bar window and its glyph matrices.  */
      if (!NILP (f->tool_bar_window))
@@ -2236,10 +2220,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
@@ -2372,10 +2354,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);
@@ -2639,10 +2619,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
@@ -2738,8 +2716,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);
@@ -2775,10 +2753,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;
@@ -2806,11 +2782,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
        {
@@ -2919,10 +2892,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);
@@ -3092,10 +3063,12 @@ update_frame (struct frame *f, bool force_p, bool inhibit_hairy_id_p)
         when pending input is detected.  */
      update_begin (f);
+#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
      /* Update the menu bar on X frames that don't have toolkit
         support.  */
      if (WINDOWP (f->menu_bar_window))
        update_window (XWINDOW (f->menu_bar_window), 1);
+#endif
      /* Update the tool-bar window, if present.  */
      if (WINDOWP (f->tool_bar_window))
@@ -3186,10 +3159,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);
@@ -3967,10 +3938,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;
@@ -4451,7 +4420,7 @@ scrolling_window (struct window *w, bool header_line_p)
    row_table[row_entry_pool[i].bucket] = NULL;
  /* Value is 1 to indicate that we scrolled the display.  */
-  return 0 < nruns;
+  return nruns > 0;
 }
@@ -5117,7 +5086,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)));
@@ -5163,7 +5132,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;
@@ -5181,7 +5150,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));
    }
@@ -5756,7 +5725,7 @@ additional wait period, in milliseconds; this is for backwards compatibility.
      duration += XINT (milliseconds) / 1000.0;
    }
-  if (0 < duration)
+  if (duration > 0)
    {
      EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (duration);
      wait_reading_process_output (min (EMACS_SECS (t), WAIT_READING_MAX),
@@ -5796,7 +5765,7 @@ sit_for (Lisp_Object timeout, bool reading, int display_option)
  if (INTEGERP (timeout))
    {
      sec = XINT (timeout);
-      if (! (0 < sec))
+      if (sec <= 0)
        return Qt;
      nsec = 0;
    }
diff --git a/src/editfns.c b/src/editfns.c
index f34c574cae3..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
@@ -839,14 +839,14 @@ Lisp_Object
 save_excursion_save (void)
 {
  return make_save_value
-    ("oooo",
+    (SAVE_TYPE_OBJ_OBJ_OBJ_OBJ,
     Fpoint_marker (),
     /* Do not copy the mark if it points to nowhere.  */
     (XMARKER (BVAR (current_buffer, mark))->buffer
      ? 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.  */
@@ -3958,7 +3958,7 @@ usage: (format STRING &rest OBJECTS)  */)
                   trailing "d").  */
                pMlen = sizeof pMd - 2
              };
-              verify (0 < USEFUL_PRECISION_MAX);
+              verify (USEFUL_PRECISION_MAX > 0);
              int prec;
              ptrdiff_t padding, sprintf_bytes;
@@ -4241,7 +4241,10 @@ usage: (format STRING &rest OBJECTS)  */)
            memcpy (buf, initial_buffer, used);
          }
        else
-          XSAVE_POINTER (buf_save_value, 0) = buf = xrealloc (buf, bufsize);
+          {
+            buf = xrealloc (buf, bufsize);
+            set_save_pointer (buf_save_value, 0, buf);
+          }
        p = buf + used;
      }
diff --git a/src/emacsgtkfixed.c b/src/emacsgtkfixed.c
index 6a8c751e306..970683da9c4 100644
--- a/src/emacsgtkfixed.c
+++ b/src/emacsgtkfixed.c
@@ -28,7 +28,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "xterm.h"
 /* Silence a bogus diagnostic; see GNOME bug 683906.  */
-#if (__GNUC__ == 4 && 6 <= __GNUC_MINOR__) || 4 < __GNUC__
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
 # pragma GCC diagnostic push
 # pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #endif
diff --git a/src/fileio.c b/src/fileio.c
index 724250c8aaa..2047338f03e 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -3958,7 +3958,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 +4108,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,
@@ -4218,7 +4218,8 @@ by calling `format-decode', which see.  */)
               to be signaled after decoding the text we read.  */
            nbytes = internal_condition_case_1
              (read_non_regular,
-               make_save_value ("iii", (ptrdiff_t) fd, inserted, trytry),
+               make_save_value (SAVE_TYPE_INT_INT_INT, (ptrdiff_t) fd,
+                                inserted, trytry),
               Qerror, read_non_regular_quit);
            if (NILP (nbytes))
@@ -5012,7 +5013,7 @@ This calls `write-region-annotate-functions' at the start, and
      && ! (valid_timestamp_file_system && st.st_dev == timestamp_file_system))
    {
      int desc1 = emacs_open (fn, O_WRONLY | O_BINARY, 0);
-      if (0 <= desc1)
+      if (desc1 >= 0)
        {
          struct stat st1;
          if (fstat (desc1, &st1) == 0
diff --git a/src/floatfns.c b/src/floatfns.c
index 43576a16248..6113758f964 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -193,7 +193,7 @@ DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
  CHECK_NUMBER_OR_FLOAT (arg2);
  if (INTEGERP (arg1)     /* common lisp spec */
      && INTEGERP (arg2)   /* don't promote, if both are ints, and */
-      && 0 <= XINT (arg2)) /* we are sure the result is not fractional */
+      && XINT (arg2) >= 0) /* we are sure the result is not fractional */
    {                           /* this can be improved by pre-calculating */
      EMACS_INT y;              /* some binary powers of x then accumulating */
      EMACS_UINT acc, x;  /* Unsigned so that overflow is well defined.  */
@@ -475,7 +475,7 @@ fmod_float (Lisp_Object x, Lisp_Object y)
  f1 = fmod (f1, f2);
  /* If the "remainder" comes out with the wrong sign, fix it.  */
-  if (f2 < 0 ? 0 < f1 : f1 < 0)
+  if (f2 < 0 ? f1 > 0 : f1 < 0)
    f1 += f2;
  return make_float (f1);
diff --git a/src/font.c b/src/font.c
index ba98d19afa0..17573cdc264 100644
--- a/src/font.c
+++ b/src/font.c
@@ -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,7 +4844,7 @@ If the named font is not yet loaded, return nil.  */)
  Lisp_Object info;
  Lisp_Object font_object;
-  (*check_window_system_func) ();
+  check_window_system ();
  if (! FONTP (name))
    CHECK_STRING (name);
diff --git a/src/fontset.c b/src/fontset.c
index 3578bc9403d..7aec26bbb5b 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 ();
  CHECK_STRING (pattern);
@@ -1919,7 +1915,7 @@ format is the same as above.  */)
  Lisp_Object val, elt;
  int c, i, j, k;
-  (*check_window_system_func) ();
+  check_window_system ();
  fontset = check_fontset_name (fontset, &frame);
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 2ed2c5a2771..5d5876ed097 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -159,15 +159,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 +421,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 +889,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 +1189,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 +1593,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 +1630,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 +1661,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;
    }
@@ -1819,7 +1815,7 @@ See `redirect-frame-focus'.  */)
 /* Return the value of frame parameter PROP in frame FRAME.  */
 #ifdef HAVE_WINDOW_SYSTEM
-#if !HAVE_NS
+#if !HAVE_NS && !defined(WINDOWSNT)
 static
 #endif
 Lisp_Object
@@ -3315,16 +3311,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 || 1.0 < alpha)
+          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 || 100 < ialpha)
+          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);
@@ -3495,11 +3490,10 @@ The optional arguments COMPONENT and SUBCLASS add to the key and the
 class, respectively.  You must specify both of them or neither.
 If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
 and the class is `Emacs.CLASS.SUBCLASS'.  */)
-  (Lisp_Object attribute, Lisp_Object class, Lisp_Object component, Lisp_Object subclass)
+  (Lisp_Object attribute, Lisp_Object class, Lisp_Object component,
+   Lisp_Object subclass)
 {
-#ifdef HAVE_X_WINDOWS
+  check_window_system ();
-  check_x ();
-#endif
  return xrdb_get_resource (check_x_display_info (Qnil)->xrdb,
                            attribute, class, component, subclass);
@@ -3508,7 +3502,9 @@ and the class is `Emacs.CLASS.SUBCLASS'.  */)
 /* Get an X resource, like Fx_get_resource, but for display DPYINFO.  */
 Lisp_Object
-display_x_get_resource (Display_Info *dpyinfo, Lisp_Object attribute, Lisp_Object class, Lisp_Object component, Lisp_Object subclass)
+display_x_get_resource (Display_Info *dpyinfo, Lisp_Object attribute,
+                        Lisp_Object class, Lisp_Object component,
+                        Lisp_Object subclass)
 {
  return xrdb_get_resource (dpyinfo->xrdb,
                            attribute, class, component, subclass);
diff --git a/src/frame.h b/src/frame.h
index 7a4943327eb..46e18dd8ddb 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -170,9 +170,11 @@ struct frame
     most recently buried buffer is first.  For last-buffer.  */
  Lisp_Object buried_buffer_list;
+#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
  /* A dummy window used to display menu bars under X when no X
     toolkit support is available.  */
  Lisp_Object menu_bar_window;
+#endif
  /* A window used to display the tool-bar of a frame.  */
  Lisp_Object tool_bar_window;
@@ -425,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
@@ -515,11 +513,13 @@ fset_menu_bar_vector (struct frame *f, Lisp_Object val)
 {
  f->menu_bar_vector = val;
 }
+#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
 FRAME_INLINE void
 fset_menu_bar_window (struct frame *f, Lisp_Object val)
 {
  f->menu_bar_window = val;
 }
+#endif
 FRAME_INLINE void
 fset_name (struct frame *f, Lisp_Object val)
 {
@@ -781,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,
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/ftfont.c b/src/ftfont.c
index 867e25a7a25..0ad173af98a 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -393,7 +393,7 @@ ftfont_lookup_cache (Lisp_Object key, enum ftfont_cache_for cache_for)
      cache_data = xmalloc (sizeof *cache_data);
      cache_data->ft_face = NULL;
      cache_data->fc_charset = NULL;
-      val = make_save_value ("pi", cache_data, 0);
+      val = make_save_value (SAVE_TYPE_PTR_INT, cache_data, 0);
      cache = Fcons (Qnil, val);
      Fputhash (key, cache, ft_face_cache);
    }
@@ -1211,7 +1211,7 @@ ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
          return Qnil;
        }
    }
-  XSAVE_INTEGER (val, 1)++;
+  set_save_integer (val, 1, XSAVE_INTEGER (val, 1) + 1);
  size = XINT (AREF (entity, FONT_SIZE_INDEX));
  if (size == 0)
    size = pixel_size;
@@ -1326,7 +1326,7 @@ ftfont_close (FRAME_PTR f, struct font *font)
  cache = ftfont_lookup_cache (val, FTFONT_CACHE_FOR_FACE);
  eassert (CONSP (cache));
  val = XCDR (cache);
-  XSAVE_INTEGER (val, 1)--;
+  set_save_integer (val, 1, XSAVE_INTEGER (val, 1) - 1);
  if (XSAVE_INTEGER (val, 1) == 0)
    {
      struct ftfont_cache_data *cache_data = XSAVE_POINTER (val, 0);
diff --git a/src/gtkutil.c b/src/gtkutil.c
index d6e4dcebcd3..f83d8660fcc 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -1094,7 +1094,9 @@ style_changed_cb (GObject *go,
      FOR_EACH_FRAME (rest, frame)
        {
          FRAME_PTR f = XFRAME (frame);
-          if (FRAME_X_DISPLAY (f) == dpy)
+          if (FRAME_LIVE_P (f)
+              && FRAME_X_P (f)
+              && FRAME_X_DISPLAY (f) == dpy)
            {
              x_set_scroll_bar_default_width (f);
              xg_frame_set_char_size (f, FRAME_COLS (f), FRAME_LINES (f));
diff --git a/src/image.c b/src/image.c
index 3eec8b6c13d..cac23b7fa87 100644
--- a/src/image.c
+++ b/src/image.c
@@ -7373,11 +7373,10 @@ gif_load (struct frame *f, struct image *img)
               y < subimg_height;
               y++, row += interlace_increment[pass])
            {
-              if (row >= subimg_height)
+              while (subimg_height <= row)
                {
+                  lint_assume (pass < 3);
                  row = interlace_start[++pass];
-                  while (row >= subimg_height)
-                    row = interlace_start[++pass];
                }
              for (x = 0; x < subimg_width; x++)
@@ -8121,24 +8120,25 @@ svg_image_p (Lisp_Object object)
 #ifdef WINDOWSNT
 /* SVG library functions.  */
-DEF_IMGLIB_FN (RsvgHandle *, rsvg_handle_new);
+DEF_IMGLIB_FN (RsvgHandle *, rsvg_handle_new, (void));
-DEF_IMGLIB_FN (void, rsvg_handle_get_dimensions);
+DEF_IMGLIB_FN (void, rsvg_handle_get_dimensions, (RsvgHandle *, RsvgDimensionData *));
-DEF_IMGLIB_FN (gboolean, rsvg_handle_write);
+DEF_IMGLIB_FN (gboolean, rsvg_handle_write, (RsvgHandle *, const guchar *, gsize, GError **));
-DEF_IMGLIB_FN (gboolean, rsvg_handle_close);
+DEF_IMGLIB_FN (gboolean, rsvg_handle_close, (RsvgHandle *, GError **));
-DEF_IMGLIB_FN (GdkPixbuf *, rsvg_handle_get_pixbuf);
+DEF_IMGLIB_FN (GdkPixbuf *, rsvg_handle_get_pixbuf, (RsvgHandle *));
+DEF_IMGLIB_FN (void *, rsvg_handle_set_size_callback, (RsvgHandle *, RsvgSizeFunc, gpointer, GDestroyNotify));
-DEF_IMGLIB_FN (int, gdk_pixbuf_get_width);
-DEF_IMGLIB_FN (int, gdk_pixbuf_get_height);
+DEF_IMGLIB_FN (int, gdk_pixbuf_get_width, (const GdkPixbuf *));
-DEF_IMGLIB_FN (guchar *, gdk_pixbuf_get_pixels);
+DEF_IMGLIB_FN (int, gdk_pixbuf_get_height, (const GdkPixbuf *));
-DEF_IMGLIB_FN (int, gdk_pixbuf_get_rowstride);
+DEF_IMGLIB_FN (guchar *, gdk_pixbuf_get_pixels, (const GdkPixbuf *));
-DEF_IMGLIB_FN (GdkColorspace, gdk_pixbuf_get_colorspace);
+DEF_IMGLIB_FN (int, gdk_pixbuf_get_rowstride, (const GdkPixbuf *));
-DEF_IMGLIB_FN (int, gdk_pixbuf_get_n_channels);
+DEF_IMGLIB_FN (GdkColorspace, gdk_pixbuf_get_colorspace, (const GdkPixbuf *));
-DEF_IMGLIB_FN (gboolean, gdk_pixbuf_get_has_alpha);
+DEF_IMGLIB_FN (int, gdk_pixbuf_get_n_channels, (const GdkPixbuf *));
-DEF_IMGLIB_FN (int, gdk_pixbuf_get_bits_per_sample);
+DEF_IMGLIB_FN (gboolean, gdk_pixbuf_get_has_alpha, (const GdkPixbuf *));
+DEF_IMGLIB_FN (int, gdk_pixbuf_get_bits_per_sample, (const GdkPixbuf *));
-DEF_IMGLIB_FN (void, g_type_init);
-DEF_IMGLIB_FN (void, g_object_unref);
+DEF_IMGLIB_FN (void, g_type_init, (void));
-DEF_IMGLIB_FN (void, g_error_free);
+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 d1f95da6bcf..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;
@@ -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 3dd81ffeb62..8029291cd68 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -1801,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/intervals.c b/src/intervals.c
index db38c86c00b..f65ce0ecc77 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -110,14 +110,14 @@ create_root_interval (Lisp_Object parent)
    {
      new->total_length = (BUF_Z (XBUFFER (parent))
                           - BUF_BEG (XBUFFER (parent)));
-      eassert (0 <= TOTAL_LENGTH (new));
+      eassert (TOTAL_LENGTH (new) >= 0);
      set_buffer_intervals (XBUFFER (parent), new);
      new->position = BEG;
    }
  else if (STRINGP (parent))
    {
      new->total_length = SCHARS (parent);
-      eassert (0 <= TOTAL_LENGTH (new));
+      eassert (TOTAL_LENGTH (new) >= 0);
      set_string_intervals (parent, new);
      new->position = 0;
    }
@@ -371,11 +371,11 @@ rotate_right (INTERVAL interval)
  /* A's total length is decreased by the length of B and its left child.  */
  interval->total_length -= B->total_length - LEFT_TOTAL_LENGTH (interval);
-  eassert (0 <= TOTAL_LENGTH (interval));
+  eassert (TOTAL_LENGTH (interval) >= 0);
  /* B must have the same total length of A.  */
  B->total_length = old_total;
-  eassert (0 <= TOTAL_LENGTH (B));
+  eassert (TOTAL_LENGTH (B) >= 0);
  return B;
 }
@@ -418,11 +418,11 @@ rotate_left (INTERVAL interval)
  /* A's total length is decreased by the length of B and its right child.  */
  interval->total_length -= B->total_length - RIGHT_TOTAL_LENGTH (interval);
-  eassert (0 <= TOTAL_LENGTH (interval));
+  eassert (TOTAL_LENGTH (interval) >= 0);
  /* B must have the same total length of A.  */
  B->total_length = old_total;
-  eassert (0 <= TOTAL_LENGTH (B));
+  eassert (TOTAL_LENGTH (B) >= 0);
  return B;
 }
@@ -556,7 +556,7 @@ split_interval_right (INTERVAL interval, ptrdiff_t offset)
    {
      set_interval_right (interval, new);
      new->total_length = new_length;
-      eassert (0 <= TOTAL_LENGTH (new));
+      eassert (TOTAL_LENGTH (new) >= 0);
    }
  else
    {
@@ -565,7 +565,7 @@ split_interval_right (INTERVAL interval, ptrdiff_t offset)
      set_interval_parent (interval->right, new);
      set_interval_right (interval, new);
      new->total_length = new_length + new->right->total_length;
-      eassert (0 <= TOTAL_LENGTH (new));
+      eassert (TOTAL_LENGTH (new) >= 0);
      balance_an_interval (new);
    }
@@ -601,7 +601,7 @@ split_interval_left (INTERVAL interval, ptrdiff_t offset)
    {
      set_interval_left (interval, new);
      new->total_length = new_length;
-      eassert (0 <= TOTAL_LENGTH (new));
+      eassert (TOTAL_LENGTH (new) >= 0);
    }
  else
    {
@@ -610,7 +610,7 @@ split_interval_left (INTERVAL interval, ptrdiff_t offset)
      set_interval_parent (new->left, new);
      set_interval_left (interval, new);
      new->total_length = new_length + new->left->total_length;
-      eassert (0 <= TOTAL_LENGTH (new));
+      eassert (TOTAL_LENGTH (new) >= 0);
      balance_an_interval (new);
    }
@@ -960,7 +960,7 @@ adjust_intervals_for_insertion (INTERVAL tree,
      for (temp = prev ? prev : i; temp; temp = INTERVAL_PARENT_OR_NULL (temp))
        {
          temp->total_length += length;
-          eassert (0 <= TOTAL_LENGTH (temp));
+          eassert (TOTAL_LENGTH (temp) >= 0);
          temp = balance_possible_root_interval (temp);
        }
@@ -1016,7 +1016,7 @@ adjust_intervals_for_insertion (INTERVAL tree,
      for (temp = i; temp; temp = INTERVAL_PARENT_OR_NULL (temp))
        {
          temp->total_length += length;
-          eassert (0 <= TOTAL_LENGTH (temp));
+          eassert (TOTAL_LENGTH (temp) >= 0);
          temp = balance_possible_root_interval (temp);
        }
    }
@@ -1218,7 +1218,7 @@ delete_node (register INTERVAL i)
      this = this->left;
      this->total_length += migrate_amt;
    }
-  eassert (0 <= TOTAL_LENGTH (this));
+  eassert (TOTAL_LENGTH (this) >= 0);
  set_interval_left (this, migrate);
  set_interval_parent (migrate, this);
@@ -1300,7 +1300,7 @@ interval_deletion_adjustment (register INTERVAL tree, register ptrdiff_t from,
                                                         relative_position,
                                                         amount);
      tree->total_length -= subtract;
-      eassert (0 <= TOTAL_LENGTH (tree));
+      eassert (TOTAL_LENGTH (tree) >= 0);
      return subtract;
    }
  /* Right branch.  */
@@ -1315,7 +1315,7 @@ interval_deletion_adjustment (register INTERVAL tree, register ptrdiff_t from,
                                               relative_position,
                                               amount);
      tree->total_length -= subtract;
-      eassert (0 <= TOTAL_LENGTH (tree));
+      eassert (TOTAL_LENGTH (tree) >= 0);
      return subtract;
    }
  /* Here -- this node.  */
@@ -1330,7 +1330,7 @@ interval_deletion_adjustment (register INTERVAL tree, register ptrdiff_t from,
        amount = my_amount;
      tree->total_length -= amount;
-      eassert (0 <= TOTAL_LENGTH (tree));
+      eassert (TOTAL_LENGTH (tree) >= 0);
      if (LENGTH (tree) == 0)
        delete_interval (tree);
@@ -1372,7 +1372,7 @@ adjust_intervals_for_deletion (struct buffer *buffer,
  if (ONLY_INTERVAL_P (tree))
    {
      tree->total_length -= length;
-      eassert (0 <= TOTAL_LENGTH (tree));
+      eassert (TOTAL_LENGTH (tree) >= 0);
      return;
    }
@@ -1435,19 +1435,19 @@ merge_interval_right (register INTERVAL i)
      while (! NULL_LEFT_CHILD (successor))
        {
          successor->total_length += absorb;
-          eassert (0 <= TOTAL_LENGTH (successor));
+          eassert (TOTAL_LENGTH (successor) >= 0);
          successor = successor->left;
        }
      successor->total_length += absorb;
-      eassert (0 <= TOTAL_LENGTH (successor));
+      eassert (TOTAL_LENGTH (successor) >= 0);
      delete_interval (i);
      return successor;
    }
  /* Zero out this interval.  */
  i->total_length -= absorb;
-  eassert (0 <= TOTAL_LENGTH (i));
+  eassert (TOTAL_LENGTH (i) >= 0);
  successor = i;
  while (! NULL_PARENT (successor))        /* It's above us.  Subtract as
@@ -1462,7 +1462,7 @@ merge_interval_right (register INTERVAL i)
      successor = INTERVAL_PARENT (successor);
      successor->total_length -= absorb;
-      eassert (0 <= TOTAL_LENGTH (successor));
+      eassert (TOTAL_LENGTH (successor) >= 0);
    }
  /* This must be the rightmost or last interval and cannot
@@ -1491,19 +1491,19 @@ merge_interval_left (register INTERVAL i)
      while (! NULL_RIGHT_CHILD (predecessor))
        {
          predecessor->total_length += absorb;
-          eassert (0 <= TOTAL_LENGTH (predecessor));
+          eassert (TOTAL_LENGTH (predecessor) >= 0);
          predecessor = predecessor->right;
        }
      predecessor->total_length += absorb;
-      eassert (0 <= TOTAL_LENGTH (predecessor));
+      eassert (TOTAL_LENGTH (predecessor) >= 0);
      delete_interval (i);
      return predecessor;
    }
  /* Zero out this interval.  */
  i->total_length -= absorb;
-  eassert (0 <= TOTAL_LENGTH (i));
+  eassert (TOTAL_LENGTH (i) >= 0);
  predecessor = i;
  while (! NULL_PARENT (predecessor))   /* It's above us.  Go up,
@@ -1518,7 +1518,7 @@ merge_interval_left (register INTERVAL i)
      predecessor = INTERVAL_PARENT (predecessor);
      predecessor->total_length -= absorb;
-      eassert (0 <= TOTAL_LENGTH (predecessor));
+      eassert (TOTAL_LENGTH (predecessor) >= 0);
    }
  /* This must be the leftmost or first interval and cannot
@@ -2272,7 +2272,7 @@ copy_intervals (INTERVAL tree, ptrdiff_t start, ptrdiff_t length)
  new->position = 0;
  got = (LENGTH (i) - (start - i->position));
  new->total_length = length;
-  eassert (0 <= TOTAL_LENGTH (new));
+  eassert (TOTAL_LENGTH (new) >= 0);
  copy_properties (i, new);
  t = new;
@@ -2355,7 +2355,7 @@ set_intervals_multibyte_1 (INTERVAL i, bool multi_flag,
    i->total_length = end - start;
  else
    i->total_length = end_byte - start_byte;
-  eassert (0 <= TOTAL_LENGTH (i));
+  eassert (TOTAL_LENGTH (i) >= 0);
  if (TOTAL_LENGTH (i) == 0)
    {
diff --git a/src/keyboard.c b/src/keyboard.c
index e43b7a73172..beba3025887 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
@@ -833,7 +827,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;
@@ -1395,7 +1389,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.  */
@@ -1461,7 +1455,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;
@@ -1492,7 +1486,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;
        }
@@ -1512,8 +1506,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
@@ -5142,7 +5134,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;
@@ -6766,7 +6758,7 @@ gobble_input (void)
          hold_quit.kind = NO_EVENT;
          /* No need for FIONREAD or fcntl; just say don't wait.  */
-          while (0 < (nr = (*t->read_socket_hook) (t, &hold_quit)))
+          while ((nr = (*t->read_socket_hook) (t, &hold_quit)) > 0)
            nread += nr;
          if (nr == -1)          /* Not OK to read input now.  */
@@ -8240,9 +8232,8 @@ append_tool_bar_item (void)
       - (ASIZE (tool_bar_items_vector) - TOOL_BAR_ITEM_NSLOTS));
  /* Enlarge tool_bar_items_vector if necessary.  */
-  if (0 < incr)
+  if (incr > 0)
-    tool_bar_items_vector
+    tool_bar_items_vector = larger_vector (tool_bar_items_vector, incr, -1);
-      = larger_vector (tool_bar_items_vector, incr, -1);
  /* Append entries from tool_bar_item_properties to the end of
     tool_bar_items_vector.  */
@@ -9146,9 +9137,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;
@@ -9196,9 +9187,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);
            }
@@ -9247,8 +9238,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++;
@@ -9269,7 +9260,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;
                    }
                }
@@ -11048,9 +11039,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 00eefb375ef..c43d528b25b 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -611,7 +611,8 @@ map_keymap_internal (Lisp_Object map,
        }
      else if (CHAR_TABLE_P (binding))
        map_char_table (map_keymap_char_table_item, Qnil, binding,
-                        make_save_value ("ppo", fun, data, args));
+                        make_save_value (SAVE_TYPE_PTR_PTR_OBJ,
+                                         fun, data, args));
    }
  UNGCPRO;
  return tail;
@@ -1555,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
@@ -1566,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));
        }
    }
diff --git a/src/lisp.h b/src/lisp.h
index f526cd36a6f..2e1d20a5109 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -551,6 +551,7 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
  return num < lower ? lower : num <= upper ? num : upper;
 }
 /* Extract a value or address from a Lisp_Object.  */
 #define XCONS(a)   (eassert (CONSP (a)), \
@@ -571,7 +572,6 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
 #define XMISCTYPE(a)   (XMISCANY (a)->type)
 #define XMARKER(a)      (eassert (MARKERP (a)), &(XMISC (a)->u_marker))
 #define XOVERLAY(a)     (eassert (OVERLAYP (a)), &(XMISC (a)->u_overlay))
-#define XSAVE_VALUE(a)  (eassert (SAVE_VALUEP (a)), &(XMISC (a)->u_save_value))
 /* Forwarding object types.  */
@@ -781,13 +781,10 @@ extern ptrdiff_t string_bytes (struct Lisp_String *);
   would expose alloc.c internal details that we'd rather keep
   private.
-   This is a macro for use in static initializers, and a constant for
+   This is a macro for use in static initializers.  The cast to
-   visibility to GDB.  The cast to ptrdiff_t ensures that
+   ptrdiff_t ensures that the macro is signed.  */
-   the macro is signed.  */
-static ptrdiff_t const STRING_BYTES_BOUND =
 #define STRING_BYTES_BOUND  \
  ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, min (SIZE_MAX, PTRDIFF_MAX) - 1))
-        STRING_BYTES_BOUND;
 /* Mark STR as a unibyte string.  */
 #define STRING_SET_UNIBYTE(STR)  \
@@ -1392,6 +1389,35 @@ enum
    SAVE_OBJECT
  };
+/* Number of bits needed to store one of the above values.  */
+enum { SAVE_SLOT_BITS = 2 };
+/* Number of slots in a save value where save_type is nonzero.  */
+enum { SAVE_VALUE_SLOTS = 4 };
+/* Bit-width and values for struct Lisp_Save_Value's save_type member.  */
+enum { SAVE_TYPE_BITS = SAVE_VALUE_SLOTS * SAVE_SLOT_BITS + 1 };
+enum Lisp_Save_Type
+  {
+    SAVE_TYPE_INT_INT = SAVE_INTEGER + (SAVE_INTEGER << SAVE_SLOT_BITS),
+    SAVE_TYPE_INT_INT_INT
+      = (SAVE_INTEGER + (SAVE_TYPE_INT_INT << SAVE_SLOT_BITS)),
+    SAVE_TYPE_OBJ_OBJ = SAVE_OBJECT + (SAVE_OBJECT << SAVE_SLOT_BITS),
+    SAVE_TYPE_OBJ_OBJ_OBJ = SAVE_OBJECT + (SAVE_TYPE_OBJ_OBJ << SAVE_SLOT_BITS),
+    SAVE_TYPE_OBJ_OBJ_OBJ_OBJ
+      = SAVE_OBJECT + (SAVE_TYPE_OBJ_OBJ_OBJ << SAVE_SLOT_BITS),
+    SAVE_TYPE_PTR_INT = SAVE_POINTER + (SAVE_INTEGER << SAVE_SLOT_BITS),
+    SAVE_TYPE_PTR_OBJ = SAVE_POINTER + (SAVE_OBJECT << SAVE_SLOT_BITS),
+    SAVE_TYPE_PTR_PTR = SAVE_POINTER + (SAVE_POINTER << SAVE_SLOT_BITS),
+    SAVE_TYPE_PTR_PTR_OBJ
+      = SAVE_POINTER + (SAVE_TYPE_PTR_OBJ << SAVE_SLOT_BITS),
+    /* This has an extra bit indicating it's raw memory.  */
+    SAVE_TYPE_MEMORY = SAVE_TYPE_PTR_INT + (1 << (SAVE_TYPE_BITS - 1))
+  };
 /* Special object used to hold a different values for later use.
   This is mostly used to package C integers and pointers to call
@@ -1412,74 +1438,50 @@ enum
   If yon need to pass more than just one C pointer, you should
   use make_save_value.  This function allows you to pack up to
-   4 integers, pointers or Lisp_Objects and conveniently get them
+   SAVE_VALUE_SLOTS integers, pointers or Lisp_Objects and
-   back with XSAVE_POINTER, XSAVE_INTEGER and XSAVE_OBJECT macros:
+   conveniently get them back with XSAVE_POINTER, XSAVE_INTEGER and
+   XSAVE_OBJECT macros:
   ...
     struct my_data *md = get_my_data ();
-     ptrdiff_t my_offset = get_my_offset ();
     Lisp_Object my_object = get_my_object ();
     record_unwind_protect
-       (my_unwind, make_save_value ("pio", md, my_offset, my_object));
+       (my_unwind, make_save_value (SAVE_TYPE_PTR_OBJ, md, my_object));
   ...
   Lisp_Object my_unwind (Lisp_Object arg)
   {
     struct my_data *md = XSAVE_POINTER (arg, 0);
-     ptrdiff_t my_offset = XSAVE_INTEGER (arg, 1);
+     Lisp_Object my_object = XSAVE_OBJECT (arg, 1);
-     Lisp_Object my_object = XSAVE_OBJECT (arg, 2);
     ...
   }
   If ENABLE_CHECKING is in effect, XSAVE_xxx macros do type checking of the
   saved objects and raise eassert if type of the saved object doesn't match
   the type which is extracted.  In the example above, XSAVE_INTEGER (arg, 2)
-   or XSAVE_OBJECT (arg, 1) are wrong because integer was saved in slot 1 and
+   or XSAVE_OBJECT (arg, 0) are wrong because nothing was saved in slot 2 and
-   Lisp_Object was saved in slot 2 of ARG.  */
+   Lisp_Object was saved in slot 1 of ARG.  */
 struct Lisp_Save_Value
  {
    ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Save_Value */
    unsigned gcmarkbit : 1;
-    int spacer : 6;
+    int spacer : 32 - (16 + 1 + SAVE_TYPE_BITS);
-    /* If `area' is nonzero, `data[0].pointer' is the address of a memory area
-       containing `data[1].integer' potential Lisp_Objects.  The rest of `data'
+    /* DATA[N] may hold up to SAVE_VALUE_SLOTS entries.  The type of
-       fields are unused.  */
+       V's Ith entry is given by save_type (V, I).  E.g., if save_type
-    unsigned area : 1;
+       (V, 3) == SAVE_INTEGER, V->data[3].integer is in use.
-    /* If `area' is zero, `data[N]' may hold different objects which type is
-       encoded in `typeN' fields as described by the anonymous enum above.
+       If SAVE_TYPE == SAVE_TYPE_MEMORY, DATA[0].pointer is the address of
-       E.g. if `type0' is SAVE_INTEGER, `data[0].integer' is in use.  */
+       a memory area containing DATA[1].integer potential Lisp_Objects.  */
-    unsigned type0 : 2;
+    ENUM_BF (Lisp_Save_Type) save_type : SAVE_TYPE_BITS;
-    unsigned type1 : 2;
-    unsigned type2 : 2;
-    unsigned type3 : 2;
    union {
      void *pointer;
      ptrdiff_t integer;
      Lisp_Object object;
-    } data[4];
+    } data[SAVE_VALUE_SLOTS];
  };
-/* Macro to set and extract Nth saved pointer.  Type
-   checking is ugly because it's used as an lvalue.  */
-#define XSAVE_POINTER(obj, n)                                   \
-  XSAVE_VALUE (obj)->data[(eassert (XSAVE_VALUE (obj)->type     \
-    ## n == SAVE_POINTER), n)].pointer
-/* Likewise for the saved integer.  */
-#define XSAVE_INTEGER(obj, n)                                   \
-  XSAVE_VALUE (obj)->data[(eassert (XSAVE_VALUE (obj)->type     \
-    ## n == SAVE_INTEGER), n)].integer
-/* Macro to extract Nth saved object.  This is never used as
-   an lvalue, so we can do more convenient type checking.  */
-#define XSAVE_OBJECT(obj, n)                                    \
-  (eassert (XSAVE_VALUE (obj)->type ## n == SAVE_OBJECT),       \
-   XSAVE_VALUE (obj)->data[n].object)
 /* A miscellaneous object, when it's on the free list.  */
 struct Lisp_Free
  {
@@ -1786,7 +1788,66 @@ typedef struct {
 #define VECTORP(x) (VECTORLIKEP (x) && !(ASIZE (x) & PSEUDOVECTOR_FLAG))
 #define OVERLAYP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
 #define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
-#define SAVE_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Save_Value)
+LISP_INLINE bool
+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)))
@@ -3105,7 +3166,7 @@ extern bool abort_on_gc;
 extern Lisp_Object make_float (double);
 extern void display_malloc_warning (void);
 extern ptrdiff_t inhibit_garbage_collection (void);
-extern Lisp_Object make_save_value (const char *, ...);
+extern Lisp_Object make_save_value (enum Lisp_Save_Type, ...);
 extern Lisp_Object make_save_pointer (void *);
 extern Lisp_Object build_overlay (Lisp_Object, Lisp_Object, Lisp_Object);
 extern void free_marker (Lisp_Object);
@@ -3445,7 +3506,7 @@ extern Lisp_Object Qvisible;
 extern void store_frame_param (struct frame *, Lisp_Object, Lisp_Object);
 extern void store_in_alist (Lisp_Object *, Lisp_Object, Lisp_Object);
 extern Lisp_Object do_switch_frame (Lisp_Object, int, int, Lisp_Object);
-#if HAVE_NS
+#if HAVE_NS || defined(WINDOWSNT)
 extern Lisp_Object get_frame_param (struct frame *, Lisp_Object);
 #endif
 extern void frames_discard_buffer (Lisp_Object);
@@ -3704,6 +3765,11 @@ extern void syms_of_xterm (void);
 extern char *x_get_keysym_name (int);
 #endif /* HAVE_WINDOW_SYSTEM */
+#if defined(HAVE_WINDOW_SYSTEM) || defined (MSDOS)
+/* Defined in (x|w32)fns.c, nsfns.m, msdos.c.  */
+extern void check_window_system (void);
+#endif
 #ifdef HAVE_LIBXML2
 /* Defined in xml.c.  */
 extern void syms_of_xml (void);
@@ -3711,7 +3777,7 @@ extern void xml_cleanup_parser (void);
 #endif
 #ifdef HAVE_MENUS
-/* Defined in (x|w32)fns.c, nsfns.m...  */
+/* Defined in (x|w32)fns.c, nsfns.m, msdos.c.  */
 extern int have_menus_p (void);
 #endif
@@ -3822,8 +3888,7 @@ extern void *record_xmalloc (size_t);
      {                                                        \
        Lisp_Object arg_;                                      \
        buf = xmalloc ((nelt) * word_size);                    \
-        arg_ = make_save_value ("pi", buf, nelt);              \
+        arg_ = make_save_value (SAVE_TYPE_MEMORY, buf, nelt);  \
-        XSAVE_VALUE (arg_)->area = 1;                          \
        sa_must_free = 1;                                      \
        record_unwind_protect (safe_alloca_unwind, arg_);      \
      }                                                        \
diff --git a/src/lread.c b/src/lread.c
index f8ab03af218..8e623e838c7 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1571,7 +1571,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *sto
                {
                  struct stat st;
                  fd = emacs_open (pfn, O_RDONLY, 0);
-                  if (0 <= fd
+                  if (fd >= 0
                      && (fstat (fd, &st) != 0 || S_ISDIR (st.st_mode)))
                    {
                      emacs_close (fd);
@@ -2359,7 +2359,7 @@ read_integer (Lisp_Object readcharfun, EMACS_INT radix)
          while (c == '0');
        }
-      while (-1 <= (digit = digit_to_number (c, radix)))
+      while ((digit = digit_to_number (c, radix)) >= -1)
        {
          if (digit == -1)
            valid = 0;
@@ -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)))
            {
@@ -3298,12 +3298,12 @@ string_to_number (char const *string, int base, bool ignore_trailing)
  state = 0;
  leading_digit = digit_to_number (*cp, base);
-  if (0 <= leading_digit)
+  if (leading_digit >= 0)
    {
      state |= LEAD_INT;
      do
        ++cp;
-      while (0 <= digit_to_number (*cp, base));
+      while (digit_to_number (*cp, base) >= 0);
    }
  if (*cp == '.')
    {
@@ -3380,7 +3380,7 @@ string_to_number (char const *string, int base, bool ignore_trailing)
  /* If the number uses integer and not float syntax, and is in C-language
     range, use its value, preferably as a fixnum.  */
-  if (0 <= leading_digit && ! float_syntax)
+  if (leading_digit >= 0 && ! float_syntax)
    {
      uintmax_t n;
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 fdef54dd657..ec9c681a3a9 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -173,7 +173,7 @@ static void
 ensure_menu_items (int items)
 {
  int incr = items - (menu_items_allocated - menu_items_used);
-  if (0 < incr)
+  if (incr > 0)
    {
      menu_items = larger_vector (menu_items, incr, INT_MAX);
      menu_items_allocated = ASIZE (menu_items);
@@ -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 ();
    /* 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 25425cb97dc..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).  */
@@ -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..dc79b66e0b1 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");
diff --git a/src/nsfns.m b/src/nsfns.m
index 9c3051a8c6a..f7cf898c7a9 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -109,7 +109,7 @@ static ptrdiff_t image_cache_refcount;
 void
-check_ns (void)
+check_window_system (void)
 {
 if (NSApp == nil)
   error ("OpenStep is not in use or not initialized");
@@ -619,7 +619,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,7 +1145,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
  Lisp_Object tfont, tfontsize;
  static int desc_ctr = 1;
-  check_ns ();
+  check_window_system ();
  /* x_get_arg modifies parms.  */
  parms = Fcopy_alist (parms);
@@ -1442,7 +1442,7 @@ DEFUN ("ns-popup-font-panel", Fns_popup_font_panel, Sns_popup_font_panel,
  id fm;
  struct frame *f;
-  check_ns ();
+  check_window_system ();
  fm = [NSFontManager sharedFontManager];
  if (NILP (frame))
    f = SELECTED_FRAME ();
@@ -1466,7 +1466,7 @@ DEFUN ("ns-popup-color-panel", Fns_popup_color_panel, Sns_popup_color_panel,
 {
  struct frame *f;
-  check_ns ();
+  check_window_system ();
  if (NILP (frame))
    f = SELECTED_FRAME ();
  else
@@ -1503,7 +1503,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 ();
  if (fileDelegate == nil)
    fileDelegate = [EmacsFileDelegate new];
@@ -1594,7 +1594,7 @@ If OWNER is nil, Emacs is assumed.  */)
 {
  const char *value;
-  check_ns ();
+  check_window_system ();
  if (NILP (owner))
    owner = build_string([ns_app_name UTF8String]);
  CHECK_STRING (name);
@@ -1614,7 +1614,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 ();
  if (NILP (owner))
    owner = build_string ([ns_app_name UTF8String]);
  CHECK_STRING (name);
@@ -1642,7 +1642,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_window_system ();
  /* This function has no real equivalent under NeXTstep.  Return nil to
     indicate this. */
  return Qnil;
@@ -1692,7 +1692,7 @@ If omitted or nil, the selected frame's display is used.  */)
 {
  int num;
-  check_ns ();
+  check_window_system ();
  num = [[NSScreen screens] count];
  return (num != 0) ? make_number (num) : Qnil;
@@ -1706,7 +1706,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_window_system ();
  return make_number ((int)
                     ([ns_get_screen (display) frame].size.height/(92.0/25.4)));
 }
@@ -1719,7 +1719,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_window_system ();
  return make_number ((int)
                     ([ns_get_screen (display) frame].size.width/(92.0/25.4)));
 }
@@ -1733,7 +1733,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_window_system ();
  switch ([ns_get_window (display) backingType])
    {
    case NSBackingStoreBuffered:
@@ -1759,7 +1759,7 @@ If omitted or nil, the selected frame's display is used.  */)
     (Lisp_Object display)
 {
  NSWindowDepth depth;
-  check_ns ();
+  check_window_system ();
  depth = [ns_get_screen (display) depth];
  if ( depth == NSBestDepth (NSCalibratedWhiteColorSpace, 2, 2, YES, NULL))
@@ -1786,7 +1786,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_window_system ();
  switch ([ns_get_window (display) backingType])
    {
    case NSBackingStoreBuffered:
@@ -1839,7 +1839,7 @@ DEFUN ("x-close-connection", Fx_close_connection, Sx_close_connection,
 The argument DISPLAY is currently ignored.  */)
     (Lisp_Object display)
 {
-  check_ns ();
+  check_window_system ();
  /*ns_delete_terminal (dpyinfo->terminal); */
  [NSApp terminate: NSApp];
  return Qnil;
@@ -1865,7 +1865,7 @@ DEFUN ("ns-hide-others", Fns_hide_others, Sns_hide_others,
       doc: /* Hides all applications other than Emacs.  */)
     (void)
 {
-  check_ns ();
+  check_window_system ();
  [NSApp hideOtherApplications: NSApp];
  return Qnil;
 }
@@ -1878,7 +1878,7 @@ If ON is equal to `activate', Emacs is unhidden and becomes
 the active application.  */)
     (Lisp_Object on)
 {
-  check_ns ();
+  check_window_system ();
  if (EQ (on, intern ("activate")))
    {
      [NSApp unhide: NSApp];
@@ -1897,7 +1897,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 ();
  [NSApp orderFrontStandardAboutPanel: nil];
  return Qnil;
 }
@@ -1975,7 +1975,7 @@ DEFUN ("ns-list-services", Fns_list_services, Sns_list_services, 0, 0, 0,
  NSMenu *svcs;
  id delegate;
-  check_ns ();
+  check_window_system ();
  svcs = [[NSMenu alloc] initWithTitle: @"Services"];
  [NSApp setServicesMenu: svcs];
  [NSApp registerServicesMenuSendTypes: ns_send_types
@@ -2028,7 +2028,7 @@ there was no result.  */)
  char *utfStr;
  CHECK_STRING (service);
-  check_ns ();
+  check_window_system ();
  utfStr = SSDATA (service);
  svcName = [NSString stringWithUTF8String: utfStr];
@@ -2152,7 +2152,7 @@ In case the execution fails, an error is signaled. */)
  NSEvent *nxev;
  CHECK_STRING (script);
-  check_ns ();
+  check_window_system ();
  block_input ();
@@ -2235,7 +2235,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 ();
  if (inhibit_x_resources)
    /* --quick was passed, so this is a no-op.  */
@@ -2305,7 +2305,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 ();
  return ns_lisp_to_color (color, &col) ? Qnil : Qt;
 }
@@ -2317,7 +2317,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 ();
  CHECK_STRING (color);
  if (ns_lisp_to_color (color, &col))
@@ -2336,7 +2336,7 @@ DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
 {
  NSWindowDepth depth;
  NSString *colorSpace;
-  check_ns ();
+  check_window_system ();
  depth = [ns_get_screen (display) depth];
  colorSpace = NSColorSpaceFromDepth (depth);
@@ -2356,7 +2356,7 @@ If omitted or nil, that stands for the selected frame's display. */)
     (Lisp_Object display)
 {
  NSWindowDepth depth;
-  check_ns ();
+  check_window_system ();
  depth = [ns_get_screen (display) depth];
  return NSBitsPerPixelFromDepth (depth) > 1 ? Qt : Qnil;
@@ -2371,7 +2371,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_window_system ();
  return make_number ((int) [ns_get_screen (display) frame].size.width);
 }
@@ -2384,7 +2384,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_window_system ();
  return make_number ((int) [ns_get_screen (display) frame].size.height);
 }
@@ -2404,7 +2404,7 @@ that stands for the selected frame's display. */)
  NSScreen *screen;
  NSRect vScreen;
-  check_ns ();
+  check_window_system ();
  screen = ns_get_screen (display);
  if (!screen)
    return Qnil;
@@ -2428,7 +2428,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_window_system ();
  return make_number
    (NSBitsPerPixelFromDepth ([ns_get_screen (display) depth]));
 }
@@ -2443,7 +2443,7 @@ If omitted or nil, that stands for the selected frame's display.  */)
     (Lisp_Object display)
 {
  struct ns_display_info *dpyinfo;
-  check_ns ();
+  check_window_system ();
  dpyinfo = check_ns_display_info (display);
  /* We force 24+ bit depths to 24-bit to prevent an overflow.  */
@@ -2787,9 +2787,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..d364639b0bc 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,7 +1409,7 @@ ns_popup_dialog (Lisp_Object position, Lisp_Object contents, Lisp_Object header)
  NSTRACE (x-popup-dialog);
-  check_ns ();
+  check_window_system ();
  isQ = NILP (header);
diff --git a/src/nsselect.m b/src/nsselect.m
index 49380f87945..2f539a16406 100644
--- a/src/nsselect.m
+++ b/src/nsselect.m
@@ -355,7 +355,7 @@ On Nextstep, FRAME is unused.  */)
  Lisp_Object target_symbol, data;
-  check_ns ();
+  check_window_system ();
  CHECK_SYMBOL (selection);
  if (NILP (value))
      error ("selection value may not be nil.");
@@ -409,7 +409,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 ();
  CHECK_SYMBOL (selection);
  if (NILP (assq_no_quit (selection, Vselection_alist))) return Qnil;
@@ -436,7 +436,7 @@ On Nextstep, TERMINAL is unused.  */)
  id pb;
  NSArray *types;
-  check_ns ();
+  check_window_system ();
  CHECK_SYMBOL (selection);
  if (EQ (selection, Qnil)) selection = QPRIMARY;
  if (EQ (selection, Qt)) selection = QSECONDARY;
@@ -464,7 +464,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 ();
  CHECK_SYMBOL (selection);
  if (EQ (selection, Qnil)) selection = QPRIMARY;
  if (EQ (selection, Qt)) selection = QSECONDARY;
@@ -492,7 +492,7 @@ On Nextstep, TIME-STAMP and TERMINAL are unused.  */)
 {
  Lisp_Object val;
-  check_ns ();
+  check_window_system ();
  CHECK_SYMBOL (selection_name);
  CHECK_SYMBOL (target_type);
  val = ns_get_local_selection (selection_name, target_type);
@@ -516,7 +516,7 @@ SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'. */)
     (Lisp_Object selection)
 {
  id pb;
-  check_ns ();
+  check_window_system ();
  pb = ns_symbol_to_pb (selection);
  return pb != nil ? ns_string_from_pasteboard (pb) : Qnil;
 }
@@ -529,7 +529,7 @@ SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'. */)
     (Lisp_Object selection, Lisp_Object string)
 {
  id pb;
-  check_ns ();
+  check_window_system ();
  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..59cac34773a 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -764,7 +764,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 +791,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..fb1b0aa327c 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)
@@ -994,7 +1013,7 @@ ns_raise_frame (struct frame *f)
   -------------------------------------------------------------------------- */
 {
  NSView *view = FRAME_NS_VIEW (f);
-  check_ns ();
+  check_window_system ();
  block_input ();
  if (FRAME_VISIBLE_P (f))
    [[view window] makeKeyAndOrderFront: NSApp];
@@ -1009,7 +1028,7 @@ ns_lower_frame (struct frame *f)
   -------------------------------------------------------------------------- */
 {
  NSView *view = FRAME_NS_VIEW (f);
-  check_ns ();
+  check_window_system ();
  block_input ();
  [[view window] orderBack: NSApp];
  unblock_input ();
@@ -1114,7 +1133,7 @@ x_make_frame_invisible (struct frame *f)
 {
  NSView * view = FRAME_NS_VIEW (f);
  NSTRACE (x_make_frame_invisible);
-  check_ns ();
+  check_window_system ();
  [[view window] orderOut: NSApp];
  SET_FRAME_VISIBLE (f, 0);
  SET_FRAME_ICONIFIED (f, 0);
@@ -1130,7 +1149,7 @@ x_iconify_frame (struct frame *f)
  NSView * view = FRAME_NS_VIEW (f);
  struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (f);
  NSTRACE (x_iconify_frame);
-  check_ns ();
+  check_window_system ();
  if (dpyinfo->x_highlight_frame == f)
    dpyinfo->x_highlight_frame = 0;
@@ -1159,7 +1178,7 @@ x_free_frame_resources (struct frame *f)
  struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (f);
  Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
  NSTRACE (x_free_frame_resources);
-  check_ns ();
+  check_window_system ();
  [(EmacsView *)view setWindowClosing: YES]; /* may not have been informed */
@@ -1200,7 +1219,7 @@ x_destroy_window (struct frame *f)
   -------------------------------------------------------------------------- */
 {
  NSTRACE (x_destroy_window);
-  check_ns ();
+  check_window_system ();
  x_free_frame_resources (f);
  ns_window_num--;
 }
@@ -3388,6 +3407,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 +6622,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 53c0d99f836..811ab5011ce 100644
--- a/src/print.c
+++ b/src/print.c
@@ -227,9 +227,9 @@ printchar (unsigned int ch, Lisp_Object fun)
      if (NILP (fun))
        {
          ptrdiff_t incr = len - (print_buffer_size - print_buffer_pos_byte);
-          if (0 < incr)
+          if (incr > 0)
-            print_buffer =
+            print_buffer = xpalloc (print_buffer, &print_buffer_size,
-              xpalloc (print_buffer, &print_buffer_size, incr, -1, 1);
+                                    incr, -1, 1);
          memcpy (print_buffer + print_buffer_pos_byte, str, len);
          print_buffer_pos += 1;
          print_buffer_pos_byte += len;
@@ -273,7 +273,7 @@ strout (const char *ptr, ptrdiff_t size, ptrdiff_t size_byte,
  if (NILP (printcharfun))
    {
      ptrdiff_t incr = size_byte - (print_buffer_size - print_buffer_pos_byte);
-      if (0 < incr)
+      if (incr > 0)
        print_buffer = xpalloc (print_buffer, &print_buffer_size, incr, -1, 1);
      memcpy (print_buffer + print_buffer_pos_byte, ptr, size_byte);
      print_buffer_pos += size;
@@ -1769,10 +1769,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 ('>');
@@ -2042,17 +2042,15 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
            strout ("#<save-value ", -1, -1, printcharfun);
-            if (v->area)
+            if (v->save_type == SAVE_TYPE_MEMORY)
              {
                ptrdiff_t amount = v->data[1].integer;
 #if GC_MARK_STACK
-                /* If GC_MARK_STACK, valid_lisp_object_p is quite reliable,
+                /* valid_lisp_object_p is reliable, so try to print up
-                   and so we try to print up to 8 objects we have saved.
+                   to 8 saved objects.  This code is rarely used, so
-                   Although valid_lisp_object_p is slow, this shouldn't be
+                   it's OK that valid_lisp_object_p is slow.  */
-                   a real bottleneck because we do not use this code under
-                   normal circumstances.  */
                int limit = min (amount, 8);
                Lisp_Object *area = v->data[0].pointer;
@@ -2077,9 +2075,8 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 #else /* not GC_MARK_STACK */
-                /* If !GC_MARK_STACK, we have no reliable way to find
+                /* There is no reliable way to determine whether the objects
-                   whether Lisp_Object pointers points to an initialized
+                   are initialized, so do not try to print them.  */
-                   objects, and so we do not ever trying to print them.  */
                i = sprintf (buf, "with %"pD"d objects", amount);
                strout (buf, i, i, printcharfun);
@@ -2088,33 +2085,37 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
              }
            else
              {
-                /* Print each `data[N]' slot according to its type.  */
+                /* Print each slot according to its type.  */
+                int index;
-#define PRINTX(index)                                                   \
+                for (index = 0; index < SAVE_VALUE_SLOTS; index++)
-  do {                                                                  \
+                  {
-    i = 0;                                                              \
+                    if (index)
-    if (v->type ## index == SAVE_UNUSED)                                \
+                      PRINTCHAR (' ');
-      i = sprintf (buf, "<unused>");                                    \
-    else if (v->type ## index == SAVE_INTEGER)                          \
-      i = sprintf (buf, "<integer %"pD"d>", v->data[index].integer);    \
-    else if (v->type ## index == SAVE_POINTER)                          \
-      i = sprintf (buf, "<pointer %p>", v->data[index].pointer);        \
-    else /* SAVE_OBJECT */                                              \
-      print_object (v->data[index].object, printcharfun, escapeflag);   \
-    if (i)                                                              \
-      strout (buf, i, i, printcharfun);                                 \
-  } while (0)
-                PRINTX (0);
-                PRINTCHAR (' ');
-                PRINTX (1);
-                PRINTCHAR (' ');
-                PRINTX (2);
-                PRINTCHAR (' ');
-                PRINTX (3);
-#undef PRINTX
+                    switch (save_type (v, index))
+                      {
+                      case SAVE_UNUSED:
+                        i = sprintf (buf, "<unused>");
+                        break;
+                      case SAVE_POINTER:
+                        i = sprintf (buf, "<pointer %p>",
+                                     v->data[index].pointer);
+                        break;
+                      case SAVE_INTEGER:
+                        i = sprintf (buf, "<integer %"pD"d>",
+                                     v->data[index].integer);
+                        break;
+                      case SAVE_OBJECT:
+                        print_object (v->data[index].object, printcharfun,
+                                      escapeflag);
+                        continue;
+                      }
+                    strout (buf, i, i, printcharfun);
+                  }
              }
            PRINTCHAR ('>');
          }
diff --git a/src/process.c b/src/process.c
index bafdca9bd63..911a30bc808 100644
--- a/src/process.c
+++ b/src/process.c
@@ -136,7 +136,7 @@ extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
 /* Work around GCC 4.7.0 bug with strict overflow checking; see
   <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52904>.
   These lines can be removed once the GCC bug is fixed.  */
-#if (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) || 4 < __GNUC__
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
 # pragma GCC diagnostic ignored "-Wstrict-overflow"
 #endif
@@ -1804,7 +1804,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
  /* Back in the parent process.  */
  XPROCESS (process)->pid = pid;
-  if (0 <= pid)
+  if (pid >= 0)
    XPROCESS (process)->alive = 1;
  /* Stop blocking signals in the parent.  */
@@ -2155,7 +2155,7 @@ Returns nil upon error setting address, ADDRESS otherwise.  */)
  channel = XPROCESS (process)->infd;
  len = get_lisp_to_sockaddr_size (address, &family);
-  if (datagram_address[channel].len != len)
+  if (len == 0 || datagram_address[channel].len != len)
    return Qnil;
  conv_lisp_to_sockaddr (family, address, datagram_address[channel].sa, len);
  return address;
@@ -3269,7 +3269,8 @@ usage: (make-network-process &rest ARGS)  */)
                {
                  int rfamily, rlen;
                  rlen = get_lisp_to_sockaddr_size (remote, &rfamily);
-                  if (rfamily == lres->ai_family && rlen == lres->ai_addrlen)
+                  if (rlen != 0 && rfamily == lres->ai_family
+                      && rlen == lres->ai_addrlen)
                    conv_lisp_to_sockaddr (rfamily, remote,
                                           datagram_address[s].sa, rlen);
                }
@@ -3900,7 +3901,7 @@ Return non-nil if we received any output before the timeout expired.  */)
    {
      if (INTEGERP (seconds))
        {
-          if (0 < XINT (seconds))
+          if (XINT (seconds) > 0)
            {
              secs = XINT (seconds);
              nsecs = 0;
@@ -3908,7 +3909,7 @@ Return non-nil if we received any output before the timeout expired.  */)
        }
      else if (FLOATP (seconds))
        {
-          if (0 < XFLOAT_DATA (seconds))
+          if (XFLOAT_DATA (seconds) > 0)
            {
              EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (seconds));
              secs = min (EMACS_SECS (t), WAIT_READING_MAX);
@@ -4240,7 +4241,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
  /* Since we may need to wait several times,
     compute the absolute time to return at.  */
-  if (time_limit || 0 < nsecs)
+  if (time_limit || nsecs > 0)
    {
      timeout = make_emacs_time (time_limit, nsecs);
      end_time = add_emacs_time (current_emacs_time (), timeout);
@@ -4272,7 +4273,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
          timeout = make_emacs_time (0, 0);
        }
-      else if (time_limit || 0 < nsecs)
+      else if (time_limit || nsecs > 0)
        {
          EMACS_TIME now = current_emacs_time ();
          if (EMACS_TIME_LE (end_time, now))
@@ -4324,7 +4325,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
            break;
          /* A negative timeout means do not wait at all.  */
-          if (0 <= nsecs)
+          if (nsecs >= 0)
            {
              if (EMACS_TIME_VALID_P (timer_delay))
                {
@@ -4406,7 +4407,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
              if (nread == 0)
                break;
-              if (0 < nread)
+              if (nread > 0)
                {
                  total_nread += nread;
                  got_some_input = 1;
@@ -4947,7 +4948,7 @@ read_process_output (Lisp_Object proc, register int channel)
  else
 #endif
    {
-      bool buffered = 0 <= proc_buffered_char[channel];
+      bool buffered = proc_buffered_char[channel] >= 0;
      if (buffered)
        {
          chars[carryover] = proc_buffered_char[channel];
@@ -5454,7 +5455,7 @@ send_process (Lisp_Object proc, const char *buf, ptrdiff_t len,
              rv = sendto (outfd, cur_buf, cur_len,
                           0, datagram_address[outfd].sa,
                           datagram_address[outfd].len);
-              if (0 <= rv)
+              if (rv >= 0)
                written = rv;
              else if (errno == EMSGSIZE)
                report_file_error ("sending datagram", Fcons (proc, Qnil));
@@ -6577,7 +6578,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
    time_limit = TYPE_MAXIMUM (time_t);
  /* What does time_limit really mean?  */
-  if (time_limit || 0 < nsecs)
+  if (time_limit || nsecs > 0)
    {
      timeout = make_emacs_time (time_limit, nsecs);
      end_time = add_emacs_time (current_emacs_time (), timeout);
@@ -6615,7 +6616,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
          timeout = make_emacs_time (0, 0);
        }
-      else if (time_limit || 0 < nsecs)
+      else if (time_limit || nsecs > 0)
        {
          EMACS_TIME now = current_emacs_time ();
          if (EMACS_TIME_LE (end_time, now))
@@ -6653,7 +6654,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
              && requeued_events_pending_p ())
            break;
-          if (EMACS_TIME_VALID_P (timer_delay) && 0 <= nsecs)
+          if (EMACS_TIME_VALID_P (timer_delay) && nsecs >= 0)
            {
              if (EMACS_TIME_LT (timer_delay, timeout))
                {
diff --git a/src/profiler.c b/src/profiler.c
index 85d9c1ca88a..0a0a4d0bc57 100644
--- a/src/profiler.c
+++ b/src/profiler.c
@@ -55,7 +55,7 @@ make_log (int heap_size, int max_stack_depth)
  /* What is special about our hash-tables is that the keys are pre-filled
     with the vectors we'll put in them.  */
  int i = ASIZE (h->key_and_value) / 2;
-  while (0 < i)
+  while (i > 0)
    set_hash_key_slot (h, --i,
                       Fmake_vector (make_number (max_stack_depth), Qnil));
  return log;
@@ -247,7 +247,7 @@ handle_profiler_signal (int signal)
      if (profiler_timer_ok)
        {
          int overruns = timer_getoverrun (profiler_timer);
-          eassert (0 <= overruns);
+          eassert (overruns >= 0);
          count += overruns;
        }
 #endif
diff --git a/src/regex.c b/src/regex.c
index 051a4fdc26b..648f2529649 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -33,7 +33,7 @@
 /* Ignore some GCC warnings for now.  This section should go away
   once the Emacs and Gnulib regex code is merged.  */
-#if (__GNUC__ == 4 && 5 <= __GNUC_MINOR__) || 4 < __GNUC__
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
 # pragma GCC diagnostic ignored "-Wstrict-overflow"
 # ifndef emacs
 #  pragma GCC diagnostic ignored "-Wunused-but-set-variable"
@@ -6404,8 +6404,8 @@ weak_function
 re_exec (const char *s)
 {
  const size_t len = strlen (s);
-  return
+  return (re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0)
-    0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0);
+          >= 0);
 }
 #endif /* _REGEX_RE_COMP */
diff --git a/src/regex.h b/src/regex.h
index f1fd837bd6f..8fe7ba16adc 100644
--- a/src/regex.h
+++ b/src/regex.h
@@ -530,7 +530,7 @@ extern int re_exec (const char *);
 /* GCC 2.95 and later have "__restrict"; C99 compilers have
   "restrict", and "configure" may have defined "restrict".  */
 #ifndef __restrict
-# if ! (2 < __GNUC__ || (2 == __GNUC__ && 95 <= __GNUC_MINOR__))
+# if ! (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95))
 #  if defined restrict || 199901L <= __STDC_VERSION__
 #   define __restrict restrict
 #  else
diff --git a/src/search.c b/src/search.c
index c5ac7d494dc..ea36133deb7 100644
--- a/src/search.c
+++ b/src/search.c
@@ -326,7 +326,7 @@ looking_at_1 (Lisp_Object string, bool posix)
  if (i == -2)
    matcher_overflow ();
-  val = (0 <= i ? Qt : Qnil);
+  val = (i >= 0 ? Qt : Qnil);
  if (NILP (Vinhibit_changing_match_data) && i >= 0)
    for (i = 0; i < search_regs.num_regs; i++)
      if (search_regs.start[i] >= 0)
@@ -2450,7 +2450,7 @@ since only regular expressions have distinguished subexpressions.  */)
                  else if (c >= '1' && c <= '9')
                    {
                      if (c - '0' < search_regs.num_regs
-                          && 0 <= search_regs.start[c - '0'])
+                          && search_regs.start[c - '0'] >= 0)
                        {
                          substart = search_regs.start[c - '0'];
                          subend = search_regs.end[c - '0'];
@@ -2533,9 +2533,9 @@ since only regular expressions have distinguished subexpressions.  */)
      bool str_multibyte = STRING_MULTIBYTE (newtext);
      bool really_changed = 0;
-      substed_alloc_size = ((STRING_BYTES_BOUND - 100) / 2 < length
+      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/sysdep.c b/src/sysdep.c
index bff11fc9f75..1d3e646d359 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -282,7 +282,7 @@ get_child_status (pid_t child, int *status, int options, bool interruptible)
     reap an unwanted process by mistake.  For example, invoking
     waitpid (-1, ...) can mess up glib by reaping glib's subprocesses,
     so that another thread running glib won't find them.  */
-  eassert (0 < child);
+  eassert (child > 0);
  while ((pid = waitpid (child, status, options)) < 0)
    {
@@ -2691,7 +2691,7 @@ procfs_ttyname (int rdev)
      while (!feof (fdev) && !ferror (fdev))
        {
-          if (3 <= fscanf (fdev, "%*s %s %u %s %*s\n", name, &major, minor)
+          if (fscanf (fdev, "%*s %s %u %s %*s\n", name, &major, minor) >= 3
              && major == MAJOR (rdev))
            {
              minor_beg = strtoul (minor, &endp, 0);
@@ -2731,7 +2731,7 @@ procfs_get_total_memory (void)
      while (!feof (fmem) && !ferror (fmem))
        {
-          if (2 <= fscanf (fmem, "%s %lu kB\n", entry_name, &entry_value)
+          if (fscanf (fmem, "%s %lu kB\n", entry_name, &entry_value) >= 2
              && strcmp (entry_name, "MemTotal:") == 0)
            {
              retval = entry_value;
diff --git a/src/systime.h b/src/systime.h
index fa5e7270cb5..da495b9064b 100644
--- a/src/systime.h
+++ b/src/systime.h
@@ -121,7 +121,7 @@ EMACS_TIME_SIGN (EMACS_TIME t)
 SYSTIME_INLINE int
 EMACS_TIME_VALID_P (EMACS_TIME t)
 {
-  return 0 <= t.tv_nsec;
+  return t.tv_nsec >= 0;
 }
 /* Convert the double D to the greatest EMACS_TIME not greater than D.
diff --git a/src/term.c b/src/term.c
index 38706602a02..28b944c6436 100644
--- a/src/term.c
+++ b/src/term.c
@@ -2909,7 +2909,7 @@ dissociate_if_controlling_tty (int fd)
 {
  /* If tcgetpgrp succeeds, fd is the controlling terminal,
     so dissociate it by invoking setsid.  */
-  if (0 <= tcgetpgrp (fd) && setsid () < 0)
+  if (tcgetpgrp (fd) >= 0 && setsid () < 0)
    {
 #ifdef TIOCNOTTY
      /* setsid failed, presumably because Emacs is already a process
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/unexcw.c b/src/unexcw.c
index af93e158e14..1290c28d245 100644
--- a/src/unexcw.c
+++ b/src/unexcw.c
@@ -20,7 +20,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <config.h>
 #include "unexec.h"
-#include "w32common.h"
 #include <lisp.h>
 #include <stdio.h>
@@ -31,6 +30,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define DOTEXE ".exe"
+extern void report_sheap_usage (int);
 extern int bss_sbrk_did_unexec;
 extern int __malloc_initialized;
@@ -73,7 +74,11 @@ read_exe_header (int fd, exe_header_t * exe_header_buffer)
  assert (exe_header_buffer->file_header.e_magic == 0x5a4d);
  assert (exe_header_buffer->file_header.nt_signature == 0x4550);
+#ifdef __x86_64__
+  assert (exe_header_buffer->file_header.f_magic == 0x8664);
+#else
  assert (exe_header_buffer->file_header.f_magic == 0x014c);
+#endif
  assert (exe_header_buffer->file_header.f_nscns > 0);
  assert (exe_header_buffer->file_header.f_nscns <=
          sizeof (exe_header_buffer->section_header) /
@@ -85,7 +90,11 @@ read_exe_header (int fd, exe_header_t * exe_header_buffer)
          sizeof (exe_header_buffer->file_optional_header));
  assert (ret == sizeof (exe_header_buffer->file_optional_header));
+#ifdef __x86_64__
+  assert (exe_header_buffer->file_optional_header.magic == 0x020b);
+#else
  assert (exe_header_buffer->file_optional_header.magic == 0x010b);
+#endif
  for (i = 0; i < exe_header_buffer->file_header.f_nscns; ++i)
    {
@@ -132,7 +141,7 @@ fixup_executable (int fd)
        exe_header->file_optional_header.ImageBase +
        exe_header->section_header[i].s_paddr;
      if (debug_unexcw)
-        printf ("%8s start 0x%08x end 0x%08x\n",
+        printf ("%8s start %#lx end %#lx\n",
                exe_header->section_header[i].s_name,
                start_address, end_address);
      if (my_edata >= (char *) start_address
@@ -149,7 +158,7 @@ fixup_executable (int fd)
          assert (ret == my_edata - (char *) start_address);
          ++found_data;
          if (debug_unexcw)
-            printf ("         .data, mem start 0x%08x mem length %d\n",
+            printf ("         .data, mem start %#lx mem length %d\n",
                    start_address, my_edata - (char *) start_address);
          if (debug_unexcw)
            printf ("         .data, file start %d file length %d\n",
@@ -233,7 +242,7 @@ fixup_executable (int fd)
          __malloc_initialized = 1;
          assert (ret == (my_endbss - (char *) start_address));
          if (debug_unexcw)
-            printf ("         .bss, mem start 0x%08x mem length %d\n",
+            printf ("         .bss, mem start %#lx mem length %d\n",
                    start_address, my_endbss - (char *) start_address);
          if (debug_unexcw)
            printf ("         .bss, file start %d file length %d\n",
diff --git a/src/w32.c b/src/w32.c
index 647faf94ef1..431826c4b82 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -29,10 +29,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <ctype.h>
 #include <signal.h>
 #include <sys/file.h>
+#include <time.h>       /* must be before nt/inc/sys/time.h, for MinGW64 */
 #include <sys/time.h>
 #include <sys/utime.h>
 #include <math.h>
-#include <time.h>
 /* must include CRT headers *before* config.h */
@@ -69,7 +69,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <pwd.h>
 #include <grp.h>
-#ifdef __GNUC__
+/* MinGW64 (_W64) defines these in its _mingw.h.  */
+#if defined(__GNUC__) && !defined(_W64)
 #define _ANONYMOUS_UNION
 #define _ANONYMOUS_STRUCT
 #endif
@@ -96,6 +97,7 @@ typedef struct _MEMORY_STATUS_EX {
 #ifndef _MSC_VER
 #include <w32api.h>
 #endif
+#if _WIN32_WINNT < 0x0500
 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
 /* This either is not in psapi.h or guarded by higher value of
   _WIN32_WINNT than what we use.  w32api supplied with MinGW 3.15
@@ -114,6 +116,7 @@ typedef struct _PROCESS_MEMORY_COUNTERS_EX {
  SIZE_T PrivateUsage;
 } PROCESS_MEMORY_COUNTERS_EX,*PPROCESS_MEMORY_COUNTERS_EX;
 #endif
+#endif
 #include <winioctl.h>
 #include <aclapi.h>
@@ -127,11 +130,11 @@ typedef struct _PROCESS_MEMORY_COUNTERS_EX {
 #define SDDL_REVISION_1 1
 #endif  /* SDDL_REVISION_1 */
-#ifdef _MSC_VER
+#if defined(_MSC_VER) || defined(_W64)
-/* MSVC doesn't provide the definition of REPARSE_DATA_BUFFER and the
+/* MSVC and MinGW64 don't provide the definition of
-   associated macros, except on ntifs.h, which cannot be included
+   REPARSE_DATA_BUFFER and the associated macros, except on ntifs.h,
-   because it triggers conflicts with other Windows API headers.  So
+   which cannot be included because it triggers conflicts with other
-   we define it here by hand.  */
+   Windows API headers.  So we define it here by hand.  */
 typedef struct _REPARSE_DATA_BUFFER {
    ULONG  ReparseTag;
@@ -171,9 +174,12 @@ typedef struct _REPARSE_DATA_BUFFER {
 #ifndef CTL_CODE
 #define CTL_CODE(t,f,m,a)       (((t)<<16)|((a)<<14)|((f)<<2)|(m))
 #endif
+/* MinGW64 defines FSCTL_GET_REPARSE_POINT on winioctl.h.  */
+#ifndef FSCTL_GET_REPARSE_POINT
 #define FSCTL_GET_REPARSE_POINT \
  CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
 #endif
+#endif
 /* TCP connection support.  */
 #include <sys/socket.h>
diff --git a/src/w32fns.c b/src/w32fns.c
index 4c47465e67b..2bc1042e126 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -242,7 +242,7 @@ static unsigned int sound_type = 0xFFFFFFFF;
 /* Error if we are not connected to MS-Windows.  */
 void
-check_w32 (void)
+check_window_system (void)
 {
  if (! w32_in_use)
    error ("MS-Windows not in use or not initialized");
@@ -3155,8 +3155,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));
@@ -5340,7 +5358,7 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
  Lisp_Object buffer;
  struct buffer *old_buffer;
-  check_w32 ();
+  check_window_system ();
  /* Use this general default value to start with until we know if
     this frame has a specified name.  */
@@ -5792,13 +5810,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);
@@ -7617,8 +7635,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);
@@ -7759,6 +7775,9 @@ emacs_abort (void)
 #endif
            if (stderr_fd >= 0)
              write (stderr_fd, "\r\nBacktrace:\r\n", 14);
+#ifdef CYGWIN
+#define _open open
+#endif
            errfile_fd = _open ("emacs_backtrace.txt", O_RDWR | O_CREAT | O_BINARY, S_IREAD | S_IWRITE);
            if (errfile_fd >= 0)
              {
diff --git a/src/w32menu.c b/src/w32menu.c
index 03904cf20b8..0c8d5ca06c5 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -140,7 +140,7 @@ otherwise it is "Question". */)
  FRAME_PTR f = NULL;
  Lisp_Object window;
-  check_w32 ();
+  check_window_system ();
  /* Decode the first argument: find the window or frame to use.  */
  if (EQ (position, Qt)
@@ -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 989ceb0f847..d249d6e3252 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -109,9 +109,10 @@ struct w32_display_info *x_display_list;
 Lisp_Object w32_display_name_list;
-#if _WIN32_WINNT < 0x0500
+#if _WIN32_WINNT < 0x0500 && !defined(_W64)
 /* Pre Windows 2000, this was not available, but define it here so
-   that Emacs compiled on such a platform will run on newer versions.  */
+   that Emacs compiled on such a platform will run on newer versions.
+   MinGW64 (_W64) defines these unconditionally, so avoid redefining.  */
 typedef struct tagWCRANGE
 {
@@ -5660,8 +5661,6 @@ x_check_fullscreen (struct frame *f)
 static void
 w32fullscreen_hook (FRAME_PTR f)
 {
-  static int normal_width, normal_height;
  if (FRAME_VISIBLE_P (f))
    {
      int width, height, top_pos, left_pos, pixel_height, pixel_width;
@@ -5669,17 +5668,38 @@ w32fullscreen_hook (FRAME_PTR f)
      RECT workarea_rect;
      block_input ();
-      if (normal_height <= 0)
+      /* Record current "normal" dimensions for restoring later.  */
-        normal_height = cur_h;
+      if (!(   FRAME_PREV_FSMODE (f) == FULLSCREEN_BOTH
-      if (normal_width <= 0)
+            || FRAME_PREV_FSMODE (f) == FULLSCREEN_MAXIMIZED))
-        normal_width = cur_w;
+        {
+          if (FRAME_PREV_FSMODE (f) != FULLSCREEN_HEIGHT)
+            {
+              FRAME_NORMAL_HEIGHT (f) = cur_h;
+              FRAME_NORMAL_TOP (f) = f->top_pos;
+            }
+          if (FRAME_PREV_FSMODE (f) != FULLSCREEN_WIDTH)
+            {
+              FRAME_NORMAL_WIDTH (f)  = cur_w;
+              FRAME_NORMAL_LEFT (f) = f->left_pos;
+            }
+        }
+      eassert (FRAME_NORMAL_HEIGHT (f) > 0);
+      eassert (FRAME_NORMAL_WIDTH (f) > 0);
      x_real_positions (f, &f->left_pos, &f->top_pos);
      x_fullscreen_adjust (f, &width, &height, &top_pos, &left_pos);
      SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0);
      pixel_height = workarea_rect.bottom - workarea_rect.top;
      pixel_width  = workarea_rect.right  - workarea_rect.left;
+      /* 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, 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);
+      FRAME_PREV_FSMODE (f) = f->want_fullscreen;
      switch (f->want_fullscreen)
        {
        case FULLSCREEN_BOTH:
@@ -5700,8 +5720,7 @@ w32fullscreen_hook (FRAME_PTR f)
          width  =
            FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pixel_width)
            - FRAME_SCROLL_BAR_COLS (f);
-          if (normal_height > 0)
+          height = FRAME_NORMAL_HEIGHT (f);
-            height = normal_height;
          left_pos = workarea_rect.left;
          break;
        case FULLSCREEN_HEIGHT:
@@ -5709,21 +5728,14 @@ w32fullscreen_hook (FRAME_PTR f)
            FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, pixel_height)
            - XINT (Ftool_bar_lines_needed (selected_frame))
            + (NILP (Vmenu_bar_mode) ? 1 : 0);
-          if (normal_width > 0)
+          width = FRAME_NORMAL_WIDTH (f);
-            width = normal_width;
          top_pos = workarea_rect.top;
          break;
        case FULLSCREEN_NONE:
-          if (normal_height > 0)
+          height = FRAME_NORMAL_HEIGHT (f);
-            height = normal_height;
+          width = FRAME_NORMAL_WIDTH (f);
-          else
+          left_pos = FRAME_NORMAL_LEFT (f);
-            normal_height = height;
+          top_pos = FRAME_NORMAL_TOP (f);
-          if (normal_width > 0)
-            width = normal_width;
-          else
-            normal_width = width;
-          /* FIXME: Should restore the original position of the frame.  */
-          top_pos = left_pos = 0;
          break;
        }
@@ -6651,7 +6663,7 @@ w32_initialize (void)
  Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
  {
-    DWORD input_locale_id = (DWORD) GetKeyboardLayout (0);
+    DWORD input_locale_id = ((DWORD_PTR) GetKeyboardLayout (0) & 0xffffffff);
    w32_keyboard_codepage =
      codepage_for_locale ((LCID) (input_locale_id & 0xffff));
  }
diff --git a/src/w32term.h b/src/w32term.h
index a31c5de193d..e85ee7790d5 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,
@@ -359,6 +358,12 @@ struct w32_output
  /* The background for which the above relief GCs were set up.
     They are changed only when a different background is involved.  */
  unsigned long relief_background;
+  /* Frame geometry and full-screen mode before it was resized by
+     specifying the 'fullscreen' frame parameter.  Used to restore the
+     geometry when 'fullscreen' is reset to nil.  */
+  int normal_width, normal_height, normal_top, normal_left;
+  int prev_fsmode;
 };
 extern struct w32_output w32term_display;
@@ -390,6 +395,13 @@ extern struct w32_output w32term_display;
 #define FRAME_SMALLEST_FONT_HEIGHT(F) \
     FRAME_W32_DISPLAY_INFO(F)->smallest_font_height
+#define FRAME_NORMAL_WIDTH(F)  ((F)->output_data.w32->normal_width)
+#define FRAME_NORMAL_HEIGHT(F) ((F)->output_data.w32->normal_height)
+#define FRAME_NORMAL_TOP(F)    ((F)->output_data.w32->normal_top)
+#define FRAME_NORMAL_LEFT(F)   ((F)->output_data.w32->normal_left)
+#define FRAME_PREV_FSMODE(F)   ((F)->output_data.w32->prev_fsmode)
 /* W32-specific scroll bar stuff.  */
diff --git a/src/window.c b/src/window.c
index 875d7770277..feb5f7b5cc7 100644
--- a/src/window.c
+++ b/src/window.c
@@ -147,11 +147,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;
@@ -217,11 +212,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;
@@ -231,6 +221,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)
@@ -275,9 +277,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;
@@ -296,7 +298,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);
 }
@@ -394,15 +400,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;
 }
@@ -489,11 +488,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;
@@ -516,7 +515,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;
 }
@@ -533,10 +532,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;
@@ -581,7 +580,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,
@@ -601,7 +601,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,
@@ -612,7 +613,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,
@@ -645,9 +647,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,
@@ -663,7 +665,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;
@@ -860,7 +862,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);
@@ -1441,7 +1443,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);
 }
@@ -1483,7 +1485,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);
@@ -1546,7 +1548,7 @@ Return POS.  */)
  if (w == XWINDOW (selected_window))
    {
-      if (XBUFFER (w->buffer) == current_buffer)
+      if (XBUFFER (w->contents) == current_buffer)
        Fgoto_char (pos);
      else
        {
@@ -1554,14 +1556,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;
@@ -1579,7 +1581,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))
@@ -1623,7 +1625,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))
@@ -1692,8 +1694,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
@@ -1919,9 +1921,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));
@@ -1946,17 +1948,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
@@ -1972,14 +1971,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),
@@ -2044,13 +2043,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
@@ -2069,22 +2063,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);
@@ -2122,8 +2113,7 @@ recombine_windows (Lisp_Object window)
            }
          /* WINDOW can be deleted now.  */
-          wset_vchild (w, Qnil);
+          wset_combination (w, 0, Qnil);
-          wset_hchild (w, Qnil);
        }
    }
 }
@@ -2209,7 +2199,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)
@@ -2549,7 +2539,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
@@ -2613,7 +2603,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))
@@ -2637,25 +2627,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;
@@ -2665,11 +2655,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:
@@ -2786,7 +2785,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);
@@ -2858,7 +2857,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);
@@ -2917,28 +2916,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
@@ -2947,18 +2939,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');
@@ -3158,7 +3150,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);
@@ -3277,7 +3269,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
@@ -3330,8 +3322,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;
    }
@@ -3400,7 +3392,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);
      }
@@ -3421,7 +3413,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);
@@ -3430,12 +3422,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);
 }
@@ -3524,10 +3515,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.  */
        {
@@ -3555,10 +3546,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.  */
@@ -3625,10 +3616,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)
@@ -3641,10 +3632,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)
@@ -3727,7 +3718,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;
@@ -3842,9 +3833,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))
@@ -3914,17 +3905,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);
@@ -3973,7 +3959,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
@@ -3995,13 +3981,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;
@@ -4015,7 +3999,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);
@@ -4033,10 +4017,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.  */
@@ -4075,17 +4056,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));
@@ -4104,8 +4080,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);
        }
@@ -4153,10 +4128,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
        {
@@ -4299,10 +4271,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;
@@ -4321,8 +4291,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))
@@ -4461,7 +4430,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;
@@ -4585,7 +4554,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;
@@ -4605,7 +4574,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');
@@ -4805,7 +4774,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;
@@ -4899,10 +4868,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;
@@ -5017,7 +4986,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))
@@ -5111,10 +5080,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;
@@ -5176,7 +5145,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;
@@ -5342,7 +5311,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;
@@ -5386,9 +5355,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");
@@ -5398,7 +5366,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;
    }
@@ -5548,9 +5516,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
@@ -5564,7 +5532,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);
@@ -5606,8 +5574,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.  */
@@ -5640,13 +5608,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++;
@@ -5693,18 +5661,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.  */
@@ -5753,20 +5713,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
@@ -5775,23 +5731,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
@@ -5800,8 +5754,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.  */
@@ -5814,17 +5768,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)
@@ -5851,14 +5805,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;
        }
@@ -5889,7 +5838,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));
    }
@@ -5900,8 +5849,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)
 {
@@ -5913,17 +5864,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));
@@ -5931,7 +5877,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);
    }
@@ -5944,10 +5890,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;
 }
@@ -5959,10 +5903,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;
@@ -6002,8 +5944,7 @@ get_phys_cursor_glyph (struct window *w)
        hpos = row->used[TEXT_AREA] - 1;
    }
-  if (row->used[TEXT_AREA] > hpos
+  if (0 <= hpos && hpos < row->used[TEXT_AREA])
-      && 0 <= hpos)
    glyph = row->glyphs[TEXT_AREA] + hpos;
  else
    glyph = NULL;
@@ -6019,14 +5960,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);
@@ -6093,15 +6034,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
@@ -6110,7 +6051,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
@@ -6131,10 +6072,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;
@@ -6451,7 +6390,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;
        }
    }
@@ -6485,10 +6424,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 4f6374b9d3e..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))))
@@ -512,9 +521,14 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 /* 1 if W is a menu bar window.  */
+#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
 #define WINDOW_MENU_BAR_P(W) \
  (WINDOWP (WINDOW_XFRAME (W)->menu_bar_window) \
   && (W) == XWINDOW (WINDOW_XFRAME (W)->menu_bar_window))
+#else
+/* No menu bar windows if X toolkit is in use.  */
+#define WINDOW_MENU_BAR_P(W) (0)
+#endif
 /* 1 if W is a tool bar window.  */
@@ -926,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 2a565b5cffd..41214880a56 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -580,7 +580,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.  */
@@ -1283,10 +1283,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);
@@ -2677,7 +2677,7 @@ init_iterator (struct it *it, struct window *w,
     and IT->region_end_charpos to the start and end of a visible region
     in window IT->w.  Set both to -1 to indicate no region.  */
  markpos = markpos_of_region ();
-  if (0 <= markpos
+  if (markpos >= 0
      /* Maybe highlight only in selected window.  */
      && (/* Either show region everywhere.  */
          highlight_nonselected_windows
@@ -4458,7 +4458,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,
@@ -4866,7 +4866,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;
@@ -5012,7 +5012,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
@@ -5836,7 +5836,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;
@@ -5849,7 +5849,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;
@@ -6290,7 +6290,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;
@@ -7141,7 +7141,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;
@@ -7714,7 +7714,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;
    }
@@ -7978,7 +7978,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
@@ -8084,7 +8084,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);
    }
@@ -8925,7 +8925,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;
    }
@@ -8952,7 +8951,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)
@@ -9994,7 +9992,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;
@@ -10003,13 +10001,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);
    }
@@ -10032,16 +10032,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;
@@ -10255,9 +10257,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
@@ -10284,10 +10286,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);
@@ -10736,7 +10738,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)
@@ -10751,7 +10753,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));
@@ -11005,7 +11007,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;
@@ -11124,7 +11126,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;
        }
@@ -11196,7 +11198,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))
@@ -11400,7 +11402,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)
@@ -12267,10 +12269,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;
@@ -12290,7 +12290,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
@@ -12325,7 +12325,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;
@@ -12378,7 +12378,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;
                }
@@ -12467,9 +12467,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);
 }
@@ -12533,8 +12533,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;
    }
@@ -12757,7 +12757,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;
@@ -12766,11 +12766,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;
    }
 }
@@ -12948,8 +12948,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);
@@ -13025,11 +13023,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
@@ -13047,7 +13045,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.  */
@@ -13171,7 +13169,7 @@ redisplay_internal (void)
               /* Make sure the cursor was last displayed
                  in this window.  Otherwise we have to reposition it.  */
               && 0 <= w->cursor.vpos
-               && WINDOW_TOTAL_LINES (w) > w->cursor.vpos)
+               && w->cursor.vpos < WINDOW_TOTAL_LINES (w))
        {
          if (!must_finish)
            {
@@ -13338,7 +13336,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,
@@ -13548,7 +13546,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;
@@ -13595,11 +13593,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);
    }
@@ -13656,13 +13652,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,
@@ -14309,7 +14303,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;
@@ -14345,7 +14339,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))
@@ -14354,7 +14348,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;
@@ -15005,7 +14999,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;
@@ -15068,7 +15062,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
@@ -15175,7 +15169,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
@@ -15209,7 +15203,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;
@@ -15231,12 +15225,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);
@@ -15262,10 +15258,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.  */
@@ -15287,7 +15283,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
@@ -15520,7 +15516,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
          /* If we are highlighting the region, then we just changed
             the region, so redisplay to show it.  */
-          if (0 <= markpos_of_region ())
+          if (markpos_of_region () >= 0)
            {
              clear_glyph_matrix (w->desired_matrix);
              if (!try_window (window, startp, 0))
@@ -16221,7 +16217,7 @@ try_window_reusing_current_matrix (struct window *w)
    return 0;
  /* Can't do this if region may have changed.  */
-  if (0 <= markpos_of_region ()
+  if (markpos_of_region () >= 0
      || w->region_showing
      || !NILP (Vshow_trailing_whitespace))
    return 0;
@@ -16578,7 +16574,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))
@@ -16829,7 +16825,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));
@@ -16871,7 +16867,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.  */
@@ -16907,7 +16903,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
@@ -17053,7 +17049,7 @@ try_window_id (struct window *w)
  /* Can't use this if highlighting a region because a cursor movement
     will do more than just set the cursor.  */
-  if (0 <= markpos_of_region ())
+  if (markpos_of_region () >= 0)
    GIVE_UP (9);
  /* Likewise if highlighting trailing whitespace.  */
@@ -17073,7 +17069,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
@@ -17084,8 +17080,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
@@ -17950,7 +17946,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));
@@ -18056,7 +18052,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);
@@ -19263,7 +19259,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;
@@ -19988,18 +19984,17 @@ display_menu_bar (struct window *w)
    return;
 #endif /* HAVE_NS */
-#ifdef USE_X_TOOLKIT
+#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
  eassert (!FRAME_WINDOW_P (f));
  init_iterator (&it, w, -1, -1, f->desired_matrix->rows, MENU_FACE_ID);
  it.first_visible_x = 0;
  it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
-#else /* not USE_X_TOOLKIT */
+#elif defined (HAVE_X_WINDOWS) /* X without toolkit.  */
  if (FRAME_WINDOW_P (f))
    {
      /* Menu bar lines are displayed in the desired matrix of the
         dummy window menu_bar_window.  */
      struct window *menu_w;
-      eassert (WINDOWP (f->menu_bar_window));
      menu_w = XWINDOW (f->menu_bar_window);
      init_iterator (&it, menu_w, -1, -1, menu_w->desired_matrix->rows,
                     MENU_FACE_ID);
@@ -20007,6 +20002,7 @@ display_menu_bar (struct window *w)
      it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
    }
  else
+#endif /* not USE_X_TOOLKIT and not USE_GTK */
    {
      /* This is a TTY frame, i.e. character hpos/vpos are used as
         pixel x/y.  */
@@ -20015,7 +20011,6 @@ display_menu_bar (struct window *w)
      it.first_visible_x = 0;
      it.last_visible_x = FRAME_COLS (f);
    }
-#endif /* not USE_X_TOOLKIT */
  /* FIXME: This should be controlled by a user option.  See the
     comments in redisplay_tool_bar and display_mode_line about
@@ -20079,10 +20074,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)
@@ -20092,7 +20085,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.  */
@@ -20874,7 +20867,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
@@ -21009,7 +21002,7 @@ pint2hrstr (char *buf, int width, ptrdiff_t d)
  char * psuffix;
  char * p;
-  if (1000 <= quotient)
+  if (quotient >= 1000)
    {
      /* Scale to the appropriate EXPONENT. */
      do
@@ -21018,13 +21011,13 @@ pint2hrstr (char *buf, int width, ptrdiff_t d)
          quotient /= 1000;
          exponent++;
        }
-      while (1000 <= quotient);
+      while (quotient >= 1000);
      /* Round to nearest and decide whether to use TENTHS or not. */
      if (quotient <= 9)
        {
          tenths = remainder / 100;
-          if (50 <= remainder % 100)
+          if (remainder % 100 >= 50)
            {
              if (tenths < 9)
                tenths++;
@@ -21039,7 +21032,7 @@ pint2hrstr (char *buf, int width, ptrdiff_t d)
            }
        }
      else
-        if (500 <= remainder)
+        if (remainder >= 500)
          {
            if (quotient < 999)
              quotient++;
@@ -22180,7 +22173,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;
    }
@@ -22232,7 +22225,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;
        }
@@ -22392,16 +22385,16 @@ get_char_face_and_encoding (struct frame *f, int c, int face_id,
                            XChar2b *char2b, int display_p)
 {
  struct face *face = FACE_FROM_ID (f, face_id);
+  unsigned code = 0;
  if (face->font)
    {
-      unsigned code = face->font->driver->encode_char (face->font, c);
+      code = face->font->driver->encode_char (face->font, c);
-      if (code != FONT_INVALID_CODE)
+      if (code == FONT_INVALID_CODE)
-        STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
+        code = 0;
-      else
-        STORE_XCHAR2B (char2b, 0, 0);
    }
+  STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
  /* Make sure X resources of the face are allocated.  */
 #ifdef HAVE_X_WINDOWS
@@ -22425,31 +22418,30 @@ get_glyph_face_and_encoding (struct frame *f, struct glyph *glyph,
                             XChar2b *char2b, int *two_byte_p)
 {
  struct face *face;
+  unsigned code = 0;
  eassert (glyph->type == CHAR_GLYPH);
  face = FACE_FROM_ID (f, glyph->face_id);
+  /* Make sure X resources of the face are allocated.  */
+  eassert (face != NULL);
+  PREPARE_FACE_FOR_DISPLAY (f, face);
  if (two_byte_p)
    *two_byte_p = 0;
  if (face->font)
    {
-      unsigned code;
      if (CHAR_BYTE8_P (glyph->u.ch))
        code = CHAR_TO_BYTE8 (glyph->u.ch);
      else
        code = face->font->driver->encode_char (face->font, glyph->u.ch);
-      if (code != FONT_INVALID_CODE)
+      if (code == FONT_INVALID_CODE)
-        STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
+        code = 0;
-      else
-        STORE_XCHAR2B (char2b, 0, 0);
    }
-  /* Make sure X resources of the face are allocated.  */
+  STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
-  eassert (face != NULL);
-  PREPARE_FACE_FOR_DISPLAY (f, face);
  return face;
 }
@@ -22759,9 +22751,12 @@ static struct font_metrics *
 get_per_char_metric (struct font *font, XChar2b *char2b)
 {
  static struct font_metrics metrics;
-  unsigned code = (XCHAR2B_BYTE1 (char2b) << 8) | XCHAR2B_BYTE2 (char2b);
+  unsigned code;
-  if (! font || code == FONT_INVALID_CODE)
+  if (! font)
+    return NULL;
+  code = (XCHAR2B_BYTE1 (char2b) << 8) | XCHAR2B_BYTE2 (char2b);
+  if (code == FONT_INVALID_CODE)
    return NULL;
  font->driver->text_extents (font, &code, 1, &metrics);
  return &metrics;
@@ -24082,7 +24077,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);
@@ -25478,7 +25473,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;
@@ -26029,10 +26024,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);
@@ -27278,7 +27271,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;
                }
            }
@@ -27314,7 +27307,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))
                {
@@ -27589,7 +27582,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)
@@ -27798,8 +27791,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;
                    }
                }
@@ -27912,11 +27905,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;
                          }
                      }
                  }
@@ -27967,7 +27960,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)
@@ -28410,12 +28403,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);
@@ -28480,11 +28470,11 @@ expose_frame (struct frame *f, int x, int y, int w, int h)
 #ifdef HAVE_X_WINDOWS
 #ifndef MSDOS
-#ifndef USE_X_TOOLKIT
+#if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
  if (WINDOWP (f->menu_bar_window))
    mouse_face_overwritten_p
      |= expose_window (XWINDOW (f->menu_bar_window), &r);
-#endif /* not USE_X_TOOLKIT */
+#endif /* not USE_X_TOOLKIT and not USE_GTK */
 #endif
 #endif
diff --git a/src/xfaces.c b/src/xfaces.c
index eb33a38a491..9acaf6d6f52 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 ();
  CHECK_STRING (pattern);
  if (! NILP (maximum))
@@ -3395,21 +3393,22 @@ set_font_frame_param (Lisp_Object frame, Lisp_Object lface)
    }
 }
-/* Get the value of X resource RESOURCE, class CLASS for the display
-   of frame FRAME.  This is here because ordinary `x-get-resource'
-   doesn't take a frame argument.  */
 DEFUN ("internal-face-x-get-resource", Finternal_face_x_get_resource,
-       Sinternal_face_x_get_resource, 3, 3, 0, doc: /* */)
+       Sinternal_face_x_get_resource, 2, 3, 0,
+       doc: /* Get the value of X resource RESOURCE, class CLASS.
+Returned value is for the display of frame FRAME.  If FRAME is not
+specified or nil, use selected frame.  This function exists because
+ordinary `x-get-resource' doesn't take a frame argument.  */)
  (Lisp_Object resource, Lisp_Object class, Lisp_Object frame)
 {
  Lisp_Object value = Qnil;
+  struct frame *f;
  CHECK_STRING (resource);
  CHECK_STRING (class);
-  CHECK_LIVE_FRAME (frame);
+  f = decode_live_frame (frame);
  block_input ();
-  value = display_x_get_resource (FRAME_X_DISPLAY_INFO (XFRAME (frame)),
+  value = display_x_get_resource (FRAME_X_DISPLAY_INFO (f),
                                  resource, class, Qnil, Qnil);
  unblock_input ();
  return value;
@@ -5963,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);
@@ -5973,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);
@@ -6071,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);
@@ -6081,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 488365561d3..8b8d94d4779 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -143,7 +143,7 @@ static struct x_display_info *x_display_info_for_name (Lisp_Object);
 /* Error if we are not connected to X.  */
 void
-check_x (void)
+check_window_system (void)
 {
  if (! x_in_use)
    error ("X windows are not in use or not initialized");
@@ -4322,7 +4322,7 @@ no value of TYPE (always string in the MS Windows case).  */)
             property and those are indeed in 32 bit quantities if format is
             32.  */
-          if (32 < BITS_PER_LONG && actual_format == 32)
+          if (BITS_PER_LONG > 32 && actual_format == 32)
            {
              unsigned long i;
              int  *idata = (int *) tmp_data;
@@ -4525,7 +4525,7 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
  Lisp_Object buffer;
  struct buffer *old_buffer;
-  check_x ();
+  check_window_system ();
  if (!dpyinfo->terminal->name)
    error ("Terminal is not live, can't create new frames on it");
@@ -5043,7 +5043,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);
@@ -5316,7 +5316,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 ();
  GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
@@ -5486,7 +5486,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 ();
  GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
@@ -5548,7 +5548,7 @@ nil, it defaults to the selected frame. */)
  struct gcpro gcpro1, gcpro2;
  ptrdiff_t count = SPECPDL_INDEX ();
-  check_x ();
+  check_window_system ();
  if (popup_activated ())
    error ("Trying to use a menu from within a menu-entry");
@@ -5591,7 +5591,7 @@ nil, it defaults to the selected frame. */)
                               Keyboard
 ***********************************************************************/
-#ifdef HAVE_XKBGETKEYBOARD
+#ifdef HAVE_XKB
 #include <X11/XKBlib.h>
 #include <X11/keysym.h>
 #endif
@@ -5605,7 +5605,9 @@ usual X keysyms.  Value is `lambda' if we cannot determine if both keys are
 present and mapped to the usual X keysyms.  */)
  (Lisp_Object frame)
 {
-#ifdef HAVE_XKBGETKEYBOARD
+#ifndef HAVE_XKB
+  return Qlambda;
+#else
  XkbDescPtr kb;
  struct frame *f = check_x_frame (frame);
  Display *dpy = FRAME_X_DISPLAY (f);
@@ -5683,9 +5685,7 @@ present and mapped to the usual X keysyms.  */)
    }
  unblock_input ();
  return have_keys;
-#else /* not HAVE_XKBGETKEYBOARD */
+#endif
-  return Qlambda;
-#endif /* not HAVE_XKBGETKEYBOARD */
 }
@@ -5919,9 +5919,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/xmenu.c b/src/xmenu.c
index 958cd220393..e6291edf7d6 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -223,7 +223,7 @@ for instance using the window manager, then this produces a quit and
  FRAME_PTR f = NULL;
  Lisp_Object window;
-  check_x ();
+  check_window_system ();
  /* Decode the first argument: find the window or frame to use.  */
  if (EQ (position, Qt)
@@ -976,7 +976,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.  */
@@ -1055,7 +1055,7 @@ set_frame_menubar (FRAME_PTR f, bool first_time, bool deep_p)
      wv->help = Qnil;
      first_wv = wv;
-      for (i = 0; 0 <= submenu_start[i]; i++)
+      for (i = 0; submenu_start[i] >= 0; i++)
        {
          menu_items_n_panes = submenu_n_panes[i];
          wv = digest_single_submenu (submenu_start[i], submenu_end[i],
@@ -2479,7 +2479,7 @@ xmenu_show (FRAME_PTR f, int x, int y, bool for_click, bool keymaps,
 #endif
  record_unwind_protect (pop_down_menu,
-                         make_save_value ("pp", f, menu));
+                         make_save_value (SAVE_TYPE_PTR_PTR, f, menu));
  /* Help display under X won't work because XMenuActivate contains
     a loop that doesn't give Emacs a chance to process it.  */
diff --git a/src/xselect.c b/src/xselect.c
index 5b90d7def22..cca1a47212b 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1388,7 +1388,7 @@ x_get_window_property (Display *display, Window window, Atom property,
          data = data1;
        }
-      if (32 < BITS_PER_LONG && *actual_format_ret == 32)
+      if (BITS_PER_LONG > 32 && *actual_format_ret == 32)
        {
          unsigned long i;
          int  *idata = (int *) (data + offset);
@@ -2541,7 +2541,7 @@ x_handle_dnd_message (struct frame *f, XClientMessageEvent *event,
     function expects them to be of size int (i.e. 32).  So to be able to
     use that function, put the data in the form it expects if format is 32. */
-  if (32 < BITS_PER_LONG && event->format == 32)
+  if (BITS_PER_LONG > 32 && event->format == 32)
    {
      for (i = 0; i < 5; ++i) /* There are only 5 longs in a ClientMessage. */
        idata[i] = event->data.l[i];
@@ -2571,7 +2571,7 @@ x_handle_dnd_message (struct frame *f, XClientMessageEvent *event,
  return 1;
 }
-DEFUN ("x-send-client-message", Fx_send_client_event,
+DEFUN ("x-send-client-message", Fx_send_client_message,
       Sx_send_client_message, 6, 6, 0,
       doc: /* Send a client message of MESSAGE-TYPE to window DEST on DISPLAY.
diff --git a/src/xterm.c b/src/xterm.c
index 88433b6c0b3..e4a681031ef 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -130,6 +130,10 @@ extern void _XEditResCheckMessages (Widget, XtPointer, XEvent *, Boolean *);
 #include "bitmaps/gray.xbm"
+#ifdef HAVE_XKB
+#include <X11/XKBlib.h>
+#endif
 /* Default to using XIM if available.  */
 #ifdef USE_XIM
 int use_xim = 1;
@@ -3218,7 +3222,11 @@ XTring_bell (struct frame *f)
      else
        {
          block_input ();
+#ifdef HAVE_XKB
+          XkbBell (FRAME_X_DISPLAY (f), None, 0, None);
+#else
          XBell (FRAME_X_DISPLAY (f), 0);
+#endif
          XFlush (FRAME_X_DISPLAY (f));
          unblock_input ();
        }
@@ -5076,7 +5084,7 @@ x_scroll_bar_set_handle (struct scroll_bar *bar, int start, int end, int rebuild
    /* Draw the empty space above the handle.  Note that we can't clear
       zero-height areas; that means "clear to end of window."  */
-    if (0 < start)
+    if (start > 0)
      x_clear_area (FRAME_X_DISPLAY (f), w,
                    /* x, y, width, height, and exposures.  */
                    VERTICAL_SCROLL_BAR_LEFT_BORDER,
diff --git a/src/xterm.h b/src/xterm.h
index b241ff23559..6b64135927e 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 *,
author	Kenichi Handa	2013-04-05 23:17:55 +0900
committer	Kenichi Handa	2013-04-05 23:17:55 +0900
commit	b7a6f9f7919b7fc0871ae768b58f8e746aa7dd9f (patch)
tree	f32c8cce416e346d2953f063a0f22e95382cf57e /src
parent	251e91474c91e16b101502c2ed7c05fc13e4ecea (diff)
parent	73931ad14ad7a51d91f10b19ae9ca8cadb256916 (diff)
download	emacs-b7a6f9f7919b7fc0871ae768b58f8e746aa7dd9f.tar.gz emacs-b7a6f9f7919b7fc0871ae768b58f8e746aa7dd9f.zip