97 files changed, 5021 insertions, 3765 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 69e00cadbe9..e0aa1ed577f 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,1388 @@
+2013-09-03  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * buffer.c (drop_overlay):
+        * fileio.c (restore_point_unwind): Prefer unchain_marker to
+        Fset_marker (X, Qnil, ...) (which is the same but a bit slower).
+
+2013-09-03  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * buffer.c (Fmake_overlay, Fmove_overlay):
+        * intervals.c (set_point_from_marker):
+        * print.c (PRINTPREPARE): Prefer signal_error
+        to plain error and report unsuitable marker too.
+
+2013-09-03  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xterm.h (struct scroll_bar): Prefer int to Lisp_Object
+        for 'dragging' member.
+        (struct x_output): Remove set-but-unused leftovers
+        'left_before_move' and 'top_before_move'.
+        * gtkutil.c (xg_set_toolkit_scroll_bar_thumb):
+        * xterm.c (xt_action_hook, xm_scroll_callback, xg_scroll_callback)
+        (xg_end_scroll_callback, xaw_jump_callback, xaw_scroll_callback)
+        (x_set_toolkit_scroll_bar_thumb, x_scroll_bar_create)
+        (x_scroll_bar_set_handle, XTset_vertical_scroll_bar)
+        (x_scroll_bar_handle_click, x_scroll_bar_note_movement)
+        (x_scroll_bar_report_motion, x_set_offset): Related users changed.
+        * xfns.c, image.c (XLIB_ILLEGAL_ACCESS): No longer needed.
+
+2013-09-03  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfont.m (INVALID_GLYPH): New define.
+        (nsfont_encode_char): Use INVALID_GLYPH.
+        (ns_uni_to_glyphs): Ditto, check for NSNullGlyph (Bug#15138).
+
+2013-09-02  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xterm.c (x_last_mouse_movement_time): Revert last change.
+        This code should use XDisplayMotionBufferSize to check display's
+        motion history first, and there are few other issues as well.
+        (x_scroll_bar_note_movement): Pass XMotionEvent rather than XEvent.
+        (handle_one_xevent): Adjust user.
+
+2013-09-02  Martin Rudalics  <rudalics@gmx.at>
+
+        * dispnew.c (Flast_nonminibuf_frame): Move from here ...
+        * frame.c (Flast_nonminibuf_frame): ... to here.
+        (check_minibuf_window): Don't abort if no window was found
+        (Bug#15247).
+
+2013-09-02  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Use XGetMotionEvents to ask the last mouse motion time from X server.
+        * xterm.c (X_MOTION_HISTORY): Default to 1.
+        (x_last_mouse_movement_time) [X_MOTION_HISTORY]: New function.
+        (x_last_mouse_movement_time) [!X_MOTION_HISTORY]: Legacy version.
+        (note_mouse_movement, x_scroll_bar_note_movement) [!X_MOTION_HISTORY]:
+        Ifdef away legacy code.
+        (XTmouse_position, x_scroll_bar_report_motion):
+        Use x_last_mouse_movement_time.
+        (handle_one_xevent): Use event.xunmap and not event.xmap when handling
+        UnmapNotify event.
+
+2013-09-02  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * msdos.c (last_mouse_window): Move to...
+        (dos_rawgetc): ...this function and adjust comment.
+        * nsterm.m (last_window): Rename to last_mouse_window, move to...
+        (mouseMoved): ...this function and adjust comment.
+        * w32term.c (last_window): Likewise with...
+        (w32_read_socket): ...this function.
+        * xterm.c (last_window): Likewise with...
+        (handle_one_xevent): ...this function.
+
+2013-09-02  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.h (Vmouse_window, Vmouse_event): Remove the leftovers.
+        * xterm.c (toplevel): Drop obsolete comment and move compose_status...
+        (handle_one_xevent): ...to here.
+        (STORE_KEYSYM_FOR_DEBUG): Move under ENABLE_CHECKING and make no-op
+        otherwise.
+
+2013-09-02  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * msdos.c (IT_set_terminal_window): Remove no-op.
+        (initialize_msdos_display): Adjust terminal setup.
+        * w32console.c (w32con_set_terminal_window): Remove no-op.
+        (initialize_w32_display): Adjust terminal setup.
+        * w32term.c (w32_set_terminal_window): Remove no-op.
+        (w32_create_terminal): Adjust terminal setup.
+        * xterm.c (XTset_terminal_window): Remove no-op.
+        (x_create_terminal): Adjust terminal setup.
+
+2013-09-01  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * nsterm.m (ns_set_terminal_modes, ns_reset_terminal_modes):
+        Remove no-ops.
+        (ns_create_terminal): Adjust terminal setup.
+        * w32term.c (w32_set_terminal_modes, w32_reset_terminal_modes):
+        Remove no-ops.
+        (w32_create_terminal): Adjust terminal setup.
+        * xterm.c (XTset_terminal_modes, XTreset_terminal_modes):
+        Remove no-ops.
+        (x_create_terminal): Adjust terminal setup.
+
+2013-09-01  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * dispextern.h (SET_TEXT_POS_FROM_MARKER): Indent.
+        (CLIP_TEXT_POS_FROM_MARKER): New macro.
+        * dispnew.c (buffer_posn_from_coords):
+        * window.c (Fwindow_end, displayed_window_lines):
+        * xdisp.c (redisplay_mode_lines): Use it.
+
+2013-09-01  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * fontset.c (face_for_char): Check char in the current face font first
+        if HAVE_NS (Bug#15138).
+
+2013-08-31  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.c (temp_output_buffer_show): Make sure window returned
+        by display_buffer is live (Bug#15213).
+
+2013-08-30  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Minor cleanup to avoid forward declarations.
+        * coding.h (struct ccl_spec): Remove forward declaration.
+        * composite.h (toplevel): Include font.h.
+        (struct composition_it, struct face, struct font_metrics):
+        Remove forward declaration.
+        * dispextern.h (struct image, struct atimer): Likewise.
+        * emacsgtkfixed.h (struct frame): Likewise.
+        * emacsgtkfixed.c (toplevel): Reorder headers and drop stdio.h.
+        * font.h (struct font_driver, struct font, struct glyph_string)
+        (struct face): Remove forward declaration.
+        * fontset.h (struct face, struct font): Likewise.
+        * frame.h (toplevel): Style cleanup.
+        (enum output_method): Move to...
+        * termhooks.h (enum output_method): ...here.
+        (struct glyph, struct frame, struct ns_display_info)
+        (struct x_display_info, struct w32_display_info):
+        Remove forward declaration.
+        * xterm.h (toplevel): Include termhooks.h.
+        (struct font, struct window, struct glyph_matrix, struct frame)
+        (struct input_event, struct face, struct image): Remove forward
+        declaration.
+        * gtkutil.h (struct _widget_value): Likewise.
+        * keyboard.h (toplevel): Include termhooks.h.
+        (struct input_event): Remove forward declaration.
+
+2013-08-29  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * intervals.c (set_point_from_marker): New function.
+        * editfns.c (Fgoto_char):
+        * process.c (Finternal_default_process_filter):
+        * window.c (select_window_1): Use it.
+        * buffer.h (set_point_from_marker): Add prototype.
+
+2013-08-29  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (term_winsock): Call release_listen_threads before calling
+        WSACleanup.
+        (_sys_wait_accept): Wait for accept event in a loop with a finite
+        timeout, instead of waiting indefinitely.  Will hopefully avoid
+        hanging during exit because WSACleanup deadlocks waiting for the
+        event object to be released.  (Bug#14333)
+
+        * w32proc.c (release_listen_threads): New function, signals all
+        the reader threads that listen for connections to stop waiting.
+
+        * w32.h (release_listen_threads): Add prototype.
+
+2013-08-29  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * alloc.c (Fmake_marker, build_marker): Zero need_adjustment
+        field of new marker (for sanity and safety).
+        * lisp.h (XSETMARKER): Remove unused macro (it doesn't work
+        anyway because XMISCTYPE is a function and can't be an lvalue).
+
+2013-08-29  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xterm.c (x_clear_area): Lost 7th arg because it is always False.
+        (x_after_update_window_line, x_scroll_bar_create):
+        (x_scroll_bar_set_handle, XTset_vertical_scroll_bar):
+        (handle_one_xevent, x_clear_frame_area):
+        * gtkutil.c (xg_clear_under_internal_border, xg_update_scrollbar_pos):
+        * xfns.c (x_set_menu_bar_lines, x_set_tool_bar_lines): Adjust users.
+        * xterm.h (x_clear_area): Adjust prototype.
+
+2013-08-29  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Hook scanning and indentation functions to find_newline.  This helps
+        to avoid duplicated code and renders more respect to newline cache.
+        * lisp.h (scan_newline): Prefer ptrdiff_t to EMACS_INT.
+        * cmds.c (Fforward_line):
+        * indent.c (scan_for_column, Fcurrent_indentation, indented_beyond_p):
+        Use find_newline and avoid unnecessary point movements.
+        * search.c (scan_newline): Implement on top of find_newline.
+
+2013-08-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (Ffuncall): Fix handling of ((lambda ..) ..) in lexically
+        scoped code (bug#11258).
+
+2013-08-28  Davor Cubranic  <cubranic@stat.ubc.ca> (tiny change)
+
+        * nsterm.m (last_window): New variable.
+        (EV_TRAILER2): New macro.
+        (EV_TRAILER): Call EV_TRAILER2.
+        (mouseMoved:):  Add support for mouse-autoselect-window
+        on nextstep (Bug#6888).
+
+2013-08-28  Andreas Schwab  <schwab@suse.de>
+
+        * regex.c (CHAR_CHARSET, CHARSET_LEADING_CODE_BASE, CHAR_HEAD_P)
+        (SINGLE_BYTE_CHAR_P, SAME_CHARSET_P, MAKE_CHAR, BYTE8_TO_CHAR):
+        Remove unused macro definitions.
+        (CHARSET_RANGE_TABLE_BITS, EXTEND_RANGE_TABLE)
+        (SET_RANGE_TABLE_WORK_AREA_BIT, SET_RANGE_TABLE_WORK_AREA):
+        Only define if emacs.
+
+2013-08-28  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Prefer enum glyph_row_area to int where appropriate.
+        * dispextern.h (enum glyph_row_area): Add ANY_AREA member.
+        Fix comment.
+        (window_box, window_box_width, window_box_left, window_box_left_offset)
+        (window_box_right, window_box_right_offset): Adjust prototypes.
+        * xdisp.c (window_box, window_box_width, window_box_left)
+        (window_box_left_offset, window_box_right, window_box_right_offset):
+        Use enum glyph_row_area.  Adjust users and tweak comment where needed.
+        (window_box_edges): Likewise.  Lost 2nd arg since it is always ANY_AREA.
+        * nsterm.m (ns_clip_to_row):
+        * w32term.c (w32_clip_to_row):
+        * xterm.c (x_clip_to_row): Likewise.
+
+2013-08-28  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * buffer.c (Foverlays_at, Foverlays_in, Fnext_overlay_change)
+        (Fprevious_overlay_change): Fast path for buffer with no overlays.
+
+2013-08-28  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * Makefile.in (SHELL): Now @SHELL@, not /bin/sh,
+        for portability to hosts where /bin/sh has problems.
+
+2013-08-28  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Redesign redisplay interface to drop global output_cursor.
+        * dispextern.h (struct redisplay_interface): Remove cursor_to member.
+        (toplevel): Remove declaration of output_cursor.
+        (set_output_cursor, x_cursor_to): Remove prototype.
+        * window.h (struct window): New member output_cursor.
+        (output_cursor_to): New function to replace RIF member.
+        * dispnew.c (redraw_overlapped_rows, update_marginal_area)
+        (update_text_area, set_window_cursor_after_update): Use it.
+        * xdisp.c (output_cursor, set_output_cursor, x_cursor_to): Remove.
+        (x_write_glyphs, x_insert_glyphs, x_clear_end_of_line):
+        * nsterm.m (ns_update_window_begin, ns_update_window_end):
+        * w32term.c (x_update_window_begin, x_update_window_end):
+        * xterm.c (x_update_window_begin, x_update_window_end):
+        Adjust to use per-window output cursor.
+
+2013-08-27  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Simplify SELECT_TYPE-related code.
+        Like EMACS_TIME, this portability layer is no longer needed, since
+        Emacs has been using fd_set as a portability layer for some time.
+        * sysselect.h (FD_SETSIZE): Rename from MAXDESC.  All uses changed.
+        (SELECT_TYPE): Remove.  All uses changed to fd_set.
+        (fd_set) [!FD_SET]: New typedef.
+
+        Simplify EMACS_TIME-related code.
+        This portability layer is no longer needed, since Emacs has been
+        using struct timespec as a portability layer for some time.
+        * atimer.h, buffer.h, dispextern.h, xgselect.h:
+        Include <time.h> rather than "systime.h"; that's all that's needed now.
+        * dispnew.c: Include <timespec.h> rather than "systime.h";
+        that's all that's needed now.
+        * systime.h (EMACS_TIME): Remove.  All uses changed to struct timespec.
+        (EMACS_TIME_RESOLUTION): Remove.  All uses changed to
+        TIMESPEC_RESOLUTION.
+        (LOG10_EMACS_TIME_RESOLUTION): Remove.  All uses changed to
+        LOG10_TIMESPEC_RESOLUTION.
+        (EMACS_SECS, emacs_secs_addr): Remove.  All uses changed to tv_sec.
+        (EMACS_NSECS): Remove.  All uses changed to tv_nsec.
+        (make_emacs_time): Remove.  All used changed to make_timespec.
+        (invalid_timespec): Rename from invalid_emacs_time.  All uses changed.
+        (current_timespec): Rename from current_emacs_time.  All uses changed.
+        (add_emacs_time): Remove.  All uses changed to timespec_add.
+        (sub_emacs_time): Remove.  All uses change dot timespec_sub.
+        (EMACS_TIME_SIGN): Remove.  All uses changed to timespec_sign.
+        (timespec_valid_p): Rename from EMACS_TIME_VALID_P.  All uses changed.
+        (EMACS_TIME_FROM_DOUBLE): Remove.  All uses changed to dtotimespec.
+        (EMACS_TIME_TO_DOUBLE): Remove.  All uses changed to timespectod.
+        (current_timespec): Rename from current_emacs_time.  All uses changed.
+        (EMACS_TIME_EQ, EMACS_TIME_LT, EMACS_TIME_LE): Remove.  All uses
+        changed to timespec_cmp.
+        * xgselect.c: Include <timespec.h>, since our .h files don't.
+
+2013-08-27  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xterm.h (FONT_TYPE_FOR_UNIBYTE, FONT_TYPE_FOR_MULTIBYTE:)
+        * nsterm.h (FONT_TYPE_FOR_UNIBYTE, FONT_TYPE_FOR_MULTIBYTE):
+        Remove the leftovers.
+        * gtkutil.c (toplevel): Do not declare Qxft but include
+        font.h to do so.
+        * image.c (toplevel): Do not declare Vlibrary_cache because
+        it's already done in lisp.h.
+
+2013-08-27  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (Mouse_HLInfo): Move from here...
+        * dispextern.h (Mouse_HLInfo): ...to here and offload lisp.h.
+        (reset_mouse_highlight): New function.
+        * msdos.c (dos_set_window_size, IT_update_begin)
+        (internal_terminal_init):
+        * nsterm.m (ns_update_window_end, x_free_frame_resources)
+        (ns_initialize_display_info):
+        * w32console.c (initialize_w32_display):
+        * w32term.c (x_update_window_end, x_free_frame_resources)
+        (w32_initialize_display_info):
+        * xterm.c (x_update_window_end, x_free_frame_resources, x_term_init):
+        * window.c (Fdelete_other_windows_internal):
+        * xdisp.c (clear_mouse_face, cancel_mouse_face): Use it.
+        * termchar.h (toplevel):
+        * xterm.h (toplevel): Include dispextern.h.
+
+2013-08-26  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor problems found by static checking.
+        * image.c (XGetPixel, XPutPixel) [HAVE_NS]: Now static.
+        (expect): Avoid nested-if warning.
+        (x_build_heuristic_mask) [HAVE_NS]: Avoid unused-var warning.
+        * nsmenu.m (fillWithWidgetValue:): Avoid type warning.
+        * nsterm.h, nsterm.m (ns_select):
+        * xgselect.c, xgselect.h (xg_select):
+        Adjust signature to better match pselect's.
+        * nsterm.m (ns_select):
+        Don't set *TIMEOUT, since pselect doesn't.
+        * regex.c (whitespace_regexp): Now const_re_char *, to avoid
+        diagnostic about assigning const char * to it.
+        * xfaces.c (x_display_info) [HAVE_NS]: Remove; unused.
+
+2013-08-26  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lread.c (substitute_object_recurse): Handle hash-tables as well
+        (bug#15190).
+
+2013-08-26  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix unlikely core dump in init_tty, and simplify terminfo case.
+        * term.c (init_tty) [TERMINFO]: Fix check for buffer overrun.
+        The old version incorrectly dumped core if malloc returned a
+        buffer containing only non-NUL bytes.
+        (init_tty): Do not allocate or free termcap buffers; the
+        struct does that for us now.
+        * termchar.h (TERMCAP_BUFFER_SIZE) [!TERMINFO]: New constant.
+        (struct tty_display_info): Define members termcap_term_buffer and
+        termcap_strings_buffer only if !TERMINFO, since terminfo doesn't
+        use them.  Allocate them directly in struct rather than indirectly
+        via a pointer, to simplify init_tty.
+
+        * frame.c (check_minibuf_window): Initialize 'window' properly,
+        so that Emacs reliably aborts later if 'window' is not initialized.
+
+2013-08-26  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (xg_initialize): Set gtk-menu-bar-accel to "" instead
+        of VoidSymbol (Bug#15154).
+
+2013-08-26  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (Mouse_HLInfo): Drop set-but-unused members
+        mouse_face_beg_y and mouse_face_end_y.
+        * xdisp.c (note_tool_bar_highlight, mouse_face_from_buffer_pos)
+        (mouse_face_from_string_pos, note_mode_line_or_margin_highlight):
+        Adjust users and update comment where appropriate.
+
+2013-08-26  Martin Rudalics  <rudalics@gmx.at>
+
+        * frame.c (check_minibuf_window): New function.
+        (delete_frame, Fmake_frame_invisible, Ficonify_frame):
+        Call check_minibuf_window (Bug#15183).
+
+2013-08-26  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.h (struct window): Replace last_cursor with last_cursor_vpos
+        because this is the only last cursor data we need to keep and consult.
+        * window.c (replace_window, set_window_buffer, Fsplit_window_internal):
+        * xdisp.c (mark_window_display_accurate_1, try_cursor_movement):
+        Adjust users.
+
+2013-08-26  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix recovering from possible decompression error.
+        Since insert_from_gap doesn't always move point, we can't use PT as
+        the position where the partially decompressed data ends, and
+        should count how many bytes was produced so far.
+        * decompress.c (struct decompress_unwind_data): Add nbytes member.
+        (unwind_decompress): Really delete partially uncompressed data.
+        (Fzlib_decompress_region): Take decompressed data size into account.
+
+2013-08-26  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * syntax.c (init_syntax_once): Adjust comment and do an early
+        initialization of Qchar_table_extra_slots just once...
+        * casetab.c (init_casetab_once):
+        * category.c (init_category_once):
+        * character.c (syms_of_character):
+        * coding.c (syms_of_coding):
+        * xdisp.c (syms_of_xdisp): ...and omit it here.
+
+2013-08-24  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (get_next_display_element): Don't apply to characters
+        from a display vector the logic of setting it->end_of_box_run_p
+        suitable for characters from a buffer.  (Bug#15175)
+
+        * w32.c (fdutimens): Call 'utime', which is implemented on w32.c
+        to handle directories, rather than '_utime' which doesn't.
+        (Bug#15176)
+
+2013-08-24  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (x_wm_set_size_hint): Don't set hints when maximized
+        or fullscreen (Bug#14627).
+
+2013-08-24  Paul Eggert  <eggert@cs.ucla.edu>
+
+        System-dependent integer overflow fixes.
+        * process.c (Fset_process_window_size): Signal an error if
+        the window size is outside the range supported by the lower level.
+        * sysdep.c (set_window_size): Return negative on error,
+        nonnegative on success, rather than -1, 0, 1 on not in system,
+        failure, success.  This is simpler.  Caller changed.
+        (serial_configure): Remove unnecessary initialization of local.
+        (procfs_get_total_memory) [GNU_LINUX]: Don't assume system memory
+        size fits in unsigned long; this isn't true on some 32-bit hosts.
+        Avoid buffer overrun if some future version of /proc/meminfo has a
+        variable name longer than 20 bytes.
+        (system_process_attributes) [__FreeBSD__]:
+        Don't assume hw.availpages fits in 'int'.
+
+2013-08-23  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Don't let very long directory names overrun the stack.
+        Fix some related minor problems involving "//", vfork.
+        * callproc.c (encode_current_directory): New function.
+        (call_process): Don't append "/"; not needed.
+        * fileio.c (file_name_as_directory_slop): New constant.
+        (file_name_as_directory): Allow SRC to be longer than SRCLEN;
+        this can save the caller having to alloca.
+        (Ffile_name_as_directory, Fdirectory_file_name, Fexpand_file_name):
+        Use SAFE_ALLOCA, not alloca.
+        (directory_file_name, Fexpand_file_name): Leave leading "//"
+        alone, since it can be special even on POSIX platforms.
+        * callproc.c (call_process):
+        * process.c (Fformat_network_address):
+        * sysdep.c (sys_subshell):
+        Use encode_current_directory rather than rolling our own.
+        (create_process): No need to encode directory; caller does that now.
+        * process.h (encode_current_directory): New decl.
+        * sysdep.c (sys_subshell): Work even if vfork trashes saved_handlers.
+        Rework to avoid 'goto xyzzy;'.
+
+2013-08-23  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (handle_face_prop): If the default face was remapped use
+        the remapped face for strings from prefix properties.  (Bug#15155)
+
+2013-08-23  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Minor cleanup for redisplay interface and few related functions.
+        * frame.h (enum text_cursor_kinds): Move from here...
+        * dispextern.h (enum text_cursor_kinds): ...to here.
+        (toplevel): Drop unnecessary declarations.
+        (struct redisplay_interface): Use bool and enum text_cursor_kinds
+        in update_window_end_hook and draw_window_cursor functions.
+        (display_and_set_cursor, x_update_cursor): Adjust prototypes.
+        * nsterm.m (ns_update_window_end, ns_draw_window_cursor):
+        * w32term.c (x_update_window_end,w32_draw_window_cursor):
+        * xterm.c (x_update_window_end, x_draw_window_cursor):
+        * xdisp.c (display_and_set_cursor, update_window_cursor)
+        (update_cursor_in_window_tree, x_update_cursor): Use bool and
+        enum text_cursor_kinds where appropriate.
+
+2013-08-23  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Redesign redisplay interface to drop updated_row and updated_area.
+        * dispextern.h (updated_row, updated_area): Remove declaration.
+        (struct redisplay_interface): Pass glyph row and row area parameters
+        to write_glyphs, insert_glyphs and clear_end_of_line functions.
+        (x_write_glyphs, x_insert_glyphs, x_clear_end_of_line):
+        Adjust prototypes.
+        * dispnew.c (updated_row, updated_area): Remove.
+        (redraw_overlapped_rows, update_window_line): Adjust user.
+        (update_marginal_area, update_text_area): Likewise.  Pass updated row
+        as a parameter.  Prefer enum glyph_row_area to int where appropriate.
+        * xdisp.c (x_write_glyphs, x_insert_glyphs, x_clear_end_of_line):
+        Adjust users.
+
+2013-08-22  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * process.c (flush_pending_output): Remove stub.
+        All uses removed.
+
+2013-08-21  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * callproc.c: Fix race that killed background processes (Bug#15144).
+        (call_process): New arg TEMPFILE_INDEX.  Callers changed.
+        Record deleted process-id in critical section, not afterwards.
+        Don't mistakenly kill process created by a call-process invocation
+        that discards output and does not wait.
+
+2013-08-21  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix compilation with GC_MARK_STACK == GC_USE_GCPROS_AS_BEFORE
+        and GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES.
+        * alloc.c (toplevel): Remove unnecessary nested #if...#endif.
+        (mark_maybe_object) [!GC_MARK_STACK]: Define to emacs_abort
+        to shut up compiler in mark_object.
+        (dump_zombies): Convert to global and add EXTERNALLY_VISIBLE.
+
+2013-08-21  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * process.c (allocate_pty) [PTY_OPEN]: Set fd's FD_CLOEXEC flag.
+        We can't portably rely on PTY_OPEN doing that, even if
+        it calls posix_openpt with O_CLOEXEC.
+
+2013-08-20  Kenichi Handa  <handa@gnu.org>
+
+        * character.c (string_char): Improve commentary.
+
+2013-08-20  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * image.c (SIGNATURE_DIGESTSIZE): Remove.
+        (struct animation_cache): Make signature a flexible array member.
+        All uses changed.  This is a tad slower but may insulate us better
+        from future changes to ImageMagick.
+
+2013-08-19  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * image.c: Shrink memory needed for animation cache.
+        (SIGNATURE_DIGESTSIZE): New constant.
+        (struct animation_cache): Make 'signature' a fixed size array of bytes.
+        (imagemagick_create_cache): Copy the signature.  This saves
+        several KB of memory that ImageMagick wastes per signature.
+        Don't bother updating the update_time, as the caller does that now.
+        (imagemagick_prune_animation_cache): Don't destroy the signature, as
+        it's a fixed size struct member now.
+        (imagemagick_get_animation_cache): Always destroy the signature,
+        as it's now imagemagick_create_cache's responsibility to copy it.
+        Avoid duplicate calls to strcmp and to imagemagick_create_cache,
+        and use memcmp rather than strcmp.
+        eassert that ImageMagick returns a signature of the specified length.
+
+2013-08-19  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * image.c (imagemagick_get_animation_cache): Don't segfault on
+        each invocation.
+        (imagemagick_get_animation_cache): Revert to previous definition
+        so that it actually works.  But keep the memory leak fix.
+        (imagemagick_get_animation_cache): Fix memory leak.
+
+2013-08-19  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * image.c: Fix animation cache signature memory leak.
+        Fix some other minor performance problems while we're at it.
+        (imagemagick_create_cache): Clear just the members that
+        need clearing.  Don't set update_time, as caller does that now.
+        (imagemagick_prune_animation_cache, imagemagick_get_animation_cache):
+        Simplify by using pointer-to-pointer instead of a prev pointer.
+        (imagemagick_prune_animation_cache): Use make_emacs_time rather
+        than EMACS_TIME_FROM_DOUBLE, and DestroyString rather than free.
+        (imagemagick_get_animation_cache): Don't xstrdup the image signature;
+        it's already a copy.  Free the signature probe unless it's cached.
+
+        * process.c (handle_child_signal): Fix crash; deleted pid (Bug#15106).
+        This was introduced by my 2013-08-12 fix for Bug#15035.
+
+2013-08-19  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * image.c (imagemagick_create_cache, imagemagick_get_animation_cache)
+        (imagemagick_prune_animation_cache): Now static.
+
+2013-08-18  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * image.c (imagemagick_get_animation_cache): Don't segfault when
+        pruning all entries.
+
+2013-08-18  Ken Brown  <kbrown@cornell.edu>
+
+        * sheap.c (STATIC_HEAP_SIZE): Adjust to current needs; use bigger
+        static heap if ENABLE_CHECKING is defined.
+        (max_bss_sbrk_ptr): New variable.
+        (bss_sbrk): Use it.
+        (report_sheap_usage): Report maximum static heap usage instead of
+        ending static heap usage.
+
+2013-08-17  Eli Zaretskii  <eliz@gnu.org>
+
+        * decompress.c (Fzlib_available_p) [WINDOWSNT]: Update the value
+        of zlib_initialized according to the results of calling
+        init_zlib_functions.
+
+2013-08-16  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * image.c: Implement an ImageMagick per-image cache.
+        (imagemagick_get_animation_cache): Fix a double-free error.
+        (imagemagick_load_image): Remove the ping_wand code, which only
+        apparently saved time on invalid animated images, and slowed down
+        everything else.  Optimise for the common case.
+
+2013-08-16  Xue Fuqiao  <xfq.free@gmail.com>
+
+        * buffer.c (syms_of_buffer) <buffer-undo-list>: Doc fix.
+
+        * editfns.c (insert_before_markers): Mention overlay in the doc string.
+
+        * marker.c (set_marker): Remove documentation of undefined behavior.
+
+2013-08-15  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * image.c (imagemagick_compute_animated_image): Animate correctly
+        when sub-images are smaller than the main image.
+        (imagemagick_compute_animated_image): Setting the iterator row to
+        zero is apparently not allowed.
+        (imagemagick_compute_animated_image): Allow images that say they
+        have sub-images that are bigger than the main image, but just crop
+        them.
+
+2013-08-15  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsmenu.m (menuWillOpen:): Fix preprocessor test (Bug#15001).
+
+2013-08-15  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * image.c (imagemagick_compute_animated_image): Respect the GIF
+        disposal methods.
+
+2013-08-15  Ken Brown  <kbrown@cornell.edu>
+
+        * emacs.c (main): Update comment about G_SLICE_ALWAYS_MALLOC.
+        * gmalloc.c (memalign) [CYGWIN]: Revert last change; it's not
+        needed.
+
+2013-08-15  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor problems found by static checking.
+        * frame.c (delete_frame):
+        * xdisp.c (next_element_from_display_vector):
+        Avoid uninitialized local.
+        * image.c (imagemagick_compute_animated_image): Port to C89.
+        Prefer usual GNU indentation style for loops.
+        Be more careful about bizarrely large sizes, by using ptrdiff_t
+        instead of int.
+
+2013-08-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix infinite frame selection loop (Bug#15025).
+        * frame.c (delete_frame): Prefer fast ad-hoc loop to next_frame.
+
+2013-08-15  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (compute_window_start_on_continuation_line):
+        When WORD_WRAP is in effect, use move_it_to instead of move_it_by_lines
+        to make sure we end up setting the window start at the leftmost
+        visible character of the display line.  This avoids funky
+        horizontal shifting because the window start is not kept on the
+        same position.  (Bug#15090)
+        (next_element_from_display_vector): Support 'box' face attribute
+        in the face definitions of a display vector.  (Bug#15099)
+
+2013-08-15  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * image.c (imagemagick_compute_animated_image): Implement animated
+        images (bug#14700).
+        (imagemagick_compute_animated_image): Fix some compilation
+        warnings.  Implement a very simple cache to make the animation
+        usable at all, but it should be replaced with a per-image cache.
+
+2013-08-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (FOR_EACH_ALIST_VALUE): New macro
+        to do `for' loops over alist values.
+        * buffer.h (FOR_EACH_BUFFER):
+        * process.c (FOR_EACH_PROCESS): Use it.
+        (handle_child_signal, status_notify, Fget_buffer_process)
+        (kill_buffer_processes): Use FOR_EACH_PROCESS.
+
+2013-08-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * term.c (get_named_tty, create_tty_output, tty_free_frame_resources)
+        (tty_free_frame_resources, delete_tty): Prefer eassert to emacs_abort.
+        * image.c (make_image_cache): For struct image_cache, prefer xmalloc
+        to xzalloc and so avoid redundant call to memset.
+        * xterm.c (x_term_init): Avoid unnecessary initializations of dpyinfo
+        members because it is allocated with xzalloc and so already zeroed.
+
+2013-08-14  Ken Brown  <kbrown@cornell.edu>
+
+        * gmalloc.c (memalign) [CYGWIN]: Rename to emacs_memalign
+        (Bug#15094).
+
+2013-08-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Utility function and macro to copy Lisp string to C string.
+        * lisp.h (xlispstrdupa): New macro.
+        (xlispstrdup): New prototype.
+        * alloc.c (xlispstrdup): New function.
+        * callint.c (Fcall_interactively):
+        * fileio.c (Ffile_name_directory, Fexpand_file_name)
+        (Fsubstitute_in_file_name):
+        * frame.c (Fmake_terminal_frame): Use xlispstrdupa.
+        * image.c (x_create_bitmap_from_file):
+        * w32term.c (w32_term_init):
+        * xterm.c (x_term_init): Use xlispstrdup.
+
+2013-08-14  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * image.c (imagemagick_load_image): Make animated pictures work.
+        There's still some problems with background color settings, though
+        (bug#14700).
+
+        * decompress.c (unwind_decompress): Always restore point.
+
+2013-08-14  Xue Fuqiao  <xfq.free@gmail.com>
+
+        * marker.c (set_marker): Reformat documentation.
+
+2013-08-14  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xdisp.c (cursor_type_changed): Now static.
+
+        * image.c (imagemagick_filename_hint): New arg HINT_BUFFER.
+        Use changed.  This avoids the need to call xmalloc and for the
+        caller to call xfree, and avoids memory leaks in some situations.
+
+2013-08-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xdisp.c (adjust_window_ends): Move duplicated code to new function.
+        (try_window, try_window_reusing_current_matrix, try_window_id): Use it.
+        (redisplay_window): If window_end_valid is cleared due to non-zero
+        windows_or_buffers_changed, clear current_matrix_up_to_date_p and
+        so do not call to try_cursor_movement for that window.
+
+2013-08-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.h (struct window): Convert window_end_pos and
+        window_end_vpos from Lisp_Object to ptrdiff_t and int, respectively.
+        (wset_window_end_pos, wset_window_end_vpos): Remove.
+        * dispnew.c (adjust_glyph_matrix):
+        * window.c (Fwindow_end, replace_window, set_window_buffer)
+        (make_window):
+        * xdisp.c (check_window_end, move_it_to, redisplay_internal)
+        (set_vertical_scroll_bar, redisplay_window, try_window)
+        (try_window_reusing_current_matrix, find_first_unchanged_at_end_row)
+        (try_window_id, decode_mode_spec, mouse_face_from_buffer_pos)
+        (note_mouse_highlight): Adjust users.
+        (try_cursor_movement): Likewise.  Convert old precondition to eassert.
+        Add comment.
+
+2013-08-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix --enable-gcc-warnings errors introduced in 2013-08-13 commit.
+        * image.c (imagemagick_filename_hint): Use `const char *' and
+        prefer SSDATA to SDATA to avoid warnings.
+
+2013-08-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Cleanup window fringes, margins and scroll bars adjustments.
+        * window.c (set_window_fringes, set_window_margins)
+        (set_window_scroll_bars, apply_window_adjustment): New functions.
+        (set_window_buffer, Fset_window_margins, Fset_window_fringes)
+        (Fset_window_scroll_bars): Use them.
+
+2013-08-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.h (struct window): Convert scroll_bar_width
+        from Lisp_Object to integer.  Adjust comment.
+        (WINDOW_CONFIG_SCROLL_BAR_WIDTH, WINDOW_CONFIG_SCROLL_BAR_COLS):
+        Adjust users.
+        * window.c (wset_scroll_bar_width): Remove.
+        (make_window): Initialize scroll_bar_width.
+        (Fsplit_window_internal): Use direct assignment.
+        (Fset_window_configuration, save_window_save):
+        Convert Lisp_Object to integer and back where appropriate.
+        (Fset_window_scroll_bars): Adjust user.  Return t if any scroll
+        bar was actually changed, and mention this in docstring.
+
+2013-08-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * decompress.c: Minor simplifications.
+        (Fzlib_decompress_region): Don't bother verifying
+        that avail_out <= UINT_MAX, as that was confusing.
+        Mention the restriction in a comment instead.
+        Prefer 'int' to 'ptrdiff_t' when 'int' is wide enough.
+
+2013-08-13  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsmenu.m (x_activate_menubar): Check for OSX >= 10.5
+        (trackingNotification:): Call ns_check_menu_open only for OSX >= 10.5.
+
+2013-08-13  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * image.c (imagemagick_filename_hint): Check for errors in the
+        alist structure.
+
+2013-08-13  Eli Zaretskii  <eliz@gnu.org>
+
+        * window.c (Fwindow_margins): Return nil when there's no marginal
+        area, as per the documented API.
+
+        * w32term.c (x_scroll_bar_create): Use ALLOCATE_PSEUDOVECTOR, not
+        Fmake_vector, as scroll bar's struct members are not all Lisp
+        objects now.  This avoids crashes in GC.
+
+        * w32term.h (struct scroll_bar): Convert fringe_extended_p to a
+        bool, so its address could be taken.
+
+2013-08-13  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * image.c (imagemagick_filename_hint): New function to possibly
+        apply `image-content-type-suffixes'.
+        (imagemagick_load_image): Use it.
+
+2013-08-13  Eli Zaretskii  <eliz@gnu.org>
+
+        * decompress.c (Fzlib_decompress_region) [WINDOWSNT]: Return Qnil
+        if loading zlib failed.
+
+2013-08-13  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (ns_set_vertical_scroll_bar): Fix breakage intruduced by
+        2013-08-13 checkin below.  Change bool to BOOL, rule is:
+        All Obj-C code uses BOOL, except for interfaces callable from C.
+
+        * nsterm.h: Fix CGFloat for OSX 10.4 (Bug#15086).
+
+2013-08-13  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.h (WINDOW_FRINGE_EXTENDED_P): New macro.
+        * nsterm.m (ns_set_vertical_scroll_bar): Use it.  Use convenient
+        bool instead of BOOL.
+        * w32term.h (struct scroll_bar): Convert fringe_extended_p
+        from Lisp_Object to bitfield.  Adjust comment.
+        * w32term.c (x_scroll_bar_create): Adjust user.
+        Use WINDOW_FRINGE_EXTENDED_P and bool for boolean.
+        * xterm.c (XTset_vertical_scroll_bar): Likewise.
+        Use bool for boolean.
+        * xterm.h (struct scroll_bar): Prefer commonly used `unsigned'
+        to `unsigned int' when defining a bitfield.
+
+2013-08-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * decompress.c (Fzlib_decompress_region): Try to clarify 'avail_out'.
+
+2013-08-13  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.h (struct window): Convert left_margin_cols and
+        right_margin_cols from Lisp_Objects to integers.  Adjust comment.
+        (WINDOW_LEFT_MARGIN_COLS, WINDOW_RIGHT_MARGIN_COLS)
+        (WINDOW_LEFT_MARGIN_WIDTH, WINDOW_RIGHT_MARGIN_WIDTH):
+        Adjust users.
+        * dispnew.c (margin_glyphs_to_reserve): Convert 3rd arg to int.
+        Adjust comment.
+        (showing_window_margins_p, update_window_line, update_frame_1):
+        * fringe.c (draw_fringe_bitmap_1):
+        * xdisp.c (window_box_width): Adjust users.
+        * window.c (wset_left_margin_cols, wset_right_margin_cols): Remove.
+        (adjust_window_margins, set_window_buffer, Fsplit_window_internal):
+        Use direct assignment.
+        (Fset_window_configuration, save_window_save, Fwindow_margins):
+        Convert Lisp_Object to integer and back where appropriate.
+        (Fset_window_margins): Adjust user.  Return t if any margin
+        was actually changed, and mention this in docstring.
+
+2013-08-13  Xue Fuqiao  <xfq.free@gmail.com>
+
+        * syntax.c (forward_word):
+        * cmds.c (forward_char, backward_char): Mention the optional argument.
+
+2013-08-13  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.h (struct window): Convert left_fringe_width
+        and right_fringe_width from Lisp_Objects to integers.
+        Adjust comment.
+        (WINDOW_FRINGE_COLS, WINDOW_LEFT_FRINGE_WIDTH)
+        (WINDOW_RIGHT_FRINGE_WIDTH): Adjust users.
+        * window.c (wset_left_fringe_width, wset_right_fringe_width):
+        Remove.
+        (make_window): Initialize new integer fields to -1.
+        (Fsplit_window_internal): Use direct assignment.
+        (Fset_window_configuration, save_window_save):
+        Convert Lisp_Object to integer and back where appropriate.
+        (Fset_window_fringes): Adjust user.  Return t if any fringe
+        was actually changed, and mention this in docstring.
+
+2013-08-13  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * keyboard.c (Fdiscard_input): Do not increment update_mode_lines.
+        * nsfns.m (x_set_cursor_type):
+        * w32fns.c (x_set_cursor_type):
+        * xfns.m (x_set_cursor_type): Do not set cursor_type_changed here...
+        * xdisp.c (set_frame_cursor_types): ...but in common code.
+
+2013-08-13  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * font.c (clear_font_cache): New function, stripped from...
+        (Fclear_font_cache): ...here, which now uses the function
+        above.  Adjust comment.
+        * font.h (clear_font_cache): Add prototype.
+        * xfaces.c (clear_face_cache): Use clear_font_cache.
+
+2013-08-13  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.c (Fset_window_start): Compare `w', not `window' because
+        `w' might not be equal to `window' after call to decode_live_window.
+
+2013-08-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * process.c (deactivate_process): Reset fds to -1 (Bug#15035).
+        This fixes a problem introduced by the Bug#15035 patch
+        when using GPG.  Reported by Herbert J. Skuhra.
+
+2013-08-12  Eli Zaretskii  <eliz@gnu.org>
+
+        * decompress.c <zlib_initialized> [WINDOWSNT]: New static variable.
+        (Fzlib_decompress_region) [WINDOWSNT]: Call init_zlib_functions if
+        not yet initialized.
+
+2013-08-12  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * decompress.c (Fzlib_decompress_region): Support zlib
+        decompression, too, and rename.
+
+2013-08-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Minor zlib configuration tweaks.
+        * decompress.c (fn_inflateInit2) [!WINDOWSNT]:
+        Don't assume presence of fn_inflateInit2_ zlib internal function.
+
+2013-08-12  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * decompress.c (Fzlib_decompress_gzipped_region): Rename to
+        include the zlib prefix.
+
+2013-08-12  Eli Zaretskii  <eliz@gnu.org>
+
+        * decompress.c [WINDOWSNT]: Include windows.h and w32.h.
+        (DEF_ZLIB_FN, LOAD_ZLIB_FN) [WINDOWSNT]: New macros.  Use them to
+        define static variables that are pointers to zlib functions to be
+        dynamically loaded.
+        (init_zlib_functions) [WINDOWSNT]: New function.
+        (fn_inflateInit2_, fn_inflate, fn_inflateEnd, fn_inflateInit2):
+        New macros.
+        (Fdecompress_gzipped_region, unwind_decompress): Use the fn_*
+        macros instead of invoking the zlib functions directly.
+        (syms_of_decompress): DEFSYM Qzlib_dll.
+        Staticpro Szlib_available_p.
+
+2013-08-12  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Avoid looping over all frame windows to freeze and unfreeze.
+        * window.h (struct window): Drop frozen_window_start_p.
+        (freeze_window_starts): Drop prototype.
+        * frame.h (struct frame): New frozen_window_starts flag.
+        (FRAME_WINDOWS_FROZEN): New macro.
+        * window.c (freeze_window_start, freeze_window_starts):
+        Remove.
+        (select_window, replace_window): Adjust users.
+        * xdisp.c (resize_mini_window): Use FRAME_WINDOWS_FROZEN.
+        (window_frozen_p): New function.
+        (redisplay_window): Use it.
+
+2013-08-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix some fd issues when running subprocesses (Bug#15035).
+        Fix bugs that can leak files or file descriptors on errors.
+        Don't unlink open temp files, as that's hard for users to diagnose
+        when things go awry (e.g., temp disk exhausted).
+        Don't bother to lock temp files.  Check for invalid recursion.
+        * callproc.c (synch_process_fd): Remove.  All uses removed.
+        (synch_process_tempfile): New var or macro.
+        (CALLPROC_STDOUT, CALLPROC_STDERR, CALLPROC_PIPEREAD, CALLPROC_FDS):
+        New constants.
+        (record_kill_process): New arg, the temp name.  All callers changed.
+        (delete_temp_file): Now just a simple wrapper around unlink.
+        (call_process_kill): New arg, the call_process_fd array.
+        Close them all.  Clear synch_process_pid.  Remove the temp file,
+        or arrange for it to be removed.
+        (call_process_cleanup) [MSDOS]: Arg no longer contains file name;
+        that's been moved to synch_process_tempfile.  Caller changed.
+        Do not remove the tempfile; that's now call_process_kill's
+        responsibility.
+        (call_process_cleanup) [!MSDOS]: Do not record unwind-protect for
+        call_process_kill; the caller now does that.
+        (call_process_cleanup): Do not close the process fd; that's now
+        call_process_kill's responsibility.
+        (Fcall_process): Implement via new function call_process, which
+        has most of the old body of Fcall_process, but with a different API.
+        (call_process): New function that does not open or close filefd if
+        it is nonnegative.  Record which fds need to be closed, and let
+        call_process_kill close (and remove the tempfile, on MSDOS) on error.
+        Signal an error if invoked recursively (could be done via a hook).
+        Simplify creation of the tempfile in the MSDOS case.
+        Don't create the output file until after checking for the executable.
+        Report any failure to open /dev/null.
+        Don't open /dev/null for writing twice; once is enough.
+        Don't create pipe if all output is being discarded or sent to file.
+        Don't worry about setting up the coding system or reading from the
+        pipe if all output is being discarded.
+        Hoist fd_error local into top level, to lessen block nesting.
+        Don't record deleted pid here; now done by Fcall_process_region.
+        (Fcall_process) [MSDOS]: Report mktemp failure immediately,
+        and note its success in synch_process_tempfile.
+        Do not leak resources when child_setup fails.
+        (Fcall_process) [!MSDOS && !WINDOWSNT]: Remove duplicate assignment
+        to child_errno.  Remove unnecessary close of fd0; it's close-on-exec.
+        (create_temp_file): Now returns open fd, with an additional
+        Lisp_Object * argument to return the name.  All callers changed.
+        Do not close the file; rewind it instead, and leave it open for
+        the caller.  Do not lock the temp file.  Unwind-protect the file
+        and the file-descriptor.
+        (Fcall_process_region): If the input is /dev/null, unwind-protect it.
+        If an asynchrounous process, record it here, not in call_process.
+        (syms_of_callproc) [MSDOS]: Initialize synch_process_tempfile.
+        * eval.c (set_unwind_protect): New function.
+        * fileio.c (write_region): New function, generalized from the
+        old Fwrite_region.  Do not lock temp files.
+        (Fwrite_region): Use it.
+        * lisp.h (set_unwind_protect, write_region): New decls.
+        * process.c: Include <verify.h>.
+        (make_process): Mark fds as initially closed.
+        (deleted_pid_list): Now a list of pid-filename pairs.
+        All uses changed.
+        (close_process_fd): New function.
+        (SUBPROCESS_STDIN, WRITE_TO_SUBPROCESS, READ_FROM_SUBPROCESS)
+        (SUBPROCESS_STDOUT, READ_FROM_EXEC_MONITOR, EXEC_MONITOR_OUTPUT):
+        New constants.  Verify that their number matches PROCESS_OPEN_FDS.
+        (create_process, create_pty, Fmake_serial_process)
+        (server_accept_connection): Record which fds need to be closed,
+        and let deactivate_process close them.
+        (Fmake_network_process): Do not discard the unwind-protect
+        until it's safe to do so.
+        (deactivate_process): Close the fds opened by create_process etc.
+        (Fprocess_send_eof): Adjust to new way of recording open fds.
+        Report an error if /dev/null can't be opened, instead of aborting.
+        * process.h (PROCESS_OPEN_FDS): New constant.
+        (struct Lisp_Process): New member open_fds.
+        (record_kill_process, record_deleted_pid): Adjust signatures.
+        (record_deleted_pid): Move decl here ...
+        * syswait.h (record_deleted_pid): ... from here.
+
+2013-08-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * decompress.c: Fix bugs with large buffers and weird inputs.
+        Tune a bit.  Reindent as per usual Emacs style.
+        (BUFFER_SIZE): Remove.
+        (Fdecompress_gzipped_region): Do not mishandle input buffers with
+        more than UINT_MAX bytes.  Decompress into the gap instead of into
+        an auto buffer, as this should avoid copying.  Return nil if
+        'inflate' returns Z_NEED_DICT, as we have no dictionary.  Do not
+        set immediate_quit; we shouldn't trust zlib code that much.
+
+2013-08-11  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * decompress.c (Fdecompress_gzipped_region): Respect all zlib
+        errors, and really move the gap to where we want it.
+
+        * lisp.h: Include decompress.c support.
+
+        * emacs.c (main): Include decompress.c support.
+
+        * Makefile.in: Include -lz if present.
+
+2013-08-11  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsmenu.m (ns_update_menubar): Call fillWithWidgetValue:frame:
+        (initWithTitle:): Initialize frame to 0.
+        (fillWithWidgetValue:): Call fillWithWidgetValue:frame.
+        (fillWithWidgetValue:frame:): Rename from
+        fillWithWidgetValue:setDelegate, call initWithTile:frame: if f.
+
+        * nsterm.h (EmacsMenu): fillWithWidgetValue:setDelegate renamed to
+        fillWithWidgetValue:frame:
+
+        * nsfns.m (Fns_convert_utf8_nfd_to_nfc): Allocate and release pool to
+        remove memory leak warnings.
+
+        * nsterm.m (menu_pending_title, ns_get_pending_menu_title): Remove.
+        (ns_check_menu_open): Handle menu == nil.  Remove assignment to
+        menu_pending_title.
+
+        * nsmenu.m (ns_update_menubar): Call fillWithWidgetValue:setDelegate.
+        (x_activate_menubar): Update the whole menu.
+        (trackingNotification:): Call ns_check_menu_open if tracking ends.
+        (menuWillOpen:): Increment trackingMenu.  For OSX <= 10.6, exit if
+        current event is not NSSystemDefined (Bug#15001).
+        Call ns_check_menu_open only if trackingMenu is 2.
+        (menuDidClose:): New method, decrease trackingMenu.
+        (fillWithWidgetValue:setDelegate:): New method.
+        (fillWithWidgetValue:): Call the above.
+
+        * nsterm.h (EmacsMenu): Add fillWithWidgetValue:setDelegate:
+
+2013-08-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Omit some unnecessary casts.
+        Many of these go back to the old pre-C89 days, when they may have
+        been needed, but we've been assuming C89 or later for a while now.
+        * alloc.c (live_string_p, live_cons_p, live_symbol_p)
+        (live_float_p, live_misc_p, live_vector_p):
+        * buffer.c (compare_overlays, cmp_for_strings, mmap_find)
+        (mmap_alloc, alloc_buffer_text, enlarge_buffer_text)
+        (defvar_per_buffer):
+        * callint.c (Fcall_interactively):
+        * doc.c (Fsubstitute_command_keys):
+        * filelock.c (get_boot_time):
+        * frame.c (xrdb_get_resource):
+        * gtkutil.c (hierarchy_ch_cb, qttip_cb, style_changed_cb)
+        (delete_cb, xg_dialog_response_cb, xg_maybe_add_timer)
+        (xg_get_file_name_from_selector, menuitem_destroy_callback)
+        (menuitem_highlight_callback, menu_destroy_callback)
+        (xg_update_menu_item, xg_modify_menubar_widgets, menubar_map_cb)
+        (xg_tool_bar_callback, xg_get_tool_bar_widgets)
+        (xg_tool_bar_detach_callback, xg_tool_bar_attach_callback)
+        (xg_tool_bar_help_callback, tb_size_cb):
+        * image.c (xpm_alloc_color, png_read_from_memory)
+        (png_read_from_file, png_load_body, our_memory_skip_input_data)
+        (jpeg_memory_src, jpeg_file_src, imagemagick_load_image)
+        (syms_of_image):
+        * keymap.c (describe_map):
+        * nsfns.m (Fns_display_monitor_attributes_list):
+        * nsmenu.m (process_dialog:):
+        * nsterm.m (hold_event):
+        * process.c (wait_reading_process_output):
+        * regex.c (REGEX_REALLOCATE, re_set_registers, re_exec, regexec):
+        * scroll.c (do_direct_scrolling, scrolling_1):
+        * termcap.c (tgetent):
+        * window.c (check_window_containing, add_window_to_list)
+        (freeze_window_starts):
+        * xdisp.c (compare_overlay_entries, vmessage):
+        * xfns.c (x_window, x_get_monitor_attributes_xinerama)
+        (x_get_monitor_attributes_xrandr)
+        (Fx_display_monitor_attributes_list, x_display_info_for_name)
+        (Fx_open_connection, file_dialog_cb, file_dialog_unmap_cb):
+        * xfont.c (xfont_match, xfont_open):
+        * xmenu.c (x_menu_wait_for_event, menu_highlight_callback)
+        (menubar_selection_callback, menu_position_func)
+        (popup_selection_callback, create_and_show_popup_menu)
+        (dialog_selection_callback, create_and_show_dialog):
+        * xrdb.c (x_get_string_resource):
+        (main) [TESTRM]:
+        * xsmfns.c (x_session_check_input):
+        * xterm.c (x_draw_glyphless_glyph_string_foreground)
+        (xm_scroll_callback, xg_scroll_callback, xg_end_scroll_callback)
+        (xaw_jump_callback, xaw_scroll_callback):
+        Omit unnecessary casts.
+
+2013-08-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Minor string-length refactoring.
+        * alloc.c (xstrdup): Use memcpy, not strcpy, since the length's known.
+        * frame.c (make_monitor_attribute_list):
+        Prefer build_string to strlen + make_string.
+
+2013-08-10  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xterm.c (x_error_handler): Also ignore BadWindow for X_SetInputFocus,
+        don't check minor_code (Bug#14417).
+
+2013-08-09  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (draw_glyphs): Don't compare row pointers, compare row
+        vertical positions instead.  This avoids calling MATRIX_ROW with
+        row numbers that are possibly beyond valid limits.  (Bug#15064)
+
+2013-08-09  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Use xstrdup and build_unibyte_string where applicable.
+        * alloc.c (xstrdup): Tiny cleanup.  Add eassert.
+        * xfns.c (x_window):
+        * xrdb.c (x_get_customization_string):
+        * xterm.c (xim_initialize):
+        * w32fns.c (w32_window): Use xstrdup.
+        (w32_display_monitor_attributes_list):
+        * emacs.c (init_cmdargs):
+        * keyboard.c (PUSH_C_STR):
+        * nsfont.m (nsfont_open):
+        * sysdep.c (system_process_attributes):
+        * w32.c (system_process_attributes):
+        * xdisp.c (message1, message1_nolog): Use build_unibyte_string.
+
+2013-08-09  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (PEXCEPTION_POINTERS, PEXCEPTION_RECORD, PCONTEXT): Define
+        variables of these types so that GDB would know about them, as aid
+        for debugging fatal exceptions.  (Bug#15024)  See also
+        http://sourceware.org/ml/gdb/2013-08/msg00010.html for related
+        discussions.
+
+2013-08-08  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (ns_update_begin): Don't change clip path if it would be
+        larger than the NSWindow (Bug#14934).
+
+2013-08-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Redesign redisplay interface to drop global variable updated_window.
+        Always pass currently updated window as a parameter to update routines.
+        * dispextern.h (updated_window): Remove declaration.
+        (struct redisplay_interface): Pass window parameter to
+        write_glyphs, insert_glyphs, clear_end_of_line, cursor_to
+        and after_update_window_hook.
+        (x_write_glyphs, x_insert_glyphs, x_clear_end_of_line, x_cursor_to):
+        Adjust prototypes.
+        * dispnew.c (updated_window): Remove.
+        (redraw_overlapped_rows, update_marginal_area, update_text_area)
+        (update_window_line): Adjust to match redisplay interface changes.
+        * nsterm.m (ns_update_window_begin, ns_update_window_end)
+        (ns_scroll_run, ns_after_update_window_line):
+        * w32term.c (x_update_window_begin, x_update_window_end)
+        (x_after_update_window_line, x_scroll_run):
+        * xterm.c (x_update_window_begin, x_update_window_end)
+        (x_after_update_window_line, x_scroll_run):
+        * xdisp.c (x_write_glyphs, x_insert_glyphs, x_clear_end_of_line):
+        Likewise.  Adjust comments where appropriate.
+        (x_cursor_to): Simplify because this is always called during window
+        update (but install debugging check anyway).
+        (expose_window): Check must_be_updated_p flag to see whether this
+        function is called during window update.
+
+2013-08-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Do not reset window modification event counters excessively.
+        These leftovers and poor man's tricky methods to catch extra
+        redisplay's attention are no longer needed.
+        * frame.c (set_menu_bar_lines_1):
+        * minibuf.c (read_minibuf_unwind):
+        * window.c (Fset_window_start, set_window_buffer, window_resize_apply)
+        (grow_mini_window, shrink_mini_window, window_scroll_pixel_based)
+        (window_scroll_line_based, Fset_window_configuration):
+        * xdisp.c (redisplay_window): Do not reset last_modified and
+        last_overlay_modified counters.
+
+2013-08-07  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xselect.c (x_send_client_event): Set send_event and serial, memset
+        data.l as it might be bigger than data.b.   Use 24 bit mask to
+        XSendEvent (Bug#15034).
+
+2013-08-07  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (prepare_menu_bars): Don't call x_consider_frame_title
+        for TTY frames that are not the top frame on their console.
+        (Bug#14616)
+
+2013-08-07  Martin Rudalics  <rudalics@gmx.at>
+
+        * w32term.c (w32fullscreen_hook): Really maximize frame when
+        asked for (Bug#14841).
+
+2013-08-07  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Prefer selected_window to Fselected_window, likewise for frames.
+        * buffer.c (Fbuffer_swap_text):
+        * data.c (Fvariable_binding_locus):
+        * window.c (run_window_configuration_change_hook): Adjust users.
+        * w16select.c (Fw16_set_clipboard_data, Fw16_get_clipboard_data):
+        Use decode_live_frame.
+
+2013-08-07  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Be more careful if selected window shows the buffer other than current,
+        use window_outdated only if this is not so.  This change should also
+        address some weird issues discussed in Bug#13012.
+        * window.h (window_outdated): New prototype.
+        * window.c (window_outdated): Now here.  Convert from static and
+        always assume window's buffer.
+        (Fwindow_end, Fwindow_line_height): Use it.
+        * xdisp.c (reconsider_clip_changes): Remove prototype, drop 2nd arg
+        and always assume window's buffer.
+        (redisplay_window): Adjust user.
+        (redisplay_internal): Call to reconsider_clip_changes once and
+        check whether mode line should be updated only if selected window
+        shows current buffer.
+        (run_window_scroll_functions): Use eassert for debugging check.
+        (Fmove_point_visually, note_mouse_highlight): Use window_outdated.
+
+2013-08-06  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.c (window_scroll, window_scroll_pixel_based)
+        (window_scroll_line_based): Use bool for booleans.
+
+2013-08-06  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * process.c: Fix minor off-by-one issues in descriptor counts.
+        This shouldn't fix any real bugs, but it cleans up the code a bit.
+        (max_process_desc, max_input_desc): -1, not 0, means none.
+        All uses changed.
+        (delete_input_desc): New function.
+        (delete_write_fd, delete_keyboard_wait_descriptor): Use it.
+        (deactivate_process): Scan backwards when recomuting max_process_desc;
+        that should be faster.
+        (init_process_emacs): Initialize max_input_desc.
+
+2013-08-06  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Use region cache to speedup bidi_find_paragraph_start.
+        * buffer.h (struct buffer): New member bidi_paragraph_cache.
+        Rename cache_long_line_scans to cache_long_scans.
+        * buffer.c (bset_cache_long_line_scans): Rename to
+        bset_cache_long_scans.
+        (Fget_buffer_create, Fmake_indirect_buffer, Fkill_buffer)
+        (Fbuffer_swap_text, init_buffer_once): Take bidi_paragraph_cache
+        into account.
+        (syms_of_buffer): Rename cache-long-line-scans to
+        cache-long-scans.  Adjust docstring.
+        * search.c (newline_cache_on_off):
+        * indent.c (width_run_cache_on_off): Adjust users.
+        * bidi.c (bidi_paragraph_cache_on_off): New function.
+        (bidi_find_paragraph_start): Use bidi_paragraph_cache if needed.
+        * insdel.c (prepare_to_modify_buffer):
+        Invalidate bidi_paragraph_cache if enabled.
+
+2013-08-06  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Invalidate region caches only if buffer text is going to be changed.
+        * lisp.h (modify_region_1): Remove 3rd arg and rename to...
+        (modify_text): ...new prototype.
+        (prepare_to_modify_buffer_1): New prototype.
+        * textprop.c (modify_region): Rename to...
+        (modify_text_properties): ...new function.
+        (add_text_properties_1, set_text_properties, Fremove_text_properties)
+        (Fremove_list_of_text_properties): Adjust users.
+        * insdel.c (modify_region_1): Remove 3rd arg and reimplement as...
+        (modify_text): ...new function.
+        (prepare_to_modify_buffer): Reimplement mostly as a wrapper for...
+        (prepare_to_modify_buffer_1): ...new function.
+        * casefiddle.c (casify_region):
+        * editfns.c (Fsubst_char_in_region, Ftranslate_region_internal)
+        (Ftranspose_regions): Use modify_text.
+
+2013-08-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lisp.mk (lisp): Add nadvice.elc.
+
+2013-08-05  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        New macro to iterate over live buffers similar to frames.
+        * buffer.h (FOR_EACH_LIVE_BUFFER): New macro.
+        (Vbuffer_alist, Qpriority, Qbefore_string, Qafter_string):
+        Declare buffer-related variables here to offload lisp.h.
+        * buffer.c (Vbuffer_alist): Adjust comment.
+        (Fget_file_buffer, get_truename_buffer, Fother_buffer)
+        (other_buffer_safely):
+        * data.c (store_symval_forwarding):
+        * dispnew.c (Fframe_or_buffer_changed_p):
+        * fileio.c (Fdo_auto_save):
+        * filelock.c (unlock_all_files):
+        * minibuf.c (read_minibuf): Use FOR_EACH_LIVE_BUFFER.
+
+2013-08-04  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix some minor races in hosts lacking mkostemp (Bug#15015).
+        * callproc.c (create_temp_file):
+        * filelock.c (create_lock_file):
+        Assume mkostemp, since it's now provided by Gnulib.
+
+2013-08-04  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (mkostemp): New function.
+        (mktemp): Remove, no longer used.  Most of the code reused in
+        mkostemp.  (Bug#15015)
+        (mktemp): Don't undef.
+
+2013-08-04  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * dispnew.c (glyph_matrix_count, glyph_pool_count):
+        Move under GLYPH_DEBUG and ENABLE_CHECKING.
+        (new_glyph_matrix, free_glyph_matrix, new_glyph_pool)
+        (free_glyph_pool, check_glyph_memory): Likewise for
+        all users.  Adjust comments where appropriate.
+
 2013-08-03  Paul Eggert  <eggert@cs.ucla.edu>
 
         * composite.h: Minor fixups.
@@ -108,8 +1493,8 @@
         Avoid redundant Lisp_Object <-> struct frame conversions in font API.
         * font.h (struct font_driver): Change list, match, and list_family
         functions to accept struct frame * as first arg.
-        * font.c (font_score, font_compare, font_sort_entities): Remove
-        prototypes.
+        * font.c (font_score, font_compare, font_sort_entities):
+        Remove prototypes.
         (font_sort_entities, font_list_entities, font_select_entity):
         (font_find_for_lface, Flist_fonts, Ffont_family_list): Adjust to
         match font API change.
@@ -416,9 +1801,9 @@
         or fscanf fails.
         (system_process_attributes): Prefer plain char to unsigned char
         when either will do.  Clean up properly if interrupted or if
-        memory allocations fail.  Don't assume sscanf succeeds.  Remove
-        no-longer-needed workaround to stop GCC from whining.  Read
-        command-line once, instead of multiple times.  Check read status a
+        memory allocations fail.  Don't assume sscanf succeeds.
+        Remove no-longer-needed workaround to stop GCC from whining.
+        Read command-line once, instead of multiple times.  Check read status a
         bit more carefully.
 
         Fix obscure porting bug with varargs functions.
@@ -772,8 +2157,8 @@
         of the old Fcall_process_region.  Use Fcopy_sequence to create the
         temp file name, rather than alloca + build_string, for simplicity.
         Don't bother to block input around the temp file creation;
-        shouldn't be needed.  Simplify use of mktemp.  Use
-        record_unwind_protect immediately after creating the temp file;
+        shouldn't be needed.  Simplify use of mktemp.
+        Use record_unwind_protect immediately after creating the temp file;
         this closes an unlikely race where the temp file was not removed.
         Use memcpy rather than an open-coded loop.
         (Fcall_process_region): Use the new function.  If the input is
@@ -1132,8 +2517,8 @@
         (try_cursor_movement, redisplay_window, try_window)
         (try_window_id): Use it instead of FRAME_LINE_HEIGHT.  (Bug#14771)
 
-        * window.c (window_scroll_pixel_based): use
-        default_line_pixel_height.
+        * window.c (window_scroll_pixel_based):
+        use default_line_pixel_height.
 
         * dispextern.h (default_line_pixel_height): Add prototype.
 
diff --git a/src/Makefile.in b/src/Makefile.in
index 65927ba236c..0e7ff9cbd33 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -23,7 +23,7 @@
 # script may need modifying in sync with changes made here.  Try to
 # avoid shell-ism because the DOS build has to use the DOS shell.
 
-SHELL = /bin/sh
+SHELL = @SHELL@
 
 # Here are the things that we expect ../configure to edit.
 # We use $(srcdir) explicitly in dependencies so as not to depend on VPATH.
@@ -243,6 +243,8 @@ IMAGEMAGICK_CFLAGS= @IMAGEMAGICK_CFLAGS@
 LIBXML2_LIBS = @LIBXML2_LIBS@
 LIBXML2_CFLAGS = @LIBXML2_CFLAGS@
 
+LIBZ = @LIBZ@
+
 XRANDR_LIBS = @XRANDR_LIBS@
 XRANDR_CFLAGS = @XRANDR_CFLAGS@
 
@@ -374,7 +376,7 @@ base_obj = dispnew.o frame.o scroll.o xdisp.o menu.o $(XMENU_OBJ) window.o \
         process.o gnutls.o callproc.o \
         region-cache.o sound.o atimer.o \
         doprnt.o intervals.o textprop.o composite.o xml.o $(NOTIFY_OBJ) \
-        profiler.o \
+        profiler.o decompress.o \
         $(MSDOS_OBJ) $(MSDOS_X_OBJ) $(NS_OBJ) $(CYGWIN_OBJ) $(FONT_OBJ) \
         $(W32_OBJ) $(WINDOW_SYSTEM_OBJ) $(XGSELOBJ)
 obj = $(base_obj) $(NS_OBJC_OBJ)
@@ -429,7 +431,7 @@ LIBES = $(LIBS) $(W32_LIBS) $(LIBS_GNUSTEP) $(LIBX_BASE) $(LIBIMAGE) \
    $(LIBS_TERMCAP) $(GETLOADAVG_LIBS) $(SETTINGS_LIBS) $(LIBSELINUX_LIBS) \
    $(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \
    $(LIBGNUTLS_LIBS) $(LIB_PTHREAD) $(LIB_PTHREAD_SIGMASK) \
-   $(GFILENOTIFY_LIBS) $(LIB_MATH)
+   $(GFILENOTIFY_LIBS) $(LIB_MATH) $(LIBZ)
 
 all: emacs$(EXEEXT) $(OTHER_FILES)
 .PHONY: all
diff --git a/src/alloc.c b/src/alloc.c
index c8141d22f95..8417ef4982b 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -318,7 +318,6 @@ static void *min_heap_address, *max_heap_address;
 static struct mem_node mem_z;
 #define MEM_NIL &mem_z
 
-#if GC_MARK_STACK || defined GC_MALLOC_CHECK
 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 *);
@@ -326,7 +325,6 @@ static void mem_rotate_right (struct mem_node *);
 static void mem_delete (struct mem_node *);
 static void mem_delete_fixup (struct mem_node *);
 static struct mem_node *mem_find (void *);
-#endif
 
 #endif /* GC_MARK_STACK || GC_MALLOC_CHECK */
 
@@ -796,10 +794,19 @@ xpalloc (void *pa, ptrdiff_t *nitems, ptrdiff_t nitems_incr_min,
 char *
 xstrdup (const char *s)
 {
-  size_t len = strlen (s) + 1;
-  char *p = xmalloc (len);
-  memcpy (p, s, len);
-  return p;
+  ptrdiff_t size;
+  eassert (s);
+  size = strlen (s) + 1;
+  return memcpy (xmalloc (size), s, size);
+}
+
+/* Like above, but duplicates Lisp string to C string.  */
+
+char *
+xlispstrdup (Lisp_Object string)
+{
+  ptrdiff_t size = SBYTES (string) + 1;
+  return memcpy (xmalloc (size), SSDATA (string), size);
 }
 
 /* Like putenv, but (1) use the equivalent of xmalloc and (2) the
@@ -2798,7 +2805,7 @@ vector_nbytes (struct Lisp_Vector *v)
 static void
 sweep_vectors (void)
 {
-  struct vector_block *block = vector_blocks, **bprev = &vector_blocks;
+  struct vector_block *block, **bprev = &vector_blocks;
   struct large_vector *lv, **lvprev = &large_vectors;
   struct Lisp_Vector *vector, *next;
 
@@ -3472,6 +3479,7 @@ DEFUN ("make-marker", Fmake_marker, Smake_marker, 0, 0, 0,
   p->charpos = 0;
   p->next = NULL;
   p->insertion_type = 0;
+  p->need_adjustment = 0;
   return val;
 }
 
@@ -3496,6 +3504,7 @@ build_marker (struct buffer *buf, ptrdiff_t charpos, ptrdiff_t bytepos)
   m->charpos = charpos;
   m->bytepos = bytepos;
   m->insertion_type = 0;
+  m->need_adjustment = 0;
   m->next = BUF_MARKERS (buf);
   BUF_MARKERS (buf) = m;
   return obj;
@@ -4058,7 +4067,7 @@ live_string_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_STRING)
     {
-      struct string_block *b = (struct string_block *) m->start;
+      struct string_block *b = m->start;
       ptrdiff_t offset = (char *) p - (char *) &b->strings[0];
 
       /* P must point to the start of a Lisp_String structure, and it
@@ -4081,7 +4090,7 @@ live_cons_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_CONS)
     {
-      struct cons_block *b = (struct cons_block *) m->start;
+      struct cons_block *b = m->start;
       ptrdiff_t offset = (char *) p - (char *) &b->conses[0];
 
       /* P must point to the start of a Lisp_Cons, not be
@@ -4107,7 +4116,7 @@ live_symbol_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_SYMBOL)
     {
-      struct symbol_block *b = (struct symbol_block *) m->start;
+      struct symbol_block *b = m->start;
       ptrdiff_t offset = (char *) p - (char *) &b->symbols[0];
 
       /* P must point to the start of a Lisp_Symbol, not be
@@ -4133,7 +4142,7 @@ live_float_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_FLOAT)
     {
-      struct float_block *b = (struct float_block *) m->start;
+      struct float_block *b = m->start;
       ptrdiff_t offset = (char *) p - (char *) &b->floats[0];
 
       /* P must point to the start of a Lisp_Float and not be
@@ -4157,7 +4166,7 @@ live_misc_p (struct mem_node *m, void *p)
 {
   if (m->type == MEM_TYPE_MISC)
     {
-      struct marker_block *b = (struct marker_block *) m->start;
+      struct marker_block *b = m->start;
       ptrdiff_t offset = (char *) p - (char *) &b->markers[0];
 
       /* P must point to the start of a Lisp_Misc, not be
@@ -4184,7 +4193,7 @@ live_vector_p (struct mem_node *m, void *p)
   if (m->type == MEM_TYPE_VECTOR_BLOCK)
     {
       /* This memory node corresponds to a vector block.  */
-      struct vector_block *block = (struct vector_block *) m->start;
+      struct vector_block *block = m->start;
       struct Lisp_Vector *vector = (struct Lisp_Vector *) block->data;
 
       /* P is in the block's allocation range.  Scan the block
@@ -4229,6 +4238,10 @@ live_buffer_p (struct mem_node *m, void *p)
 
 #if GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES
 
+/* Currently not used, but may be called from gdb.  */
+
+void dump_zombies (void) EXTERNALLY_VISIBLE;
+
 /* Array of objects that are kept alive because the C stack contains
    a pattern that looks like a reference to them .  */
 
@@ -4611,7 +4624,7 @@ check_gcpros (void)
 
 #elif GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES
 
-static void
+void
 dump_zombies (void)
 {
   int i;
@@ -4748,6 +4761,10 @@ mark_stack (void)
 #endif
 }
 
+#else /* GC_MARK_STACK == 0 */
+
+#define mark_maybe_object(obj) emacs_abort ()
+
 #endif /* GC_MARK_STACK != 0 */
 
 
@@ -5218,7 +5235,7 @@ See Info node `(elisp)Garbage Collection'.  */)
   ptrdiff_t i;
   bool message_p;
   ptrdiff_t count = SPECPDL_INDEX ();
-  EMACS_TIME start;
+  struct timespec start;
   Lisp_Object retval = Qnil;
   size_t tot_before = 0;
 
@@ -5243,7 +5260,7 @@ See Info node `(elisp)Garbage Collection'.  */)
   if (profiler_memory_running)
     tot_before = total_bytes_of_live_objects ();
 
-  start = current_emacs_time ();
+  start = current_timespec ();
 
   /* In case user calls debug_print during GC,
      don't let that cause a recursive GC.  */
@@ -5506,9 +5523,9 @@ See Info node `(elisp)Garbage Collection'.  */)
   /* Accumulate statistics.  */
   if (FLOATP (Vgc_elapsed))
     {
-      EMACS_TIME since_start = sub_emacs_time (current_emacs_time (), start);
+      struct timespec since_start = timespec_sub (current_timespec (), start);
       Vgc_elapsed = make_float (XFLOAT_DATA (Vgc_elapsed)
-                                + EMACS_TIME_TO_DOUBLE (since_start));
+                                + timespectod (since_start));
     }
 
   gcs_done++;
diff --git a/src/atimer.c b/src/atimer.c
index 219b3502acc..6aef71db873 100644
--- a/src/atimer.c
+++ b/src/atimer.c
@@ -94,17 +94,16 @@ static struct atimer *append_atimer_lists (struct atimer *,
    to cancel_atimer; don't free it yourself.  */
 
 struct atimer *
-start_atimer (enum atimer_type type, EMACS_TIME timestamp, atimer_callback fn,
-              void *client_data)
+start_atimer (enum atimer_type type, struct timespec timestamp,
+              atimer_callback fn, void *client_data)
 {
   struct atimer *t;
 
   /* Round TIME up to the next full second if we don't have
      itimers.  */
 #ifndef HAVE_SETITIMER
-  if (EMACS_NSECS (timestamp) != 0
-      && EMACS_SECS (timestamp) < TYPE_MAXIMUM (time_t))
-    timestamp = make_emacs_time (EMACS_SECS (timestamp) + 1, 0);
+  if (timestamp.tv_nsec != 0 && timestamp.tv_sec < TYPE_MAXIMUM (time_t))
+    timestamp = make_timespec (timestamp.tv_sec + 1, 0);
 #endif /* not HAVE_SETITIMER */
 
   /* Get an atimer structure from the free-list, or allocate
@@ -133,11 +132,11 @@ start_atimer (enum atimer_type type, EMACS_TIME timestamp, atimer_callback fn,
       break;
 
     case ATIMER_RELATIVE:
-      t->expiration = add_emacs_time (current_emacs_time (), timestamp);
+      t->expiration = timespec_add (current_timespec (), timestamp);
       break;
 
     case ATIMER_CONTINUOUS:
-      t->expiration = add_emacs_time (current_emacs_time (), timestamp);
+      t->expiration = timespec_add (current_timespec (), timestamp);
       t->interval = timestamp;
       break;
     }
@@ -284,7 +283,7 @@ set_alarm (void)
 #ifdef HAVE_SETITIMER
       struct itimerval it;
 #endif
-      EMACS_TIME now, interval;
+      struct timespec now, interval;
 
 #ifdef HAVE_ITIMERSPEC
       if (alarm_timer_ok)
@@ -299,10 +298,10 @@ set_alarm (void)
 
       /* Determine interval till the next timer is ripe.
          Don't set the interval to 0; this disables the timer.  */
-      now = current_emacs_time ();
-      interval = (EMACS_TIME_LE (atimers->expiration, now)
-                  ? make_emacs_time (0, 1000 * 1000)
-                  : sub_emacs_time (atimers->expiration, now));
+      now = current_timespec ();
+      interval = (timespec_cmp (atimers->expiration, now) <= 0
+                  ? make_timespec (0, 1000 * 1000)
+                  : timespec_sub (atimers->expiration, now));
 
 #ifdef HAVE_SETITIMER
 
@@ -310,7 +309,7 @@ set_alarm (void)
       it.it_value = make_timeval (interval);
       setitimer (ITIMER_REAL, &it, 0);
 #else /* not HAVE_SETITIMER */
-      alarm (max (EMACS_SECS (interval), 1));
+      alarm (max (interval.tv_sec, 1));
 #endif /* not HAVE_SETITIMER */
     }
 }
@@ -326,7 +325,7 @@ schedule_atimer (struct atimer *t)
   struct atimer *a = atimers, *prev = NULL;
 
   /* Look for the first atimer that is ripe after T.  */
-  while (a && EMACS_TIME_LT (a->expiration, t->expiration))
+  while (a && timespec_cmp (a->expiration, t->expiration) < 0)
     prev = a, a = a->next;
 
   /* Insert T in front of the atimer found, if any.  */
@@ -341,9 +340,9 @@ schedule_atimer (struct atimer *t)
 static void
 run_timers (void)
 {
-  EMACS_TIME now = current_emacs_time ();
+  struct timespec now = current_timespec ();
 
-  while (atimers && EMACS_TIME_LE (atimers->expiration, now))
+  while (atimers && timespec_cmp (atimers->expiration, now) <= 0)
     {
       struct atimer *t = atimers;
       atimers = atimers->next;
@@ -351,7 +350,7 @@ run_timers (void)
 
       if (t->type == ATIMER_CONTINUOUS)
         {
-          t->expiration = add_emacs_time (now, t->interval);
+          t->expiration = timespec_add (now, t->interval);
           schedule_atimer (t);
         }
       else
diff --git a/src/atimer.h b/src/atimer.h
index a1825fc0933..8c4d732aa4e 100644
--- a/src/atimer.h
+++ b/src/atimer.h
@@ -19,8 +19,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifndef EMACS_ATIMER_H
 #define EMACS_ATIMER_H
 
-#include "systime.h"            /* for EMACS_TIME */
 #include <stdbool.h>
+#include <time.h>
 
 /* Forward declaration.  */
 
@@ -52,10 +52,10 @@ struct atimer
   enum atimer_type type;
 
   /* Time when this timer is ripe.  */
-  EMACS_TIME expiration;
+  struct timespec expiration;
 
   /* Interval of this timer.  */
-  EMACS_TIME interval;
+  struct timespec interval;
 
   /* Function to call when timer is ripe.  Interrupt input is
      guaranteed to not be blocked when this function is called.  */
@@ -70,7 +70,7 @@ struct atimer
 
 /* Function prototypes.  */
 
-struct atimer *start_atimer (enum atimer_type, EMACS_TIME,
+struct atimer *start_atimer (enum atimer_type, struct timespec,
                              atimer_callback, void *);
 void cancel_atimer (struct atimer *);
 void do_pending_atimers (void);
diff --git a/src/bidi.c b/src/bidi.c
index c31d208ecbc..7d082a94997 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -61,6 +61,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "character.h"
 #include "buffer.h"
 #include "dispextern.h"
+#include "region-cache.h"
 
 static bool bidi_initialized = 0;
 
@@ -1085,6 +1086,29 @@ bidi_at_paragraph_end (ptrdiff_t charpos, ptrdiff_t bytepos)
   return val;
 }
 
+/* If the user has requested the long scans caching, make sure that
+   BIDI cache is enabled.  Otherwise, make sure it's disabled.  */
+
+static struct region_cache *
+bidi_paragraph_cache_on_off (void)
+{
+  if (NILP (BVAR (current_buffer, cache_long_scans)))
+    {
+      if (current_buffer->bidi_paragraph_cache)
+        {
+          free_region_cache (current_buffer->bidi_paragraph_cache);
+          current_buffer->bidi_paragraph_cache = 0;
+        }
+      return NULL;
+    }
+  else
+    {
+      if (!current_buffer->bidi_paragraph_cache)
+        current_buffer->bidi_paragraph_cache = new_region_cache ();
+      return current_buffer->bidi_paragraph_cache;
+    }
+}
+
 /* On my 2005-vintage machine, searching back for paragraph start
    takes ~1 ms per line.  And bidi_paragraph_init is called 4 times
    when user types C-p.  The number below limits each call to
@@ -1100,7 +1124,8 @@ bidi_find_paragraph_start (ptrdiff_t pos, ptrdiff_t pos_byte)
 {
   Lisp_Object re = paragraph_start_re;
   ptrdiff_t limit = ZV, limit_byte = ZV_BYTE;
-  ptrdiff_t n = 0;
+  struct region_cache *bpc = bidi_paragraph_cache_on_off ();
+  ptrdiff_t n = 0, oldpos = pos, next;
 
   while (pos_byte > BEGV_BYTE
          && n++ < MAX_PARAGRAPH_SEARCH
@@ -1111,10 +1136,18 @@ bidi_find_paragraph_start (ptrdiff_t pos, ptrdiff_t pos_byte)
          of the text over which we scan back includes
          paragraph_start_re?  */
       DEC_BOTH (pos, pos_byte);
-      pos = find_newline_no_quit (pos, pos_byte, -1, &pos_byte);
+      if (bpc && region_cache_backward (current_buffer, bpc, pos, &next))
+        {
+          pos = next, pos_byte = CHAR_TO_BYTE (pos);
+          break;
+        }
+      else
+        pos = find_newline_no_quit (pos, pos_byte, -1, &pos_byte);
     }
   if (n >= MAX_PARAGRAPH_SEARCH)
-    pos_byte = BEGV_BYTE;
+    pos = BEGV, pos_byte = BEGV_BYTE;
+  if (bpc)
+    know_region_cache (current_buffer, bpc, pos, oldpos);
   return pos_byte;
 }
 
diff --git a/src/buffer.c b/src/buffer.c
index dfc6b8bcc02..0bcb608dbd3 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -108,9 +108,9 @@ static void call_overlay_mod_hooks (Lisp_Object list, Lisp_Object overlay,
 static void swap_out_buffer_local_variables (struct buffer *b);
 static void reset_buffer_local_variables (struct buffer *, bool);
 
-/* Alist of all buffer names vs the buffers.  */
-/* This used to be a variable, but is no longer,
- to prevent lossage due to user rplac'ing this alist or its elements.  */
+/* Alist of all buffer names vs the buffers.  This used to be
+   a Lisp-visible variable, but is no longer, to prevent lossage
+   due to user rplac'ing this alist or its elements.  */
 Lisp_Object Vbuffer_alist;
 
 static Lisp_Object Qkill_buffer_query_functions;
@@ -203,9 +203,9 @@ bset_buffer_file_coding_system (struct buffer *b, Lisp_Object val)
   b->INTERNAL_FIELD (buffer_file_coding_system) = val;
 }
 static void
-bset_cache_long_line_scans (struct buffer *b, Lisp_Object val)
+bset_cache_long_scans (struct buffer *b, Lisp_Object val)
 {
-  b->INTERNAL_FIELD (cache_long_line_scans) = val;
+  b->INTERNAL_FIELD (cache_long_scans) = val;
 }
 static void
 bset_case_fold_search (struct buffer *b, Lisp_Object val)
@@ -478,8 +478,7 @@ If there is no such live buffer, return nil.
 See also `find-buffer-visiting'.  */)
   (register Lisp_Object filename)
 {
-  register Lisp_Object tail, buf, tem;
-  Lisp_Object handler;
+  register Lisp_Object tail, buf, handler;
 
   CHECK_STRING (filename);
   filename = Fexpand_file_name (filename, Qnil);
@@ -494,13 +493,10 @@ See also `find-buffer-visiting'.  */)
       return BUFFERP (handled_buf) ? handled_buf : Qnil;
     }
 
-  for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_LIVE_BUFFER (tail, buf)
     {
-      buf = Fcdr (XCAR (tail));
-      if (!BUFFERP (buf)) continue;
       if (!STRINGP (BVAR (XBUFFER (buf), filename))) continue;
-      tem = Fstring_equal (BVAR (XBUFFER (buf), filename), filename);
-      if (!NILP (tem))
+      if (!NILP (Fstring_equal (BVAR (XBUFFER (buf), filename), filename)))
         return buf;
     }
   return Qnil;
@@ -509,15 +505,12 @@ See also `find-buffer-visiting'.  */)
 Lisp_Object
 get_truename_buffer (register Lisp_Object filename)
 {
-  register Lisp_Object tail, buf, tem;
+  register Lisp_Object tail, buf;
 
-  for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_LIVE_BUFFER (tail, buf)
     {
-      buf = Fcdr (XCAR (tail));
-      if (!BUFFERP (buf)) continue;
       if (!STRINGP (BVAR (XBUFFER (buf), file_truename))) continue;
-      tem = Fstring_equal (BVAR (XBUFFER (buf), file_truename), filename);
-      if (!NILP (tem))
+      if (!NILP (Fstring_equal (BVAR (XBUFFER (buf), file_truename), filename)))
         return buf;
     }
   return Qnil;
@@ -590,6 +583,7 @@ even if it is dead.  The return value is never nil.  */)
 
   b->newline_cache = 0;
   b->width_run_cache = 0;
+  b->bidi_paragraph_cache = 0;
   bset_width_table (b, Qnil);
   b->prevent_redisplay_optimizations_p = 1;
 
@@ -813,6 +807,7 @@ CLONE nil means the indirect buffer's state is reset to default values.  */)
 
   b->newline_cache = 0;
   b->width_run_cache = 0;
+  b->bidi_paragraph_cache = 0;
   bset_width_table (b, Qnil);
 
   name = Fcopy_sequence (name);
@@ -893,8 +888,8 @@ drop_overlay (struct buffer *b, struct Lisp_Overlay *ov)
   eassert (b == XBUFFER (Fmarker_buffer (ov->start)));
   modify_overlay (b, marker_position (ov->start),
                   marker_position (ov->end));
-  Fset_marker (ov->start, Qnil, Qnil);
-  Fset_marker (ov->end, Qnil, Qnil);
+  unchain_marker (XMARKER (ov->start));
+  unchain_marker (XMARKER (ov->end));
 
 }
 
@@ -938,7 +933,7 @@ reset_buffer (register struct buffer *b)
   bset_filename (b, Qnil);
   bset_file_truename (b, Qnil);
   bset_directory (b, current_buffer ? BVAR (current_buffer, directory) : Qnil);
-  b->modtime = make_emacs_time (0, UNKNOWN_MODTIME_NSECS);
+  b->modtime = make_timespec (0, UNKNOWN_MODTIME_NSECS);
   b->modtime_size = -1;
   XSETFASTINT (BVAR (b, save_length), 0);
   b->last_window_start = 1;
@@ -1581,10 +1576,8 @@ exists, return the buffer `*scratch*' (creating it if necessary).  */)
     }
 
   /* Consider alist of all buffers next.  */
-  tail = Vbuffer_alist;
-  for (; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_LIVE_BUFFER (tail, buf)
     {
-      buf = Fcdr (XCAR (tail));
       if (candidate_buffer (buf, buffer)
           /* If the frame has a buffer_predicate, disregard buffers that
              don't fit the predicate.  */
@@ -1621,12 +1614,9 @@ other_buffer_safely (Lisp_Object buffer)
 {
   Lisp_Object tail, buf;
 
-  for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
-    {
-      buf = Fcdr (XCAR (tail));
-      if (candidate_buffer (buf, buffer))
-        return buf;
-    }
+  FOR_EACH_LIVE_BUFFER (tail, buf)
+    if (candidate_buffer (buf, buffer))
+      return buf;
 
   buf = Fget_buffer (build_string ("*scratch*"));
   if (NILP (buf))
@@ -1957,6 +1947,11 @@ cleaning up all windows currently displaying the buffer to be killed. */)
       free_region_cache (b->width_run_cache);
       b->width_run_cache = 0;
     }
+  if (b->bidi_paragraph_cache)
+    {
+      free_region_cache (b->bidi_paragraph_cache);
+      b->bidi_paragraph_cache = 0;
+    }
   bset_width_table (b, Qnil);
   unblock_input ();
   bset_undo_list (b, Qnil);
@@ -2367,6 +2362,7 @@ DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text,
   current_buffer->clip_changed = 1;     other_buffer->clip_changed = 1;
   swapfield (newline_cache, struct region_cache *);
   swapfield (width_run_cache, struct region_cache *);
+  swapfield (bidi_paragraph_cache, struct region_cache *);
   current_buffer->prevent_redisplay_optimizations_p = 1;
   other_buffer->prevent_redisplay_optimizations_p = 1;
   swapfield (overlays_before, struct Lisp_Overlay *);
@@ -2413,7 +2409,7 @@ DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text,
        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 w = selected_window, ws = Qnil;
     Lisp_Object buf1, buf2;
     XSETBUFFER (buf1, current_buffer); XSETBUFFER (buf2, other_buffer);
 
@@ -3150,8 +3146,8 @@ struct sortvec
 static int
 compare_overlays (const void *v1, const void *v2)
 {
-  const struct sortvec *s1 = (const struct sortvec *) v1;
-  const struct sortvec *s2 = (const struct sortvec *) v2;
+  const struct sortvec *s1 = v1;
+  const struct sortvec *s2 = v2;
   if (s1->priority != s2->priority)
     return s1->priority < s2->priority ? -1 : 1;
   if (s1->beg != s2->beg)
@@ -3257,8 +3253,8 @@ static ptrdiff_t overlay_str_len;
 static int
 cmp_for_strings (const void *as1, const void *as2)
 {
-  struct sortstr *s1 = (struct sortstr *)as1;
-  struct sortstr *s2 = (struct sortstr *)as2;
+  struct sortstr const *s1 = as1;
+  struct sortstr const *s2 = as2;
   if (s1->size != s2->size)
     return s2->size < s1->size ? -1 : 1;
   if (s1->priority != s2->priority)
@@ -3838,7 +3834,8 @@ for the front of the overlay advance when text is inserted there
 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
 for the rear of the overlay advance when text is inserted there
 \(which means the text *is* included in the overlay).  */)
-  (Lisp_Object beg, Lisp_Object end, Lisp_Object buffer, Lisp_Object front_advance, Lisp_Object rear_advance)
+  (Lisp_Object beg, Lisp_Object end, Lisp_Object buffer,
+   Lisp_Object front_advance, Lisp_Object rear_advance)
 {
   Lisp_Object overlay;
   struct buffer *b;
@@ -3847,12 +3844,11 @@ for the rear of the overlay advance when text is inserted there
     XSETBUFFER (buffer, current_buffer);
   else
     CHECK_BUFFER (buffer);
-  if (MARKERP (beg)
-      && ! EQ (Fmarker_buffer (beg), buffer))
-    error ("Marker points into wrong buffer");
-  if (MARKERP (end)
-      && ! EQ (Fmarker_buffer (end), buffer))
-    error ("Marker points into wrong buffer");
+
+  if (MARKERP (beg) && !EQ (Fmarker_buffer (beg), buffer))
+    signal_error ("Marker points into wrong buffer", beg);
+  if (MARKERP (end) && !EQ (Fmarker_buffer (end), buffer))
+    signal_error ("Marker points into wrong buffer", end);
 
   CHECK_NUMBER_COERCE_MARKER (beg);
   CHECK_NUMBER_COERCE_MARKER (end);
@@ -3978,12 +3974,10 @@ buffer.  */)
   if (NILP (Fbuffer_live_p (buffer)))
     error ("Attempt to move overlay to a dead buffer");
 
-  if (MARKERP (beg)
-      && ! EQ (Fmarker_buffer (beg), buffer))
-    error ("Marker points into wrong buffer");
-  if (MARKERP (end)
-      && ! EQ (Fmarker_buffer (end), buffer))
-    error ("Marker points into wrong buffer");
+  if (MARKERP (beg) && !EQ (Fmarker_buffer (beg), buffer))
+    signal_error ("Marker points into wrong buffer", beg);
+  if (MARKERP (end) && !EQ (Fmarker_buffer (end), buffer))
+    signal_error ("Marker points into wrong buffer", end);
 
   CHECK_NUMBER_COERCE_MARKER (beg);
   CHECK_NUMBER_COERCE_MARKER (end);
@@ -4165,6 +4159,9 @@ DEFUN ("overlays-at", Foverlays_at, Soverlays_at, 1, 1, 0,
 
   CHECK_NUMBER_COERCE_MARKER (pos);
 
+  if (!buffer_has_overlays ())
+    return Qnil;
+
   len = 10;
   /* We can't use alloca here because overlays_at can call xrealloc.  */
   overlay_vec = xmalloc (len * sizeof *overlay_vec);
@@ -4197,6 +4194,9 @@ end of the buffer.  */)
   CHECK_NUMBER_COERCE_MARKER (beg);
   CHECK_NUMBER_COERCE_MARKER (end);
 
+  if (!buffer_has_overlays ())
+    return Qnil;
+
   len = 10;
   overlay_vec = xmalloc (len * sizeof *overlay_vec);
 
@@ -4225,6 +4225,9 @@ the value is (point-max).  */)
 
   CHECK_NUMBER_COERCE_MARKER (pos);
 
+  if (!buffer_has_overlays ())
+    return make_number (ZV);
+
   len = 10;
   overlay_vec = xmalloc (len * sizeof *overlay_vec);
 
@@ -4264,6 +4267,9 @@ the value is (point-min).  */)
 
   CHECK_NUMBER_COERCE_MARKER (pos);
 
+  if (!buffer_has_overlays ())
+    return make_number (BEGV);
+
   /* At beginning of buffer, we know the answer;
      avoid bug subtracting 1 below.  */
   if (XINT (pos) == BEGV)
@@ -4756,7 +4762,7 @@ static struct mmap_region *
 mmap_find (void *start, void *end)
 {
   struct mmap_region *r;
-  char *s = (char *) start, *e = (char *) end;
+  char *s = start, *e = end;
 
   for (r = mmap_regions; r; r = r->next)
     {
@@ -4915,7 +4921,7 @@ mmap_alloc (void **var, size_t nbytes)
     }
   else
     {
-      struct mmap_region *r = (struct mmap_region *) p;
+      struct mmap_region *r = p;
 
       r->nbytes_specified = nbytes;
       r->nbytes_mapped = map;
@@ -5055,7 +5061,7 @@ alloc_buffer_text (struct buffer *b, ptrdiff_t nbytes)
       memory_full (nbytes);
     }
 
-  b->text->beg = (unsigned char *) p;
+  b->text->beg = p;
   unblock_input ();
 }
 
@@ -5083,7 +5089,7 @@ enlarge_buffer_text (struct buffer *b, ptrdiff_t delta)
       memory_full (nbytes);
     }
 
-  BUF_BEG_ADDR (b) = (unsigned char *) p;
+  BUF_BEG_ADDR (b) = p;
   unblock_input ();
 }
 
@@ -5181,7 +5187,7 @@ init_buffer_once (void)
   bset_buffer_file_coding_system (&buffer_defaults, Qnil);
   XSETFASTINT (BVAR (&buffer_defaults, fill_column), 70);
   XSETFASTINT (BVAR (&buffer_defaults, left_margin), 0);
-  bset_cache_long_line_scans (&buffer_defaults, Qnil);
+  bset_cache_long_scans (&buffer_defaults, Qnil);
   bset_file_truename (&buffer_defaults, Qnil);
   XSETFASTINT (BVAR (&buffer_defaults, display_count), 0);
   XSETFASTINT (BVAR (&buffer_defaults, left_margin_cols), 0);
@@ -5245,7 +5251,7 @@ init_buffer_once (void)
   XSETFASTINT (BVAR (&buffer_local_flags, abbrev_table), idx); ++idx;
   XSETFASTINT (BVAR (&buffer_local_flags, display_table), idx); ++idx;
   XSETFASTINT (BVAR (&buffer_local_flags, syntax_table), idx); ++idx;
-  XSETFASTINT (BVAR (&buffer_local_flags, cache_long_line_scans), idx); ++idx;
+  XSETFASTINT (BVAR (&buffer_local_flags, cache_long_scans), idx); ++idx;
   XSETFASTINT (BVAR (&buffer_local_flags, category_table), idx); ++idx;
   XSETFASTINT (BVAR (&buffer_local_flags, bidi_display_reordering), idx); ++idx;
   XSETFASTINT (BVAR (&buffer_local_flags, bidi_paragraph_direction), idx); ++idx;
@@ -5401,11 +5407,7 @@ defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
   bo_fwd->predicate = predicate;
   sym->declared_special = 1;
   sym->redirect = SYMBOL_FORWARDED;
-  {
-    /* I tried to do the job without a cast, but it seems impossible.
-       union Lisp_Fwd *fwd; &(fwd->u_buffer_objfwd) = bo_fwd;  */
-    SET_SYMBOL_FWD (sym, (union Lisp_Fwd *)bo_fwd);
-  }
+  SET_SYMBOL_FWD (sym, (union Lisp_Fwd *) bo_fwd);
   XSETSYMBOL (PER_BUFFER_SYMBOL (offset), sym);
 
   if (PER_BUFFER_IDX (offset) == 0)
@@ -6114,7 +6116,7 @@ An entry (apply FUN-NAME . ARGS) means undo the change with
 
 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
 in the active region.  BEG and END is the range affected by this entry
-and DELTA is the number of bytes added or deleted in that range by
+and DELTA is the number of characters added or deleted in that range by
 this change.
 
 An entry (MARKER . DISTANCE) indicates that the marker MARKER
@@ -6132,8 +6134,8 @@ If the value of the variable is t, undo information is not recorded.  */);
   DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer, mark_active), Qnil,
                      doc: /* Non-nil means the mark and region are currently active in this buffer.  */);
 
-  DEFVAR_PER_BUFFER ("cache-long-line-scans", &BVAR (current_buffer, cache_long_line_scans), Qnil,
-                     doc: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
+  DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer, cache_long_scans), Qnil,
+                     doc: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans.
 
 Normally, the line-motion functions work by scanning the buffer for
 newlines.  Columnar operations (like `move-to-column' and
@@ -6143,18 +6145,24 @@ buffer's lines are very long (say, more than 500 characters), these
 motion functions will take longer to execute.  Emacs may also take
 longer to update the display.
 
-If `cache-long-line-scans' is non-nil, these motion functions cache the
+If `cache-long-scans' is non-nil, these motion functions cache the
 results of their scans, and consult the cache to avoid rescanning
 regions of the buffer until the text is modified.  The caches are most
 beneficial when they prevent the most searching---that is, when the
 buffer contains long lines and large regions of characters with the
 same, fixed screen width.
 
-When `cache-long-line-scans' is non-nil, processing short lines will
+When `cache-long-scans' is non-nil, processing short lines will
 become slightly slower (because of the overhead of consulting the
 cache), and the caches will use memory roughly proportional to the
 number of newlines and characters whose screen width varies.
 
+Bidirectional editing also requires buffer scans to find paragraph
+separators.  If you have large paragraphs or no paragraph separators
+at all, these scans may be slow.  If `cache-long-scans' is non-nil,
+results of these scans are cached.  This doesn't help too much if
+paragraphs are of the reasonable (few thousands of characters) size.
+
 The caches require no explicit maintenance; their accuracy is
 maintained internally by the Emacs primitives.  Enabling or disabling
 the cache should not affect the behavior of any of the motion
diff --git a/src/buffer.h b/src/buffer.h
index 641a561cafc..169a15c7d0f 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -18,8 +18,8 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
-#include <sys/types.h> /* for off_t, time_t */
-#include "systime.h" /* for EMACS_TIME */
+#include <sys/types.h>
+#include <time.h>
 
 INLINE_HEADER_BEGIN
 #ifndef BUFFER_INLINE
@@ -249,6 +249,7 @@ extern void temp_set_point (struct buffer *, ptrdiff_t);
 extern void set_point_both (ptrdiff_t, ptrdiff_t);
 extern void temp_set_point_both (struct buffer *,
                                  ptrdiff_t, ptrdiff_t);
+extern void set_point_from_marker (Lisp_Object);
 extern void enlarge_buffer_text (struct buffer *, ptrdiff_t);
 
 
@@ -632,9 +633,9 @@ struct buffer
   /* List of symbols naming the file format used for auto-save file.  */
   Lisp_Object INTERNAL_FIELD (auto_save_file_format);
 
-  /* True if the newline position cache and width run cache are
-     enabled.  See search.c and indent.c.  */
-  Lisp_Object INTERNAL_FIELD (cache_long_line_scans);
+  /* True if the newline position cache, width run cache and BIDI paragraph
+     cache are enabled.  See search.c, indent.c and bidi.c for details.  */
+  Lisp_Object INTERNAL_FIELD (cache_long_scans);
 
   /* If the width run cache is enabled, this table contains the
      character widths width_run_cache (see above) assumes.  When we
@@ -794,13 +795,13 @@ struct buffer
   char local_flags[MAX_PER_BUFFER_VARS];
 
   /* Set to the modtime of the visited file when read or written.
-     EMACS_NSECS (modtime) == NONEXISTENT_MODTIME_NSECS means
-     visited file was nonexistent.  EMACS_NSECS (modtime) ==
+     modtime.tv_nsec == NONEXISTENT_MODTIME_NSECS means
+     visited file was nonexistent.  modtime.tv_nsec ==
      UNKNOWN_MODTIME_NSECS means visited file modtime unknown;
      in no case complain about any mismatch on next save attempt.  */
 #define NONEXISTENT_MODTIME_NSECS (-1)
 #define UNKNOWN_MODTIME_NSECS (-2)
-  EMACS_TIME modtime;
+  struct timespec modtime;
 
   /* Size of the file when modtime was set.  This is used to detect the
      case where the file grew while we were reading it, so the modtime
@@ -839,9 +840,12 @@ struct buffer
      the character's width; if it maps a character to zero, we don't
      know what its width is.  This allows compute_motion to process
      such regions very quickly, using algebra instead of inspecting
-     each character.   See also width_table, below.  */
+     each character.   See also width_table, below.
+
+     The latter cache is used to speedup bidi_find_paragraph_start.  */
   struct region_cache *newline_cache;
   struct region_cache *width_run_cache;
+  struct region_cache *bidi_paragraph_cache;
 
   /* Non-zero means don't use redisplay optimizations for
      displaying this buffer.  */
@@ -1120,9 +1124,17 @@ record_unwind_current_buffer (void)
       }                                                                 \
   } while (0)
 
+extern Lisp_Object Vbuffer_alist;
 extern Lisp_Object Qbefore_change_functions;
 extern Lisp_Object Qafter_change_functions;
 extern Lisp_Object Qfirst_change_hook;
+extern Lisp_Object Qpriority, Qbefore_string, Qafter_string;
+
+/* FOR_EACH_LIVE_BUFFER (LIST_VAR, BUF_VAR) followed by a statement is
+   a `for' loop which iterates over the buffers from Vbuffer_alist.  */
+
+#define FOR_EACH_LIVE_BUFFER(list_var, buf_var)                 \
+  FOR_EACH_ALIST_VALUE (Vbuffer_alist, list_var, buf_var)
 
 /* Get text properties of B.  */
 
diff --git a/src/callint.c b/src/callint.c
index 38431226508..25096af5068 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -331,12 +331,9 @@ invoke it.  If KEYS is omitted or nil, the return value of
 
   /* If SPECS is set to a string, use it as an interactive prompt.  */
   if (STRINGP (specs))
-    {
-      /* Make a copy of string so that if a GC relocates specs,
-         `string' will still be valid.  */
-      string = alloca (SBYTES (specs) + 1);
-      memcpy (string, SSDATA (specs), SBYTES (specs) + 1);
-    }
+    /* Make a copy of string so that if a GC relocates specs,
+       `string' will still be valid.  */
+    string = xlispstrdupa (specs);
   else
     {
       Lisp_Object input;
@@ -529,7 +526,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
                               make_number (SCHARS (callint_message)),
                               Qface, Qminibuffer_prompt, callint_message);
           args[i] = Fread_char (callint_message, Qnil, Qnil);
-          message1_nolog ((char *) 0);
+          message1_nolog (0);
           /* Passing args[i] directly stimulates compiler bug.  */
           teml = args[i];
           /* See bug#8479.  */
diff --git a/src/callproc.c b/src/callproc.c
index 450fc57f929..d4b4a26ec3a 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -68,9 +68,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Pattern used by call-process-region to make temp files.  */
 static Lisp_Object Vtemp_file_name_pattern;
 
-/* The next two variables are valid only while record-unwind-protect
-   is in place during call-process for a synchronous subprocess.  At
-   other times, their contents are irrelevant.  Doing this via static
+/* The next two variables are used while record-unwind-protect is in place
+   during call-process for a subprocess for which record_deleted_pid has
+   not yet been called.  At other times, synch_process_pid is zero and
+   synch_process_tempfile's contents are irrelevant.  Doing this via static
    C variables is more convenient than putting them into the arguments
    of record-unwind-protect, as they need to be updated at randomish
    times in the code, and Lisp cannot always store these values as
@@ -80,8 +81,28 @@ static Lisp_Object Vtemp_file_name_pattern;
 /* If nonzero, a process-ID that has not been reaped.  */
 static pid_t synch_process_pid;
 
-/* If nonnegative, a file descriptor that has not been closed.  */
-static int synch_process_fd;
+/* If a string, the name of a temp file that has not been removed.  */
+#ifdef MSDOS
+static Lisp_Object synch_process_tempfile;
+#else
+# define synch_process_tempfile make_number (0)
+#endif
+
+/* Indexes of file descriptors that need closing on call_process_kill.  */
+enum
+  {
+    /* The subsidiary process's stdout and stderr.  stdin is handled
+       separately, in either Fcall_process_region or create_temp_file.  */
+    CALLPROC_STDOUT, CALLPROC_STDERR,
+
+    /* How to read from a pipe (or substitute) from the subsidiary process.  */
+    CALLPROC_PIPEREAD,
+
+    /* A bound on the number of file descriptors.  */
+    CALLPROC_FDS
+  };
+
+static Lisp_Object call_process (ptrdiff_t, Lisp_Object *, int, ptrdiff_t);
 
 /* Block SIGCHLD.  */
 
@@ -102,85 +123,104 @@ unblock_child_signal (void)
   pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
 }
 
+/* Return the current buffer's working directory, or the home
+   directory if it's unreachable, as a string suitable for a system call.
+   Signal an error if the result would not be an accessible directory.  */
+
+Lisp_Object
+encode_current_directory (void)
+{
+  Lisp_Object dir;
+  struct gcpro gcpro1;
+
+  dir = BVAR (current_buffer, directory);
+  GCPRO1 (dir);
+
+  dir = Funhandled_file_name_directory (dir);
+
+  /* If the file name handler says that dir is unreachable, use
+     a sensible default. */
+  if (NILP (dir))
+    dir = build_string ("~");
+
+  dir = expand_and_dir_to_file (dir, Qnil);
+
+  if (STRING_MULTIBYTE (dir))
+    dir = ENCODE_FILE (dir);
+  if (! file_accessible_directory_p (SSDATA (dir)))
+    report_file_error ("Setting current directory",
+                       BVAR (current_buffer, directory));
+
+  RETURN_UNGCPRO (dir);
+}
+
 /* If P is reapable, record it as a deleted process and kill it.
    Do this in a critical section.  Unless PID is wedged it will be
    reaped on receipt of the first SIGCHLD after the critical section.  */
 
 void
-record_kill_process (struct Lisp_Process *p)
+record_kill_process (struct Lisp_Process *p, Lisp_Object tempfile)
 {
   block_child_signal ();
 
   if (p->alive)
     {
+      record_deleted_pid (p->pid, tempfile);
       p->alive = 0;
-      record_deleted_pid (p->pid);
       kill (- p->pid, SIGKILL);
     }
 
   unblock_child_signal ();
 }
 
-/* Clean up when exiting call_process_cleanup.  */
+/* Clean up files, file descriptors and processes created by Fcall_process.  */
+
+static void
+delete_temp_file (Lisp_Object name)
+{
+  unlink (SSDATA (name));
+}
 
 static void
-call_process_kill (void)
+call_process_kill (void *ptr)
 {
-  if (synch_process_fd >= 0)
-    emacs_close (synch_process_fd);
+  int *callproc_fd = ptr;
+  int i;
+  for (i = 0; i < CALLPROC_FDS; i++)
+    if (0 <= callproc_fd[i])
+      emacs_close (callproc_fd[i]);
 
   if (synch_process_pid)
     {
       struct Lisp_Process proc;
       proc.alive = 1;
       proc.pid = synch_process_pid;
-      record_kill_process (&proc);
+      record_kill_process (&proc, synch_process_tempfile);
+      synch_process_pid = 0;
     }
+  else if (STRINGP (synch_process_tempfile))
+    delete_temp_file (synch_process_tempfile);
 }
 
-/* Clean up when exiting Fcall_process.
-   On MSDOS, delete the temporary file on any kind of termination.
-   On Unix, kill the process and any children on termination by signal.  */
+/* Clean up when exiting Fcall_process: restore the buffer, and
+   kill the subsidiary process group if the process still exists.  */
 
 static void
-call_process_cleanup (Lisp_Object arg)
+call_process_cleanup (Lisp_Object buffer)
 {
-#ifdef MSDOS
-  Lisp_Object buffer = Fcar (arg);
-  Lisp_Object file = Fcdr (arg);
-#else
-  Lisp_Object buffer = arg;
-#endif
-
   Fset_buffer (buffer);
 
-#ifndef MSDOS
-  /* If the process still exists, kill its process group.  */
   if (synch_process_pid)
     {
-      ptrdiff_t count = SPECPDL_INDEX ();
       kill (-synch_process_pid, SIGINT);
-      record_unwind_protect_void (call_process_kill);
       message1 ("Waiting for process to die...(type C-g again to kill it instantly)");
       immediate_quit = 1;
       QUIT;
       wait_for_termination (synch_process_pid, 0, 1);
       synch_process_pid = 0;
       immediate_quit = 0;
-      specpdl_ptr = specpdl + count; /* Discard the unwind protect.  */
       message1 ("Waiting for process to die...done");
     }
-#endif
-
-  if (synch_process_fd >= 0)
-    emacs_close (synch_process_fd);
-
-#ifdef MSDOS
-  /* FILE is "" when we didn't actually create a temporary file in
-     call-process.  */
-  if (!(strcmp (SDATA (file), NULL_DEVICE) == 0 || SREF (file, 0) == '\0'))
-    unlink (SDATA (file));
-#endif
 }
 
 #ifdef DOS_NT
@@ -218,10 +258,48 @@ If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
 usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  Lisp_Object infile, buffer, current_dir, path;
+  Lisp_Object infile, encoded_infile;
+  int filefd;
+  struct gcpro gcpro1;
+  ptrdiff_t count = SPECPDL_INDEX ();
+
+  if (nargs >= 2 && ! NILP (args[1]))
+    {
+      infile = Fexpand_file_name (args[1], BVAR (current_buffer, directory));
+      CHECK_STRING (infile);
+    }
+  else
+    infile = build_string (NULL_DEVICE);
+
+  GCPRO1 (infile);
+  encoded_infile = STRING_MULTIBYTE (infile) ? ENCODE_FILE (infile) : infile;
+
+  filefd = emacs_open (SSDATA (encoded_infile), O_RDONLY, 0);
+  if (filefd < 0)
+    report_file_error ("Opening process input file", infile);
+  record_unwind_protect_int (close_file_unwind, filefd);
+  UNGCPRO;
+  return unbind_to (count, call_process (nargs, args, filefd, -1));
+}
+
+/* Like Fcall_process (NARGS, ARGS), except use FILEFD as the input file.
+
+   If TEMPFILE_INDEX is nonnegative, it is the specpdl index of an
+   unwinder that is intended to remove the input temporary file; in
+   this case NARGS must be at least 2 and ARGS[1] is the file's name.
+
+   At entry, the specpdl stack top entry must be close_file_unwind (FILEFD).  */
+
+static Lisp_Object
+call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
+              ptrdiff_t tempfile_index)
+{
+  Lisp_Object buffer, current_dir, path;
   bool display_p;
-  int fd0, fd1, filefd;
+  int fd0;
+  int callproc_fd[CALLPROC_FDS];
   int status;
+  ptrdiff_t i;
   ptrdiff_t count = SPECPDL_INDEX ();
   USE_SAFE_ALLOCA;
 
@@ -231,19 +309,21 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
   Lisp_Object error_file;
   Lisp_Object output_file = Qnil;
 #ifdef MSDOS    /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
-  char *outf, *tempfile = NULL;
-  int outfilefd;
+  char *tempfile = NULL;
   int pid;
 #else
   pid_t pid;
 #endif
   int child_errno;
-  int fd_output = -1;
+  int fd_output, fd_error;
   struct coding_system process_coding; /* coding-system of process output */
   struct coding_system argument_coding; /* coding-system of arguments */
   /* Set to the return value of Ffind_operation_coding_system.  */
   Lisp_Object coding_systems;
-  bool output_to_buffer = 1;
+  bool discard_output;
+
+  if (synch_process_pid)
+    error ("call-process invoked recursively");
 
   /* Qt denotes that Ffind_operation_coding_system is not yet called.  */
   coding_systems = Qt;
@@ -262,7 +342,6 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
   /* Decide the coding-system for giving arguments.  */
   {
     Lisp_Object val, *args2;
-    ptrdiff_t i;
 
     /* If arguments are supplied, we may have to encode them.  */
     if (nargs >= 5)
@@ -301,24 +380,16 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
       }
   }
 
-  if (nargs >= 2 && ! NILP (args[1]))
-    {
-      infile = Fexpand_file_name (args[1], BVAR (current_buffer, directory));
-      CHECK_STRING (infile);
-    }
+  if (nargs < 3)
+    buffer = Qnil;
   else
-    infile = build_string (NULL_DEVICE);
-
-  if (nargs >= 3)
     {
       buffer = args[2];
 
       /* If BUFFER is a list, its meaning is (BUFFER-FOR-STDOUT
          FILE-FOR-STDERR), unless the first element is :file, in which case see
          the next paragraph. */
-      if (CONSP (buffer)
-          && (! SYMBOLP (XCAR (buffer))
-              || strcmp (SSDATA (SYMBOL_NAME (XCAR (buffer))), ":file")))
+      if (CONSP (buffer) && !EQ (XCAR (buffer), QCfile))
         {
           if (CONSP (XCDR (buffer)))
             {
@@ -335,9 +406,7 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
         }
 
       /* If the buffer is (still) a list, it might be a (:file "file") spec. */
-      if (CONSP (buffer)
-          && SYMBOLP (XCAR (buffer))
-          && ! strcmp (SSDATA (SYMBOL_NAME (XCAR (buffer))), ":file"))
+      if (CONSP (buffer) && EQ (XCAR (buffer), QCfile))
         {
           output_file = Fexpand_file_name (XCAR (XCDR (buffer)),
                                            BVAR (current_buffer, directory));
@@ -345,9 +414,7 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
           buffer = Qnil;
         }
 
-      if (!(EQ (buffer, Qnil)
-            || EQ (buffer, Qt)
-            || INTEGERP (buffer)))
+      if (! (NILP (buffer) || EQ (buffer, Qt) || INTEGERP (buffer)))
         {
           Lisp_Object spec_buffer;
           spec_buffer = buffer;
@@ -358,8 +425,6 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
           CHECK_BUFFER (buffer);
         }
     }
-  else
-    buffer = Qnil;
 
   /* Make sure that the child will be able to chdir to the current
      buffer's current directory, or its unhandled equivalent.  We
@@ -372,28 +437,12 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
      protected by the caller, so all we really have to worry about is
      buffer.  */
   {
-    struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
-
-    current_dir = BVAR (current_buffer, directory);
-
-    GCPRO5 (infile, buffer, current_dir, error_file, output_file);
+    struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 
-    current_dir = Funhandled_file_name_directory (current_dir);
-    if (NILP (current_dir))
-      /* If the file name handler says that current_dir is unreachable, use
-         a sensible default. */
-      current_dir = build_string ("~/");
-    current_dir = expand_and_dir_to_file (current_dir, Qnil);
-    current_dir = Ffile_name_as_directory (current_dir);
+    current_dir = encode_current_directory ();
 
-    if (NILP (Ffile_accessible_directory_p (current_dir)))
-      report_file_error ("Setting current directory",
-                         BVAR (current_buffer, directory));
+    GCPRO4 (buffer, current_dir, error_file, output_file);
 
-    if (STRING_MULTIBYTE (infile))
-      infile = ENCODE_FILE (infile);
-    if (STRING_MULTIBYTE (current_dir))
-      current_dir = ENCODE_FILE (current_dir);
     if (STRINGP (error_file) && STRING_MULTIBYTE (error_file))
       error_file = ENCODE_FILE (error_file);
     if (STRINGP (output_file) && STRING_MULTIBYTE (output_file))
@@ -403,44 +452,23 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
 
   display_p = INTERACTIVE && nargs >= 4 && !NILP (args[3]);
 
-  filefd = emacs_open (SSDATA (infile), O_RDONLY, 0);
-  if (filefd < 0)
-    {
-      int open_errno = errno;
-      report_file_errno ("Opening process input file", DECODE_FILE (infile),
-                         open_errno);
-    }
-
-  if (STRINGP (output_file))
-    {
-      fd_output = emacs_open (SSDATA (output_file),
-                              O_WRONLY | O_CREAT | O_TRUNC | O_TEXT,
-                              default_output_mode);
-      if (fd_output < 0)
-        {
-          int open_errno = errno;
-          output_file = DECODE_FILE (output_file);
-          report_file_errno ("Opening process output file",
-                             output_file, open_errno);
-        }
-      if (STRINGP (error_file) || NILP (error_file))
-        output_to_buffer = 0;
-    }
+  for (i = 0; i < CALLPROC_FDS; i++)
+    callproc_fd[i] = -1;
+#ifdef MSDOS
+  synch_process_tempfile = make_number (0);
+#endif
+  record_unwind_protect_ptr (call_process_kill, callproc_fd);
 
   /* Search for program; barf if not found.  */
   {
-    struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+    struct gcpro gcpro1, gcpro2, gcpro3;
     int ok;
 
-    GCPRO4 (infile, buffer, current_dir, error_file);
+    GCPRO3 (buffer, current_dir, error_file);
     ok = openp (Vexec_path, args[0], Vexec_suffixes, &path, make_number (X_OK));
     UNGCPRO;
     if (ok < 0)
-      {
-        int openp_errno = errno;
-        emacs_close (filefd);
-        report_file_errno ("Searching for program", args[0], openp_errno);
-      }
+      report_file_error ("Searching for program", args[0]);
   }
 
   /* If program file name starts with /: for quoting a magic name,
@@ -452,9 +480,9 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
   new_argv = SAFE_ALLOCA ((nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv);
 
   {
-    struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
+    struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 
-    GCPRO5 (infile, buffer, current_dir, path, error_file);
+    GCPRO4 (buffer, current_dir, path, error_file);
     if (nargs > 4)
       {
         ptrdiff_t i;
@@ -479,254 +507,228 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
     UNGCPRO;
   }
 
-#ifdef MSDOS /* MW, July 1993 */
+  discard_output = INTEGERP (buffer) || (NILP (buffer) && NILP (output_file));
 
-  /* If we're redirecting STDOUT to a file, that file is already open
-     on fd_output.  */
-  if (fd_output < 0)
+#ifdef MSDOS
+  if (! discard_output && ! STRINGP (output_file))
     {
-      if ((outf = egetenv ("TMPDIR")))
-        strcpy (tempfile = alloca (strlen (outf) + 20), outf);
-      else
-        {
-          tempfile = alloca (20);
-          *tempfile = '\0';
-        }
+      char const *tmpdir = egetenv ("TMPDIR");
+      char const *outf = tmpdir ? tmpdir : "";
+      tempfile = alloca (strlen (outf) + 20);
+      strcpy (tempfile, outf);
       dostounix_filename (tempfile, 0);
       if (*tempfile == '\0' || tempfile[strlen (tempfile) - 1] != '/')
         strcat (tempfile, "/");
       strcat (tempfile, "detmp.XXX");
       mktemp (tempfile);
-      outfilefd = emacs_open (tempfile, O_WRONLY | O_CREAT | O_TRUNC,
-                              S_IREAD | S_IWRITE);
-      if (outfilefd < 0)
+      if (!*tempfile)
+        report_file_error ("Opening process output file", Qnil);
+      output_file = build_string (tempfile);
+      synch_process_tempfile = output_file;
+    }
+#endif
+
+  if (discard_output)
+    {
+      fd_output = emacs_open (NULL_DEVICE, O_WRONLY, 0);
+      if (fd_output < 0)
+        report_file_error ("Opening null device", Qnil);
+    }
+  else if (STRINGP (output_file))
+    {
+      fd_output = emacs_open (SSDATA (output_file),
+                              O_WRONLY | O_CREAT | O_TRUNC | O_TEXT,
+                              default_output_mode);
+      if (fd_output < 0)
         {
           int open_errno = errno;
-          emacs_close (filefd);
+          output_file = DECODE_FILE (output_file);
           report_file_errno ("Opening process output file",
-                             build_string (tempfile), open_errno);
+                             output_file, open_errno);
         }
     }
   else
-    outfilefd = fd_output;
-  fd0 = filefd;
-  fd1 = outfilefd;
-#endif /* MSDOS */
-
-  if (INTEGERP (buffer))
     {
-      fd0 = -1;
-      fd1 = emacs_open (NULL_DEVICE, O_WRONLY, 0);
-    }
-  else
-    {
-#ifndef MSDOS
       int fd[2];
       if (emacs_pipe (fd) != 0)
-        {
-          int pipe_errno = errno;
-          emacs_close (filefd);
-          report_file_errno ("Creating process pipe", Qnil, pipe_errno);
-        }
-      fd0 = fd[0];
-      fd1 = fd[1];
-#endif
+        report_file_error ("Creating process pipe", Qnil);
+      callproc_fd[CALLPROC_PIPEREAD] = fd[0];
+      fd_output = fd[1];
     }
+  callproc_fd[CALLPROC_STDOUT] = fd_output;
 
-  {
-    int fd_error = fd1;
+  fd_error = fd_output;
 
-    if (fd_output >= 0)
-      fd1 = fd_output;
-
-    if (NILP (error_file))
-      fd_error = emacs_open (NULL_DEVICE, O_WRONLY, 0);
-    else if (STRINGP (error_file))
-      fd_error = emacs_open (SSDATA (error_file),
+  if (STRINGP (error_file) || (NILP (error_file) && !discard_output))
+    {
+      fd_error = emacs_open ((STRINGP (error_file)
+                              ? SSDATA (error_file)
+                              : NULL_DEVICE),
                              O_WRONLY | O_CREAT | O_TRUNC | O_TEXT,
                              default_output_mode);
-
-    if (fd_error < 0)
-      {
-        int open_errno = errno;
-        emacs_close (filefd);
-        if (fd0 != filefd)
-          emacs_close (fd0);
-        if (fd1 >= 0)
-          emacs_close (fd1);
-#ifdef MSDOS
-        unlink (tempfile);
-#endif
-        if (NILP (error_file))
-          error_file = build_string (NULL_DEVICE);
-        else if (STRINGP (error_file))
-          error_file = DECODE_FILE (error_file);
-        report_file_errno ("Cannot redirect stderr", error_file, open_errno);
-      }
+      if (fd_error < 0)
+        {
+          int open_errno = errno;
+          report_file_errno ("Cannot redirect stderr",
+                             (STRINGP (error_file)
+                              ? DECODE_FILE (error_file)
+                              : build_string (NULL_DEVICE)),
+                             open_errno);
+        }
+      callproc_fd[CALLPROC_STDERR] = fd_error;
+    }
 
 #ifdef MSDOS /* MW, July 1993 */
-    /* Note that on MSDOS `child_setup' actually returns the child process
-       exit status, not its PID, so assign it to status below.  */
-    pid = child_setup (filefd, outfilefd, fd_error, new_argv, 0, current_dir);
-    child_errno = errno;
-
-    emacs_close (outfilefd);
-    if (fd_error != outfilefd)
-      emacs_close (fd_error);
-    if (pid < 0)
-      {
-        synchronize_system_messages_locale ();
-        return
-          code_convert_string_norecord (build_string (strerror (child_errno)),
-                                        Vlocale_coding_system, 0);
-      }
-    status = pid;
-    fd1 = -1; /* No harm in closing that one!  */
-    if (tempfile)
+  /* Note that on MSDOS `child_setup' actually returns the child process
+     exit status, not its PID, so assign it to status below.  */
+  pid = child_setup (filefd, fd_output, fd_error, new_argv, 0, current_dir);
+
+  if (pid < 0)
+    {
+      child_errno = errno;
+      unbind_to (count, Qnil);
+      synchronize_system_messages_locale ();
+      return
+        code_convert_string_norecord (build_string (strerror (child_errno)),
+                                      Vlocale_coding_system, 0);
+    }
+  status = pid;
+
+  for (i = 0; i < CALLPROC_FDS; i++)
+    if (0 <= callproc_fd[i])
       {
-        /* Since CRLF is converted to LF within `decode_coding', we
-           can always open a file with binary mode.  */
-        fd0 = emacs_open (tempfile, O_RDONLY | O_BINARY, 0);
-        if (fd0 < 0)
-          {
-            int open_errno = errno;
-            unlink (tempfile);
-            emacs_close (filefd);
-            report_file_errno ("Cannot re-open temporary file",
-                               build_string (tempfile), open_errno);
-          }
+        emacs_close (callproc_fd[i]);
+        callproc_fd[i] = -1;
       }
-    else
-      fd0 = -1; /* We are not going to read from tempfile.   */
+  emacs_close (filefd);
+  clear_unwind_protect (count - 1);
+
+  if (tempfile)
+    {
+      /* Since CRLF is converted to LF within `decode_coding', we
+         can always open a file with binary mode.  */
+      callproc_fd[CALLPROC_PIPEREAD] = emacs_open (tempfile,
+                                                   O_RDONLY | O_BINARY, 0);
+      if (callproc_fd[CALLPROC_PIPEREAD] < 0)
+        {
+          int open_errno = errno;
+          report_file_errno ("Cannot re-open temporary file",
+                             build_string (tempfile), open_errno);
+        }
+    }
+
 #endif /* MSDOS */
 
-    /* Do the unwind-protect now, even though the pid is not known, so
-       that no storage allocation is done in the critical section.
-       The actual PID will be filled in during the critical section.  */
-    synch_process_pid = 0;
-    synch_process_fd = fd0;
+  /* Do the unwind-protect now, even though the pid is not known, so
+     that no storage allocation is done in the critical section.
+     The actual PID will be filled in during the critical section.  */
+  record_unwind_protect (call_process_cleanup, Fcurrent_buffer ());
 
-#ifdef MSDOS
-    /* MSDOS needs different cleanup information.  */
-    record_unwind_protect (call_process_cleanup,
-                           Fcons (Fcurrent_buffer (),
-                                  build_string (tempfile ? tempfile : "")));
-#else
-    record_unwind_protect (call_process_cleanup, Fcurrent_buffer ());
+#ifndef MSDOS
 
-    block_input ();
-    block_child_signal ();
+  block_input ();
+  block_child_signal ();
 
 #ifdef WINDOWSNT
-    pid = child_setup (filefd, fd1, fd_error, new_argv, 0, current_dir);
-    /* We need to record the input file of this child, for when we are
-       called from call-process-region to create an async subprocess.
-       That's because call-process-region's unwind procedure will
-       attempt to delete the temporary input file, which will fail
-       because that file is still in use.  Recording it with the child
-       will allow us to delete the file when the subprocess exits.
-       The second part of this is in delete_temp_file, q.v.  */
-    if (pid > 0 && INTEGERP (buffer) && nargs >= 2 && !NILP (args[1]))
-      record_infile (pid, xstrdup (SSDATA (infile)));
+  pid = child_setup (filefd, fd_output, fd_error, new_argv, 0, current_dir);
 #else  /* not WINDOWSNT */
 
-    /* vfork, and prevent local vars from being clobbered by the vfork.  */
-    {
-      Lisp_Object volatile buffer_volatile = buffer;
-      Lisp_Object volatile coding_systems_volatile = coding_systems;
-      Lisp_Object volatile current_dir_volatile = current_dir;
-      bool volatile display_p_volatile = display_p;
-      bool volatile output_to_buffer_volatile = output_to_buffer;
-      bool volatile sa_must_free_volatile = sa_must_free;
-      int volatile fd1_volatile = fd1;
-      int volatile fd_error_volatile = fd_error;
-      int volatile fd_output_volatile = fd_output;
-      int volatile filefd_volatile = filefd;
-      ptrdiff_t volatile count_volatile = count;
-      ptrdiff_t volatile sa_count_volatile = sa_count;
-      char **volatile new_argv_volatile = new_argv;
-
-      pid = vfork ();
-      child_errno = errno;
-
-      buffer = buffer_volatile;
-      coding_systems = coding_systems_volatile;
-      current_dir = current_dir_volatile;
-      display_p = display_p_volatile;
-      output_to_buffer = output_to_buffer_volatile;
-      sa_must_free = sa_must_free_volatile;
-      fd1 = fd1_volatile;
-      fd_error = fd_error_volatile;
-      fd_output = fd_output_volatile;
-      filefd = filefd_volatile;
-      count = count_volatile;
-      sa_count = sa_count_volatile;
-      new_argv = new_argv_volatile;
-
-      fd0 = synch_process_fd;
-    }
-
-    if (pid == 0)
-      {
-        unblock_child_signal ();
+  /* vfork, and prevent local vars from being clobbered by the vfork.  */
+  {
+    Lisp_Object volatile buffer_volatile = buffer;
+    Lisp_Object volatile coding_systems_volatile = coding_systems;
+    Lisp_Object volatile current_dir_volatile = current_dir;
+    bool volatile display_p_volatile = display_p;
+    bool volatile sa_must_free_volatile = sa_must_free;
+    int volatile fd_error_volatile = fd_error;
+    int volatile filefd_volatile = filefd;
+    ptrdiff_t volatile count_volatile = count;
+    ptrdiff_t volatile sa_count_volatile = sa_count;
+    char **volatile new_argv_volatile = new_argv;
+    int volatile callproc_fd_volatile[CALLPROC_FDS];
+    for (i = 0; i < CALLPROC_FDS; i++)
+      callproc_fd_volatile[i] = callproc_fd[i];
+
+    pid = vfork ();
+
+    buffer = buffer_volatile;
+    coding_systems = coding_systems_volatile;
+    current_dir = current_dir_volatile;
+    display_p = display_p_volatile;
+    sa_must_free = sa_must_free_volatile;
+    fd_error = fd_error_volatile;
+    filefd = filefd_volatile;
+    count = count_volatile;
+    sa_count = sa_count_volatile;
+    new_argv = new_argv_volatile;
+
+    for (i = 0; i < CALLPROC_FDS; i++)
+      callproc_fd[i] = callproc_fd_volatile[i];
+    fd_output = callproc_fd[CALLPROC_STDOUT];
+  }
 
-        if (fd0 >= 0)
-          emacs_close (fd0);
+  if (pid == 0)
+    {
+      unblock_child_signal ();
 
-        setsid ();
+      setsid ();
 
-        /* Emacs ignores SIGPIPE, but the child should not.  */
-        signal (SIGPIPE, SIG_DFL);
+      /* Emacs ignores SIGPIPE, but the child should not.  */
+      signal (SIGPIPE, SIG_DFL);
 
-        child_setup (filefd, fd1, fd_error, new_argv, 0, current_dir);
-      }
+      child_setup (filefd, fd_output, fd_error, new_argv, 0, current_dir);
+    }
 
 #endif /* not WINDOWSNT */
 
-    child_errno = errno;
+  child_errno = errno;
 
-    if (pid > 0)
-      {
-        if (INTEGERP (buffer))
-          record_deleted_pid (pid);
-        else
-          synch_process_pid = pid;
-      }
+  if (pid > 0)
+    {
+      synch_process_pid = pid;
 
-    unblock_child_signal ();
-    unblock_input ();
+      if (INTEGERP (buffer))
+        {
+          if (tempfile_index < 0)
+            record_deleted_pid (pid, Qnil);
+          else
+            {
+              eassert (1 < nargs);
+              record_deleted_pid (pid, args[1]);
+              clear_unwind_protect (tempfile_index);
+            }
+          synch_process_pid = 0;
+        }
+    }
 
-    /* The MSDOS case did this already.  */
-    if (fd_error >= 0)
-      emacs_close (fd_error);
-#endif /* not MSDOS */
+  unblock_child_signal ();
+  unblock_input ();
 
-    /* Close most of our file descriptors, but not fd0
-       since we will use that to read input from.  */
-    emacs_close (filefd);
-    if (fd_output >= 0)
-      emacs_close (fd_output);
-    if (fd1 >= 0 && fd1 != fd_error)
-      emacs_close (fd1);
-  }
+#endif /* not MSDOS */
 
   if (pid < 0)
     report_file_errno ("Doing vfork", Qnil, child_errno);
 
+  /* Close our file descriptors, except for callproc_fd[CALLPROC_PIPEREAD]
+     since we will use that to read input from.  */
+  for (i = 0; i < CALLPROC_FDS; i++)
+    if (i != CALLPROC_PIPEREAD && 0 <= callproc_fd[i])
+      {
+        emacs_close (callproc_fd[i]);
+        callproc_fd[i] = -1;
+      }
+  emacs_close (filefd);
+  clear_unwind_protect (count - 1);
+
   if (INTEGERP (buffer))
     return unbind_to (count, Qnil);
 
   if (BUFFERP (buffer))
     Fset_buffer (buffer);
 
-  if (NILP (buffer))
-    {
-      /* If BUFFER is nil, we must read process output once and then
-         discard it, so setup coding system but with nil.  */
-      setup_coding_system (Qnil, &process_coding);
-      process_coding.dst_multibyte = 0;
-    }
-  else
+  fd0 = callproc_fd[CALLPROC_PIPEREAD];
+
+  if (0 <= fd0)
     {
       Lisp_Object val, *args2;
 
@@ -762,13 +764,13 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
       setup_coding_system (val, &process_coding);
       process_coding.dst_multibyte
         = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
+      process_coding.src_multibyte = 0;
     }
-  process_coding.src_multibyte = 0;
 
   immediate_quit = 1;
   QUIT;
 
-  if (output_to_buffer)
+  if (0 <= fd0)
     {
       enum { CALLPROC_BUFFER_SIZE_MIN = 16 * 1024 };
       enum { CALLPROC_BUFFER_SIZE_MAX = 4 * CALLPROC_BUFFER_SIZE_MIN };
@@ -779,9 +781,8 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
       EMACS_INT total_read = 0;
       int carryover = 0;
       bool display_on_the_fly = display_p;
-      struct coding_system saved_coding;
+      struct coding_system saved_coding = process_coding;
 
-      saved_coding = process_coding;
       while (1)
         {
           /* Repeatedly read until we've filled as much as possible
@@ -812,58 +813,54 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
           /* Now NREAD is the total amount of data in the buffer.  */
           immediate_quit = 0;
 
-          if (!NILP (buffer))
-            {
-              if (NILP (BVAR (current_buffer, enable_multibyte_characters))
-                  && ! CODING_MAY_REQUIRE_DECODING (&process_coding))
-                insert_1_both (buf, nread, nread, 0, 1, 0);
-              else
-                {                       /* We have to decode the input.  */
-                  Lisp_Object curbuf;
-                  ptrdiff_t count1 = SPECPDL_INDEX ();
-
-                  XSETBUFFER (curbuf, current_buffer);
-                  /* We cannot allow after-change-functions be run
-                     during decoding, because that might modify the
-                     buffer, while we rely on process_coding.produced to
-                     faithfully reflect inserted text until we
-                     TEMP_SET_PT_BOTH below.  */
-                  specbind (Qinhibit_modification_hooks, Qt);
-                  decode_coding_c_string (&process_coding,
-                                          (unsigned char *) buf, nread, curbuf);
-                  unbind_to (count1, Qnil);
-                  if (display_on_the_fly
-                      && CODING_REQUIRE_DETECTION (&saved_coding)
-                      && ! CODING_REQUIRE_DETECTION (&process_coding))
-                    {
-                      /* We have detected some coding system.  But,
-                         there's a possibility that the detection was
-                         done by insufficient data.  So, we give up
-                         displaying on the fly.  */
-                      if (process_coding.produced > 0)
-                        del_range_2 (process_coding.dst_pos,
-                                     process_coding.dst_pos_byte,
-                                     process_coding.dst_pos
-                                     + process_coding.produced_char,
-                                     process_coding.dst_pos_byte
-                                     + process_coding.produced, 0);
-                      display_on_the_fly = 0;
-                      process_coding = saved_coding;
-                      carryover = nread;
-                      /* This is to make the above condition always
-                         fails in the future.  */
-                      saved_coding.common_flags
-                        &= ~CODING_REQUIRE_DETECTION_MASK;
-                      continue;
-                    }
-
-                  TEMP_SET_PT_BOTH (PT + process_coding.produced_char,
-                                    PT_BYTE + process_coding.produced);
-                  carryover = process_coding.carryover_bytes;
-                  if (carryover > 0)
-                    memcpy (buf, process_coding.carryover,
-                            process_coding.carryover_bytes);
+          if (NILP (BVAR (current_buffer, enable_multibyte_characters))
+              && ! CODING_MAY_REQUIRE_DECODING (&process_coding))
+            insert_1_both (buf, nread, nread, 0, 1, 0);
+          else
+            {                   /* We have to decode the input.  */
+              Lisp_Object curbuf;
+              ptrdiff_t count1 = SPECPDL_INDEX ();
+
+              XSETBUFFER (curbuf, current_buffer);
+              /* We cannot allow after-change-functions be run
+                 during decoding, because that might modify the
+                 buffer, while we rely on process_coding.produced to
+                 faithfully reflect inserted text until we
+                 TEMP_SET_PT_BOTH below.  */
+              specbind (Qinhibit_modification_hooks, Qt);
+              decode_coding_c_string (&process_coding,
+                                      (unsigned char *) buf, nread, curbuf);
+              unbind_to (count1, Qnil);
+              if (display_on_the_fly
+                  && CODING_REQUIRE_DETECTION (&saved_coding)
+                  && ! CODING_REQUIRE_DETECTION (&process_coding))
+                {
+                  /* We have detected some coding system, but the
+                     detection may have been via insufficient data.
+                     So give up displaying on the fly.  */
+                  if (process_coding.produced > 0)
+                    del_range_2 (process_coding.dst_pos,
+                                 process_coding.dst_pos_byte,
+                                 (process_coding.dst_pos
+                                  + process_coding.produced_char),
+                                 (process_coding.dst_pos_byte
+                                  + process_coding.produced),
+                                 0);
+                  display_on_the_fly = 0;
+                  process_coding = saved_coding;
+                  carryover = nread;
+                  /* Make the above condition always fail in the future.  */
+                  saved_coding.common_flags
+                    &= ~CODING_REQUIRE_DETECTION_MASK;
+                  continue;
                 }
+
+              TEMP_SET_PT_BOTH (PT + process_coding.produced_char,
+                                PT_BYTE + process_coding.produced);
+              carryover = process_coding.carryover_bytes;
+              if (carryover > 0)
+                memcpy (buf, process_coding.carryover,
+                        process_coding.carryover_bytes);
             }
 
           if (process_coding.mode & CODING_MODE_LAST_BLOCK)
@@ -882,7 +879,7 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
               first = 0;
               redisplay_preserve_echo_area (1);
               /* This variable might have been set to 0 for code
-                 detection.  In that case, we set it back to 1 because
+                 detection.  In that case, set it back to 1 because
                  we should have already detected a coding system.  */
               display_on_the_fly = 1;
             }
@@ -901,7 +898,7 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
 
 #ifndef MSDOS
   /* Wait for it to terminate, unless it already has.  */
-  wait_for_termination (pid, &status, !output_to_buffer);
+  wait_for_termination (pid, &status, fd0 < 0);
 #endif
 
   immediate_quit = 0;
@@ -931,37 +928,18 @@ usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  *
   return make_number (WEXITSTATUS (status));
 }
 
-static void
-delete_temp_file (Lisp_Object name)
-{
-  /* Suppress jka-compr handling, etc.  */
-  ptrdiff_t count = SPECPDL_INDEX ();
-  specbind (intern ("file-name-handler-alist"), Qnil);
-#ifdef WINDOWSNT
-  /* If this is called when the subprocess didn't exit yet, the
-     attempt to delete its input file will fail.  In that case, we
-     schedule the file for deletion when the subprocess exits.  This
-     is the 2nd part of handling this situation; see the call to
-     record_infile in call-process above, for the first part.  */
-  if (!internal_delete_file (name))
-    {
-      Lisp_Object encoded_file = ENCODE_FILE (name);
-
-      record_pending_deletion (SSDATA (encoded_file));
-    }
-#else
-  internal_delete_file (name);
-#endif
-  unbind_to (count, Qnil);
-}
-
 /* Create a temporary file suitable for storing the input data of
    call-process-region.  NARGS and ARGS are the same as for
-   call-process-region.  */
+   call-process-region.  Store into *FILENAME_STRING_PTR a Lisp string
+   naming the file, and return a file descriptor for reading.
+   Unwind-protect the file, so that the file descriptor will be closed
+   and the file removed when the caller unwinds the specpdl stack.  */
 
-static Lisp_Object
-create_temp_file (ptrdiff_t nargs, Lisp_Object *args)
+static int
+create_temp_file (ptrdiff_t nargs, Lisp_Object *args,
+                  Lisp_Object *filename_string_ptr)
 {
+  int fd;
   struct gcpro gcpro1;
   Lisp_Object filename_string;
   Lisp_Object val, start, end;
@@ -988,6 +966,7 @@ create_temp_file (ptrdiff_t nargs, Lisp_Object *args)
   {
     Lisp_Object pattern = Fexpand_file_name (Vtemp_file_name_pattern, tmpdir);
     char *tempfile;
+    ptrdiff_t count;
 
 #ifdef WINDOWSNT
     /* Cannot use the result of Fexpand_file_name, because it
@@ -1008,27 +987,14 @@ create_temp_file (ptrdiff_t nargs, Lisp_Object *args)
     GCPRO1 (filename_string);
     tempfile = SSDATA (filename_string);
 
-    {
-      int fd;
-
-#ifdef HAVE_MKOSTEMP
-      fd = mkostemp (tempfile, O_CLOEXEC);
-#elif defined HAVE_MKSTEMP
-      fd = mkstemp (tempfile);
-#else
-      errno = EEXIST;
-      mktemp (tempfile);
-      fd = *tempfile ? 0 : -1;
-#endif
-      if (fd < 0)
-        report_file_error ("Failed to open temporary file using pattern",
-                           pattern);
-#if defined HAVE_MKOSTEMP || defined HAVE_MKSTEMP
-      emacs_close (fd);
-#endif
-    }
-
-    record_unwind_protect (delete_temp_file, filename_string);
+    count = SPECPDL_INDEX ();
+    record_unwind_protect_nothing ();
+    fd = mkostemp (tempfile, O_CLOEXEC);
+    if (fd < 0)
+      report_file_error ("Failed to open temporary file using pattern",
+                         pattern);
+    set_unwind_protect (count, delete_temp_file, filename_string);
+    record_unwind_protect_int (close_file_unwind, fd);
   }
 
   start = args[0];
@@ -1059,15 +1025,20 @@ create_temp_file (ptrdiff_t nargs, Lisp_Object *args)
     /* POSIX lets mk[s]temp use "."; don't invoke jka-compr if we
        happen to get a ".Z" suffix.  */
     specbind (intern ("file-name-handler-alist"), Qnil);
-    Fwrite_region (start, end, filename_string, Qnil, Qlambda, Qnil, Qnil);
+    write_region (start, end, filename_string, Qnil, Qlambda, Qnil, Qnil, fd);
 
     unbind_to (count1, Qnil);
   }
 
+  if (lseek (fd, 0, SEEK_SET) < 0)
+    report_file_error ("Setting file position", filename_string);
+
   /* Note that Fcall_process takes care of binding
      coding-system-for-read.  */
 
-  RETURN_UNGCPRO (filename_string);
+  *filename_string_ptr = filename_string;
+  UNGCPRO;
+  return fd;
 }
 
 DEFUN ("call-process-region", Fcall_process_region, Scall_process_region,
@@ -1098,11 +1069,12 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
   (ptrdiff_t nargs, Lisp_Object *args)
 {
   struct gcpro gcpro1;
-  Lisp_Object infile;
+  Lisp_Object infile, val;
   ptrdiff_t count = SPECPDL_INDEX ();
   Lisp_Object start = args[0];
   Lisp_Object end = args[1];
   bool empty_input;
+  int fd;
 
   if (STRINGP (start))
     empty_input = SCHARS (start) == 0;
@@ -1116,7 +1088,17 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
       empty_input = XINT (start) == XINT (end);
     }
 
-  infile = empty_input ? Qnil : create_temp_file (nargs, args);
+  if (!empty_input)
+    fd = create_temp_file (nargs, args, &infile);
+  else
+    {
+      infile = Qnil;
+      fd = emacs_open (NULL_DEVICE, O_RDONLY, 0);
+      if (fd < 0)
+        report_file_error ("Opening null device", Qnil);
+      record_unwind_protect_int (close_file_unwind, fd);
+    }
+
   GCPRO1 (infile);
 
   if (nargs > 3 && !NILP (args[3]))
@@ -1134,7 +1116,8 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
     }
   args[1] = infile;
 
-  RETURN_UNGCPRO (unbind_to (count, Fcall_process (nargs, args)));
+  val = call_process (nargs, args, fd, empty_input ? -1 : count);
+  RETURN_UNGCPRO (unbind_to (count, val));
 }
 
 #ifndef WINDOWSNT
@@ -1210,23 +1193,21 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
      static variables as if the superior had done alloca and will be
      cleaned up in the usual way. */
   {
-    register char *temp;
-    size_t i; /* size_t, because ptrdiff_t might overflow here!  */
+    char *temp;
+    ptrdiff_t i;
 
     i = SBYTES (current_dir);
 #ifdef MSDOS
     /* MSDOS must have all environment variables malloc'ed, because
        low-level libc functions that launch subsidiary processes rely
        on that.  */
-    pwd_var = xmalloc (i + 6);
+    pwd_var = xmalloc (i + 5);
 #else
-    pwd_var = alloca (i + 6);
+    pwd_var = alloca (i + 5);
 #endif
     temp = pwd_var + 4;
     memcpy (pwd_var, "PWD=", 4);
-    memcpy (temp, SDATA (current_dir), i);
-    if (!IS_DIRECTORY_SEP (temp[i - 1])) temp[i++] = DIRECTORY_SEP;
-    temp[i] = 0;
+    strcpy (temp, SSDATA (current_dir));
 
 #ifndef DOS_NT
     /* We can't signal an Elisp error here; we're in a vfork.  Since
@@ -1695,6 +1676,11 @@ syms_of_callproc (void)
 #endif
   staticpro (&Vtemp_file_name_pattern);
 
+#ifdef MSDOS
+  synch_process_tempfile = make_number (0);
+  staticpro (&synch_process_tempfile);
+#endif
+
   DEFVAR_LISP ("shell-file-name", Vshell_file_name,
                doc: /* File name to load inferior shells from.
 Initialized from the SHELL environment variable, or to a system-dependent
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 7f5b99752fa..5a40790f87f 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -214,7 +214,7 @@ casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
   validate_region (&b, &e);
   start = XFASTINT (b);
   end = XFASTINT (e);
-  modify_region_1 (start, end, false);
+  modify_text (start, end);
   record_change (start, end - start);
   start_byte = CHAR_TO_BYTE (start);
 
diff --git a/src/casetab.c b/src/casetab.c
index 5f3c8db2869..b6b1c99c39f 100644
--- a/src/casetab.c
+++ b/src/casetab.c
@@ -247,15 +247,8 @@ init_casetab_once (void)
 {
   register int i;
   Lisp_Object down, up, eqv;
-  DEFSYM (Qcase_table, "case-table");
-
-  /* Intern this now in case it isn't already done.
-     Setting this variable twice is harmless.
-     But don't staticpro it here--that is done in alloc.c.  */
-  Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
 
-  /* Now we are ready to set up this property, so we can
-     create char tables.  */
+  DEFSYM (Qcase_table, "case-table");
   Fput (Qcase_table, Qchar_table_extra_slots, make_number (3));
 
   down = Fmake_char_table (Qcase_table, Qnil);
diff --git a/src/category.c b/src/category.c
index 30ffbd0890f..b28978fb721 100644
--- a/src/category.c
+++ b/src/category.c
@@ -460,14 +460,6 @@ init_category_once (void)
 {
   /* This has to be done here, before we call Fmake_char_table.  */
   DEFSYM (Qcategory_table, "category-table");
-
-  /* Intern this now in case it isn't already done.
-     Setting this variable twice is harmless.
-     But don't staticpro it here--that is done in alloc.c.  */
-  Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
-
-  /* Now we are ready to set up this property, so we can
-     create category tables.  */
   Fput (Qcategory_table, Qchar_table_extra_slots, make_number (2));
 
   Vstandard_category_table = Fmake_char_table (Qcategory_table, Qnil);
diff --git a/src/character.c b/src/character.c
index b2caaa290af..6fefb6e8824 100644
--- a/src/character.c
+++ b/src/character.c
@@ -174,11 +174,14 @@ string_char (const unsigned char *p, const unsigned char **advanced, int *len)
 
   if (*p < 0x80 || ! (*p & 0x20) || ! (*p & 0x10))
     {
+      /* 1-, 2-, and 3-byte sequences can be handled by the macro.  */
       c = STRING_CHAR_ADVANCE (p);
     }
   else if (! (*p & 0x08))
     {
-      c = ((((p)[0] & 0xF) << 18)
+      /* A 4-byte sequence of this form:
+         11110xxx 10xxxxxx 10xxxxxx 10xxxxxx  */
+      c = ((((p)[0] & 0x7) << 18)
            | (((p)[1] & 0x3F) << 12)
            | (((p)[2] & 0x3F) << 6)
            | ((p)[3] & 0x3F));
@@ -186,7 +189,14 @@ string_char (const unsigned char *p, const unsigned char **advanced, int *len)
     }
   else
     {
-      c = ((((p)[1] & 0x3F) << 18)
+      /* A 5-byte sequence of this form:
+
+         111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
+
+         Note that the top 4 `x's are always 0, so shifting p[1] can
+         never exceed the maximum valid character codepoint. */
+      c = (/* (((p)[0] & 0x3) << 24) ... always 0, so no need to shift. */
+           (((p)[1] & 0x3F) << 18)
            | (((p)[2] & 0x3F) << 12)
            | (((p)[3] & 0x3F) << 6)
            | ((p)[4] & 0x3F));
@@ -1062,10 +1072,6 @@ A char-table for width (columns) of each character.  */);
                doc: /* Char table of script symbols.
 It has one extra slot whose value is a list of script symbols.  */);
 
-  /* Intern this now in case it isn't already done.
-     Setting this variable twice is harmless.
-     But don't staticpro it here--that is done in alloc.c.  */
-  Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
   DEFSYM (Qchar_script_table, "char-script-table");
   Fput (Qchar_script_table, Qchar_table_extra_slots, make_number (1));
   Vchar_script_table = Fmake_char_table (Qchar_script_table, Qnil);
diff --git a/src/cmds.c b/src/cmds.c
index 3ebad50184a..ee3be79a0ab 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -86,6 +86,7 @@ DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "^p",
        doc: /* Move point N characters forward (backward if N is negative).
 On reaching end or beginning of buffer, stop and signal error.
 Interactively, N is the numeric prefix argument.
+If N is omitted or nil, move point 1 character forward.
 
 Depending on the bidirectional context, the movement may be to the
 right or to the left on the screen.  This is in contrast with
@@ -99,6 +100,7 @@ DEFUN ("backward-char", Fbackward_char, Sbackward_char, 0, 1, "^p",
        doc: /* Move point N characters backward (forward if N is negative).
 On attempt to pass beginning or end of buffer, stop and signal error.
 Interactively, N is the numeric prefix argument.
+If N is omitted or nil, move point 1 character backward.
 
 Depending on the bidirectional context, the movement may be to the
 right or to the left on the screen.  This is in contrast with
@@ -119,9 +121,7 @@ With positive N, a non-empty line at the end counts as one line
 successfully moved (for the return value).  */)
   (Lisp_Object n)
 {
-  ptrdiff_t opoint = PT, opoint_byte = PT_BYTE;
-  ptrdiff_t pos, pos_byte;
-  EMACS_INT count, shortage;
+  ptrdiff_t opoint = PT, pos, pos_byte, shortage, count;
 
   if (NILP (n))
     count = 1;
@@ -132,16 +132,12 @@ successfully moved (for the return value).  */)
     }
 
   if (count <= 0)
-    shortage = scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, count - 1, 1);
+    pos = find_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, count - 1,
+                        &shortage, &pos_byte, 1);
   else
-    shortage = scan_newline (PT, PT_BYTE, ZV, ZV_BYTE, count, 1);
-
-  /* Since scan_newline does TEMP_SET_PT_BOTH,
-     and we want to set PT "for real",
-     go back to the old point and then come back here.  */
-  pos = PT;
-  pos_byte = PT_BYTE;
-  TEMP_SET_PT_BOTH (opoint, opoint_byte);
+    pos = find_newline (PT, PT_BYTE, ZV, ZV_BYTE, count,
+                        &shortage, &pos_byte, 1);
+
   SET_PT_BOTH (pos, pos_byte);
 
   if (shortage > 0
diff --git a/src/coding.c b/src/coding.c
index 5b637627763..c10fb375672 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -10814,11 +10814,6 @@ syms_of_coding (void)
   Fput (Qcoding_system_error, Qerror_message,
         build_pure_c_string ("Invalid coding system"));
 
-  /* Intern this now in case it isn't already done.
-     Setting this variable twice is harmless.
-     But don't staticpro it here--that is done in alloc.c.  */
-  Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
-
   DEFSYM (Qtranslation_table, "translation-table");
   Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (2));
   DEFSYM (Qtranslation_table_id, "translation-table-id");
diff --git a/src/coding.h b/src/coding.h
index 7b7078e06fa..2c01a05d197 100644
--- a/src/coding.h
+++ b/src/coding.h
@@ -378,8 +378,6 @@ struct emacs_mule_spec
   struct composition_status cmp_status;
 };
 
-struct ccl_spec;
-
 struct undecided_spec
 {
   /* Inhibit null byte detection.  1 means always inhibit,
diff --git a/src/composite.h b/src/composite.h
index 53665b36bd1..df170093797 100644
--- a/src/composite.h
+++ b/src/composite.h
@@ -25,6 +25,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifndef EMACS_COMPOSITE_H
 #define EMACS_COMPOSITE_H
 
+#include "font.h"
+
 INLINE_HEADER_BEGIN
 #ifndef COMPOSITE_INLINE
 # define COMPOSITE_INLINE INLINE
@@ -312,10 +314,6 @@ enum lglyph_indices
 #define LGLYPH_WADJUST(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
                            ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 2)) : 0)
 
-struct composition_it;
-struct face;
-struct font_metrics;
-
 extern Lisp_Object composition_gstring_put_cache (Lisp_Object, ptrdiff_t);
 extern Lisp_Object composition_gstring_from_id (ptrdiff_t);
 extern bool composition_gstring_p (Lisp_Object);
diff --git a/src/data.c b/src/data.c
index d1e43ac1b5f..9f4bd1f1c02 100644
--- a/src/data.c
+++ b/src/data.c
@@ -981,19 +981,14 @@ store_symval_forwarding (union Lisp_Fwd *valcontents, register Lisp_Object newva
                         - (char *) &buffer_defaults);
           int idx = PER_BUFFER_IDX (offset);
 
-          Lisp_Object tail;
+          Lisp_Object tail, buf;
 
           if (idx <= 0)
             break;
 
-          for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
+          FOR_EACH_LIVE_BUFFER (tail, buf)
             {
-              Lisp_Object lbuf;
-              struct buffer *b;
-
-              lbuf = Fcdr (XCAR (tail));
-              if (!BUFFERP (lbuf)) continue;
-              b = XBUFFER (lbuf);
+              struct buffer *b = XBUFFER (buf);
 
               if (! PER_BUFFER_VALUE_P (b, idx))
                 set_per_buffer_value (b, offset, newval);
@@ -1980,7 +1975,7 @@ If the current binding is global (the default), the value is nil.  */)
       {
         union Lisp_Fwd *valcontents = SYMBOL_FWD (sym);
         if (KBOARD_OBJFWDP (valcontents))
-          return Fframe_terminal (Fselected_frame ());
+          return Fframe_terminal (selected_frame);
         else if (!BUFFER_OBJFWDP (valcontents))
           return Qnil;
       }
diff --git a/src/decompress.c b/src/decompress.c
new file mode 100644
index 00000000000..dc9f4b72d93
--- /dev/null
+++ b/src/decompress.c
@@ -0,0 +1,232 @@
+/* Interface to zlib.
+   Copyright (C) 2013 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <config.h>
+
+#ifdef HAVE_ZLIB
+
+#include <zlib.h>
+
+#include "lisp.h"
+#include "character.h"
+#include "buffer.h"
+
+#include <verify.h>
+
+static Lisp_Object Qzlib_dll;
+
+#ifdef WINDOWSNT
+#include <windows.h>
+#include "w32.h"
+
+/* Macro for defining functions that will be loaded from the zlib DLL.  */
+#define DEF_ZLIB_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
+
+/* Macro for loading zlib functions from the library.  */
+#define LOAD_ZLIB_FN(lib,func) {                                        \
+    fn_##func = (void *) GetProcAddress (lib, #func);                   \
+    if (!fn_##func) return false;                                       \
+  }
+
+DEF_ZLIB_FN (int, inflateInit2_,
+             (z_streamp strm, int  windowBits, const char *version, int stream_size));
+
+DEF_ZLIB_FN (int, inflate,
+             (z_streamp strm, int flush));
+
+DEF_ZLIB_FN (int, inflateEnd,
+             (z_streamp strm));
+
+static bool zlib_initialized;
+
+static bool
+init_zlib_functions (void)
+{
+  HMODULE library = w32_delayed_load (Qzlib_dll);
+
+  if (!library)
+    {
+      message1 ("zlib library not found");
+      return false;
+    }
+
+  LOAD_ZLIB_FN (library, inflateInit2_);
+  LOAD_ZLIB_FN (library, inflate);
+  LOAD_ZLIB_FN (library, inflateEnd);
+  return true;
+}
+
+#define fn_inflateInit2(strm, windowBits) \
+        fn_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+
+#else /* !WINDOWSNT */
+
+#define fn_inflateInit2         inflateInit2
+#define fn_inflate              inflate
+#define fn_inflateEnd           inflateEnd
+
+#endif  /* WINDOWSNT */
+
+
+struct decompress_unwind_data
+{
+  ptrdiff_t old_point, start, nbytes;
+  z_stream *stream;
+};
+
+static void
+unwind_decompress (void *ddata)
+{
+  struct decompress_unwind_data *data = ddata;
+  fn_inflateEnd (data->stream);
+
+  /* Delete any uncompressed data already inserted on error.  */
+  if (data->start)
+    del_range (data->start, data->start + data->nbytes);
+
+  /* Put point where it was, or if the buffer has shrunk because the
+     compressed data is bigger than the uncompressed, at
+     point-max.  */
+  SET_PT (min (data->old_point, ZV));
+}
+
+DEFUN ("zlib-available-p", Fzlib_available_p, Szlib_available_p, 0, 0, 0,
+       doc: /* Return t if zlib decompression is available in this instance of Emacs.  */)
+     (void)
+{
+#ifdef WINDOWSNT
+  Lisp_Object found = Fassq (Qzlib_dll, Vlibrary_cache);
+  if (CONSP (found))
+    return XCDR (found);
+  else
+    {
+      Lisp_Object status;
+      zlib_initialized = init_zlib_functions ();
+      status = zlib_initialized ? Qt : Qnil;
+      Vlibrary_cache = Fcons (Fcons (Qzlib_dll, status), Vlibrary_cache);
+      return status;
+    }
+#else
+  return Qt;
+#endif
+}
+
+DEFUN ("zlib-decompress-region", Fzlib_decompress_region,
+       Szlib_decompress_region,
+       2, 2, 0,
+       doc: /* Decompress a gzip- or zlib-compressed region.
+Replace the text in the region by the decompressed data.
+On failure, return nil and leave the data in place.
+This function can be called only in unibyte buffers.  */)
+  (Lisp_Object start, Lisp_Object end)
+{
+  ptrdiff_t istart, iend, pos_byte;
+  z_stream stream;
+  int inflate_status;
+  struct decompress_unwind_data unwind_data;
+  ptrdiff_t count = SPECPDL_INDEX ();
+
+  validate_region (&start, &end);
+
+  if (! NILP (BVAR (current_buffer, enable_multibyte_characters)))
+    error ("This function can be called only in unibyte buffers");
+
+#ifdef WINDOWSNT
+  if (!zlib_initialized)
+    zlib_initialized = init_zlib_functions ();
+  if (!zlib_initialized)
+    return Qnil;
+#endif
+
+  /* This is a unibyte buffer, so character positions and bytes are
+     the same.  */
+  istart = XINT (start);
+  iend = XINT (end);
+  move_gap_both (iend, iend);
+
+  stream.zalloc = Z_NULL;
+  stream.zfree = Z_NULL;
+  stream.opaque = Z_NULL;
+  stream.avail_in = 0;
+  stream.next_in = Z_NULL;
+
+  /* The magic number 32 apparently means "autodetect both the gzip and
+     zlib formats" according to zlib.h.  */
+  if (fn_inflateInit2 (&stream, MAX_WBITS + 32) != Z_OK)
+    return Qnil;
+
+  unwind_data.start = iend;
+  unwind_data.stream = &stream;
+  unwind_data.old_point = PT;
+  unwind_data.nbytes = 0;
+  record_unwind_protect_ptr (unwind_decompress, &unwind_data);
+
+  /* Insert the decompressed data at the end of the compressed data.  */
+  SET_PT (iend);
+
+  pos_byte = istart;
+
+  /* Keep calling 'inflate' until it reports an error or end-of-input.  */
+  do
+    {
+      /* Maximum number of bytes that one 'inflate' call should read and write.
+         Do not make avail_out too large, as that might unduly delay C-g.
+         zlib requires that avail_in and avail_out not exceed UINT_MAX.  */
+      ptrdiff_t avail_in = min (iend - pos_byte, UINT_MAX);
+      int avail_out = 16 * 1024;
+      int decompressed;
+
+      if (GAP_SIZE < avail_out)
+        make_gap (avail_out - GAP_SIZE);
+      stream.next_in = BYTE_POS_ADDR (pos_byte);
+      stream.avail_in = avail_in;
+      stream.next_out = GPT_ADDR;
+      stream.avail_out = avail_out;
+      inflate_status = fn_inflate (&stream, Z_NO_FLUSH);
+      pos_byte += avail_in - stream.avail_in;
+      decompressed = avail_out - stream.avail_out;
+      insert_from_gap (decompressed, decompressed, 0);
+      unwind_data.nbytes += decompressed;
+      QUIT;
+    }
+  while (inflate_status == Z_OK);
+
+  if (inflate_status != Z_STREAM_END)
+    return unbind_to (count, Qnil);
+
+  unwind_data.start = 0;
+
+  /* Delete the compressed data.  */
+  del_range (istart, iend);
+
+  return unbind_to (count, Qt);
+}
+
+
+/***********************************************************************
+                            Initialization
+ ***********************************************************************/
+void
+syms_of_decompress (void)
+{
+  DEFSYM (Qzlib_dll, "zlib");
+  defsubr (&Szlib_decompress_region);
+  defsubr (&Szlib_available_p);
+}
+
+#endif /* HAVE_ZLIB */
diff --git a/src/dispextern.h b/src/dispextern.h
index d747700fd66..947e50fa4dd 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -83,7 +83,7 @@ typedef XImagePtr XImagePtr_or_DC;
 #endif
 
 #ifdef HAVE_WINDOW_SYSTEM
-# include "systime.h"
+# include <time.h>
 #endif
 
 #ifndef HAVE_WINDOW_SYSTEM
@@ -95,18 +95,17 @@ typedef int Cursor;
 #define NativeRectangle int
 #endif
 
-/* Structure forward declarations.  Some are here because function
-   prototypes below reference structure types before their definition
-   in this file.  Some are here because not every file including
-   dispextern.h also includes frame.h and windows.h.  */
-
-struct glyph;
-struct glyph_row;
-struct glyph_matrix;
-struct glyph_pool;
-struct frame;
-struct window;
+/* Text cursor types.  */
 
+enum text_cursor_kinds
+{
+  DEFAULT_CURSOR = -2,
+  NO_CURSOR = -1,
+  FILLED_BOX_CURSOR,
+  HOLLOW_BOX_CURSOR,
+  BAR_CURSOR,
+  HBAR_CURSOR
+};
 
 /* Values returned from coordinates_in_window.  */
 
@@ -224,8 +223,16 @@ struct text_pos
 /* Set text position POS from marker MARKER.  */
 
 #define SET_TEXT_POS_FROM_MARKER(POS, MARKER)           \
-     (CHARPOS (POS) = marker_position ((MARKER)),       \
-      BYTEPOS (POS) = marker_byte_position ((MARKER)))
+  (CHARPOS (POS) = marker_position (MARKER),            \
+   BYTEPOS (POS) = marker_byte_position (MARKER))
+
+/* Like above, but clip POS within accessible range.  */
+
+#define CLIP_TEXT_POS_FROM_MARKER(POS, MARKER)          \
+  (CHARPOS (POS) = clip_to_bounds                       \
+   (BEGV, marker_position (MARKER), ZV),                \
+   BYTEPOS (POS) = clip_to_bounds                       \
+   (BEGV_BYTE, marker_byte_position (MARKER), ZV_BYTE))
 
 /* Set marker MARKER from text position POS.  */
 
@@ -752,11 +759,12 @@ void check_matrix_pointer_lossage (struct glyph_matrix *);
                              Glyph Rows
  ***********************************************************************/
 
-/* Area in window glyph matrix.  If values are added or removed, the
-   function mark_object in alloc.c has to be changed.  */
+/* Area in window glyph matrix.  If values are added or removed,
+   the function mark_glyph_matrix in alloc.c may need to be changed.  */
 
 enum glyph_row_area
 {
+  ANY_AREA = -1,
   LEFT_MARGIN_AREA,
   TEXT_AREA,
   RIGHT_MARGIN_AREA,
@@ -1197,16 +1205,6 @@ extern bool fonts_changed_p;
 
 extern struct glyph space_glyph;
 
-/* Window being updated by update_window.  This is non-null as long as
-   update_window has not finished, and null otherwise.  */
-
-extern struct window *updated_window;
-
-/* Glyph row and area updated by update_window_line.  */
-
-extern struct glyph_row *updated_row;
-extern int updated_area;
-
 /* Non-zero means last display completed.  Zero means it was
    preempted.  */
 
@@ -2678,8 +2676,57 @@ enum move_operation_enum
   MOVE_TO_POS = 0x08
 };
 
+/***********************************************************************
+                            Mouse Highlight
+ ***********************************************************************/
+
+/* Structure to hold mouse highlight data.  */
+
+typedef struct {
+  /* These variables describe the range of text currently shown in its
+     mouse-face, together with the window they apply to.  As long as
+     the mouse stays within this range, we need not redraw anything on
+     its account.  Rows and columns are glyph matrix positions in
+     MOUSE_FACE_WINDOW.  */
+  int mouse_face_beg_row, mouse_face_beg_col, mouse_face_beg_x;
+  int mouse_face_end_row, mouse_face_end_col, mouse_face_end_x;
+  Lisp_Object mouse_face_window;
+  int mouse_face_face_id;
+  Lisp_Object mouse_face_overlay;
+
+  /* FRAME and X, Y position of mouse when last checked for
+     highlighting.  X and Y can be negative or out of range for the frame.  */
+  struct frame *mouse_face_mouse_frame;
+  int mouse_face_mouse_x, mouse_face_mouse_y;
+
+  /* Nonzero if part of the text currently shown in
+     its mouse-face is beyond the window end.  */
+  unsigned mouse_face_past_end : 1;
+
+  /* Nonzero means defer mouse-motion highlighting.  */
+  unsigned mouse_face_defer : 1;
+
+  /* Nonzero means that the mouse highlight should not be shown.  */
+  unsigned mouse_face_hidden : 1;
+} Mouse_HLInfo;
+
+DISPEXTERN_INLINE void
+reset_mouse_highlight (Mouse_HLInfo *hlinfo)
+{
+
+    hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
+    hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
+    hlinfo->mouse_face_mouse_x = hlinfo->mouse_face_mouse_y = 0;
+    hlinfo->mouse_face_beg_x = hlinfo->mouse_face_end_x = 0;
+    hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
+    hlinfo->mouse_face_mouse_frame = NULL;
+    hlinfo->mouse_face_window = Qnil;
+    hlinfo->mouse_face_overlay = Qnil;
+    hlinfo->mouse_face_past_end = 0;
+    hlinfo->mouse_face_hidden = 0;
+    hlinfo->mouse_face_defer = 0;
+}
 
-
 /***********************************************************************
                    Window-based redisplay interface
  ***********************************************************************/
@@ -2718,12 +2765,17 @@ struct redisplay_interface
 
   /* Write or insert LEN glyphs from STRING at the nominal output
      position.  */
-  void (*write_glyphs) (struct glyph *string, int len);
-  void (*insert_glyphs) (struct glyph *start, int len);
+  void (*write_glyphs) (struct window *w, struct glyph_row *row,
+                        struct glyph *string, enum glyph_row_area area,
+                        int len);
+  void (*insert_glyphs) (struct window *w, struct glyph_row *row,
+                         struct glyph *start, enum glyph_row_area area,
+                         int len);
 
   /* Clear from nominal output position to X.  X < 0 means clear
      to right end of display.  */
-  void (*clear_end_of_line) (int x);
+  void (*clear_end_of_line) (struct window *w, struct glyph_row *row,
+                             enum glyph_row_area area, int x);
 
   /* Function to call to scroll the display as described by RUN on
      window W.  */
@@ -2732,7 +2784,8 @@ struct redisplay_interface
   /* Function to call after a line in a display has been completely
      updated.  Used to draw truncation marks and alike.  DESIRED_ROW
      is the desired row which has been updated.  */
-  void (*after_update_window_line_hook) (struct glyph_row *desired_row);
+  void (*after_update_window_line_hook) (struct window *w,
+                                         struct glyph_row *desired_row);
 
   /* Function to call before beginning to update window W in
      window-based redisplay.  */
@@ -2743,13 +2796,8 @@ struct redisplay_interface
      MOUSE_FACE_OVERWRITTEN_P non-zero means that some lines in W
      that contained glyphs in mouse-face were overwritten, so we
      have to update the mouse highlight.  */
-  void (*update_window_end_hook) (struct window *w, int cursor_on_p,
-                                  int mouse_face_overwritten_p);
-
-  /* Move cursor to row/column position VPOS/HPOS, pixel coordinates
-     Y/X. HPOS/VPOS are window-relative row and column numbers and X/Y
-     are window-relative pixel positions.  */
-  void (*cursor_to) (int vpos, int hpos, int y, int x);
+  void (*update_window_end_hook) (struct window *w, bool cursor_on_p,
+                                  bool mouse_face_overwritten_p);
 
   /* Flush the display of frame F.  For X, this is XFlush.  */
   void (*flush_display) (struct frame *f);
@@ -2803,10 +2851,10 @@ struct redisplay_interface
    0, don't draw cursor.  If ACTIVE_P is 1, system caret
    should track this cursor (when applicable).  */
   void (*draw_window_cursor) (struct window *w,
-                              struct glyph_row *glyph_row,
-                              int x, int y,
-                              int cursor_type, int cursor_width,
-                              int on_p, int active_p);
+                              struct glyph_row *glyph_row,
+                              int x, int y,
+                              enum text_cursor_kinds cursor_type,
+                              int cursor_width, bool on_p, bool active_p);
 
 /* Draw vertical border for window W from (X,Y_0) to (X,Y_1).  */
   void (*draw_vertical_window_border) (struct window *w,
@@ -2829,11 +2877,6 @@ struct redisplay_interface
 
 #ifdef HAVE_WINDOW_SYSTEM
 
-/* Structure forward declarations.  */
-
-struct image;
-
-
 /* Each image format (JPEG, TIFF, ...) supported is described by
    a structure of the type below.  */
 
@@ -2870,7 +2913,7 @@ struct image
 {
   /* The time in seconds at which the image was last displayed.  Set
      in prepare_image_for_display.  */
-  EMACS_TIME timestamp;
+  struct timespec timestamp;
 
   /* Pixmaps of the image.  */
   Pixmap pixmap, mask;
@@ -3124,14 +3167,15 @@ int resize_mini_window (struct window *, int);
 void set_vertical_scroll_bar (struct window *);
 #endif
 int try_window (Lisp_Object, struct text_pos, int);
-void window_box (struct window *, int, int *, int *, int *, int *);
+void window_box (struct window *, enum glyph_row_area,
+                 int *, int *, int *, int *);
 int window_box_height (struct window *);
 int window_text_bottom_y (struct window *);
-int window_box_width (struct window *, int);
-int window_box_left (struct window *, int);
-int window_box_left_offset (struct window *, int);
-int window_box_right (struct window *, int);
-int window_box_right_offset (struct window *, int);
+int window_box_width (struct window *, enum glyph_row_area);
+int window_box_left (struct window *, enum glyph_row_area);
+int window_box_left_offset (struct window *, enum glyph_row_area);
+int window_box_right (struct window *, enum glyph_row_area);
+int window_box_right_offset (struct window *, enum glyph_row_area);
 int estimate_mode_line_height (struct frame *, enum face_id);
 void pixel_to_glyph_coords (struct frame *, int, int, int *, int *,
                             NativeRectangle *, int);
@@ -3182,12 +3226,12 @@ extern void x_get_glyph_overhangs (struct glyph *, struct frame *,
                                    int *, int *);
 extern void x_produce_glyphs (struct it *);
 
-extern void x_write_glyphs (struct glyph *, int);
-extern void x_insert_glyphs (struct glyph *, int len);
-extern void x_clear_end_of_line (int);
-
-extern struct cursor_pos output_cursor;
-
+extern void x_write_glyphs (struct window *, struct glyph_row *,
+                            struct glyph *, enum glyph_row_area, int);
+extern void x_insert_glyphs (struct window *, struct glyph_row *,
+                             struct glyph *, enum glyph_row_area, int);
+extern void x_clear_end_of_line (struct window *, struct glyph_row *,
+                                 enum glyph_row_area, int);
 extern void x_fix_overlapping_area (struct window *, struct glyph_row *,
                                     enum glyph_row_area, int);
 extern void draw_phys_cursor_glyph (struct window *,
@@ -3196,13 +3240,8 @@ extern void draw_phys_cursor_glyph (struct window *,
 extern void get_phys_cursor_geometry (struct window *, struct glyph_row *,
                                       struct glyph *, int *, int *, int *);
 extern void erase_phys_cursor (struct window *);
-extern void display_and_set_cursor (struct window *,
-                                    int, int, int, int, int);
-
-extern void set_output_cursor (struct cursor_pos *);
-extern void x_cursor_to (int, int, int, int);
-
-extern void x_update_cursor (struct frame *, int);
+extern void display_and_set_cursor (struct window *, bool, int, int, int, int);
+extern void x_update_cursor (struct frame *, bool);
 extern void x_clear_cursor (struct window *);
 extern void x_draw_vertical_border (struct window *w);
 
@@ -3365,8 +3404,6 @@ extern frame_parm_handler x_frame_parm_handlers[];
 extern void start_hourglass (void);
 extern void cancel_hourglass (void);
 extern int hourglass_shown_p;
-
-struct atimer;                  /* Defined in atimer.h.  */
 /* If non-null, an asynchronous timer that, when it expires, displays
    an hourglass cursor on all frames.  */
 extern struct atimer *hourglass_atimer;
diff --git a/src/dispnew.c b/src/dispnew.c
index 522a0e6a30d..1d7cad13e6d 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -49,12 +49,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include TERM_HEADER
 #endif /* HAVE_WINDOW_SYSTEM */
 
-/* Include systime.h after xterm.h to avoid double inclusion of time.h.  */
-
-#include "systime.h"
 #include <errno.h>
 
 #include <fpending.h>
+#include <timespec.h>
 
 #if defined (HAVE_TERM_H) && defined (GNU_LINUX)
 #include <term.h>               /* for tgetent */
@@ -135,25 +133,20 @@ struct frame *last_nonminibuf_frame;
 
 static bool delayed_size_change;
 
-/* Updated window if != 0.  Set by update_window.  */
-
-struct window *updated_window;
-
-/* Glyph row updated in update_window_line, and area that is updated.  */
-
-struct glyph_row *updated_row;
-int updated_area;
-
 /* A glyph for a space.  */
 
 struct glyph space_glyph;
 
+#if defined GLYPH_DEBUG && defined ENABLE_CHECKING
+
 /* Counts of allocated structures.  These counts serve to diagnose
    memory leaks and double frees.  */
 
 static int glyph_matrix_count;
 static int glyph_pool_count;
 
+#endif /* GLYPH_DEBUG and ENABLE_CHECKING */
+
 /* If non-null, the frame whose frame matrices are manipulated.  If
    null, window matrices are worked on.  */
 
@@ -307,9 +300,11 @@ new_glyph_matrix (struct glyph_pool *pool)
 {
   struct glyph_matrix *result = xzalloc (sizeof *result);
 
+#if defined GLYPH_DEBUG && defined ENABLE_CHECKING
   /* Increment number of allocated matrices.  This count is used
      to detect memory leaks.  */
   ++glyph_matrix_count;
+#endif
 
   /* Set pool and return.  */
   result->pool = pool;
@@ -319,10 +314,10 @@ new_glyph_matrix (struct glyph_pool *pool)
 
 /* Free glyph matrix MATRIX.  Passing in a null MATRIX is allowed.
 
-   The global counter glyph_matrix_count is decremented when a matrix
-   is freed.  If the count gets negative, more structures were freed
-   than allocated, i.e. one matrix was freed more than once or a bogus
-   pointer was passed to this function.
+   If GLYPH_DEBUG and ENABLE_CHECKING are in effect, the global counter
+   glyph_matrix_count is decremented when a matrix is freed.  If the count
+   gets negative, more structures were freed than allocated, i.e. one matrix
+   was freed more than once or a bogus pointer was passed to this function.
 
    If MATRIX->pool is null, this means that the matrix manages its own
    glyph memory---this is done for matrices on X frames.  Freeing the
@@ -335,10 +330,12 @@ free_glyph_matrix (struct glyph_matrix *matrix)
     {
       int i;
 
+#if defined GLYPH_DEBUG && defined ENABLE_CHECKING
       /* Detect the case that more matrices are freed than were
          allocated.  */
-      if (--glyph_matrix_count < 0)
-        emacs_abort ();
+      --glyph_matrix_count;
+      eassert (glyph_matrix_count >= 0);
+#endif
 
       /* Free glyph memory if MATRIX owns it.  */
       if (matrix->pool == NULL)
@@ -355,25 +352,19 @@ free_glyph_matrix (struct glyph_matrix *matrix)
 /* Return the number of glyphs to reserve for a marginal area of
    window W.  TOTAL_GLYPHS is the number of glyphs in a complete
    display line of window W.  MARGIN gives the width of the marginal
-   area in canonical character units.  MARGIN should be an integer
-   or a float.  */
+   area in canonical character units.  */
 
 static int
-margin_glyphs_to_reserve (struct window *w, int total_glyphs, Lisp_Object margin)
+margin_glyphs_to_reserve (struct window *w, int total_glyphs, int margin)
 {
-  int n;
-
-  if (NUMBERP (margin))
+  if (margin > 0)
     {
       int width = w->total_cols;
-      double d = max (0, XFLOATINT (margin));
+      double d = max (0, margin);
       d = min (width / 2 - 1, d);
-      n = (int) ((double) total_glyphs / width * d);
+      return (int) ((double) total_glyphs / width * d);
     }
-  else
-    n = 0;
-
-  return n;
+  return 0;
 }
 
 /* Return true if ROW's hash value is correct.
@@ -422,7 +413,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
      Get W's size.  */
   if (w)
     {
-      window_box (w, -1, 0, 0, &window_width, &window_height);
+      window_box (w, ANY_AREA, 0, 0, &window_width, &window_height);
 
       header_line_p = WINDOW_WANTS_HEADER_LINE_P (w);
       header_line_changed_p = header_line_p != matrix->header_line_p;
@@ -600,8 +591,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
 
               /* Window end is invalid, if inside of the rows that
                  are invalidated below.  */
-              if (INTEGERP (w->window_end_vpos)
-                  && XFASTINT (w->window_end_vpos) >= i)
+              if (w->window_end_vpos >= i)
                 w->window_end_valid = 0;
 
               while (i < matrix->nrows)
@@ -1310,38 +1300,41 @@ row_equal_p (struct glyph_row *a, struct glyph_row *b, bool mouse_face_p)
      See dispextern.h for an overall explanation of glyph pools.
  ***********************************************************************/
 
-/* Allocate a glyph_pool structure.  The structure returned is
-   initialized with zeros.  The global variable glyph_pool_count is
-   incremented for each pool allocated.  */
+/* Allocate a glyph_pool structure.  The structure returned is initialized
+   with zeros.  If GLYPH_DEBUG and ENABLE_CHECKING are in effect, the global
+   variable glyph_pool_count is incremented for each pool allocated.  */
 
 static struct glyph_pool *
 new_glyph_pool (void)
 {
   struct glyph_pool *result = xzalloc (sizeof *result);
 
+#if defined GLYPH_DEBUG && defined ENABLE_CHECKING
   /* For memory leak and double deletion checking.  */
   ++glyph_pool_count;
+#endif
 
   return result;
 }
 
 
 /* Free a glyph_pool structure POOL.  The function may be called with
-   a null POOL pointer.  The global variable glyph_pool_count is
-   decremented with every pool structure freed.  If this count gets
-   negative, more structures were freed than allocated, i.e. one
-   structure must have been freed more than once or a bogus pointer
-   was passed to free_glyph_pool.  */
+   a null POOL pointer.  If GLYPH_DEBUG and ENABLE_CHECKING are in effect,
+   global variable glyph_pool_count is decremented with every pool structure
+   freed.  If this count gets negative, more structures were freed than
+   allocated, i.e. one structure must have been freed more than once or
+   a bogus pointer was passed to free_glyph_pool.  */
 
 static void
 free_glyph_pool (struct glyph_pool *pool)
 {
   if (pool)
     {
+#if defined GLYPH_DEBUG && defined ENABLE_CHECKING
       /* More freed than allocated?  */
       --glyph_pool_count;
       eassert (glyph_pool_count >= 0);
-
+#endif
       xfree (pool->glyphs);
       xfree (pool);
     }
@@ -1860,7 +1853,7 @@ showing_window_margins_p (struct window *w)
           if (showing_window_margins_p (XWINDOW (w->contents)))
             return 1;
         }
-      else if (!NILP (w->left_margin_cols) || !NILP (w->right_margin_cols))
+      else if (w->left_margin_cols > 0 || w->right_margin_cols > 0)
         return 1;
 
       w = NILP (w->next) ? 0 : XWINDOW (w->next);
@@ -2254,11 +2247,11 @@ check_glyph_memory (void)
   FOR_EACH_FRAME (tail, frame)
     free_glyphs (XFRAME (frame));
 
+#if defined GLYPH_DEBUG && defined ENABLE_CHECKING
   /* Check that nothing is left allocated.  */
-  if (glyph_matrix_count)
-    emacs_abort ();
-  if (glyph_pool_count)
-    emacs_abort ();
+  eassert (glyph_matrix_count == 0);
+  eassert (glyph_pool_count == 0);
+#endif
 }
 
 
@@ -2275,7 +2268,7 @@ check_glyph_memory (void)
    screen.  We build such a view by constructing a frame matrix from
    window matrices in this section.
 
-   Windows that must be updated have their must_be_update_p flag set.
+   Windows that must be updated have their must_be_updated_p flag set.
    For all such windows, their desired matrix is made part of the
    desired frame matrix.  For other windows, their current matrix is
    made part of the desired frame matrix.
@@ -3230,14 +3223,12 @@ redraw_overlapped_rows (struct window *w, int yb)
 
           for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
             {
-              updated_row = row;
-              updated_area = area;
-              FRAME_RIF (f)->cursor_to (i, 0, row->y,
-                                        area == TEXT_AREA ? row->x : 0);
+              output_cursor_to (w, i, 0, row->y,
+                                area == TEXT_AREA ? row->x : 0);
               if (row->used[area])
-                FRAME_RIF (f)->write_glyphs (row->glyphs[area],
-                                             row->used[area]);
-              FRAME_RIF (f)->clear_end_of_line (-1);
+                FRAME_RIF (f)->write_glyphs (w, row, row->glyphs[area],
+                                             area, row->used[area]);
+              FRAME_RIF (f)->clear_end_of_line (w, row, area, -1);
             }
 
           row->overlapped_p = 0;
@@ -3490,7 +3481,7 @@ update_window (struct window *w, bool force_p)
       /* End the update of window W.  Don't set the cursor if we
          paused updating the display because in this case,
          set_window_cursor_after_update hasn't been called, and
-         output_cursor doesn't contain the cursor location.  */
+         W->output_cursor doesn't contain the cursor location.  */
       rif->update_window_end_hook (w, !paused_p, mouse_face_overwritten_p);
     }
   else
@@ -3511,22 +3502,20 @@ update_window (struct window *w, bool force_p)
    AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA.  */
 
 static void
-update_marginal_area (struct window *w, int area, int vpos)
+update_marginal_area (struct window *w, struct glyph_row *updated_row,
+                      enum glyph_row_area area, int vpos)
 {
   struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
   struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
 
-  /* Let functions in xterm.c know what area subsequent X positions
-     will be relative to.  */
-  updated_area = area;
-
   /* Set cursor to start of glyphs, write them, and clear to the end
      of the area.  I don't think that something more sophisticated is
      necessary here, since marginal areas will not be the default.  */
-  rif->cursor_to (vpos, 0, desired_row->y, 0);
+  output_cursor_to (w, vpos, 0, desired_row->y, 0);
   if (desired_row->used[area])
-    rif->write_glyphs (desired_row->glyphs[area], desired_row->used[area]);
-  rif->clear_end_of_line (-1);
+    rif->write_glyphs (w, updated_row, desired_row->glyphs[area],
+                       area, desired_row->used[area]);
+  rif->clear_end_of_line (w, updated_row, area, -1);
 }
 
 
@@ -3534,17 +3523,13 @@ update_marginal_area (struct window *w, int area, int vpos)
    Value is true if display has changed.  */
 
 static bool
-update_text_area (struct window *w, int vpos)
+update_text_area (struct window *w, struct glyph_row *updated_row, int vpos)
 {
   struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
   struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
   struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
   bool changed_p = 0;
 
-  /* Let functions in xterm.c know what area subsequent X positions
-     will be relative to.  */
-  updated_area = TEXT_AREA;
-
   /* If rows are at different X or Y, or rows have different height,
      or the current row is marked invalid, write the entire line.  */
   if (!current_row->enabled_p
@@ -3564,14 +3549,14 @@ update_text_area (struct window *w, int vpos)
           && !(current_row->mode_line_p && vpos > 0))
       || current_row->x != desired_row->x)
     {
-      rif->cursor_to (vpos, 0, desired_row->y, desired_row->x);
+      output_cursor_to (w, vpos, 0, desired_row->y, desired_row->x);
 
       if (desired_row->used[TEXT_AREA])
-        rif->write_glyphs (desired_row->glyphs[TEXT_AREA],
-                           desired_row->used[TEXT_AREA]);
+        rif->write_glyphs (w, updated_row, desired_row->glyphs[TEXT_AREA],
+                           TEXT_AREA, desired_row->used[TEXT_AREA]);
 
       /* Clear to end of window.  */
-      rif->clear_end_of_line (-1);
+      rif->clear_end_of_line (w, updated_row, TEXT_AREA, -1);
       changed_p = 1;
 
       /* This erases the cursor.  We do this here because
@@ -3707,8 +3692,9 @@ update_text_area (struct window *w, int vpos)
                   break;
                 }
 
-              rif->cursor_to (vpos, start_hpos, desired_row->y, start_x);
-              rif->write_glyphs (start, i - start_hpos);
+              output_cursor_to (w, vpos, start_hpos, desired_row->y, start_x);
+              rif->write_glyphs (w, updated_row, start,
+                                 TEXT_AREA, i - start_hpos);
               changed_p = 1;
             }
         }
@@ -3716,8 +3702,9 @@ update_text_area (struct window *w, int vpos)
       /* Write the rest.  */
       if (i < desired_row->used[TEXT_AREA])
         {
-          rif->cursor_to (vpos, i, desired_row->y, x);
-          rif->write_glyphs (desired_glyph, desired_row->used[TEXT_AREA] - i);
+          output_cursor_to (w, vpos, i, desired_row->y, x);
+          rif->write_glyphs (w, updated_row, desired_glyph,
+                             TEXT_AREA, desired_row->used[TEXT_AREA] - i);
           changed_p = 1;
         }
 
@@ -3737,9 +3724,9 @@ update_text_area (struct window *w, int vpos)
         {
           /* If old row extends to the end of the text area, clear.  */
           if (i >= desired_row->used[TEXT_AREA])
-            rif->cursor_to (vpos, i, desired_row->y,
-                            desired_row->pixel_width);
-          rif->clear_end_of_line (-1);
+            output_cursor_to (w, vpos, i, desired_row->y,
+                              desired_row->pixel_width);
+          rif->clear_end_of_line (w, updated_row, TEXT_AREA, -1);
           changed_p = 1;
         }
       else if (desired_row->pixel_width < current_row->pixel_width)
@@ -3749,8 +3736,8 @@ update_text_area (struct window *w, int vpos)
           int xlim;
 
           if (i >= desired_row->used[TEXT_AREA])
-            rif->cursor_to (vpos, i, desired_row->y,
-                            desired_row->pixel_width);
+            output_cursor_to (w, vpos, i, desired_row->y,
+                              desired_row->pixel_width);
 
           /* If cursor is displayed at the end of the line, make sure
              it's cleared.  Nowadays we don't have a phys_cursor_glyph
@@ -3767,7 +3754,7 @@ update_text_area (struct window *w, int vpos)
             }
           else
             xlim = current_row->pixel_width;
-          rif->clear_end_of_line (xlim);
+          rif->clear_end_of_line (w, updated_row, TEXT_AREA, xlim);
           changed_p = 1;
         }
     }
@@ -3786,10 +3773,6 @@ update_window_line (struct window *w, int vpos, bool *mouse_face_overwritten_p)
   struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
   bool changed_p = 0;
 
-  /* Set the row being updated.  This is important to let xterm.c
-     know what line height values are in effect.  */
-  updated_row = desired_row;
-
   /* A row can be completely invisible in case a desired matrix was
      built with a vscroll and then make_cursor_line_fully_visible shifts
      the matrix.  Make sure to make such rows current anyway, since
@@ -3800,11 +3783,10 @@ update_window_line (struct window *w, int vpos, bool *mouse_face_overwritten_p)
       eassert (desired_row->enabled_p);
 
       /* Update display of the left margin area, if there is one.  */
-      if (!desired_row->full_width_p
-          && !NILP (w->left_margin_cols))
+      if (!desired_row->full_width_p && w->left_margin_cols > 0)
         {
           changed_p = 1;
-          update_marginal_area (w, LEFT_MARGIN_AREA, vpos);
+          update_marginal_area (w, desired_row, LEFT_MARGIN_AREA, vpos);
           /* Setting this flag will ensure the vertical border, if
              any, between this window and the one on its left will be
              redrawn.  This is necessary because updating the left
@@ -3813,7 +3795,7 @@ update_window_line (struct window *w, int vpos, bool *mouse_face_overwritten_p)
         }
 
       /* Update the display of the text area.  */
-      if (update_text_area (w, vpos))
+      if (update_text_area (w, desired_row, vpos))
         {
           changed_p = 1;
           if (current_row->mouse_face_p)
@@ -3821,11 +3803,10 @@ update_window_line (struct window *w, int vpos, bool *mouse_face_overwritten_p)
         }
 
       /* Update display of the right margin area, if there is one.  */
-      if (!desired_row->full_width_p
-          && !NILP (w->right_margin_cols))
+      if (!desired_row->full_width_p && w->right_margin_cols > 0)
         {
           changed_p = 1;
-          update_marginal_area (w, RIGHT_MARGIN_AREA, vpos);
+          update_marginal_area (w, desired_row, RIGHT_MARGIN_AREA, vpos);
         }
 
       /* Draw truncation marks etc.  */
@@ -3839,12 +3820,11 @@ update_window_line (struct window *w, int vpos, bool *mouse_face_overwritten_p)
           || desired_row->exact_window_width_line_p != current_row->exact_window_width_line_p
           || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row)
               != MATRIX_ROW_CONTINUATION_LINE_P (current_row)))
-        rif->after_update_window_line_hook (desired_row);
+        rif->after_update_window_line_hook (w, desired_row);
     }
 
   /* Update current_row from desired_row.  */
   make_current (w->desired_matrix, w->current_matrix, vpos);
-  updated_row = NULL;
   return changed_p;
 }
 
@@ -3856,7 +3836,6 @@ static void
 set_window_cursor_after_update (struct window *w)
 {
   struct frame *f = XFRAME (w->frame);
-  struct redisplay_interface *rif = FRAME_RIF (f);
   int cx, cy, vpos, hpos;
 
   /* Not intended for frame matrix updates.  */
@@ -3928,7 +3907,7 @@ set_window_cursor_after_update (struct window *w)
      Horizontal position is -1 when cursor is on the left fringe.   */
   hpos = clip_to_bounds (-1, hpos, w->current_matrix->matrix_w - 1);
   vpos = clip_to_bounds (0, vpos, w->current_matrix->nrows - 1);
-  rif->cursor_to (vpos, hpos, cy, cx);
+  output_cursor_to (w, vpos, hpos, cy, cx);
 }
 
 
@@ -4599,10 +4578,7 @@ update_frame_1 (struct frame *f, bool force_p, bool inhibit_id_p)
               int x = WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos);
               int y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
 
-              if (INTEGERP (w->left_margin_cols))
-                x += XFASTINT (w->left_margin_cols);
-
-              /* x = max (min (x, FRAME_TOTAL_COLS (f) - 1), 0); */
+              x += max (0, w->left_margin_cols);
               cursor_to (f, y, x);
             }
         }
@@ -5090,9 +5066,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
      wrong thing with `face-remapping-alist' (bug#2044).  */
   Fset_buffer (w->contents);
   itdata = bidi_shelve_cache ();
-  SET_TEXT_POS_FROM_MARKER (startp, w->start);
-  CHARPOS (startp) = min (ZV, max (BEGV, CHARPOS (startp)));
-  BYTEPOS (startp) = min (ZV_BYTE, max (BEGV_BYTE, BYTEPOS (startp)));
+  CLIP_TEXT_POS_FROM_MARKER (startp, w->start);
   start_display (&it, w, startp);
   /* start_display takes into account the header-line row, but IT's
      vpos still counts from the glyph row that includes the window's
@@ -5729,9 +5703,9 @@ additional wait period, in milliseconds; this is for backwards compatibility.
 
   if (duration > 0)
     {
-      EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (duration);
-      wait_reading_process_output (min (EMACS_SECS (t), WAIT_READING_MAX),
-                                   EMACS_NSECS (t), 0, 0, Qnil, NULL, 0);
+      struct timespec t = dtotimespec (duration);
+      wait_reading_process_output (min (t.tv_sec, WAIT_READING_MAX),
+                                   t.tv_nsec, 0, 0, Qnil, NULL, 0);
     }
 
   return Qnil;
@@ -5778,9 +5752,9 @@ sit_for (Lisp_Object timeout, bool reading, int display_option)
         return Qt;
       else
         {
-          EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (seconds);
-          sec = min (EMACS_SECS (t), WAIT_READING_MAX);
-          nsec = EMACS_NSECS (t);
+          struct timespec t = dtotimespec (seconds);
+          sec = min (t.tv_sec, WAIT_READING_MAX);
+          nsec = t.tv_nsec;
         }
     }
   else if (EQ (timeout, Qt))
@@ -5884,9 +5858,8 @@ pass nil for VARIABLE.  */)
         goto changed;
     }
   /* Check that the buffer info matches.  */
-  for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_LIVE_BUFFER (tail, buf)
     {
-      buf = XCDR (XCAR (tail));
       /* Ignore buffers that aren't included in buffer lists.  */
       if (SREF (BVAR (XBUFFER (buf), name), 0) == ' ')
         continue;
@@ -5916,7 +5889,7 @@ pass nil for VARIABLE.  */)
   n = 1;
   FOR_EACH_FRAME (tail, frame)
     n += 2;
-  for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_LIVE_BUFFER (tail, buf)
     n += 3;
   /* Reallocate the vector if data has grown to need it,
      or if it has shrunk a lot.  */
@@ -5941,9 +5914,8 @@ pass nil for VARIABLE.  */)
       ASET (state, idx, XFRAME (frame)->name);
       idx++;
     }
-  for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_LIVE_BUFFER (tail, buf)
     {
-      buf = XCDR (XCAR (tail));
       /* Ignore buffers that aren't included in buffer lists.  */
       if (SREF (BVAR (XBUFFER (buf), name), 0) == ' ')
         continue;
@@ -6200,19 +6172,6 @@ WINDOW nil or omitted means report on the selected window.  */)
 {
   return decode_any_window (window)->cursor_off_p ? Qnil : Qt;
 }
-
-DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame,
-       Slast_nonminibuf_frame, 0, 0, 0,
-       doc: /* Value is last nonminibuffer frame. */)
-  (void)
-{
-  Lisp_Object frame = Qnil;
-
-  if (last_nonminibuf_frame)
-    XSETFRAME (frame, last_nonminibuf_frame);
-
-  return frame;
-}
 
 /***********************************************************************
                             Initialization
@@ -6231,7 +6190,6 @@ syms_of_display (void)
   defsubr (&Ssend_string_to_terminal);
   defsubr (&Sinternal_show_cursor);
   defsubr (&Sinternal_show_cursor_p);
-  defsubr (&Slast_nonminibuf_frame);
 
 #ifdef GLYPH_DEBUG
   defsubr (&Sdump_redisplay_history);
diff --git a/src/doc.c b/src/doc.c
index 009616f4f87..d3f8fde08f6 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -905,7 +905,7 @@ Otherwise, return a new string, without any text properties.  */)
                  If this one's not active, get nil.  */
               earlier_maps = Fcdr (Fmemq (tem, Freverse (active_maps)));
               describe_map_tree (tem, 1, Fnreverse (earlier_maps),
-                                 Qnil, (char *)0, 1, 0, 0, 1);
+                                 Qnil, 0, 1, 0, 0, 1);
             }
           tem = Fbuffer_string ();
           Ferase_buffer ();
diff --git a/src/editfns.c b/src/editfns.c
index 50bde90788d..84a5c8395fc 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -64,7 +64,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 extern Lisp_Object w32_get_internal_run_time (void);
 #endif
 
-static Lisp_Object format_time_string (char const *, ptrdiff_t, EMACS_TIME,
+static Lisp_Object format_time_string (char const *, ptrdiff_t, struct timespec,
                                        bool, struct tm *);
 static int tm_diff (struct tm *, struct tm *);
 static void update_buffer_properties (ptrdiff_t, ptrdiff_t);
@@ -233,26 +233,12 @@ Beginning of buffer is position (point-min), end is (point-max).
 The return value is POSITION.  */)
   (register Lisp_Object position)
 {
-  ptrdiff_t pos;
-
-  if (MARKERP (position)
-      && current_buffer == XMARKER (position)->buffer)
-    {
-      pos = marker_position (position);
-      if (pos < BEGV)
-        SET_PT_BOTH (BEGV, BEGV_BYTE);
-      else if (pos > ZV)
-        SET_PT_BOTH (ZV, ZV_BYTE);
-      else
-        SET_PT_BOTH (pos, marker_byte_position (position));
-
-      return position;
-    }
-
-  CHECK_NUMBER_COERCE_MARKER (position);
-
-  pos = clip_to_bounds (BEGV, XINT (position), ZV);
-  SET_PT (pos);
+  if (MARKERP (position))
+    set_point_from_marker (position);
+  else if (INTEGERP (position))
+    SET_PT (clip_to_bounds (BEGV, XINT (position), ZV));
+  else
+    wrong_type_argument (Qinteger_or_marker_p, position);
   return position;
 }
 
@@ -1420,7 +1406,7 @@ least significant 16 bits.  USEC and PSEC are the microsecond and
 picosecond counts.  */)
   (void)
 {
-  return make_lisp_time (current_emacs_time ());
+  return make_lisp_time (current_timespec ());
 }
 
 DEFUN ("get-internal-run-time", Fget_internal_run_time, Sget_internal_run_time,
@@ -1450,7 +1436,7 @@ does the same thing as `current-time'.  */)
       usecs -= 1000000;
       secs++;
     }
-  return make_lisp_time (make_emacs_time (secs, usecs * 1000));
+  return make_lisp_time (make_timespec (secs, usecs * 1000));
 #else /* ! HAVE_GETRUSAGE  */
 #ifdef WINDOWSNT
   return w32_get_internal_run_time ();
@@ -1481,10 +1467,10 @@ make_time (time_t t)
    UNKNOWN_MODTIME_NSECS; in that case, the Lisp list contains a
    correspondingly negative picosecond count.  */
 Lisp_Object
-make_lisp_time (EMACS_TIME t)
+make_lisp_time (struct timespec t)
 {
-  int ns = EMACS_NSECS (t);
-  return make_time_tail (EMACS_SECS (t), list2i (ns / 1000, ns % 1000 * 1000));
+  int ns = t.tv_nsec;
+  return make_time_tail (t.tv_sec, list2i (ns / 1000, ns % 1000 * 1000));
 }
 
 /* Decode a Lisp list SPECIFIED_TIME that represents a time.
@@ -1529,7 +1515,7 @@ disassemble_lisp_time (Lisp_Object specified_time, Lisp_Object *phigh,
    list, generate the corresponding time value.
 
    If RESULT is not null, store into *RESULT the converted time;
-   this can fail if the converted time does not fit into EMACS_TIME.
+   this can fail if the converted time does not fit into struct timespec.
    If *DRESULT is not null, store into *DRESULT the number of
    seconds since the start of the POSIX Epoch.
 
@@ -1537,7 +1523,7 @@ disassemble_lisp_time (Lisp_Object specified_time, Lisp_Object *phigh,
 bool
 decode_time_components (Lisp_Object high, Lisp_Object low, Lisp_Object usec,
                         Lisp_Object psec,
-                        EMACS_TIME *result, double *dresult)
+                        struct timespec *result, double *dresult)
 {
   EMACS_INT hi, lo, us, ps;
   if (! (INTEGERP (high) && INTEGERP (low)
@@ -1565,7 +1551,7 @@ decode_time_components (Lisp_Object high, Lisp_Object low, Lisp_Object usec,
           /* Return the greatest representable time that is not greater
              than the requested time.  */
           time_t sec = hi;
-          *result = make_emacs_time ((sec << 16) + lo, us * 1000 + ps / 1000);
+          *result = make_timespec ((sec << 16) + lo, us * 1000 + ps / 1000);
         }
       else
         {
@@ -1583,15 +1569,15 @@ decode_time_components (Lisp_Object high, Lisp_Object low, Lisp_Object usec,
 /* Decode a Lisp list SPECIFIED_TIME that represents a time.
    If SPECIFIED_TIME is nil, use the current time.
 
-   Round the time down to the nearest EMACS_TIME value.
+   Round the time down to the nearest struct timespec value.
    Return seconds since the Epoch.
    Signal an error if unsuccessful.  */
-EMACS_TIME
+struct timespec
 lisp_time_argument (Lisp_Object specified_time)
 {
-  EMACS_TIME t;
+  struct timespec t;
   if (NILP (specified_time))
-    t = current_emacs_time ();
+    t = current_timespec ();
   else
     {
       Lisp_Object high, low, usec, psec;
@@ -1613,12 +1599,12 @@ lisp_seconds_argument (Lisp_Object specified_time)
   else
     {
       Lisp_Object high, low, usec, psec;
-      EMACS_TIME t;
+      struct timespec t;
       if (! (disassemble_lisp_time (specified_time, &high, &low, &usec, &psec)
              && decode_time_components (high, low, make_number (0),
                                         make_number (0), &t, 0)))
         error ("Invalid time specification");
-      return EMACS_SECS (t);
+      return t.tv_sec;
     }
 }
 
@@ -1639,8 +1625,8 @@ or (if you need time as a string) `format-time-string'.  */)
   double t;
   if (NILP (specified_time))
     {
-      EMACS_TIME now = current_emacs_time ();
-      t = EMACS_SECS (now) + EMACS_NSECS (now) / 1e9;
+      struct timespec now = current_timespec ();
+      t = now.tv_sec + now.tv_nsec / 1e9;
     }
   else
     {
@@ -1758,7 +1744,7 @@ For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z".
 usage: (format-time-string FORMAT-STRING &optional TIME UNIVERSAL)  */)
   (Lisp_Object format_string, Lisp_Object timeval, Lisp_Object universal)
 {
-  EMACS_TIME t = lisp_time_argument (timeval);
+  struct timespec t = lisp_time_argument (timeval);
   struct tm tm;
 
   CHECK_STRING (format_string);
@@ -1770,20 +1756,20 @@ usage: (format-time-string FORMAT-STRING &optional TIME UNIVERSAL)  */)
 
 static Lisp_Object
 format_time_string (char const *format, ptrdiff_t formatlen,
-                    EMACS_TIME t, bool ut, struct tm *tmp)
+                    struct timespec t, bool ut, struct tm *tmp)
 {
   char buffer[4000];
   char *buf = buffer;
   ptrdiff_t size = sizeof buffer;
   size_t len;
   Lisp_Object bufstring;
-  int ns = EMACS_NSECS (t);
+  int ns = t.tv_nsec;
   struct tm *tm;
   USE_SAFE_ALLOCA;
 
   while (1)
     {
-      time_t *taddr = emacs_secs_addr (&t);
+      time_t *taddr = &t.tv_sec;
       block_input ();
 
       synchronize_system_time_locale ();
@@ -2068,17 +2054,17 @@ in this case, `current-time-zone' returns a list containing nil for
 the data it can't find.  */)
   (Lisp_Object specified_time)
 {
-  EMACS_TIME value;
+  struct timespec value;
   int offset;
   struct tm *t;
   struct tm localtm;
   Lisp_Object zone_offset, zone_name;
 
   zone_offset = Qnil;
-  value = make_emacs_time (lisp_seconds_argument (specified_time), 0);
+  value = make_timespec (lisp_seconds_argument (specified_time), 0);
   zone_name = format_time_string ("%Z", sizeof "%Z" - 1, value, 0, &localtm);
   block_input ();
-  t = gmtime (emacs_secs_addr (&value));
+  t = gmtime (&value.tv_sec);
   if (t)
     offset = tm_diff (&localtm, t);
   unblock_input ();
@@ -2330,6 +2316,10 @@ to multibyte for insertion (see `unibyte-char-to-multibyte').
 If the current buffer is unibyte, multibyte strings are converted
 to unibyte for insertion.
 
+If an overlay begins at the insertion point, the inserted text falls
+outside the overlay; if a nonempty overlay ends at the insertion
+point, the inserted text falls inside that overlay.
+
 usage: (insert-before-markers &rest ARGS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
@@ -2928,7 +2918,7 @@ Both characters must have the same length of multi-byte form.  */)
           else if (!changed)
             {
               changed = -1;
-              modify_region_1 (pos, XINT (end), false);
+              modify_text (pos, XINT (end));
 
               if (! NILP (noundo))
                 {
@@ -3104,7 +3094,7 @@ It returns the number of characters changed.  */)
   pos = XINT (start);
   pos_byte = CHAR_TO_BYTE (pos);
   end_pos = XINT (end);
-  modify_region_1 (pos, end_pos, false);
+  modify_text (pos, end_pos);
 
   cnt = 0;
   for (; pos < end_pos; )
@@ -4615,7 +4605,7 @@ Transposing beyond buffer boundaries is an error.  */)
 
   if (end1 == start2)           /* adjacent regions */
     {
-      modify_region_1 (start1, end2, false);
+      modify_text (start1, end2);
       record_change (start1, len1 + len2);
 
       tmp_interval1 = copy_intervals (cur_intv, start1, len1);
@@ -4674,8 +4664,8 @@ Transposing beyond buffer boundaries is an error.  */)
         {
           USE_SAFE_ALLOCA;
 
-          modify_region_1 (start1, end1, false);
-          modify_region_1 (start2, end2, false);
+          modify_text (start1, end1);
+          modify_text (start2, end2);
           record_change (start1, len1);
           record_change (start2, len2);
           tmp_interval1 = copy_intervals (cur_intv, start1, len1);
@@ -4708,7 +4698,7 @@ Transposing beyond buffer boundaries is an error.  */)
         {
           USE_SAFE_ALLOCA;
 
-          modify_region_1 (start1, end2, false);
+          modify_text (start1, end2);
           record_change (start1, (end2 - start1));
           tmp_interval1 = copy_intervals (cur_intv, start1, len1);
           tmp_interval_mid = copy_intervals (cur_intv, end1, len_mid);
@@ -4741,7 +4731,7 @@ Transposing beyond buffer boundaries is an error.  */)
           USE_SAFE_ALLOCA;
 
           record_change (start1, (end2 - start1));
-          modify_region_1 (start1, end2, false);
+          modify_text (start1, end2);
 
           tmp_interval1 = copy_intervals (cur_intv, start1, len1);
           tmp_interval_mid = copy_intervals (cur_intv, end1, len_mid);
diff --git a/src/emacs.c b/src/emacs.c
index cf3a3c68932..05384145330 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -517,8 +517,7 @@ init_cmdargs (int argc, char **argv, int skip_args)
            They are decoded in the function command-line after we know
            locale-coding-system.  */
         Vcommand_line_args
-          = Fcons (make_unibyte_string (argv[i], strlen (argv[i])),
-                   Vcommand_line_args);
+          = Fcons (build_unibyte_string (argv[i]), Vcommand_line_args);
     }
 
   unbind_to (count, Qnil);
@@ -697,7 +696,8 @@ main (int argc, char **argv)
 #endif
 
 #ifdef G_SLICE_ALWAYS_MALLOC
-  /* This is used by the Cygwin build.  */
+  /* This is used by the Cygwin build.  It's not needed starting with
+     cygwin-1.7.24, but it doesn't do any harm.  */
   xputenv ("G_SLICE=always-malloc");
 #endif
 
@@ -1407,6 +1407,10 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
       syms_of_xml ();
 #endif
 
+#ifdef HAVE_ZLIB
+      syms_of_decompress ();
+#endif
+
       syms_of_menu ();
 
 #ifdef HAVE_NTGUI
diff --git a/src/emacsgtkfixed.c b/src/emacsgtkfixed.c
index 8b19d89f3a0..44f5cde1b0b 100644
--- a/src/emacsgtkfixed.c
+++ b/src/emacsgtkfixed.c
@@ -20,12 +20,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 
-#include "emacsgtkfixed.h"
-#include <stdio.h>
-
 #include "lisp.h"
 #include "frame.h"
 #include "xterm.h"
+#include "emacsgtkfixed.h"
 
 /* Silence a bogus diagnostic; see GNOME bug 683906.  */
 #if 4 < __GNUC__ + (7 <= __GNUC_MINOR__)
diff --git a/src/emacsgtkfixed.h b/src/emacsgtkfixed.h
index d987797a934..773ca26b143 100644
--- a/src/emacsgtkfixed.h
+++ b/src/emacsgtkfixed.h
@@ -25,8 +25,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 G_BEGIN_DECLS
 
-struct frame;
-
 extern GtkWidget *emacs_fixed_new (struct frame *f);
 
 G_END_DECLS
diff --git a/src/eval.c b/src/eval.c
index 8ee259110f4..1ce14ae94a6 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -2149,6 +2149,8 @@ eval_sub (Lisp_Object form)
   if (SYMBOLP (fun) && !NILP (fun)
       && (fun = XSYMBOL (fun)->function, SYMBOLP (fun)))
     fun = indirect_function (fun);
+  else
+    fun = Ffunction (Fcons (fun, Qnil));
 
   if (SUBRP (fun))
     {
@@ -3151,20 +3153,17 @@ let_shadows_global_binding_p (Lisp_Object symbol)
   return 0;
 }
 
-/* `specpdl_ptr->symbol' is a field which describes which variable is
+/* `specpdl_ptr' describes which variable is
    let-bound, so it can be properly undone when we unbind_to.
-   It can have the following two shapes:
-   - SYMBOL : if it's a plain symbol, it means that we have let-bound
-     a symbol that is not buffer-local (at least at the time
-     the let binding started).  Note also that it should not be
+   It can be either a plain SPECPDL_LET or a SPECPDL_LET_LOCAL/DEFAULT.
+   - SYMBOL is the variable being bound.  Note that it should not be
      aliased (i.e. when let-binding V1 that's aliased to V2, we want
      to record V2 here).
-   - (SYMBOL WHERE . BUFFER) : this means that it is a let-binding for
-     variable SYMBOL which can be buffer-local.  WHERE tells us
-     which buffer is affected (or nil if the let-binding affects the
-     global value of the variable) and BUFFER tells us which buffer was
-     current (i.e. if WHERE is non-nil, then BUFFER==WHERE, otherwise
-     BUFFER did not yet have a buffer-local value).  */
+   - WHERE tells us in which buffer the binding took place.
+     This is used for SPECPDL_LET_LOCAL bindings (i.e. bindings to a
+     buffer-local variable) as well as for SPECPDL_LET_DEFAULT bindings,
+     i.e. bindings to the default value of a variable which can be
+     buffer-local.  */
 
 void
 specbind (Lisp_Object symbol, Lisp_Object value)
@@ -3302,6 +3301,16 @@ clear_unwind_protect (ptrdiff_t count)
    previous value without invoking it.  */
 
 void
+set_unwind_protect (ptrdiff_t count, void (*func) (Lisp_Object),
+                    Lisp_Object arg)
+{
+  union specbinding *p = specpdl + count;
+  p->unwind.kind = SPECPDL_UNWIND;
+  p->unwind.func = func;
+  p->unwind.arg = arg;
+}
+
+void
 set_unwind_protect_ptr (ptrdiff_t count, void (*func) (void *), void *arg)
 {
   union specbinding *p = specpdl + count;
diff --git a/src/fileio.c b/src/fileio.c
index 59e84053773..0e6113f349d 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -233,7 +233,7 @@ void
 restore_point_unwind (Lisp_Object location)
 {
   Fgoto_char (location);
-  Fset_marker (location, Qnil, Qnil);
+  unchain_marker (XMARKER (location));
 }
 
 
@@ -366,8 +366,7 @@ Given a Unix syntax file name, returns a string ending in slash.  */)
     }
 
 #ifdef DOS_NT
-  beg = alloca (SBYTES (filename) + 1);
-  memcpy (beg, SSDATA (filename), SBYTES (filename) + 1);
+  beg = xlispstrdupa (filename);
 #else
   beg = SSDATA (filename);
 #endif
@@ -505,6 +504,10 @@ get a current directory to run processes in.  */)
   return Ffile_name_directory (filename);
 }
 
+/* Maximum number of bytes that DST will be longer than SRC
+   in file_name_as_directory.  This occurs when SRCLEN == 0.  */
+enum { file_name_as_directory_slop = 2 };
+
 /* Convert from file name SRC of length SRCLEN to directory name in
    DST.  MULTIBYTE non-zero means the file name in SRC is a multibyte
    string.  On UNIX, just make sure there is a terminating /.  Return
@@ -522,14 +525,10 @@ file_name_as_directory (char *dst, const char *src, ptrdiff_t srclen,
       return 2;
     }
 
-  strcpy (dst, src);
-
+  memcpy (dst, src, srclen);
   if (!IS_DIRECTORY_SEP (dst[srclen - 1]))
-    {
-      dst[srclen] = DIRECTORY_SEP;
-      dst[srclen + 1] = '\0';
-      srclen++;
-    }
+    dst[srclen++] = DIRECTORY_SEP;
+  dst[srclen] = 0;
 #ifdef DOS_NT
   dostounix_filename (dst, multibyte);
 #endif
@@ -548,7 +547,8 @@ For a Unix-syntax file name, just appends a slash.  */)
 {
   char *buf;
   ptrdiff_t length;
-  Lisp_Object handler;
+  Lisp_Object handler, val;
+  USE_SAFE_ALLOCA;
 
   CHECK_STRING (file);
   if (NILP (file))
@@ -570,10 +570,12 @@ For a Unix-syntax file name, just appends a slash.  */)
   if (!NILP (Vw32_downcase_file_names))
     file = Fdowncase (file);
 #endif
-  buf = alloca (SBYTES (file) + 10);
+  buf = SAFE_ALLOCA (SBYTES (file) + file_name_as_directory_slop + 1);
   length = file_name_as_directory (buf, SSDATA (file), SBYTES (file),
                                    STRING_MULTIBYTE (file));
-  return make_specified_string (buf, -1, length, STRING_MULTIBYTE (file));
+  val = make_specified_string (buf, -1, length, STRING_MULTIBYTE (file));
+  SAFE_FREE ();
+  return val;
 }
 
 /* Convert from directory name SRC of length SRCLEN to file name in
@@ -585,18 +587,17 @@ static ptrdiff_t
 directory_file_name (char *dst, char *src, ptrdiff_t srclen, bool multibyte)
 {
   /* Process as Unix format: just remove any final slash.
-     But leave "/" unchanged; do not change it to "".  */
-  strcpy (dst, src);
-  if (srclen > 1
-      && IS_DIRECTORY_SEP (dst[srclen - 1])
+     But leave "/" and "//" unchanged.  */
+  while (srclen > 1
 #ifdef DOS_NT
-      && !IS_ANY_SEP (dst[srclen - 2])
+         && !IS_ANY_SEP (src[srclen - 2])
 #endif
-      )
-    {
-      dst[srclen - 1] = 0;
-      srclen--;
-    }
+         && IS_DIRECTORY_SEP (src[srclen - 1])
+         && ! (srclen == 2 && IS_DIRECTORY_SEP (src[0])))
+    srclen--;
+
+  memcpy (dst, src, srclen);
+  dst[srclen] = 0;
 #ifdef DOS_NT
   dostounix_filename (dst, multibyte);
 #endif
@@ -614,7 +615,8 @@ In Unix-syntax, this function just removes the final slash.  */)
 {
   char *buf;
   ptrdiff_t length;
-  Lisp_Object handler;
+  Lisp_Object handler, val;
+  USE_SAFE_ALLOCA;
 
   CHECK_STRING (directory);
 
@@ -637,10 +639,12 @@ In Unix-syntax, this function just removes the final slash.  */)
   if (!NILP (Vw32_downcase_file_names))
     directory = Fdowncase (directory);
 #endif
-  buf = alloca (SBYTES (directory) + 20);
+  buf = SAFE_ALLOCA (SBYTES (directory) + 1);
   length = directory_file_name (buf, SSDATA (directory), SBYTES (directory),
                                 STRING_MULTIBYTE (directory));
-  return make_specified_string (buf, -1, length, STRING_MULTIBYTE (directory));
+  val = make_specified_string (buf, -1, length, STRING_MULTIBYTE (directory));
+  SAFE_FREE ();
+  return val;
 }
 
 static const char make_temp_name_tbl[64] =
@@ -838,6 +842,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
   Lisp_Object handler, result, handled_name;
   bool multibyte;
   Lisp_Object hdir;
+  USE_SAFE_ALLOCA;
 
   CHECK_STRING (name);
 
@@ -944,8 +949,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
 #endif
 
   /* Make a local copy of nm[] to protect it from GC in DECODE_FILE below.  */
-  nm = alloca (SBYTES (name) + 1);
-  memcpy (nm, SSDATA (name), SBYTES (name) + 1);
+  nm = xlispstrdupa (name);
 
 #ifdef DOS_NT
   /* Note if special escape prefix is present, but remove for now.  */
@@ -1013,11 +1017,11 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
                   || (p[2] == '.' && (IS_DIRECTORY_SEP (p[3])
                                       || p[3] == 0))))
             lose = 1;
-          /* We want to replace multiple `/' in a row with a single
-             slash.  */
-          else if (p > nm
-                   && IS_DIRECTORY_SEP (p[0])
-                   && IS_DIRECTORY_SEP (p[1]))
+          /* Replace multiple slashes with a single one, except
+             leave leading "//" alone.  */
+          else if (IS_DIRECTORY_SEP (p[0])
+                   && IS_DIRECTORY_SEP (p[1])
+                   && (p != nm || IS_DIRECTORY_SEP (p[2])))
             lose = 1;
           p++;
         }
@@ -1100,10 +1104,11 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
       else                      /* ~user/filename */
         {
           char *o, *p;
-          for (p = nm; *p && (!IS_DIRECTORY_SEP (*p)); p++);
-          o = alloca (p - nm + 1);
+          for (p = nm; *p && !IS_DIRECTORY_SEP (*p); p++)
+            continue;
+          o = SAFE_ALLOCA (p - nm + 1);
           memcpy (o, nm, p - nm);
-          o [p - nm] = 0;
+          o[p - nm] = 0;
 
           block_input ();
           pw = getpwnam (o + 1);
@@ -1219,7 +1224,8 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           if (!IS_DIRECTORY_SEP (nm[0]))
             {
               ptrdiff_t newlen = strlen (newdir);
-              char *tmp = alloca (newlen + strlen (nm) + 2);
+              char *tmp = alloca (newlen + file_name_as_directory_slop
+                                  + strlen (nm) + 1);
               file_name_as_directory (tmp, newdir, newlen, multibyte);
               strcat (tmp, nm);
               nm = tmp;
@@ -1273,31 +1279,18 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
 
   if (newdir)
     {
-      /* Get rid of any slash at the end of newdir, unless newdir is
-         just / or // (an incomplete UNC name).  */
+      /* Ignore any slash at the end of newdir, unless newdir is
+         just "/" or "//".  */
       length = strlen (newdir);
-      tlen = length + 1;
-      if (length > 1 && IS_DIRECTORY_SEP (newdir[length - 1])
-#ifdef WINDOWSNT
-          && !(length == 2 && IS_DIRECTORY_SEP (newdir[0]))
-#endif
-          )
-        {
-          char *temp = alloca (length);
-          memcpy (temp, newdir, length - 1);
-          temp[length - 1] = 0;
-          length--;
-          newdir = temp;
-        }
+      while (length > 1 && IS_DIRECTORY_SEP (newdir[length - 1])
+             && ! (length == 2 && IS_DIRECTORY_SEP (newdir[0])))
+        length--;
     }
   else
-    {
-      length = 0;
-      tlen = 0;
-    }
+    length = 0;
 
   /* Now concatenate the directory and name to new space in the stack frame.  */
-  tlen += strlen (nm) + 1;
+  tlen = length + file_name_as_directory_slop + strlen (nm) + 1;
 #ifdef DOS_NT
   /* Reserve space for drive specifier and escape prefix, since either
      or both may need to be inserted.  (The Microsoft x86 compiler
@@ -1305,7 +1298,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
   target = alloca (tlen + 4);
   target += 4;
 #else  /* not DOS_NT */
-  target = alloca (tlen);
+  target = SAFE_ALLOCA (tlen);
 #endif /* not DOS_NT */
   *target = 0;
 
@@ -1322,7 +1315,10 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           if (!(drive && nm[0] && IS_DIRECTORY_SEP (newdir[0])
                 && newdir[1] == '\0'))
 #endif
-            strcpy (target, newdir);
+            {
+              memcpy (target, newdir, length);
+              target[length] = 0;
+            }
         }
       else
         file_name_as_directory (target, newdir, length, multibyte);
@@ -1382,8 +1378,9 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
               ++o;
             p += 3;
           }
-        else if (p > target && IS_DIRECTORY_SEP (p[1]))
-          /* Collapse multiple `/' in a row.  */
+        else if (IS_DIRECTORY_SEP (p[1])
+                 && (p != target || IS_DIRECTORY_SEP (p[2])))
+          /* Collapse multiple "/", except leave leading "//" alone.  */
           p++;
         else
           {
@@ -1431,11 +1428,12 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
     {
       handled_name = call3 (handler, Qexpand_file_name,
                             result, default_directory);
-      if (STRINGP (handled_name))
-        return handled_name;
-      error ("Invalid handler in `file-name-handler-alist'");
+      if (! STRINGP (handled_name))
+        error ("Invalid handler in `file-name-handler-alist'");
+      result = handled_name;
     }
 
+  SAFE_FREE ();
   return result;
 }
 
@@ -1693,8 +1691,7 @@ those `/' is discarded.  */)
   /* Always work on a copy of the string, in case GC happens during
      decode of environment variables, causing the original Lisp_String
      data to be relocated.  */
-  nm = alloca (SBYTES (filename) + 1);
-  memcpy (nm, SDATA (filename), SBYTES (filename) + 1);
+  nm = xlispstrdupa (filename);
 
 #ifdef DOS_NT
   dostounix_filename (nm, multibyte);
@@ -2048,7 +2045,7 @@ entries (depending on how Emacs was built).  */)
   /* CopyFile retains the timestamp by default.  */
   else if (NILP (keep_time))
     {
-      EMACS_TIME now;
+      struct timespec now;
       DWORD attributes;
       char * filename;
 
@@ -2057,7 +2054,7 @@ entries (depending on how Emacs was built).  */)
       /* Ensure file is writable while its modified time is set.  */
       attributes = GetFileAttributes (filename);
       SetFileAttributes (filename, attributes & ~FILE_ATTRIBUTE_READONLY);
-      now = current_emacs_time ();
+      now = current_timespec ();
       if (set_file_times (-1, filename, now, now))
         {
           /* Restore original attributes.  */
@@ -2181,8 +2178,8 @@ entries (depending on how Emacs was built).  */)
 
   if (!NILP (keep_time))
     {
-      EMACS_TIME atime = get_stat_atime (&st);
-      EMACS_TIME mtime = get_stat_mtime (&st);
+      struct timespec atime = get_stat_atime (&st);
+      struct timespec mtime = get_stat_mtime (&st);
       if (set_file_times (ofd, SSDATA (encoded_newname), atime, mtime))
         xsignal2 (Qfile_date_error,
                   build_string ("Cannot set file date"), newname);
@@ -3289,7 +3286,7 @@ Use the current time if TIMESTAMP is nil.  TIMESTAMP is in the format of
 {
   Lisp_Object absname, encoded_absname;
   Lisp_Object handler;
-  EMACS_TIME t = lisp_time_argument (timestamp);
+  struct timespec t = lisp_time_argument (timestamp);
 
   absname = Fexpand_file_name (filename, BVAR (current_buffer, directory));
 
@@ -3366,7 +3363,7 @@ otherwise, if FILE2 does not exist, the answer is t.  */)
   if (stat (SSDATA (absname2), &st2) < 0)
     return Qt;
 
-  return (EMACS_TIME_LT (get_stat_mtime (&st2), get_stat_mtime (&st1))
+  return (timespec_cmp (get_stat_mtime (&st2), get_stat_mtime (&st1)) < 0
           ? Qt : Qnil);
 }
 
@@ -3466,13 +3463,13 @@ file_offset (Lisp_Object val)
 }
 
 /* Return a special time value indicating the error number ERRNUM.  */
-static EMACS_TIME
+static struct timespec
 time_error_value (int errnum)
 {
   int ns = (errnum == ENOENT || errnum == EACCES || errnum == ENOTDIR
             ? NONEXISTENT_MODTIME_NSECS
             : UNKNOWN_MODTIME_NSECS);
-  return make_emacs_time (0, ns);
+  return make_timespec (0, ns);
 }
 
 DEFUN ("insert-file-contents", Finsert_file_contents, Sinsert_file_contents,
@@ -3504,7 +3501,7 @@ by calling `format-decode', which see.  */)
   (Lisp_Object filename, Lisp_Object visit, Lisp_Object beg, Lisp_Object end, Lisp_Object replace)
 {
   struct stat st;
-  EMACS_TIME mtime;
+  struct timespec mtime;
   int fd;
   ptrdiff_t inserted = 0;
   ptrdiff_t how_much;
@@ -4570,7 +4567,7 @@ by calling `format-decode', which see.  */)
     }
 
   if (!NILP (visit)
-      && EMACS_NSECS (current_buffer->modtime) == NONEXISTENT_MODTIME_NSECS)
+      && current_buffer->modtime.tv_nsec == NONEXISTENT_MODTIME_NSECS)
     {
       /* If visiting nonexistent file, return nil.  */
       report_file_errno ("Opening input file", orig_filename, save_errno);
@@ -4746,25 +4743,39 @@ This does code conversion according to the value of
 
 This calls `write-region-annotate-functions' at the start, and
 `write-region-post-annotation-function' at the end.  */)
-  (Lisp_Object start, Lisp_Object end, Lisp_Object filename, Lisp_Object append, Lisp_Object visit, Lisp_Object lockname, Lisp_Object mustbenew)
+  (Lisp_Object start, Lisp_Object end, Lisp_Object filename, Lisp_Object append,
+   Lisp_Object visit, Lisp_Object lockname, Lisp_Object mustbenew)
+{
+  return write_region (start, end, filename, append, visit, lockname, mustbenew,
+                       -1);
+}
+
+/* Like Fwrite_region, except that if DESC is nonnegative, it is a file
+   descriptor for FILENAME, so do not open or close FILENAME.  */
+
+Lisp_Object
+write_region (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
+              Lisp_Object append, Lisp_Object visit, Lisp_Object lockname,
+              Lisp_Object mustbenew, int desc)
 {
-  int desc;
   int open_flags;
   int mode;
   off_t offset IF_LINT (= 0);
+  bool open_and_close_file = desc < 0;
   bool ok;
   int save_errno = 0;
   const char *fn;
   struct stat st;
-  EMACS_TIME modtime;
+  struct timespec modtime;
   ptrdiff_t count = SPECPDL_INDEX ();
-  ptrdiff_t count1;
+  ptrdiff_t count1 IF_LINT (= 0);
   Lisp_Object handler;
   Lisp_Object visit_file;
   Lisp_Object annotations;
   Lisp_Object encoded_filename;
   bool visiting = (EQ (visit, Qt) || STRINGP (visit));
   bool quietly = !NILP (visit);
+  bool file_locked = 0;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
   struct buffer *given_buffer;
   struct coding_system coding;
@@ -4832,7 +4843,6 @@ This calls `write-region-annotate-functions' at the start, and
   record_unwind_protect (build_annotations_unwind,
                          Vwrite_region_annotation_buffers);
   Vwrite_region_annotation_buffers = list1 (Fcurrent_buffer ());
-  count1 = SPECPDL_INDEX ();
 
   given_buffer = current_buffer;
 
@@ -4871,8 +4881,11 @@ This calls `write-region-annotate-functions' at the start, and
     coding.mode |= CODING_MODE_SELECTIVE_DISPLAY;
 
 #ifdef CLASH_DETECTION
-  if (!auto_saving)
-    lock_file (lockname);
+  if (open_and_close_file && !auto_saving)
+    {
+      lock_file (lockname);
+      file_locked = 1;
+    }
 #endif /* CLASH_DETECTION */
 
   encoded_filename = ENCODE_FILE (filename);
@@ -4889,19 +4902,23 @@ This calls `write-region-annotate-functions' at the start, and
   mode = auto_saving ? auto_save_mode_bits : 0666;
 #endif
 
-  desc = emacs_open (fn, open_flags, mode);
-
-  if (desc < 0)
+  if (open_and_close_file)
     {
-      int open_errno = errno;
+      desc = emacs_open (fn, open_flags, mode);
+      if (desc < 0)
+        {
+          int open_errno = errno;
 #ifdef CLASH_DETECTION
-      if (!auto_saving) unlock_file (lockname);
+          if (file_locked)
+            unlock_file (lockname);
 #endif /* CLASH_DETECTION */
-      UNGCPRO;
-      report_file_errno ("Opening output file", filename, open_errno);
-    }
+          UNGCPRO;
+          report_file_errno ("Opening output file", filename, open_errno);
+        }
 
-  record_unwind_protect_int (close_file_unwind, desc);
+      count1 = SPECPDL_INDEX ();
+      record_unwind_protect_int (close_file_unwind, desc);
+    }
 
   if (NUMBERP (append))
     {
@@ -4910,7 +4927,8 @@ This calls `write-region-annotate-functions' at the start, and
         {
           int lseek_errno = errno;
 #ifdef CLASH_DETECTION
-          if (!auto_saving) unlock_file (lockname);
+          if (file_locked)
+            unlock_file (lockname);
 #endif /* CLASH_DETECTION */
           UNGCPRO;
           report_file_errno ("Lseek error", filename, lseek_errno);
@@ -4945,9 +4963,9 @@ This calls `write-region-annotate-functions' at the start, and
 
   immediate_quit = 0;
 
-  /* fsync is not crucial for auto-save files, since they might lose
-     some work anyway.  */
-  if (!auto_saving && !write_region_inhibit_fsync)
+  /* fsync is not crucial for temporary files.  Nor for auto-save
+     files, since they might lose some work anyway.  */
+  if (open_and_close_file && !auto_saving && !write_region_inhibit_fsync)
     {
       /* Transfer data and metadata to disk, retrying if interrupted.
          fsync can report a write failure here, e.g., due to disk full
@@ -4962,7 +4980,7 @@ This calls `write-region-annotate-functions' at the start, and
           }
     }
 
-  modtime = invalid_emacs_time ();
+  modtime = invalid_timespec ();
   if (visiting)
     {
       if (fstat (desc, &st) == 0)
@@ -4971,12 +4989,15 @@ This calls `write-region-annotate-functions' at the start, and
         ok = 0, save_errno = errno;
     }
 
-  /* NFS can report a write failure now.  */
-  if (emacs_close (desc) < 0)
-    ok = 0, save_errno = errno;
+  if (open_and_close_file)
+    {
+      /* NFS can report a write failure now.  */
+      if (emacs_close (desc) < 0)
+        ok = 0, save_errno = errno;
 
-  /* Discard the unwind protect for close_file_unwind.  */
-  specpdl_ptr = specpdl + count1;
+      /* Discard the unwind protect for close_file_unwind.  */
+      specpdl_ptr = specpdl + count1;
+    }
 
   /* Some file systems have a bug where st_mtime is not updated
      properly after a write.  For example, CIFS might not see the
@@ -4993,7 +5014,7 @@ This calls `write-region-annotate-functions' at the start, and
      unlikely and a similar race between the last write and the fstat
      above cannot possibly be closed anyway.  */
 
-  if (EMACS_TIME_VALID_P (modtime)
+  if (timespec_valid_p (modtime)
       && ! (valid_timestamp_file_system && st.st_dev == timestamp_file_system))
     {
       int desc1 = emacs_open (fn, O_WRONLY | O_BINARY, 0);
@@ -5015,11 +5036,11 @@ This calls `write-region-annotate-functions' at the start, and
               bool use_heuristic
                 = ((open_flags & (O_EXCL | O_TRUNC)) != 0
                    && st.st_size != 0
-                   && EMACS_NSECS (modtime) % 100 != 0);
+                   && modtime.tv_nsec % 100 != 0);
 
-              EMACS_TIME modtime1 = get_stat_mtime (&st1);
+              struct timespec modtime1 = get_stat_mtime (&st1);
               if (use_heuristic
-                  && EMACS_TIME_EQ (modtime, modtime1)
+                  && timespec_cmp (modtime, modtime1) == 0
                   && st.st_size == st1.st_size)
                 {
                   timestamp_file_system = st.st_dev;
@@ -5052,14 +5073,14 @@ This calls `write-region-annotate-functions' at the start, and
   unbind_to (count, Qnil);
 
 #ifdef CLASH_DETECTION
-  if (!auto_saving)
+  if (file_locked)
     unlock_file (lockname);
 #endif /* CLASH_DETECTION */
 
   /* Do this before reporting IO error
      to avoid a "file has changed on disk" warning on
      next attempt to save.  */
-  if (EMACS_TIME_VALID_P (modtime))
+  if (timespec_valid_p (modtime))
     {
       current_buffer->modtime = modtime;
       current_buffer->modtime_size = st.st_size;
@@ -5334,7 +5355,7 @@ See Info node `(elisp)Modification Time' for more details.  */)
   struct stat st;
   Lisp_Object handler;
   Lisp_Object filename;
-  EMACS_TIME mtime;
+  struct timespec mtime;
 
   if (NILP (buf))
     b = current_buffer;
@@ -5345,7 +5366,7 @@ See Info node `(elisp)Modification Time' for more details.  */)
     }
 
   if (!STRINGP (BVAR (b, filename))) return Qt;
-  if (EMACS_NSECS (b->modtime) == UNKNOWN_MODTIME_NSECS) return Qt;
+  if (b->modtime.tv_nsec == UNKNOWN_MODTIME_NSECS) return Qt;
 
   /* If the file name has special constructs in it,
      call the corresponding file handler.  */
@@ -5359,7 +5380,7 @@ See Info node `(elisp)Modification Time' for more details.  */)
   mtime = (stat (SSDATA (filename), &st) == 0
            ? get_stat_mtime (&st)
            : time_error_value (errno));
-  if (EMACS_TIME_EQ (mtime, b->modtime)
+  if (timespec_cmp (mtime, b->modtime) == 0
       && (b->modtime_size < 0
           || st.st_size == b->modtime_size))
     return Qt;
@@ -5376,7 +5397,7 @@ doesn't exist, return -1.
 See Info node `(elisp)Modification Time' for more details.  */)
   (void)
 {
-  int ns = EMACS_NSECS (current_buffer->modtime);
+  int ns = current_buffer->modtime.tv_nsec;
   if (ns < 0)
     return make_number (UNKNOWN_MODTIME_NSECS - ns);
   return make_lisp_time (current_buffer->modtime);
@@ -5395,11 +5416,11 @@ An argument specifies the modification time value to use
 {
   if (!NILP (time_flag))
     {
-      EMACS_TIME mtime;
+      struct timespec mtime;
       if (INTEGERP (time_flag))
         {
           CHECK_RANGED_INTEGER (time_flag, -1, 0);
-          mtime = make_emacs_time (0, UNKNOWN_MODTIME_NSECS - XINT (time_flag));
+          mtime = make_timespec (0, UNKNOWN_MODTIME_NSECS - XINT (time_flag));
         }
       else
         mtime = lisp_time_argument (time_flag);
@@ -5618,9 +5639,8 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
      couldn't handle some ange-ftp'd file.  */
 
   for (do_handled_files = 0; do_handled_files < 2; do_handled_files++)
-    for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
+    FOR_EACH_LIVE_BUFFER (tail, buf)
       {
-        buf = XCDR (XCAR (tail));
         b = XBUFFER (buf);
 
         /* Record all the buffers that have auto save mode
@@ -5663,12 +5683,12 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
                 || NILP (Ffind_file_name_handler (BVAR (b, auto_save_file_name),
                                                   Qwrite_region))))
           {
-            EMACS_TIME before_time = current_emacs_time ();
-            EMACS_TIME after_time;
+            struct timespec before_time = current_timespec ();
+            struct timespec after_time;
 
             /* If we had a failure, don't try again for 20 minutes.  */
             if (b->auto_save_failure_time > 0
-                && EMACS_SECS (before_time) - b->auto_save_failure_time < 1200)
+                && before_time.tv_sec - b->auto_save_failure_time < 1200)
               continue;
 
             set_buffer_internal (b);
@@ -5701,12 +5721,12 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
             XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
             set_buffer_internal (old);
 
-            after_time = current_emacs_time ();
+            after_time = current_timespec ();
 
             /* If auto-save took more than 60 seconds,
                assume it was an NFS failure that got a timeout.  */
-            if (EMACS_SECS (after_time) - EMACS_SECS (before_time) > 60)
-              b->auto_save_failure_time = EMACS_SECS (after_time);
+            if (after_time.tv_sec - before_time.tv_sec > 60)
+              b->auto_save_failure_time = after_time.tv_sec;
           }
       }
 
diff --git a/src/filelock.c b/src/filelock.c
index b9c991e4baf..df72eff5950 100644
--- a/src/filelock.c
+++ b/src/filelock.c
@@ -181,7 +181,7 @@ get_boot_time (void)
      since utmp is typically much smaller than wtmp.
      Passing a null pointer causes get_boot_time_1
      to inspect the default file, namely utmp.  */
-  get_boot_time_1 ((char *) 0, 0);
+  get_boot_time_1 (0, 0);
   if (boot_time)
     return boot_time;
 
@@ -411,28 +411,14 @@ create_lock_file (char *lfname, char *lock_info_str, bool force)
       memcpy (nonce, lfname, lfdirlen);
       strcpy (nonce + lfdirlen, nonce_base);
 
-#if HAVE_MKOSTEMP
-      /* Prefer mkostemp to mkstemp, as it avoids a window where FD is
-         temporarily open without close-on-exec.  */
       fd = mkostemp (nonce, O_BINARY | O_CLOEXEC);
-#elif HAVE_MKSTEMP
-      /* Prefer mkstemp to mktemp, as it avoids a race between
-         mktemp and emacs_open.  */
-      fd = mkstemp (nonce);
-#else
-      mktemp (nonce);
-      fd = emacs_open (nonce, O_WRONLY | O_CREAT | O_EXCL | O_BINARY,
-                       S_IRUSR | S_IWUSR);
-#endif
-
       if (fd < 0)
         err = errno;
       else
         {
           ptrdiff_t lock_info_len;
-#if ! (HAVE_MKOSTEMP && O_CLOEXEC)
-          fcntl (fd, F_SETFD, FD_CLOEXEC);
-#endif
+          if (! O_CLOEXEC)
+            fcntl (fd, F_SETFD, FD_CLOEXEC);
           lock_info_len = strlen (lock_info_str);
           err = 0;
           /* Use 'write', not 'emacs_write', as garbage collection
@@ -759,16 +745,15 @@ unlock_file (Lisp_Object fn)
 void
 unlock_all_files (void)
 {
-  register Lisp_Object tail;
+  register Lisp_Object tail, buf;
   register struct buffer *b;
 
-  for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_LIVE_BUFFER (tail, buf)
     {
-      b = XBUFFER (XCDR (XCAR (tail)));
-      if (STRINGP (BVAR (b, file_truename)) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
-        {
-          unlock_file (BVAR (b, file_truename));
-        }
+      b = XBUFFER (buf);
+      if (STRINGP (BVAR (b, file_truename))
+          && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
+        unlock_file (BVAR (b, file_truename));
     }
 }
 
diff --git a/src/font.c b/src/font.c
index 073487b540d..6a8262623dc 100644
--- a/src/font.c
+++ b/src/font.c
@@ -4226,36 +4226,38 @@ the consecutive wildcards are folded into one.  */)
   return make_string (name, namelen);
 }
 
+void
+clear_font_cache (struct frame *f)
+{
+  struct font_driver_list *driver_list = f->font_driver_list;
+
+  for (; driver_list; driver_list = driver_list->next)
+    if (driver_list->on)
+      {
+        Lisp_Object val, tmp, cache = driver_list->driver->get_cache (f);
+
+        val = XCDR (cache);
+        while (! NILP (val)
+               && ! EQ (XCAR (XCAR (val)), driver_list->driver->type))
+          val = XCDR (val);
+        eassert (! NILP (val));
+        tmp = XCDR (XCAR (val));
+        if (XINT (XCAR (tmp)) == 0)
+          {
+            font_clear_cache (f, XCAR (val), driver_list->driver);
+            XSETCDR (cache, XCDR (val));
+          }
+      }
+}
+
 DEFUN ("clear-font-cache", Fclear_font_cache, Sclear_font_cache, 0, 0, 0,
-       doc: /* Clear font cache.  */)
+       doc: /* Clear font cache of each frame.  */)
   (void)
 {
   Lisp_Object list, frame;
 
   FOR_EACH_FRAME (list, frame)
-    {
-      struct frame *f = XFRAME (frame);
-      struct font_driver_list *driver_list = f->font_driver_list;
-
-      for (; driver_list; driver_list = driver_list->next)
-        if (driver_list->on)
-          {
-            Lisp_Object cache = driver_list->driver->get_cache (f);
-            Lisp_Object val, tmp;
-
-            val = XCDR (cache);
-            while (! NILP (val)
-                   && ! EQ (XCAR (XCAR (val)), driver_list->driver->type))
-              val = XCDR (val);
-            eassert (! NILP (val));
-            tmp = XCDR (XCAR (val));
-            if (XINT (XCAR (tmp)) == 0)
-              {
-                font_clear_cache (f, XCAR (val), driver_list->driver);
-                XSETCDR (cache, XCDR (val));
-              }
-          }
-    }
+    clear_font_cache (XFRAME (frame));
 
   return Qnil;
 }
diff --git a/src/font.h b/src/font.h
index daeb320c1ab..3ee579aba2b 100644
--- a/src/font.h
+++ b/src/font.h
@@ -56,11 +56,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 extern Lisp_Object Qfont_spec, Qfont_entity, Qfont_object;
 
-
-struct font_driver;
-struct font;
-struct glyph_string;
-
 /* An enumerator for each font property.  This is used as an index to
    the vector of FONT-SPEC and FONT-ENTITY.
 
@@ -487,8 +482,6 @@ struct font_bitmap
    this value.  */
 #define FONT_PIXEL_SIZE_QUANTUM 1
 
-struct face;
-
 #define FONT_INVALID_CODE 0xFFFFFFFF
 
 /* Font driver.  Members specified as "optional" can be NULL.  */
@@ -760,6 +753,7 @@ extern Lisp_Object font_load_for_lface (struct frame *f, Lisp_Object *lface,
                                         Lisp_Object spec);
 extern void font_prepare_for_face (struct frame *f, struct face *face);
 extern void font_done_for_face (struct frame *f, struct face *face);
+extern void clear_font_cache (struct frame *);
 
 extern Lisp_Object font_open_by_spec (struct frame *f, Lisp_Object spec);
 extern Lisp_Object font_open_by_name (struct frame *f, Lisp_Object name);
diff --git a/src/fontset.c b/src/fontset.c
index 0bf716bf1b2..a6277b050d5 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -944,6 +944,19 @@ face_for_char (struct frame *f, struct face *face, int c, int pos, Lisp_Object o
   if (ASCII_CHAR_P (c) || face->fontset < 0)
     return face->ascii_face->id;
 
+#ifdef HAVE_NS
+  if (face->font)
+    {
+      /* Fonts often have characters in other scripts, like symbol, even if they
+         don't match script: symbol.  So check if the character is present
+         in the current face first.  Only enable for NS for now, but should
+         perhaps be general?  */
+      Lisp_Object font_object;
+      XSETFONT (font_object, face->font);
+      if (font_has_char (f, font_object, c)) return face->id;
+    }
+#endif
+
   eassert (fontset_id_valid_p (face->fontset));
   fontset = FONTSET_FROM_ID (face->fontset);
   eassert (!BASE_FONTSET_P (fontset));
diff --git a/src/fontset.h b/src/fontset.h
index fd16c7178f5..b8ef4789e71 100644
--- a/src/fontset.h
+++ b/src/fontset.h
@@ -26,8 +26,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifndef EMACS_FONTSET_H
 #define EMACS_FONTSET_H
 
-struct face;
-
 extern void free_face_fontset (struct frame *, struct face *);
 extern int face_for_char (struct frame *, struct face *, int,
                           int, Lisp_Object);
@@ -42,7 +40,6 @@ extern Lisp_Object Qlatin;
 extern Lisp_Object fontset_name (int);
 extern Lisp_Object fontset_ascii (int);
 
-struct font;
 extern int face_for_font (struct frame *, Lisp_Object, struct face *);
 
 #endif /* EMACS_FONTSET_H */
diff --git a/src/frame.c b/src/frame.c
index 14fc15c4717..d11a6b8fee9 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -185,7 +185,6 @@ set_menu_bar_lines_1 (Lisp_Object window, int n)
 {
   struct window *w = XWINDOW (window);
 
-  w->last_modified = 0;
   w->top_line += n;
   w->total_lines -= n;
 
@@ -693,24 +692,16 @@ affects all frames on the same terminal device.  */)
                        ? FRAME_TTY (XFRAME (selected_frame))->name
                        : NULL));
       if (!NILP (tty))
-        {
-          name = alloca (SBYTES (tty) + 1);
-          memcpy (name, SSDATA (tty), SBYTES (tty));
-          name[SBYTES (tty)] = 0;
-        }
+        name = xlispstrdupa (tty);
 
       tty_type = get_future_frame_param
         (Qtty_type, parms, (FRAME_TERMCAP_P (XFRAME (selected_frame))
                             ? FRAME_TTY (XFRAME (selected_frame))->type
                             : NULL));
       if (!NILP (tty_type))
-        {
-          type = alloca (SBYTES (tty_type) + 1);
-          memcpy (type, SSDATA (tty_type), SBYTES (tty_type));
-          type[SBYTES (tty_type)] = 0;
-        }
+        type = xlispstrdupa (tty_type);
 
-      t = init_tty (name, type, 0); /* Errors are not fatal. */
+      t = init_tty (name, type, 0); /* Errors are not fatal.  */
     }
 
   f = make_terminal_frame (t);
@@ -726,7 +717,7 @@ affects all frames on the same terminal device.  */)
   XSETFRAME (frame, f);
 
   store_in_alist (&parms, Qtty_type, build_string (t->display_info.tty->type));
-  store_in_alist (&parms, Qtty, 
+  store_in_alist (&parms, Qtty,
                   (t->display_info.tty->name
                    ? build_string (t->display_info.tty->name)
                    : Qnil));
@@ -1087,6 +1078,19 @@ Otherwise, include all frames.  */)
   CHECK_LIVE_FRAME (frame);
   return prev_frame (frame, miniframe);
 }
+
+DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame,
+       Slast_nonminibuf_frame, 0, 0, 0,
+       doc: /* Return last non-minibuffer frame selected. */)
+  (void)
+{
+  Lisp_Object frame = Qnil;
+
+  if (last_nonminibuf_frame)
+    XSETFRAME (frame, last_nonminibuf_frame);
+
+  return frame;
+}
 
 /* Return 1 if it is ok to delete frame F;
    0 if all frames aside from F are invisible.
@@ -1119,6 +1123,50 @@ other_visible_frames (struct frame *f)
   return 0;
 }
 
+/* Make sure that minibuf_window doesn't refer to FRAME's minibuffer
+   window.  Preferably use the selected frame's minibuffer window
+   instead.  If the selected frame doesn't have one, get some other
+   frame's minibuffer window.  SELECT non-zero means select the new
+   minibuffer window.  */
+static void
+check_minibuf_window (Lisp_Object frame, int select)
+{
+  struct frame *f = decode_live_frame (frame);
+
+  if (WINDOWP (minibuf_window) && EQ (f->minibuffer_window, minibuf_window))
+    {
+      Lisp_Object frames, this, window = make_number (0);
+
+      if (!EQ (frame, selected_frame)
+          && FRAME_HAS_MINIBUF_P (XFRAME (selected_frame)))
+        window = FRAME_MINIBUF_WINDOW (XFRAME (selected_frame));
+      else
+        FOR_EACH_FRAME (frames, this)
+          {
+            if (!EQ (this, frame) && FRAME_HAS_MINIBUF_P (XFRAME (this)))
+              {
+                window = FRAME_MINIBUF_WINDOW (XFRAME (this));
+                break;
+              }
+          }
+
+      /* Don't abort if no window was found (Bug#15247).  */
+      if (WINDOWP (window))
+        {
+          /* Use set_window_buffer instead of Fset_window_buffer (see
+             discussion of bug#11984, bug#12025, bug#12026).  */
+          set_window_buffer (window, XWINDOW (minibuf_window)->contents, 0, 0);
+          minibuf_window = window;
+
+          /* SELECT non-zero usually means that FRAME's minibuffer
+             window was selected; select the new one.  */
+          if (select)
+            Fselect_window (minibuf_window, Qnil);
+        }
+    }
+}
+
+
 /* Delete FRAME.  When FORCE equals Qnoelisp, delete FRAME
   unconditionally.  x_connection_closed and delete_terminal use
   this.  Any other value of FORCE implements the semantics
@@ -1206,10 +1254,18 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
   /* Don't let the frame remain selected.  */
   if (f == sf)
     {
-      Lisp_Object tail, frame1;
-
-      /* Look for another visible frame on the same terminal.  */
-      frame1 = next_frame (frame, Qvisible);
+      Lisp_Object tail;
+      Lisp_Object frame1 = Qnil;
+
+      /* Look for another visible frame on the same terminal.
+         Do not call next_frame here because it may loop forever.
+         See http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15025.  */
+      FOR_EACH_FRAME (tail, frame1)
+        if (!EQ (frame, frame1)
+            && (FRAME_TERMINAL (XFRAME (frame))
+                == FRAME_TERMINAL (XFRAME (frame1)))
+            && FRAME_VISIBLE_P (XFRAME (frame1)))
+         break;
 
       /* If there is none, find *some* other frame.  */
       if (NILP (frame1) || EQ (frame1, frame))
@@ -1245,19 +1301,7 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
     }
 
   /* Don't allow minibuf_window to remain on a deleted frame.  */
-  if (EQ (f->minibuffer_window, minibuf_window))
-    {
-      /* 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)->contents, 0, 0);
-      minibuf_window = sf->minibuffer_window;
-
-      /* If the dying minibuffer window was selected,
-         select the new one.  */
-      if (minibuffer_selected)
-        Fselect_window (minibuf_window, Qnil);
-    }
+  check_minibuf_window (frame, minibuffer_selected);
 
   /* Don't let echo_area_window to remain on a deleted frame.  */
   if (EQ (f->minibuffer_window, echo_area_window))
@@ -1684,16 +1728,8 @@ displayed in the terminal.  */)
   if (NILP (force) && !other_visible_frames (f))
     error ("Attempt to make invisible the sole visible or iconified frame");
 
-  /* Don't allow minibuf_window to remain on a deleted frame.  */
-  if (EQ (f->minibuffer_window, minibuf_window))
-    {
-      struct frame *sf = XFRAME (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)->contents, 0, 0);
-      minibuf_window = sf->minibuffer_window;
-    }
+  /* Don't allow minibuf_window to remain on an invisible frame.  */
+  check_minibuf_window (frame, EQ (minibuf_window, selected_window));
 
   /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
@@ -1716,15 +1752,7 @@ If omitted, FRAME defaults to the currently selected frame.  */)
   struct frame *f = decode_live_frame (frame);
 
   /* Don't allow minibuf_window to remain on an iconified frame.  */
-  if (EQ (f->minibuffer_window, minibuf_window))
-    {
-      struct frame *sf = XFRAME (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)->contents, 0, 0);
-      minibuf_window = sf->minibuffer_window;
-    }
+  check_minibuf_window (frame, EQ (minibuf_window, selected_window));
 
   /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
@@ -3545,7 +3573,7 @@ xrdb_get_resource (XrmDatabase rdb, Lisp_Object attribute, Lisp_Object class, Li
 
   value = x_get_string_resource (rdb, name_key, class_key);
 
-  if (value != (char *) 0 && *value)
+  if (value && *value)
     return build_string (value);
   else
     return Qnil;
@@ -4204,8 +4232,7 @@ make_monitor_attribute_list (struct MonitorInfo *monitors,
                          mi->work.width, mi->work.height);
       geometry = list4i (mi->geom.x, mi->geom.y,
                          mi->geom.width, mi->geom.height);
-      attributes = Fcons (Fcons (Qsource,
-                                 make_string (source, strlen (source))),
+      attributes = Fcons (Fcons (Qsource, build_string (source)),
                           attributes);
       attributes = Fcons (Fcons (Qframes, AREF (monitor_frames, i)),
                           attributes);
@@ -4478,6 +4505,7 @@ automatically.  See also `mouse-autoselect-window'.  */);
   defsubr (&Sframe_list);
   defsubr (&Snext_frame);
   defsubr (&Sprevious_frame);
+  defsubr (&Slast_nonminibuf_frame);
   defsubr (&Sdelete_frame);
   defsubr (&Smouse_position);
   defsubr (&Smouse_pixel_position);
diff --git a/src/frame.h b/src/frame.h
index 33e4bb71d7a..17b6089120a 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -24,31 +24,13 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define EMACS_FRAME_H
 
 #include "dispextern.h"
+#include "termhooks.h"
 
 INLINE_HEADER_BEGIN
 #ifndef FRAME_INLINE
 # define FRAME_INLINE INLINE
 #endif
 
-
-/* Miscellanea.  */
-
-/* Nonzero means there is at least one garbaged frame.  */
-extern bool frame_garbaged;
-
-
-/* The structure representing a frame.  */
-
-enum output_method
-{
-  output_initial,
-  output_termcap,
-  output_x_window,
-  output_msdos_raw,
-  output_w32,
-  output_ns
-};
-
 enum vertical_scroll_bar_type
 {
   vertical_scroll_bar_none,
@@ -56,16 +38,6 @@ enum vertical_scroll_bar_type
   vertical_scroll_bar_right
 };
 
-enum text_cursor_kinds
-{
-  DEFAULT_CURSOR = -2,
-  NO_CURSOR = -1,
-  FILLED_BOX_CURSOR,
-  HOLLOW_BOX_CURSOR,
-  BAR_CURSOR,
-  HBAR_CURSOR
-};
-
 enum fullscreen_type
 {
   FULLSCREEN_NONE,
@@ -76,10 +48,7 @@ enum fullscreen_type
   FULLSCREEN_WAIT      = 0x100
 };
 
-
-#define FRAME_FOREGROUND_PIXEL(f) ((f)->foreground_pixel)
-#define FRAME_BACKGROUND_PIXEL(f) ((f)->background_pixel)
-
+/* The structure representing a frame.  */
 
 struct frame
 {
@@ -410,6 +379,10 @@ struct frame
   /* Nonzero means that the pointer is invisible. */
   unsigned pointer_invisible :1;
 
+  /* Nonzero means that all windows except mini-window and
+     selected window on this frame have frozen window starts.  */
+  unsigned frozen_window_starts : 1;
+
   /* Nonzero if we should actually display the scroll bars on this frame.  */
   enum vertical_scroll_bar_type vertical_scroll_bar_type;
 
@@ -761,6 +734,10 @@ default_pixels_per_inch_y (void)
 /* Not really implemented.  */
 #define FRAME_WANTS_MODELINE_P(f) (f)->wants_modeline
 
+/* Nonzero if all windows except selected window and mini window
+   are frozen on frame F.  */
+#define FRAME_WINDOWS_FROZEN(f) (f)->frozen_window_starts
+
 /* Nonzero if a size change has been requested for frame F
    but not yet really put into effect.  This can be true temporarily
    when an X event comes in at a bad time.  */
@@ -886,6 +863,9 @@ default_pixels_per_inch_y (void)
 #define FRAME_CURSOR_WIDTH(f) ((f)->cursor_width)
 #define FRAME_BLINK_OFF_CURSOR_WIDTH(f) ((f)->blink_off_cursor_width)
 
+#define FRAME_FOREGROUND_PIXEL(f) ((f)->foreground_pixel)
+#define FRAME_BACKGROUND_PIXEL(f) ((f)->background_pixel)
+
 /* Return a pointer to the face cache of frame F.  */
 
 #define FRAME_FACE_CACHE(F)     (F)->face_cache
@@ -952,6 +932,9 @@ extern Lisp_Object Qtty_color_mode;
 extern Lisp_Object Qterminal;
 extern Lisp_Object Qnoelisp;
 
+/* Nonzero means there is at least one garbaged frame.  */
+extern bool frame_garbaged;
+
 extern struct frame *last_nonminibuf_frame;
 
 extern void set_menu_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
diff --git a/src/fringe.c b/src/fringe.c
index 1d05244e64e..492eddae8d4 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -666,7 +666,7 @@ draw_fringe_bitmap_1 (struct window *w, struct glyph_row *row, int left_p, int o
                      and OTOH leaving out that one pixel leaves behind
                      traces of the cursor, if it was in column zero
                      before drawing non-empty margin area.  */
-                  && NILP (w->left_margin_cols))
+                  && w->left_margin_cols == 0)
                  ? 1 : 0);
           p.bx = x - wd;
           p.nx = wd;
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 237d031295c..6228f2150f5 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -35,6 +35,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "keyboard.h"
 #include "charset.h"
 #include "coding.h"
+#include "font.h"
+
 #include <gdk/gdkkeysyms.h>
 #include "xsettings.h"
 
@@ -641,7 +643,7 @@ hierarchy_ch_cb (GtkWidget *widget,
                  GtkWidget *previous_toplevel,
                  gpointer   user_data)
 {
-  struct frame *f = (struct frame *) user_data;
+  struct frame *f = user_data;
   struct x_output *x = f->output_data.x;
   GtkWidget *top = gtk_widget_get_toplevel (x->ttip_lbl);
 
@@ -663,7 +665,7 @@ qttip_cb (GtkWidget  *widget,
           GtkTooltip *tooltip,
           gpointer    user_data)
 {
-  struct frame *f = (struct frame *) user_data;
+  struct frame *f = user_data;
   struct x_output *x = f->output_data.x;
   if (x->ttip_widget == NULL)
     {
@@ -870,29 +872,23 @@ xg_clear_under_internal_border (struct frame *f)
   if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0)
     {
       GtkWidget *wfixed = f->output_data.x->edit_widget;
+
       gtk_widget_queue_draw (wfixed);
       gdk_window_process_all_updates ();
-      x_clear_area (FRAME_X_DISPLAY (f),
-                    FRAME_X_WINDOW (f),
-                    0, 0,
-                    FRAME_PIXEL_WIDTH (f),
-                    FRAME_INTERNAL_BORDER_WIDTH (f), 0);
-      x_clear_area (FRAME_X_DISPLAY (f),
-                    FRAME_X_WINDOW (f),
-                    0, 0,
-                    FRAME_INTERNAL_BORDER_WIDTH (f),
-                    FRAME_PIXEL_HEIGHT (f), 0);
-      x_clear_area (FRAME_X_DISPLAY (f),
-                    FRAME_X_WINDOW (f),
-                    0, FRAME_PIXEL_HEIGHT (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
-                    FRAME_PIXEL_WIDTH (f),
-                    FRAME_INTERNAL_BORDER_WIDTH (f), 0);
-      x_clear_area (FRAME_X_DISPLAY (f),
-                    FRAME_X_WINDOW (f),
-                    FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
-                    0,
-                    FRAME_INTERNAL_BORDER_WIDTH (f),
-                    FRAME_PIXEL_HEIGHT (f), 0);
+
+      x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0, 0,
+                    FRAME_PIXEL_WIDTH (f), FRAME_INTERNAL_BORDER_WIDTH (f));
+
+      x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0, 0,
+                    FRAME_INTERNAL_BORDER_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
+
+      x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0,
+                    FRAME_PIXEL_HEIGHT (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
+                    FRAME_PIXEL_WIDTH (f), FRAME_INTERNAL_BORDER_WIDTH (f));
+
+      x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+                    FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
+                    0, FRAME_INTERNAL_BORDER_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
     }
 }
 
@@ -1073,7 +1069,7 @@ style_changed_cb (GObject *go,
                   gpointer user_data)
 {
   struct input_event event;
-  GdkDisplay *gdpy = (GdkDisplay *) user_data;
+  GdkDisplay *gdpy = user_data;
   const char *display_name = gdk_display_get_name (gdpy);
   Display *dpy = GDK_DISPLAY_XDISPLAY (gdpy);
 
@@ -1115,7 +1111,7 @@ delete_cb (GtkWidget *widget,
 #ifdef HAVE_GTK3
   /* The event doesn't arrive in the normal event loop.  Send event
      here.  */
-  struct frame *f = (struct frame *) user_data;
+  struct frame *f = user_data;
   struct input_event ie;
 
   EVENT_INIT (ie);
@@ -1341,6 +1337,7 @@ x_wm_set_size_hint (struct frame *f, long int flags, bool user_position)
   int base_width, base_height;
   int min_rows = 0, min_cols = 0;
   int win_gravity = f->win_gravity;
+  Lisp_Object fs_state, frame;
 
   /* Don't set size hints during initialization; that apparently leads
      to a race condition.  See the thread at
@@ -1348,6 +1345,16 @@ x_wm_set_size_hint (struct frame *f, long int flags, bool user_position)
   if (NILP (Vafter_init_time) || !FRAME_GTK_OUTER_WIDGET (f))
     return;
 
+  XSETFRAME (frame, f);
+  fs_state = Fframe_parameter (frame, Qfullscreen);
+  if (EQ (fs_state, Qmaximized) || EQ (fs_state, Qfullboth))
+    {
+      /* Don't set hints when maximized or fullscreen.  Apparently KWin and
+         Gtk3 don't get along and the frame shrinks (!).
+      */
+      return;
+    }
+
   if (flags)
     {
       memset (&size_hints, 0, sizeof (size_hints));
@@ -1642,7 +1649,7 @@ xg_dialog_response_cb (GtkDialog *w,
                        gint response,
                        gpointer user_data)
 {
-  struct xg_dialog_data *dd = (struct xg_dialog_data *)user_data;
+  struct xg_dialog_data *dd = user_data;
   dd->response = response;
   g_main_loop_quit (dd->loop);
 }
@@ -1671,16 +1678,16 @@ pop_down_dialog (void *arg)
 static gboolean
 xg_maybe_add_timer (gpointer data)
 {
-  struct xg_dialog_data *dd = (struct xg_dialog_data *) data;
-  EMACS_TIME next_time = timer_check ();
+  struct xg_dialog_data *dd = data;
+  struct timespec next_time = timer_check ();
 
   dd->timerid = 0;
 
-  if (EMACS_TIME_VALID_P (next_time))
+  if (timespec_valid_p (next_time))
     {
-      time_t s = EMACS_SECS (next_time);
-      int per_ms = EMACS_TIME_RESOLUTION / 1000;
-      int ms = (EMACS_NSECS (next_time) + per_ms - 1) / per_ms;
+      time_t s = next_time.tv_sec;
+      int per_ms = TIMESPEC_RESOLUTION / 1000;
+      int ms = (next_time.tv_nsec + per_ms - 1) / per_ms;
       if (s <= ((guint) -1 - ms) / 1000)
         dd->timerid = g_timeout_add (s * 1000 + ms, xg_maybe_add_timer, dd);
     }
@@ -1921,7 +1928,7 @@ static char *
 xg_get_file_name_from_selector (GtkWidget *w)
 {
   GtkFileSelection *filesel = GTK_FILE_SELECTION (w);
-  return xstrdup ((char*) gtk_file_selection_get_filename (filesel));
+  return xstrdup (gtk_file_selection_get_filename (filesel));
 }
 
 /* Create a file selection dialog.
@@ -2039,7 +2046,6 @@ xg_get_file_name (struct frame *f,
 
 
 static char *x_last_font_name;
-extern Lisp_Object Qxft;
 
 /* Pop up a GTK font selector and return the name of the font the user
    selects, as a C string.  The returned font name follows GTK's own
@@ -2277,7 +2283,7 @@ menuitem_destroy_callback (GtkWidget *w, gpointer client_data)
 {
   if (client_data)
     {
-      xg_menu_item_cb_data *data = (xg_menu_item_cb_data*) client_data;
+      xg_menu_item_cb_data *data = client_data;
       xg_list_remove (&xg_menu_item_cb_list, &data->ptrs);
       xfree (data);
     }
@@ -2301,8 +2307,7 @@ menuitem_highlight_callback (GtkWidget *w,
 
   ev.crossing = *event;
   subwidget = gtk_get_event_widget (&ev);
-  data = (xg_menu_item_cb_data *) g_object_get_data (G_OBJECT (subwidget),
-                                                     XG_ITEM_DATA);
+  data = g_object_get_data (G_OBJECT (subwidget), XG_ITEM_DATA);
   if (data)
     {
       if (! NILP (data->help) && data->cl_data->highlight_cb)
@@ -2323,7 +2328,7 @@ menuitem_highlight_callback (GtkWidget *w,
 static void
 menu_destroy_callback (GtkWidget *w, gpointer client_data)
 {
-  unref_cl_data ((xg_menu_cb_data*) client_data);
+  unref_cl_data (client_data);
 }
 
 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
@@ -3064,8 +3069,7 @@ xg_update_menu_item (widget_value *val,
   else if (val->enabled && ! gtk_widget_get_sensitive (w))
     gtk_widget_set_sensitive (w, TRUE);
 
-  cb_data = (xg_menu_item_cb_data*) g_object_get_data (G_OBJECT (w),
-                                                       XG_ITEM_DATA);
+  cb_data = g_object_get_data (G_OBJECT (w), XG_ITEM_DATA);
   if (cb_data)
     {
       cb_data->call_data = val->call_data;
@@ -3271,8 +3275,7 @@ xg_modify_menubar_widgets (GtkWidget *menubar, struct frame *f,
 
   if (! list) return;
 
-  cl_data = (xg_menu_cb_data*) g_object_get_data (G_OBJECT (menubar),
-                                                  XG_FRAME_DATA);
+  cl_data = g_object_get_data (G_OBJECT (menubar), XG_FRAME_DATA);
 
   xg_update_menubar (menubar, f, &list, list, 0, val->contents,
                      select_cb, deactivate_cb, highlight_cb, cl_data);
@@ -3336,7 +3339,7 @@ static void
 menubar_map_cb (GtkWidget *w, gpointer user_data)
 {
   GtkRequisition req;
-  struct frame *f = (struct frame *) user_data;
+  struct frame *f = user_data;
   gtk_widget_get_preferred_size (w, NULL, &req);
   if (FRAME_MENUBAR_HEIGHT (f) != req.height)
     {
@@ -3742,14 +3745,11 @@ xg_update_scrollbar_pos (struct frame *f,
       gtk_widget_queue_draw (wfixed);
       gdk_window_process_all_updates ();
       if (oldx != -1 && oldw > 0 && oldh > 0)
-        {
-          /* Clear under old scroll bar position.  This must be done after
-             the gtk_widget_queue_draw and gdk_window_process_all_updates
-             above.  */
-          x_clear_area (FRAME_X_DISPLAY (f),
-                        FRAME_X_WINDOW (f),
-                        oldx, oldy, oldw, oldh, 0);
-        }
+        /* Clear under old scroll bar position.  This must be done after
+           the gtk_widget_queue_draw and gdk_window_process_all_updates
+           above.  */
+        x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+                      oldx, oldy, oldw, oldh);
 
       /* GTK does not redraw until the main loop is entered again, but
          if there are no X events pending we will not enter it.  So we sync
@@ -3783,7 +3783,7 @@ xg_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar,
 
   struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
 
-  if (wscroll && NILP (bar->dragging))
+  if (wscroll && bar->dragging == -1)
     {
       GtkAdjustment *adj;
       gdouble shown;
@@ -3946,8 +3946,7 @@ xg_tool_bar_callback (GtkWidget *w, gpointer client_data)
   gpointer gmod = g_object_get_data (G_OBJECT (w), XG_TOOL_BAR_LAST_MODIFIER);
   intptr_t mod = (intptr_t) gmod;
 
-  struct frame *f = (struct frame *) g_object_get_data (G_OBJECT (w),
-                                                        XG_FRAME_DATA);
+  struct frame *f = g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
   Lisp_Object key, frame;
   struct input_event event;
   EVENT_INIT (event);
@@ -4020,8 +4019,8 @@ static GtkWidget *
 xg_get_tool_bar_widgets (GtkWidget *vb, GtkWidget **wimage)
 {
   GList *clist = gtk_container_get_children (GTK_CONTAINER (vb));
-  GtkWidget *c1 = (GtkWidget *) clist->data;
-  GtkWidget *c2 = clist->next ? (GtkWidget *) clist->next->data : NULL;
+  GtkWidget *c1 = clist->data;
+  GtkWidget *c2 = clist->next ? clist->next->data : NULL;
 
   *wimage = GTK_IS_IMAGE (c1) ? c1 : c2;
   g_list_free (clist);
@@ -4150,7 +4149,7 @@ xg_tool_bar_detach_callback (GtkHandleBox *wbox,
                              GtkWidget *w,
                              gpointer client_data)
 {
-  struct frame *f = (struct frame *) client_data;
+  struct frame *f = client_data;
 
   g_object_set (G_OBJECT (w), "show-arrow", !x_gtk_whole_detached_tool_bar,
                 NULL);
@@ -4187,7 +4186,7 @@ xg_tool_bar_attach_callback (GtkHandleBox *wbox,
                              GtkWidget *w,
                              gpointer client_data)
 {
-  struct frame *f = (struct frame *) client_data;
+  struct frame *f = client_data;
   g_object_set (G_OBJECT (w), "show-arrow", TRUE, NULL);
 
   if (f)
@@ -4225,8 +4224,7 @@ xg_tool_bar_help_callback (GtkWidget *w,
                            gpointer client_data)
 {
   intptr_t idx = (intptr_t) client_data;
-  struct frame *f = (struct frame *) g_object_get_data (G_OBJECT (w),
-                                                        XG_FRAME_DATA);
+  struct frame *f = g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
   Lisp_Object help, frame;
 
   if (! f || ! f->n_tool_bar_items || NILP (f->tool_bar_items))
@@ -4366,7 +4364,7 @@ tb_size_cb (GtkWidget    *widget,
   /* When tool bar is created it has one preferred size.  But when size is
      allocated between widgets, it may get another.  So we must update
      size hints if tool bar size changes.  Seen on Fedora 18 at least.  */
-  struct frame *f = (struct frame *) user_data;
+  struct frame *f = user_data;
   if (xg_update_tool_bar_sizes (f))
     x_wm_set_size_hint (f, 0, 0);
 }
@@ -5038,10 +5036,10 @@ xg_initialize (void)
                                           (gdk_display_get_default ()));
   /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
      bindings.  It doesn't seem to be any way to remove properties,
-     so we set it to VoidSymbol which in X means "no key".  */
+     so we set it to "" which in means "no key".  */
   gtk_settings_set_string_property (settings,
                                     "gtk-menu-bar-accel",
-                                    "VoidSymbol",
+                                    "",
                                     EMACS_CLASS);
 
   /* Make GTK text input widgets use Emacs style keybindings.  This is
diff --git a/src/gtkutil.h b/src/gtkutil.h
index 482331a8934..fc959862fd3 100644
--- a/src/gtkutil.h
+++ b/src/gtkutil.h
@@ -74,8 +74,6 @@ typedef struct xg_menu_item_cb_data_
 
 } xg_menu_item_cb_data;
 
-struct _widget_value;
-
 extern struct _widget_value *malloc_widget_value (void);
 extern void free_widget_value (struct _widget_value *);
 
diff --git a/src/image.c b/src/image.c
index 911ca8e6681..1271376bcab 100644
--- a/src/image.c
+++ b/src/image.c
@@ -30,13 +30,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 #include <setjmp.h>
-
 #include <c-ctype.h>
 
-/* This makes the fields of a Display accessible, in Xlib header files.  */
-
-#define XLIB_ILLEGAL_ACCESS
-
 #include "lisp.h"
 #include "frame.h"
 #include "window.h"
@@ -145,7 +140,7 @@ static Lisp_Object QCmax_width, QCmax_height;
 
 #ifdef HAVE_NS
 /* Use with images created by ns_image_for_XPM.  */
-unsigned long
+static unsigned long
 XGetPixel (XImagePtr ximage, int x, int y)
 {
   return ns_get_pixel (ximage, x, y);
@@ -153,7 +148,7 @@ XGetPixel (XImagePtr ximage, int x, int y)
 
 /* Use with images created by ns_image_for_XPM; alpha set to 1;
    pixel is assumed to be in RGB form.  */
-void
+static void
 XPutPixel (XImagePtr ximage, int x, int y, unsigned long pixel)
 {
   ns_put_pixel (ximage, x, y, pixel);
@@ -302,11 +297,10 @@ x_create_bitmap_from_file (struct frame *f, Lisp_Object file)
   id = x_allocate_bitmap_record (f);
   dpyinfo->bitmaps[id - 1].img = bitmap;
   dpyinfo->bitmaps[id - 1].refcount = 1;
-  dpyinfo->bitmaps[id - 1].file = xmalloc (SBYTES (file) + 1);
+  dpyinfo->bitmaps[id - 1].file = xlispstrdup (file);
   dpyinfo->bitmaps[id - 1].depth = 1;
   dpyinfo->bitmaps[id - 1].height = ns_image_width (bitmap);
   dpyinfo->bitmaps[id - 1].width = ns_image_height (bitmap);
-  strcpy (dpyinfo->bitmaps[id - 1].file, SSDATA (file));
   return id;
 #endif
 
@@ -345,11 +339,10 @@ x_create_bitmap_from_file (struct frame *f, Lisp_Object file)
   dpyinfo->bitmaps[id - 1].pixmap = bitmap;
   dpyinfo->bitmaps[id - 1].have_mask = 0;
   dpyinfo->bitmaps[id - 1].refcount = 1;
-  dpyinfo->bitmaps[id - 1].file = xmalloc (SBYTES (file) + 1);
+  dpyinfo->bitmaps[id - 1].file = xlispstrdup (file);
   dpyinfo->bitmaps[id - 1].depth = 1;
   dpyinfo->bitmaps[id - 1].height = height;
   dpyinfo->bitmaps[id - 1].width = width;
-  strcpy (dpyinfo->bitmaps[id - 1].file, SSDATA (file));
 
   return id;
 #endif /* HAVE_X_WINDOWS */
@@ -565,7 +558,6 @@ static void x_emboss (struct frame *, struct image *);
 static void x_build_heuristic_mask (struct frame *, struct image *,
                                     Lisp_Object);
 #ifdef WINDOWSNT
-extern Lisp_Object Vlibrary_cache;
 #define CACHE_IMAGE_TYPE(type, status) \
   do { Vlibrary_cache = Fcons (Fcons (type, status), Vlibrary_cache); } while (0)
 #else
@@ -1044,7 +1036,7 @@ void
 prepare_image_for_display (struct frame *f, struct image *img)
 {
   /* We're about to display IMG, so set its timestamp to `now'.  */
-  img->timestamp = current_emacs_time ();
+  img->timestamp = current_timespec ();
 
   /* If IMG doesn't have a pixmap yet, load it now, using the image
      type dependent loader function.  */
@@ -1362,14 +1354,12 @@ static void cache_image (struct frame *f, struct image *img);
 struct image_cache *
 make_image_cache (void)
 {
-  struct image_cache *c = xzalloc (sizeof *c);
-  int size;
+  struct image_cache *c = xmalloc (sizeof *c);
 
-  size = 50;
-  c->images = xmalloc (size * sizeof *c->images);
-  c->size = size;
-  size = IMAGE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
-  c->buckets = xzalloc (size);
+  c->size = 50;
+  c->used = c->refcount = 0;
+  c->images = xmalloc (c->size * sizeof *c->images);
+  c->buckets = xzalloc (IMAGE_CACHE_BUCKETS_SIZE * sizeof *c->buckets);
   return c;
 }
 
@@ -1485,7 +1475,7 @@ clear_image_cache (struct frame *f, Lisp_Object filter)
       else if (INTEGERP (Vimage_cache_eviction_delay))
         {
           /* Free cache based on timestamp.  */
-          EMACS_TIME old, t;
+          struct timespec old, t;
           double delay;
           ptrdiff_t nimages = 0;
 
@@ -1500,13 +1490,13 @@ clear_image_cache (struct frame *f, Lisp_Object filter)
             delay = 1600 * delay / nimages / nimages;
           delay = max (delay, 1);
 
-          t = current_emacs_time ();
-          old = sub_emacs_time (t, EMACS_TIME_FROM_DOUBLE (delay));
+          t = current_timespec ();
+          old = timespec_sub (t, dtotimespec (delay));
 
           for (i = 0; i < c->used; ++i)
             {
               struct image *img = c->images[i];
-              if (img && EMACS_TIME_LT (img->timestamp, old))
+              if (img && timespec_cmp (img->timestamp, old) < 0)
                 {
                   free_image (f, img);
                   ++nfreed;
@@ -1769,7 +1759,7 @@ lookup_image (struct frame *f, Lisp_Object spec)
     }
 
   /* We're using IMG, so set its timestamp to `now'.  */
-  img->timestamp = current_emacs_time ();
+  img->timestamp = current_timespec ();
 
   /* Value is the image id.  */
   return img->id;
@@ -2717,10 +2707,13 @@ xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *e
      LA1 = xbm_scan (&s, end, buffer, &value)
 
 #define expect(TOKEN)           \
-     if (LA1 != (TOKEN))        \
-       goto failure;            \
-     else                       \
-       match ()
+  do                            \
+    {                           \
+      if (LA1 != (TOKEN))       \
+        goto failure;           \
+      match ();                 \
+    }                           \
+  while (0)
 
 #define expect_ident(IDENT)                                     \
      if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0)  \
@@ -3332,7 +3325,7 @@ static int
 xpm_alloc_color (Display *dpy, Colormap cmap, char *color_name, XColor *color,
                  void *closure)
 {
-  return xpm_lookup_color ((struct frame *) closure, color_name, color);
+  return xpm_lookup_color (closure, color_name, color);
 }
 
 
@@ -3980,10 +3973,13 @@ xpm_load_image (struct frame *f,
      LA1 = xpm_scan (&s, end, &beg, &len)
 
 #define expect(TOKEN)           \
-     if (LA1 != (TOKEN))        \
-       goto failure;            \
-     else                       \
-       match ()
+  do                            \
+    {                           \
+      if (LA1 != (TOKEN))       \
+        goto failure;           \
+      match ();                 \
+    }                           \
+  while (0)
 
 #define expect_ident(IDENT)                                     \
      if (LA1 == XPM_TK_IDENT \
@@ -4936,7 +4932,7 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
   int row_width;
 #endif /* HAVE_NTGUI */
   int x, y;
-  bool rc, use_img_background;
+  bool use_img_background;
   unsigned long bg = 0;
 
   if (img->mask)
@@ -4945,9 +4941,8 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
 #ifndef HAVE_NTGUI
 #ifndef HAVE_NS
   /* Create an image and pixmap serving as mask.  */
-  rc = image_create_x_image_and_pixmap (f, img, img->width, img->height, 1,
-                                        &mask_img, 1);
-  if (!rc)
+  if (! image_create_x_image_and_pixmap (f, img, img->width, img->height, 1,
+                                         &mask_img, 1))
     return;
 #endif /* !HAVE_NS */
 #else
@@ -5652,8 +5647,7 @@ struct png_memory_storage
 static void
 png_read_from_memory (png_structp png_ptr, png_bytep data, png_size_t length)
 {
-  struct png_memory_storage *tbr
-    = (struct png_memory_storage *) fn_png_get_io_ptr (png_ptr);
+  struct png_memory_storage *tbr = fn_png_get_io_ptr (png_ptr);
 
   if (length > tbr->len - tbr->index)
     fn_png_error (png_ptr, "Read error");
@@ -5670,7 +5664,7 @@ png_read_from_memory (png_structp png_ptr, png_bytep data, png_size_t length)
 static void
 png_read_from_file (png_structp png_ptr, png_bytep data, png_size_t length)
 {
-  FILE *fp = (FILE *) fn_png_get_io_ptr (png_ptr);
+  FILE *fp = fn_png_get_io_ptr (png_ptr);
 
   if (fread (data, 1, length, fp) < length)
     fn_png_error (png_ptr, "Read error");
@@ -5814,9 +5808,9 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
   /* Read image info.  */
   if (!NILP (specified_data))
-    fn_png_set_read_fn (png_ptr, (void *) &tbr, png_read_from_memory);
+    fn_png_set_read_fn (png_ptr, &tbr, png_read_from_memory);
   else
-    fn_png_set_read_fn (png_ptr, (void *) fp, png_read_from_file);
+    fn_png_set_read_fn (png_ptr, fp, png_read_from_file);
 
   fn_png_set_sig_bytes (png_ptr, sizeof sig);
   fn_png_read_info (png_ptr, info_ptr);
@@ -6306,7 +6300,7 @@ our_memory_fill_input_buffer (j_decompress_ptr cinfo)
 static void
 our_memory_skip_input_data (j_decompress_ptr cinfo, long int num_bytes)
 {
-  struct jpeg_source_mgr *src = (struct jpeg_source_mgr *) cinfo->src;
+  struct jpeg_source_mgr *src = cinfo->src;
 
   if (src)
     {
@@ -6326,19 +6320,17 @@ our_memory_skip_input_data (j_decompress_ptr cinfo, long int num_bytes)
 static void
 jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, ptrdiff_t len)
 {
-  struct jpeg_source_mgr *src;
+  struct jpeg_source_mgr *src = cinfo->src;
 
-  if (cinfo->src == NULL)
+  if (! src)
     {
       /* First time for this JPEG object?  */
-      cinfo->src = (struct jpeg_source_mgr *)
-        (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
-                                    sizeof (struct jpeg_source_mgr));
-      src = (struct jpeg_source_mgr *) cinfo->src;
+      src = cinfo->mem->alloc_small ((j_common_ptr) cinfo,
+                                     JPOOL_PERMANENT, sizeof *src);
+      cinfo->src = src;
       src->next_input_byte = data;
     }
 
-  src = (struct jpeg_source_mgr *) cinfo->src;
   src->init_source = our_common_init_source;
   src->fill_input_buffer = our_memory_fill_input_buffer;
   src->skip_input_data = our_memory_skip_input_data;
@@ -6430,20 +6422,17 @@ our_stdio_skip_input_data (j_decompress_ptr cinfo, long int num_bytes)
 static void
 jpeg_file_src (j_decompress_ptr cinfo, FILE *fp)
 {
-  struct jpeg_stdio_mgr *src;
+  struct jpeg_stdio_mgr *src = (struct jpeg_stdio_mgr *) cinfo->src;
 
-  if (cinfo->src != NULL)
-      src = (struct jpeg_stdio_mgr *) cinfo->src;
-  else
+  if (! src)
     {
       /* First time for this JPEG object?  */
-      cinfo->src = (struct jpeg_source_mgr *)
-        (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
-                                    sizeof (struct jpeg_stdio_mgr));
-      src = (struct jpeg_stdio_mgr *) cinfo->src;
-      src->buffer = (JOCTET *)
-          (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
-                                      JPEG_STDIO_BUFFER_SIZE);
+      src = cinfo->mem->alloc_small ((j_common_ptr) cinfo,
+                                     JPOOL_PERMANENT, sizeof *src);
+      cinfo->src = (struct jpeg_source_mgr *) src;
+      src->buffer = cinfo->mem->alloc_small ((j_common_ptr) cinfo,
+                                             JPOOL_PERMANENT,
+                                             JPEG_STDIO_BUFFER_SIZE);
     }
 
   src->file = fp;
@@ -7746,6 +7735,7 @@ enum imagemagick_keyword_index
     IMAGEMAGICK_WIDTH,
     IMAGEMAGICK_MAX_HEIGHT,
     IMAGEMAGICK_MAX_WIDTH,
+    IMAGEMAGICK_FORMAT,
     IMAGEMAGICK_ROTATION,
     IMAGEMAGICK_CROP,
     IMAGEMAGICK_LAST
@@ -7770,6 +7760,7 @@ static struct image_keyword imagemagick_format[IMAGEMAGICK_LAST] =
     {":width",          IMAGE_INTEGER_VALUE,                    0},
     {":max-height",     IMAGE_INTEGER_VALUE,                    0},
     {":max-width",      IMAGE_INTEGER_VALUE,                    0},
+    {":format",         IMAGE_SYMBOL_VALUE,                     0},
     {":rotation",       IMAGE_NUMBER_VALUE,                     0},
     {":crop",           IMAGE_DONT_CHECK_VALUE_TYPE,            0}
   };
@@ -7848,6 +7839,233 @@ imagemagick_error (MagickWand *wand)
   description = (char *) MagickRelinquishMemory (description);
 }
 
+/* Possibly give ImageMagick some extra help to determine the image
+   type by supplying a "dummy" filename based on the Content-Type.  */
+
+static char *
+imagemagick_filename_hint (Lisp_Object spec, char hint_buffer[MaxTextExtent])
+{
+  Lisp_Object symbol = intern ("image-format-suffixes");
+  Lisp_Object val = find_symbol_value (symbol);
+  Lisp_Object format;
+
+  if (! CONSP (val))
+    return NULL;
+
+  format = image_spec_value (spec, intern (":format"), NULL);
+  val = Fcar_safe (Fcdr_safe (Fassq (format, val)));
+  if (! STRINGP (val))
+    return NULL;
+
+  /* It's OK to truncate the hint if it has MaxTextExtent or more bytes,
+     as ImageMagick would ignore the extra bytes anyway.  */
+  snprintf (hint_buffer, MaxTextExtent, "/tmp/foo.%s", SSDATA (val));
+  return hint_buffer;
+}
+
+/* Animated images (e.g., GIF89a) are composed from one "master image"
+   (which is the first one, and then there's a number of images that
+   follow.  If following images have non-transparent colors, these are
+   composed "on top" of the master image.  So, in general, one has to
+   compute ann the preceding images to be able to display a particular
+   sub-image.
+
+   Computing all the preceding images is too slow, so we maintain a
+   cache of previously computed images.  We have to maintain a cache
+   separate from the image cache, because the images may be scaled
+   before display. */
+
+struct animation_cache
+{
+  MagickWand *wand;
+  int index;
+  struct timespec update_time;
+  struct animation_cache *next;
+  char signature[FLEXIBLE_ARRAY_MEMBER];
+};
+
+static struct animation_cache *animation_cache = NULL;
+
+static struct animation_cache *
+imagemagick_create_cache (char *signature)
+{
+  struct animation_cache *cache
+    = xmalloc (offsetof (struct animation_cache, signature)
+               + strlen (signature) + 1);
+  cache->wand = 0;
+  cache->index = 0;
+  cache->next = 0;
+  strcpy (cache->signature, signature);
+  return cache;
+}
+
+/* Discard cached images that haven't been used for a minute. */
+static void
+imagemagick_prune_animation_cache (void)
+{
+  struct animation_cache **pcache = &animation_cache;
+  struct timespec old = timespec_sub (current_timespec (),
+                                      make_timespec (60, 0));
+
+  while (*pcache)
+    {
+      struct animation_cache *cache = *pcache;
+      if (timespec_cmp (old, cache->update_time) <= 0)
+        pcache = &cache->next;
+      else
+        {
+          if (cache->wand)
+            DestroyMagickWand (cache->wand);
+          *pcache = cache->next;
+          xfree (cache);
+        }
+    }
+}
+
+static struct animation_cache *
+imagemagick_get_animation_cache (MagickWand *wand)
+{
+  char *signature = MagickGetImageSignature (wand);
+  struct animation_cache *cache;
+  struct animation_cache **pcache = &animation_cache;
+
+  imagemagick_prune_animation_cache ();
+
+  while (1)
+    {
+      cache = *pcache;
+      if (! cache)
+        {
+          *pcache = cache = imagemagick_create_cache (signature);
+          break;
+        }
+      if (strcmp (signature, cache->signature) == 0)
+        break;
+      pcache = &cache->next;
+    }
+
+  DestroyString (signature);
+  cache->update_time = current_timespec ();
+  return cache;
+}
+
+static MagickWand *
+imagemagick_compute_animated_image (MagickWand *super_wand, int ino)
+{
+  int i;
+  MagickWand *composite_wand;
+  size_t dest_width, dest_height;
+  struct animation_cache *cache = imagemagick_get_animation_cache (super_wand);
+
+  MagickSetIteratorIndex (super_wand, 0);
+
+  if (ino == 0 || cache->wand == NULL || cache->index > ino)
+    {
+      composite_wand = MagickGetImage (super_wand);
+      if (cache->wand)
+        DestroyMagickWand (cache->wand);
+    }
+  else
+    composite_wand = cache->wand;
+
+  dest_width = MagickGetImageWidth (composite_wand);
+  dest_height = MagickGetImageHeight (composite_wand);
+
+  for (i = max (1, cache->index + 1); i <= ino; i++)
+    {
+      MagickWand *sub_wand;
+      PixelIterator *source_iterator, *dest_iterator;
+      PixelWand **source, **dest;
+      size_t source_width, source_height;
+      ssize_t source_left, source_top;
+      MagickPixelPacket pixel;
+      DisposeType dispose;
+      ptrdiff_t lines = 0;
+
+      MagickSetIteratorIndex (super_wand, i);
+      sub_wand = MagickGetImage (super_wand);
+
+      MagickGetImagePage (sub_wand, &source_width, &source_height,
+                          &source_left, &source_top);
+
+      /* This flag says how to handle transparent pixels.  */
+      dispose = MagickGetImageDispose (sub_wand);
+
+      source_iterator = NewPixelIterator (sub_wand);
+      if (! source_iterator)
+        {
+          DestroyMagickWand (composite_wand);
+          DestroyMagickWand (sub_wand);
+          cache->wand = NULL;
+          image_error ("Imagemagick pixel iterator creation failed",
+                       Qnil, Qnil);
+          return NULL;
+        }
+
+      dest_iterator = NewPixelIterator (composite_wand);
+      if (! dest_iterator)
+        {
+          DestroyMagickWand (composite_wand);
+          DestroyMagickWand (sub_wand);
+          DestroyPixelIterator (source_iterator);
+          cache->wand = NULL;
+          image_error ("Imagemagick pixel iterator creation failed",
+                       Qnil, Qnil);
+          return NULL;
+        }
+
+      /* The sub-image may not start at origin, so move the destination
+         iterator to where the sub-image should start. */
+      if (source_top > 0)
+        {
+          PixelSetIteratorRow (dest_iterator, source_top);
+          lines = source_top;
+        }
+
+      while ((source = PixelGetNextIteratorRow (source_iterator, &source_width))
+             != NULL)
+        {
+          ptrdiff_t x;
+
+          /* Sanity check.  This shouldn't happen, but apparently
+             does in some pictures.  */
+          if (++lines >= dest_height)
+            break;
+
+          dest = PixelGetNextIteratorRow (dest_iterator, &dest_width);
+          for (x = 0; x < source_width; x++)
+            {
+              /* Sanity check.  This shouldn't happen, but apparently
+                 also does in some pictures.  */
+              if (x + source_left > dest_width)
+                break;
+              /* Normally we only copy over non-transparent pixels,
+                 but if the disposal method is "Background", then we
+                 copy over all pixels.  */
+              if (dispose == BackgroundDispose ||
+                  PixelGetAlpha (source[x]))
+                {
+                  PixelGetMagickColor (source[x], &pixel);
+                  PixelSetMagickColor (dest[x + source_left], &pixel);
+                }
+            }
+          PixelSyncIterator (dest_iterator);
+        }
+
+      DestroyPixelIterator (source_iterator);
+      DestroyPixelIterator (dest_iterator);
+      DestroyMagickWand (sub_wand);
+    }
+
+  /* Cache a copy for the next iteration.  The current wand will be
+     destroyed by the caller. */
+  cache->wand = CloneMagickWand (composite_wand);
+  cache->index = ino;
+
+  return composite_wand;
+}
+
+
 /* Helper function for imagemagick_load, which does the actual loading
    given contents and size, apart from frame and image structures,
    passed from imagemagick_load.  Uses librimagemagick to do most of
@@ -7870,7 +8088,6 @@ imagemagick_load_image (struct frame *f, struct image *img,
   XImagePtr ximg;
   int x, y;
   MagickWand *image_wand;
-  MagickWand *ping_wand;
   PixelIterator *iterator;
   PixelWand **pixels, *bg_wand = NULL;
   MagickPixelPacket  pixel;
@@ -7881,6 +8098,8 @@ imagemagick_load_image (struct frame *f, struct image *img,
   int desired_width, desired_height;
   double rotation;
   int pixelwidth;
+  char hint_buffer[MaxTextExtent];
+  char *filename_hint = NULL;
 
   /* Handle image index for image types who can contain more than one image.
      Interface :index is same as for GIF.  First we "ping" the image to see how
@@ -7891,48 +8110,48 @@ imagemagick_load_image (struct frame *f, struct image *img,
   MagickWandGenesis ();
   image = image_spec_value (img->spec, QCindex, NULL);
   ino = INTEGERP (image) ? XFASTINT (image) : 0;
-  ping_wand = NewMagickWand ();
-  /* MagickSetResolution (ping_wand, 2, 2);   (Bug#10112)  */
+  image_wand = NewMagickWand ();
 
-  status = filename
-    ? MagickPingImage (ping_wand, filename)
-    : MagickPingImageBlob (ping_wand, contents, size);
+  if (filename)
+    status = MagickReadImage (image_wand, filename);
+  else
+    {
+      filename_hint = imagemagick_filename_hint (img->spec, hint_buffer);
+      MagickSetFilename (image_wand, filename_hint);
+      status = MagickReadImageBlob (image_wand, contents, size);
+    }
 
   if (status == MagickFalse)
     {
-      imagemagick_error (ping_wand);
-      DestroyMagickWand (ping_wand);
+      imagemagick_error (image_wand);
+      DestroyMagickWand (image_wand);
       return 0;
     }
 
-  if (ino < 0 || ino >= MagickGetNumberImages (ping_wand))
+  if (ino < 0 || ino >= MagickGetNumberImages (image_wand))
     {
       image_error ("Invalid image number `%s' in image `%s'",
                    image, img->spec);
-      DestroyMagickWand (ping_wand);
+      DestroyMagickWand (image_wand);
       return 0;
     }
 
-  if (MagickGetNumberImages (ping_wand) > 1)
+  if (MagickGetNumberImages (image_wand) > 1)
     img->lisp_data =
       Fcons (Qcount,
-             Fcons (make_number (MagickGetNumberImages (ping_wand)),
+             Fcons (make_number (MagickGetNumberImages (image_wand)),
                     img->lisp_data));
 
-  DestroyMagickWand (ping_wand);
-
-  /* Now we know how many images are inside the file.  If it's not a
-     bundle, the number is one.  Load the image data.  */
-
-  image_wand = NewMagickWand ();
-
-  if ((filename
-       ? MagickReadImage (image_wand, filename)
-       : MagickReadImageBlob (image_wand, contents, size))
-      == MagickFalse)
+  /* If we have an animated image, get the new wand based on the
+     "super-wand". */
+  if (MagickGetNumberImages (image_wand) > 1)
     {
-      imagemagick_error (image_wand);
-      goto imagemagick_error;
+      MagickWand *super_wand = image_wand;
+      image_wand = imagemagick_compute_animated_image (super_wand, ino);
+      if (! image_wand)
+        image_wand = super_wand;
+      else
+        DestroyMagickWand (super_wand);
     }
 
   /* Retrieve the frame's background color, for use later.  */
@@ -8120,7 +8339,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
 
       /* Copy pixels from the imagemagick image structure to the x image map. */
       iterator = NewPixelIterator (image_wand);
-      if (iterator == (PixelIterator *) NULL)
+      if (! iterator)
         {
 #ifdef COLOR_TABLE_SUPPORT
           free_color_table ();
@@ -8135,7 +8354,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
       for (y = 0; y < image_height; y++)
         {
           pixels = PixelGetNextIteratorRow (iterator, &width);
-          if (pixels == (PixelWand **) NULL)
+          if (! pixels)
             break;
           for (x = 0; x < (long) width; x++)
             {
@@ -9200,7 +9419,7 @@ A cross is always drawn on black & white displays.  */);
 
   DEFVAR_LISP ("x-bitmap-file-path", Vx_bitmap_file_path,
     doc: /* List of directories to search for window system bitmap files.  */);
-  Vx_bitmap_file_path = decode_env_path ((char *) 0, PATH_BITMAPS);
+  Vx_bitmap_file_path = decode_env_path (0, PATH_BITMAPS);
 
   DEFVAR_LISP ("image-cache-eviction-delay", Vimage_cache_eviction_delay,
     doc: /* Maximum time after which images are removed from the cache.
diff --git a/src/indent.c b/src/indent.c
index 47358e17db8..891b42788ed 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -141,13 +141,13 @@ recompute_width_table (struct buffer *buf, struct Lisp_Char_Table *disptab)
     XSETFASTINT (widthtab->contents[i], character_width (i, disptab));
 }
 
-/* Allocate or free the width run cache, as requested by the current
-   state of current_buffer's cache_long_line_scans variable.  */
+/* Allocate or free the width run cache, as requested by the
+   current state of current_buffer's cache_long_scans variable.  */
 
 static void
 width_run_cache_on_off (void)
 {
-  if (NILP (BVAR (current_buffer, cache_long_line_scans))
+  if (NILP (BVAR (current_buffer, cache_long_scans))
       /* And, for the moment, this feature doesn't work on multibyte
          characters.  */
       || !NILP (BVAR (current_buffer, enable_multibyte_characters)))
@@ -510,15 +510,10 @@ scan_for_column (ptrdiff_t *endpos, EMACS_INT *goalcol, ptrdiff_t *prevcol)
   register ptrdiff_t col = 0, prev_col = 0;
   EMACS_INT goal = goalcol ? *goalcol : MOST_POSITIVE_FIXNUM;
   ptrdiff_t end = endpos ? *endpos : PT;
-  ptrdiff_t scan, scan_byte;
-  ptrdiff_t next_boundary;
-  {
-  ptrdiff_t opoint = PT, opoint_byte = PT_BYTE;
-  scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
-  scan = PT, scan_byte = PT_BYTE;
-  SET_PT_BOTH (opoint, opoint_byte);
+  ptrdiff_t scan, scan_byte, next_boundary;
+
+  scan = find_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, NULL, &scan_byte, 1);
   next_boundary = scan;
-  }
 
   window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
   w = ! NILP (window) ? XWINDOW (window) : NULL;
@@ -835,14 +830,10 @@ This is the horizontal position of the character
 following any initial whitespace.  */)
   (void)
 {
-  Lisp_Object val;
-  ptrdiff_t opoint = PT, opoint_byte = PT_BYTE;
-
-  scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
+  ptrdiff_t posbyte;
 
-  XSETFASTINT (val, position_indentation (PT_BYTE));
-  SET_PT_BOTH (opoint, opoint_byte);
-  return val;
+  find_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, NULL, &posbyte, 1);
+  return make_number (position_indentation (posbyte));
 }
 
 static ptrdiff_t
@@ -935,16 +926,13 @@ position_indentation (ptrdiff_t pos_byte)
 bool
 indented_beyond_p (ptrdiff_t pos, ptrdiff_t pos_byte, EMACS_INT column)
 {
-  ptrdiff_t val;
-  ptrdiff_t opoint = PT, opoint_byte = PT_BYTE;
-
-  SET_PT_BOTH (pos, pos_byte);
-  while (PT > BEGV && FETCH_BYTE (PT_BYTE) == '\n')
-    scan_newline (PT - 1, PT_BYTE - 1, BEGV, BEGV_BYTE, -1, 0);
-
-  val = position_indentation (PT_BYTE);
-  SET_PT_BOTH (opoint, opoint_byte);
-  return val >= column;
+  while (pos > BEGV && FETCH_BYTE (pos_byte) == '\n')
+    {
+      DEC_BOTH (pos, pos_byte);
+      pos = find_newline (pos, pos_byte, BEGV, BEGV_BYTE,
+                          -1, NULL, &pos_byte, 0);
+    }
+  return position_indentation (pos_byte) >= column;
 }
 
 DEFUN ("move-to-column", Fmove_to_column, Smove_to_column, 1, 2,
diff --git a/src/insdel.c b/src/insdel.c
index 58c3e15c233..f746fd34330 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -1756,27 +1756,22 @@ del_range_2 (ptrdiff_t from, ptrdiff_t from_byte,
   return deletion;
 }
 
-/* Call this if you're about to change the region of current buffer
+/* Call this if you're about to change the text of current buffer
    from character positions START to END.  This checks the read-only
    properties of the region, calls the necessary modification hooks,
    and warns the next redisplay that it should pay attention to that
-   area.
-
-   If PRESERVE_CHARS_MODIFF, do not update CHARS_MODIFF.
-   Otherwise set CHARS_MODIFF to the new value of MODIFF.  */
+   area.  */
 
 void
-modify_region_1 (ptrdiff_t start, ptrdiff_t end, bool preserve_chars_modiff)
+modify_text (ptrdiff_t start, ptrdiff_t end)
 {
   prepare_to_modify_buffer (start, end, NULL);
 
   BUF_COMPUTE_UNCHANGED (current_buffer, start - 1, end);
-
   if (MODIFF <= SAVE_MODIFF)
     record_first_change ();
   MODIFF++;
-  if (! preserve_chars_modiff)
-    CHARS_MODIFF = MODIFF;
+  CHARS_MODIFF = MODIFF;
 
   bset_point_before_scroll (current_buffer, Qnil);
 }
@@ -1792,8 +1787,8 @@ modify_region_1 (ptrdiff_t start, ptrdiff_t end, bool preserve_chars_modiff)
    by holding its value temporarily in a marker.  */
 
 void
-prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
-                          ptrdiff_t *preserve_ptr)
+prepare_to_modify_buffer_1 (ptrdiff_t start, ptrdiff_t end,
+                            ptrdiff_t *preserve_ptr)
 {
   struct buffer *base_buffer;
 
@@ -1864,6 +1859,17 @@ prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
     }
 
   signal_before_change (start, end, preserve_ptr);
+  Vdeactivate_mark = Qt;
+}
+
+/* Like above, but called when we know that the buffer text
+   will be modified and region caches should be invalidated.  */
+
+void
+prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
+                          ptrdiff_t *preserve_ptr)
+{
+  prepare_to_modify_buffer_1 (start, end, preserve_ptr);
 
   if (current_buffer->newline_cache)
     invalidate_region_cache (current_buffer,
@@ -1873,10 +1879,12 @@ prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
     invalidate_region_cache (current_buffer,
                              current_buffer->width_run_cache,
                              start - BEG, Z - end);
-
-  Vdeactivate_mark = Qt;
+  if (current_buffer->bidi_paragraph_cache)
+    invalidate_region_cache (current_buffer,
+                             current_buffer->bidi_paragraph_cache,
+                             start - BEG, Z - end);
 }
-
+
 /* These macros work with an argument named `preserve_ptr'
    and a local variable named `preserve_marker'.  */
 
diff --git a/src/intervals.c b/src/intervals.c
index f2ddcd01507..ded536ca3c8 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -1821,6 +1821,18 @@ set_point (ptrdiff_t charpos)
   set_point_both (charpos, buf_charpos_to_bytepos (current_buffer, charpos));
 }
 
+/* Set PT from MARKER's clipped position.  */
+
+void
+set_point_from_marker (Lisp_Object marker)
+{
+  if (XMARKER (marker)->buffer != current_buffer)
+    signal_error ("Marker points into wrong buffer", marker);
+  set_point_both
+    (clip_to_bounds (BEGV, marker_position (marker), ZV),
+     clip_to_bounds (BEGV_BYTE, marker_byte_position (marker), ZV_BYTE));
+}
+
 /* If there's an invisible character at position POS + TEST_OFFS in the
    current buffer, and the invisible property has a `stickiness' such that
    inserting a character at position POS would inherit the property it,
diff --git a/src/keyboard.c b/src/keyboard.c
index c026b16e689..b8e05cf7925 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -360,7 +360,7 @@ Lisp_Object Qmenu_bar;
 static void recursive_edit_unwind (Lisp_Object buffer);
 static Lisp_Object command_loop (void);
 static Lisp_Object Qcommand_execute;
-EMACS_TIME timer_check (void);
+struct timespec timer_check (void);
 
 static void echo_now (void);
 static ptrdiff_t echo_length (void);
@@ -370,9 +370,9 @@ static Lisp_Object Qpolling_period;
 /* Incremented whenever a timer is run.  */
 unsigned timers_run;
 
-/* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
+/* Address (if not 0) of struct timespec to zero out if a SIGIO interrupt
    happens.  */
-EMACS_TIME *input_available_clear_time;
+struct timespec *input_available_clear_time;
 
 /* True means use SIGIO interrupts; false means use CBREAK mode.
    Default is true if INTERRUPT_INPUT is defined.  */
@@ -389,12 +389,12 @@ bool interrupts_deferred;
 
 /* The time when Emacs started being idle.  */
 
-static EMACS_TIME timer_idleness_start_time;
+static struct timespec timer_idleness_start_time;
 
 /* After Emacs stops being idle, this saves the last value
    of timer_idleness_start_time from when it was idle.  */
 
-static EMACS_TIME timer_last_idleness_start_time;
+static struct timespec timer_last_idleness_start_time;
 
 
 /* Global variable declarations.  */
@@ -1986,10 +1986,10 @@ start_polling (void)
       /* If poll timer doesn't exist, are we need one with
          a different interval, start a new one.  */
       if (poll_timer == NULL
-          || EMACS_SECS (poll_timer->interval) != polling_period)
+          || poll_timer->interval.tv_sec != polling_period)
         {
           time_t period = max (1, min (polling_period, TYPE_MAXIMUM (time_t)));
-          EMACS_TIME interval = make_emacs_time (period, 0);
+          struct timespec interval = make_timespec (period, 0);
 
           if (poll_timer)
             cancel_atimer (poll_timer);
@@ -2182,7 +2182,7 @@ show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
 /* Input of single characters from keyboard */
 
 static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, bool *used_mouse_menu,
-                                         EMACS_TIME *end_time);
+                                         struct timespec *end_time);
 static void record_char (Lisp_Object c);
 
 static Lisp_Object help_form_saved_window_configs;
@@ -2204,7 +2204,7 @@ do { if (polling_stopped_here) start_polling ();	\
        polling_stopped_here = 0; } while (0)
 
 static Lisp_Object
-read_event_from_main_queue (EMACS_TIME *end_time,
+read_event_from_main_queue (struct timespec *end_time,
                             sys_jmp_buf local_getcjmp,
                             bool *used_mouse_menu)
 {
@@ -2217,7 +2217,7 @@ read_event_from_main_queue (EMACS_TIME *end_time,
   /* Read from the main queue, and if that gives us something we can't use yet,
      we put it on the appropriate side queue and try again.  */
 
-  if (end_time && EMACS_TIME_LE (*end_time, current_emacs_time ()))
+  if (end_time && timespec_cmp (*end_time, current_timespec ()) <= 0)
     return c;
 
   /* Actually read a character, waiting if necessary.  */
@@ -2278,7 +2278,7 @@ read_event_from_main_queue (EMACS_TIME *end_time,
 /* Like `read_event_from_main_queue' but applies keyboard-coding-system
    to tty input.  */
 static Lisp_Object
-read_decoded_event_from_main_queue (EMACS_TIME *end_time,
+read_decoded_event_from_main_queue (struct timespec *end_time,
                                     sys_jmp_buf local_getcjmp,
                                     Lisp_Object prev_event,
                                     bool *used_mouse_menu)
@@ -2376,7 +2376,7 @@ read_decoded_event_from_main_queue (EMACS_TIME *end_time,
    Value is -2 when we find input on another keyboard.  A second call
    to read_char will read it.
 
-   If END_TIME is non-null, it is a pointer to an EMACS_TIME
+   If END_TIME is non-null, it is a pointer to a struct timespec
    specifying the maximum time to wait until.  If no input arrives by
    that time, stop waiting and return nil.
 
@@ -2385,7 +2385,7 @@ read_decoded_event_from_main_queue (EMACS_TIME *end_time,
 Lisp_Object
 read_char (int commandflag, Lisp_Object map,
            Lisp_Object prev_event,
-           bool *used_mouse_menu, EMACS_TIME *end_time)
+           bool *used_mouse_menu, struct timespec *end_time)
 {
   Lisp_Object c;
   ptrdiff_t jmpcount;
@@ -2877,7 +2877,7 @@ read_char (int commandflag, Lisp_Object map,
     {
       c = read_decoded_event_from_main_queue (end_time, local_getcjmp,
                                               prev_event, used_mouse_menu);
-      if (end_time && EMACS_TIME_LE (*end_time, current_emacs_time ()))
+      if (end_time && timespec_cmp (*end_time, current_timespec ()) <= 0)
         goto exit;
       if (EQ (c, make_number (-2)))
         {
@@ -3798,7 +3798,7 @@ clear_event (struct input_event *event)
 static Lisp_Object
 kbd_buffer_get_event (KBOARD **kbp,
                       bool *used_mouse_menu,
-                      EMACS_TIME *end_time)
+                      struct timespec *end_time)
 {
   Lisp_Object obj;
 
@@ -3856,15 +3856,15 @@ kbd_buffer_get_event (KBOARD **kbp,
         break;
       if (end_time)
         {
-          EMACS_TIME now = current_emacs_time ();
-          if (EMACS_TIME_LE (*end_time, now))
+          struct timespec now = current_timespec ();
+          if (timespec_cmp (*end_time, now) <= 0)
             return Qnil;        /* Finished waiting.  */
           else
             {
-              EMACS_TIME duration = sub_emacs_time (*end_time, now);
-              wait_reading_process_output (min (EMACS_SECS (duration),
+              struct timespec duration = timespec_sub (*end_time, now);
+              wait_reading_process_output (min (duration.tv_sec,
                                                 WAIT_READING_MAX),
-                                           EMACS_NSECS (duration),
+                                           duration.tv_nsec,
                                            -1, 1, Qnil, NULL, 0);
             }
         }
@@ -4295,10 +4295,10 @@ static void
 timer_start_idle (void)
 {
   /* If we are already in the idle state, do nothing.  */
-  if (EMACS_TIME_VALID_P (timer_idleness_start_time))
+  if (timespec_valid_p (timer_idleness_start_time))
     return;
 
-  timer_idleness_start_time = current_emacs_time ();
+  timer_idleness_start_time = current_timespec ();
   timer_last_idleness_start_time = timer_idleness_start_time;
 
   /* Mark all idle-time timers as once again candidates for running.  */
@@ -4310,7 +4310,7 @@ timer_start_idle (void)
 static void
 timer_stop_idle (void)
 {
-  timer_idleness_start_time = invalid_emacs_time ();
+  timer_idleness_start_time = invalid_timespec ();
 }
 
 /* Resume idle timer from last idle start time.  */
@@ -4318,7 +4318,7 @@ timer_stop_idle (void)
 static void
 timer_resume_idle (void)
 {
-  if (EMACS_TIME_VALID_P (timer_idleness_start_time))
+  if (timespec_valid_p (timer_idleness_start_time))
     return;
 
   timer_idleness_start_time = timer_last_idleness_start_time;
@@ -4334,7 +4334,7 @@ Lisp_Object pending_funcalls;
 
 /* Return true if TIMER is a valid timer, placing its value into *RESULT.  */
 static bool
-decode_timer (Lisp_Object timer, EMACS_TIME *result)
+decode_timer (Lisp_Object timer, struct timespec *result)
 {
   Lisp_Object *vector;
 
@@ -4361,16 +4361,16 @@ decode_timer (Lisp_Object timer, EMACS_TIME *result)
    In that case we return 0 to indicate that a new timer_check_2 call
    should be done.  */
 
-static EMACS_TIME
+static struct timespec
 timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
 {
-  EMACS_TIME nexttime;
-  EMACS_TIME now;
-  EMACS_TIME idleness_now;
+  struct timespec nexttime;
+  struct timespec now;
+  struct timespec idleness_now;
   Lisp_Object chosen_timer;
   struct gcpro gcpro1;
 
-  nexttime = invalid_emacs_time ();
+  nexttime = invalid_timespec ();
 
   chosen_timer = Qnil;
   GCPRO1 (chosen_timer);
@@ -4385,19 +4385,19 @@ timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
 
   if (CONSP (timers) || CONSP (idle_timers))
     {
-      now = current_emacs_time ();
-      idleness_now = (EMACS_TIME_VALID_P (timer_idleness_start_time)
-                      ? sub_emacs_time (now, timer_idleness_start_time)
-                      : make_emacs_time (0, 0));
+      now = current_timespec ();
+      idleness_now = (timespec_valid_p (timer_idleness_start_time)
+                      ? timespec_sub (now, timer_idleness_start_time)
+                      : make_timespec (0, 0));
     }
 
   while (CONSP (timers) || CONSP (idle_timers))
     {
       Lisp_Object timer = Qnil, idle_timer = Qnil;
-      EMACS_TIME timer_time, idle_timer_time;
-      EMACS_TIME difference;
-      EMACS_TIME timer_difference = invalid_emacs_time ();
-      EMACS_TIME idle_timer_difference = invalid_emacs_time ();
+      struct timespec timer_time, idle_timer_time;
+      struct timespec difference;
+      struct timespec timer_difference = invalid_timespec ();
+      struct timespec idle_timer_difference = invalid_timespec ();
       bool ripe, timer_ripe = 0, idle_timer_ripe = 0;
 
       /* Set TIMER and TIMER_DIFFERENCE
@@ -4414,10 +4414,10 @@ timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
               continue;
             }
 
-          timer_ripe = EMACS_TIME_LE (timer_time, now);
+          timer_ripe = timespec_cmp (timer_time, now) <= 0;
           timer_difference = (timer_ripe
-                              ? sub_emacs_time (now, timer_time)
-                              : sub_emacs_time (timer_time, now));
+                              ? timespec_sub (now, timer_time)
+                              : timespec_sub (timer_time, now));
         }
 
       /* Likewise for IDLE_TIMER and IDLE_TIMER_DIFFERENCE
@@ -4431,26 +4431,27 @@ timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
               continue;
             }
 
-          idle_timer_ripe = EMACS_TIME_LE (idle_timer_time, idleness_now);
+          idle_timer_ripe = timespec_cmp (idle_timer_time, idleness_now) <= 0;
           idle_timer_difference
             = (idle_timer_ripe
-               ? sub_emacs_time (idleness_now, idle_timer_time)
-               : sub_emacs_time (idle_timer_time, idleness_now));
+               ? timespec_sub (idleness_now, idle_timer_time)
+               : timespec_sub (idle_timer_time, idleness_now));
         }
 
       /* Decide which timer is the next timer,
          and set CHOSEN_TIMER, DIFFERENCE, and RIPE accordingly.
          Also step down the list where we found that timer.  */
 
-      if (EMACS_TIME_VALID_P (timer_difference)
-          && (! EMACS_TIME_VALID_P (idle_timer_difference)
+      if (timespec_valid_p (timer_difference)
+          && (! timespec_valid_p (idle_timer_difference)
               || idle_timer_ripe < timer_ripe
               || (idle_timer_ripe == timer_ripe
-                  && (timer_ripe
-                      ? EMACS_TIME_LT (idle_timer_difference,
+                  && ((timer_ripe
+                       ? timespec_cmp (idle_timer_difference,
                                        timer_difference)
-                      : EMACS_TIME_LT (timer_difference,
-                                       idle_timer_difference)))))
+                       : timespec_cmp (timer_difference,
+                                       idle_timer_difference))
+                      < 0))))
         {
           chosen_timer = timer;
           timers = XCDR (timers);
@@ -4490,7 +4491,7 @@ timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
                  return 0 to indicate that.  */
             }
 
-          nexttime = make_emacs_time (0, 0);
+          nexttime = make_timespec (0, 0);
           break;
         }
       else
@@ -4518,10 +4519,10 @@ timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
 
    As long as any timer is ripe, we run it.  */
 
-EMACS_TIME
+struct timespec
 timer_check (void)
 {
-  EMACS_TIME nexttime;
+  struct timespec nexttime;
   Lisp_Object timers, idle_timers;
   struct gcpro gcpro1, gcpro2;
 
@@ -4535,7 +4536,7 @@ timer_check (void)
   /* Always consider the ordinary timers.  */
   timers = Fcopy_sequence (Vtimer_list);
   /* Consider the idle timers only if Emacs is idle.  */
-  if (EMACS_TIME_VALID_P (timer_idleness_start_time))
+  if (timespec_valid_p (timer_idleness_start_time))
     idle_timers = Fcopy_sequence (Vtimer_idle_list);
   else
     idle_timers = Qnil;
@@ -4548,7 +4549,7 @@ timer_check (void)
     {
       nexttime = timer_check_2 (timers, idle_timers);
     }
-  while (EMACS_SECS (nexttime) == 0 && EMACS_NSECS (nexttime) == 0);
+  while (nexttime.tv_sec == 0 && nexttime.tv_nsec == 0);
 
   UNGCPRO;
   return nexttime;
@@ -4564,9 +4565,9 @@ The value when Emacs is not idle is nil.
 PSEC is a multiple of the system clock resolution.  */)
   (void)
 {
-  if (EMACS_TIME_VALID_P (timer_idleness_start_time))
-    return make_lisp_time (sub_emacs_time (current_emacs_time (),
-                                           timer_idleness_start_time));
+  if (timespec_valid_p (timer_idleness_start_time))
+    return make_lisp_time (timespec_sub (current_timespec (),
+                                         timer_idleness_start_time));
 
   return Qnil;
 }
@@ -7126,7 +7127,7 @@ handle_input_available_signal (int sig)
   pending_signals = 1;
 
   if (input_available_clear_time)
-    *input_available_clear_time = make_emacs_time (0, 0);
+    *input_available_clear_time = make_timespec (0, 0);
 }
 
 static void
@@ -7213,7 +7214,7 @@ handle_user_signal (int sig)
             /* Tell wait_reading_process_output that it needs to wake
                up and look around.  */
             if (input_available_clear_time)
-              *input_available_clear_time = make_emacs_time (0, 0);
+              *input_available_clear_time = make_timespec (0, 0);
           }
         break;
       }
@@ -8431,7 +8432,7 @@ read_char_minibuf_menu_prompt (int commandflag,
     return Qnil;
 
 #define PUSH_C_STR(str, listvar) \
-  listvar = Fcons (make_unibyte_string (str, strlen (str)), listvar)
+  listvar = Fcons (build_unibyte_string (str), listvar)
 
   /* Prompt string always starts with map's prompt, and a space.  */
   prompt_strings = Fcons (name, prompt_strings);
@@ -10124,8 +10125,6 @@ Also end any kbd macro being defined.  */)
       end_kbd_macro ();
     }
 
-  update_mode_lines++;
-
   Vunread_command_events = Qnil;
 
   discard_tty_input ();
@@ -10237,7 +10236,7 @@ stuff_buffered_input (Lisp_Object stuffstring)
 }
 
 void
-set_waiting_for_input (EMACS_TIME *time_to_clear)
+set_waiting_for_input (struct timespec *time_to_clear)
 {
   input_available_clear_time = time_to_clear;
 
@@ -10848,7 +10847,7 @@ init_keyboard (void)
   immediate_quit = 0;
   quit_char = Ctl ('g');
   Vunread_command_events = Qnil;
-  timer_idleness_start_time = invalid_emacs_time ();
+  timer_idleness_start_time = invalid_timespec ();
   total_keys = 0;
   recent_keys_index = 0;
   kbd_fetch_ptr = kbd_buffer;
diff --git a/src/keyboard.h b/src/keyboard.h
index daba94898d8..1ee4a97c5c5 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -17,8 +17,9 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
-#include "systime.h"            /* for EMACS_TIME, Time */
+#include "systime.h"            /* for struct timespec, Time */
 #include "coding.h"             /* for ENCODE_UTF_8 and ENCODE_SYSTEM */
+#include "termhooks.h"
 
 INLINE_HEADER_BEGIN
 #ifndef KEYBOARD_INLINE
@@ -466,9 +467,9 @@ extern Lisp_Object Qmode_line, Qvertical_line, Qheader_line;
 /* True while doing kbd input.  */
 extern bool waiting_for_input;
 
-/* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
+/* Address (if not 0) of struct timespec to zero out if a SIGIO interrupt
    happens.  */
-extern EMACS_TIME *input_available_clear_time;
+extern struct timespec *input_available_clear_time;
 
 #if defined HAVE_WINDOW_SYSTEM && !defined USE_GTK && !defined HAVE_NS
 extern bool ignore_mouse_drag_p;
@@ -477,13 +478,10 @@ extern bool ignore_mouse_drag_p;
 /* The primary selection.  */
 extern Lisp_Object QPRIMARY;
 
-/* Forward declaration for prototypes.  */
-struct input_event;
-
 extern Lisp_Object parse_modifiers (Lisp_Object);
 extern Lisp_Object reorder_modifiers (Lisp_Object);
 extern Lisp_Object read_char (int, Lisp_Object, Lisp_Object,
-                              bool *, EMACS_TIME *);
+                              bool *, struct timespec *);
 extern int parse_solitary_modifier (Lisp_Object symbol);
 
 
@@ -549,7 +547,7 @@ extern bool kbd_buffer_events_waiting (void);
 extern void add_user_signal (int, const char *);
 
 extern int tty_read_avail_input (struct terminal *, struct input_event *);
-extern EMACS_TIME timer_check (void);
+extern struct timespec timer_check (void);
 extern void mark_kboards (void);
 
 #ifdef HAVE_NTGUI
diff --git a/src/keymap.c b/src/keymap.c
index d13a6274347..7a18cd5d983 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -3249,8 +3249,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
   for (tail = map; CONSP (tail); tail = XCDR (tail))
     length_needed++;
 
-  vect = ((struct describe_map_elt *)
-          alloca (sizeof (struct describe_map_elt) * length_needed));
+  vect = alloca (length_needed * sizeof *vect);
 
   for (tail = map; CONSP (tail); tail = XCDR (tail))
     {
diff --git a/src/lisp.h b/src/lisp.h
index 5daddb7d335..b19745baf91 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -734,6 +734,7 @@ extern Lisp_Object Qarrayp, Qbufferp, Qbuffer_or_string_p, Qchar_table_p;
 extern Lisp_Object Qconsp, Qfloatp, Qintegerp, Qlambda, Qlistp, Qmarkerp, Qnil;
 extern Lisp_Object Qnumberp, Qstringp, Qsymbolp, Qvectorp;
 extern Lisp_Object Qvector_or_char_table_p, Qwholenump;
+extern Lisp_Object Qwindow;
 extern Lisp_Object Ffboundp (Lisp_Object);
 extern _Noreturn Lisp_Object wrong_type_argument (Lisp_Object, Lisp_Object);
 
@@ -865,11 +866,7 @@ make_lisp_proc (struct Lisp_Process *p)
 #define XSETSTRING(a, b) ((a) = make_lisp_ptr (b, Lisp_String))
 #define XSETSYMBOL(a, b) ((a) = make_lisp_ptr (b, Lisp_Symbol))
 #define XSETFLOAT(a, b) ((a) = make_lisp_ptr (b, Lisp_Float))
-
-/* Misc types.  */
-
 #define XSETMISC(a, b) ((a) = make_lisp_ptr (b, Lisp_Misc))
-#define XSETMARKER(a, b) (XSETMISC (a, b), XMISCTYPE (a) = Lisp_Misc_Marker)
 
 /* Pseudovector types.  */
 
@@ -2163,38 +2160,6 @@ enum char_bits
     CHARACTERBITS = 22
   };
 
-/* Structure to hold mouse highlight data.  This is here because other
-   header files need it for defining struct x_output etc.  */
-typedef struct {
-  /* These variables describe the range of text currently shown in its
-     mouse-face, together with the window they apply to.  As long as
-     the mouse stays within this range, we need not redraw anything on
-     its account.  Rows and columns are glyph matrix positions in
-     MOUSE_FACE_WINDOW.  */
-  int mouse_face_beg_row, mouse_face_beg_col;
-  int mouse_face_beg_x, mouse_face_beg_y;
-  int mouse_face_end_row, mouse_face_end_col;
-  int mouse_face_end_x, mouse_face_end_y;
-  Lisp_Object mouse_face_window;
-  int mouse_face_face_id;
-  Lisp_Object mouse_face_overlay;
-
-  /* FRAME and X, Y position of mouse when last checked for
-     highlighting.  X and Y can be negative or out of range for the frame.  */
-  struct frame *mouse_face_mouse_frame;
-  int mouse_face_mouse_x, mouse_face_mouse_y;
-
-  /* Nonzero if part of the text currently shown in
-     its mouse-face is beyond the window end.  */
-  unsigned mouse_face_past_end : 1;
-
-  /* Nonzero means defer mouse-motion highlighting.  */
-  unsigned mouse_face_defer : 1;
-
-  /* Nonzero means that the mouse highlight should not be shown.  */
-  unsigned mouse_face_hidden : 1;
-} Mouse_HLInfo;
-
 /* Data type checking.  */
 
 LISP_MACRO_DEFUN (NILP, bool, (Lisp_Object x), (x))
@@ -2665,19 +2630,6 @@ typedef jmp_buf sys_jmp_buf;
    they are bound by a function application or a let form, stores the
    code to be executed for unwind-protect forms.
 
-   If func is non-zero, undoing this binding applies func to old_value;
-      This implements record_unwind_protect.
-
-   Otherwise, the element is a variable binding.
-
-   If the symbol field is a symbol, it is an ordinary variable binding.
-
-   Otherwise, it should be a structure (SYMBOL WHERE . CURRENT-BUFFER),
-   which means having bound a local value while CURRENT-BUFFER was active.
-   If WHERE is nil this means we saw the default value when binding SYMBOL.
-   WHERE being a buffer or frame means we saw a buffer-local or frame-local
-   value.  Other values of WHERE mean an internal error.
-
    NOTE: The specbinding union is defined here, because SPECPDL_INDEX is
    used all over the place, needs to be fast, and needs to know the size of
    union specbinding.  But only eval.c should access it.  */
@@ -3369,8 +3321,9 @@ extern void del_range_byte (ptrdiff_t, ptrdiff_t, bool);
 extern void del_range_both (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t, bool);
 extern Lisp_Object del_range_2 (ptrdiff_t, ptrdiff_t,
                                 ptrdiff_t, ptrdiff_t, bool);
-extern void modify_region_1 (ptrdiff_t, ptrdiff_t, bool);
+extern void modify_text (ptrdiff_t, ptrdiff_t);
 extern void prepare_to_modify_buffer (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
+extern void prepare_to_modify_buffer_1 (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
 extern void signal_after_change (ptrdiff_t, ptrdiff_t, ptrdiff_t);
 extern void adjust_after_insert (ptrdiff_t, ptrdiff_t, ptrdiff_t,
                                  ptrdiff_t, ptrdiff_t);
@@ -3744,11 +3697,12 @@ extern Lisp_Object internal_condition_case_n
      Lisp_Object, Lisp_Object (*) (Lisp_Object, ptrdiff_t, Lisp_Object *));
 extern void specbind (Lisp_Object, Lisp_Object);
 extern void record_unwind_protect (void (*) (Lisp_Object), Lisp_Object);
-extern void record_unwind_protect_int (void (*) (int), int);
 extern void record_unwind_protect_ptr (void (*) (void *), void *);
+extern void record_unwind_protect_int (void (*) (int), int);
 extern void record_unwind_protect_void (void (*) (void));
 extern void record_unwind_protect_nothing (void);
 extern void clear_unwind_protect (ptrdiff_t);
+extern void set_unwind_protect (ptrdiff_t, void (*) (Lisp_Object), Lisp_Object);
 extern void set_unwind_protect_ptr (ptrdiff_t, void (*) (void *), void *);
 extern Lisp_Object unbind_to (ptrdiff_t, Lisp_Object);
 extern _Noreturn void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
@@ -3797,9 +3751,7 @@ extern void fix_start_end_in_overlays (ptrdiff_t, ptrdiff_t);
 extern void report_overlay_modification (Lisp_Object, Lisp_Object, bool,
                                          Lisp_Object, Lisp_Object, Lisp_Object);
 extern bool overlay_touches_p (ptrdiff_t);
-extern Lisp_Object Vbuffer_alist;
 extern Lisp_Object other_buffer_safely (Lisp_Object);
-extern Lisp_Object Qpriority, Qwindow, Qbefore_string, Qafter_string;
 extern Lisp_Object get_truename_buffer (Lisp_Object);
 extern void init_buffer_once (void);
 extern void init_buffer (void);
@@ -3830,6 +3782,9 @@ extern Lisp_Object Qfile_directory_p;
 extern Lisp_Object Qinsert_file_contents;
 extern Lisp_Object Qfile_name_history;
 extern Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object);
+extern Lisp_Object write_region (Lisp_Object, Lisp_Object, Lisp_Object,
+                                 Lisp_Object, Lisp_Object, Lisp_Object,
+                                 Lisp_Object, int);
 EXFUN (Fread_file_name, 6);     /* Not a normal DEFUN.  */
 extern void close_file_unwind (int);
 extern void fclose_unwind (void *);
@@ -3862,8 +3817,8 @@ extern ptrdiff_t fast_looking_at (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                   ptrdiff_t, ptrdiff_t, Lisp_Object);
 extern ptrdiff_t find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
                                ptrdiff_t, ptrdiff_t *, ptrdiff_t *, bool);
-extern EMACS_INT scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
-                               EMACS_INT, bool);
+extern ptrdiff_t scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
+                               ptrdiff_t, bool);
 extern ptrdiff_t find_newline_no_quit (ptrdiff_t, ptrdiff_t,
                                        ptrdiff_t, ptrdiff_t *);
 extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t,
@@ -4096,7 +4051,6 @@ extern void init_sys_modes (struct tty_display_info *);
 extern void reset_sys_modes (struct tty_display_info *);
 extern void init_all_sys_modes (void);
 extern void reset_all_sys_modes (void);
-extern void flush_pending_output (int) ATTRIBUTE_CONST;
 extern void child_setup_tty (int);
 extern void setup_pty (int);
 extern int set_window_size (int, int, int);
@@ -4213,6 +4167,11 @@ extern void syms_of_xml (void);
 extern void xml_cleanup_parser (void);
 #endif
 
+#ifdef HAVE_ZLIB
+/* Defined in decompress.c.  */
+extern void syms_of_decompress (void);
+#endif
+
 #ifdef HAVE_DBUS
 /* Defined in dbusbind.c.  */
 void syms_of_dbusbind (void);
@@ -4246,10 +4205,17 @@ extern void *xnrealloc (void *, ptrdiff_t, ptrdiff_t);
 extern void *xpalloc (void *, ptrdiff_t *, ptrdiff_t, ptrdiff_t, ptrdiff_t);
 
 extern char *xstrdup (const char *);
+extern char *xlispstrdup (Lisp_Object);
 extern void xputenv (const char *);
 
 extern char *egetenv (const char *);
 
+/* Copy Lisp string to temporary (allocated on stack) C string.  */
+
+#define xlispstrdupa(string)                    \
+  memcpy (alloca (SBYTES (string) + 1),         \
+          SSDATA (string), SBYTES (string) + 1)
+
 /* Set up the name of the machine we're running on.  */
 extern void init_system_name (void);
 
@@ -4326,6 +4292,12 @@ extern void *record_xmalloc (size_t);
       memory_full (SIZE_MAX);                                  \
   } while (0)
 
+/* Do a `for' loop over alist values.  */
+
+#define FOR_EACH_ALIST_VALUE(head_var, list_var, value_var)             \
+  for (list_var = head_var;                                             \
+       (CONSP (list_var) && (value_var = XCDR (XCAR (list_var)), 1));   \
+       list_var = XCDR (list_var))
 
 /* Check whether it's time for GC, and run it if so.  */
 
diff --git a/src/lisp.mk b/src/lisp.mk
index edd81bcf493..a9a661ea3a8 100644
--- a/src/lisp.mk
+++ b/src/lisp.mk
@@ -71,6 +71,7 @@ lisp = \
         $(lispsource)/faces.elc \
         $(lispsource)/button.elc \
         $(lispsource)/startup.elc \
+        $(lispsource)/emacs-lisp/nadvice.elc \
         $(lispsource)/minibuffer.elc \
         $(lispsource)/abbrev.elc \
         $(lispsource)/simple.elc \
diff --git a/src/lread.c b/src/lread.c
index 57c7df74127..9518631ba6d 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -609,7 +609,7 @@ read_filtered_event (bool no_switch_frame, bool ascii_required,
                      bool error_nonascii, bool input_method, Lisp_Object seconds)
 {
   Lisp_Object val, delayed_switch_frame;
-  EMACS_TIME end_time;
+  struct timespec end_time;
 
 #ifdef HAVE_WINDOW_SYSTEM
   if (display_hourglass_p)
@@ -622,8 +622,8 @@ read_filtered_event (bool no_switch_frame, bool ascii_required,
   if (NUMBERP (seconds))
     {
       double duration = extract_float (seconds);
-      EMACS_TIME wait_time = EMACS_TIME_FROM_DOUBLE (duration);
-      end_time = add_emacs_time (current_emacs_time (), wait_time);
+      struct timespec wait_time = dtotimespec (duration);
+      end_time = timespec_add (current_timespec (), wait_time);
     }
 
   /* Read until we get an acceptable event.  */
@@ -1262,7 +1262,7 @@ Return t if the file exists and loads successfully.  */)
             }
 
           if (result == 0
-              && EMACS_TIME_LT (get_stat_mtime (&s1), get_stat_mtime (&s2)))
+              && timespec_cmp (get_stat_mtime (&s1), get_stat_mtime (&s2)) < 0)
             {
               /* Make the progress messages mention that source is newer.  */
               newer = 1;
@@ -3229,7 +3229,7 @@ substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Obj
         if (BOOL_VECTOR_P (subtree))
           return subtree;               /* No sub-objects anyway.  */
         else if (CHAR_TABLE_P (subtree) || SUB_CHAR_TABLE_P (subtree)
-                 || COMPILEDP (subtree))
+                 || COMPILEDP (subtree) || HASH_TABLE_P (subtree))
           length = ASIZE (subtree) & PSEUDOVECTOR_SIZE_MASK;
         else if (VECTORP (subtree))
           length = ASIZE (subtree);
diff --git a/src/marker.c b/src/marker.c
index 6c50def51a3..2f91bdf9727 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -534,9 +534,9 @@ set_marker_internal (Lisp_Object marker, Lisp_Object position,
 }
 
 DEFUN ("set-marker", Fset_marker, Sset_marker, 2, 3, 0,
-       doc: /* Position MARKER before character number POSITION in BUFFER,
-which defaults to the current buffer.  If POSITION is nil,
-makes marker point nowhere so it no longer slows down
+       doc: /* Position MARKER before character number POSITION in BUFFER.
+If BUFFER is omitted or nil, it defaults to the current buffer.  If
+POSITION is nil, makes marker point nowhere so it no longer slows down
 editing in any buffer.  Returns MARKER.  */)
   (Lisp_Object marker, Lisp_Object position, Lisp_Object buffer)
 {
diff --git a/src/minibuf.c b/src/minibuf.c
index 2c33b83c11b..7403fc6c32d 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -568,22 +568,15 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
     bset_directory (current_buffer, ambient_dir);
   else
     {
-      Lisp_Object buf_list;
+      Lisp_Object tail, buf;
 
-      for (buf_list = Vbuffer_alist;
-           CONSP (buf_list);
-           buf_list = XCDR (buf_list))
-        {
-          Lisp_Object other_buf;
-
-          other_buf = XCDR (XCAR (buf_list));
-          if (STRINGP (BVAR (XBUFFER (other_buf), directory)))
-            {
-              bset_directory (current_buffer,
-                              BVAR (XBUFFER (other_buf), directory));
-              break;
-            }
-        }
+      FOR_EACH_LIVE_BUFFER (tail, buf)
+        if (STRINGP (BVAR (XBUFFER (buf), directory)))
+          {
+            bset_directory (current_buffer,
+                            BVAR (XBUFFER (buf), directory));
+            break;
+          }
     }
 
   if (!EQ (mini_frame, selected_frame))
@@ -877,10 +870,8 @@ read_minibuf_unwind (void)
   if (minibuf_level == 0)
     resize_mini_window (XWINDOW (window), 0);
 
-  /* Make sure minibuffer window is erased, not ignored.  */
+  /* Enforce full redisplay.  FIXME: make it more selective.  */
   windows_or_buffers_changed++;
-  XWINDOW (window)->last_modified = 0;
-  XWINDOW (window)->last_overlay_modified = 0;
 
   /* In case the previous minibuffer displayed in this miniwindow is
      dead, we may keep displaying this buffer (tho it's inactive), so reset it,
diff --git a/src/msdos.c b/src/msdos.c
index 88a2eb60726..7142c3ada77 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -602,11 +602,7 @@ dos_set_window_size (int *rows, int *cols)
       Lisp_Object window = hlinfo->mouse_face_window;
 
       if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
-        {
-          hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-          hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-          hlinfo->mouse_face_window = Qnil;
-        }
+        reset_mouse_highlight (hlinfo);
     }
 
   /* Enable bright background colors.  */
@@ -950,9 +946,6 @@ IT_write_glyphs (struct frame *f, struct glyph *str, int str_len)
                           Mouse Highlight (and friends..)
  ************************************************************************/
 
-/* Last window where we saw the mouse.  Used by mouse-autoselect-window.  */
-static Lisp_Object last_mouse_window;
-
 static int mouse_preempted = 0; /* non-zero when XMenu gobbles mouse events */
 
 int
@@ -1276,14 +1269,9 @@ IT_update_begin (struct frame *f)
         }
     }
   else if (mouse_face_frame && !FRAME_LIVE_P (mouse_face_frame))
-    {
-      /* If the frame with mouse highlight was deleted, invalidate the
-         highlight info.  */
-      hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-      hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-      hlinfo->mouse_face_window = Qnil;
-      hlinfo->mouse_face_mouse_frame = NULL;
-    }
+    /* If the frame with mouse highlight was deleted, invalidate the
+       highlight info.  */
+    reset_mouse_highlight (hlinfo);
 
   unblock_input ();
 }
@@ -1555,11 +1543,6 @@ IT_reset_terminal_modes (struct terminal *term)
   term_setup_done = 0;
 }
 
-static void
-IT_set_terminal_window (struct frame *f, int foo)
-{
-}
-
 /* Remember the screen colors of the current frame, to serve as the
    default colors for newly-created frames.  */
 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors,
@@ -1843,17 +1826,8 @@ internal_terminal_init (void)
           if (colors[1] >= 0 && colors[1] < 16)
             FRAME_BACKGROUND_PIXEL (SELECTED_FRAME ()) = colors[1];
         }
-      the_only_display_info.mouse_highlight.mouse_face_mouse_frame = NULL;
-      the_only_display_info.mouse_highlight.mouse_face_beg_row =
-        the_only_display_info.mouse_highlight.mouse_face_beg_col = -1;
-      the_only_display_info.mouse_highlight.mouse_face_end_row =
-        the_only_display_info.mouse_highlight.mouse_face_end_col = -1;
-      the_only_display_info.mouse_highlight.mouse_face_face_id = DEFAULT_FACE_ID;
-      the_only_display_info.mouse_highlight.mouse_face_window = Qnil;
-      the_only_display_info.mouse_highlight.mouse_face_mouse_x =
-        the_only_display_info.mouse_highlight.mouse_face_mouse_y = 0;
-      the_only_display_info.mouse_highlight.mouse_face_defer = 0;
-      the_only_display_info.mouse_highlight.mouse_face_hidden = 0;
+
+      reset_mouse_highlight (&the_only_display_info.mouse_highlight);
 
       if (have_mouse)   /* detected in dos_ttraw, which see */
         {
@@ -1889,7 +1863,7 @@ initialize_msdos_display (struct terminal *term)
   term->ring_bell_hook = IT_ring_bell;
   term->reset_terminal_modes_hook = IT_reset_terminal_modes;
   term->set_terminal_modes_hook = IT_set_terminal_modes;
-  term->set_terminal_window_hook = IT_set_terminal_window;
+  term->set_terminal_window_hook = NULL;
   term->update_begin_hook = IT_update_begin;
   term->update_end_hook = IT_update_end;
   term->frame_up_to_date_hook = IT_frame_up_to_date;
@@ -2691,10 +2665,10 @@ dos_rawgetc (void)
           /* Generate SELECT_WINDOW_EVENTs when needed.  */
           if (!NILP (Vmouse_autoselect_window))
             {
-              mouse_window = window_from_coordinates (SELECTED_FRAME (),
-                                                      mouse_last_x,
-                                                      mouse_last_y,
-                                                      0, 0);
+              static Lisp_Object last_mouse_window;
+
+              mouse_window = window_from_coordinates
+                (SELECTED_FRAME (), mouse_last_x, mouse_last_y, 0, 0);
               /* A window will be selected only when it is not
                  selected now, and the last mouse movement event was
                  not in it.  A minibuffer window will be selected iff
@@ -2709,10 +2683,9 @@ dos_rawgetc (void)
                   event.timestamp = event_timestamp ();
                   kbd_buffer_store_event (&event);
                 }
+              /* Remember the last window where we saw the mouse.  */
               last_mouse_window = mouse_window;
             }
-          else
-            last_mouse_window = Qnil;
 
           previous_help_echo_string = help_echo_string;
           help_echo_string = help_echo_object = help_echo_window = Qnil;
@@ -4073,7 +4046,7 @@ dos_yield_time_slice (void)
    because wait_reading_process_output takes care of that.  */
 int
 sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
-            EMACS_TIME *timeout, void *ignored)
+            struct timespec *timeout, void *ignored)
 {
   int check_input;
   struct timespec t;
@@ -4103,20 +4076,20 @@ sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
     }
   else
     {
-      EMACS_TIME clnow, cllast, cldiff;
+      struct timespec clnow, cllast, cldiff;
 
       gettime (&t);
-      cllast = make_emacs_time (t.tv_sec, t.tv_nsec);
+      cllast = make_timespec (t.tv_sec, t.tv_nsec);
 
       while (!check_input || !detect_input_pending ())
         {
           gettime (&t);
-          clnow = make_emacs_time (t.tv_sec, t.tv_nsec);
-          cldiff = sub_emacs_time (clnow, cllast);
-          *timeout = sub_emacs_time (*timeout, cldiff);
+          clnow = make_timespec (t.tv_sec, t.tv_nsec);
+          cldiff = timespec_sub (clnow, cllast);
+          *timeout = timespec_sub (*timeout, cldiff);
 
           /* Stop when timeout value crosses zero.  */
-          if (EMACS_TIME_SIGN (*timeout) <= 0)
+          if (timespec_sign (*timeout) <= 0)
             return 0;
           cllast = clnow;
           dos_yield_time_slice ();
diff --git a/src/nsfns.m b/src/nsfns.m
index 3f43afde787..fc276c2b12d 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -860,11 +860,7 @@ static void
 x_set_cursor_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
   set_frame_cursor_types (f, arg);
-
-  /* Make sure the cursor gets redrawn.  */
-  cursor_type_changed = 1;
 }
-
 
 /* called to set mouse pointer color, but all other terms use it to
    initialize pointer types (and don't set the color ;) */
@@ -2035,13 +2031,17 @@ DEFUN ("ns-convert-utf8-nfd-to-nfc", Fns_convert_utf8_nfd_to_nfc,
 /* TODO: If GNUstep ever implements precomposedStringWithCanonicalMapping,
          remove this. */
   NSString *utfStr;
+  Lisp_Object ret;
 
   CHECK_STRING (str);
-  utfStr = [NSString stringWithUTF8String: SSDATA (str)];
+  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+ utfStr = [NSString stringWithUTF8String: SSDATA (str)];
 #ifdef NS_IMPL_COCOA
-    utfStr = [utfStr precomposedStringWithCanonicalMapping];
+  utfStr = [utfStr precomposedStringWithCanonicalMapping];
 #endif
-  return build_string ([utfStr UTF8String]);
+  ret = build_string ([utfStr UTF8String]);
+  [pool release];
+  return ret;
 }
 
 
@@ -2447,7 +2447,7 @@ Internal use only, use `display-monitor-attributes-list' instead.  */)
   if (n_monitors == 0)
     return Qnil;
 
-  monitors = (struct MonitorInfo *) xzalloc (n_monitors * sizeof (*monitors));
+  monitors = xzalloc (n_monitors * sizeof *monitors);
 
   for (i = 0; i < [screens count]; ++i)
     {
diff --git a/src/nsfont.m b/src/nsfont.m
index ad169d7ddae..e1c7d32dde0 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -61,6 +61,7 @@ static void ns_uni_to_glyphs (struct nsfont_info *font_info,
 static void ns_glyph_metrics (struct nsfont_info *font_info,
                               unsigned char block);
 
+#define INVALID_GLYPH 0xFFFF
 
 /* ==========================================================================
 
@@ -920,8 +921,7 @@ nsfont_open (struct frame *f, Lisp_Object font_entity, int pixel_size)
     font->underline_thickness = lrint (font_info->underwidth);
 
     font->props[FONT_NAME_INDEX] = Ffont_xlfd_name (font_object, Qnil);
-    font->props[FONT_FULLNAME_INDEX] =
-      make_unibyte_string (font_info->name, strlen (font_info->name));
+    font->props[FONT_FULLNAME_INDEX] = build_unibyte_string (font_info->name);
   }
   unblock_input ();
 
@@ -982,7 +982,7 @@ nsfont_encode_char (struct font *font, int c)
     ns_uni_to_glyphs (font_info, high);
 
   g = font_info->glyphs[high][low];
-  return g == 0xFFFF ? FONT_INVALID_CODE : g;
+  return g == INVALID_GLYPH ? FONT_INVALID_CODE : g;
 }
 
 
@@ -1355,8 +1355,8 @@ ns_uni_to_glyphs (struct nsfont_info *font_info, unsigned char block)
 #else
         g = glyphStorage->cglyphs[i];
         /* TODO: is this a good check?  maybe need to use coveredChars.. */
-        if (g > numGlyphs)
-          g = 0xFFFF; /* hopefully unused... */
+        if (g > numGlyphs || g == NSNullGlyph)
+          g = INVALID_GLYPH; /* hopefully unused... */
 #endif
         *glyphs = g;
       }
@@ -1484,7 +1484,7 @@ ns_glyph_metrics (struct nsfont_info *font_info, unsigned char block)
         characterIndex: (NSUInteger)charIndex
 {
   len = glyphIndex+length;
-  for (i =glyphIndex; i<len; i++)
+  for (i =glyphIndex; i<len; i++) 
     cglyphs[i] = glyphs[i-glyphIndex];
   if (len > maxGlyph)
     maxGlyph = len;
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 464be89c524..f9cd511efe9 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -366,7 +366,7 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
         }
       else
         {
-          [menu fillWithWidgetValue: first_wv->contents];
+          [menu fillWithWidgetValue: first_wv->contents frame: f];
         }
 
     }
@@ -504,23 +504,11 @@ void
 x_activate_menubar (struct frame *f)
 {
 #ifdef NS_IMPL_COCOA
-  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;
-    }
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+  ns_update_menubar (f, true, nil);
   ns_check_pending_open_menu ();
 #endif
+#endif
 }
 
 
@@ -541,6 +529,7 @@ x_activate_menubar (struct frame *f)
 /* override designated initializer */
 - initWithTitle: (NSString *)title
 {
+  frame = 0;
   if ((self = [super initWithTitle: title]))
     [self setAutoenablesItems: NO];
   return self;
@@ -576,17 +565,36 @@ extern NSString *NSMenuDidBeginTrackingNotification;
   /* Update menu in menuNeedsUpdate only while tracking menus.  */
   trackingMenu = ([notification name] == NSMenuDidBeginTrackingNotification
                   ? 1 : 0);
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+  if (! trackingMenu) ns_check_menu_open (nil);
+#endif
 }
 
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
 - (void)menuWillOpen:(NSMenu *)menu
 {
-  ns_check_menu_open (menu);
-}
-#endif
+  ++trackingMenu;
 
+#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
+  // On 10.6 we get repeated calls, only the one for NSSystemDefined is "real".
+  if ([[NSApp currentEvent] type] != NSSystemDefined) return;
 #endif
 
+  /* When dragging from one menu to another, we get willOpen followed by didClose,
+     i.e. trackingMenu == 3 in willOpen and then 2 after didClose.
+     We have updated all menus, so avoid doing it when trackingMenu == 3.  */
+  if (trackingMenu == 2)
+    ns_check_menu_open (menu);
+}
+
+- (void)menuDidClose:(NSMenu *)menu
+{
+  --trackingMenu;
+}
+#endif /* OSX >= 10.5 */
+
+#endif /* NS_IMPL_COCOA */
+
 /* delegate method called when a submenu is being opened: run a 'deep' call
    to set_frame_menubar */
 - (void)menuNeedsUpdate: (NSMenu *)menu
@@ -722,6 +730,11 @@ extern NSString *NSMenuDidBeginTrackingNotification;
 
 - (void)fillWithWidgetValue: (void *)wvptr
 {
+  [self fillWithWidgetValue: wvptr frame: (struct frame *)nil];
+}
+
+- (void)fillWithWidgetValue: (void *)wvptr frame: (struct frame *)f
+{
   widget_value *wv = (widget_value *)wvptr;
 
   /* clear existing contents */
@@ -735,7 +748,12 @@ extern NSString *NSMenuDidBeginTrackingNotification;
 
       if (wv->contents)
         {
-          EmacsMenu *submenu = [[EmacsMenu alloc] initWithTitle: [item title]];
+          EmacsMenu *submenu;
+
+          if (f)
+            submenu = [[EmacsMenu alloc] initWithTitle: [item title] frame:f];
+          else
+            submenu = [[EmacsMenu alloc] initWithTitle: [item title]];
 
           [self setSubmenu: submenu forItem: item];
           [submenu fillWithWidgetValue: wv->contents];
@@ -1665,7 +1683,7 @@ ns_popup_dialog (Lisp_Object position, Lisp_Object contents, Lisp_Object header)
     }
 
   if (buttons > 0)
-    button_values = (Lisp_Object *) xmalloc (buttons * sizeof (*button_values));
+    button_values = xmalloc (buttons * sizeof *button_values);
 
   for (; XTYPE (list) == Lisp_Cons; list = XCDR (list))
     {
@@ -1849,11 +1867,11 @@ ns_popup_dialog (Lisp_Object position, Lisp_Object contents, Lisp_Object header)
   while (popup_activated_flag)
     {
       NSTimer *tmo = nil;
-      EMACS_TIME next_time = timer_check ();
+      struct timespec next_time = timer_check ();
 
-      if (EMACS_TIME_VALID_P (next_time))
+      if (timespec_valid_p (next_time))
         {
-          double time = EMACS_TIME_TO_DOUBLE (next_time);
+          double time = timespectod (next_time);
           tmo = [NSTimer timerWithTimeInterval: time
                                         target: self
                                       selector: @selector (timeout_handler:)
diff --git a/src/nsterm.h b/src/nsterm.h
index 1303a475547..4e07d796250 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -53,9 +53,24 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* CGFloat on GNUStep may be 4 or 8 byte, but functions expect float* for some
    versions.
-   On Cocoa, functions expect CGFloat*. Make compatible type.  */
-#if defined (NS_IMPL_COCOA) || GNUSTEP_GUI_MAJOR_VERSION > 0 || \
-    GNUSTEP_GUI_MINOR_VERSION >= 22
+   On Cocoa >= 10.5, functions expect CGFloat*. Make compatible type.  */
+#ifdef NS_IMPL_COCOA
+
+#ifndef NS_HAVE_NSINTEGER
+#if defined (__LP64__) && __LP64__
+typedef double CGFloat;
+typedef long NSInteger;
+typedef unsigned long NSUInteger;
+#else
+typedef float CGFloat;
+typedef int NSInteger;
+typedef unsigned int NSUInteger;
+#endif /* not LP64 */
+#endif /* not NS_HAVE_NSINTEGER */
+
+typedef CGFloat EmacsCGFloat;
+
+#elif GNUSTEP_GUI_MAJOR_VERSION > 0 || GNUSTEP_GUI_MINOR_VERSION >= 22
 typedef CGFloat EmacsCGFloat;
 #else
 typedef float EmacsCGFloat;
@@ -196,6 +211,7 @@ typedef float EmacsCGFloat;
 - (NSString *)parseKeyEquiv: (const char *)key;
 - (NSMenuItem *)addItemWithWidgetValue: (void *)wvptr;
 - (void)fillWithWidgetValue: (void *)wvptr;
+- (void)fillWithWidgetValue: (void *)wvptr frame: (struct frame *)f;
 - (EmacsMenu *)addSubmenuWithTitle: (const char *)title forFrame: (struct frame *)f;
 - (void) clear;
 - (Lisp_Object)runMenuAt: (NSPoint)p forFrame: (struct frame *)f
@@ -423,18 +439,6 @@ extern EmacsMenu *mainMenu, *svcsMenu, *dockMenu;
 @end
 #endif
 
-#ifndef NS_HAVE_NSINTEGER
-#if defined (__LP64__) && __LP64__
-typedef double CGFloat;
-typedef long NSInteger;
-typedef unsigned long NSUInteger;
-#else
-typedef float CGFloat;
-typedef int NSInteger;
-typedef unsigned int NSUInteger;
-#endif /* not LP64 */
-#endif /* not NS_HAVE_NSINTEGER */
-
 #endif  /* __OBJC__ */
 
 
@@ -748,8 +752,6 @@ struct x_output
   (FRAME_NS_DISPLAY_INFO (f)->smallest_char_width)
 #define FRAME_SMALLEST_FONT_HEIGHT(f) \
   (FRAME_NS_DISPLAY_INFO (f)->smallest_font_height)
-#define FONT_TYPE_FOR_UNIBYTE(font, ch)   0
-#define FONT_TYPE_FOR_MULTIBYTE(font, ch) 0
 #define FRAME_BASELINE_OFFSET(f) ((f)->output_data.ns->baseline_offset)
 #define BLACK_PIX_DEFAULT(f) 0x000000
 #define WHITE_PIX_DEFAULT(f) 0xFFFFFF
@@ -870,8 +872,8 @@ extern int x_display_pixel_width (struct ns_display_info *);
 /* This in nsterm.m */
 extern void x_destroy_window (struct frame *f);
 extern int ns_select (int nfds, fd_set *readfds, fd_set *writefds,
-                      fd_set *exceptfds, EMACS_TIME *timeout,
-                      sigset_t *sigmask);
+                      fd_set *exceptfds, struct timespec const *timeout,
+                      sigset_t const *sigmask);
 extern unsigned long ns_get_rgb_color (struct frame *f,
                                        float r, float g, float b, float a);
 extern NSPoint last_mouse_motion_position;
diff --git a/src/nsterm.m b/src/nsterm.m
index 3672c7656da..31053ca7a0d 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -214,7 +214,7 @@ static NSTimer *scroll_repeat_entry = nil;
 static fd_set select_readfds, select_writefds;
 enum { SELECT_HAVE_READ = 1, SELECT_HAVE_WRITE = 2, SELECT_HAVE_TMO = 4 };
 static int select_nfds = 0, select_valid = 0;
-static EMACS_TIME select_timeout = { 0, 0 };
+static struct timespec select_timeout = { 0, 0 };
 static int selfds[2] = { -1, -1 };
 static pthread_mutex_t select_mutex;
 static int apploopnr = 0;
@@ -250,9 +250,6 @@ 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;
 #endif
 
 /* Convert modifiers in a NeXTstep event to emacs style modifiers.  */
@@ -311,8 +308,13 @@ static char *menu_pending_title = 0;
 /* This is a piece of code which is common to all the event handling
    methods.  Maybe it should even be a function.  */
 #define EV_TRAILER(e)                                                   \
-    {                                                                   \
-      XSETFRAME (emacs_event->frame_or_window, emacsframe);             \
+  {                                                                     \
+    XSETFRAME (emacs_event->frame_or_window, emacsframe);               \
+    EV_TRAILER2 (e);                                                    \
+  }
+
+#define EV_TRAILER2(e)                                                  \
+  {                                                                     \
       if (e) emacs_event->timestamp = EV_TIMESTAMP (e);                 \
       if (q_event_ptr)                                                  \
         {                                                               \
@@ -344,8 +346,8 @@ hold_event (struct input_event *event)
     {
       if (hold_event_q.cap == 0) hold_event_q.cap = 10;
       else hold_event_q.cap *= 2;
-      hold_event_q.q = (struct input_event *)
-        xrealloc (hold_event_q.q, hold_event_q.cap * sizeof (*hold_event_q.q));
+      hold_event_q.q =
+        xrealloc (hold_event_q.q, hold_event_q.cap * sizeof *hold_event_q.q);
     }
 
   hold_event_q.q[hold_event_q.nr++] = *event;
@@ -488,16 +490,16 @@ ns_timeout (int usecs)
      Blocking timer utility used by ns_ring_bell
    -------------------------------------------------------------------------- */
 {
-  EMACS_TIME wakeup = add_emacs_time (current_emacs_time (),
-                                      make_emacs_time (0, usecs * 1000));
+  struct timespec wakeup = timespec_add (current_timespec (),
+                                         make_timespec (0, usecs * 1000));
 
   /* Keep waiting until past the time wakeup.  */
   while (1)
     {
-      EMACS_TIME timeout, now = current_emacs_time ();
-      if (EMACS_TIME_LE (wakeup, now))
+      struct timespec timeout, now = current_timespec ();
+      if (timespec_cmp (wakeup, now) <= 0)
         break;
-      timeout = sub_emacs_time (wakeup, now);
+      timeout = timespec_sub (wakeup, now);
 
       /* Try to wait that long--but we might wake up sooner.  */
       pselect (0, NULL, NULL, NULL, &timeout, NULL);
@@ -691,9 +693,18 @@ ns_update_begin (struct frame *f)
   {
     NSBezierPath *bp;
     NSRect r = [view frame];
-  bp = [[NSBezierPath bezierPathWithRect: r] retain];
-  [bp setClip];
-  [bp release];
+    NSRect cr = [[view window] frame];
+    /* If a large frame size is set, r may be larger than the window frame
+       before constrained.  In that case don't change the clip path, as we
+       will clear in to the tool bar and title bar.  */
+    if (r.size.height
+        + FRAME_NS_TITLEBAR_HEIGHT (f)
+        + FRAME_TOOLBAR_HEIGHT (f) <= cr.size.height)
+      {
+        bp = [[NSBezierPath bezierPathWithRect: r] retain];
+        [bp setClip];
+        [bp release];
+      }
   }
 #endif
 
@@ -711,10 +722,10 @@ ns_update_window_begin (struct window *w)
    -------------------------------------------------------------------------- */
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
- Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
+  Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
+
   NSTRACE (ns_update_window_begin);
-  updated_window = w;
-  set_output_cursor (&w->cursor);
+  w->output_cursor = w->cursor;
 
   block_input ();
 
@@ -736,15 +747,13 @@ ns_update_window_begin (struct window *w)
 
 
 static void
-ns_update_window_end (struct window *w, int cursor_on_p,
-                      int mouse_face_overwritten_p)
+ns_update_window_end (struct window *w, bool cursor_on_p,
+                      bool mouse_face_overwritten_p)
 /* --------------------------------------------------------------------------
    Finished a grouped sequence of drawing calls
    external (RIF) call; for one window called before update_end
    -------------------------------------------------------------------------- */
 {
-  Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
-
   /* note: this fn is nearly identical in all terms */
   if (!w->pseudo_window_p)
     {
@@ -752,8 +761,8 @@ ns_update_window_end (struct window *w, int cursor_on_p,
 
       if (cursor_on_p)
         display_and_set_cursor (w, 1,
-                                output_cursor.hpos, output_cursor.vpos,
-                                output_cursor.x, output_cursor.y);
+                                w->output_cursor.hpos, w->output_cursor.vpos,
+                                w->output_cursor.x, w->output_cursor.y);
 
       if (draw_window_fringes (w, 1))
         x_draw_vertical_border (w);
@@ -764,13 +773,8 @@ ns_update_window_end (struct window *w, int cursor_on_p,
   /* If a row with mouse-face was overwritten, arrange for
      frame_up_to_date to redisplay the mouse highlight.  */
   if (mouse_face_overwritten_p)
-    {
-      hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-      hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-      hlinfo->mouse_face_window = Qnil;
-    }
+    reset_mouse_highlight (MOUSE_HL_INFO (XFRAME (w->frame)));
 
-  updated_window = NULL;
   NSTRACE (update_window_end);
 }
 
@@ -785,9 +789,9 @@ ns_update_end (struct frame *f)
   EmacsView *view = FRAME_NS_VIEW (f);
 
 /*   if (f == MOUSE_HL_INFO (f)->mouse_face_mouse_frame) */
-    MOUSE_HL_INFO (f)->mouse_face_defer = 0;
+  MOUSE_HL_INFO (f)->mouse_face_defer = 0;
 
-    block_input ();
+  block_input ();
 
   [view unlockFocus];
   [[view window] flushWindow];
@@ -886,7 +890,8 @@ ns_unfocus (struct frame *f)
 
 
 static void
-ns_clip_to_row (struct window *w, struct glyph_row *row, int area, BOOL gc)
+ns_clip_to_row (struct window *w, struct glyph_row *row,
+                enum glyph_row_area area, BOOL gc)
 /* --------------------------------------------------------------------------
      Internal (but parallels other terms): Focus drawing on given row
    -------------------------------------------------------------------------- */
@@ -955,24 +960,6 @@ ns_ring_bell (struct frame *f)
     }
 }
 
-
-static void
-ns_reset_terminal_modes (struct terminal *terminal)
-/*  Externally called as hook */
-{
-  NSTRACE (ns_reset_terminal_modes);
-}
-
-
-static void
-ns_set_terminal_modes (struct terminal *terminal)
-/*  Externally called as hook */
-{
-  NSTRACE (ns_set_terminal_modes);
-}
-
-
-
 /* ==========================================================================
 
     Frame / window manager related functions
@@ -1178,12 +1165,7 @@ x_free_frame_resources (struct frame *f)
   if (f == dpyinfo->x_highlight_frame)
     dpyinfo->x_highlight_frame = 0;
   if (f == hlinfo->mouse_face_mouse_frame)
-    {
-      hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-      hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-      hlinfo->mouse_face_window = Qnil;
-      hlinfo->mouse_face_mouse_frame = 0;
-    }
+    reset_mouse_highlight (hlinfo);
 
   if (f->output_data.ns->miniimage != nil)
     [f->output_data.ns->miniimage release];
@@ -1995,9 +1977,6 @@ ns_clear_frame (struct frame *f)
 
   mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
 
-  output_cursor.hpos = output_cursor.vpos = 0;
-  output_cursor.x = -1;
-
   r = [view bounds];
 
   block_input ();
@@ -2053,7 +2032,7 @@ ns_scroll_run (struct window *w, struct run *run)
   /* Get frame-relative bounding box of the text display area of W,
      without mode lines.  Include in this box the left and right
      fringe of W.  */
-  window_box (w, -1, &x, &y, &width, &height);
+  window_box (w, ANY_AREA, &x, &y, &width, &height);
 
   from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
   to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
@@ -2084,7 +2063,6 @@ ns_scroll_run (struct window *w, struct run *run)
 
   block_input ();
 
-  updated_window = w;
   x_clear_cursor (w);
 
   {
@@ -2102,12 +2080,11 @@ ns_scroll_run (struct window *w, struct run *run)
 
 
 static void
-ns_after_update_window_line (struct glyph_row *desired_row)
+ns_after_update_window_line (struct window *w, struct glyph_row *desired_row)
 /* --------------------------------------------------------------------------
     External (RIF): preparatory to fringe update after text was updated
    -------------------------------------------------------------------------- */
 {
-  struct window *w = updated_window;
   struct frame *f;
   int width, height;
 
@@ -2230,7 +2207,7 @@ ns_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
     }
 
   /* Must clip because of partially visible lines.  */
-  ns_clip_to_row (w, row, -1, YES);
+  ns_clip_to_row (w, row, ANY_AREA, YES);
 
   if (!p->overlay_p)
     {
@@ -2338,8 +2315,8 @@ ns_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
 
 static void
 ns_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
-                       int x, int y, int cursor_type, int cursor_width,
-                       int on_p, int active_p)
+                       int x, int y, enum text_cursor_kinds cursor_type,
+                       int cursor_width, bool on_p, bool active_p)
 /* --------------------------------------------------------------------------
      External call (RIF): draw cursor.
      Note that CURSOR_WIDTH is meaningful only for (h)bar cursors.
@@ -2410,7 +2387,7 @@ ns_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
 
   /* TODO: only needed in rare cases with last-resort font in HELLO..
      should we do this more efficiently? */
-  ns_clip_to_row (w, glyph_row, -1, NO); /* do ns_focus(f, &r, 1); if remove */
+  ns_clip_to_row (w, glyph_row, ANY_AREA, NO); /* do ns_focus(f, &r, 1); if remove */
 
 
   face = FACE_FROM_ID (f, phys_cursor_glyph->face_id);
@@ -3391,12 +3368,6 @@ check_native_fs ()
 /* 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
-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)
@@ -3405,6 +3376,14 @@ ns_check_menu_open (NSMenu *menu)
   NSArray *a = [[NSApp mainMenu] itemArray];
   int i;
   BOOL found = NO;
+
+  if (menu == nil) // Menu tracking ended.
+    {
+      if (menu_will_open_state == MENU_OPENING)
+        menu_will_open_state = MENU_NONE;
+      return;
+    }
+
   for (i = 0; ! found && i < [a count]; i++)
     found = menu == [[a objectAtIndex:i] submenu];
   if (found)
@@ -3422,8 +3401,6 @@ ns_check_menu_open (NSMenu *menu)
           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)
         {
@@ -3537,7 +3514,8 @@ ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
 
 int
 ns_select (int nfds, fd_set *readfds, fd_set *writefds,
-           fd_set *exceptfds, EMACS_TIME *timeout, sigset_t *sigmask)
+           fd_set *exceptfds, struct timespec const *timeout,
+           sigset_t const *sigmask)
 /* --------------------------------------------------------------------------
      Replacement for select, checking for events
    -------------------------------------------------------------------------- */
@@ -3607,7 +3585,7 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
   else if (nr == 0 && timeout)
     {
       /* No file descriptor, just a timeout, no need to wake fd_handler  */
-      double time = EMACS_TIME_TO_DOUBLE (*timeout);
+      double time = timespectod (*timeout);
       timed_entry = [[NSTimer scheduledTimerWithTimeInterval: time
                                                       target: NSApp
                                                     selector:
@@ -3663,7 +3641,6 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
           pthread_mutex_lock (&select_mutex);
           if (readfds) *readfds = select_readfds;
           if (writefds) *writefds = select_writefds;
-          if (timeout) *timeout = select_timeout;
           pthread_mutex_unlock (&select_mutex);
           result = t;
         }
@@ -3721,7 +3698,7 @@ ns_set_vertical_scroll_bar (struct window *window,
   NSTRACE (ns_set_vertical_scroll_bar);
 
   /* Get dimensions.  */
-  window_box (window, -1, 0, &window_y, 0, &window_height);
+  window_box (window, ANY_AREA, 0, &window_y, 0, &window_height);
   top = window_y;
   height = window_height;
   width = WINDOW_CONFIG_SCROLL_BAR_COLS (window) * FRAME_COLUMN_WIDTH (f);
@@ -3737,16 +3714,7 @@ ns_set_vertical_scroll_bar (struct window *window,
   v = [view frame];
   r.origin.y = (v.size.height - r.size.height - r.origin.y);
 
-  if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (window))
-    fringe_extended_p = (WINDOW_LEFTMOST_P (window)
-                         && WINDOW_LEFT_FRINGE_WIDTH (window)
-                         && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (window)
-                             || WINDOW_LEFT_MARGIN_COLS (window) == 0));
-  else
-    fringe_extended_p = (WINDOW_RIGHTMOST_P (window)
-                         && WINDOW_RIGHT_FRINGE_WIDTH (window)
-                         && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (window)
-                             || WINDOW_RIGHT_MARGIN_COLS (window) == 0));
+  fringe_extended_p = WINDOW_FRINGE_EXTENDED_P (window);
 
   XSETWINDOW (win, window);
   block_input ();
@@ -3957,7 +3925,6 @@ ns_initialize_display_info (struct ns_display_info *dpyinfo)
 {
     NSScreen *screen = [NSScreen mainScreen];
     NSWindowDepth depth = [screen depth];
-    Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
 
     dpyinfo->resx = 72.27; /* used 75.0, but this makes pt == pixel, expected */
     dpyinfo->resy = 72.27;
@@ -3970,22 +3937,12 @@ ns_initialize_display_info (struct ns_display_info *dpyinfo)
     dpyinfo->color_table = xmalloc (sizeof *dpyinfo->color_table);
     dpyinfo->color_table->colors = NULL;
     dpyinfo->root_window = 42; /* a placeholder.. */
-
-    hlinfo->mouse_face_mouse_frame = NULL;
-    hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-    hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-    hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
-    hlinfo->mouse_face_window = hlinfo->mouse_face_overlay = Qnil;
-    hlinfo->mouse_face_hidden = 0;
-
-    hlinfo->mouse_face_mouse_x = hlinfo->mouse_face_mouse_y = 0;
-    hlinfo->mouse_face_defer = 0;
-
     dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame = NULL;
-
     dpyinfo->n_fonts = 0;
     dpyinfo->smallest_font_height = 1;
     dpyinfo->smallest_char_width = 1;
+
+    reset_mouse_highlight (&dpyinfo->mouse_highlight);
 }
 
 
@@ -4006,7 +3963,6 @@ static struct redisplay_interface ns_redisplay_interface =
   ns_after_update_window_line,
   ns_update_window_begin,
   ns_update_window_end,
-  x_cursor_to,
   ns_flush,
   0, /* flush_display_optional */
   x_clear_window_mouse_face,
@@ -4073,8 +4029,8 @@ ns_create_terminal (struct ns_display_info *dpyinfo)
   terminal->ins_del_lines_hook = 0; /* XXX vestigial? */
   terminal->delete_glyphs_hook = 0; /* XXX vestigial? */
   terminal->ring_bell_hook = ns_ring_bell;
-  terminal->reset_terminal_modes_hook = ns_reset_terminal_modes;
-  terminal->set_terminal_modes_hook = ns_set_terminal_modes;
+  terminal->reset_terminal_modes_hook = NULL;
+  terminal->set_terminal_modes_hook = NULL;
   terminal->update_begin_hook = ns_update_begin;
   terminal->update_end_hook = ns_update_end;
   terminal->set_terminal_window_hook = NULL; /* XXX vestigial? */
@@ -4714,8 +4670,8 @@ not_in_argv (NSString *arg)
   int waiting = 1, nfds;
   char c;
 
-  SELECT_TYPE readfds, writefds, *wfds;
-  EMACS_TIME timeout, *tmo;
+  fd_set readfds, writefds, *wfds;
+  struct timespec timeout, *tmo;
   NSAutoreleasePool *pool = nil;
 
   /* NSTRACE (fd_handler); */
@@ -4727,7 +4683,7 @@ not_in_argv (NSString *arg)
 
       if (waiting)
         {
-          SELECT_TYPE fds;
+          fd_set fds;
           FD_ZERO (&fds);
           FD_SET (selfds[0], &fds);
           result = select (selfds[0]+1, &fds, NULL, NULL, NULL);
@@ -5496,6 +5452,30 @@ not_in_argv (NSString *arg)
   previous_help_echo_string = help_echo_string;
   help_echo_string = Qnil;
 
+  if (!NILP (Vmouse_autoselect_window))
+    {
+      NSTRACE (mouse_autoselect_window);
+      static Lisp_Object last_mouse_window;
+      Lisp_Object window = window_from_coordinates
+        (emacsframe, last_mouse_motion_position.x,
+         last_mouse_motion_position.y, 0, 0);
+
+      if (WINDOWP (window)
+          && !EQ (window, last_mouse_window)
+          && !EQ (window, selected_window)
+          && (focus_follows_mouse
+              || (EQ (XWINDOW (window)->frame,
+                      XWINDOW (selected_window)->frame))))
+        {
+          NSTRACE (in_window);
+          emacs_event->kind = SELECT_WINDOW_EVENT;
+          emacs_event->frame_or_window = window;
+          EV_TRAILER2 (e);
+        }
+      /* Remember the last window where we saw the mouse.  */
+      last_mouse_window = window;
+    }
+
   if (!note_mouse_movement (emacsframe, last_mouse_motion_position.x,
                             last_mouse_motion_position.y))
     help_echo_string = previous_help_echo_string;
diff --git a/src/print.c b/src/print.c
index 80f1bb6beb4..4ad34534da3 100644
--- a/src/print.c
+++ b/src/print.c
@@ -124,7 +124,8 @@ bool print_output_debug_flag EXTERNALLY_VISIBLE = 1;
          set_buffer_internal (XMARKER (printcharfun)->buffer);          \
        marker_pos = marker_position (printcharfun);                     \
        if (marker_pos < BEGV || marker_pos > ZV)                        \
-         error ("Marker is outside the accessible part of the buffer"); \
+         signal_error ("Marker is outside the accessible "              \
+                       "part of the buffer", printcharfun);             \
        old_point = PT;                                                  \
        old_point_byte = PT_BYTE;                                        \
        SET_PT_BOTH (marker_pos,                                         \
@@ -136,10 +137,10 @@ bool print_output_debug_flag EXTERNALLY_VISIBLE = 1;
    if (NILP (printcharfun))                                             \
      {                                                                  \
        Lisp_Object string;                                              \
-       if (NILP (BVAR (current_buffer, enable_multibyte_characters))            \
+       if (NILP (BVAR (current_buffer, enable_multibyte_characters))    \
            && ! print_escape_multibyte)                                 \
          specbind (Qprint_escape_multibyte, Qt);                        \
-       if (! NILP (BVAR (current_buffer, enable_multibyte_characters))          \
+       if (! NILP (BVAR (current_buffer, enable_multibyte_characters))  \
            && ! print_escape_nonascii)                                  \
          specbind (Qprint_escape_nonascii, Qt);                         \
        if (print_buffer != 0)                                           \
@@ -166,7 +167,7 @@ bool print_output_debug_flag EXTERNALLY_VISIBLE = 1;
    if (NILP (printcharfun))                                             \
      {                                                                  \
        if (print_buffer_pos != print_buffer_pos_byte                    \
-           && NILP (BVAR (current_buffer, enable_multibyte_characters)))        \
+           && NILP (BVAR (current_buffer, enable_multibyte_characters)))\
          {                                                              \
            unsigned char *temp = alloca (print_buffer_pos + 1);         \
            copy_text ((unsigned char *) print_buffer, temp,             \
diff --git a/src/process.c b/src/process.c
index d87a1803fe2..20f84990d6f 100644
--- a/src/process.c
+++ b/src/process.c
@@ -92,6 +92,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <c-ctype.h>
 #include <sig2str.h>
+#include <verify.h>
 
 #endif  /* subprocesses */
 
@@ -131,8 +132,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 #ifdef WINDOWSNT
-extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
-                       EMACS_TIME *, void *);
+extern int sys_select (int, fd_set *, fd_set *, fd_set *,
+                       struct timespec *, void *);
 #endif
 
 #ifndef SOCK_CLOEXEC
@@ -260,7 +261,7 @@ static EMACS_INT update_tick;
 #endif
 
 #ifdef ADAPTIVE_READ_BUFFERING
-#define READ_OUTPUT_DELAY_INCREMENT (EMACS_TIME_RESOLUTION / 100)
+#define READ_OUTPUT_DELAY_INCREMENT (TIMESPEC_RESOLUTION / 100)
 #define READ_OUTPUT_DELAY_MAX       (READ_OUTPUT_DELAY_INCREMENT * 5)
 #define READ_OUTPUT_DELAY_MAX_MAX   (READ_OUTPUT_DELAY_INCREMENT * 7)
 
@@ -279,7 +280,7 @@ static bool process_output_skip;
 
 static void create_process (Lisp_Object, char **, Lisp_Object);
 #ifdef USABLE_SIGIO
-static bool keyboard_bit_set (SELECT_TYPE *);
+static bool keyboard_bit_set (fd_set *);
 #endif
 static void deactivate_process (Lisp_Object);
 static void status_notify (struct Lisp_Process *);
@@ -298,39 +299,39 @@ static void exec_sentinel (Lisp_Object proc, Lisp_Object reason);
 
 /* Mask of bits indicating the descriptors that we wait for input on.  */
 
-static SELECT_TYPE input_wait_mask;
+static fd_set input_wait_mask;
 
 /* Mask that excludes keyboard input descriptor(s).  */
 
-static SELECT_TYPE non_keyboard_wait_mask;
+static fd_set non_keyboard_wait_mask;
 
 /* Mask that excludes process input descriptor(s).  */
 
-static SELECT_TYPE non_process_wait_mask;
+static fd_set non_process_wait_mask;
 
 /* Mask for selecting for write.  */
 
-static SELECT_TYPE write_mask;
+static fd_set write_mask;
 
 #ifdef NON_BLOCKING_CONNECT
 /* Mask of bits indicating the descriptors that we wait for connect to
    complete on.  Once they complete, they are removed from this mask
    and added to the input_wait_mask and non_keyboard_wait_mask.  */
 
-static SELECT_TYPE connect_wait_mask;
+static fd_set connect_wait_mask;
 
 /* Number of bits set in connect_wait_mask.  */
 static int num_pending_connects;
 #endif  /* NON_BLOCKING_CONNECT */
 
-/* The largest descriptor currently in use for a process object.  */
+/* The largest descriptor currently in use for a process object; -1 if none.  */
 static int max_process_desc;
 
-/* The largest descriptor currently in use for input.  */
+/* The largest descriptor currently in use for input; -1 if none.  */
 static int max_input_desc;
 
 /* Indexed by descriptor, gives the process (if any) for that descriptor */
-static Lisp_Object chan_process[MAXDESC];
+static Lisp_Object chan_process[FD_SETSIZE];
 
 /* Alist of elements (NAME . PROCESS) */
 static Lisp_Object Vprocess_alist;
@@ -341,18 +342,18 @@ static Lisp_Object Vprocess_alist;
    output from the process is to read at least one char.
    Always -1 on systems that support FIONREAD.  */
 
-static int proc_buffered_char[MAXDESC];
+static int proc_buffered_char[FD_SETSIZE];
 
 /* Table of `struct coding-system' for each process.  */
-static struct coding_system *proc_decode_coding_system[MAXDESC];
-static struct coding_system *proc_encode_coding_system[MAXDESC];
+static struct coding_system *proc_decode_coding_system[FD_SETSIZE];
+static struct coding_system *proc_encode_coding_system[FD_SETSIZE];
 
 #ifdef DATAGRAM_SOCKETS
 /* Table of `partner address' for datagram sockets.  */
 static struct sockaddr_and_len {
   struct sockaddr *sa;
   int len;
-} datagram_address[MAXDESC];
+} datagram_address[FD_SETSIZE];
 #define DATAGRAM_CHAN_P(chan)   (datagram_address[chan].sa != 0)
 #define DATAGRAM_CONN_P(proc)   (PROCESSP (proc) && datagram_address[XPROCESS (proc)->infd].sa != 0)
 #else
@@ -360,6 +361,12 @@ static struct sockaddr_and_len {
 #define DATAGRAM_CONN_P(proc)   (0)
 #endif
 
+/* FOR_EACH_PROCESS (LIST_VAR, PROC_VAR) followed by a statement is
+   a `for' loop which iterates over processes from Vprocess_alist.  */
+
+#define FOR_EACH_PROCESS(list_var, proc_var)                    \
+  FOR_EACH_ALIST_VALUE (Vprocess_alist, list_var, proc_var)
+
 /* These setters are used only in this file, so they can be private.  */
 static void
 pset_buffer (struct Lisp_Process *p, Lisp_Object val)
@@ -451,7 +458,7 @@ static struct fd_callback_data
 #define FOR_READ  1
 #define FOR_WRITE 2
   int condition; /* mask of the defines above.  */
-} fd_callback_info[MAXDESC];
+} fd_callback_info[FD_SETSIZE];
 
 
 /* Add a file descriptor FD to be monitored for when read is possible.
@@ -460,7 +467,7 @@ static struct fd_callback_data
 void
 add_read_fd (int fd, fd_callback func, void *data)
 {
-  eassert (fd < MAXDESC);
+  eassert (fd < FD_SETSIZE);
   add_keyboard_wait_descriptor (fd);
 
   fd_callback_info[fd].func = func;
@@ -473,7 +480,7 @@ add_read_fd (int fd, fd_callback func, void *data)
 void
 delete_read_fd (int fd)
 {
-  eassert (fd < MAXDESC);
+  eassert (fd < FD_SETSIZE);
   delete_keyboard_wait_descriptor (fd);
 
   fd_callback_info[fd].condition &= ~FOR_READ;
@@ -490,7 +497,7 @@ delete_read_fd (int fd)
 void
 add_write_fd (int fd, fd_callback func, void *data)
 {
-  eassert (fd < MAXDESC);
+  eassert (fd < FD_SETSIZE);
   FD_SET (fd, &write_mask);
   if (fd > max_input_desc)
     max_input_desc = fd;
@@ -500,29 +507,35 @@ add_write_fd (int fd, fd_callback func, void *data)
   fd_callback_info[fd].condition |= FOR_WRITE;
 }
 
+/* FD is no longer an input descriptor; update max_input_desc accordingly.  */
+
+static void
+delete_input_desc (int fd)
+{
+  if (fd == max_input_desc)
+    {
+      do
+        fd--;
+      while (0 <= fd && ! (FD_ISSET (fd, &input_wait_mask)
+                           || FD_ISSET (fd, &write_mask)));
+
+      max_input_desc = fd;
+    }
+}
+
 /* Stop monitoring file descriptor FD for when write is possible.  */
 
 void
 delete_write_fd (int fd)
 {
-  int lim = max_input_desc;
-
-  eassert (fd < MAXDESC);
+  eassert (fd < FD_SETSIZE);
   FD_CLR (fd, &write_mask);
   fd_callback_info[fd].condition &= ~FOR_WRITE;
   if (fd_callback_info[fd].condition == 0)
     {
       fd_callback_info[fd].func = 0;
       fd_callback_info[fd].data = 0;
-
-      if (fd == max_input_desc)
-        for (fd = lim; fd >= 0; fd--)
-          if (FD_ISSET (fd, &input_wait_mask) || FD_ISSET (fd, &write_mask))
-            {
-              max_input_desc = fd;
-              break;
-            }
-
+      delete_input_desc (fd);
     }
 }
 
@@ -674,6 +687,15 @@ allocate_pty (char pty_name[PTY_NAME_SIZE])
 
         if (fd >= 0)
           {
+#ifdef PTY_OPEN
+            /* Set FD's close-on-exec flag.  This is needed even if
+               PT_OPEN calls posix_openpt with O_CLOEXEC, since POSIX
+               doesn't require support for that combination.
+               Multithreaded platforms where posix_openpt ignores
+               O_CLOEXEC (or where PTY_OPEN doesn't call posix_openpt)
+               have a race condition between the PTY_OPEN and here.  */
+            fcntl (fd, F_SETFD, FD_CLOEXEC);
+#endif
             /* check to make certain that both sides are available
                this avoids a nasty yet stupid bug in rlogins */
 #ifdef PTY_TTY_NAME_SPRINTF
@@ -716,6 +738,8 @@ make_process (Lisp_Object name)
      non-Lisp data, so do it only for slots which should not be zero.  */
   p->infd = -1;
   p->outfd = -1;
+  for (i = 0; i < PROCESS_OPEN_FDS; i++)
+    p->open_fd[i] = -1;
 
 #ifdef HAVE_GNUTLS
   p->gnutls_initstage = GNUTLS_STAGE_EMPTY;
@@ -812,13 +836,17 @@ get_process (register Lisp_Object name)
    treated by the SIGCHLD handler and waitpid has been invoked on them;
    otherwise they might fill up the kernel's process table.
 
-   Some processes created by call-process are also put onto this list.  */
+   Some processes created by call-process are also put onto this list.
+
+   Members of this list are (process-ID . filename) pairs.  The
+   process-ID is a number; the filename, if a string, is a file that
+   needs to be removed after the process exits.  */
 static Lisp_Object deleted_pid_list;
 
 void
-record_deleted_pid (pid_t pid)
+record_deleted_pid (pid_t pid, Lisp_Object filename)
 {
-  deleted_pid_list = Fcons (make_fixnum_or_float (pid),
+  deleted_pid_list = Fcons (Fcons (make_fixnum_or_float (pid), filename),
                             /* GC treated elements set to nil.  */
                             Fdelq (Qnil, deleted_pid_list));
 
@@ -846,7 +874,7 @@ nil, indicating the current buffer's process.  */)
   else
     {
       if (p->alive)
-        record_kill_process (p);
+        record_kill_process (p, Qnil);
 
       if (p->infd >= 0)
         {
@@ -1112,15 +1140,18 @@ See `set-process-sentinel' for more info on sentinels.  */)
 DEFUN ("set-process-window-size", Fset_process_window_size,
        Sset_process_window_size, 3, 3, 0,
        doc: /* Tell PROCESS that it has logical window size HEIGHT and WIDTH.  */)
-  (register Lisp_Object process, Lisp_Object height, Lisp_Object width)
+  (Lisp_Object process, Lisp_Object height, Lisp_Object width)
 {
   CHECK_PROCESS (process);
-  CHECK_RANGED_INTEGER (height, 0, INT_MAX);
-  CHECK_RANGED_INTEGER (width, 0, INT_MAX);
+
+  /* All known platforms store window sizes as 'unsigned short'.  */
+  CHECK_RANGED_INTEGER (height, 0, USHRT_MAX);
+  CHECK_RANGED_INTEGER (width, 0, USHRT_MAX);
 
   if (XPROCESS (process)->infd < 0
-      || set_window_size (XPROCESS (process)->infd,
-                          XINT (height), XINT (width)) <= 0)
+      || (set_window_size (XPROCESS (process)->infd,
+                           XINT (height), XINT (width))
+          < 0))
     return Qnil;
   else
     return Qt;
@@ -1380,22 +1411,9 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
      function.  The argument list is protected by the caller, so all
      we really have to worry about is buffer.  */
   {
-    struct gcpro gcpro1, gcpro2;
-
-    current_dir = BVAR (current_buffer, directory);
-
-    GCPRO2 (buffer, current_dir);
-
-    current_dir = Funhandled_file_name_directory (current_dir);
-    if (NILP (current_dir))
-      /* If the file name handler says that current_dir is unreachable, use
-         a sensible default. */
-      current_dir = build_string ("~/");
-    current_dir = expand_and_dir_to_file (current_dir, Qnil);
-    if (NILP (Ffile_accessible_directory_p (current_dir)))
-      report_file_error ("Setting current directory",
-                         BVAR (current_buffer, directory));
-
+    struct gcpro gcpro1;
+    GCPRO1 (buffer);
+    current_dir = encode_current_directory ();
     UNGCPRO;
   }
 
@@ -1599,22 +1617,49 @@ start_process_unwind (Lisp_Object proc)
     remove_process (proc);
 }
 
+/* If *FD_ADDR is nonnegative, close it, and mark it as closed.  */
+
+static void
+close_process_fd (int *fd_addr)
+{
+  int fd = *fd_addr;
+  if (0 <= fd)
+    {
+      *fd_addr = -1;
+      emacs_close (fd);
+    }
+}
+
+/* Indexes of file descriptors in open_fds.  */
+enum
+  {
+    /* The pipe from Emacs to its subprocess.  */
+    SUBPROCESS_STDIN,
+    WRITE_TO_SUBPROCESS,
+
+    /* The main pipe from the subprocess to Emacs.  */
+    READ_FROM_SUBPROCESS,
+    SUBPROCESS_STDOUT,
+
+    /* The pipe from the subprocess to Emacs that is closed when the
+       subprocess execs.  */
+    READ_FROM_EXEC_MONITOR,
+    EXEC_MONITOR_OUTPUT
+  };
+
+verify (PROCESS_OPEN_FDS == EXEC_MONITOR_OUTPUT + 1);
 
 static void
 create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 {
+  struct Lisp_Process *p = XPROCESS (process);
   int inchannel, outchannel;
   pid_t pid;
   int vfork_errno;
-  int sv[2];
-#ifndef WINDOWSNT
-  int wait_child_setup[2];
-#endif
   int forkin, forkout;
   bool pty_flag = 0;
   char pty_name[PTY_NAME_SIZE];
   Lisp_Object lisp_pty_name = Qnil;
-  Lisp_Object encoded_current_dir;
 
   inchannel = outchannel = -1;
 
@@ -1623,6 +1668,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 
   if (inchannel >= 0)
     {
+      p->open_fd[READ_FROM_SUBPROCESS] = inchannel;
 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
       /* On most USG systems it does not work to open the pty's tty here,
          then close it and reopen it in the child.  */
@@ -1631,6 +1677,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
       forkout = forkin = emacs_open (pty_name, O_RDWR | O_NOCTTY, 0);
       if (forkin < 0)
         report_file_error ("Opening pty", Qnil);
+      p->open_fd[SUBPROCESS_STDIN] = forkin;
 #else
       forkin = forkout = -1;
 #endif /* not USG, or USG_SUBTTY_WORKS */
@@ -1639,23 +1686,17 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
     }
   else
     {
-      if (emacs_pipe (sv) != 0)
+      if (emacs_pipe (p->open_fd + SUBPROCESS_STDIN) != 0
+          || emacs_pipe (p->open_fd + READ_FROM_SUBPROCESS) != 0)
         report_file_error ("Creating pipe", Qnil);
-      inchannel = sv[0];
-      forkout = sv[1];
-      if (emacs_pipe (sv) != 0)
-        {
-          int pipe_errno = errno;
-          emacs_close (inchannel);
-          emacs_close (forkout);
-          report_file_errno ("Creating pipe", Qnil, pipe_errno);
-        }
-      outchannel = sv[1];
-      forkin = sv[0];
+      forkin = p->open_fd[SUBPROCESS_STDIN];
+      outchannel = p->open_fd[WRITE_TO_SUBPROCESS];
+      inchannel = p->open_fd[READ_FROM_SUBPROCESS];
+      forkout = p->open_fd[SUBPROCESS_STDOUT];
     }
 
 #ifndef WINDOWSNT
-  if (emacs_pipe (wait_child_setup) != 0)
+  if (emacs_pipe (p->open_fd + READ_FROM_EXEC_MONITOR) != 0)
     report_file_error ("Creating pipe", Qnil);
 #endif
 
@@ -1664,16 +1705,16 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 
   /* Record this as an active process, with its channels.  */
   chan_process[inchannel] = process;
-  XPROCESS (process)->infd = inchannel;
-  XPROCESS (process)->outfd = outchannel;
+  p->infd = inchannel;
+  p->outfd = outchannel;
 
   /* Previously we recorded the tty descriptor used in the subprocess.
      It was only used for getting the foreground tty process, so now
      we just reopen the device (see emacs_get_tty_pgrp) as this is
      more portable (see USG_SUBTTY_WORKS above).  */
 
-  XPROCESS (process)->pty_flag = pty_flag;
-  pset_status (XPROCESS (process), Qrun);
+  p->pty_flag = pty_flag;
+  pset_status (p, Qrun);
 
   FD_SET (inchannel, &input_wait_mask);
   FD_SET (inchannel, &non_keyboard_wait_mask);
@@ -1683,35 +1724,29 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
   /* This may signal an error. */
   setup_process_coding_systems (process);
 
-  encoded_current_dir = ENCODE_FILE (current_dir);
-
   block_input ();
   block_child_signal ();
 
 #ifndef WINDOWSNT
   /* vfork, and prevent local vars from being clobbered by the vfork.  */
   {
-    Lisp_Object volatile encoded_current_dir_volatile = encoded_current_dir;
+    Lisp_Object volatile current_dir_volatile = current_dir;
     Lisp_Object volatile lisp_pty_name_volatile = lisp_pty_name;
-    Lisp_Object volatile process_volatile = process;
     char **volatile new_argv_volatile = new_argv;
     int volatile forkin_volatile = forkin;
     int volatile forkout_volatile = forkout;
-    int volatile wait_child_setup_0_volatile = wait_child_setup[0];
-    int volatile wait_child_setup_1_volatile = wait_child_setup[1];
+    struct Lisp_Process *p_volatile = p;
 
     pid = vfork ();
 
-    encoded_current_dir = encoded_current_dir_volatile;
+    current_dir = current_dir_volatile;
     lisp_pty_name = lisp_pty_name_volatile;
-    process = process_volatile;
     new_argv = new_argv_volatile;
     forkin = forkin_volatile;
     forkout = forkout_volatile;
-    wait_child_setup[0] = wait_child_setup_0_volatile;
-    wait_child_setup[1] = wait_child_setup_1_volatile;
+    p = p_volatile;
 
-    pty_flag = XPROCESS (process)->pty_flag;
+    pty_flag = p->pty_flag;
   }
 
   if (pid == 0)
@@ -1816,53 +1851,51 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
       if (pty_flag)
         child_setup_tty (xforkout);
 #ifdef WINDOWSNT
-      pid = child_setup (xforkin, xforkout, xforkout,
-                         new_argv, 1, encoded_current_dir);
+      pid = child_setup (xforkin, xforkout, xforkout, new_argv, 1, current_dir);
 #else  /* not WINDOWSNT */
-      child_setup (xforkin, xforkout, xforkout,
-                   new_argv, 1, encoded_current_dir);
+      child_setup (xforkin, xforkout, xforkout, new_argv, 1, current_dir);
 #endif /* not WINDOWSNT */
     }
 
   /* Back in the parent process.  */
 
   vfork_errno = errno;
-  XPROCESS (process)->pid = pid;
+  p->pid = pid;
   if (pid >= 0)
-    XPROCESS (process)->alive = 1;
+    p->alive = 1;
 
   /* Stop blocking in the parent.  */
   unblock_child_signal ();
   unblock_input ();
 
-  if (forkin >= 0)
-    emacs_close (forkin);
-  if (forkin != forkout && forkout >= 0)
-    emacs_close (forkout);
-
   if (pid < 0)
     report_file_errno ("Doing vfork", Qnil, vfork_errno);
   else
     {
       /* vfork succeeded.  */
 
+      /* Close the pipe ends that the child uses, or the child's pty.  */
+      close_process_fd (&p->open_fd[SUBPROCESS_STDIN]);
+      close_process_fd (&p->open_fd[SUBPROCESS_STDOUT]);
+
 #ifdef WINDOWSNT
       register_child (pid, inchannel);
 #endif /* WINDOWSNT */
 
-      pset_tty_name (XPROCESS (process), lisp_pty_name);
+      pset_tty_name (p, lisp_pty_name);
 
 #ifndef WINDOWSNT
       /* Wait for child_setup to complete in case that vfork is
-         actually defined as fork.  The descriptor wait_child_setup[1]
+         actually defined as fork.  The descriptor
+         XPROCESS (proc)->open_fd[EXEC_MONITOR_OUTPUT]
          of a pipe is closed at the child side either by close-on-exec
          on successful execve or the _exit call in child_setup.  */
       {
         char dummy;
 
-        emacs_close (wait_child_setup[1]);
-        emacs_read (wait_child_setup[0], &dummy, 1);
-        emacs_close (wait_child_setup[0]);
+        close_process_fd (&p->open_fd[EXEC_MONITOR_OUTPUT]);
+        emacs_read (p->open_fd[READ_FROM_EXEC_MONITOR], &dummy, 1);
+        close_process_fd (&p->open_fd[READ_FROM_EXEC_MONITOR]);
       }
 #endif
     }
@@ -1871,16 +1904,13 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 static void
 create_pty (Lisp_Object process)
 {
+  struct Lisp_Process *p = XPROCESS (process);
   char pty_name[PTY_NAME_SIZE];
-  int inchannel, outchannel;
+  int pty_fd = NILP (Vprocess_connection_type) ? -1 : allocate_pty (pty_name);
 
-  inchannel = outchannel = -1;
-
-  if (!NILP (Vprocess_connection_type))
-    outchannel = inchannel = allocate_pty (pty_name);
-
-  if (inchannel >= 0)
+  if (pty_fd >= 0)
     {
+      p->open_fd[SUBPROCESS_STDIN] = pty_fd;
 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
       /* On most USG systems it does not work to open the pty's tty here,
          then close it and reopen it in the child.  */
@@ -1889,6 +1919,7 @@ create_pty (Lisp_Object process)
       int forkout = emacs_open (pty_name, O_RDWR | O_NOCTTY, 0);
       if (forkout < 0)
         report_file_error ("Opening pty", Qnil);
+      p->open_fd[WRITE_TO_SUBPROCESS] = forkout;
 #if defined (DONT_REOPEN_PTY)
       /* In the case that vfork is defined as fork, the parent process
          (Emacs) may send some data before the child process completes
@@ -1897,33 +1928,32 @@ create_pty (Lisp_Object process)
 #endif /* DONT_REOPEN_PTY */
 #endif /* not USG, or USG_SUBTTY_WORKS */
 
-      fcntl (inchannel, F_SETFL, O_NONBLOCK);
-      fcntl (outchannel, F_SETFL, O_NONBLOCK);
+      fcntl (pty_fd, F_SETFL, O_NONBLOCK);
 
       /* Record this as an active process, with its channels.
          As a result, child_setup will close Emacs's side of the pipes.  */
-      chan_process[inchannel] = process;
-      XPROCESS (process)->infd = inchannel;
-      XPROCESS (process)->outfd = outchannel;
+      chan_process[pty_fd] = process;
+      p->infd = pty_fd;
+      p->outfd = pty_fd;
 
       /* Previously we recorded the tty descriptor used in the subprocess.
          It was only used for getting the foreground tty process, so now
          we just reopen the device (see emacs_get_tty_pgrp) as this is
          more portable (see USG_SUBTTY_WORKS above).  */
 
-      XPROCESS (process)->pty_flag = 1;
-      pset_status (XPROCESS (process), Qrun);
+      p->pty_flag = 1;
+      pset_status (p, Qrun);
       setup_process_coding_systems (process);
 
-      FD_SET (inchannel, &input_wait_mask);
-      FD_SET (inchannel, &non_keyboard_wait_mask);
-      if (inchannel > max_process_desc)
-        max_process_desc = inchannel;
+      FD_SET (pty_fd, &input_wait_mask);
+      FD_SET (pty_fd, &non_keyboard_wait_mask);
+      if (pty_fd > max_process_desc)
+        max_process_desc = pty_fd;
 
-      pset_tty_name (XPROCESS (process), build_string (pty_name));
+      pset_tty_name (p, build_string (pty_name));
     }
 
-  XPROCESS (process)->pid = -2;
+  p->pid = -2;
 }
 
 
@@ -2529,6 +2559,7 @@ usage:  (make-serial-process &rest ARGS)  */)
   p = XPROCESS (proc);
 
   fd = serial_open (port);
+  p->open_fd[SUBPROCESS_STDIN] = fd;
   p->infd = fd;
   p->outfd = fd;
   if (fd > max_process_desc)
@@ -3201,7 +3232,7 @@ usage: (make-network-process &rest ARGS)  */)
              wait for completion is pselect(). */
           int sc;
           socklen_t len;
-          SELECT_TYPE fdset;
+          fd_set fdset;
         retry_select:
           FD_ZERO (&fdset);
           FD_SET (s, &fdset);
@@ -3291,12 +3322,6 @@ usage: (make-network-process &rest ARGS)  */)
     }
 #endif
 
-  /* Discard the unwind protect for closing S, if any.  */
-  specpdl_ptr = specpdl + count1;
-
-  /* Unwind bind_polling_period and request_sigio.  */
-  unbind_to (count, Qnil);
-
   if (s < 0)
     {
       /* If non-blocking got this far - and failed - assume non-blocking is
@@ -3338,8 +3363,17 @@ usage: (make-network-process &rest ARGS)  */)
   if ((tem = Fplist_get (contact, QCstop), !NILP (tem)))
     pset_command (p, Qt);
   p->pid = 0;
+
+  p->open_fd[SUBPROCESS_STDIN] = inch;
   p->infd  = inch;
   p->outfd = outch;
+
+  /* Discard the unwind protect for closing S, if any.  */
+  specpdl_ptr = specpdl + count1;
+
+  /* Unwind bind_polling_period and request_sigio.  */
+  unbind_to (count, Qnil);
+
   if (is_server && socktype != SOCK_DGRAM)
     pset_status (p, Qlisten);
 
@@ -3778,17 +3812,15 @@ FLAGS is the current flags of the interface.  */)
 static void
 deactivate_process (Lisp_Object proc)
 {
-  register int inchannel, outchannel;
-  register struct Lisp_Process *p = XPROCESS (proc);
+  int inchannel;
+  struct Lisp_Process *p = XPROCESS (proc);
+  int i;
 
 #ifdef HAVE_GNUTLS
   /* Delete GnuTLS structures in PROC, if any.  */
   emacs_gnutls_deinit (proc);
 #endif /* HAVE_GNUTLS */
 
-  inchannel  = p->infd;
-  outchannel = p->outfd;
-
 #ifdef ADAPTIVE_READ_BUFFERING
   if (p->read_output_delay > 0)
     {
@@ -3799,14 +3831,14 @@ deactivate_process (Lisp_Object proc)
     }
 #endif
 
+  /* Beware SIGCHLD hereabouts. */
+
+  for (i = 0; i < PROCESS_OPEN_FDS; i++)
+    close_process_fd (&p->open_fd[i]);
+
+  inchannel = p->infd;
   if (inchannel >= 0)
     {
-      /* Beware SIGCHLD hereabouts. */
-      flush_pending_output (inchannel);
-      emacs_close (inchannel);
-      if (outchannel >= 0 && outchannel != inchannel)
-        emacs_close (outchannel);
-
       p->infd  = -1;
       p->outfd = -1;
 #ifdef DATAGRAM_SOCKETS
@@ -3831,13 +3863,14 @@ deactivate_process (Lisp_Object proc)
 #endif
       if (inchannel == max_process_desc)
         {
-          int i;
           /* We just closed the highest-numbered process input descriptor,
              so recompute the highest-numbered one now.  */
-          max_process_desc = 0;
-          for (i = 0; i < MAXDESC; i++)
-            if (!NILP (chan_process[i]))
-              max_process_desc = i;
+          int i = inchannel;
+          do
+            i--;
+          while (0 <= i && NILP (chan_process[i]));
+
+          max_process_desc = i;
         }
     }
 }
@@ -3899,9 +3932,9 @@ Return non-nil if we received any output before the timeout expired.  */)
         {
           if (XFLOAT_DATA (seconds) > 0)
             {
-              EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (seconds));
-              secs = min (EMACS_SECS (t), WAIT_READING_MAX);
-              nsecs = EMACS_NSECS (t);
+              struct timespec t = dtotimespec (XFLOAT_DATA (seconds));
+              secs = min (t.tv_sec, WAIT_READING_MAX);
+              nsecs = t.tv_nsec;
             }
         }
       else
@@ -4088,6 +4121,7 @@ server_accept_connection (Lisp_Object server, int channel)
   /* Discard the unwind protect for closing S.  */
   specpdl_ptr = specpdl + count;
 
+  p->open_fd[SUBPROCESS_STDIN] = s;
   p->infd  = s;
   p->outfd = s;
   pset_status (p, Qrun);
@@ -4198,14 +4232,14 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                              struct Lisp_Process *wait_proc, int just_wait_proc)
 {
   int channel, nfds;
-  SELECT_TYPE Available;
-  SELECT_TYPE Writeok;
+  fd_set Available;
+  fd_set Writeok;
   bool check_write;
   int check_delay;
   bool no_avail;
   int xerrno;
   Lisp_Object proc;
-  EMACS_TIME timeout, end_time;
+  struct timespec timeout, end_time;
   int wait_channel = -1;
   bool got_some_input = 0;
   ptrdiff_t count = SPECPDL_INDEX ();
@@ -4238,8 +4272,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
      compute the absolute time to return at.  */
   if (time_limit || nsecs > 0)
     {
-      timeout = make_emacs_time (time_limit, nsecs);
-      end_time = add_emacs_time (current_emacs_time (), timeout);
+      timeout = make_timespec (time_limit, nsecs);
+      end_time = timespec_add (current_timespec (), timeout);
     }
 
   while (1)
@@ -4266,18 +4300,18 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
              gobble output available now
              but don't wait at all. */
 
-          timeout = make_emacs_time (0, 0);
+          timeout = make_timespec (0, 0);
         }
       else if (time_limit || nsecs > 0)
         {
-          EMACS_TIME now = current_emacs_time ();
-          if (EMACS_TIME_LE (end_time, now))
+          struct timespec now = current_timespec ();
+          if (timespec_cmp (end_time, now) <= 0)
             break;
-          timeout = sub_emacs_time (end_time, now);
+          timeout = timespec_sub (end_time, now);
         }
       else
         {
-          timeout = make_emacs_time (100000, 0);
+          timeout = make_timespec (100000, 0);
         }
 
       /* Normally we run timers here.
@@ -4287,7 +4321,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
       if (NILP (wait_for_cell)
           && just_wait_proc >= 0)
         {
-          EMACS_TIME timer_delay;
+          struct timespec timer_delay;
 
           do
             {
@@ -4322,9 +4356,9 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
           /* A negative timeout means do not wait at all.  */
           if (nsecs >= 0)
             {
-              if (EMACS_TIME_VALID_P (timer_delay))
+              if (timespec_valid_p (timer_delay))
                 {
-                  if (EMACS_TIME_LT (timer_delay, timeout))
+                  if (timespec_cmp (timer_delay, timeout) < 0)
                     {
                       timeout = timer_delay;
                       timeout_reduced_for_timers = 1;
@@ -4353,8 +4387,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
          timeout to get our attention.  */
       if (update_tick != process_tick)
         {
-          SELECT_TYPE Atemp;
-          SELECT_TYPE Ctemp;
+          fd_set Atemp;
+          fd_set Ctemp;
 
           if (kbd_on_hold_p ())
             FD_ZERO (&Atemp);
@@ -4362,7 +4396,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
             Atemp = input_wait_mask;
           Ctemp = write_mask;
 
-          timeout = make_emacs_time (0, 0);
+          timeout = make_timespec (0, 0);
           if ((pselect (max (max_process_desc, max_input_desc) + 1,
                         &Atemp,
 #ifdef NON_BLOCKING_CONNECT
@@ -4484,8 +4518,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
              Vprocess_adaptive_read_buffering is nil.  */
           if (process_output_skip && check_delay > 0)
             {
-              int nsecs = EMACS_NSECS (timeout);
-              if (EMACS_SECS (timeout) > 0 || nsecs > READ_OUTPUT_DELAY_MAX)
+              int nsecs = timeout.tv_nsec;
+              if (timeout.tv_sec > 0 || nsecs > READ_OUTPUT_DELAY_MAX)
                 nsecs = READ_OUTPUT_DELAY_MAX;
               for (channel = 0; check_delay > 0 && channel <= max_process_desc; channel++)
                 {
@@ -4505,7 +4539,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                         nsecs = XPROCESS (proc)->read_output_delay;
                     }
                 }
-              timeout = make_emacs_time (0, nsecs);
+              timeout = make_timespec (0, nsecs);
               process_output_skip = 0;
             }
 #endif
@@ -4519,7 +4553,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
 #endif
             (max (max_process_desc, max_input_desc) + 1,
              &Available,
-             (check_write ? &Writeok : (SELECT_TYPE *)0),
+             (check_write ? &Writeok : 0),
              NULL, &timeout, NULL);
 
 #ifdef HAVE_GNUTLS
@@ -4537,7 +4571,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                      the gnutls library -- 2.12.14 has been confirmed
                      to need it.  See
                      http://comments.gmane.org/gmane.emacs.devel/145074 */
-                  for (channel = 0; channel < MAXDESC; ++channel)
+                  for (channel = 0; channel < FD_SETSIZE; ++channel)
                     if (! NILP (chan_process[channel]))
                       {
                         struct Lisp_Process *p =
@@ -5144,15 +5178,10 @@ DEFUN ("internal-default-process-filter", Finternal_default_process_filter,
 
       bset_read_only (current_buffer, Qnil);
 
-      /* Insert new output into buffer
-         at the current end-of-output marker,
-         thus preserving logical ordering of input and output.  */
+      /* Insert new output into buffer at the current end-of-output
+         marker, thus preserving logical ordering of input and output.  */
       if (XMARKER (p->mark)->buffer)
-        SET_PT_BOTH (clip_to_bounds (BEGV,
-                                     marker_position (p->mark), ZV),
-                     clip_to_bounds (BEGV_BYTE,
-                                     marker_byte_position (p->mark),
-                                     ZV_BYTE));
+        set_point_from_marker (p->mark);
       else
         SET_PT_BOTH (ZV, ZV_BYTE);
       before = PT;
@@ -5733,10 +5762,9 @@ process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
         return;
     }
 
-  switch (signo)
-    {
 #ifdef SIGCONT
-    case SIGCONT:
+  if (signo == SIGCONT)
+    {
       p->raw_status_new = 0;
       pset_status (p, Qrun);
       p->tick = ++process_tick;
@@ -5745,14 +5773,8 @@ process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
           status_notify (NULL);
           redisplay_preserve_echo_area (13);
         }
-      break;
-#endif /* ! defined (SIGCONT) */
-    case SIGINT:
-    case SIGQUIT:
-    case SIGKILL:
-      flush_pending_output (p->infd);
-      break;
     }
+#endif
 
   /* If we don't have process groups, send the signal to the immediate
      subprocess.  That isn't really right, but it's better than any
@@ -6007,7 +6029,8 @@ process has been transmitted to the serial port.  */)
     }
   else
     {
-      int old_outfd, new_outfd;
+      int old_outfd = XPROCESS (proc)->outfd;
+      int new_outfd;
 
 #ifdef HAVE_SHUTDOWN
       /* If this is a network connection, or socketpair is used
@@ -6015,18 +6038,15 @@ process has been transmitted to the serial port.  */)
          (In some old system, shutdown to socketpair doesn't work.
          Then we just can't win.)  */
       if (EQ (XPROCESS (proc)->type, Qnetwork)
-          || XPROCESS (proc)->outfd == XPROCESS (proc)->infd)
-        shutdown (XPROCESS (proc)->outfd, 1);
-      /* In case of socketpair, outfd == infd, so don't close it.  */
-      if (XPROCESS (proc)->outfd != XPROCESS (proc)->infd)
-        emacs_close (XPROCESS (proc)->outfd);
-#else /* not HAVE_SHUTDOWN */
-      emacs_close (XPROCESS (proc)->outfd);
-#endif /* not HAVE_SHUTDOWN */
+          || XPROCESS (proc)->infd == old_outfd)
+        shutdown (old_outfd, 1);
+#endif
+      close_process_fd (&XPROCESS (proc)->open_fd[WRITE_TO_SUBPROCESS]);
       new_outfd = emacs_open (NULL_DEVICE, O_WRONLY, 0);
       if (new_outfd < 0)
-        emacs_abort ();
-      old_outfd = XPROCESS (proc)->outfd;
+        report_file_error ("Opening null device", Qnil);
+      XPROCESS (proc)->open_fd[WRITE_TO_SUBPROCESS] = new_outfd;
+      XPROCESS (proc)->outfd = new_outfd;
 
       if (!proc_encode_coding_system[new_outfd])
         proc_encode_coding_system[new_outfd]
@@ -6035,8 +6055,6 @@ process has been transmitted to the serial port.  */)
         = *proc_encode_coding_system[old_outfd];
       memset (proc_encode_coding_system[old_outfd], 0,
               sizeof (struct coding_system));
-
-      XPROCESS (proc)->outfd = new_outfd;
     }
   return process;
 }
@@ -6102,7 +6120,7 @@ static signal_handler_t volatile lib_child_handler;
 static void
 handle_child_signal (int sig)
 {
-  Lisp_Object tail;
+  Lisp_Object tail, proc;
 
   /* Find the process that signaled us, and record its status.  */
 
@@ -6113,7 +6131,11 @@ handle_child_signal (int sig)
       bool all_pids_are_fixnums
         = (MOST_NEGATIVE_FIXNUM <= TYPE_MINIMUM (pid_t)
            && TYPE_MAXIMUM (pid_t) <= MOST_POSITIVE_FIXNUM);
-      Lisp_Object xpid = XCAR (tail);
+      Lisp_Object head = XCAR (tail);
+      Lisp_Object xpid;
+      if (! CONSP (head))
+        continue;
+      xpid = XCAR (head);
       if (all_pids_are_fixnums ? INTEGERP (xpid) : NUMBERP (xpid))
         {
           pid_t deleted_pid;
@@ -6122,14 +6144,17 @@ handle_child_signal (int sig)
           else
             deleted_pid = XFLOAT_DATA (xpid);
           if (child_status_changed (deleted_pid, 0, 0))
-            XSETCAR (tail, Qnil);
+            {
+              if (STRINGP (XCDR (head)))
+                unlink (SSDATA (XCDR (head)));
+              XSETCAR (tail, Qnil);
+            }
         }
     }
 
   /* Otherwise, if it is asynchronous, it is in Vprocess_alist.  */
-  for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_PROCESS (tail, proc)
     {
-      Lisp_Object proc = XCDR (XCAR (tail));
       struct Lisp_Process *p = XPROCESS (proc);
       int status;
 
@@ -6284,13 +6309,10 @@ status_notify (struct Lisp_Process *deleting_process)
      that we run, we get called again to handle their status changes.  */
   update_tick = process_tick;
 
-  for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_PROCESS (tail, proc)
     {
       Lisp_Object symbol;
-      register struct Lisp_Process *p;
-
-      proc = Fcdr (XCAR (tail));
-      p = XPROCESS (proc);
+      register struct Lisp_Process *p = XPROCESS (proc);
 
       if (p->tick != p->update_tick)
         {
@@ -6515,8 +6537,8 @@ keyboard_bit_set (fd_set *mask)
 #else  /* not subprocesses */
 
 /* Defined on msdos.c.  */
-extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
-                       EMACS_TIME *, void *);
+extern int sys_select (int, fd_set *, fd_set *, fd_set *,
+                       struct timespec *, void *);
 
 /* Implementation of wait_reading_process_output, assuming that there
    are no subprocesses.  Used only by the MS-DOS build.
@@ -6555,7 +6577,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                              struct Lisp_Process *wait_proc, int just_wait_proc)
 {
   register int nfds;
-  EMACS_TIME end_time, timeout;
+  struct timespec end_time, timeout;
 
   if (time_limit < 0)
     {
@@ -6568,8 +6590,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
   /* What does time_limit really mean?  */
   if (time_limit || nsecs > 0)
     {
-      timeout = make_emacs_time (time_limit, nsecs);
-      end_time = add_emacs_time (current_emacs_time (), timeout);
+      timeout = make_timespec (time_limit, nsecs);
+      end_time = timespec_add (current_timespec (), timeout);
     }
 
   /* Turn off periodic alarms (in case they are in use)
@@ -6581,7 +6603,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
   while (1)
     {
       bool timeout_reduced_for_timers = 0;
-      SELECT_TYPE waitchannels;
+      fd_set waitchannels;
       int xerrno;
 
       /* If calling from keyboard input, do not quit
@@ -6602,18 +6624,18 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
              gobble output available now
              but don't wait at all.  */
 
-          timeout = make_emacs_time (0, 0);
+          timeout = make_timespec (0, 0);
         }
       else if (time_limit || nsecs > 0)
         {
-          EMACS_TIME now = current_emacs_time ();
-          if (EMACS_TIME_LE (end_time, now))
+          struct timespec now = current_timespec ();
+          if (timespec_cmp (end_time, now) <= 0)
             break;
-          timeout = sub_emacs_time (end_time, now);
+          timeout = timespec_sub (end_time, now);
         }
       else
         {
-          timeout = make_emacs_time (100000, 0);
+          timeout = make_timespec (100000, 0);
         }
 
       /* If our caller will not immediately handle keyboard events,
@@ -6622,7 +6644,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
          call timer_delay on their own.)  */
       if (NILP (wait_for_cell))
         {
-          EMACS_TIME timer_delay;
+          struct timespec timer_delay;
 
           do
             {
@@ -6642,9 +6664,9 @@ 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) && nsecs >= 0)
+          if (timespec_valid_p (timer_delay) && nsecs >= 0)
             {
-              if (EMACS_TIME_LT (timer_delay, timeout))
+              if (timespec_cmp (timer_delay, timeout) < 0)
                 {
                   timeout = timer_delay;
                   timeout_reduced_for_timers = 1;
@@ -6763,16 +6785,9 @@ void
 delete_keyboard_wait_descriptor (int desc)
 {
 #ifdef subprocesses
-  int fd;
-  int lim = max_input_desc;
-
   FD_CLR (desc, &input_wait_mask);
   FD_CLR (desc, &non_process_wait_mask);
-
-  if (desc == max_input_desc)
-    for (fd = 0; fd < lim; fd++)
-      if (FD_ISSET (fd, &input_wait_mask) || FD_ISSET (fd, &write_mask))
-        max_input_desc = fd;
+  delete_input_desc (desc);
 #endif
 }
 
@@ -6820,12 +6835,9 @@ BUFFER may be a buffer or the name of one.  */)
   buf = Fget_buffer (buffer);
   if (NILP (buf)) return Qnil;
 
-  for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
-    {
-      proc = Fcdr (XCAR (tail));
-      if (PROCESSP (proc) && EQ (XPROCESS (proc)->buffer, buf))
-        return proc;
-    }
+  FOR_EACH_PROCESS (tail, proc)
+    if (EQ (XPROCESS (proc)->buffer, buf))
+      return proc;
 #endif  /* subprocesses */
   return Qnil;
 }
@@ -6858,18 +6870,14 @@ kill_buffer_processes (Lisp_Object buffer)
 #ifdef subprocesses
   Lisp_Object tail, proc;
 
-  for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
-    {
-      proc = XCDR (XCAR (tail));
-      if (PROCESSP (proc)
-          && (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer)))
-        {
-          if (NETCONN_P (proc) || SERIALCONN_P (proc))
-            Fdelete_process (proc);
-          else if (XPROCESS (proc)->infd >= 0)
-            process_send_signal (proc, SIGHUP, Qnil, 1);
-        }
-    }
+  FOR_EACH_PROCESS (tail, proc)
+    if (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer))
+      {
+        if (NETCONN_P (proc) || SERIALCONN_P (proc))
+          Fdelete_process (proc);
+        else if (XPROCESS (proc)->infd >= 0)
+          process_send_signal (proc, SIGHUP, Qnil, 1);
+      }
 #else  /* subprocesses */
   /* Since we have no subprocesses, this does nothing.  */
 #endif /* subprocesses */
@@ -7037,7 +7045,7 @@ init_process_emacs (void)
   FD_ZERO (&non_keyboard_wait_mask);
   FD_ZERO (&non_process_wait_mask);
   FD_ZERO (&write_mask);
-  max_process_desc = 0;
+  max_process_desc = max_input_desc = -1;
   memset (fd_callback_info, 0, sizeof (fd_callback_info));
 
 #ifdef NON_BLOCKING_CONNECT
@@ -7059,7 +7067,7 @@ init_process_emacs (void)
 
   Vprocess_alist = Qnil;
   deleted_pid_list = Qnil;
-  for (i = 0; i < MAXDESC; i++)
+  for (i = 0; i < FD_SETSIZE; i++)
     {
       chan_process[i] = Qnil;
       proc_buffered_char[i] = -1;
diff --git a/src/process.h b/src/process.h
index 8ae33aebf39..6aff95686a2 100644
--- a/src/process.h
+++ b/src/process.h
@@ -31,6 +31,11 @@ INLINE_HEADER_BEGIN
 # define PROCESS_INLINE INLINE
 #endif
 
+/* Bound on number of file descriptors opened on behalf of a process,
+   that need to be closed.  */
+
+enum { PROCESS_OPEN_FDS = 6 };
+
 /* This structure records information about a subprocess
    or network connection.  */
 
@@ -115,6 +120,9 @@ struct Lisp_Process
     int infd;
     /* Descriptor by which we write to this process */
     int outfd;
+    /* Descriptors that were created for this process and that need
+       closing.  Unused entries are negative.  */
+    int open_fd[PROCESS_OPEN_FDS];
     /* Event-count of last event in which this process changed status.  */
     EMACS_INT tick;
     /* Event-count of last such event reported.  */
@@ -210,13 +218,17 @@ enum
 
 extern void block_child_signal (void);
 extern void unblock_child_signal (void);
-extern void record_kill_process (struct Lisp_Process *);
+extern Lisp_Object encode_current_directory (void);
+extern void record_kill_process (struct Lisp_Process *, Lisp_Object);
 
-/* Defined in process.c.  */
+/* Defined in sysdep.c.  */
 
 extern Lisp_Object list_system_processes (void);
 extern Lisp_Object system_process_attributes (Lisp_Object);
 
+/* Defined in process.c.  */
+
+extern void record_deleted_pid (pid_t, Lisp_Object);
 extern void hold_keyboard_input (void);
 extern void unhold_keyboard_input (void);
 extern bool kbd_on_hold_p (void);
diff --git a/src/profiler.c b/src/profiler.c
index c86fb47d21d..64eb5cafc25 100644
--- a/src/profiler.c
+++ b/src/profiler.c
@@ -267,8 +267,8 @@ setup_cpu_timer (Lisp_Object sampling_interval)
     return NOT_RUNNING;
 
   current_sampling_interval = XINT (sampling_interval);
-  interval = make_emacs_time (current_sampling_interval / billion,
-                              current_sampling_interval % billion);
+  interval = make_timespec (current_sampling_interval / billion,
+                            current_sampling_interval % billion);
   emacs_sigaction_init (&action, deliver_profiler_signal);
   sigaction (SIGPROF, &action, 0);
 
diff --git a/src/regex.c b/src/regex.c
index 39adb080efd..1befececd22 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -257,15 +257,10 @@ xrealloc (void *block, size_t size)
 enum syntaxcode { Swhitespace = 0, Sword = 1, Ssymbol = 2 };
 
 /* Dummy macros for non-Emacs environments.  */
-# define CHAR_CHARSET(c) 0
-# define CHARSET_LEADING_CODE_BASE(c) 0
 # define MAX_MULTIBYTE_LENGTH 1
 # define RE_MULTIBYTE_P(x) 0
 # define RE_TARGET_MULTIBYTE_P(x) 0
 # define WORD_BOUNDARY_P(c1, c2) (0)
-# define CHAR_HEAD_P(p) (1)
-# define SINGLE_BYTE_CHAR_P(c) (1)
-# define SAME_CHARSET_P(c1, c2) (1)
 # define BYTES_BY_CHAR_HEAD(p) (1)
 # define PREV_CHAR_BOUNDARY(p, limit) ((p)--)
 # define STRING_CHAR(p) (*(p))
@@ -279,8 +274,6 @@ enum syntaxcode { Swhitespace = 0, Sword = 1, Ssymbol = 2 };
   (c = ((p) == (str2) ? *((end1) - 1) : *((p) - 1)))
 # define GET_CHAR_AFTER(c, p, len)      \
   (c = *p, len = 1)
-# define MAKE_CHAR(charset, c1, c2) (c1)
-# define BYTE8_TO_CHAR(c) (c)
 # define CHAR_BYTE8_P(c) (0)
 # define CHAR_LEADING_CODE(c) (c)
 
@@ -468,7 +461,7 @@ init_syntax_once (void)
 
 /* Assumes a `char *destination' variable.  */
 # define REGEX_REALLOCATE(source, osize, nsize)                         \
-  (destination = (char *) alloca (nsize),                               \
+  (destination = alloca (nsize),                                        \
    memcpy (destination, source, osize))
 
 /* No need to do anything to free, after alloca.  */
@@ -775,10 +768,12 @@ extract_number_and_incr (re_char **source)
    and the 2 bytes of flags at the start of the range table.  */
 #define CHARSET_RANGE_TABLE(p) (&(p)[4 + CHARSET_BITMAP_SIZE (p)])
 
+#ifdef emacs
 /* Extract the bit flags that start a range table.  */
 #define CHARSET_RANGE_TABLE_BITS(p)             \
   ((p)[2 + CHARSET_BITMAP_SIZE (p)]             \
    + (p)[3 + CHARSET_BITMAP_SIZE (p)] * 0x100)
+#endif
 
 /* Return the address of end of RANGE_TABLE.  COUNT is number of
    ranges (which is a pair of (start, end)) in the RANGE_TABLE.  `* 2'
@@ -1238,12 +1233,12 @@ re_set_syntax (reg_syntax_t syntax)
 WEAK_ALIAS (__re_set_syntax, re_set_syntax)
 
 /* Regexp to use to replace spaces, or NULL meaning don't.  */
-static re_char *whitespace_regexp;
+static const_re_char *whitespace_regexp;
 
 void
 re_set_whitespace_regexp (const char *regexp)
 {
-  whitespace_regexp = (re_char *) regexp;
+  whitespace_regexp = (const_re_char *) regexp;
 }
 WEAK_ALIAS (__re_set_syntax, re_set_syntax)
 
@@ -1830,6 +1825,8 @@ struct range_table_work_area
   int bits;                     /* flag to record character classes */
 };
 
+#ifdef emacs
+
 /* Make sure that WORK_AREA can hold more N multibyte characters.
    This is used only in set_image_of_range and set_image_of_range_1.
    It expects WORK_AREA to be a pointer.
@@ -1848,15 +1845,6 @@ struct range_table_work_area
 #define SET_RANGE_TABLE_WORK_AREA_BIT(work_area, bit)           \
   (work_area).bits |= (bit)
 
-/* Bits used to implement the multibyte-part of the various character classes
-   such as [:alnum:] in a charset's range table.  */
-#define BIT_WORD        0x1
-#define BIT_LOWER       0x2
-#define BIT_PUNCT       0x4
-#define BIT_SPACE       0x8
-#define BIT_UPPER       0x10
-#define BIT_MULTIBYTE   0x20
-
 /* Set a range (RANGE_START, RANGE_END) to WORK_AREA.  */
 #define SET_RANGE_TABLE_WORK_AREA(work_area, range_start, range_end)    \
   do {                                                                  \
@@ -1865,6 +1853,8 @@ struct range_table_work_area
     (work_area).table[(work_area).used++] = (range_end);                \
   } while (0)
 
+#endif /* emacs */
+
 /* Free allocated memory for WORK_AREA.  */
 #define FREE_RANGE_TABLE_WORK_AREA(work_area)   \
   do {                                          \
@@ -1876,6 +1866,15 @@ struct range_table_work_area
 #define RANGE_TABLE_WORK_USED(work_area) ((work_area).used)
 #define RANGE_TABLE_WORK_BITS(work_area) ((work_area).bits)
 #define RANGE_TABLE_WORK_ELT(work_area, i) ((work_area).table[i])
+
+/* Bits used to implement the multibyte-part of the various character classes
+   such as [:alnum:] in a charset's range table.  */
+#define BIT_WORD        0x1
+#define BIT_LOWER       0x2
+#define BIT_PUNCT       0x4
+#define BIT_SPACE       0x8
+#define BIT_UPPER       0x10
+#define BIT_MULTIBYTE   0x20
 
 
 /* Set the bit for character C in a list.  */
@@ -4208,7 +4207,7 @@ re_set_registers (struct re_pattern_buffer *bufp, struct re_registers *regs, uns
     {
       bufp->regs_allocated = REGS_UNALLOCATED;
       regs->num_regs = 0;
-      regs->start = regs->end = (regoff_t *) 0;
+      regs->start = regs->end = 0;
     }
 }
 WEAK_ALIAS (__re_set_registers, re_set_registers)
@@ -6395,8 +6394,7 @@ weak_function
 re_exec (const char *s)
 {
   const size_t len = strlen (s);
-  return (re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0)
-          >= 0);
+  return re_search (&re_comp_buf, s, len, 0, len, 0) >= 0;
 }
 #endif /* _REGEX_RE_COMP */
 
@@ -6560,7 +6558,7 @@ regexec (const regex_t *_Restrict_ preg, const char *_Restrict_ string,
   /* Perform the searching operation.  */
   ret = re_search (&private_preg, string, len,
                    /* start: */ 0, /* range: */ len,
-                   want_reg_info ? &regs : (struct re_registers *) 0);
+                   want_reg_info ? &regs : 0);
 
   /* Copy the register information to the POSIX structure.  */
   if (want_reg_info)
diff --git a/src/scroll.c b/src/scroll.c
index 3e296068e8f..b9ed8c04ba8 100644
--- a/src/scroll.c
+++ b/src/scroll.c
@@ -652,8 +652,7 @@ do_direct_scrolling (struct frame *frame, struct glyph_matrix *current_matrix,
 
   /* A queue of deletions and insertions to be performed.  */
   struct alt_queue { int count, pos, window; };
-  struct alt_queue *queue_start = (struct alt_queue *)
-    alloca (window_size * sizeof *queue_start);
+  struct alt_queue *queue_start = alloca (window_size * sizeof *queue_start);
   struct alt_queue *queue = queue_start;
 
   /* True if a terminal window has been set with set_terminal_window.  */
@@ -797,9 +796,8 @@ scrolling_1 (struct frame *frame, int window_size, int unchanged_at_top,
              int unchanged_at_bottom, int *draw_cost, int *old_draw_cost,
              int *old_hash, int *new_hash, int free_at_end)
 {
-  struct matrix_elt *matrix;
-  matrix = ((struct matrix_elt *)
-            alloca ((window_size + 1) * (window_size + 1) * sizeof *matrix));
+  struct matrix_elt *matrix
+    = alloca ((window_size + 1) * (window_size + 1) * sizeof *matrix);
 
   if (FRAME_SCROLL_REGION_OK (frame))
     {
diff --git a/src/search.c b/src/search.c
index 0f4d41586a3..99e8d2501fe 100644
--- a/src/search.c
+++ b/src/search.c
@@ -598,14 +598,14 @@ fast_looking_at (Lisp_Object regexp, ptrdiff_t pos, ptrdiff_t pos_byte,
 
 /* The newline cache: remembering which sections of text have no newlines.  */
 
-/* If the user has requested newline caching, make sure it's on.
+/* If the user has requested the long scans caching, make sure it's on.
    Otherwise, make sure it's off.
    This is our cheezy way of associating an action with the change of
    state of a buffer-local variable.  */
 static void
 newline_cache_on_off (struct buffer *buf)
 {
-  if (NILP (BVAR (buf, cache_long_line_scans)))
+  if (NILP (BVAR (buf, cache_long_scans)))
     {
       /* It should be off.  */
       if (buf->newline_cache)
@@ -859,88 +859,20 @@ find_newline (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
    If ALLOW_QUIT, set immediate_quit.  That's good to do
    except in special cases.  */
 
-EMACS_INT
+ptrdiff_t
 scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
               ptrdiff_t limit, ptrdiff_t limit_byte,
-              EMACS_INT count, bool allow_quit)
+              ptrdiff_t count, bool allow_quit)
 {
-  int direction = ((count > 0) ? 1 : -1);
-
-  unsigned char *cursor;
-  unsigned char *base;
-
-  ptrdiff_t ceiling;
-  unsigned char *ceiling_addr;
-
-  bool old_immediate_quit = immediate_quit;
-
-  if (allow_quit)
-    immediate_quit++;
+  ptrdiff_t charpos, bytepos, shortage;
 
-  if (count > 0)
-    {
-      while (start_byte < limit_byte)
-        {
-          ceiling =  BUFFER_CEILING_OF (start_byte);
-          ceiling = min (limit_byte - 1, ceiling);
-          ceiling_addr = BYTE_POS_ADDR (ceiling) + 1;
-          base = (cursor = BYTE_POS_ADDR (start_byte));
-
-          do
-            {
-              unsigned char *nl = memchr (cursor, '\n', ceiling_addr - cursor);
-              if (! nl)
-                break;
-              if (--count == 0)
-                {
-                  immediate_quit = old_immediate_quit;
-                  start_byte += nl - base + 1;
-                  start = BYTE_TO_CHAR (start_byte);
-                  TEMP_SET_PT_BOTH (start, start_byte);
-                  return 0;
-                }
-              cursor = nl + 1;
-            }
-          while (cursor < ceiling_addr);
-
-          start_byte += ceiling_addr - base;
-        }
-    }
+  charpos = find_newline (start, start_byte, limit, limit_byte,
+                          count, &shortage, &bytepos, allow_quit);
+  if (shortage)
+    TEMP_SET_PT_BOTH (limit, limit_byte);
   else
-    {
-      while (start_byte > limit_byte)
-        {
-          ceiling = BUFFER_FLOOR_OF (start_byte - 1);
-          ceiling = max (limit_byte, ceiling);
-          ceiling_addr = BYTE_POS_ADDR (ceiling);
-          base = (cursor = BYTE_POS_ADDR (start_byte - 1) + 1);
-          while (1)
-            {
-              unsigned char *nl = memrchr (ceiling_addr, '\n',
-                                           cursor - ceiling_addr);
-              if (! nl)
-                break;
-
-              if (++count == 0)
-                {
-                  immediate_quit = old_immediate_quit;
-                  /* Return the position AFTER the match we found.  */
-                  start_byte += nl - base + 1;
-                  start = BYTE_TO_CHAR (start_byte);
-                  TEMP_SET_PT_BOTH (start, start_byte);
-                  return 0;
-                }
-
-              cursor = nl;
-            }
-          start_byte += ceiling_addr - base;
-        }
-    }
-
-  TEMP_SET_PT_BOTH (limit, limit_byte);
-  immediate_quit = old_immediate_quit;
-
-  return count * direction;
+    TEMP_SET_PT_BOTH (charpos, bytepos);
+  return shortage;
 }
 
 /* Like find_newline, but doesn't allow QUITting and doesn't return
diff --git a/src/sheap.c b/src/sheap.c
index 54eef60c27d..daff0c1d700 100644
--- a/src/sheap.c
+++ b/src/sheap.c
@@ -26,10 +26,18 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <unistd.h>
 
 #ifdef __x86_64__
+#ifdef ENABLE_CHECKING
+#define STATIC_HEAP_SIZE        (28 * 1024 * 1024)
+#else
+#define STATIC_HEAP_SIZE        (19 * 1024 * 1024)
+#endif
+#else  /* x86 */
+#ifdef ENABLE_CHECKING
 #define STATIC_HEAP_SIZE        (18 * 1024 * 1024)
 #else
 #define STATIC_HEAP_SIZE        (13 * 1024 * 1024)
 #endif
+#endif  /* x86 */
 
 int debug_sheap = 0;
 
@@ -37,6 +45,7 @@ int debug_sheap = 0;
 
 char bss_sbrk_buffer[STATIC_HEAP_SIZE];
 char *bss_sbrk_ptr;
+char *max_bss_sbrk_ptr;
 int bss_sbrk_did_unexec;
 
 void *
@@ -44,7 +53,7 @@ bss_sbrk (ptrdiff_t request_size)
 {
   if (!bss_sbrk_ptr)
     {
-      bss_sbrk_ptr = bss_sbrk_buffer;
+      max_bss_sbrk_ptr = bss_sbrk_ptr = bss_sbrk_buffer;
 #ifdef CYGWIN
       sbrk (BLOCKSIZE);         /* force space for fork to work */
 #endif
@@ -85,6 +94,8 @@ bss_sbrk (ptrdiff_t request_size)
       if (debug_sheap)
         printf ("allocated 0x%08x size %d\n", ret, request_size);
       bss_sbrk_ptr += (int) request_size;
+      if (bss_sbrk_ptr > max_bss_sbrk_ptr)
+        max_bss_sbrk_ptr = bss_sbrk_ptr;
       return ret;
     }
 }
@@ -93,8 +104,8 @@ void
 report_sheap_usage (int die_if_pure_storage_exceeded)
 {
   char buf[200];
-  sprintf (buf, "Static heap usage: %d of %d bytes",
-           bss_sbrk_ptr - bss_sbrk_buffer, STATIC_HEAP_SIZE);
+  sprintf (buf, "Maximum static heap usage: %d of %d bytes",
+           max_bss_sbrk_ptr - bss_sbrk_buffer, STATIC_HEAP_SIZE);
   /* Don't log messages, cause at this point, we're not allowed to create
      buffers.  */
   message1_nolog (buf);
diff --git a/src/syntax.c b/src/syntax.c
index 6d52d115889..31eb86faed8 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -1464,6 +1464,7 @@ scan_words (register ptrdiff_t from, register EMACS_INT count)
 
 DEFUN ("forward-word", Fforward_word, Sforward_word, 0, 1, "^p",
        doc: /* Move point forward ARG words (backward if ARG is negative).
+If ARG is omitted or nil, move point forward one word.
 Normally returns t.
 If an edge of the buffer or a field boundary is reached, point is left there
 and the function returns nil.  Field boundaries are not noticed if
@@ -3485,9 +3486,9 @@ init_syntax_once (void)
   /* This has to be done here, before we call Fmake_char_table.  */
   DEFSYM (Qsyntax_table, "syntax-table");
 
-  /* Intern_C_String this now in case it isn't already done.
-     Setting this variable twice is harmless.
-     But don't staticpro it here--that is done in alloc.c.  */
+  /* This variable is DEFSYMed in alloc.c and not initialized yet, so
+     intern it here.  NOTE: you must guarantee that init_syntax_once
+     is called before all other users of this variable.  */
   Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
 
   /* Create objects which can be shared among syntax tables.  */
diff --git a/src/sysdep.c b/src/sysdep.c
index 11a6f4a76ce..6439697501e 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -306,7 +306,7 @@ get_child_status (pid_t child, int *status, int options, bool interruptible)
   /* If successful and status is requested, tell wait_reading_process_output
      that it needs to wake up and look around.  */
   if (pid && status && input_available_clear_time)
-    *input_available_clear_time = make_emacs_time (0, 0);
+    *input_available_clear_time = make_timespec (0, 0);
 
   return pid;
 }
@@ -337,16 +337,6 @@ child_status_changed (pid_t child, int *status, int options)
   return get_child_status (child, status, WNOHANG | options, 0);
 }
 
-/*
- *      flush any pending output
- *      (may flush input as well; it does not matter the way we use it)
- */
-
-void
-flush_pending_output (int channel)
-{
-  /* FIXME: maybe this function should be removed */
-}
 
 /*  Set up the terminal at the other end of a pseudo-terminal that
     we will be controlling an inferior through.
@@ -481,10 +471,20 @@ sys_subshell (void)
   pid_t pid;
   int status;
   struct save_signal saved_handlers[5];
-  Lisp_Object dir;
-  unsigned char *volatile str_volatile = 0;
-  unsigned char *str;
-  int len;
+  char *str = SSDATA (encode_current_directory ());
+
+#ifdef DOS_NT
+  pid = 0;
+#else
+  {
+    char *volatile str_volatile = str;
+    pid = vfork ();
+    str = str_volatile;
+  }
+#endif
+
+  if (pid < 0)
+    error ("Can't spawn subshell");
 
   saved_handlers[0].code = SIGINT;
   saved_handlers[1].code = SIGQUIT;
@@ -496,31 +496,8 @@ sys_subshell (void)
   saved_handlers[3].code = 0;
 #endif
 
-  /* Mentioning current_buffer->buffer would mean including buffer.h,
-     which somehow wedges the hp compiler.  So instead...  */
-
-  dir = intern ("default-directory");
-  if (NILP (Fboundp (dir)))
-    goto xyzzy;
-  dir = Fsymbol_value (dir);
-  if (!STRINGP (dir))
-    goto xyzzy;
-
-  dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
-  str_volatile = str = alloca (SCHARS (dir) + 2);
-  len = SCHARS (dir);
-  memcpy (str, SDATA (dir), len);
-  if (str[len - 1] != '/') str[len++] = '/';
-  str[len] = 0;
- xyzzy:
-
 #ifdef DOS_NT
-  pid = 0;
   save_signal_handlers (saved_handlers);
-#else
-  pid = vfork ();
-  if (pid == -1)
-    error ("Can't spawn subshell");
 #endif
 
   if (pid == 0)
@@ -538,11 +515,10 @@ sys_subshell (void)
         sh = "sh";
 
       /* Use our buffer's default directory for the subshell.  */
-      str = str_volatile;
-      if (str && chdir ((char *) str) != 0)
+      if (chdir (str) != 0)
         {
 #ifndef DOS_NT
-          emacs_perror ((char *) str);
+          emacs_perror (str);
           _exit (EXIT_CANCELED);
 #endif
         }
@@ -556,8 +532,6 @@ sys_subshell (void)
         if (epwd)
           {
             strcpy (old_pwd, epwd);
-            if (str[len - 1] == '/')
-              str[len - 1] = '\0';
             setenv ("PWD", str, 1);
           }
         st = system (sh);
@@ -614,7 +588,7 @@ restore_signal_handlers (struct save_signal *saved_handlers)
 }
 
 #ifdef USABLE_SIGIO
-static int old_fcntl_flags[MAXDESC];
+static int old_fcntl_flags[FD_SETSIZE];
 #endif
 
 void
@@ -843,7 +817,7 @@ emacs_set_tty (int fd, struct emacs_tty *settings, bool flushp)
 
 
 #ifdef F_SETOWN
-static int old_fcntl_owner[MAXDESC];
+static int old_fcntl_owner[FD_SETSIZE];
 #endif /* F_SETOWN */
 
 /* This may also be defined in stdio,
@@ -1196,7 +1170,8 @@ get_tty_size (int fd, int *widthp, int *heightp)
 }
 
 /* Set the logical window size associated with descriptor FD
-   to HEIGHT and WIDTH.  This is used mainly with ptys.  */
+   to HEIGHT and WIDTH.  This is used mainly with ptys.
+   Return a negative value on failure.  */
 
 int
 set_window_size (int fd, int height, int width)
@@ -1208,10 +1183,7 @@ set_window_size (int fd, int height, int width)
   size.ws_row = height;
   size.ws_col = width;
 
-  if (ioctl (fd, TIOCSWINSZ, &size) == -1)
-    return 0; /* error */
-  else
-    return 1;
+  return ioctl (fd, TIOCSWINSZ, &size);
 
 #else
 #ifdef TIOCSSIZE
@@ -1221,10 +1193,7 @@ set_window_size (int fd, int height, int width)
   size.ts_lines = height;
   size.ts_cols = width;
 
-  if (ioctl (fd, TIOCGSIZE, &size) == -1)
-    return 0;
-  else
-    return 1;
+  return ioctl (fd, TIOCGSIZE, &size);
 #else
   return -1;
 #endif /* not SunOS-style */
@@ -2052,8 +2021,8 @@ seed_random (void *seed, ptrdiff_t seed_size)
 void
 init_random (void)
 {
-  EMACS_TIME t = current_emacs_time ();
-  uintmax_t v = getpid () ^ EMACS_SECS (t) ^ EMACS_NSECS (t);
+  struct timespec t = current_timespec ();
+  uintmax_t v = getpid () ^ t.tv_sec ^ t.tv_nsec;
   seed_random (&v, sizeof v);
 }
 
@@ -2388,7 +2357,7 @@ emacs_perror (char const *message)
    Use the least timeval not less than T.
    Return an extremal value if the result would overflow.  */
 struct timeval
-make_timeval (EMACS_TIME t)
+make_timeval (struct timespec t)
 {
   struct timeval tv;
   tv.tv_sec = t.tv_sec;
@@ -2415,7 +2384,7 @@ make_timeval (EMACS_TIME t)
    If FD is nonnegative, then FILE can be NULL.  */
 int
 set_file_times (int fd, const char *filename,
-                EMACS_TIME atime, EMACS_TIME mtime)
+                struct timespec atime, struct timespec mtime)
 {
   struct timespec timespec[2];
   timespec[0] = atime;
@@ -2485,7 +2454,7 @@ serial_configure (struct Lisp_Process *p,
   Lisp_Object childp2 = Qnil;
   Lisp_Object tem = Qnil;
   struct termios attr;
-  int err = -1;
+  int err;
   char summary[4] = "???"; /* This usually becomes "8N1".  */
 
   childp2 = Fcopy_sequence (p->childp);
@@ -2732,7 +2701,7 @@ list_system_processes (void)
 #endif /* !defined (WINDOWSNT) */
 
 #if defined GNU_LINUX && defined HAVE_LONG_LONG_INT
-static EMACS_TIME
+static struct timespec
 time_from_jiffies (unsigned long long tval, long hz)
 {
   unsigned long long s = tval / hz;
@@ -2741,34 +2710,34 @@ time_from_jiffies (unsigned long long tval, long hz)
 
   if (TYPE_MAXIMUM (time_t) < s)
     time_overflow ();
-  if (LONG_MAX - 1 <= ULLONG_MAX / EMACS_TIME_RESOLUTION
-      || frac <= ULLONG_MAX / EMACS_TIME_RESOLUTION)
-    ns = frac * EMACS_TIME_RESOLUTION / hz;
+  if (LONG_MAX - 1 <= ULLONG_MAX / TIMESPEC_RESOLUTION
+      || frac <= ULLONG_MAX / TIMESPEC_RESOLUTION)
+    ns = frac * TIMESPEC_RESOLUTION / hz;
   else
     {
       /* This is reachable only in the unlikely case that HZ * HZ
          exceeds ULLONG_MAX.  It calculates an approximation that is
          guaranteed to be in range.  */
-      long hz_per_ns = (hz / EMACS_TIME_RESOLUTION
-                        + (hz % EMACS_TIME_RESOLUTION != 0));
+      long hz_per_ns = (hz / TIMESPEC_RESOLUTION
+                        + (hz % TIMESPEC_RESOLUTION != 0));
       ns = frac / hz_per_ns;
     }
 
-  return make_emacs_time (s, ns);
+  return make_timespec (s, ns);
 }
 
 static Lisp_Object
 ltime_from_jiffies (unsigned long long tval, long hz)
 {
-  EMACS_TIME t = time_from_jiffies (tval, hz);
+  struct timespec t = time_from_jiffies (tval, hz);
   return make_lisp_time (t);
 }
 
-static EMACS_TIME
+static struct timespec
 get_up_time (void)
 {
   FILE *fup;
-  EMACS_TIME up = make_emacs_time (0, 0);
+  struct timespec up = make_timespec (0, 0);
 
   block_input ();
   fup = emacs_fopen ("/proc/uptime", "r");
@@ -2786,18 +2755,18 @@ get_up_time (void)
           if (TYPE_MAXIMUM (time_t) < upsec)
             {
               upsec = TYPE_MAXIMUM (time_t);
-              upfrac = EMACS_TIME_RESOLUTION - 1;
+              upfrac = TIMESPEC_RESOLUTION - 1;
             }
           else
             {
               int upfraclen = upfrac_end - upfrac_start;
-              for (; upfraclen < LOG10_EMACS_TIME_RESOLUTION; upfraclen++)
+              for (; upfraclen < LOG10_TIMESPEC_RESOLUTION; upfraclen++)
                 upfrac *= 10;
-              for (; LOG10_EMACS_TIME_RESOLUTION < upfraclen; upfraclen--)
+              for (; LOG10_TIMESPEC_RESOLUTION < upfraclen; upfraclen--)
                 upfrac /= 10;
-              upfrac = min (upfrac, EMACS_TIME_RESOLUTION - 1);
+              upfrac = min (upfrac, TIMESPEC_RESOLUTION - 1);
             }
-          up = make_emacs_time (upsec, upfrac);
+          up = make_timespec (upsec, upfrac);
         }
       fclose (fup);
     }
@@ -2852,29 +2821,41 @@ procfs_ttyname (int rdev)
   return build_string (name);
 }
 
-static unsigned long
+static uintmax_t
 procfs_get_total_memory (void)
 {
   FILE *fmem;
-  unsigned long retval = 2 * 1024 * 1024; /* default: 2GB */
+  uintmax_t retval = 2 * 1024 * 1024; /* default: 2 GiB */
+  int c;
 
   block_input ();
   fmem = emacs_fopen ("/proc/meminfo", "r");
 
   if (fmem)
     {
-      unsigned long entry_value;
-      char entry_name[20];      /* the longest I saw is 13+1 */
+      uintmax_t entry_value;
+      bool done;
+
+      do
+        switch (fscanf (fmem, "MemTotal: %"SCNuMAX, &entry_value))
+          {
+          case 1:
+            retval = entry_value;
+            done = 1;
+            break;
+
+          case 0:
+            while ((c = getc (fmem)) != EOF && c != '\n')
+              continue;
+            done = c == EOF;
+            break;
+
+          default:
+            done = 1;
+            break;
+          }
+      while (!done);
 
-      while (!feof (fmem) && !ferror (fmem))
-        {
-          if (fscanf (fmem, "%s %lu kB\n", entry_name, &entry_value) >= 2
-              && strcmp (entry_name, "MemTotal:") == 0)
-            {
-              retval = entry_value;
-              break;
-            }
-        }
       fclose (fmem);
     }
   unblock_input ();
@@ -2906,7 +2887,7 @@ system_process_attributes (Lisp_Object pid)
   unsigned long long u_time, s_time, cutime, cstime, start;
   long priority, niceness, rss;
   unsigned long minflt, majflt, cminflt, cmajflt, vsize;
-  EMACS_TIME tnow, tstart, tboot, telapsed, us_time;
+  struct timespec tnow, tstart, tboot, telapsed, us_time;
   double pcpu, pmem;
   Lisp_Object attrs = Qnil;
   Lisp_Object cmd_str, decoded_cmd;
@@ -3027,20 +3008,19 @@ system_process_attributes (Lisp_Object pid)
           attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs);
           attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount)),
                          attrs);
-          tnow = current_emacs_time ();
+          tnow = current_timespec ();
           telapsed = get_up_time ();
-          tboot = sub_emacs_time (tnow, telapsed);
+          tboot = timespec_sub (tnow, telapsed);
           tstart = time_from_jiffies (start, clocks_per_sec);
-          tstart = add_emacs_time (tboot, tstart);
+          tstart = timespec_add (tboot, tstart);
           attrs = Fcons (Fcons (Qstart, make_lisp_time (tstart)), attrs);
           attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize / 1024)),
                          attrs);
           attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4 * rss)), attrs);
-          telapsed = sub_emacs_time (tnow, tstart);
+          telapsed = timespec_sub (tnow, tstart);
           attrs = Fcons (Fcons (Qetime, make_lisp_time (telapsed)), attrs);
           us_time = time_from_jiffies (u_time + s_time, clocks_per_sec);
-          pcpu = (EMACS_TIME_TO_DOUBLE (us_time)
-                  / EMACS_TIME_TO_DOUBLE (telapsed));
+          pcpu = timespectod (us_time) / timespectod (telapsed);
           if (pcpu > 1.0)
             pcpu = 1.0;
           attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs);
@@ -3243,13 +3223,11 @@ system_process_attributes (Lisp_Object pid)
                      attrs);
 
       decoded_cmd = (code_convert_string_norecord
-                     (make_unibyte_string (pinfo.pr_fname,
-                                           strlen (pinfo.pr_fname)),
+                     (build_unibyte_string (pinfo.pr_fname),
                       Vlocale_coding_system, 0));
       attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
       decoded_cmd = (code_convert_string_norecord
-                     (make_unibyte_string (pinfo.pr_psargs,
-                                           strlen (pinfo.pr_psargs)),
+                     (build_unibyte_string (pinfo.pr_psargs),
                       Vlocale_coding_system, 0));
       attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
     }
@@ -3260,16 +3238,16 @@ system_process_attributes (Lisp_Object pid)
 
 #elif defined __FreeBSD__
 
-static EMACS_TIME
-timeval_to_EMACS_TIME (struct timeval t)
+static struct timespec
+timeval_to_timespec (struct timeval t)
 {
-  return make_emacs_time (t.tv_sec, t.tv_usec * 1000);
+  return make_timespec (t.tv_sec, t.tv_usec * 1000);
 }
 
 static Lisp_Object
 make_lisp_timeval (struct timeval t)
 {
-  return make_lisp_time (timeval_to_EMACS_TIME (t));
+  return make_lisp_time (timeval_to_timespec (t));
 }
 
 Lisp_Object
@@ -3277,14 +3255,14 @@ system_process_attributes (Lisp_Object pid)
 {
   int proc_id;
   int pagesize = getpagesize ();
-  int npages;
+  unsigned long npages;
   int fscale;
   struct passwd *pw;
   struct group  *gr;
   char *ttyname;
   size_t len;
   char args[MAXPATHLEN];
-  EMACS_TIME t, now;
+  struct timespec t, now;
 
   int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID};
   struct kinfo_proc proc;
@@ -3319,9 +3297,9 @@ system_process_attributes (Lisp_Object pid)
   if (gr)
     attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
 
-  decoded_comm = code_convert_string_norecord
-    (make_unibyte_string (proc.ki_comm, strlen (proc.ki_comm)),
-     Vlocale_coding_system, 0);
+  decoded_comm = (code_convert_string_norecord
+                  (build_unibyte_string (proc.ki_comm),
+                   Vlocale_coding_system, 0));
 
   attrs = Fcons (Fcons (Qcomm, decoded_comm), attrs);
   {
@@ -3371,8 +3349,8 @@ system_process_attributes (Lisp_Object pid)
                  attrs);
   attrs = Fcons (Fcons (Qstime, make_lisp_timeval (proc.ki_rusage.ru_stime)),
                  attrs);
-  t = add_emacs_time (timeval_to_EMACS_TIME (proc.ki_rusage.ru_utime),
-                      timeval_to_EMACS_TIME (proc.ki_rusage.ru_stime));
+  t = timespec_add (timeval_to_timespec (proc.ki_rusage.ru_utime),
+                    timeval_to_timespec (proc.ki_rusage.ru_stime));
   attrs = Fcons (Fcons (Qtime, make_lisp_time (t)), attrs);
 
   attrs = Fcons (Fcons (Qcutime,
@@ -3381,8 +3359,8 @@ system_process_attributes (Lisp_Object pid)
   attrs = Fcons (Fcons (Qcstime,
                         make_lisp_timeval (proc.ki_rusage_ch.ru_utime)),
                  attrs);
-  t = add_emacs_time (timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_utime),
-                      timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_stime));
+  t = timespec_add (timeval_to_timespec (proc.ki_rusage_ch.ru_utime),
+                    timeval_to_timespec (proc.ki_rusage_ch.ru_stime));
   attrs = Fcons (Fcons (Qctime, make_lisp_time (t)), attrs);
 
   attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (proc.ki_numthreads)),
@@ -3394,8 +3372,8 @@ system_process_attributes (Lisp_Object pid)
   attrs = Fcons (Fcons (Qrss,   make_number (proc.ki_rssize * pagesize >> 10)),
                  attrs);
 
-  now = current_emacs_time ();
-  t = sub_emacs_time (now, timeval_to_EMACS_TIME (proc.ki_start));
+  now = current_timespec ();
+  t = timespec_sub (now, timeval_to_timespec (proc.ki_start));
   attrs = Fcons (Fcons (Qetime, make_lisp_time (t)), attrs);
 
   len = sizeof fscale;
diff --git a/src/sysselect.h b/src/sysselect.h
index 0a4f7e3ad96..5df0af9ed37 100644
--- a/src/sysselect.h
+++ b/src/sysselect.h
@@ -25,15 +25,12 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    definitions in w32.h are incompatible with the below.  */
 #ifndef WINDOWSNT
 #ifdef FD_SET
-#ifdef FD_SETSIZE
-#define MAXDESC FD_SETSIZE
-#else
-#define MAXDESC 64
+#ifndef FD_SETSIZE
+#define FD_SETSIZE 64
 #endif
-#define SELECT_TYPE fd_set
 #else /* no FD_SET */
-#define MAXDESC 32
-#define SELECT_TYPE int
+#define FD_SETSIZE 32
+typedef int fd_set;
 
 /* Define the macros to access a single-int bitmap of descriptors.  */
 #define FD_SET(n, p) (*(p) |= (1 << (n)))
diff --git a/src/systime.h b/src/systime.h
index df733b290c3..b1c3d940b0e 100644
--- a/src/systime.h
+++ b/src/systime.h
@@ -46,140 +46,56 @@ typedef unsigned long Time;
 
 #include <sys/time.h>   /* for 'struct timeval' */
 
-/* The type to use to represent non-negative temporal intervals.  Its
-   address can be passed as the timeout argument to the pselect system
-   call.  */
-typedef struct timespec EMACS_TIME;
-
-/* Resolution of EMACS_TIME time stamps (in units per second), and log
-   base 10 of the resolution.  The log must be a positive integer.  */
-enum { EMACS_TIME_RESOLUTION = 1000000000 };
-enum { LOG10_EMACS_TIME_RESOLUTION = 9 };
-
-/* EMACS_SECS (TIME) is the seconds component of TIME.
-   EMACS_NSECS (TIME) is the nanoseconds component of TIME.
-   emacs_secs_addr (PTIME) is the address of *PTIME's seconds component.  */
-SYSTIME_INLINE time_t EMACS_SECS (EMACS_TIME t) { return t.tv_sec; }
-SYSTIME_INLINE int EMACS_NSECS (EMACS_TIME t) { return t.tv_nsec; }
-SYSTIME_INLINE time_t *emacs_secs_addr (EMACS_TIME *t) { return &t->tv_sec; }
-
-/* Return an Emacs time with seconds S and nanoseconds NS.  */
-SYSTIME_INLINE EMACS_TIME
-make_emacs_time (time_t s, int ns)
-{
-  EMACS_TIME r;
-  r.tv_sec = s;
-  r.tv_nsec = ns;
-  return r;
-}
+/* Emacs uses struct timespec to represent nonnegative temporal intervals.
 
-/* Return an invalid Emacs time.  */
-SYSTIME_INLINE EMACS_TIME
-invalid_emacs_time (void)
-{
-  EMACS_TIME r;
-  r.tv_sec = 0;
-  r.tv_nsec = -1;
-  return r;
-}
-
-/* Return current system time.  */
-SYSTIME_INLINE EMACS_TIME
-current_emacs_time (void)
-{
-  EMACS_TIME r;
-  gettime (&r);
-  return r;
-}
-
-/* Return the result of adding A to B, or of subtracting B from A.
-   On overflow, store an extremal value: ergo, if time_t is unsigned,
-   return 0 if the true answer would be negative.
-
-   WARNING: These are NOT general-purpose macros for adding or
-   subtracting arbitrary time values!  They are generally intended to
-   be used with their first argument an absolute time since the epoch
-   and the second argument a non-negative offset.  Do NOT use them for
-   anything else.  */
-SYSTIME_INLINE EMACS_TIME
-add_emacs_time (EMACS_TIME a, EMACS_TIME b)
-{
-  return timespec_add (a, b);
-}
-SYSTIME_INLINE EMACS_TIME
-sub_emacs_time (EMACS_TIME a, EMACS_TIME b)
-{
-  return timespec_sub (a, b);
-}
+   WARNING: Since tv_sec might be an unsigned value, do not use struct
+   timespec as a general-purpose data type for adding or subtracting
+   arbitrary time values!  When computing A + B or A - B, typically A
+   should be an absolute time since the epoch and B a nonnegative offset.  */
 
-/* Return the sign of the valid time stamp TIME, either -1, 0, or 1.
-   Note: this can only return a negative value if time_t is a signed
-   data type.  */
-SYSTIME_INLINE int
-EMACS_TIME_SIGN (EMACS_TIME t)
+/* Return an invalid timespec.  */
+SYSTIME_INLINE struct timespec
+invalid_timespec (void)
 {
-  return timespec_sign (t);
+  return make_timespec (0, -1);
 }
 
-/* Return 1 if TIME is a valid time stamp.  */
+/* Return 1 if TIME is a valid timespec.  This currently doesn't worry
+   about whether tv_nsec is less than TIMESPEC_RESOLUTION; leap seconds
+   might cause a problem if it did.  */
 SYSTIME_INLINE int
-EMACS_TIME_VALID_P (EMACS_TIME t)
+timespec_valid_p (struct timespec t)
 {
   return t.tv_nsec >= 0;
 }
 
-/* Convert the double D to the greatest EMACS_TIME not greater than D.
-   On overflow, return an extremal value; in particular, if time_t is
-   an unsigned data type and D is negative, return zero.  Return the
-   minimum EMACS_TIME if D is not a number.  */
-SYSTIME_INLINE EMACS_TIME
-EMACS_TIME_FROM_DOUBLE (double d)
-{
-  return dtotimespec (d);
-}
-
-/* Convert the Emacs time T to an approximate double value D.  */
-SYSTIME_INLINE double
-EMACS_TIME_TO_DOUBLE (EMACS_TIME t)
+/* Return current system time.  */
+SYSTIME_INLINE struct timespec
+current_timespec (void)
 {
-  return timespectod (t);
+  struct timespec r;
+  gettime (&r);
+  return r;
 }
 
 /* defined in sysdep.c */
-extern int set_file_times (int, const char *, EMACS_TIME, EMACS_TIME);
-extern struct timeval make_timeval (EMACS_TIME) ATTRIBUTE_CONST;
+extern int set_file_times (int, const char *, struct timespec, struct timespec);
+extern struct timeval make_timeval (struct timespec) ATTRIBUTE_CONST;
 
 /* defined in keyboard.c */
-extern void set_waiting_for_input (EMACS_TIME *);
+extern void set_waiting_for_input (struct timespec *);
 
 /* When lisp.h is not included Lisp_Object is not defined (this can
    happen when this files is used outside the src directory).
    Use GCPRO1 to determine if lisp.h was included.  */
 #ifdef GCPRO1
 /* defined in editfns.c */
-extern Lisp_Object make_lisp_time (EMACS_TIME);
+extern Lisp_Object make_lisp_time (struct timespec);
 extern bool decode_time_components (Lisp_Object, Lisp_Object, Lisp_Object,
-                                    Lisp_Object, EMACS_TIME *, double *);
-extern EMACS_TIME lisp_time_argument (Lisp_Object);
+                                    Lisp_Object, struct timespec *, double *);
+extern struct timespec lisp_time_argument (Lisp_Object);
 #endif
 
-/* Compare times T1 and T2 for equality, inequality etc.  */
-SYSTIME_INLINE int
-EMACS_TIME_EQ (EMACS_TIME t1, EMACS_TIME t2)
-{
-  return timespec_cmp (t1, t2) == 0;
-}
-SYSTIME_INLINE int
-EMACS_TIME_LT (EMACS_TIME t1, EMACS_TIME t2)
-{
-  return timespec_cmp (t1, t2) < 0;
-}
-SYSTIME_INLINE int
-EMACS_TIME_LE (EMACS_TIME t1, EMACS_TIME t2)
-{
-  return timespec_cmp (t1, t2) <= 0;
-}
-
 INLINE_HEADER_END
 
 #endif /* EMACS_SYSTIME_H */
diff --git a/src/syswait.h b/src/syswait.h
index 03e5cb5fe2e..4ae9129d7ed 100644
--- a/src/syswait.h
+++ b/src/syswait.h
@@ -52,9 +52,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define WTERMSIG(status) ((status) & 0x7f)
 #endif
 
-/* Defined in process.c.  */
-extern void record_deleted_pid (pid_t);
-
 /* Defined in sysdep.c.  */
 extern void wait_for_termination (pid_t, int *, bool);
 extern pid_t child_status_changed (pid_t, int *, int);
diff --git a/src/term.c b/src/term.c
index fb69aefbe7a..aa61fde06ee 100644
--- a/src/term.c
+++ b/src/term.c
@@ -2233,8 +2233,7 @@ get_named_tty (const char *name)
 {
   struct terminal *t;
 
-  if (!name)
-    emacs_abort ();
+  eassert (name);
 
   for (t = terminal_list; t; t = t->next_terminal)
     {
@@ -2786,8 +2785,7 @@ create_tty_output (struct frame *f)
 {
   struct tty_output *t = xzalloc (sizeof *t);
 
-  if (! FRAME_TERMCAP_P (f))
-    emacs_abort ();
+  eassert (FRAME_TERMCAP_P (f));
 
   t->display_info = FRAME_TERMINAL (f)->display_info.tty;
 
@@ -2799,8 +2797,7 @@ create_tty_output (struct frame *f)
 static void
 tty_free_frame_resources (struct frame *f)
 {
-  if (! FRAME_TERMCAP_P (f))
-    emacs_abort ();
+  eassert (FRAME_TERMCAP_P (f));
 
   if (FRAME_FACE_CACHE (f))
     free_frame_faces (f);
@@ -2815,8 +2812,7 @@ tty_free_frame_resources (struct frame *f)
 static void
 tty_free_frame_resources (struct frame *f)
 {
-  if (! FRAME_TERMCAP_P (f) && ! FRAME_MSDOS_P (f))
-    emacs_abort ();
+  eassert (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f));
 
   if (FRAME_FACE_CACHE (f))
     free_frame_faces (f);
@@ -2938,9 +2934,12 @@ dissociate_if_controlling_tty (int fd)
 struct terminal *
 init_tty (const char *name, const char *terminal_type, bool must_succeed)
 {
-  char *area = NULL;
+#ifdef TERMINFO
+  char **address = 0;
+#else
+  char *area;
   char **address = &area;
-  int buffer_size = 4096;
+#endif
   int status;
   struct tty_display_info *tty = NULL;
   struct terminal *terminal = NULL;
@@ -3028,12 +3027,16 @@ init_tty (const char *name, const char *terminal_type, bool must_succeed)
 
   Wcm_clear (tty);
 
-  tty->termcap_term_buffer = xmalloc (buffer_size);
-
   /* On some systems, tgetent tries to access the controlling
      terminal.  */
   block_tty_out_signal ();
+#ifdef TERMINFO
+  status = tgetent (0, terminal_type);
+#else
   status = tgetent (tty->termcap_term_buffer, terminal_type);
+  if (tty->termcap_term_buffer[TERMCAP_BUFFER_SIZE - 1])
+    emacs_abort ();
+#endif
   unblock_tty_out_signal ();
 
   if (status < 0)
@@ -3065,11 +3068,8 @@ use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
     }
 
 #ifndef TERMINFO
-  if (strlen (tty->termcap_term_buffer) >= buffer_size)
-    emacs_abort ();
-  buffer_size = strlen (tty->termcap_term_buffer);
+  area = tty->termcap_strings_buffer;
 #endif
-  tty->termcap_strings_buffer = area = xmalloc (buffer_size);
   tty->TS_ins_line = tgetstr ("al", address);
   tty->TS_ins_multi_lines = tgetstr ("AL", address);
   tty->TS_bell = tgetstr ("bl", address);
@@ -3443,8 +3443,7 @@ delete_tty (struct terminal *terminal)
   if (!terminal->name)
     return;
 
-  if (terminal->type != output_termcap)
-    emacs_abort ();
+  eassert (terminal->type == output_termcap);
 
   tty = terminal->display_info.tty;
 
@@ -3486,9 +3485,6 @@ delete_tty (struct terminal *terminal)
 
   xfree (tty->old_tty);
   xfree (tty->Wcm);
-  xfree (tty->termcap_strings_buffer);
-  xfree (tty->termcap_term_buffer);
-
   xfree (tty);
 }
 
diff --git a/src/termcap.c b/src/termcap.c
index be05828eea6..aa225d9b3b1 100644
--- a/src/termcap.c
+++ b/src/termcap.c
@@ -406,7 +406,7 @@ tgetent (char *bp, const char *name)
 
   if (termcap_name && !filep && !strcmp (name, getenv ("TERM")))
     {
-      indirect = tgetst1 (find_capability (termcap_name, "tc"), (char **) 0);
+      indirect = tgetst1 (find_capability (termcap_name, "tc"), 0);
       if (!indirect)
         {
           if (!bp)
@@ -490,7 +490,7 @@ tgetent (char *bp, const char *name)
       /* Does this entry refer to another terminal type's entry?
          If something is found, copy it into heap and null-terminate it.  */
       tc_search_point = find_capability (tc_search_point, "tc");
-      term = tgetst1 (tc_search_point, (char **) 0);
+      term = tgetst1 (tc_search_point, 0);
     }
 
   emacs_close (fd);
diff --git a/src/termchar.h b/src/termchar.h
index 1c8e8646d4e..687f7fbd119 100644
--- a/src/termchar.h
+++ b/src/termchar.h
@@ -16,6 +16,8 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
+#include "dispextern.h"
+
 /* Each termcap frame points to its own struct tty_output object in
    the output_data.tty field.  The tty_output structure contains the
    information that is specific to termcap frames. */
@@ -28,6 +30,10 @@ struct tty_output
   /* There is nothing else here at the moment... */
 };
 
+#ifndef TERMINFO
+enum { TERMCAP_BUFFER_SIZE = 4096 };
+#endif
+
 /* Parameters that are shared between frames on the same tty device. */
 
 struct tty_display_info
@@ -72,14 +78,15 @@ struct tty_display_info
      mouse-face.  */
   Mouse_HLInfo mouse_highlight;
 
+#ifndef TERMINFO
   /* Buffer used internally by termcap (see tgetent in the Termcap
-     manual).  Only init_tty and delete_tty should change this.  */
-  char *termcap_term_buffer;
+     manual).  Only init_tty should use this.  */
+  char termcap_term_buffer[TERMCAP_BUFFER_SIZE];
 
   /* Buffer storing terminal description strings (see tgetstr in the
-     Termcap manual).  Only init_tty and delete_tty should change
-     this.  */
-  char *termcap_strings_buffer;
+     Termcap manual).  Only init_tty should use this.  */
+  char termcap_strings_buffer[TERMCAP_BUFFER_SIZE];
+#endif
 
   /* Strings, numbers and flags taken from the termcap entry.  */
 
diff --git a/src/termhooks.h b/src/termhooks.h
index b49a7bc706b..77f98938edb 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -18,7 +18,9 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
-
+#ifndef EMACS_TERMHOOKS_H
+#define EMACS_TERMHOOKS_H
+
 /* Miscellanea.   */
 
 #include "systime.h" /* for Time */
@@ -28,10 +30,6 @@ INLINE_HEADER_BEGIN
 # define TERMHOOKS_INLINE INLINE
 #endif
 
-struct glyph;
-struct frame;
-
-
 enum scroll_bar_part {
   scroll_bar_above_handle,
   scroll_bar_handle,
@@ -49,7 +47,18 @@ enum scroll_bar_part {
    may do something OS dependent, like extended window manager hints on X11.  */
 extern void (*fullscreen_hook) (struct frame *f);
 
-
+/* Output method of a terminal (and frames on this terminal, respectively).  */
+
+enum output_method
+{
+  output_initial,
+  output_termcap,
+  output_x_window,
+  output_msdos_raw,
+  output_w32,
+  output_ns
+};
+
 /* Input queue declarations and hooks.  */
 
 enum event_kind
@@ -321,11 +330,6 @@ extern void term_mouse_moveto (int, int);
 extern struct tty_display_info *gpm_tty;
 #endif
 
-
-struct ns_display_info;
-struct x_display_info;
-struct w32_display_info;
-
 /* Terminal-local parameters. */
 struct terminal
 {
@@ -660,3 +664,5 @@ extern void close_gpm (int gpm_fd);
 #endif
 
 INLINE_HEADER_END
+
+#endif /* EMACS_TERMHOOKS_H */
diff --git a/src/textprop.c b/src/textprop.c
index 282ae11d4ac..b804f345047 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -93,15 +93,25 @@ text_read_only (Lisp_Object propval)
   xsignal0 (Qtext_read_only);
 }
 
-/* Prepare to modify the region of BUFFER from START to END.  */
+/* Prepare to modify the text properties of BUFFER from START to END.  */
 
 static void
-modify_region (Lisp_Object buffer, Lisp_Object start, Lisp_Object end)
+modify_text_properties (Lisp_Object buffer, Lisp_Object start, Lisp_Object end)
 {
+  ptrdiff_t b = XINT (start), e = XINT (end);
   struct buffer *buf = XBUFFER (buffer), *old = current_buffer;
 
   set_buffer_internal (buf);
-  modify_region_1 (XINT (start), XINT (end), true);
+
+  prepare_to_modify_buffer_1 (b, e, NULL);
+
+  BUF_COMPUTE_UNCHANGED (buf, b - 1, e);
+  if (MODIFF <= SAVE_MODIFF)
+    record_first_change ();
+  MODIFF++;
+
+  bset_point_before_scroll (current_buffer, Qnil);
+
   set_buffer_internal (old);
 }
 
@@ -1213,9 +1223,9 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
       ptrdiff_t prev_total_length = TOTAL_LENGTH (i);
       ptrdiff_t prev_pos = i->position;
 
-      modify_region (object, start, end);
+      modify_text_properties (object, start, end);
       /* If someone called us recursively as a side effect of
-         modify_region, and changed the intervals behind our back
+         modify_text_properties, and changed the intervals behind our back
          (could happen if lock_file, called by prepare_to_modify_buffer,
          triggers redisplay, and that calls add-text-properties again
          in the same buffer), we cannot continue with I, because its
@@ -1357,7 +1367,8 @@ into it.  */)
    otherwise.  */
 
 Lisp_Object
-set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object, Lisp_Object coherent_change_p)
+set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties,
+                     Lisp_Object object, Lisp_Object coherent_change_p)
 {
   register INTERVAL i;
   Lisp_Object ostart, oend;
@@ -1403,7 +1414,7 @@ set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties,
     }
 
   if (BUFFERP (object) && !NILP (coherent_change_p))
-    modify_region (object, start, end);
+    modify_text_properties (object, start, end);
 
   set_text_properties_1 (start, end, properties, object, i);
 
@@ -1558,9 +1569,9 @@ Use `set-text-properties' if you want to remove all text properties.  */)
       ptrdiff_t prev_total_length = TOTAL_LENGTH (i);
       ptrdiff_t prev_pos = i->position;
 
-      modify_region (object, start, end);
+      modify_text_properties (object, start, end);
       /* If someone called us recursively as a side effect of
-         modify_region, and changed the intervals behind our back
+         modify_text_properties, and changed the intervals behind our back
          (could happen if lock_file, called by prepare_to_modify_buffer,
          triggers redisplay, and that calls add-text-properties again
          in the same buffer), we cannot continue with I, because its
@@ -1667,9 +1678,9 @@ Return t if any property was actually removed, nil otherwise.  */)
 
   /* We are at the beginning of an interval, with len to scan.
      The flag `modified' records if changes have been made.
-     When object is a buffer, we must call modify_region before changes are
-     made and signal_after_change when we are done.
-     We call modify_region before calling remove_properties if modified == 0,
+     When object is a buffer, we must call modify_text_properties
+     before changes are made and signal_after_change when we are done.
+     We call modify_text_properties before calling remove_properties if modified == 0,
      and we call signal_after_change before returning if modified != 0. */
   for (;;)
     {
@@ -1693,7 +1704,7 @@ Return t if any property was actually removed, nil otherwise.  */)
           else if (LENGTH (i) == len)
             {
               if (!modified && BUFFERP (object))
-                modify_region (object, start, end);
+                modify_text_properties (object, start, end);
               remove_properties (Qnil, properties, i, object);
               if (BUFFERP (object))
                 signal_after_change (XINT (start), XINT (end) - XINT (start),
@@ -1706,7 +1717,7 @@ Return t if any property was actually removed, nil otherwise.  */)
               i = split_interval_left (i, len);
               copy_properties (unchanged, i);
               if (!modified && BUFFERP (object))
-                modify_region (object, start, end);
+                modify_text_properties (object, start, end);
               remove_properties (Qnil, properties, i, object);
               if (BUFFERP (object))
                 signal_after_change (XINT (start), XINT (end) - XINT (start),
@@ -1717,7 +1728,7 @@ Return t if any property was actually removed, nil otherwise.  */)
       if (interval_has_some_properties_list (properties, i))
         {
           if (!modified && BUFFERP (object))
-            modify_region (object, start, end);
+            modify_text_properties (object, start, end);
           remove_properties (Qnil, properties, i, object);
           modified = 1;
         }
diff --git a/src/w16select.c b/src/w16select.c
index 3bcc663e565..864757b3e61 100644
--- a/src/w16select.c
+++ b/src/w16select.c
@@ -452,11 +452,7 @@ DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_dat
 
   CHECK_STRING (string);
 
-  if (NILP (frame))
-    frame = Fselected_frame ();
-
-  CHECK_LIVE_FRAME (frame);
-  if ( !FRAME_MSDOS_P (XFRAME (frame)))
+  if (!FRAME_MSDOS_P (decode_live_frame (frame)))
     goto done;
 
   block_input ();
@@ -558,11 +554,7 @@ DEFUN ("w16-get-clipboard-data", Fw16_get_clipboard_data, Sw16_get_clipboard_dat
   Lisp_Object ret = Qnil;
   int require_decoding = 0;
 
-  if (NILP (frame))
-    frame = Fselected_frame ();
-
-  CHECK_LIVE_FRAME (frame);
-  if ( !FRAME_MSDOS_P (XFRAME (frame)))
+  if (!FRAME_MSDOS_P (decode_live_frame (frame)))
     goto done;
 
   block_input ();
diff --git a/src/w32.c b/src/w32.c
index fb2d7c75972..1dcf46b5f4b 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -47,7 +47,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #undef fopen
 #undef link
 #undef mkdir
-#undef mktemp
 #undef open
 #undef rename
 #undef rmdir
@@ -90,6 +89,21 @@ typedef struct _MEMORY_STATUS_EX {
   DWORDLONG ullAvailExtendedVirtual;
 } MEMORY_STATUS_EX,*LPMEMORY_STATUS_EX;
 
+/* These are here so that GDB would know about these data types.  This
+   allows to attach GDB to Emacs when a fatal exception is triggered
+   and Windows pops up the "application needs to be closed" dialog.
+   At that point, _gnu_exception_handler, the top-level exception
+   handler installed by the MinGW startup code, is somewhere on the
+   call-stack of the main thread, so going to that call frame and
+   looking at the argument to _gnu_exception_handler, which is a
+   PEXCEPTION_POINTERS pointer, can reveal the exception code
+   (excptr->ExceptionRecord->ExceptionCode) and the address where the
+   exception happened (excptr->ExceptionRecord->ExceptionAddress), as
+   well as some additional information specific to the exception.  */
+PEXCEPTION_POINTERS excptr;
+PEXCEPTION_RECORD excprec;
+PCONTEXT ctxrec;
+
 #include <lmcons.h>
 #include <shlobj.h>
 
@@ -233,7 +247,7 @@ static BOOL WINAPI revert_to_self (void);
 extern int sys_access (const char *, int);
 extern void *e_malloc (size_t);
 extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
-                       EMACS_TIME *, void *);
+                       struct timespec *, void *);
 extern int sys_dup (int);
 
 
@@ -2489,8 +2503,6 @@ gettimeofday (struct timeval *__restrict tv, struct timezone *__restrict tz)
 int
 fdutimens (int fd, char const *file, struct timespec const timespec[2])
 {
-  struct _utimbuf ut;
-
   if (!timespec)
     {
       errno = ENOSYS;
@@ -2501,12 +2513,28 @@ fdutimens (int fd, char const *file, struct timespec const timespec[2])
       errno = EBADF;
       return -1;
     }
-  ut.actime = timespec[0].tv_sec;
-  ut.modtime = timespec[1].tv_sec;
+  /* _futime's prototype defines 2nd arg as having the type 'struct
+     _utimbuf', while utime needs to accept 'struct utimbuf' for
+     compatibility with Posix.  So we need to use 2 different (but
+     equivalent) types to avoid compiler warnings, sigh.  */
   if (fd >= 0)
-    return _futime (fd, &ut);
+    {
+      struct _utimbuf _ut;
+
+      _ut.actime = timespec[0].tv_sec;
+      _ut.modtime = timespec[1].tv_sec;
+      return _futime (fd, &_ut);
+    }
   else
-    return _utime (file, &ut);
+    {
+      struct utimbuf ut;
+
+      ut.actime = timespec[0].tv_sec;
+      ut.modtime = timespec[1].tv_sec;
+      /* Call 'utime', which is implemented below, not the MS library
+         function, which fails on directories.  */
+      return utime (file, &ut);
+    }
 }
 
 
@@ -3414,25 +3442,46 @@ sys_mkdir (const char * path)
   return _mkdir (map_w32_filename (path, NULL));
 }
 
-/* Because of long name mapping issues, we need to implement this
-   ourselves.  Also, MSVC's _mktemp returns NULL when it can't generate
-   a unique name, instead of setting the input template to an empty
-   string.
+int
+sys_open (const char * path, int oflag, int mode)
+{
+  const char* mpath = map_w32_filename (path, NULL);
+  int res = -1;
+
+  /* If possible, try to open file without _O_CREAT, to be able to
+     write to existing hidden and system files.  Force all file
+     handles to be non-inheritable. */
+  if ((oflag & (_O_CREAT | _O_EXCL)) != (_O_CREAT | _O_EXCL))
+    res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
+  if (res < 0)
+    res = _open (mpath, oflag | _O_NOINHERIT, mode);
+
+  return res;
+}
+
+/* Implementation of mkostemp for MS-Windows, to avoid race conditions
+   when using mktemp.
 
-   Standard algorithm seems to be use pid or tid with a letter on the
-   front (in place of the 6 X's) and cycle through the letters to find a
-   unique name.  We extend that to allow any reasonable character as the
-   first of the 6 X's.  */
-char *
-sys_mktemp (char * template)
+   Standard algorithm for generating a temporary file name seems to be
+   use pid or tid with a letter on the front (in place of the 6 X's)
+   and cycle through the letters to find a unique name.  We extend
+   that to allow any reasonable character as the first of the 6 X's,
+   so that the number of simultaneously used temporary files will be
+   greater.  */
+
+int
+mkostemp (char * template, int flags)
 {
   char * p;
-  int i;
+  int i, fd = -1;
   unsigned uid = GetCurrentThreadId ();
+  int save_errno = errno;
   static char first_char[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
 
+  errno = EINVAL;
   if (template == NULL)
-    return NULL;
+    return -1;
+
   p = template + strlen (template);
   i = 5;
   /* replace up to the last 5 X's with uid in decimal */
@@ -3447,38 +3496,22 @@ sys_mktemp (char * template)
       i = 0;
       do
         {
-          int save_errno = errno;
           p[0] = first_char[i];
-          if (faccessat (AT_FDCWD, template, F_OK, AT_EACCESS) < 0)
+          if ((fd = sys_open (template,
+                              flags | _O_CREAT | _O_EXCL | _O_RDWR,
+                              S_IRUSR | S_IWUSR)) >= 0
+              || errno != EEXIST)
             {
-              errno = save_errno;
-              return template;
+              if (fd >= 0)
+                errno = save_errno;
+              return fd;
             }
         }
       while (++i < sizeof (first_char));
     }
 
-  /* Template is badly formed or else we can't generate a unique name,
-     so return empty string */
-  template[0] = 0;
-  return template;
-}
-
-int
-sys_open (const char * path, int oflag, int mode)
-{
-  const char* mpath = map_w32_filename (path, NULL);
-  int res = -1;
-
-  /* If possible, try to open file without _O_CREAT, to be able to
-     write to existing hidden and system files.  Force all file
-     handles to be non-inheritable. */
-  if ((oflag & (_O_CREAT | _O_EXCL)) != (_O_CREAT | _O_EXCL))
-    res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
-  if (res < 0)
-    res = _open (mpath, oflag | _O_NOINHERIT, mode);
-
-  return res;
+  /* Template is badly formed or else we can't generate a unique name.  */
+  return -1;
 }
 
 int
@@ -4482,6 +4515,9 @@ fstat (int desc, struct stat * buf)
   return 0;
 }
 
+/* A version of 'utime' which handles directories as well as
+   files.  */
+
 int
 utime (const char *name, struct utimbuf *times)
 {
@@ -5750,8 +5786,8 @@ system_process_attributes (Lisp_Object pid)
                 {
                   /* Decode the command name from locale-specific
                      encoding.  */
-                  cmd_str = make_unibyte_string (pe.szExeFile,
-                                                 strlen (pe.szExeFile));
+                  cmd_str = build_unibyte_string (pe.szExeFile);
+
                   decoded_cmd =
                     code_convert_string_norecord (cmd_str,
                                                   Vlocale_coding_system, 0);
@@ -6056,6 +6092,7 @@ term_winsock (void)
 {
   if (winsock_lib != NULL && winsock_inuse == 0)
     {
+      release_listen_threads ();
       /* Not sure what would cause WSAENETDOWN, or even if it can happen
          after WSAStartup returns successfully, but it seems reasonable
          to allow unloading winsock anyway in that case. */
@@ -7040,7 +7077,12 @@ _sys_wait_accept (int fd)
   rc = pfn_WSAEventSelect (SOCK_HANDLE (fd), hEv, FD_ACCEPT);
   if (rc != SOCKET_ERROR)
     {
-      rc = WaitForSingleObject (hEv, INFINITE);
+      do {
+        rc = WaitForSingleObject (hEv, 500);
+        Sleep (5);
+      } while (rc == WAIT_TIMEOUT
+               && cp->status != STATUS_READ_ERROR
+               && cp->char_avail);
       pfn_WSAEventSelect (SOCK_HANDLE (fd), NULL, 0);
       if (rc == WAIT_OBJECT_0)
         cp->status = STATUS_READ_SUCCEEDED;
@@ -7903,7 +7945,7 @@ emacs_gnutls_pull (gnutls_transport_ptr_t p, void* buf, size_t sz)
 {
   int n, err;
   SELECT_TYPE fdset;
-  EMACS_TIME timeout;
+  struct timespec timeout;
   struct Lisp_Process *process = (struct Lisp_Process *)p;
   int fd = process->infd;
 
diff --git a/src/w32.h b/src/w32.h
index 9c1f1efa699..32d0fdbe3cf 100644
--- a/src/w32.h
+++ b/src/w32.h
@@ -163,6 +163,7 @@ extern void reset_standard_handles (int in, int out,
 /* Return the string resource associated with KEY of type TYPE.  */
 extern LPBYTE w32_get_resource (char * key, LPDWORD type);
 
+extern void release_listen_threads (void);
 extern void init_ntproc (int);
 extern void term_ntproc (int);
 extern void globals_of_w32 (void);
diff --git a/src/w32console.c b/src/w32console.c
index ee92a593301..8da1ccf1892 100644
--- a/src/w32console.c
+++ b/src/w32console.c
@@ -53,7 +53,6 @@ static void w32con_write_glyphs (struct frame *f, struct glyph *string, int len)
 static void w32con_delete_glyphs (struct frame *f, int n);
 static void w32con_reset_terminal_modes (struct terminal *t);
 static void w32con_set_terminal_modes (struct terminal *t);
-static void w32con_set_terminal_window (struct frame *f, int size);
 static void w32con_update_begin (struct frame * f);
 static void w32con_update_end (struct frame * f);
 static WORD w32_face_attributes (struct frame *f, int face_id);
@@ -497,11 +496,6 @@ w32con_update_end (struct frame * f)
   SetConsoleCursorPosition (cur_screen, cursor_coords);
 }
 
-static void
-w32con_set_terminal_window (struct frame *f, int size)
-{
-}
-
 /***********************************************************************
                         stubs from termcap.c
  ***********************************************************************/
@@ -619,7 +613,7 @@ initialize_w32_display (struct terminal *term, int *width, int *height)
   term->ring_bell_hook          = w32_sys_ring_bell;
   term->reset_terminal_modes_hook = w32con_reset_terminal_modes;
   term->set_terminal_modes_hook = w32con_set_terminal_modes;
-  term->set_terminal_window_hook = w32con_set_terminal_window;
+  term->set_terminal_window_hook = NULL;
   term->update_begin_hook       = w32con_update_begin;
   term->update_end_hook         = w32con_update_end;
 
@@ -636,13 +630,7 @@ initialize_w32_display (struct terminal *term, int *width, int *height)
   term->frame_up_to_date_hook = 0;
 
   /* Initialize the mouse-highlight data.  */
-  hlinfo = &term->display_info.tty->mouse_highlight;
-  hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-  hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-  hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
-  hlinfo->mouse_face_mouse_frame = NULL;
-  hlinfo->mouse_face_window = Qnil;
-  hlinfo->mouse_face_hidden = 0;
+  reset_mouse_highlight (&term->display_info.tty->mouse_highlight);
 
   /* Initialize interrupt_handle.  */
   init_crit ();
diff --git a/src/w32fns.c b/src/w32fns.c
index dff35de0973..b8c445a3a36 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -1528,11 +1528,8 @@ void
 x_set_cursor_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
   set_frame_cursor_types (f, arg);
-
-  /* Make sure the cursor gets redrawn.  */
-  cursor_type_changed = 1;
 }
-
+
 void
 x_set_icon_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
@@ -4124,12 +4121,7 @@ w32_window (struct frame *f, long window_prompting, int minibuffer_only)
      for the window manager, so GC relocation won't bother it.
 
      Elsewhere we specify the window name for the window manager.  */
-
-  {
-    char *str = SSDATA (Vx_resource_name);
-    f->namebuf = xmalloc (strlen (str) + 1);
-    strcpy (f->namebuf, str);
-  }
+  f->namebuf = xstrdup (SSDATA (Vx_resource_name));
 
   my_create_window (f);
 
@@ -4992,8 +4984,8 @@ w32_display_monitor_attributes_list (void)
       attributes = Fcons (Fcons (Qframes, AREF (monitor_frames, i)),
                           attributes);
 
-      name = DECODE_SYSTEM (make_unibyte_string (mi.szDevice,
-                                                 strlen (mi.szDevice)));
+      name = DECODE_SYSTEM (build_unibyte_string (mi.szDevice));
+
       attributes = Fcons (Fcons (Qname, name), attributes);
 
       attributes = Fcons (Fcons (Qmm_size, list2i (width_mm, height_mm)),
diff --git a/src/w32proc.c b/src/w32proc.c
index 84589388cd7..dabaa62f71c 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -990,6 +990,18 @@ find_child_pid (DWORD pid)
   return NULL;
 }
 
+void
+release_listen_threads (void)
+{
+  int i;
+
+  for (i = child_proc_count - 1; i >= 0; i--)
+    {
+      if (CHILD_ACTIVE (&child_procs[i])
+          && (fd_info[child_procs[i].fd].flags & FILE_LISTEN))
+        child_procs[i].status = STATUS_READ_ERROR;
+    }
+}
 
 /* Thread proc for child process and socket reader threads. Each thread
    is normally blocked until woken by select() to check for input by
@@ -1916,7 +1928,7 @@ extern int proc_buffered_char[];
 
 int
 sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
-            EMACS_TIME *timeout, void *ignored)
+            struct timespec *timeout, void *ignored)
 {
   SELECT_TYPE orfds;
   DWORD timeout_ms, start_time;
diff --git a/src/w32term.c b/src/w32term.c
index 59cfdee86b0..532ded7cdad 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -84,9 +84,6 @@ static int last_mousemove_y = 0;
 
 static int any_help_event_p;
 
-/* Last window where we saw the mouse.  Used by mouse-autoselect-window.  */
-static Lisp_Object last_window;
-
 extern unsigned int msh_mousewheel;
 
 extern void free_frame_menubar (struct frame *);
@@ -210,7 +207,6 @@ static int volatile input_signal_count;
 int w32_message_fd = -1;
 #endif /* CYGWIN */
 
-static void x_update_window_end (struct window *, int, int);
 static void w32_handle_tool_bar_click (struct frame *,
                                        struct input_event *);
 static void w32_define_cursor (Window, Cursor);
@@ -225,8 +221,6 @@ void x_wm_set_icon_pixmap (struct frame *, int);
 static void w32_initialize (void);
 static void x_update_end (struct frame *);
 static void w32_frame_up_to_date (struct frame *);
-static void w32_set_terminal_modes (struct terminal *);
-static void w32_reset_terminal_modes (struct terminal *);
 static void x_clear_frame (struct frame *);
 static void frame_highlight (struct frame *);
 static void frame_unhighlight (struct frame *);
@@ -241,7 +235,8 @@ static void x_frame_rehighlight (struct w32_display_info *);
 static void x_draw_hollow_cursor (struct window *, struct glyph_row *);
 static void x_draw_bar_cursor (struct window *, struct glyph_row *, int,
                                enum text_cursor_kinds);
-static void w32_clip_to_row (struct window *, struct glyph_row *, int, HDC);
+static void w32_clip_to_row (struct window *, struct glyph_row *,
+                             enum glyph_row_area, HDC);
 static BOOL my_show_window (struct frame *, HWND, int);
 static void my_set_window_pos (HWND, HWND, int, int, int, int, UINT);
 #if 0
@@ -577,9 +572,7 @@ x_update_begin (struct frame *f)
 }
 
 
-/* Start update of window W.  Set the global variable updated_window
-   to the window being updated and set output_cursor to the cursor
-   position of W.  */
+/* Start update of window W.  */
 
 static void
 x_update_window_begin (struct window *w)
@@ -593,8 +586,7 @@ x_update_window_begin (struct window *w)
       SendMessage (w32_system_caret_hwnd, WM_EMACS_HIDE_CARET, 0, 0);
     }
 
-  updated_window = w;
-  set_output_cursor (&w->cursor);
+  w->output_cursor = w->cursor;
 
   block_input ();
 
@@ -664,7 +656,7 @@ w32_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
 }
 
 
-/* End update of window W (which is equal to updated_window).
+/* End update of window W.
 
    Draw vertical borders between horizontally adjacent windows, and
    display W's cursor if CURSOR_ON_P is non-zero.
@@ -678,19 +670,17 @@ w32_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
    here. */
 
 static void
-x_update_window_end (struct window *w, int cursor_on_p,
-                     int mouse_face_overwritten_p)
+x_update_window_end (struct window *w, bool cursor_on_p,
+                     bool mouse_face_overwritten_p)
 {
-  Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
-
   if (!w->pseudo_window_p)
     {
       block_input ();
 
       if (cursor_on_p)
-        display_and_set_cursor (w, 1, output_cursor.hpos,
-                                output_cursor.vpos,
-                                output_cursor.x, output_cursor.y);
+        display_and_set_cursor (w, 1,
+                                w->output_cursor.hpos, w->output_cursor.vpos,
+                                w->output_cursor.x, w->output_cursor.y);
 
       if (draw_window_fringes (w, 1))
         x_draw_vertical_border (w);
@@ -701,11 +691,7 @@ x_update_window_end (struct window *w, int cursor_on_p,
   /* If a row with mouse-face was overwritten, arrange for
      XTframe_up_to_date to redisplay the mouse highlight.  */
   if (mouse_face_overwritten_p)
-    {
-      hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-      hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-      hlinfo->mouse_face_window = Qnil;
-    }
+    reset_mouse_highlight (MOUSE_HL_INFO (XFRAME (w->frame)));
 
   /* Unhide the caret.  This won't actually show the cursor, unless it
      was visible before the corresponding call to HideCaret in
@@ -714,8 +700,6 @@ x_update_window_end (struct window *w, int cursor_on_p,
     {
       SendMessage (w32_system_caret_hwnd, WM_EMACS_SHOW_CARET, 0, 0);
     }
-
-  updated_window = NULL;
 }
 
 
@@ -733,9 +717,8 @@ x_update_end (struct frame *f)
 }
 
 
-/* This function is called from various places in xdisp.c whenever a
-   complete update has been performed.  The global variable
-   updated_window is not available here.  */
+/* This function is called from various places in xdisp.c
+   whenever a complete update has been performed.  */
 
 static void
 w32_frame_up_to_date (struct frame *f)
@@ -747,15 +730,13 @@ w32_frame_up_to_date (struct frame *f)
 
 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
    arrow bitmaps, or clear the fringes if no bitmaps are required
-   before DESIRED_ROW is made current.  The window being updated is
-   found in updated_window.  This function is called from
+   before DESIRED_ROW is made current.  This function is called from
    update_window_line only if it is known that there are differences
    between bitmaps to be drawn between current row and DESIRED_ROW.  */
 
 static void
-x_after_update_window_line (struct glyph_row *desired_row)
+x_after_update_window_line (struct window *w, struct glyph_row *desired_row)
 {
-  struct window *w = updated_window;
   struct frame *f;
   int width, height;
 
@@ -766,7 +747,7 @@ x_after_update_window_line (struct glyph_row *desired_row)
 
   /* When a window has disappeared, make sure that no rest of
      full-width rows stays visible in the internal border.  Could
-     check here if updated_window is the leftmost/rightmost window,
+     check here if updated window is the leftmost/rightmost window,
      but I guess it's not worth doing since vertically split windows
      are almost never used, internal border is rarely set, and the
      overhead is very small.  */
@@ -863,7 +844,7 @@ w32_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
     }
 
   /* Must clip because of partially visible lines.  */
-  w32_clip_to_row (w, row, -1, hdc);
+  w32_clip_to_row (w, row, ANY_AREA, hdc);
 
   if (p->which && p->which < max_fringe_bmp)
     {
@@ -948,28 +929,6 @@ w32_destroy_fringe_bitmap (int which)
   fringe_bmp[which] = 0;
 }
 
-
-
-/* This is called when starting Emacs and when restarting after
-   suspend.  When starting Emacs, no window is mapped.  And nothing
-   must be done to Emacs's own window if it is suspended (though that
-   rarely happens).  */
-
-static void
-w32_set_terminal_modes (struct terminal *term)
-{
-}
-
-/* This is called when exiting or suspending Emacs.  Exiting will make
-   the W32 windows go away, and suspending requires no action. */
-
-static void
-w32_reset_terminal_modes (struct terminal *term)
-{
-}
-
-
-
 /***********************************************************************
                            Display Iterator
  ***********************************************************************/
@@ -2665,11 +2624,7 @@ x_clear_frame (struct frame *f)
   /* Clearing the frame will erase any cursor, so mark them all as no
      longer visible.  */
   mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
-  output_cursor.hpos = output_cursor.vpos = 0;
-  output_cursor.x = -1;
 
-  /* We don't set the output cursor here because there will always
-     follow an explicit cursor_to.  */
   block_input ();
 
   w32_clear_window (f);
@@ -2707,19 +2662,6 @@ w32_ring_bell (struct frame *f)
   unblock_input ();
 }
 
-
-/* Specify how many text lines, from the top of the window,
-   should be affected by insert-lines and delete-lines operations.
-   This, and those operations, are used only within an update
-   that is bounded by calls to x_update_begin and x_update_end.  */
-
-static void
-w32_set_terminal_window (struct frame *f, int n)
-{
-  /* This function intentionally left blank.  */
-}
-
-
 /***********************************************************************
                               Line Dance
  ***********************************************************************/
@@ -2750,7 +2692,7 @@ x_scroll_run (struct window *w, struct run *run)
   /* Get frame-relative bounding box of the text display area of W,
      without mode lines.  Include in this box the left and right
      fringes of W.  */
-  window_box (w, -1, &x, &y, &width, &height);
+  window_box (w, ANY_AREA, &x, &y, &width, &height);
 
   /* If the fringe is adjacent to the left (right) scroll bar of a
      leftmost (rightmost, respectively) window, then extend its
@@ -2806,7 +2748,6 @@ x_scroll_run (struct window *w, struct run *run)
   block_input ();
 
   /* Cursor off.  Will be switched on again in x_update_window_end.  */
-  updated_window = w;
   x_clear_cursor (w);
 
   {
@@ -3765,7 +3706,7 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
   HWND hwnd;
   SCROLLINFO si;
   struct scroll_bar *bar
-    = XSCROLL_BAR (Fmake_vector (make_number (VECSIZE (struct scroll_bar)), Qnil));
+    = ALLOCATE_PSEUDOVECTOR (struct scroll_bar, fringe_extended_p, PVEC_OTHER);
   Lisp_Object barobj;
 
   block_input ();
@@ -3778,7 +3719,7 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
   XSETINT (bar->start, 0);
   XSETINT (bar->end, 0);
   bar->dragging = Qnil;
-  bar->fringe_extended_p = Qnil;
+  bar->fringe_extended_p = 0;
 
   /* Requires geometry to be set before call to create the real window */
 
@@ -3842,10 +3783,10 @@ w32_set_vertical_scroll_bar (struct window *w,
   struct scroll_bar *bar;
   int top, height, left, sb_left, width, sb_width;
   int window_y, window_height;
-  int fringe_extended_p;
+  bool fringe_extended_p;
 
   /* Get window dimensions.  */
-  window_box (w, -1, 0, &window_y, 0, &window_height);
+  window_box (w, ANY_AREA, 0, &window_y, 0, &window_height);
   top  = window_y;
   width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
   height = window_height;
@@ -3866,16 +3807,7 @@ w32_set_vertical_scroll_bar (struct window *w,
   else
     sb_left = left + (WINDOW_LEFTMOST_P (w) ? 0 : width - sb_width);
 
-  if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
-    fringe_extended_p = (WINDOW_LEFTMOST_P (w)
-                         && WINDOW_LEFT_FRINGE_WIDTH (w)
-                         && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-                             || WINDOW_LEFT_MARGIN_COLS (w) == 0));
-  else
-    fringe_extended_p = (WINDOW_RIGHTMOST_P (w)
-                         && WINDOW_RIGHT_FRINGE_WIDTH (w)
-                         && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-                             || WINDOW_RIGHT_MARGIN_COLS (w) == 0));
+  fringe_extended_p = WINDOW_FRINGE_EXTENDED_P (w);
 
   /* Does the scroll bar exist yet?  */
   if (NILP (w->vertical_scroll_bar))
@@ -3904,11 +3836,11 @@ w32_set_vertical_scroll_bar (struct window *w,
       hwnd = SCROLL_BAR_W32_WINDOW (bar);
 
       /* If already correctly positioned, do nothing.  */
-      if ( XINT (bar->left) == sb_left
-           && XINT (bar->top) == top
-           && XINT (bar->width) ==  sb_width
-           && XINT (bar->height) == height
-           && !NILP (bar->fringe_extended_p) == fringe_extended_p )
+      if (XINT (bar->left) == sb_left
+          && XINT (bar->top) == top
+          && XINT (bar->width) == sb_width
+          && XINT (bar->height) == height
+          && bar->fringe_extended_p == fringe_extended_p)
         {
           /* Redraw after clear_frame. */
           if (!my_show_window (f, hwnd, SW_NORMAL))
@@ -3958,7 +3890,7 @@ w32_set_vertical_scroll_bar (struct window *w,
           unblock_input ();
         }
     }
-  bar->fringe_extended_p = fringe_extended_p ? Qt : Qnil;
+  bar->fringe_extended_p = fringe_extended_p;
 
   w32_set_scroll_bar_thumb (bar, portion, position, whole);
   XSETVECTOR (barobj, bar);
@@ -4568,18 +4500,16 @@ w32_read_socket (struct terminal *terminal,
               /* Generate SELECT_WINDOW_EVENTs when needed.  */
               if (!NILP (Vmouse_autoselect_window))
                 {
-                  Lisp_Object window;
-                  int x = LOWORD (msg.msg.lParam);
-                  int y = HIWORD (msg.msg.lParam);
-
-                  window = window_from_coordinates (f, x, y, 0, 0);
+                  static Lisp_Object last_mouse_window;
+                  Lisp_Object window = window_from_coordinates
+                    (f, LOWORD (msg.msg.lParam), HIWORD (msg.msg.lParam), 0, 0);
 
                   /* Window will be selected only when it is not
                      selected now and last mouse movement event was
                      not in it.  Minibuffer window will be selected
                      only when it is active.  */
                   if (WINDOWP (window)
-                      && !EQ (window, last_window)
+                      && !EQ (window, last_mouse_window)
                       && !EQ (window, selected_window)
                       /* For click-to-focus window managers
                          create event iff we don't leave the
@@ -4591,8 +4521,8 @@ w32_read_socket (struct terminal *terminal,
                       inev.kind = SELECT_WINDOW_EVENT;
                       inev.frame_or_window = window;
                     }
-
-                  last_window = window;
+                  /* Remember the last window where we saw the mouse.  */
+                  last_mouse_window = window;
                 }
               if (!note_mouse_movement (f, &msg.msg))
                 help_echo_string = previous_help_echo_string;
@@ -5147,7 +5077,8 @@ w32_read_socket (struct terminal *terminal,
    mode lines must be clipped to the whole window.  */
 
 static void
-w32_clip_to_row (struct window *w, struct glyph_row *row, int area, HDC hdc)
+w32_clip_to_row (struct window *w, struct glyph_row *row,
+                 enum glyph_row_area area, HDC hdc)
 {
   RECT clip_rect;
   int window_x, window_y, window_width;
@@ -5317,8 +5248,8 @@ w32_clear_frame_area (struct frame *f, int x, int y, int width, int height)
 
 static void
 w32_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
-                        int x, int y, int cursor_type, int cursor_width,
-                        int on_p, int active_p)
+                        int x, int y, enum text_cursor_kinds cursor_type,
+                        int cursor_width, bool on_p, bool active_p)
 {
   if (on_p)
     {
@@ -5717,7 +5648,9 @@ w32fullscreen_hook (struct frame *f)
       w32_fullscreen_rect (hwnd, f->want_fullscreen,
                            FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
       FRAME_PREV_FSMODE (f) = f->want_fullscreen;
-      if (f->want_fullscreen == FULLSCREEN_BOTH)
+      if (f->want_fullscreen == FULLSCREEN_MAXIMIZED)
+        PostMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, 0xf030, 0);
+      else if (f->want_fullscreen == FULLSCREEN_BOTH)
         {
           SetWindowLong (hwnd, GWL_STYLE, dwStyle & ~WS_OVERLAPPEDWINDOW);
           SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
@@ -6172,16 +6105,8 @@ x_free_frame_resources (struct frame *f)
     dpyinfo->w32_focus_event_frame = 0;
   if (f == dpyinfo->x_highlight_frame)
     dpyinfo->x_highlight_frame = 0;
-
   if (f == hlinfo->mouse_face_mouse_frame)
-    {
-      hlinfo->mouse_face_beg_row
-        = hlinfo->mouse_face_beg_col = -1;
-      hlinfo->mouse_face_end_row
-        = hlinfo->mouse_face_end_col = -1;
-      hlinfo->mouse_face_window = Qnil;
-      hlinfo->mouse_face_mouse_frame = 0;
-    }
+    reset_mouse_highlight (hlinfo);
 
   unblock_input ();
 }
@@ -6251,7 +6176,6 @@ void
 w32_initialize_display_info (Lisp_Object display_name)
 {
   struct w32_display_info *dpyinfo = &one_w32_display_info;
-  Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
 
   memset (dpyinfo, 0, sizeof (*dpyinfo));
 
@@ -6274,17 +6198,10 @@ w32_initialize_display_info (Lisp_Object display_name)
   dpyinfo->n_fonts = 0;
   dpyinfo->smallest_font_height = 1;
   dpyinfo->smallest_char_width = 1;
-
-  hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-  hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-  hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
-  hlinfo->mouse_face_window = Qnil;
-  hlinfo->mouse_face_overlay = Qnil;
-  hlinfo->mouse_face_hidden = 0;
-
   dpyinfo->vertical_scroll_bar_cursor = w32_load_cursor (IDC_ARROW);
   /* TODO: dpyinfo->gray */
 
+  reset_mouse_highlight (&dpyinfo->mouse_highlight);
 }
 
 /* Create an xrdb-style database of resources to supersede registry settings.
@@ -6359,7 +6276,6 @@ static struct redisplay_interface w32_redisplay_interface =
   x_after_update_window_line,
   x_update_window_begin,
   x_update_window_end,
-  x_cursor_to,
   x_flush,
   0,  /* flush_display_optional */
   x_clear_window_mouse_face,
@@ -6396,11 +6312,11 @@ w32_create_terminal (struct w32_display_info *dpyinfo)
   terminal->ins_del_lines_hook = x_ins_del_lines;
   terminal->delete_glyphs_hook = x_delete_glyphs;
   terminal->ring_bell_hook = w32_ring_bell;
-  terminal->reset_terminal_modes_hook = w32_reset_terminal_modes;
-  terminal->set_terminal_modes_hook = w32_set_terminal_modes;
+  terminal->reset_terminal_modes_hook = NULL;
+  terminal->set_terminal_modes_hook = NULL;
   terminal->update_begin_hook = x_update_begin;
   terminal->update_end_hook = x_update_end;
-  terminal->set_terminal_window_hook = w32_set_terminal_window;
+  terminal->set_terminal_window_hook = NULL;
   terminal->read_socket_hook = w32_read_socket;
   terminal->frame_up_to_date_hook = w32_frame_up_to_date;
   terminal->mouse_position_hook = w32_mouse_position;
@@ -6478,9 +6394,7 @@ w32_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   terminal = w32_create_terminal (dpyinfo);
 
   /* Set the name of the terminal. */
-  terminal->name = xmalloc (SBYTES (display_name) + 1);
-  strncpy (terminal->name, SDATA (display_name), SBYTES (display_name));
-  terminal->name[SBYTES (display_name)] = 0;
+  terminal->name = xlispstrdup (display_name);
 
   dpyinfo->xrdb = xrm_option ? w32_make_rdb (xrm_option) : NULL;
 
diff --git a/src/w32term.h b/src/w32term.h
index 3c9cce35221..41c5c71832a 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -451,9 +451,11 @@ struct scroll_bar {
      being dragged, this is Qnil.  */
   Lisp_Object dragging;
 
-  /* t if the background of the fringe that is adjacent to a scroll
+  /* 1 if the background of the fringe that is adjacent to a scroll
      bar is extended to the gap between the fringe and the bar.  */
-  Lisp_Object fringe_extended_p;
+  /* Note: this could be a bit field, but we need to take its address
+     in ALLOCATE_PSEUDOVECTOR (see x_scroll_bar_create).  */
+  bool fringe_extended_p;
 };
 
 /* Turning a lisp vector value into a pointer to a struct scroll_bar.  */
diff --git a/src/window.c b/src/window.c
index 1b288368884..ef96861dc71 100644
--- a/src/window.c
+++ b/src/window.c
@@ -66,10 +66,9 @@ static Lisp_Object Qsafe, Qabove, Qbelow, Qwindow_size, Qclone_of;
 static int displayed_window_lines (struct window *);
 static int count_windows (struct window *);
 static int get_leaf_windows (struct window *, struct window **, int);
-static void window_scroll (Lisp_Object, EMACS_INT, int, int);
-static void window_scroll_pixel_based (Lisp_Object, int, int, int);
-static void window_scroll_line_based (Lisp_Object, int, int, int);
-static int freeze_window_start (struct window *, void *);
+static void window_scroll (Lisp_Object, EMACS_INT, bool, int);
+static void window_scroll_pixel_based (Lisp_Object, int, bool, int);
+static void window_scroll_line_based (Lisp_Object, int, bool, int);
 static Lisp_Object window_list (void);
 static int add_window_to_list (struct window *, void *);
 static Lisp_Object next_window (Lisp_Object, Lisp_Object,
@@ -88,6 +87,14 @@ static void window_resize_apply (struct window *, bool);
 static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
 static void select_window_1 (Lisp_Object, bool);
 
+static struct window *set_window_fringes (struct window *, Lisp_Object,
+                                          Lisp_Object, Lisp_Object);
+static struct window *set_window_margins (struct window *, Lisp_Object,
+                                          Lisp_Object);
+static struct window *set_window_scroll_bars (struct window *, Lisp_Object,
+                                              Lisp_Object, Lisp_Object);
+static void apply_window_adjustment (struct window *);
+
 /* This is the window in which the terminal's cursor should
    be left when nothing is being done with it.  This must
    always be a leaf window, and its buffer is selected by
@@ -152,16 +159,6 @@ wset_display_table (struct window *w, Lisp_Object val)
   w->display_table = val;
 }
 static void
-wset_left_fringe_width (struct window *w, Lisp_Object val)
-{
-  w->left_fringe_width = val;
-}
-static void
-wset_left_margin_cols (struct window *w, Lisp_Object val)
-{
-  w->left_margin_cols = val;
-}
-static void
 wset_new_normal (struct window *w, Lisp_Object val)
 {
   w->new_normal = val;
@@ -192,21 +189,6 @@ wset_pointm (struct window *w, Lisp_Object val)
   w->pointm = val;
 }
 static void
-wset_right_fringe_width (struct window *w, Lisp_Object val)
-{
-  w->right_fringe_width = val;
-}
-static void
-wset_right_margin_cols (struct window *w, Lisp_Object val)
-{
-  w->right_margin_cols = val;
-}
-static void
-wset_scroll_bar_width (struct window *w, Lisp_Object val)
-{
-  w->scroll_bar_width = val;
-}
-static void
 wset_start (struct window *w, Lisp_Object val)
 {
   w->start = val;
@@ -239,6 +221,17 @@ wset_combination (struct window *w, bool horflag, Lisp_Object val)
     w->horizontal = horflag;
 }
 
+/* Nonzero if leaf window W doesn't reflect the actual state
+   of displayed buffer due to its text or overlays change.  */
+
+bool
+window_outdated (struct window *w)
+{
+  struct buffer *b = XBUFFER (w->contents);
+  return (w->last_modified < BUF_MODIFF (b)
+          || w->last_overlay_modified < BUF_OVERLAY_MODIFF (b));
+}
+
 struct window *
 decode_live_window (register Lisp_Object window)
 {
@@ -488,7 +481,6 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
   CHECK_LIVE_WINDOW (window);
 
   w = XWINDOW (window);
-  w->frozen_window_start_p = 0;
 
   /* Make the selected window's buffer current.  */
   Fset_buffer (w->contents);
@@ -557,15 +549,7 @@ select_window_1 (Lisp_Object window, bool inhibit_point_swap)
      than one window.  It also matters when
      redisplay_window has altered point after scrolling,
      because it makes the change only in the window.  */
-  {
-    register ptrdiff_t new_point = marker_position (XWINDOW (window)->pointm);
-    if (new_point < BEGV)
-      SET_PT (BEGV);
-    else if (new_point > ZV)
-      SET_PT (ZV);
-    else
-      SET_PT (new_point);
-  }
+  set_point_from_marker (XWINDOW (window)->pointm);
 }
 
 DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
@@ -1353,7 +1337,7 @@ struct check_window_data
 static int
 check_window_containing (struct window *w, void *user_data)
 {
-  struct check_window_data *cw = (struct check_window_data *) user_data;
+  struct check_window_data *cw = user_data;
   enum window_part found;
   int continue_p = 1;
 
@@ -1506,12 +1490,10 @@ if it isn't already recorded.  */)
           || !w->window_end_valid
           || b->clip_changed
           || b->prevent_redisplay_optimizations_p
-          || w->last_modified < BUF_MODIFF (b)
-          || w->last_overlay_modified < BUF_OVERLAY_MODIFF (b))
+          || window_outdated (w))
       && !noninteractive)
     {
       struct text_pos startp;
-      ptrdiff_t charpos = marker_position (w->start);
       struct it it;
       struct buffer *old_buffer = NULL;
       void *itdata = NULL;
@@ -1529,12 +1511,7 @@ if it isn't already recorded.  */)
          `-l' containing a call to `rmail' with subsequent other
          commands.  At the end, W->start happened to be BEG, while
          rmail had already narrowed the buffer.  */
-      if (charpos < BEGV)
-        SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
-      else if (charpos > ZV)
-        SET_TEXT_POS (startp, ZV, ZV_BYTE);
-      else
-        SET_TEXT_POS_FROM_MARKER (startp, w->start);
+      CLIP_TEXT_POS_FROM_MARKER (startp, w->start);
 
       itdata = bidi_shelve_cache ();
       start_display (&it, w, startp);
@@ -1548,7 +1525,7 @@ if it isn't already recorded.  */)
         set_buffer_internal (old_buffer);
     }
   else
-    XSETINT (value, BUF_Z (b) - XFASTINT (w->window_end_pos));
+    XSETINT (value, BUF_Z (b) - w->window_end_pos);
 
   return value;
 }
@@ -1604,9 +1581,8 @@ overriding motion of point in order to display at this exact start.  */)
   if (NILP (noforce))
     w->force_start = 1;
   w->update_mode_line = 1;
-  w->last_modified = 0;
-  w->last_overlay_modified = 0;
-  if (!EQ (window, selected_window))
+  if (w != XWINDOW (selected_window))
+    /* Enforce full redisplay.  FIXME: make it more selective.  */
     windows_or_buffers_changed++;
 
   return pos;
@@ -1720,8 +1696,7 @@ Return nil if window display is not up-to-date.  In that case, use
       || windows_or_buffers_changed
       || b->clip_changed
       || b->prevent_redisplay_optimizations_p
-      || w->last_modified < BUF_MODIFF (b)
-      || w->last_overlay_modified < BUF_OVERLAY_MODIFF (b))
+      || window_outdated (w))
     return Qnil;
 
   if (NILP (line))
@@ -2038,16 +2013,15 @@ replace_window (Lisp_Object old, Lisp_Object new, int setflag)
       n->desired_matrix = n->current_matrix = 0;
       n->vscroll = 0;
       memset (&n->cursor, 0, sizeof (n->cursor));
-      memset (&n->last_cursor, 0, sizeof (n->last_cursor));
       memset (&n->phys_cursor, 0, sizeof (n->phys_cursor));
+      n->last_cursor_vpos = 0;
       n->phys_cursor_type = -1;
       n->phys_cursor_width = -1;
       n->must_be_updated_p = 0;
       n->pseudo_window_p = 0;
-      wset_window_end_vpos (n, make_number (0));
-      wset_window_end_pos (n, make_number (0));
+      n->window_end_vpos = 0;
+      n->window_end_pos = 0;
       n->window_end_valid = 0;
-      n->frozen_window_start_p = 0;
     }
 
   tem = o->next;
@@ -2156,7 +2130,7 @@ delete_deletable_window (Lisp_Object window)
 static int
 add_window_to_list (struct window *w, void *user_data)
 {
-  Lisp_Object *list = (Lisp_Object *) user_data;
+  Lisp_Object *list = user_data;
   Lisp_Object window;
   XSETWINDOW (window, w);
   *list = Fcons (window, *list);
@@ -2854,7 +2828,7 @@ window-start value is reasonable when this function is called.  */)
   block_input ();
   if (!FRAME_INITIAL_P (f))
     {
-        Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
+      Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 
       /* We are going to free the glyph matrices of WINDOW, and with
          that we might lose any information about glyph rows that have
@@ -2864,11 +2838,7 @@ window-start value is reasonable when this function is called.  */)
          frame's up-to-date hook that mouse highlight was overwritten,
          so that it will arrange for redisplaying the highlight.  */
       if (EQ (hlinfo->mouse_face_window, window))
-        {
-          hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-          hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-          hlinfo->mouse_face_window = Qnil;
-        }
+        reset_mouse_highlight (hlinfo);
     }
   free_window_matrices (r);
 
@@ -3063,15 +3033,12 @@ adjust_window_margins (struct window *w)
   if (WINDOW_RIGHT_MARGIN_COLS (w) > 0)
     {
       if (WINDOW_LEFT_MARGIN_COLS (w) > 0)
-        {
-          wset_left_margin_cols (w, make_number (margin_cols / 2));
-          wset_right_margin_cols (w, make_number (margin_cols / 2));
-        }
+        w->left_margin_cols = w->right_margin_cols = margin_cols / 2;
       else
-        wset_right_margin_cols (w, make_number (margin_cols));
+        w->right_margin_cols = margin_cols;
     }
   else
-    wset_left_margin_cols (w, make_number (margin_cols));
+    w->left_margin_cols = margin_cols;
   return 1;
 }
 
@@ -3119,7 +3086,7 @@ run_window_configuration_change_hook (struct frame *f)
 
   if (SELECTED_FRAME () != f)
     {
-      record_unwind_protect (select_frame_norecord, Fselected_frame ());
+      record_unwind_protect (select_frame_norecord, selected_frame);
       select_frame_norecord (frame);
     }
 
@@ -3134,7 +3101,7 @@ run_window_configuration_change_hook (struct frame *f)
                                       buffer)))
           {
             ptrdiff_t inner_count = SPECPDL_INDEX ();
-            record_unwind_protect (select_window_norecord, Fselected_window ());
+            record_unwind_protect (select_window_norecord, selected_window);
             select_window_norecord (window);
             run_funs (Fbuffer_local_value (Qwindow_configuration_change_hook,
                                            buffer));
@@ -3185,9 +3152,9 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
     bset_display_count (b, make_number (XINT (BVAR (b, display_count)) + 1));
   bset_display_time (b, Fcurrent_time ());
 
-  wset_window_end_pos (w, make_number (0));
-  wset_window_end_vpos (w, make_number (0));
-  memset (&w->last_cursor, 0, sizeof w->last_cursor);
+  w->window_end_pos = 0;
+  w->window_end_vpos = 0;
+  w->last_cursor_vpos = 0;
 
   if (!(keep_margins_p && samebuf))
     { /* If we're not actually changing the buffer, don't reset hscroll and
@@ -3206,8 +3173,6 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
                              buffer);
       w->start_at_line_beg = 0;
       w->force_start = 0;
-      w->last_modified = 0;
-      w->last_overlay_modified = 0;
     }
   /* Maybe we could move this into the `if' but it's not obviously safe and
      I doubt it's worth the trouble.  */
@@ -3227,28 +3192,14 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
   if (!keep_margins_p)
     {
       /* Set left and right marginal area width etc. from buffer.  */
-
-      /* This may call adjust_window_margins three times, so
-         temporarily disable window margins.  */
-      Lisp_Object save_left = w->left_margin_cols;
-      Lisp_Object save_right = w->right_margin_cols;
-
-      wset_left_margin_cols (w, Qnil);
-      wset_right_margin_cols (w, Qnil);
-
-      Fset_window_fringes (window,
-                           BVAR (b, left_fringe_width), BVAR (b, right_fringe_width),
-                           BVAR (b, fringes_outside_margins));
-
-      Fset_window_scroll_bars (window,
-                               BVAR (b, scroll_bar_width),
-                               BVAR (b, vertical_scroll_bar_type), Qnil);
-
-      wset_left_margin_cols (w, save_left);
-      wset_right_margin_cols (w, save_right);
-
-      Fset_window_margins (window,
-                           BVAR (b, left_margin_cols), BVAR (b, right_margin_cols));
+      set_window_fringes (w, BVAR (b, left_fringe_width),
+                          BVAR (b, right_fringe_width),
+                          BVAR (b, fringes_outside_margins));
+      set_window_scroll_bars (w, BVAR (b, scroll_bar_width),
+                              BVAR (b, vertical_scroll_bar_type), Qnil);
+      set_window_margins (w, BVAR (b, left_margin_cols),
+                          BVAR (b, right_margin_cols));
+      apply_window_adjustment (w);
     }
 
   if (run_hooks_p)
@@ -3384,10 +3335,8 @@ temp_output_buffer_show (register Lisp_Object buf)
 
   if (!NILP (Vtemp_buffer_show_function))
     call1 (Vtemp_buffer_show_function, buf);
-  else
+  else if (WINDOW_LIVE_P (window = display_buffer (buf, Qnil, Qnil)))
     {
-      window = display_buffer (buf, Qnil, Qnil);
-
       if (!EQ (XWINDOW (window)->frame, selected_frame))
         Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window)));
       Vminibuf_scroll_window = window;
@@ -3468,8 +3417,6 @@ make_window (void)
   wset_start (w, Fmake_marker ());
   wset_pointm (w, Fmake_marker ());
   wset_vertical_scroll_bar_type (w, Qt);
-  wset_window_end_pos (w, make_number (0));
-  wset_window_end_vpos (w, make_number (0));
   /* These Lisp fields are marked specially so they're not set to nil by
      allocate_window.  */
   wset_prev_buffers (w, Qnil);
@@ -3478,8 +3425,10 @@ make_window (void)
   /* Initialize non-Lisp data.  Note that allocate_window zeroes out all
      non-Lisp data, so do it only for slots which should not be zero.  */
   w->nrows_scale_factor = w->ncols_scale_factor = 1;
+  w->left_fringe_width = w->right_fringe_width = -1;
   w->phys_cursor_type = -1;
   w->phys_cursor_width = -1;
+  w->scroll_bar_width = -1;
   w->column_number_displayed = -1;
 
   /* Reset window_list.  */
@@ -3668,10 +3617,6 @@ window_resize_apply (struct window *w, bool horflag)
           c = NILP (c->next) ? 0 : XWINDOW (c->next);
         }
     }
-
-  /* Clear out some redisplay caches.  */
-  w->last_modified = 0;
-  w->last_overlay_modified = 0;
 }
 
 
@@ -3946,15 +3891,15 @@ set correctly.  See the code of `split-window' for how this is done.  */)
     }
 
   n->window_end_valid = 0;
-  memset (&n->last_cursor, 0, sizeof n->last_cursor);
+  n->last_cursor_vpos = 0;
 
   /* Get special geometry settings from reference window.  */
-  wset_left_margin_cols (n, r->left_margin_cols);
-  wset_right_margin_cols (n, r->right_margin_cols);
-  wset_left_fringe_width (n, r->left_fringe_width);
-  wset_right_fringe_width (n, r->right_fringe_width);
+  n->left_margin_cols = r->left_margin_cols;
+  n->right_margin_cols = r->right_margin_cols;
+  n->left_fringe_width = r->left_fringe_width;
+  n->right_fringe_width = r->right_fringe_width;
   n->fringes_outside_margins = r->fringes_outside_margins;
-  wset_scroll_bar_width (n, r->scroll_bar_width);
+  n->scroll_bar_width = r->scroll_bar_width;
   wset_vertical_scroll_bar_type (n, r->vertical_scroll_bar_type);
 
   /* Directly assign orthogonal coordinates and sizes.  */
@@ -4190,9 +4135,7 @@ grow_mini_window (struct window *w, int delta)
       /* Grow the mini-window.  */
       w->top_line = r->top_line + r->total_lines;
       w->total_lines -= XINT (value);
-      w->last_modified = 0;
-      w->last_overlay_modified = 0;
-
+      /* Enforce full redisplay.  FIXME: make it more selective.  */
       windows_or_buffers_changed++;
       adjust_glyphs (f);
       unblock_input ();
@@ -4226,10 +4169,7 @@ shrink_mini_window (struct window *w)
           /* Shrink the mini-window.  */
           w->top_line = r->top_line + r->total_lines;
           w->total_lines = 1;
-
-          w->last_modified = 0;
-          w->last_overlay_modified = 0;
-
+          /* Enforce full redisplay.  FIXME: make it more selective.  */
           windows_or_buffers_changed++;
           adjust_glyphs (f);
           unblock_input ();
@@ -4336,7 +4276,7 @@ window_internal_height (struct window *w)
    respectively.  */
 
 static void
-window_scroll (Lisp_Object window, EMACS_INT n, int whole, int noerror)
+window_scroll (Lisp_Object window, EMACS_INT n, bool whole, int noerror)
 {
   immediate_quit = 1;
   n = clip_to_bounds (INT_MIN, n, INT_MAX);
@@ -4357,7 +4297,7 @@ window_scroll (Lisp_Object window, EMACS_INT n, int whole, int noerror)
    descriptions.  */
 
 static void
-window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
+window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
 {
   struct it it;
   struct window *w = XWINDOW (window);
@@ -4455,8 +4395,6 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
                                          w->contents);
                   w->start_at_line_beg = 1;
                   w->update_mode_line = 1;
-                  w->last_modified = 0;
-                  w->last_overlay_modified = 0;
                   /* Set force_start so that redisplay_window will run the
                      window-scroll-functions.  */
                   w->force_start = 1;
@@ -4601,8 +4539,6 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
       bytepos = marker_byte_position (w->start);
       w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
       w->update_mode_line = 1;
-      w->last_modified = 0;
-      w->last_overlay_modified = 0;
       /* Set force_start so that redisplay_window will run the
          window-scroll-functions.  */
       w->force_start = 1;
@@ -4725,7 +4661,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
    See the comment of window_scroll for parameter descriptions.  */
 
 static void
-window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
+window_scroll_line_based (Lisp_Object window, int n, bool whole, int noerror)
 {
   register struct window *w = XWINDOW (window);
   /* Fvertical_motion enters redisplay, which can trigger
@@ -4737,7 +4673,7 @@ window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
   register ptrdiff_t pos, pos_byte;
   register int ht = window_internal_height (w);
   register Lisp_Object tem;
-  int lose;
+  bool lose;
   Lisp_Object bolp;
   ptrdiff_t startpos = marker_position (w->start);
   ptrdiff_t startbyte = marker_byte_position (w->start);
@@ -4801,8 +4737,6 @@ window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
       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;
-      w->last_overlay_modified = 0;
       /* Set force_start so that redisplay_window will run
          the window-scroll-functions.  */
       w->force_start = 1;
@@ -5098,7 +5032,6 @@ displayed_window_lines (struct window *w)
 {
   struct it it;
   struct text_pos start;
-  ptrdiff_t charpos = marker_position (w->start);
   int height = window_box_height (w);
   struct buffer *old_buffer;
   int bottom_y;
@@ -5115,12 +5048,7 @@ displayed_window_lines (struct window *w)
   /* In case W->start is out of the accessible range, do something
      reasonable.  This happens in Info mode when Info-scroll-down
      calls (recenter -1) while W->start is 1.  */
-  if (charpos < BEGV)
-    SET_TEXT_POS (start, BEGV, BEGV_BYTE);
-  else if (charpos > ZV)
-    SET_TEXT_POS (start, ZV, ZV_BYTE);
-  else
-    SET_TEXT_POS_FROM_MARKER (start, w->start);
+  CLIP_TEXT_POS_FROM_MARKER (start, w->start);
 
   itdata = bidi_shelve_cache ();
   start_display (&it, w, start);
@@ -5454,7 +5382,7 @@ struct save_window_data
     Lisp_Object saved_windows;
 
     /* All fields above are traced by the GC.
-       From `fame-cols' down, the fields are ignored by the GC.  */
+       From `frame-cols' down, the fields are ignored by the GC.  */
 
     int frame_cols, frame_lines, frame_menu_bar_lines;
     int frame_tool_bar_lines;
@@ -5703,12 +5631,12 @@ the return value is nil.  Otherwise the value is t.  */)
           w->hscroll = XFASTINT (p->hscroll);
           w->min_hscroll = XFASTINT (p->min_hscroll);
           wset_display_table (w, p->display_table);
-          wset_left_margin_cols (w, p->left_margin_cols);
-          wset_right_margin_cols (w, p->right_margin_cols);
-          wset_left_fringe_width (w, p->left_fringe_width);
-          wset_right_fringe_width (w, p->right_fringe_width);
+          w->left_margin_cols = XINT (p->left_margin_cols);
+          w->right_margin_cols = XINT (p->right_margin_cols);
+          w->left_fringe_width = XINT (p->left_fringe_width);
+          w->right_fringe_width = XINT (p->right_fringe_width);
           w->fringes_outside_margins = !NILP (p->fringes_outside_margins);
-          wset_scroll_bar_width (w, p->scroll_bar_width);
+          w->scroll_bar_width = XINT (p->scroll_bar_width);
           wset_vertical_scroll_bar_type (w, p->vertical_scroll_bar_type);
           wset_dedicated (w, p->dedicated);
           wset_combination_limit (w, p->combination_limit);
@@ -5734,9 +5662,6 @@ the return value is nil.  Otherwise the value is t.  */)
                 }
             }
 
-          w->last_modified = 0;
-          w->last_overlay_modified = 0;
-
           if (BUFFERP (p->buffer) && BUFFER_LIVE_P (XBUFFER (p->buffer)))
             /* If saved buffer is alive, install it.  */
             {
@@ -6007,12 +5932,12 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
       XSETFASTINT (p->hscroll, w->hscroll);
       XSETFASTINT (p->min_hscroll, w->min_hscroll);
       p->display_table = w->display_table;
-      p->left_margin_cols = w->left_margin_cols;
-      p->right_margin_cols = w->right_margin_cols;
-      p->left_fringe_width = w->left_fringe_width;
-      p->right_fringe_width = w->right_fringe_width;
+      p->left_margin_cols = make_number (w->left_margin_cols);
+      p->right_margin_cols = make_number (w->right_margin_cols);
+      p->left_fringe_width = make_number (w->left_fringe_width);
+      p->right_fringe_width = make_number (w->right_fringe_width);
       p->fringes_outside_margins = w->fringes_outside_margins ? Qt : Qnil;
-      p->scroll_bar_width = w->scroll_bar_width;
+      p->scroll_bar_width = make_number (w->scroll_bar_width);
       p->vertical_scroll_bar_type = w->vertical_scroll_bar_type;
       p->dedicated = w->dedicated;
       p->combination_limit = w->combination_limit;
@@ -6153,11 +6078,46 @@ saved by this function.  */)
   XSETWINDOW_CONFIGURATION (tem, data);
   return (tem);
 }
+
+/* Called after W's margins, fringes or scroll bars was adjusted.  */
+
+static void
+apply_window_adjustment (struct window *w)
+{
+  eassert (w);
+  adjust_window_margins (w);
+  clear_glyph_matrix (w->current_matrix);
+  w->window_end_valid = 0;
+  windows_or_buffers_changed++;
+  adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
+}
+
 
 /***********************************************************************
                             Marginal Areas
  ***********************************************************************/
 
+static struct window *
+set_window_margins (struct window *w, Lisp_Object left_width,
+                    Lisp_Object right_width)
+{
+  int left, right;
+
+  /* FIXME: what about margins that are too wide?  */
+  left = (NILP (left_width) ? 0
+          : (CHECK_NATNUM (left_width), XINT (left_width)));
+  right = (NILP (right_width) ? 0
+           : (CHECK_NATNUM (right_width), XINT (right_width)));
+
+  if (w->left_margin_cols != left || w->right_margin_cols != right)
+    {
+      w->left_margin_cols = left;
+      w->right_margin_cols = right;
+      return w;
+    }
+  return NULL;
+}
+
 DEFUN ("set-window-margins", Fset_window_margins, Sset_window_margins,
        2, 3, 0,
        doc: /* Set width of marginal areas of window WINDOW.
@@ -6166,41 +6126,14 @@ WINDOW must be a live window and defaults to the selected one.
 Second arg LEFT-WIDTH specifies the number of character cells to
 reserve for the left marginal area.  Optional third arg RIGHT-WIDTH
 does the same for the right marginal area.  A nil width parameter
-means no margin.  */)
+means no margin.
+
+Return t if any margin was actually changed and nil otherwise.  */)
   (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width)
 {
-  struct window *w = decode_live_window (window);
-
-  /* Translate negative or zero widths to nil.
-     Margins that are too wide have to be checked elsewhere.  */
-
-  if (!NILP (left_width))
-    {
-      CHECK_NUMBER (left_width);
-      if (XINT (left_width) <= 0)
-        left_width = Qnil;
-    }
-
-  if (!NILP (right_width))
-    {
-      CHECK_NUMBER (right_width);
-      if (XINT (right_width) <= 0)
-        right_width = Qnil;
-    }
-
-  if (!EQ (w->left_margin_cols, left_width)
-      || !EQ (w->right_margin_cols, right_width))
-    {
-      wset_left_margin_cols (w, left_width);
-      wset_right_margin_cols (w, right_width);
-
-      adjust_window_margins (w);
-
-      ++windows_or_buffers_changed;
-      adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
-    }
-
-  return Qnil;
+  struct window *w = set_window_margins (decode_live_window (window),
+                                         left_width, right_width);
+  return w ? (apply_window_adjustment (w), Qt) : Qnil;
 }
 
 
@@ -6215,7 +6148,8 @@ as nil.  */)
   (Lisp_Object window)
 {
   struct window *w = decode_live_window (window);
-  return Fcons (w->left_margin_cols, w->right_margin_cols);
+  return Fcons (w->left_margin_cols ? make_number (w->left_margin_cols) : Qnil,
+                w->right_margin_cols ? make_number (w->right_margin_cols) : Qnil);
 }
 
 
@@ -6224,6 +6158,31 @@ as nil.  */)
                             Fringes
  ***********************************************************************/
 
+static struct window *
+set_window_fringes (struct window *w, Lisp_Object left_width,
+                    Lisp_Object right_width, Lisp_Object outside_margins)
+{
+  int left, right, outside = !NILP (outside_margins);
+
+  left = (NILP (left_width) ? -1
+          : (CHECK_NATNUM (left_width), XINT (left_width)));
+  right = (NILP (right_width) ? -1
+           : (CHECK_NATNUM (right_width), XINT (right_width)));
+
+  /* Do nothing on a tty or if nothing to actually change.  */
+  if (FRAME_WINDOW_P (WINDOW_XFRAME (w))
+      && (w->left_fringe_width != left
+          || w->right_fringe_width != right
+          || w->fringes_outside_margins != outside))
+    {
+      w->left_fringe_width = left;
+      w->right_fringe_width = right;
+      w->fringes_outside_margins = outside;
+      return w;
+    }
+  return NULL;
+}
+
 DEFUN ("set-window-fringes", Fset_window_fringes, Sset_window_fringes,
        2, 4, 0,
        doc: /* Set the fringe widths of window WINDOW.
@@ -6236,37 +6195,16 @@ frame's default fringe width.  Default fringe widths can be set with
 the command `set-fringe-style'.
 If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes
 outside of the display margins.  By default, fringes are drawn between
-display marginal areas and the text area.  */)
-  (Lisp_Object window, Lisp_Object left_width, Lisp_Object right_width, Lisp_Object outside_margins)
-{
-  struct window *w = decode_live_window (window);
-  int outside = !NILP (outside_margins);
-
-  if (!NILP (left_width))
-    CHECK_NATNUM (left_width);
-  if (!NILP (right_width))
-    CHECK_NATNUM (right_width);
-
-  /* Do nothing on a tty.  */
-  if (FRAME_WINDOW_P (WINDOW_XFRAME (w))
-      && (!EQ (w->left_fringe_width, left_width)
-          || !EQ (w->right_fringe_width, right_width)
-          || w->fringes_outside_margins != outside))
-    {
-      wset_left_fringe_width (w, left_width);
-      wset_right_fringe_width (w, right_width);
-      w->fringes_outside_margins = outside;
+display marginal areas and the text area.
 
-      adjust_window_margins (w);
-
-      clear_glyph_matrix (w->current_matrix);
-      w->window_end_valid = 0;
-
-      ++windows_or_buffers_changed;
-      adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
-    }
-
-  return Qnil;
+Return t if any fringe was actually changed and nil otherwise.  */)
+  (Lisp_Object window, Lisp_Object left_width,
+   Lisp_Object right_width, Lisp_Object outside_margins)
+{
+  struct window *w
+    = set_window_fringes (decode_live_window (window),
+                          left_width, right_width, outside_margins);
+  return w ? (apply_window_adjustment (w), Qt) : Qnil;
 }
 
 
@@ -6291,29 +6229,14 @@ Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).  */)
                             Scroll bars
  ***********************************************************************/
 
-DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars,
-       Sset_window_scroll_bars, 2, 4, 0,
-       doc: /* Set width and type of scroll bars of window WINDOW.
-WINDOW must be a live window and defaults to the selected one.
-
-Second parameter WIDTH specifies the pixel width for the scroll bar;
-this is automatically adjusted to a multiple of the frame column width.
-Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
-bar: left, right, or nil.
-If WIDTH is nil, use the frame's scroll-bar width.
-If VERTICAL-TYPE is t, use the frame's scroll-bar type.
-Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
-  (Lisp_Object window, Lisp_Object width, Lisp_Object vertical_type, Lisp_Object horizontal_type)
+static struct window *
+set_window_scroll_bars (struct window *w, Lisp_Object width,
+                        Lisp_Object vertical_type, Lisp_Object horizontal_type)
 {
-  struct window *w = decode_live_window (window);
+  int iwidth = (NILP (width) ? -1 : (CHECK_NATNUM (width), XINT (width)));
 
-  if (!NILP (width))
-    {
-      CHECK_RANGED_INTEGER (width, 0, INT_MAX);
-
-      if (XINT (width) == 0)
-        vertical_type = Qnil;
-    }
+  if (iwidth == 0)
+    vertical_type = Qnil;
 
   if (!(NILP (vertical_type)
         || EQ (vertical_type, Qleft)
@@ -6321,22 +6244,37 @@ Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
         || EQ (vertical_type, Qt)))
     error ("Invalid type of vertical scroll bar");
 
-  if (!EQ (w->scroll_bar_width, width)
+  if (w->scroll_bar_width != iwidth
       || !EQ (w->vertical_scroll_bar_type, vertical_type))
     {
-      wset_scroll_bar_width (w, width);
+      w->scroll_bar_width = iwidth;
       wset_vertical_scroll_bar_type (w, vertical_type);
+      return w;
+    }
+  return NULL;
+}
 
-      adjust_window_margins (w);
-
-      clear_glyph_matrix (w->current_matrix);
-      w->window_end_valid = 0;
+DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars,
+       Sset_window_scroll_bars, 2, 4, 0,
+       doc: /* Set width and type of scroll bars of window WINDOW.
+WINDOW must be a live window and defaults to the selected one.
 
-      ++windows_or_buffers_changed;
-      adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
-    }
+Second parameter WIDTH specifies the pixel width for the scroll bar;
+this is automatically adjusted to a multiple of the frame column width.
+Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
+bar: left, right, or nil.
+If WIDTH is nil, use the frame's scroll-bar width.
+If VERTICAL-TYPE is t, use the frame's scroll-bar type.
+Fourth parameter HORIZONTAL-TYPE is currently unused.
 
-  return Qnil;
+Return t if scroll bars was actually changed and nil otherwise.  */)
+  (Lisp_Object window, Lisp_Object width,
+   Lisp_Object vertical_type, Lisp_Object horizontal_type)
+{
+  struct window *w
+    = set_window_scroll_bars (decode_live_window (window),
+                              width, vertical_type, horizontal_type);
+  return w ? (apply_window_adjustment (w), Qt) : Qnil;
 }
 
 
@@ -6465,38 +6403,6 @@ foreach_window_1 (struct window *w, int (*fn) (struct window *, void *), void *u
   return cont;
 }
 
-
-/* Freeze or unfreeze the window start of W unless it is a
-   mini-window or the selected window.  FREEZE_P non-null means freeze
-   the window start.  */
-
-static int
-freeze_window_start (struct window *w, void *freeze_p)
-{
-  if (MINI_WINDOW_P (w)
-      || (WINDOWP (selected_window) /* Can be nil in corner cases.  */
-         && (w == XWINDOW (selected_window)
-             || (MINI_WINDOW_P (XWINDOW (selected_window))
-                 && ! NILP (Vminibuf_scroll_window)
-                 && w == XWINDOW (Vminibuf_scroll_window)))))
-    freeze_p = NULL;
-
-  w->frozen_window_start_p = freeze_p != NULL;
-  return 1;
-}
-
-
-/* Freeze or unfreeze the window starts of all leaf windows on frame
-   F, except the selected window and a mini-window.  FREEZE_P non-zero
-   means freeze the window start.  */
-
-void
-freeze_window_starts (struct frame *f, bool freeze_p)
-{
-  foreach_window (f, freeze_window_start, (void *) (freeze_p ? f : 0));
-}
-
-
 /***********************************************************************
                             Initialization
  ***********************************************************************/
diff --git a/src/window.h b/src/window.h
index 5da6165c48d..efe03737052 100644
--- a/src/window.h
+++ b/src/window.h
@@ -141,32 +141,10 @@ struct window
        it yet, or if the frame doesn't have any scroll bars, this is nil.  */
     Lisp_Object vertical_scroll_bar;
 
-    /* Width of left and right marginal areas.  A value of nil means
-       no margin.  */
-    Lisp_Object left_margin_cols;
-    Lisp_Object right_margin_cols;
-
-    /* Width of left and right fringes.
-       A value of nil or t means use frame values.  */
-    Lisp_Object left_fringe_width;
-    Lisp_Object right_fringe_width;
-
-    /* Pixel width of scroll bars.
-       A value of nil or t means use frame values.  */
-    Lisp_Object scroll_bar_width;
-
     /* Type of vertical scroll bar.  A value of nil means
        no scroll bar.  A value of t means use frame value.  */
     Lisp_Object vertical_scroll_bar_type;
 
-    /* Z - the buffer position of the last glyph in the current
-       matrix of W.  Only valid if window_end_valid is nonzero.  */
-    Lisp_Object window_end_pos;
-
-    /* Glyph matrix row of the last glyph in the current matrix
-       of W.  Only valid if window_end_valid is nonzero.  */
-    Lisp_Object window_end_vpos;
-
     /* Display-table to use for displaying chars in this window.
        Nil means use the buffer's own display-table.  */
     Lisp_Object display_table;
@@ -251,10 +229,6 @@ struct window
        as the normal  may yield a matrix which is too small.  */
     int nrows_scale_factor, ncols_scale_factor;
 
-    /* Cursor position as of last update that completed without
-       pause.  This is the position of last_point.  */
-    struct cursor_pos last_cursor;
-
     /* Intended cursor position.   This is a position within the
        glyph matrix.  */
     struct cursor_pos cursor;
@@ -262,6 +236,13 @@ struct window
     /* Where the cursor actually is.  */
     struct cursor_pos phys_cursor;
 
+    /* Internally used for redisplay purposes.  */
+    struct cursor_pos output_cursor;
+
+    /* Vertical cursor position as of last update that completed
+       without pause.  This is the position of last_point.  */
+    int last_cursor_vpos;
+
     /* Cursor type and width of last cursor drawn on the window.
        Used for X and w32 frames; -1 initially.  */
     int phys_cursor_type, phys_cursor_width;
@@ -269,6 +250,28 @@ struct window
     /* This is handy for undrawing the cursor.  */
     int phys_cursor_ascent, phys_cursor_height;
 
+    /* Width of left and right fringes, in pixels.
+       A value of -1 means use frame values.  */
+    int left_fringe_width;
+    int right_fringe_width;
+
+    /* Width of left and right marginal areas in columns.
+       A value of 0 means no margin.  */
+    int left_margin_cols;
+    int right_margin_cols;
+
+    /* Pixel width of scroll bars.
+       A value of -1 means use frame values.  */
+    int scroll_bar_width;
+
+    /* Z - the buffer position of the last glyph in the current
+       matrix of W.  Only valid if window_end_valid is nonzero.  */
+    ptrdiff_t window_end_pos;
+
+    /* Glyph matrix row of the last glyph in the current matrix
+       of W.  Only valid if window_end_valid is nonzero.  */
+    int window_end_vpos;
+
     /* Non-zero if this window is a minibuffer window.  */
     unsigned mini : 1;
 
@@ -316,11 +319,6 @@ struct window
        Currently only used for menu bar windows of frames.  */
     unsigned pseudo_window_p : 1;
 
-    /* 1 means the window start of this window is frozen and may not
-       be changed during redisplay.  If point is not in the window,
-       accept that.  */
-    unsigned frozen_window_start_p : 1;
-
     /* Non-zero means fringes are drawn outside display margins.
        Otherwise draw them between margin areas and text.  */
     unsigned fringes_outside_margins : 1;
@@ -371,16 +369,6 @@ wset_vertical_scroll_bar (struct window *w, Lisp_Object val)
   w->vertical_scroll_bar = val;
 }
 WINDOW_INLINE void
-wset_window_end_pos (struct window *w, Lisp_Object val)
-{
-  w->window_end_pos = val;
-}
-WINDOW_INLINE void
-wset_window_end_vpos (struct window *w, Lisp_Object val)
-{
-  w->window_end_vpos = val;
-}
-WINDOW_INLINE void
 wset_prev_buffers (struct window *w, Lisp_Object val)
 {
   w->prev_buffers = val;
@@ -605,33 +593,21 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 
 /* Width of left margin area in columns.  */
 
-#define WINDOW_LEFT_MARGIN_COLS(W)      \
-  (NILP (W->left_margin_cols)           \
-   ? 0                                  \
-   : XINT (W->left_margin_cols))
+#define WINDOW_LEFT_MARGIN_COLS(W) (W->left_margin_cols)
 
 /* Width of right marginal area in columns.  */
 
-#define WINDOW_RIGHT_MARGIN_COLS(W)     \
-  (NILP (W->right_margin_cols)          \
-   ? 0                                  \
-   : XINT (W->right_margin_cols))
+#define WINDOW_RIGHT_MARGIN_COLS(W) (W->right_margin_cols)
 
 /* Width of left margin area in pixels.  */
 
-#define WINDOW_LEFT_MARGIN_WIDTH(W)     \
-  (NILP (W->left_margin_cols)           \
-   ? 0                                  \
-   : (XINT (W->left_margin_cols)        \
-      * WINDOW_FRAME_COLUMN_WIDTH (W)))
+#define WINDOW_LEFT_MARGIN_WIDTH(W)                     \
+  (W->left_margin_cols * WINDOW_FRAME_COLUMN_WIDTH (W))
 
 /* Width of right marginal area in pixels.  */
 
-#define WINDOW_RIGHT_MARGIN_WIDTH(W)    \
-  (NILP (W->right_margin_cols)          \
-   ? 0                                  \
-   : (XINT (W->right_margin_cols)       \
-      * WINDOW_FRAME_COLUMN_WIDTH (W)))
+#define WINDOW_RIGHT_MARGIN_WIDTH(W)                    \
+  (W->right_margin_cols * WINDOW_FRAME_COLUMN_WIDTH (W))
 
 /* Total width of fringes reserved for drawing truncation bitmaps,
    continuation bitmaps and alike.  The width is in canonical char
@@ -640,10 +616,10 @@ wset_next_buffers (struct window *w, Lisp_Object val)
    able to split windows horizontally nicely.  */
 
 #define WINDOW_FRINGE_COLS(W)                   \
-  ((INTEGERP (W->left_fringe_width)             \
-    || INTEGERP (W->right_fringe_width))        \
-   ? ((WINDOW_LEFT_FRINGE_WIDTH (W)             \
-       + WINDOW_RIGHT_FRINGE_WIDTH (W)          \
+  ((W->left_fringe_width >= 0                   \
+    && W->right_fringe_width >= 0)              \
+   ? ((W->left_fringe_width                     \
+       + W->right_fringe_width                  \
        + WINDOW_FRAME_COLUMN_WIDTH (W) - 1)     \
       / WINDOW_FRAME_COLUMN_WIDTH (W))          \
    : FRAME_FRINGE_COLS (WINDOW_XFRAME (W)))
@@ -663,13 +639,11 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 /* Pixel-width of the left and right fringe.  */
 
 #define WINDOW_LEFT_FRINGE_WIDTH(W)                     \
-  (INTEGERP (W->left_fringe_width)                      \
-   ? XFASTINT (W->left_fringe_width)                    \
+  (W->left_fringe_width >= 0 ? W->left_fringe_width     \
    : FRAME_LEFT_FRINGE_WIDTH (WINDOW_XFRAME (W)))
 
 #define WINDOW_RIGHT_FRINGE_WIDTH(W)                    \
-  (INTEGERP (W->right_fringe_width)                     \
-   ? XFASTINT (W->right_fringe_width)                   \
+  (W->right_fringe_width >= 0 ? W->right_fringe_width   \
    : FRAME_RIGHT_FRINGE_WIDTH (WINDOW_XFRAME (W)))
 
 /* Total width of fringes in pixels.  */
@@ -714,8 +688,7 @@ wset_next_buffers (struct window *w, Lisp_Object val)
    nonzero.  */
 
 #define WINDOW_CONFIG_SCROLL_BAR_WIDTH(w)               \
-  (INTEGERP (w->scroll_bar_width)                       \
-   ? XFASTINT (w->scroll_bar_width)                     \
+  (w->scroll_bar_width >= 0 ? w->scroll_bar_width       \
    : FRAME_CONFIG_SCROLL_BAR_WIDTH (WINDOW_XFRAME (w)))
 
 /* Width that a scroll bar in window W should have, if there is one.
@@ -723,8 +696,8 @@ wset_next_buffers (struct window *w, Lisp_Object val)
    this is still nonzero.  */
 
 #define WINDOW_CONFIG_SCROLL_BAR_COLS(w)                \
-  (INTEGERP (w->scroll_bar_width)                       \
-   ? ((XFASTINT (w->scroll_bar_width)                   \
+  (w->scroll_bar_width >= 0                             \
+   ? ((w->scroll_bar_width                              \
        + WINDOW_FRAME_COLUMN_WIDTH (w) - 1)             \
       / WINDOW_FRAME_COLUMN_WIDTH (w))                  \
    : FRAME_CONFIG_SCROLL_BAR_COLS (WINDOW_XFRAME (w)))
@@ -847,13 +820,25 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 #define WINDOW_TEXT_TO_FRAME_PIXEL_X(W, X)      \
   (window_box_left ((W), TEXT_AREA) + (X))
 
-/* This is the window in which the terminal's cursor should
-   be left when nothing is being done with it.  This must
-   always be a leaf window, and its buffer is selected by
-   the top level editing loop at the end of each command.
+/* Nonzero if the background of the window W's fringe that is adjacent to
+   a scroll bar is extended to the gap between the fringe and the bar.  */
+
+#define WINDOW_FRINGE_EXTENDED_P(w)                     \
+  (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)           \
+   ? (WINDOW_LEFTMOST_P (w)                             \
+      && WINDOW_LEFT_FRINGE_WIDTH (w)                   \
+      && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)        \
+          || WINDOW_LEFT_MARGIN_COLS (w) == 0))         \
+   : (WINDOW_RIGHTMOST_P (w)                            \
+      && WINDOW_RIGHT_FRINGE_WIDTH (w)                  \
+      && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)        \
+          || WINDOW_RIGHT_MARGIN_COLS (w) == 0)))
 
-   This value is always the same as
-    FRAME_SELECTED_WINDOW (selected_frame).  */
+/* This is the window in which the terminal's cursor should be left when
+   nothing is being done with it.  This must always be a leaf window, and its
+   buffer is selected by the top level editing loop at the end of each command.
+
+   This value is always the same as FRAME_SELECTED_WINDOW (selected_frame).  */
 
 extern Lisp_Object selected_window;
 
@@ -874,21 +859,12 @@ extern Lisp_Object minibuf_window;
 
 extern Lisp_Object minibuf_selected_window;
 
-/* Window that the mouse is over (nil if no mouse support).  */
-
-extern Lisp_Object Vmouse_window;
-
-/* Last mouse-click event (nil if no mouse support).  */
-
-extern Lisp_Object Vmouse_event;
-
 extern Lisp_Object make_window (void);
 extern Lisp_Object window_from_coordinates (struct frame *, int, int,
                                             enum window_part *, bool);
 extern void resize_frame_windows (struct frame *, int, bool);
 extern void restore_window_configuration (Lisp_Object);
 extern void delete_all_child_windows (Lisp_Object);
-extern void freeze_window_starts (struct frame *, bool);
 extern void grow_mini_window (struct window *, int);
 extern void shrink_mini_window (struct window *);
 extern int window_relative_x_coord (struct window *, enum window_part, int);
@@ -925,10 +901,6 @@ extern int update_mode_lines;
 
 extern int windows_or_buffers_changed;
 
-/* Nonzero means a frame's cursor type has been changed.  */
-
-extern int cursor_type_changed;
-
 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
    minimum allowable size.  */
 
@@ -973,11 +945,28 @@ extern void replace_buffer_in_windows (Lisp_Object);
 extern void replace_buffer_in_windows_safely (Lisp_Object);
 /* This looks like a setter, but it is a bit special.  */
 extern void wset_buffer (struct window *, Lisp_Object);
+extern bool window_outdated (struct window *);
 extern void init_window_once (void);
 extern void init_window (void);
 extern void syms_of_window (void);
 extern void keys_of_window (void);
 
+/* Move cursor to row/column position VPOS/HPOS, pixel coordinates
+   Y/X. HPOS/VPOS are window-relative row and column numbers and X/Y
+   are window-relative pixel positions.  This is always done during
+   window update, so the position is the future output cursor position
+   for currently updated window W.  */
+
+WINDOW_INLINE void
+output_cursor_to (struct window *w, int vpos, int hpos, int y, int x)
+{
+  eassert (w);
+  w->output_cursor.hpos = hpos;
+  w->output_cursor.vpos = vpos;
+  w->output_cursor.x = x;
+  w->output_cursor.y = y;
+}
+
 INLINE_HEADER_END
 
 #endif /* not WINDOW_H_INCLUDED */
diff --git a/src/xdisp.c b/src/xdisp.c
index 7a1f03ce244..d78e78a58d3 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -524,7 +524,7 @@ int windows_or_buffers_changed;
 
 /* Nonzero means a frame's cursor type has been changed.  */
 
-int cursor_type_changed;
+static int cursor_type_changed;
 
 /* Nonzero after display_mode_line if %l was used and it displayed a
    line number.  */
@@ -804,7 +804,6 @@ static void pint2str (char *, int, ptrdiff_t);
 static void pint2hrstr (char *, int, ptrdiff_t);
 static struct text_pos run_window_scroll_functions (Lisp_Object,
                                                     struct text_pos);
-static void reconsider_clip_changes (struct window *, struct buffer *);
 static int text_outside_line_unchanged_p (struct window *,
                                           ptrdiff_t, ptrdiff_t);
 static void store_mode_line_noprop_char (char);
@@ -967,12 +966,12 @@ window_text_bottom_y (struct window *w)
   return height;
 }
 
-/* Return the pixel width of display area AREA of window W.  AREA < 0
-   means return the total width of W, not including fringes to
-   the left and right of the window.  */
+/* Return the pixel width of display area AREA of window W.
+   ANY_AREA means return the total width of W, not including
+   fringes to the left and right of the window.  */
 
 int
-window_box_width (struct window *w, int area)
+window_box_width (struct window *w, enum glyph_row_area area)
 {
   int cols = w->total_cols;
   int pixels = 0;
@@ -983,22 +982,18 @@ window_box_width (struct window *w, int area)
 
       if (area == TEXT_AREA)
         {
-          if (INTEGERP (w->left_margin_cols))
-            cols -= XFASTINT (w->left_margin_cols);
-          if (INTEGERP (w->right_margin_cols))
-            cols -= XFASTINT (w->right_margin_cols);
+          cols -= max (0, w->left_margin_cols);
+          cols -= max (0, w->right_margin_cols);
           pixels = -WINDOW_TOTAL_FRINGE_WIDTH (w);
         }
       else if (area == LEFT_MARGIN_AREA)
         {
-          cols = (INTEGERP (w->left_margin_cols)
-                   ? XFASTINT (w->left_margin_cols) : 0);
+          cols = max (0, w->left_margin_cols);
           pixels = 0;
         }
       else if (area == RIGHT_MARGIN_AREA)
         {
-          cols = (INTEGERP (w->right_margin_cols)
-                   ? XFASTINT (w->right_margin_cols) : 0);
+          cols = max (0, w->right_margin_cols);
           pixels = 0;
         }
     }
@@ -1054,11 +1049,11 @@ window_box_height (struct window *w)
 }
 
 /* Return the window-relative coordinate of the left edge of display
-   area AREA of window W.  AREA < 0 means return the left edge of the
+   area AREA of window W.  ANY_AREA means return the left edge of the
    whole window, to the right of the left fringe of W.  */
 
 int
-window_box_left_offset (struct window *w, int area)
+window_box_left_offset (struct window *w, enum glyph_row_area area)
 {
   int x;
 
@@ -1086,21 +1081,21 @@ window_box_left_offset (struct window *w, int area)
 
 
 /* Return the window-relative coordinate of the right edge of display
-   area AREA of window W.  AREA < 0 means return the right edge of the
+   area AREA of window W.  ANY_AREA means return the right edge of the
    whole window, to the left of the right fringe of W.  */
 
 int
-window_box_right_offset (struct window *w, int area)
+window_box_right_offset (struct window *w, enum glyph_row_area area)
 {
   return window_box_left_offset (w, area) + window_box_width (w, area);
 }
 
 /* Return the frame-relative coordinate of the left edge of display
-   area AREA of window W.  AREA < 0 means return the left edge of the
+   area AREA of window W.  ANY_AREA means return the left edge of the
    whole window, to the right of the left fringe of W.  */
 
 int
-window_box_left (struct window *w, int area)
+window_box_left (struct window *w, enum glyph_row_area area)
 {
   struct frame *f = XFRAME (w->frame);
   int x;
@@ -1116,25 +1111,25 @@ window_box_left (struct window *w, int area)
 
 
 /* Return the frame-relative coordinate of the right edge of display
-   area AREA of window W.  AREA < 0 means return the right edge of the
+   area AREA of window W.  ANY_AREA means return the right edge of the
    whole window, to the left of the right fringe of W.  */
 
 int
-window_box_right (struct window *w, int area)
+window_box_right (struct window *w, enum glyph_row_area area)
 {
   return window_box_left (w, area) + window_box_width (w, area);
 }
 
 /* Get the bounding box of the display area AREA of window W, without
-   mode lines, in frame-relative coordinates.  AREA < 0 means the
+   mode lines, in frame-relative coordinates.  ANY_AREA means the
    whole window, not including the left and right fringes of
    the window.  Return in *BOX_X and *BOX_Y the frame-relative pixel
    coordinates of the upper-left corner of the box.  Return in
    *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box.  */
 
 void
-window_box (struct window *w, int area, int *box_x, int *box_y,
-            int *box_width, int *box_height)
+window_box (struct window *w, enum glyph_row_area area, int *box_x,
+            int *box_y, int *box_width, int *box_height)
 {
   if (box_width)
     *box_width = window_box_width (w, area);
@@ -1152,19 +1147,18 @@ window_box (struct window *w, int area, int *box_x, int *box_y,
 
 
 /* Get the bounding box of the display area AREA of window W, without
-   mode lines.  AREA < 0 means the whole window, not including the
-   left and right fringe of the window.  Return in *TOP_LEFT_X
+   mode lines and both fringes of the window.  Return in *TOP_LEFT_X
    and TOP_LEFT_Y the frame-relative pixel coordinates of the
    upper-left corner of the box.  Return in *BOTTOM_RIGHT_X, and
    *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
    box.  */
 
 static void
-window_box_edges (struct window *w, int area, int *top_left_x, int *top_left_y,
-                   int *bottom_right_x, int *bottom_right_y)
+window_box_edges (struct window *w, int *top_left_x, int *top_left_y,
+                  int *bottom_right_x, int *bottom_right_y)
 {
-  window_box (w, area, top_left_x, top_left_y, bottom_right_x,
-              bottom_right_y);
+  window_box (w, ANY_AREA, top_left_x, top_left_y,
+              bottom_right_x, bottom_right_y);
   *bottom_right_x += *top_left_x;
   *bottom_right_y += *top_left_y;
 }
@@ -2466,7 +2460,16 @@ remember_mouse_glyph (struct frame *f, int gx, int gy, NativeRectangle *rect)
 
 #endif /* HAVE_WINDOW_SYSTEM */
 
-
+static void
+adjust_window_ends (struct window *w, struct glyph_row *row, bool current)
+{
+  eassert (w);
+  w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
+  w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
+  w->window_end_vpos
+    = MATRIX_ROW_VPOS (row, current ? w->current_matrix : w->desired_matrix);
+}
+
 /***********************************************************************
                         Lisp form evaluation
  ***********************************************************************/
@@ -2602,8 +2605,7 @@ check_window_end (struct window *w)
   if (!MINI_WINDOW_P (w) && w->window_end_valid)
     {
       struct glyph_row *row;
-      eassert ((row = MATRIX_ROW (w->current_matrix,
-                                  XFASTINT (w->window_end_vpos)),
+      eassert ((row = MATRIX_ROW (w->current_matrix, w->window_end_vpos),
                 !row->enabled_p
                 || MATRIX_ROW_DISPLAYS_TEXT_P (row)
                 || MATRIX_ROW_VPOS (row, w->current_matrix) == 0));
@@ -3909,10 +3911,14 @@ handle_face_prop (struct it *it)
           /* For strings from a `display' property, use the face at
              IT's current buffer position as the base face to merge
              with, so that overlay strings appear in the same face as
-             surrounding text, unless they specify their own
-             faces.  */
+             surrounding text, unless they specify their own faces.
+             For strings from wrap-prefix and line-prefix properties,
+             use the default face, possibly remapped via
+             Vface_remapping_alist.  */
           base_face_id = it->string_from_prefix_prop_p
-            ? DEFAULT_FACE_ID
+            ? (!NILP (Vface_remapping_alist)
+               ? lookup_basic_face (it->f, DEFAULT_FACE_ID)
+               : DEFAULT_FACE_ID)
             : underlying_face_id (it);
         }
 
@@ -5509,8 +5515,8 @@ next_overlay_string (struct it *it)
 static int
 compare_overlay_entries (const void *e1, const void *e2)
 {
-  struct overlay_entry *entry1 = (struct overlay_entry *) e1;
-  struct overlay_entry *entry2 = (struct overlay_entry *) e2;
+  struct overlay_entry const *entry1 = e1;
+  struct overlay_entry const *entry2 = e2;
   int result;
 
   if (entry1->after_string_p != entry2->after_string_p)
@@ -7043,7 +7049,9 @@ get_next_display_element (struct it *it)
                 }
             }
         }
-      else
+      /* next_element_from_display_vector sets this flag according to
+         faces of the display vector glyphs, see there.  */
+      else if (it->method != GET_FROM_DISPLAY_VECTOR)
         {
           int face_id = face_after_it_pos (it);
           it->end_of_box_run_p
@@ -7458,6 +7466,8 @@ static int
 next_element_from_display_vector (struct it *it)
 {
   Lisp_Object gc;
+  int prev_face_id = it->face_id;
+  int next_face_id;
 
   /* Precondition.  */
   eassert (it->dpvec && it->current.dpvec_index >= 0);
@@ -7470,6 +7480,8 @@ next_element_from_display_vector (struct it *it)
 
   if (GLYPH_CODE_P (gc))
     {
+      struct face *this_face, *prev_face, *next_face;
+
       it->c = GLYPH_CODE_CHAR (gc);
       it->len = CHAR_BYTES (it->c);
 
@@ -7485,6 +7497,41 @@ next_element_from_display_vector (struct it *it)
             it->face_id = merge_faces (it->f, Qt, lface_id,
                                        it->saved_face_id);
         }
+
+      /* Glyphs in the display vector could have the box face, so we
+         need to set the related flags in the iterator, as
+         appropriate.  */
+      this_face = FACE_FROM_ID (it->f, it->face_id);
+      prev_face = FACE_FROM_ID (it->f, prev_face_id);
+
+      /* Is this character the first character of a box-face run?  */
+      it->start_of_box_run_p = (this_face && this_face->box != FACE_NO_BOX
+                                && (!prev_face
+                                    || prev_face->box == FACE_NO_BOX));
+
+      /* For the last character of the box-face run, we need to look
+         either at the next glyph from the display vector, or at the
+         face we saw before the display vector.  */
+      next_face_id = it->saved_face_id;
+      if (it->current.dpvec_index < it->dpend - it->dpvec - 1)
+        {
+          if (it->dpvec_face_id >= 0)
+            next_face_id = it->dpvec_face_id;
+          else
+            {
+              int lface_id =
+                GLYPH_CODE_FACE (it->dpvec[it->current.dpvec_index + 1]);
+
+              if (lface_id > 0)
+                next_face_id = merge_faces (it->f, Qt, lface_id,
+                                            it->saved_face_id);
+            }
+        }
+      next_face = FACE_FROM_ID (it->f, next_face_id);
+      it->end_of_box_run_p = (this_face && this_face->box != FACE_NO_BOX
+                              && (!next_face
+                                  || next_face->box == FACE_NO_BOX));
+      it->face_box_p = this_face && this_face->box != FACE_NO_BOX;
     }
   else
     /* Display table entry is invalid.  Return a space.  */
@@ -9059,7 +9106,7 @@ move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos
       && it->current_x == it->last_visible_x - 1
       && it->c != '\n'
       && it->c != '\t'
-      && it->vpos < XFASTINT (it->w->window_end_vpos))
+      && it->vpos < it->w->window_end_vpos)
     {
       it->continuation_lines_width += it->current_x;
       it->current_x = it->hpos = it->max_ascent = it->max_descent = 0;
@@ -9790,7 +9837,7 @@ message3_nolog (Lisp_Object m)
 void
 message1 (const char *m)
 {
-  message3 (m ? make_unibyte_string (m, strlen (m)) : Qnil);
+  message3 (m ? build_unibyte_string (m) : Qnil);
 }
 
 
@@ -9799,7 +9846,7 @@ message1 (const char *m)
 void
 message1_nolog (const char *m)
 {
-  message3_nolog (m ? make_unibyte_string (m, strlen (m)) : Qnil);
+  message3_nolog (m ? build_unibyte_string (m) : Qnil);
 }
 
 /* Display a message M which contains a single %s
@@ -9909,7 +9956,7 @@ vmessage (const char *m, va_list ap)
               ptrdiff_t maxsize = FRAME_MESSAGE_BUF_SIZE (f);
               char *message_buf = alloca (maxsize + 1);
 
-              len = doprnt (message_buf, maxsize, m, (char *)0, ap);
+              len = doprnt (message_buf, maxsize, m, 0, ap);
 
               message3 (make_string (message_buf, len));
             }
@@ -10461,7 +10508,8 @@ resize_mini_window (struct window *w, int exact_p)
           if (height > WINDOW_TOTAL_LINES (w))
             {
               int old_height = WINDOW_TOTAL_LINES (w);
-              freeze_window_starts (f, 1);
+
+              FRAME_WINDOWS_FROZEN (f) = 1;
               grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
               window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
             }
@@ -10469,7 +10517,8 @@ resize_mini_window (struct window *w, int exact_p)
                    && (exact_p || BEGV == ZV))
             {
               int old_height = WINDOW_TOTAL_LINES (w);
-              freeze_window_starts (f, 0);
+
+              FRAME_WINDOWS_FROZEN (f) = 0;
               shrink_mini_window (w);
               window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
             }
@@ -10480,19 +10529,21 @@ resize_mini_window (struct window *w, int exact_p)
           if (height > WINDOW_TOTAL_LINES (w))
             {
               int old_height = WINDOW_TOTAL_LINES (w);
-              freeze_window_starts (f, 1);
+
+              FRAME_WINDOWS_FROZEN (f) = 1;
               grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
               window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
             }
           else if (height < WINDOW_TOTAL_LINES (w))
             {
               int old_height = WINDOW_TOTAL_LINES (w);
-              freeze_window_starts (f, 0);
+
+              FRAME_WINDOWS_FROZEN (f) = 0;
               shrink_mini_window (w);
 
               if (height)
                 {
-                  freeze_window_starts (f, 1);
+                  FRAME_WINDOWS_FROZEN (f) = 1;
                   grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
                 }
 
@@ -10850,17 +10901,6 @@ buffer_shared_and_changed (void)
           && UNCHANGED_MODIFIED < MODIFF);
 }
 
-/* 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->contents) != current_buffer, which looks suspicious.  */
-
-static int
-window_outdated (struct window *w)
-{
-  return (w->last_modified < MODIFF
-          || w->last_overlay_modified < OVERLAY_MODIFF);
-}
-
 /* Nonzero if W's buffer was changed but not saved or Transient Mark mode
    is enabled and mark of W's buffer was changed since last W's update.  */
 
@@ -10886,6 +10926,31 @@ mode_line_update_needed (struct window *w)
           && (w->column_number_displayed != current_column ()));
 }
 
+/* Nonzero if window start of W is frozen and may not be changed during
+   redisplay.  */
+
+static bool
+window_frozen_p (struct window *w)
+{
+  if (FRAME_WINDOWS_FROZEN (XFRAME (WINDOW_FRAME (w))))
+    {
+      Lisp_Object window;
+
+      XSETWINDOW (window, w);
+      if (MINI_WINDOW_P (w))
+        return 0;
+      else if (EQ (window, selected_window))
+        return 0;
+      else if (MINI_WINDOW_P (XWINDOW (selected_window))
+               && EQ (window, Vminibuf_scroll_window))
+        /* This special window can't be frozen too.  */
+        return 0;
+      else
+        return 1;
+    }
+  return 0;
+}
+
 /***********************************************************************
                      Mode Lines and Frame Titles
  ***********************************************************************/
@@ -11181,7 +11246,18 @@ prepare_menu_bars (void)
         {
           f = XFRAME (frame);
           if (!EQ (frame, tooltip_frame)
-              && (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f)))
+              && (FRAME_ICONIFIED_P (f)
+                  || FRAME_VISIBLE_P (f) == 1
+                  /* Exclude TTY frames that are obscured because they
+                     are not the top frame on their console.  This is
+                     because x_consider_frame_title actually switches
+                     to the frame, which for TTY frames means it is
+                     marked as garbaged, and will be completely
+                     redrawn on the next redisplay cycle.  This causes
+                     TTY frames to be completely redrawn, when there
+                     are more than one of them, even though nothing
+                     should be changed on display.  */
+                  || (FRAME_VISIBLE_P (f) == 2 && FRAME_WINDOW_P (f))))
             x_consider_frame_title (frame);
         }
     }
@@ -11368,79 +11444,6 @@ update_menu_bar (struct frame *f, int save_match_data, int hooks_run)
   return hooks_run;
 }
 
-
-
-/***********************************************************************
-                            Output Cursor
- ***********************************************************************/
-
-#ifdef HAVE_WINDOW_SYSTEM
-
-/* EXPORT:
-   Nominal cursor position -- where to draw output.
-   HPOS and VPOS are window relative glyph matrix coordinates.
-   X and Y are window relative pixel coordinates.  */
-
-struct cursor_pos output_cursor;
-
-
-/* EXPORT:
-   Set the global variable output_cursor to CURSOR.  All cursor
-   positions are relative to updated_window.  */
-
-void
-set_output_cursor (struct cursor_pos *cursor)
-{
-  output_cursor.hpos = cursor->hpos;
-  output_cursor.vpos = cursor->vpos;
-  output_cursor.x = cursor->x;
-  output_cursor.y = cursor->y;
-}
-
-
-/* EXPORT for RIF:
-   Set a nominal cursor position.
-
-   HPOS and VPOS are column/row positions in a window glyph matrix.  X
-   and Y are window text area relative pixel positions.
-
-   If this is done during an update, updated_window will contain the
-   window that is being updated and the position is the future output
-   cursor position for that window.  If updated_window is null, use
-   selected_window and display the cursor at the given position.  */
-
-void
-x_cursor_to (int vpos, int hpos, int y, int x)
-{
-  struct window *w;
-
-  /* If updated_window is not set, work on selected_window.  */
-  if (updated_window)
-    w = updated_window;
-  else
-    w = XWINDOW (selected_window);
-
-  /* Set the output cursor.  */
-  output_cursor.hpos = hpos;
-  output_cursor.vpos = vpos;
-  output_cursor.x = x;
-  output_cursor.y = y;
-
-  /* If not called as part of an update, really display the cursor.
-     This will also set the cursor position of W.  */
-  if (updated_window == NULL)
-    {
-      block_input ();
-      display_and_set_cursor (w, 1, hpos, vpos, x, y);
-      if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
-        FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
-      unblock_input ();
-    }
-}
-
-#endif /* HAVE_WINDOW_SYSTEM */
-
-
 /***********************************************************************
                                Tool-bars
  ***********************************************************************/
@@ -12324,13 +12327,11 @@ note_tool_bar_highlight (struct frame *f, int x, int y)
       hlinfo->mouse_face_beg_col = hpos;
       hlinfo->mouse_face_beg_row = vpos;
       hlinfo->mouse_face_beg_x = x;
-      hlinfo->mouse_face_beg_y = row->y;
       hlinfo->mouse_face_past_end = 0;
 
       hlinfo->mouse_face_end_col = hpos + 1;
       hlinfo->mouse_face_end_row = vpos;
       hlinfo->mouse_face_end_x = x + glyph->pixel_width;
-      hlinfo->mouse_face_end_y = row->y;
       hlinfo->mouse_face_window = window;
       hlinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
 
@@ -12866,13 +12867,13 @@ check_point_in_composition (struct buffer *prev_buf, ptrdiff_t prev_pt,
           && start < pt && end > pt);
 }
 
-
-/* Reconsider the setting of B->clip_changed which is displayed
-   in window W.  */
+/* Reconsider the clip changes of buffer which is displayed in W.  */
 
 static void
-reconsider_clip_changes (struct window *w, struct buffer *b)
+reconsider_clip_changes (struct window *w)
 {
+  struct buffer *b = XBUFFER (w->contents);
+
   if (b->clip_changed
       && w->window_end_valid
       && w->current_matrix->buffer == b
@@ -12885,24 +12886,17 @@ 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->contents) && w->window_end_valid)
+  if (!b->clip_changed && w->window_end_valid)
     {
-      ptrdiff_t pt;
-
-      if (w == XWINDOW (selected_window))
-        pt = PT;
-      else
-        pt = marker_position (w->pointm);
+      ptrdiff_t pt = (w == XWINDOW (selected_window)
+                      ? PT : marker_position (w->pointm));
 
-      if ((w->current_matrix->buffer != XBUFFER (w->contents)
-           || pt != w->last_point)
+      if ((w->current_matrix->buffer != b || pt != w->last_point)
           && check_point_in_composition (w->current_matrix->buffer,
-                                         w->last_point,
-                                         XBUFFER (w->contents), pt))
+                                         w->last_point, b, pt))
         b->clip_changed = 1;
     }
 }
-
 
 #define STOP_POLLING                                    \
 do { if (! polling_stopped_here) stop_polling ();       \
@@ -12923,10 +12917,10 @@ redisplay_internal (void)
   struct window *sw;
   struct frame *fr;
   int pending;
-  int must_finish = 0;
+  bool must_finish = 0, match_p;
   struct text_pos tlbufpos, tlendpos;
   int number_of_visible_frames;
-  ptrdiff_t count, count1;
+  ptrdiff_t count;
   struct frame *sf;
   int polling_stopped_here = 0;
   Lisp_Object tail, frame;
@@ -12983,7 +12977,6 @@ redisplay_internal (void)
   sw = w;
 
   pending = 0;
-  reconsider_clip_changes (w, current_buffer);
   last_escape_glyph_frame = NULL;
   last_escape_glyph_face_id = (1 << FACE_ID_BITS);
   last_glyphless_glyph_frame = NULL;
@@ -13038,10 +13031,7 @@ redisplay_internal (void)
   /* do_pending_window_change could change the selected_window due to
      frame resizing which makes the selected window too small.  */
   if (WINDOWP (selected_window) && (w = XWINDOW (selected_window)) != sw)
-    {
-      sw = w;
-      reconsider_clip_changes (w, current_buffer);
-    }
+    sw = w;
 
   /* Clear frames marked as garbaged.  */
   clear_garbaged_frames ();
@@ -13053,22 +13043,31 @@ redisplay_internal (void)
   if (windows_or_buffers_changed)
     update_mode_lines++;
 
-  /* Detect case that we need to write or remove a star in the mode line.  */
-  if ((SAVE_MODIFF < MODIFF) != w->last_had_star)
+  reconsider_clip_changes (w);
+
+  /* In most cases selected window displays current buffer.  */
+  match_p = XBUFFER (w->contents) == current_buffer;
+  if (match_p)
     {
-      w->update_mode_line = 1;
-      if (buffer_shared_and_changed ())
-        update_mode_lines++;
-    }
+      ptrdiff_t count1;
 
-  /* Avoid invocation of point motion hooks by `current_column' below.  */
-  count1 = SPECPDL_INDEX ();
-  specbind (Qinhibit_point_motion_hooks, Qt);
+      /* Detect case that we need to write or remove a star in the mode line.  */
+      if ((SAVE_MODIFF < MODIFF) != w->last_had_star)
+        {
+          w->update_mode_line = 1;
+          if (buffer_shared_and_changed ())
+            update_mode_lines++;
+        }
 
-  if (mode_line_update_needed (w))
-    w->update_mode_line = 1;
+      /* Avoid invocation of point motion hooks by `current_column' below.  */
+      count1 = SPECPDL_INDEX ();
+      specbind (Qinhibit_point_motion_hooks, Qt);
 
-  unbind_to (count1, Qnil);
+      if (mode_line_update_needed (w))
+        w->update_mode_line = 1;
+
+      unbind_to (count1, Qnil);
+    }
 
   consider_all_windows_p = (update_mode_lines
                             || buffer_shared_and_changed ()
@@ -13167,7 +13166,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->contents)
+      && match_p
       && !w->force_start
       && !w->optional_new_start
       /* Point must be on the line that we have info recorded about.  */
@@ -13263,12 +13262,12 @@ redisplay_internal (void)
                  adjusted.  */
               if (MATRIX_ROW_DISPLAYS_TEXT_P (it.glyph_row - 1))
                 {
-                  if (XFASTINT (w->window_end_vpos) < this_line_vpos)
-                    wset_window_end_vpos (w, make_number (this_line_vpos));
+                  if (w->window_end_vpos < this_line_vpos)
+                    w->window_end_vpos = this_line_vpos;
                 }
-              else if (XFASTINT (w->window_end_vpos) == this_line_vpos
+              else if (w->window_end_vpos == this_line_vpos
                        && this_line_vpos > 0)
-                wset_window_end_vpos (w, make_number (this_line_vpos - 1));
+                w->window_end_vpos = this_line_vpos - 1;
               w->window_end_valid = 0;
 
               /* Update hint: No need to try to scroll in update_window.  */
@@ -13685,7 +13684,7 @@ mark_window_display_accurate_1 (struct window *w, int accurate_p)
       w->current_matrix->begv = BUF_BEGV (b);
       w->current_matrix->zv = BUF_ZV (b);
 
-      w->last_cursor = w->cursor;
+      w->last_cursor_vpos = w->cursor.vpos;
       w->last_cursor_off_p = w->cursor_off_p;
 
       if (w == XWINDOW (selected_window))
@@ -14458,8 +14457,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->contents))
-    emacs_abort ();
+  eassert (current_buffer == XBUFFER (w->contents));
 
   if (!NILP (Vwindow_scroll_functions))
     {
@@ -14900,7 +14898,25 @@ compute_window_start_on_continuation_line (struct window *w)
             {
               min_distance = distance;
               pos = it.current.pos;
-              move_it_by_lines (&it, 1);
+              if (it.line_wrap == WORD_WRAP)
+                {
+                  /* Under WORD_WRAP, move_it_by_lines is likely to
+                     overshoot and stop not at the first, but the
+                     second character from the left margin.  So in
+                     that case, we need a more tight control on the X
+                     coordinate of the iterator than move_it_by_lines
+                     promises in its contract.  The method is to first
+                     go to the last (rightmost) visible character of a
+                     line, then move to the leftmost character on the
+                     next line in a separate call.  */
+                  move_it_to (&it, ZV, it.last_visible_x, it.current_y, -1,
+                              MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
+                  move_it_to (&it, ZV, 0,
+                              it.current_y + it.max_ascent + it.max_descent, -1,
+                              MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
+                }
+              else
+                move_it_by_lines (&it, 1);
             }
 
           /* Set the window start there.  */
@@ -14952,6 +14968,10 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
      if-statement below. Now, this field is converted to
      ptrdiff_t, thus zero means invalid position in a buffer.  */
   eassert (w->last_point > 0);
+  /* Likewise there was a check whether window_end_vpos is nil or larger
+     than the window.  Now window_end_vpos is int and so never nil, but
+     let's leave eassert to check whether it fits in the window.  */
+  eassert (w->window_end_vpos < w->current_matrix->nrows);
 
   /* Handle case where text has not changed, only point, and it has
      not moved off the frame.  */
@@ -14979,13 +14999,6 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
          since the handling of this_line_start_pos, etc., in redisplay
          handles the same cases.  */
       && !EQ (window, minibuf_window)
-      /* When splitting windows or for new windows, it happens that
-         redisplay is called with a nil window_end_vpos or one being
-         larger than the window.  This should really be fixed in
-         window.c.  I don't have this on my list, now, so we do
-         approximately the same as the old redisplay code.  --gerd.  */
-      && INTEGERP (w->window_end_vpos)
-      && XFASTINT (w->window_end_vpos) < w->current_matrix->nrows
       && (FRAME_WINDOW_P (f)
           || !overlay_arrow_in_current_buffer_p ()))
     {
@@ -15015,12 +15028,12 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
 
       /* Start with the row the cursor was displayed during the last
          not paused redisplay.  Give up if that row is not valid.  */
-      if (w->last_cursor.vpos < 0
-          || w->last_cursor.vpos >= w->current_matrix->nrows)
+      if (w->last_cursor_vpos < 0
+          || w->last_cursor_vpos >= w->current_matrix->nrows)
         rc = CURSOR_MOVEMENT_MUST_SCROLL;
       else
         {
-          row = MATRIX_ROW (w->current_matrix, w->last_cursor.vpos);
+          row = MATRIX_ROW (w->current_matrix, w->last_cursor_vpos);
           if (row->mode_line_p)
             ++row;
           if (!row->enabled_p)
@@ -15299,7 +15312,7 @@ set_vertical_scroll_bar (struct window *w)
       start = marker_position (w->start) - BUF_BEGV (buf);
       /* I don't think this is guaranteed to be right.  For the
          moment, we'll pretend it is.  */
-      end = BUF_Z (buf) - XFASTINT (w->window_end_pos) - BUF_BEGV (buf);
+      end = BUF_Z (buf) - w->window_end_pos - BUF_BEGV (buf);
 
       if (end < start)
         end = start;
@@ -15360,7 +15373,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   eassert (XMARKER (w->pointm)->buffer == buffer);
 
  restart:
-  reconsider_clip_changes (w, buffer);
+  reconsider_clip_changes (w);
   frame_line_height = default_line_pixel_height (w);
 
   /* Has the mode line to be updated?  */
@@ -15440,8 +15453,8 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
        && !current_buffer->clip_changed
        && !window_outdated (w));
 
-  /* When windows_or_buffers_changed is non-zero, we can't rely on
-     the window end being valid, so set it to nil there.  */
+  /* When windows_or_buffers_changed is non-zero, we can't rely
+     on the window end being valid, so set it to zero there.  */
   if (windows_or_buffers_changed)
     {
       /* If window starts on a continuation line, maybe adjust the
@@ -15450,6 +15463,9 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
         compute_window_start_on_continuation_line (w);
 
       w->window_end_valid = 0;
+      /* If so, we also can't rely on current matrix
+         and should not fool try_cursor_movement below.  */
+      current_matrix_up_to_date_p = 0;
     }
 
   /* Some sanity checks.  */
@@ -15531,7 +15547,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
   /* Handle case where place to start displaying has been specified,
      unless the specified location is outside the accessible range.  */
-  if (w->force_start || w->frozen_window_start_p)
+  if (w->force_start || window_frozen_p (w))
     {
       /* We set this later on if we have to adjust point.  */
       int new_vpos = -1;
@@ -15559,8 +15575,6 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
           startp = run_window_scroll_functions (window, startp);
         }
 
-      w->last_modified = 0;
-      w->last_overlay_modified = 0;
       if (CHARPOS (startp) < BEGV)
         SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
       else if (CHARPOS (startp) > ZV)
@@ -15578,7 +15592,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
           goto need_larger_matrices;
         }
 
-      if (w->cursor.vpos < 0 && !w->frozen_window_start_p)
+      if (w->cursor.vpos < 0 && !window_frozen_p (w))
         {
           /* If point does not appear, try to move point so it does
              appear. The desired matrix has been built above, so we
@@ -15806,9 +15820,6 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
  try_to_scroll:
 
-  w->last_modified = 0;
-  w->last_overlay_modified = 0;
-
   /* Redisplay the mode line.  Select the buffer properly for that.  */
   if (!update_mode_line)
     {
@@ -15994,7 +16005,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
      line.)  */
   if (w->cursor.vpos < 0)
     {
-      if (w->window_end_valid && PT >= Z - XFASTINT (w->window_end_pos))
+      if (w->window_end_valid && PT >= Z - w->window_end_pos)
         {
           clear_glyph_matrix (w->desired_matrix);
           move_it_by_lines (&it, 1);
@@ -16287,8 +16298,7 @@ try_window (Lisp_Object window, struct text_pos pos, int flags)
     }
 
   /* If bottom moved off end of frame, change mode line percentage.  */
-  if (XFASTINT (w->window_end_pos) <= 0
-      && Z != IT_CHARPOS (it))
+  if (w->window_end_pos <= 0 && Z != IT_CHARPOS (it))
     w->update_mode_line = 1;
 
   /* Set window_end_pos to the offset of the last character displayed
@@ -16297,21 +16307,16 @@ try_window (Lisp_Object window, struct text_pos pos, int flags)
   if (last_text_row)
     {
       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row));
-      w->window_end_bytepos
-        = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
-      wset_window_end_pos
-        (w, make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
-      wset_window_end_vpos
-        (w, make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix)));
+      adjust_window_ends (w, last_text_row, 0);
       eassert
         (MATRIX_ROW_DISPLAYS_TEXT_P (MATRIX_ROW (w->desired_matrix,
-                                                 XFASTINT (w->window_end_vpos))));
+                                                 w->window_end_vpos)));
     }
   else
     {
       w->window_end_bytepos = Z_BYTE - ZV_BYTE;
-      wset_window_end_pos (w, make_number (Z - ZV));
-      wset_window_end_vpos (w, make_number (0));
+      w->window_end_pos = Z - ZV;
+      w->window_end_vpos = 0;
     }
 
   /* But that is not valid info until redisplay finishes.  */
@@ -16535,32 +16540,15 @@ try_window_reusing_current_matrix (struct window *w)
          The value of last_text_row is the last displayed line
          containing text.  */
       if (last_reused_text_row)
-        {
-          w->window_end_bytepos
-            = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_reused_text_row);
-          wset_window_end_pos
-            (w, make_number (Z
-                             - MATRIX_ROW_END_CHARPOS (last_reused_text_row)));
-          wset_window_end_vpos
-            (w, make_number (MATRIX_ROW_VPOS (last_reused_text_row,
-                                              w->current_matrix)));
-        }
+        adjust_window_ends (w, last_reused_text_row, 1);
       else if (last_text_row)
-        {
-          w->window_end_bytepos
-            = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
-          wset_window_end_pos
-            (w, make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
-          wset_window_end_vpos
-            (w, make_number (MATRIX_ROW_VPOS (last_text_row,
-                                              w->desired_matrix)));
-        }
+        adjust_window_ends (w, last_text_row, 0);
       else
         {
           /* This window must be completely empty.  */
           w->window_end_bytepos = Z_BYTE - ZV_BYTE;
-          wset_window_end_pos (w, make_number (Z - ZV));
-          wset_window_end_vpos (w, make_number (0));
+          w->window_end_pos = Z - ZV;
+          w->window_end_vpos = 0;
         }
       w->window_end_valid = 0;
 
@@ -16745,20 +16733,9 @@ try_window_reusing_current_matrix (struct window *w)
          the window end is in reused rows which in turn means that
          only its vpos can have changed.  */
       if (last_text_row)
-        {
-          w->window_end_bytepos
-            = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
-          wset_window_end_pos
-            (w, make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
-          wset_window_end_vpos
-            (w, make_number (MATRIX_ROW_VPOS (last_text_row,
-                                              w->desired_matrix)));
-        }
+        adjust_window_ends (w, last_text_row, 0);
       else
-        {
-          wset_window_end_vpos
-            (w, make_number (XFASTINT (w->window_end_vpos) - nrows_scrolled));
-        }
+        w->window_end_vpos -= nrows_scrolled;
 
       w->window_end_valid = 0;
       w->desired_matrix->no_scrolling_p = 1;
@@ -16898,11 +16875,11 @@ find_first_unchanged_at_end_row (struct window *w,
   /* A value of window_end_pos >= END_UNCHANGED means that the window
      end is in the range of changed text.  If so, there is no
      unchanged row at the end of W's current matrix.  */
-  if (XFASTINT (w->window_end_pos) >= END_UNCHANGED)
+  if (w->window_end_pos >= END_UNCHANGED)
     return NULL;
 
   /* Set row to the last row in W's current matrix displaying text.  */
-  row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
+  row = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 
   /* If matrix is entirely empty, no unchanged row exists.  */
   if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
@@ -16913,7 +16890,7 @@ find_first_unchanged_at_end_row (struct window *w,
          buffer positions in the current matrix to current buffer
          positions for characters not in changed text.  */
       ptrdiff_t Z_old =
-        MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
+        MATRIX_ROW_END_CHARPOS (row) + w->window_end_pos;
       ptrdiff_t Z_BYTE_old =
         MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
       ptrdiff_t last_unchanged_pos, last_unchanged_pos_old;
@@ -17247,7 +17224,7 @@ try_window_id (struct window *w)
      This case happens with stealth-fontification.  Note that although
      the display is unchanged, glyph positions in the matrix have to
      be adjusted, of course.  */
-  row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
+  row = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
   if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
       && ((last_changed_charpos < CHARPOS (start)
            && CHARPOS (start) == BEGV)
@@ -17259,7 +17236,7 @@ try_window_id (struct window *w)
 
       /* Compute how many chars/bytes have been added to or removed
          from the buffer.  */
-      Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
+      Z_old = MATRIX_ROW_END_CHARPOS (row) + w->window_end_pos;
       Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
       Z_delta = Z - Z_old;
       Z_delta_bytes = Z_BYTE - Z_BYTE_old;
@@ -17330,10 +17307,8 @@ try_window_id (struct window *w)
         {
           /* We have to compute the window end anew since text
              could have been added/removed after it.  */
-          wset_window_end_pos
-            (w, make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
-          w->window_end_bytepos
-            = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
+          w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
+          w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
 
           /* Set the cursor.  */
           row = row_containing_pos (w, PT, r0, NULL, 0);
@@ -17366,7 +17341,7 @@ try_window_id (struct window *w)
 
   /* Give up if the window ends in strings.  Overlay strings
      at the end are difficult to handle, so don't try.  */
-  row = MATRIX_ROW (current_matrix, XFASTINT (w->window_end_vpos));
+  row = MATRIX_ROW (current_matrix, w->window_end_vpos);
   if (MATRIX_ROW_START_CHARPOS (row) == MATRIX_ROW_END_CHARPOS (row))
     GIVE_UP (20);
 
@@ -17712,7 +17687,7 @@ try_window_id (struct window *w)
       /* Set last_row to the glyph row in the current matrix where the
          window end line is found.  It has been moved up or down in
          the matrix by dvpos.  */
-      int last_vpos = XFASTINT (w->window_end_vpos) + dvpos;
+      int last_vpos = w->window_end_vpos + dvpos;
       struct glyph_row *last_row = MATRIX_ROW (current_matrix, last_vpos);
 
       /* If last_row is the window end line, it should display text.  */
@@ -17756,8 +17731,7 @@ try_window_id (struct window *w)
     }
 
   /* Update window_end_pos and window_end_vpos.  */
-  if (first_unchanged_at_end_row
-      && !last_text_row_at_end)
+  if (first_unchanged_at_end_row && !last_text_row_at_end)
     {
       /* Window end line if one of the preserved rows from the current
          matrix.  Set row to the last row displaying text in current
@@ -17767,23 +17741,13 @@ try_window_id (struct window *w)
       row = find_last_row_displaying_text (w->current_matrix, &it,
                                            first_unchanged_at_end_row);
       eassert (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
-
-      wset_window_end_pos (w, make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
-      w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
-      wset_window_end_vpos
-        (w, make_number (MATRIX_ROW_VPOS (row, w->current_matrix)));
+      adjust_window_ends (w, row, 1);
       eassert (w->window_end_bytepos >= 0);
       IF_DEBUG (debug_method_add (w, "A"));
     }
   else if (last_text_row_at_end)
     {
-      wset_window_end_pos
-        (w, make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end)));
-      w->window_end_bytepos
-        = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row_at_end);
-      wset_window_end_vpos
-        (w, make_number (MATRIX_ROW_VPOS (last_text_row_at_end,
-                                          desired_matrix)));
+      adjust_window_ends (w, last_text_row_at_end, 0);
       eassert (w->window_end_bytepos >= 0);
       IF_DEBUG (debug_method_add (w, "B"));
     }
@@ -17792,12 +17756,7 @@ try_window_id (struct window *w)
       /* We have displayed either to the end of the window or at the
          end of the window, i.e. the last row with text is to be found
          in the desired matrix.  */
-      wset_window_end_pos
-        (w, make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row)));
-      w->window_end_bytepos
-        = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
-      wset_window_end_vpos
-        (w, make_number (MATRIX_ROW_VPOS (last_text_row, desired_matrix)));
+      adjust_window_ends (w, last_text_row, 0);
       eassert (w->window_end_bytepos >= 0);
     }
   else if (first_unchanged_at_end_row == NULL
@@ -17807,7 +17766,7 @@ try_window_id (struct window *w)
       /* Displayed to end of window, but no line containing text was
          displayed.  Lines were deleted at the end of the window.  */
       int first_vpos = WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
-      int vpos = XFASTINT (w->window_end_vpos);
+      int vpos = w->window_end_vpos;
       struct glyph_row *current_row = current_matrix->rows + vpos;
       struct glyph_row *desired_row = desired_matrix->rows + vpos;
 
@@ -17825,8 +17784,8 @@ try_window_id (struct window *w)
         }
 
       eassert (row != NULL);
-      wset_window_end_vpos (w, make_number (vpos + 1));
-      wset_window_end_pos (w, make_number (Z - MATRIX_ROW_END_CHARPOS (row)));
+      w->window_end_vpos = vpos + 1;
+      w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
       w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
       eassert (w->window_end_bytepos >= 0);
       IF_DEBUG (debug_method_add (w, "C"));
@@ -17834,8 +17793,8 @@ try_window_id (struct window *w)
   else
     emacs_abort ();
 
-  IF_DEBUG (debug_end_pos = XFASTINT (w->window_end_pos);
-            debug_end_vpos = XFASTINT (w->window_end_vpos));
+  IF_DEBUG (debug_end_pos = w->window_end_pos;
+            debug_end_vpos = w->window_end_vpos);
 
   /* Record that display has not been completed.  */
   w->window_end_valid = 0;
@@ -20115,7 +20074,7 @@ Value is the new character position of point.  */)
   (Lisp_Object direction)
 {
   struct window *w = XWINDOW (selected_window);
-  struct buffer *b = NULL;
+  struct buffer *b = XBUFFER (w->contents);
   struct glyph_row *row;
   int dir;
   Lisp_Object paragraph_dir;
@@ -20135,9 +20094,6 @@ Value is the new character position of point.  */)
   else
     dir = -1;
 
-  if (BUFFERP (w->contents))
-    b = XBUFFER (w->contents);
-
   /* If current matrix is up-to-date, we can use the information
      recorded in the glyphs, at least as long as the goal is on the
      screen.  */
@@ -20146,8 +20102,7 @@ Value is the new character position of point.  */)
       && b
       && !b->clip_changed
       && !b->prevent_redisplay_optimizations_p
-      && w->last_modified >= BUF_MODIFF (b)
-      && w->last_overlay_modified >= BUF_OVERLAY_MODIFF (b)
+      && !window_outdated (w)
       && w->cursor.vpos >= 0
       && w->cursor.vpos < w->current_matrix->nrows
       && (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos))->enabled_p)
@@ -20651,13 +20606,8 @@ redisplay_mode_lines (Lisp_Object window, int force)
             {
               struct text_pos pt;
 
-              SET_TEXT_POS_FROM_MARKER (pt, w->pointm);
-              if (CHARPOS (pt) < BEGV)
-                TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
-              else if (CHARPOS (pt) > (ZV - 1))
-                TEMP_SET_PT_BOTH (ZV, ZV_BYTE);
-              else
-                TEMP_SET_PT_BOTH (CHARPOS (pt), BYTEPOS (pt));
+              CLIP_TEXT_POS_FROM_MARKER (pt, w->pointm);
+              TEMP_SET_PT_BOTH (CHARPOS (pt), BYTEPOS (pt));
             }
 
           /* Display mode lines.  */
@@ -22007,7 +21957,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
         ptrdiff_t pos = marker_position (w->start);
         ptrdiff_t total = BUF_ZV (b) - BUF_BEGV (b);
 
-        if (XFASTINT (w->window_end_pos) <= BUF_Z (b) - BUF_ZV (b))
+        if (w->window_end_pos <= BUF_Z (b) - BUF_ZV (b))
           {
             if (pos <= BUF_BEGV (b))
               return "All";
@@ -22036,7 +21986,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
     case 'P':
       {
         ptrdiff_t toppos = marker_position (w->start);
-        ptrdiff_t botpos = BUF_Z (b) - XFASTINT (w->window_end_pos);
+        ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
         ptrdiff_t total = BUF_ZV (b) - BUF_BEGV (b);
 
         if (botpos >= BUF_ZV (b))
@@ -23856,17 +23806,15 @@ draw_glyphs (struct window *w, int x, struct glyph_row *row,
           && hlinfo->mouse_face_beg_row >= 0
           && hlinfo->mouse_face_end_row >= 0)
         {
-          struct glyph_row *mouse_beg_row, *mouse_end_row;
-
-          mouse_beg_row = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_beg_row);
-          mouse_end_row = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_end_row);
+          ptrdiff_t row_vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
 
-          if (row >= mouse_beg_row && row <= mouse_end_row)
+          if (row_vpos >= hlinfo->mouse_face_beg_row
+              && row_vpos <= hlinfo->mouse_face_end_row)
             {
               check_mouse_face = 1;
-              mouse_beg_col = (row == mouse_beg_row)
+              mouse_beg_col = (row_vpos == hlinfo->mouse_face_beg_row)
                 ? hlinfo->mouse_face_beg_col : 0;
-              mouse_end_col = (row == mouse_end_row)
+              mouse_end_col = (row_vpos == hlinfo->mouse_face_end_row)
                 ? hlinfo->mouse_face_end_col
                 : row->used[TEXT_AREA];
             }
@@ -25757,17 +25705,16 @@ x_produce_glyphs (struct it *it)
 
 /* EXPORT for RIF:
    Output LEN glyphs starting at START at the nominal cursor position.
-   Advance the nominal cursor over the text.  The global variable
-   updated_window contains the window being updated, updated_row is
-   the glyph row being updated, and updated_area is the area of that
-   row being updated.  */
+   Advance the nominal cursor over the text.  UPDATED_ROW is the glyph row
+   being updated, and UPDATED_AREA is the area of that row being updated.  */
 
 void
-x_write_glyphs (struct glyph *start, int len)
+x_write_glyphs (struct window *w, struct glyph_row *updated_row,
+                struct glyph *start, enum glyph_row_area updated_area, int len)
 {
-  int x, hpos, chpos = updated_window->phys_cursor.hpos;
+  int x, hpos, chpos = w->phys_cursor.hpos;
 
-  eassert (updated_window && updated_row);
+  eassert (updated_row);
   /* When the window is hscrolled, cursor hpos can legitimately be out
      of bounds, but we draw the cursor at the corresponding window
      margin in that case.  */
@@ -25781,24 +25728,24 @@ x_write_glyphs (struct glyph *start, int len)
   /* Write glyphs.  */
 
   hpos = start - updated_row->glyphs[updated_area];
-  x = draw_glyphs (updated_window, output_cursor.x,
+  x = draw_glyphs (w, w->output_cursor.x,
                    updated_row, updated_area,
                    hpos, hpos + len,
                    DRAW_NORMAL_TEXT, 0);
 
   /* Invalidate old phys cursor if the glyph at its hpos is redrawn.  */
   if (updated_area == TEXT_AREA
-      && updated_window->phys_cursor_on_p
-      && updated_window->phys_cursor.vpos == output_cursor.vpos
+      && w->phys_cursor_on_p
+      && w->phys_cursor.vpos == w->output_cursor.vpos
       && chpos >= hpos
       && chpos < hpos + len)
-    updated_window->phys_cursor_on_p = 0;
+    w->phys_cursor_on_p = 0;
 
   unblock_input ();
 
   /* Advance the output cursor.  */
-  output_cursor.hpos += len;
-  output_cursor.x = x;
+  w->output_cursor.hpos += len;
+  w->output_cursor.x = x;
 }
 
 
@@ -25806,19 +25753,18 @@ x_write_glyphs (struct glyph *start, int len)
    Insert LEN glyphs from START at the nominal cursor position.  */
 
 void
-x_insert_glyphs (struct glyph *start, int len)
+x_insert_glyphs (struct window *w, struct glyph_row *updated_row,
+                 struct glyph *start, enum glyph_row_area updated_area, int len)
 {
   struct frame *f;
-  struct window *w;
   int line_height, shift_by_width, shifted_region_width;
   struct glyph_row *row;
   struct glyph *glyph;
   int frame_x, frame_y;
   ptrdiff_t hpos;
 
-  eassert (updated_window && updated_row);
+  eassert (updated_row);
   block_input ();
-  w = updated_window;
   f = XFRAME (WINDOW_FRAME (w));
 
   /* Get the height of the line we are in.  */
@@ -25832,25 +25778,25 @@ x_insert_glyphs (struct glyph *start, int len)
 
   /* Get the width of the region to shift right.  */
   shifted_region_width = (window_box_width (w, updated_area)
-                          - output_cursor.x
+                          - w->output_cursor.x
                           - shift_by_width);
 
   /* Shift right.  */
-  frame_x = window_box_left (w, updated_area) + output_cursor.x;
-  frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, output_cursor.y);
+  frame_x = window_box_left (w, updated_area) + w->output_cursor.x;
+  frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, w->output_cursor.y);
 
   FRAME_RIF (f)->shift_glyphs_for_insert (f, frame_x, frame_y, shifted_region_width,
                                           line_height, shift_by_width);
 
   /* Write the glyphs.  */
   hpos = start - row->glyphs[updated_area];
-  draw_glyphs (w, output_cursor.x, row, updated_area,
+  draw_glyphs (w, w->output_cursor.x, row, updated_area,
                hpos, hpos + len,
                DRAW_NORMAL_TEXT, 0);
 
   /* Advance the output cursor.  */
-  output_cursor.hpos += len;
-  output_cursor.x += shift_by_width;
+  w->output_cursor.hpos += len;
+  w->output_cursor.x += shift_by_width;
   unblock_input ();
 }
 
@@ -25860,18 +25806,18 @@ x_insert_glyphs (struct glyph *start, int len)
    (inclusive) to pixel column TO_X (exclusive).  The idea is that
    everything from TO_X onward is already erased.
 
-   TO_X is a pixel position relative to updated_area of
-   updated_window.  TO_X == -1 means clear to the end of this area.  */
+   TO_X is a pixel position relative to UPDATED_AREA of currently
+   updated window W.  TO_X == -1 means clear to the end of this area.  */
 
 void
-x_clear_end_of_line (int to_x)
+x_clear_end_of_line (struct window *w, struct glyph_row *updated_row,
+                     enum glyph_row_area updated_area, int to_x)
 {
   struct frame *f;
-  struct window *w = updated_window;
   int max_x, min_y, max_y;
   int from_x, from_y, to_y;
 
-  eassert (updated_window && updated_row);
+  eassert (updated_row);
   f = XFRAME (w->frame);
 
   if (updated_row->full_width_p)
@@ -25889,16 +25835,16 @@ x_clear_end_of_line (int to_x)
   else
     to_x = min (to_x, max_x);
 
-  to_y = min (max_y, output_cursor.y + updated_row->height);
+  to_y = min (max_y, w->output_cursor.y + updated_row->height);
 
   /* Notice if the cursor will be cleared by this operation.  */
   if (!updated_row->full_width_p)
     notice_overwritten_cursor (w, updated_area,
-                               output_cursor.x, -1,
+                               w->output_cursor.x, -1,
                                updated_row->y,
                                MATRIX_ROW_BOTTOM_Y (updated_row));
 
-  from_x = output_cursor.x;
+  from_x = w->output_cursor.x;
 
   /* Translate to frame coordinates.  */
   if (updated_row->full_width_p)
@@ -25914,7 +25860,7 @@ x_clear_end_of_line (int to_x)
     }
 
   min_y = WINDOW_HEADER_LINE_HEIGHT (w);
-  from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
+  from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, w->output_cursor.y));
   to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
 
   /* Prevent inadvertently clearing to end of the X window.  */
@@ -26010,6 +25956,9 @@ set_frame_cursor_types (struct frame *f, Lisp_Object arg)
     }
   else
     FRAME_BLINK_OFF_CURSOR (f) = DEFAULT_CURSOR;
+
+  /* Make sure the cursor gets redrawn.  */
+  cursor_type_changed = 1;
 }
 
 
@@ -26458,7 +26407,7 @@ erase_phys_cursor (struct window *w)
    where to put the cursor is specified by HPOS, VPOS, X and Y.  */
 
 void
-display_and_set_cursor (struct window *w, int on,
+display_and_set_cursor (struct window *w, bool on,
                         int hpos, int vpos, int x, int y)
 {
   struct frame *f = XFRAME (w->frame);
@@ -26542,7 +26491,7 @@ display_and_set_cursor (struct window *w, int on,
    of ON.  */
 
 static void
-update_window_cursor (struct window *w, int on)
+update_window_cursor (struct window *w, bool on)
 {
   /* Don't update cursor in windows whose frame is in the process
      of being deleted.  */
@@ -26578,7 +26527,7 @@ update_window_cursor (struct window *w, int on)
    in the window tree rooted at W.  */
 
 static void
-update_cursor_in_window_tree (struct window *w, int on_p)
+update_cursor_in_window_tree (struct window *w, bool on_p)
 {
   while (w)
     {
@@ -26597,7 +26546,7 @@ update_cursor_in_window_tree (struct window *w, int on_p)
    Don't change the cursor's position.  */
 
 void
-x_update_cursor (struct frame *f, int on_p)
+x_update_cursor (struct frame *f, bool on_p)
 {
   update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
 }
@@ -26784,10 +26733,7 @@ clear_mouse_face (Mouse_HLInfo *hlinfo)
       cleared = 1;
     }
 
-  hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-  hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-  hlinfo->mouse_face_window = Qnil;
-  hlinfo->mouse_face_overlay = Qnil;
+  reset_mouse_highlight (hlinfo);
   return cleared;
 }
 
@@ -27048,7 +26994,7 @@ mouse_face_from_buffer_pos (Lisp_Object window,
   /* Find the rows corresponding to START_CHARPOS and END_CHARPOS.  */
   rows_from_pos_range (w, start_charpos, end_charpos, disp_string, &r1, &r2);
   if (r1 == NULL)
-    r1 = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
+    r1 = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
   /* If the before-string or display-string contains newlines,
      rows_from_pos_range skips to its last row.  Move back.  */
   if (!NILP (before_string) || !NILP (disp_string))
@@ -27070,7 +27016,7 @@ mouse_face_from_buffer_pos (Lisp_Object window,
     }
   if (r2 == NULL)
     {
-      r2 = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
+      r2 = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
       hlinfo->mouse_face_past_end = 1;
     }
   else if (!NILP (after_string))
@@ -27078,7 +27024,7 @@ mouse_face_from_buffer_pos (Lisp_Object window,
       /* If the after-string has newlines, advance to its last row.  */
       struct glyph_row *next;
       struct glyph_row *last
-        = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
+        = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 
       for (next = r2 + 1;
            next <= last
@@ -27100,9 +27046,7 @@ mouse_face_from_buffer_pos (Lisp_Object window,
       r1 = tem;
     }
 
-  hlinfo->mouse_face_beg_y = r1->y;
   hlinfo->mouse_face_beg_row = MATRIX_ROW_VPOS (r1, w->current_matrix);
-  hlinfo->mouse_face_end_y = r2->y;
   hlinfo->mouse_face_end_row = MATRIX_ROW_VPOS (r2, w->current_matrix);
 
   /* For a bidi-reordered row, the positions of BEFORE_STRING,
@@ -27466,7 +27410,6 @@ mouse_face_from_string_pos (struct window *w, Mouse_HLInfo *hlinfo,
               {
                 hlinfo->mouse_face_beg_row
                   = MATRIX_ROW_VPOS (r, w->current_matrix);
-                hlinfo->mouse_face_beg_y = r->y;
                 hlinfo->mouse_face_beg_col = g - r->glyphs[TEXT_AREA];
                 hlinfo->mouse_face_beg_x = gx;
                 found = 1;
@@ -27485,7 +27428,6 @@ mouse_face_from_string_pos (struct window *w, Mouse_HLInfo *hlinfo,
               {
                 hlinfo->mouse_face_beg_row
                   = MATRIX_ROW_VPOS (r, w->current_matrix);
-                hlinfo->mouse_face_beg_y = r->y;
                 hlinfo->mouse_face_beg_col = g - r->glyphs[TEXT_AREA];
                 for (gx = r->x, g1 = r->glyphs[TEXT_AREA]; g1 < g; ++g1)
                   gx += g1->pixel_width;
@@ -27522,9 +27464,8 @@ mouse_face_from_string_pos (struct window *w, Mouse_HLInfo *hlinfo,
   /* The highlighted region ends on the previous row.  */
   r--;
 
-  /* Set the end row and its vertical pixel coordinate.  */
+  /* Set the end row.  */
   hlinfo->mouse_face_end_row = MATRIX_ROW_VPOS (r, w->current_matrix);
-  hlinfo->mouse_face_end_y = r->y;
 
   /* Compute and set the end column and the end column's horizontal
      pixel coordinate.  */
@@ -28022,8 +27963,6 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
 
           hlinfo->mouse_face_beg_row  = vpos;
           hlinfo->mouse_face_end_row  = hlinfo->mouse_face_beg_row;
-          hlinfo->mouse_face_beg_y    = 0;
-          hlinfo->mouse_face_end_y    = 0;
           hlinfo->mouse_face_past_end = 0;
           hlinfo->mouse_face_window   = window;
 
@@ -28142,10 +28081,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->contents);
-  if (part == ON_TEXT
-      && w->window_end_valid
-      && w->last_modified == BUF_MODIFF (b)
-      && w->last_overlay_modified == BUF_OVERLAY_MODIFF (b))
+  if (part == ON_TEXT && w->window_end_valid && !window_outdated (w))
     {
       int hpos, vpos, dx, dy, area = LAST_AREA;
       ptrdiff_t pos;
@@ -28387,8 +28323,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
                     : Qnil;
                   Lisp_Object lim2 =
                     NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
-                    ? make_number (BUF_Z (XBUFFER (buffer))
-                                   - XFASTINT (w->window_end_pos))
+                    ? make_number (BUF_Z (XBUFFER (buffer)) - w->window_end_pos)
                     : Qnil;
 
                   if (NILP (overlay))
@@ -28586,11 +28521,7 @@ cancel_mouse_face (struct frame *f)
 
   window = hlinfo->mouse_face_window;
   if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
-    {
-      hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-      hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-      hlinfo->mouse_face_window = Qnil;
-    }
+    reset_mouse_highlight (hlinfo);
 }
 
 
@@ -28790,7 +28721,7 @@ x_draw_vertical_border (struct window *w)
     {
       int x0, x1, y0, y1;
 
-      window_box_edges (w, -1, &x0, &y0, &x1, &y1);
+      window_box_edges (w, &x0, &y0, &x1, &y1);
       y1 -= 1;
 
       if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
@@ -28803,7 +28734,7 @@ x_draw_vertical_border (struct window *w)
     {
       int x0, x1, y0, y1;
 
-      window_box_edges (w, -1, &x0, &y0, &x1, &y1);
+      window_box_edges (w, &x0, &y0, &x1, &y1);
       y1 -= 1;
 
       if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
@@ -28836,7 +28767,7 @@ expose_window (struct window *w, XRectangle *fr)
   /* When we're currently updating the window, display and current
      matrix usually don't agree.  Arrange for a thorough display
      later.  */
-  if (w == updated_window)
+  if (w->must_be_updated_p)
     {
       SET_FRAME_GARBAGED (f);
       return 0;
@@ -29722,10 +29653,6 @@ cursor shapes.  */);
   DEFSYM (Qzero_width, "zero-width");
 
   DEFSYM (Qglyphless_char_display, "glyphless-char-display");
-  /* Intern this now in case it isn't already done.
-     Setting this variable twice is harmless.
-     But don't staticpro it here--that is done in alloc.c.  */
-  Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
   Fput (Qglyphless_char_display, Qchar_table_extra_slots, make_number (1));
 
   DEFVAR_LISP ("glyphless-char-display", Vglyphless_char_display,
@@ -29811,20 +29738,20 @@ void
 start_hourglass (void)
 {
 #if defined (HAVE_WINDOW_SYSTEM)
-  EMACS_TIME delay;
+  struct timespec delay;
 
   cancel_hourglass ();
 
   if (INTEGERP (Vhourglass_delay)
       && XINT (Vhourglass_delay) > 0)
-    delay = make_emacs_time (min (XINT (Vhourglass_delay),
+    delay = make_timespec (min (XINT (Vhourglass_delay),
                                   TYPE_MAXIMUM (time_t)),
-                             0);
+                           0);
   else if (FLOATP (Vhourglass_delay)
            && XFLOAT_DATA (Vhourglass_delay) > 0)
-    delay = EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (Vhourglass_delay));
+    delay = dtotimespec (XFLOAT_DATA (Vhourglass_delay));
   else
-    delay = make_emacs_time (DEFAULT_HOURGLASS_DELAY, 0);
+    delay = make_timespec (DEFAULT_HOURGLASS_DELAY, 0);
 
 #ifdef HAVE_NTGUI
   {
diff --git a/src/xfaces.c b/src/xfaces.c
index acd2d2b1116..a55ac90086d 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -236,7 +236,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifdef HAVE_NS
 #undef FRAME_X_DISPLAY_INFO
 #define FRAME_X_DISPLAY_INFO FRAME_NS_DISPLAY_INFO
-#define x_display_info ns_display_info
 #define GCGraphicsExposures 0
 #endif /* HAVE_NS */
 #endif /* HAVE_WINDOW_SYSTEM */
@@ -759,11 +758,6 @@ clear_face_cache (int clear_fonts_p)
   if (clear_fonts_p
       || ++clear_font_table_count == CLEAR_FONT_TABLE_COUNT)
     {
-#if 0
-      /* Not yet implemented.  */
-      clear_font_cache (frame);
-#endif
-
       /* From time to time see if we can unload some fonts.  This also
          frees all realized faces on all frames.  Fonts needed by
          faces will be loaded again when faces are realized again.  */
@@ -774,7 +768,10 @@ clear_face_cache (int clear_fonts_p)
           struct frame *f = XFRAME (frame);
           if (FRAME_WINDOW_P (f)
               && FRAME_X_DISPLAY_INFO (f)->n_fonts > CLEAR_FONT_TABLE_NFONTS)
-            free_all_realized_faces (frame);
+            {
+              clear_font_cache (f);
+              free_all_realized_faces (frame);
+            }
         }
     }
   else
diff --git a/src/xfns.c b/src/xfns.c
index a1e9e916aba..b08fc76524c 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -22,10 +22,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <math.h>
 #include <unistd.h>
 
-/* This makes the fields of a Display accessible, in Xlib header files.  */
-
-#define XLIB_ILLEGAL_ACCESS
-
 #include "lisp.h"
 #include "xterm.h"
 #include "frame.h"
@@ -1053,11 +1049,8 @@ static void
 x_set_cursor_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
   set_frame_cursor_types (f, arg);
-
-  /* Make sure the cursor gets redrawn.  */
-  cursor_type_changed = 1;
 }
-
+
 static void
 x_set_icon_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
@@ -1189,7 +1182,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 
           block_input ();
           x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                        0, y, width, height, False);
+                        0, y, width, height);
           unblock_input ();
         }
 
@@ -1200,7 +1193,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 
           block_input ();
           x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                        0, y, width, height, False);
+                        0, y, width, height);
           unblock_input ();
         }
 
@@ -1298,8 +1291,8 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
       if (height > 0 && width > 0)
         {
           block_input ();
-          x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                        0, y, width, height, False);
+          x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+                        0, y, width, height);
           unblock_input ();
         }
 
@@ -2313,12 +2306,7 @@ x_window (struct frame *f, long window_prompting, int minibuffer_only)
      for the window manager, so GC relocation won't bother it.
 
      Elsewhere we specify the window name for the window manager.  */
-
-  {
-    char *str = SSDATA (Vx_resource_name);
-    f->namebuf = xmalloc (strlen (str) + 1);
-    strcpy (f->namebuf, str);
-  }
+  f->namebuf = xstrdup (SSDATA (Vx_resource_name));
 
   ac = 0;
   XtSetArg (al[ac], XtNallowShellResize, 1); ac++;
@@ -2336,12 +2324,8 @@ x_window (struct frame *f, long window_prompting, int minibuffer_only)
   /* maybe_set_screen_title_format (shell_widget); */
 
   pane_widget = lw_create_widget ("main", "pane", widget_id_tick++,
-                                  (widget_value *) NULL,
-                                  shell_widget, False,
-                                  (lw_callback) NULL,
-                                  (lw_callback) NULL,
-                                  (lw_callback) NULL,
-                                  (lw_callback) NULL);
+                                  NULL, shell_widget, False,
+                                  NULL, NULL, NULL, NULL);
 
   ac = 0;
   XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
@@ -2488,8 +2472,7 @@ x_window (struct frame *f, long window_prompting, int minibuffer_only)
      */
   XChangeProperty (XtDisplay (frame_widget), XtWindow (frame_widget),
                    FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
-                   XA_ATOM, 32, PropModeAppend,
-                   (unsigned char*) NULL, 0);
+                   XA_ATOM, 32, PropModeAppend, NULL, 0);
 
   /* Make all the standard events reach the Emacs frame.  */
   attributes.event_mask = STANDARD_EVENT_SET;
@@ -4014,7 +3997,7 @@ x_get_monitor_attributes_xinerama (struct x_display_info *dpyinfo)
                         / x_display_pixel_width (dpyinfo));
   mm_height_per_pixel = ((double) HeightMMOfScreen (dpyinfo->screen)
                          / x_display_pixel_height (dpyinfo));
-  monitors = (struct MonitorInfo *) xzalloc (n_monitors * sizeof (*monitors));
+  monitors = xzalloc (n_monitors * sizeof *monitors);
   for (i = 0; i < n_monitors; ++i)
     {
       struct MonitorInfo *mi = &monitors[i];
@@ -4074,7 +4057,7 @@ x_get_monitor_attributes_xrandr (struct x_display_info *dpyinfo)
       return Qnil;
     }
   n_monitors = resources->noutput;
-  monitors = (struct MonitorInfo *) xzalloc (n_monitors * sizeof (*monitors));
+  monitors = xzalloc (n_monitors * sizeof *monitors);
 
 #ifdef HAVE_XRRGETOUTPUTPRIMARY
   pxid = XRRGetOutputPrimary (dpy, dpyinfo->root_window);
@@ -4230,7 +4213,7 @@ Internal use only, use `display-monitor-attributes-list' instead.  */)
 #endif
   n_monitors = gdk_screen_get_n_monitors (gscreen);
   monitor_frames = Fmake_vector (make_number (n_monitors), Qnil);
-  monitors = (struct MonitorInfo *) xzalloc (n_monitors * sizeof (*monitors));
+  monitors = xzalloc (n_monitors * sizeof *monitors);
 
   FOR_EACH_FRAME (rest, frame)
     {
@@ -4468,8 +4451,7 @@ x_display_info_for_name (Lisp_Object name)
 
   validate_x_resource_name ();
 
-  dpyinfo = x_term_init (name, (char *)0,
-                         SSDATA (Vx_resource_name));
+  dpyinfo = x_term_init (name, 0, SSDATA (Vx_resource_name));
 
   if (dpyinfo == 0)
     error ("Cannot connect to X server %s", SDATA (name));
@@ -4502,10 +4484,7 @@ terminate Emacs if we can't open the connection.
     error ("Not using X Windows"); /* That doesn't stop us anymore. */
 #endif
 
-  if (! NILP (xrm_string))
-    xrm_option = SSDATA (xrm_string);
-  else
-    xrm_option = (char *) 0;
+  xrm_option = NILP (xrm_string) ? 0 : SSDATA (xrm_string);
 
   validate_x_resource_name ();
 
@@ -5729,8 +5708,8 @@ DEFUN ("x-uses-old-gtk-dialog", Fx_uses_old_gtk_dialog,
 static void
 file_dialog_cb (Widget widget, XtPointer client_data, XtPointer call_data)
 {
-  int *result = (int *) client_data;
-  XmAnyCallbackStruct *cb = (XmAnyCallbackStruct *) call_data;
+  int *result = client_data;
+  XmAnyCallbackStruct *cb = call_data;
   *result = cb->reason;
 }
 
@@ -5743,7 +5722,7 @@ file_dialog_cb (Widget widget, XtPointer client_data, XtPointer call_data)
 static void
 file_dialog_unmap_cb (Widget widget, XtPointer client_data, XtPointer call_data)
 {
-  int *result = (int *) client_data;
+  int *result = client_data;
   *result = XmCR_CANCEL;
 }
 
diff --git a/src/xfont.c b/src/xfont.c
index f673adbbd5e..1aface6f972 100644
--- a/src/xfont.c
+++ b/src/xfont.c
@@ -593,9 +593,7 @@ xfont_match (struct frame *f, Lisp_Object spec)
     {
       if (XGetFontProperty (xfont, XA_FONT, &value))
         {
-          char *s;
-
-          s = (char *) XGetAtomName (display, (Atom) value);
+          char *s = XGetAtomName (display, (Atom) value);
 
           /* If DXPC (a Differential X Protocol Compressor)
              Ver.3.7 is running, XGetAtomName will return null
@@ -760,7 +758,7 @@ xfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
       char *p0, *p;
       int dashes = 0;
 
-      p0 = p = (char *) XGetAtomName (FRAME_X_DISPLAY (f), (Atom) value);
+      p0 = p = XGetAtomName (FRAME_X_DISPLAY (f), (Atom) value);
       /* Count the number of dashes in the "full name".
          If it is too few, this isn't really the font's full name,
          so don't use it.
diff --git a/src/xgselect.c b/src/xgselect.c
index 4d90298a9d9..7a754bd75c0 100644
--- a/src/xgselect.c
+++ b/src/xgselect.c
@@ -25,14 +25,16 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <glib.h>
 #include <errno.h>
+#include <timespec.h>
 #include "frame.h"
 
 int
-xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
-           EMACS_TIME *timeout, sigset_t *sigmask)
+xg_select (int fds_lim, fd_set *rfds, fd_set *wfds, fd_set *efds,
+           struct timespec const *timeout, sigset_t const *sigmask)
 {
-  SELECT_TYPE all_rfds, all_wfds;
-  EMACS_TIME tmo, *tmop = timeout;
+  fd_set all_rfds, all_wfds;
+  struct timespec tmo;
+  struct timespec const *tmop = timeout;
 
   GMainContext *context;
   int have_wfds = wfds != NULL;
@@ -85,9 +87,9 @@ xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
 
   if (tmo_in_millisec >= 0)
     {
-      tmo = make_emacs_time (tmo_in_millisec / 1000,
-                             1000 * 1000 * (tmo_in_millisec % 1000));
-      if (!timeout || EMACS_TIME_LT (tmo, *timeout))
+      tmo = make_timespec (tmo_in_millisec / 1000,
+                           1000 * 1000 * (tmo_in_millisec % 1000));
+      if (!timeout || timespec_cmp (tmo, *timeout) < 0)
         tmop = &tmo;
     }
 
diff --git a/src/xgselect.h b/src/xgselect.h
index f142e85d877..1f8555591d0 100644
--- a/src/xgselect.h
+++ b/src/xgselect.h
@@ -21,14 +21,12 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define XGSELECT_H
 
 #include "lisp.h"
-#include "systime.h"
+#include <time.h>
 #include "sysselect.h"
 
 extern int xg_select (int max_fds,
-                      SELECT_TYPE *rfds,
-                      SELECT_TYPE *wfds,
-                      SELECT_TYPE *efds,
-                      EMACS_TIME *timeout,
-                      sigset_t *sigmask);
+                      fd_set *rfds, fd_set *wfds, fd_set *efds,
+                      struct timespec const *timeout,
+                      sigset_t const *sigmask);
 
 #endif /* XGSELECT_H */
diff --git a/src/xmenu.c b/src/xmenu.c
index cad892444ff..823c63bfc6f 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -373,12 +373,12 @@ x_menu_wait_for_event (void *data)
 #elif defined USE_GTK
          ! gtk_events_pending ()
 #else
-         ! XPending ((Display*) data)
+         ! XPending (data)
 #endif
          )
     {
-      EMACS_TIME next_time = timer_check (), *ntp;
-      SELECT_TYPE read_fds;
+      struct timespec next_time = timer_check (), *ntp;
+      fd_set read_fds;
       struct x_display_info *dpyinfo;
       int n = 0;
 
@@ -391,7 +391,7 @@ x_menu_wait_for_event (void *data)
           XFlush (dpyinfo->display);
         }
 
-      if (! EMACS_TIME_VALID_P (next_time))
+      if (! timespec_valid_p (next_time))
         ntp = 0;
       else
         ntp = &next_time;
@@ -722,8 +722,7 @@ menu_highlight_callback (GtkWidget *widget, gpointer call_data)
   xg_menu_item_cb_data *cb_data;
   Lisp_Object help;
 
-  cb_data = (xg_menu_item_cb_data*) g_object_get_data (G_OBJECT (widget),
-                                                       XG_ITEM_DATA);
+  cb_data = g_object_get_data (G_OBJECT (widget), XG_ITEM_DATA);
   if (! cb_data) return;
 
   help = call_data ? cb_data->help : Qnil;
@@ -741,15 +740,11 @@ menu_highlight_callback (GtkWidget *widget, gpointer call_data)
 static void
 menu_highlight_callback (Widget widget, LWLIB_ID id, void *call_data)
 {
-  struct frame *f;
-  Lisp_Object help;
-
-  widget_value *wv = (widget_value *) call_data;
-
-  help = wv ? wv->help : Qnil;
+  widget_value *wv = call_data;
+  Lisp_Object help = wv ? wv->help : Qnil;
 
   /* Determine the frame for the help event.  */
-  f = menubar_id_to_frame (id);
+  struct frame *f = menubar_id_to_frame (id);
 
   show_help_event (f, widget, help);
 }
@@ -769,7 +764,7 @@ static int xg_crazy_callback_abort;
 static void
 menubar_selection_callback (GtkWidget *widget, gpointer client_data)
 {
-  xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data*) client_data;
+  xg_menu_item_cb_data *cb_data = client_data;
 
   if (xg_crazy_callback_abort)
     return;
@@ -1370,7 +1365,7 @@ struct next_popup_x_y
 static void
 menu_position_func (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data)
 {
-  struct next_popup_x_y* data = (struct next_popup_x_y*)user_data;
+  struct next_popup_x_y *data = user_data;
   GtkRequisition req;
   struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (data->f);
   int disp_width = x_display_pixel_width (dpyinfo);
@@ -1391,10 +1386,10 @@ menu_position_func (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer
 static void
 popup_selection_callback (GtkWidget *widget, gpointer client_data)
 {
-  xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data*) client_data;
+  xg_menu_item_cb_data *cb_data = client_data;
 
   if (xg_crazy_callback_abort) return;
-  if (cb_data) menu_item_selection = (Lisp_Object *) cb_data->call_data;
+  if (cb_data) menu_item_selection = cb_data->call_data;
 }
 
 static void
@@ -1497,7 +1492,7 @@ LWLIB_ID widget_id_tick;
 static void
 popup_selection_callback (Widget widget, LWLIB_ID id, XtPointer client_data)
 {
-  menu_item_selection = (Lisp_Object *) client_data;
+  menu_item_selection = client_data;
 }
 
 /* ARG is the LWLIB ID of the dialog box, represented
@@ -1583,7 +1578,7 @@ create_and_show_popup_menu (struct frame *f, widget_value *first_wv,
                                   make_number (menu_id & ~(-1 << (fact)))));
 
     /* Process events that apply to the menu.  */
-    popup_get_selection ((XEvent *) 0, FRAME_X_DISPLAY_INFO (f), menu_id, 1);
+    popup_get_selection (0, FRAME_X_DISPLAY_INFO (f), menu_id, 1);
 
     unbind_to (specpdl_count, Qnil);
   }
@@ -1882,7 +1877,7 @@ dialog_selection_callback (GtkWidget *widget, gpointer client_data)
   /* Treat the pointer as an integer.  There's no problem
      as long as pointers have enough bits to hold small integers.  */
   if ((intptr_t) client_data != -1)
-    menu_item_selection = (Lisp_Object *) client_data;
+    menu_item_selection = client_data;
 
   popup_activated_flag = 0;
 }
@@ -1924,7 +1919,7 @@ dialog_selection_callback (Widget widget, LWLIB_ID id, XtPointer client_data)
   /* Treat the pointer as an integer.  There's no problem
      as long as pointers have enough bits to hold small integers.  */
   if ((intptr_t) client_data != -1)
-    menu_item_selection = (Lisp_Object *) client_data;
+    menu_item_selection = client_data;
 
   block_input ();
   lw_destroy_all_widgets (id);
@@ -1967,8 +1962,7 @@ create_and_show_dialog (struct frame *f, widget_value *first_wv)
                            Fcons (make_number (dialog_id >> (fact)),
                                   make_number (dialog_id & ~(-1 << (fact)))));
 
-    popup_get_selection ((XEvent *) 0, FRAME_X_DISPLAY_INFO (f),
-                         dialog_id, 1);
+    popup_get_selection (0, FRAME_X_DISPLAY_INFO (f), dialog_id, 1);
 
     unbind_to (count, Qnil);
   }
diff --git a/src/xrdb.c b/src/xrdb.c
index 7c9cd53fa8c..60dcdae080d 100644
--- a/src/xrdb.c
+++ b/src/xrdb.c
@@ -75,18 +75,9 @@ x_get_customization_string (XrmDatabase db, const char *name,
   sprintf (full_class, "%s.%s", class, "Customization");
 
   result = x_get_string_resource (db, full_name, full_class);
-
-  if (result)
-    {
-      char *copy = xmalloc (strlen (result) + 1);
-      strcpy (copy, result);
-      return copy;
-    }
-  else
-    return 0;
+  return result ? xstrdup (result) : NULL;
 }
 
-
 /* Expand all the Xt-style %-escapes in STRING, whose length is given
    by STRING_LEN.  Here are the escapes we're supposed to recognize:
 
@@ -605,7 +596,7 @@ x_get_string_resource (XrmDatabase rdb, const char *name, const char *class)
   if (x_get_resource (rdb, name, class, x_rm_string, &value))
     return (char *) value.addr;
 
-  return (char *) 0;
+  return 0;
 }
 
 /* Stand-alone test facilities.  */
@@ -655,10 +646,7 @@ main (int argc, char **argv)
     displayname = "localhost:0.0";
 
   lp = member ("-xrm", arg_list);
-  if (! NIL (lp))
-    resource_string = car (cdr (lp));
-  else
-    resource_string = (char *) 0;
+  resource_string = NIL (lp) ? 0 : car (cdr (lp));
 
   lp = member ("-c", arg_list);
   if (! NIL (lp))
diff --git a/src/xselect.c b/src/xselect.c
index 3a16d7d3496..e5f2e214fba 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -2628,6 +2628,8 @@ x_send_client_event (Lisp_Object display, Lisp_Object dest, Lisp_Object from,
 
   block_input ();
 
+  event.xclient.send_event = True;
+  event.xclient.serial = 0;
   event.xclient.message_type = message_type;
   event.xclient.display = dpyinfo->display;
 
@@ -2635,19 +2637,19 @@ x_send_client_event (Lisp_Object display, Lisp_Object dest, Lisp_Object from,
      when sending to the root window.  */
   event.xclient.window = to_root ? FRAME_OUTER_WINDOW (f) : wdest;
 
-
-  memset (event.xclient.data.b, 0, sizeof (event.xclient.data.b));
+  memset (event.xclient.data.l, 0, sizeof (event.xclient.data.l));
   x_fill_property_data (dpyinfo->display, values, event.xclient.data.b,
                         event.xclient.format);
 
   /* If event mask is 0 the event is sent to the client that created
      the destination window.  But if we are sending to the root window,
-     there is no such client.  Then we set the event mask to 0xffff.  The
+     there is no such client.  Then we set the event mask to 0xffffff.  The
      event then goes to clients selecting for events on the root window.  */
   x_catch_errors (dpyinfo->display);
   {
     int propagate = to_root ? False : True;
-    unsigned mask = to_root ? 0xffff : 0;
+    long mask = to_root ? 0xffffff : 0;
+
     XSendEvent (dpyinfo->display, wdest, propagate, mask, &event);
     XFlush (dpyinfo->display);
   }
diff --git a/src/xsmfns.c b/src/xsmfns.c
index cb7122202df..526d4c3610b 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -107,8 +107,7 @@ x_session_check_input (int fd, void *data)
      will be called.  */
   emacs_event.kind = NO_EVENT;
 
-  ret = IceProcessMessages (SmcGetIceConnection (smc_conn),
-                            (IceReplyWaitInfo *)0, (Bool *)0);
+  ret = IceProcessMessages (SmcGetIceConnection (smc_conn), 0, 0);
   if (ret != IceProcessMessagesSuccess)
     {
       /* Either IO error or Connection closed.  */
diff --git a/src/xterm.c b/src/xterm.c
index a486242b8c3..bd990014cea 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -140,16 +140,11 @@ int use_xim = 1;
 int use_xim = 0;  /* configure --without-xim */
 #endif
 
-
-
 /* Non-zero means that a HELP_EVENT has been generated since Emacs
    start.  */
 
 static bool any_help_event_p;
 
-/* Last window where we saw the mouse.  Used by mouse-autoselect-window.  */
-static Lisp_Object last_window;
-
 /* This is a chain of structures for all the X displays currently in
    use.  */
 
@@ -292,15 +287,11 @@ static void x_set_window_size_1 (struct frame *, int, int, int);
 static void x_raise_frame (struct frame *);
 static void x_lower_frame (struct frame *);
 static const XColor *x_color_cells (Display *, int *);
-static void x_update_window_end (struct window *, int, int);
-
 static int x_io_error_quitter (Display *);
 static struct terminal *x_create_terminal (struct x_display_info *);
 void x_delete_terminal (struct terminal *);
 static void x_update_end (struct frame *);
 static void XTframe_up_to_date (struct frame *);
-static void XTset_terminal_modes (struct terminal *);
-static void XTreset_terminal_modes (struct terminal *);
 static void x_clear_frame (struct frame *);
 static _Noreturn void x_ins_del_lines (struct frame *, int, int);
 static void frame_highlight (struct frame *);
@@ -316,11 +307,11 @@ static void x_draw_hollow_cursor (struct window *, struct glyph_row *);
 static void x_draw_bar_cursor (struct window *, struct glyph_row *, int,
                                enum text_cursor_kinds);
 
-static void x_clip_to_row (struct window *, struct glyph_row *, int, GC);
+static void x_clip_to_row (struct window *, struct glyph_row *,
+                           enum glyph_row_area, GC);
 static void x_flush (struct frame *f);
 static void x_update_begin (struct frame *);
 static void x_update_window_begin (struct window *);
-static void x_after_update_window_line (struct glyph_row *);
 static struct scroll_bar *x_window_to_scroll_bar (Display *, Window);
 static void x_scroll_bar_report_motion (struct frame **, Lisp_Object *,
                                         enum scroll_bar_part *,
@@ -554,9 +545,7 @@ x_update_begin (struct frame *f)
 }
 
 
-/* Start update of window W.  Set the global variable updated_window
-   to the window being updated and set output_cursor to the cursor
-   position of W.  */
+/* Start update of window W.  */
 
 static void
 x_update_window_begin (struct window *w)
@@ -564,8 +553,7 @@ x_update_window_begin (struct window *w)
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 
-  updated_window = w;
-  set_output_cursor (&w->cursor);
+  w->output_cursor = w->cursor;
 
   block_input ();
 
@@ -601,7 +589,7 @@ x_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
              f->output_data.x->normal_gc, x, y0, x, y1);
 }
 
-/* End update of window W (which is equal to updated_window).
+/* End update of window W.
 
    Draw vertical borders between horizontally adjacent windows, and
    display W's cursor if CURSOR_ON_P is non-zero.
@@ -615,18 +603,17 @@ x_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
    here.  */
 
 static void
-x_update_window_end (struct window *w, int cursor_on_p, int mouse_face_overwritten_p)
+x_update_window_end (struct window *w, bool cursor_on_p,
+                     bool mouse_face_overwritten_p)
 {
-  Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
-
   if (!w->pseudo_window_p)
     {
       block_input ();
 
       if (cursor_on_p)
-        display_and_set_cursor (w, 1, output_cursor.hpos,
-                                output_cursor.vpos,
-                                output_cursor.x, output_cursor.y);
+        display_and_set_cursor (w, 1,
+                                w->output_cursor.hpos, w->output_cursor.vpos,
+                                w->output_cursor.x, w->output_cursor.y);
 
       if (draw_window_fringes (w, 1))
         x_draw_vertical_border (w);
@@ -637,13 +624,7 @@ x_update_window_end (struct window *w, int cursor_on_p, int mouse_face_overwritt
   /* If a row with mouse-face was overwritten, arrange for
      XTframe_up_to_date to redisplay the mouse highlight.  */
   if (mouse_face_overwritten_p)
-    {
-      hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-      hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-      hlinfo->mouse_face_window = Qnil;
-    }
-
-  updated_window = NULL;
+    reset_mouse_highlight (MOUSE_HL_INFO (XFRAME (w->frame)));
 }
 
 
@@ -664,9 +645,8 @@ x_update_end (struct frame *f)
 }
 
 
-/* This function is called from various places in xdisp.c whenever a
-   complete update has been performed.  The global variable
-   updated_window is not available here.  */
+/* This function is called from various places in xdisp.c
+   whenever a complete update has been performed.  */
 
 static void
 XTframe_up_to_date (struct frame *f)
@@ -678,15 +658,13 @@ XTframe_up_to_date (struct frame *f)
 
 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
    arrow bitmaps, or clear the fringes if no bitmaps are required
-   before DESIRED_ROW is made current.  The window being updated is
-   found in updated_window.  This function It is called from
+   before DESIRED_ROW is made current.  This function is called from
    update_window_line only if it is known that there are differences
    between bitmaps to be drawn between current row and DESIRED_ROW.  */
 
 static void
-x_after_update_window_line (struct glyph_row *desired_row)
+x_after_update_window_line (struct window *w, struct glyph_row *desired_row)
 {
-  struct window *w = updated_window;
   struct frame *f;
   int width, height;
 
@@ -697,7 +675,7 @@ x_after_update_window_line (struct glyph_row *desired_row)
 
   /* When a window has disappeared, make sure that no rest of
      full-width rows stays visible in the internal border.  Could
-     check here if updated_window is the leftmost/rightmost window,
+     check here if updated window is the leftmost/rightmost window,
      but I guess it's not worth doing since vertically split windows
      are almost never used, internal border is rarely set, and the
      overhead is very small.  */
@@ -713,10 +691,10 @@ x_after_update_window_line (struct glyph_row *desired_row)
 
       block_input ();
       x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                    0, y, width, height, False);
+                    0, y, width, height);
       x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
                     FRAME_PIXEL_WIDTH (f) - width,
-                    y, width, height, False);
+                    y, width, height);
       unblock_input ();
     }
 }
@@ -731,7 +709,7 @@ x_draw_fringe_bitmap (struct window *w, struct glyph_row *row, struct draw_fring
   struct face *face = p->face;
 
   /* Must clip because of partially visible lines.  */
-  x_clip_to_row (w, row, -1, gc);
+  x_clip_to_row (w, row, ANY_AREA, gc);
 
   if (!p->overlay_p)
     {
@@ -848,27 +826,6 @@ x_draw_fringe_bitmap (struct window *w, struct glyph_row *row, struct draw_fring
   XSetClipMask (display, gc, None);
 }
 
-
-
-/* This is called when starting Emacs and when restarting after
-   suspend.  When starting Emacs, no X window is mapped.  And nothing
-   must be done to Emacs's own window if it is suspended (though that
-   rarely happens).  */
-
-static void
-XTset_terminal_modes (struct terminal *terminal)
-{
-}
-
-/* This is called when exiting or suspending Emacs.  Exiting will make
-   the X-windows go away, and suspending requires no action.  */
-
-static void
-XTreset_terminal_modes (struct terminal *terminal)
-{
-}
-
-
 /***********************************************************************
                             Glyph display
  ***********************************************************************/
@@ -1374,7 +1331,7 @@ x_draw_glyphless_glyph_string_foreground (struct glyph_string *s)
         }
       else if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_HEX_CODE)
         {
-          sprintf ((char *) buf, "%0*X",
+          sprintf (buf, "%0*X",
                    glyph->u.glyphless.ch < 0x10000 ? 4 : 6,
                    glyph->u.glyphless.ch);
           str = buf;
@@ -2983,10 +2940,10 @@ x_delete_glyphs (struct frame *f, register int n)
    If they are <= 0, this is probably an error.  */
 
 void
-x_clear_area (Display *dpy, Window window, int x, int y, int width, int height, int exposures)
+x_clear_area (Display *dpy, Window window, int x, int y, int width, int height)
 {
   eassert (width > 0 && height > 0);
-  XClearArea (dpy, window, x, y, width, height, exposures);
+  XClearArea (dpy, window, x, y, width, height, False);
 }
 
 
@@ -2998,11 +2955,7 @@ x_clear_frame (struct frame *f)
   /* Clearing the frame will erase any cursor, so mark them all as no
      longer visible.  */
   mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
-  output_cursor.hpos = output_cursor.vpos = 0;
-  output_cursor.x = -1;
 
-  /* We don't set the output cursor here because there will always
-     follow an explicit cursor_to.  */
   block_input ();
 
   XClearWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
@@ -3127,22 +3080,22 @@ XTflash (struct frame *f)
       x_flush (f);
 
       {
-        EMACS_TIME delay = make_emacs_time (0, 150 * 1000 * 1000);
-        EMACS_TIME wakeup = add_emacs_time (current_emacs_time (), delay);
+        struct timespec delay = make_timespec (0, 150 * 1000 * 1000);
+        struct timespec wakeup = timespec_add (current_timespec (), delay);
 
         /* Keep waiting until past the time wakeup or any input gets
            available.  */
         while (! detect_input_pending ())
           {
-            EMACS_TIME current = current_emacs_time ();
-            EMACS_TIME timeout;
+            struct timespec current = current_timespec ();
+            struct timespec timeout;
 
             /* Break if result would not be positive.  */
-            if (EMACS_TIME_LE (wakeup, current))
+            if (timespec_cmp (wakeup, current) <= 0)
               break;
 
             /* How long `select' should wait.  */
-            timeout = make_emacs_time (0, 10 * 1000 * 1000);
+            timeout = make_timespec (0, 10 * 1000 * 1000);
 
             /* Try to wait that long--but we might wake up sooner.  */
             pselect (0, NULL, NULL, NULL, &timeout, NULL);
@@ -3228,20 +3181,6 @@ XTring_bell (struct frame *f)
     }
 }
 
-
-/* Specify how many text lines, from the top of the window,
-   should be affected by insert-lines and delete-lines operations.
-   This, and those operations, are used only within an update
-   that is bounded by calls to x_update_begin and x_update_end.  */
-
-static void
-XTset_terminal_window (struct frame *f, int n)
-{
-  /* This function intentionally left blank.  */
-}
-
-
-
 /***********************************************************************
                               Line Dance
  ***********************************************************************/
@@ -3267,7 +3206,7 @@ x_scroll_run (struct window *w, struct run *run)
   /* Get frame-relative bounding box of the text display area of W,
      without mode lines.  Include in this box the left and right
      fringe of W.  */
-  window_box (w, -1, &x, &y, &width, &height);
+  window_box (w, ANY_AREA, &x, &y, &width, &height);
 
 #ifdef USE_TOOLKIT_SCROLL_BARS
   /* If the fringe is adjacent to the left (right) scroll bar of a
@@ -3323,7 +3262,6 @@ x_scroll_run (struct window *w, struct run *run)
   block_input ();
 
   /* Cursor off.  Will be switched on again in x_update_window_end.  */
-  updated_window = w;
   x_clear_cursor (w);
 
   XCopyArea (FRAME_X_DISPLAY (f),
@@ -3784,7 +3722,6 @@ construct_mouse_click (struct input_event *result, XButtonEvent *event, struct f
   return Qnil;
 }
 
-
 /* Function to report a mouse movement to the mainstream Emacs code.
    The input handler calls this.
 
@@ -4204,9 +4141,9 @@ xt_action_hook (Widget widget, XtPointer client_data, String action_name,
                                scroll_bar_end_scroll, 0, 0);
       w = XWINDOW (window_being_scrolled);
 
-      if (!NILP (XSCROLL_BAR (w->vertical_scroll_bar)->dragging))
+      if (XSCROLL_BAR (w->vertical_scroll_bar)->dragging != -1)
         {
-          XSCROLL_BAR (w->vertical_scroll_bar)->dragging = Qnil;
+          XSCROLL_BAR (w->vertical_scroll_bar)->dragging = -1;
           /* The thumb size is incorrect while dragging: fix it.  */
           set_vertical_scroll_bar (w);
         }
@@ -4337,39 +4274,39 @@ x_scroll_bar_to_input_event (XEvent *event, struct input_event *ievent)
 static void
 xm_scroll_callback (Widget widget, XtPointer client_data, XtPointer call_data)
 {
-  struct scroll_bar *bar = (struct scroll_bar *) client_data;
-  XmScrollBarCallbackStruct *cs = (XmScrollBarCallbackStruct *) call_data;
+  struct scroll_bar *bar = client_data;
+  XmScrollBarCallbackStruct *cs = call_data;
   int part = -1, whole = 0, portion = 0;
 
   switch (cs->reason)
     {
     case XmCR_DECREMENT:
-      bar->dragging = Qnil;
+      bar->dragging = -1;
       part = scroll_bar_up_arrow;
       break;
 
     case XmCR_INCREMENT:
-      bar->dragging = Qnil;
+      bar->dragging = -1;
       part = scroll_bar_down_arrow;
       break;
 
     case XmCR_PAGE_DECREMENT:
-      bar->dragging = Qnil;
+      bar->dragging = -1;
       part = scroll_bar_above_handle;
       break;
 
     case XmCR_PAGE_INCREMENT:
-      bar->dragging = Qnil;
+      bar->dragging = -1;
       part = scroll_bar_below_handle;
       break;
 
     case XmCR_TO_TOP:
-      bar->dragging = Qnil;
+      bar->dragging = -1;
       part = scroll_bar_to_top;
       break;
 
     case XmCR_TO_BOTTOM:
-      bar->dragging = Qnil;
+      bar->dragging = -1;
       part = scroll_bar_to_bottom;
       break;
 
@@ -4385,7 +4322,7 @@ xm_scroll_callback (Widget widget, XtPointer client_data, XtPointer call_data)
         whole = XM_SB_MAX - slider_size;
         portion = min (cs->value, whole);
         part = scroll_bar_handle;
-        bar->dragging = make_number (cs->value);
+        bar->dragging = cs->value;
       }
       break;
 
@@ -4412,12 +4349,11 @@ xg_scroll_callback (GtkRange     *range,
                     gdouble       value,
                     gpointer      user_data)
 {
-  struct scroll_bar *bar = (struct scroll_bar *) user_data;
+  struct scroll_bar *bar = user_data;
   gdouble position;
   int part = -1, whole = 0, portion = 0;
   GtkAdjustment *adj = GTK_ADJUSTMENT (gtk_range_get_adjustment (range));
-  struct frame *f = (struct frame *) g_object_get_data (G_OBJECT (range),
-                                                        XG_FRAME_DATA);
+  struct frame *f = g_object_get_data (G_OBJECT (range), XG_FRAME_DATA);
 
   if (xg_ignore_gtk_scrollbar) return FALSE;
   position = gtk_adjustment_get_value (adj);
@@ -4434,24 +4370,24 @@ xg_scroll_callback (GtkRange     *range,
           whole = gtk_adjustment_get_upper (adj) -
             gtk_adjustment_get_page_size (adj);
           portion = min ((int)position, whole);
-          bar->dragging = make_number ((int)portion);
+          bar->dragging = portion;
         }
       break;
     case GTK_SCROLL_STEP_BACKWARD:
       part = scroll_bar_up_arrow;
-      bar->dragging = Qnil;
+      bar->dragging = -1;
       break;
     case GTK_SCROLL_STEP_FORWARD:
       part = scroll_bar_down_arrow;
-      bar->dragging = Qnil;
+      bar->dragging = -1;
       break;
     case GTK_SCROLL_PAGE_BACKWARD:
       part = scroll_bar_above_handle;
-      bar->dragging = Qnil;
+      bar->dragging = -1;
       break;
     case GTK_SCROLL_PAGE_FORWARD:
       part = scroll_bar_below_handle;
-      bar->dragging = Qnil;
+      bar->dragging = -1;
       break;
     }
 
@@ -4465,15 +4401,15 @@ xg_scroll_callback (GtkRange     *range,
   return FALSE;
 }
 
-/* Callback for button release. Sets dragging to Qnil when dragging is done.  */
+/* Callback for button release. Sets dragging to -1 when dragging is done.  */
 
 static gboolean
 xg_end_scroll_callback (GtkWidget *widget,
                         GdkEventButton *event,
                         gpointer user_data)
 {
-  struct scroll_bar *bar = (struct scroll_bar *) user_data;
-  bar->dragging = Qnil;
+  struct scroll_bar *bar = user_data;
+  bar->dragging = -1;
   if (WINDOWP (window_being_scrolled))
     {
       x_send_scroll_bar_event (window_being_scrolled,
@@ -4495,8 +4431,9 @@ xg_end_scroll_callback (GtkWidget *widget,
 static void
 xaw_jump_callback (Widget widget, XtPointer client_data, XtPointer call_data)
 {
-  struct scroll_bar *bar = (struct scroll_bar *) client_data;
-  float top = *(float *) call_data;
+  struct scroll_bar *bar = client_data;
+  float *top_addr = call_data;
+  float top = *top_addr;
   float shown;
   int whole, portion, height;
   int part;
@@ -4520,7 +4457,7 @@ xaw_jump_callback (Widget widget, XtPointer client_data, XtPointer call_data)
     part = scroll_bar_handle;
 
   window_being_scrolled = bar->window;
-  bar->dragging = make_number (portion);
+  bar->dragging = portion;
   last_scroll_bar_part = part;
   x_send_scroll_bar_event (bar->window, part, portion, whole);
 }
@@ -4537,9 +4474,9 @@ xaw_jump_callback (Widget widget, XtPointer client_data, XtPointer call_data)
 static void
 xaw_scroll_callback (Widget widget, XtPointer client_data, XtPointer call_data)
 {
-  struct scroll_bar *bar = (struct scroll_bar *) client_data;
+  struct scroll_bar *bar = client_data;
   /* The position really is stored cast to a pointer.  */
-  int position = (long) call_data;
+  int position = (intptr_t) call_data;
   Dimension height;
   int part;
 
@@ -4559,7 +4496,7 @@ xaw_scroll_callback (Widget widget, XtPointer client_data, XtPointer call_data)
     part = scroll_bar_move_ratio;
 
   window_being_scrolled = bar->window;
-  bar->dragging = Qnil;
+  bar->dragging = -1;
   last_scroll_bar_part = part;
   x_send_scroll_bar_event (bar->window, part, position, height);
 }
@@ -4835,7 +4772,7 @@ x_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar, int portion, int positio
       shown = (float) portion / whole;
     }
 
-  if (NILP (bar->dragging))
+  if (bar->dragging == -1)
     {
       int size, value;
 
@@ -4870,7 +4807,7 @@ x_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar, int portion, int positio
                    NULL);
 
     /* Massage the top+shown values.  */
-    if (NILP (bar->dragging) || last_scroll_bar_part == scroll_bar_down_arrow)
+    if (bar->dragging == -1 || last_scroll_bar_part == scroll_bar_down_arrow)
       top = max (0, min (1, top));
     else
       top = old_top;
@@ -4882,7 +4819,7 @@ x_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar, int portion, int positio
        for `NARROWPROTO'.  See s/freebsd.h for an example.  */
     if (top != old_top || shown != old_shown)
       {
-        if (NILP (bar->dragging))
+        if (bar->dragging == -1)
           XawScrollbarSetThumb (widget, top, shown);
         else
           {
@@ -4947,8 +4884,7 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
        this case, no clear_frame is generated to reduce flickering.  */
     if (width > 0 && height > 0)
       x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                    left, top, width,
-                    window_box_height (w), False);
+                    left, top, width, window_box_height (w));
 
     window = XCreateWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
                             /* Position and size of scroll bar.  */
@@ -4974,7 +4910,7 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
   bar->height = height;
   bar->start = 0;
   bar->end = 0;
-  bar->dragging = Qnil;
+  bar->dragging = -1;
   bar->fringe_extended_p = 0;
 
   /* Add bar to its frame's list of scroll bars.  */
@@ -5032,7 +4968,7 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
 static void
 x_scroll_bar_set_handle (struct scroll_bar *bar, int start, int end, int rebuild)
 {
-  int dragging = ! NILP (bar->dragging);
+  bool dragging = bar->dragging != -1;
   Window w = bar->x_window;
   struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
   GC gc = f->output_data.x->normal_gc;
@@ -5084,11 +5020,9 @@ x_scroll_bar_set_handle (struct scroll_bar *bar, int start, int end, int rebuild
        zero-height areas; that means "clear to end of window."  */
     if (start > 0)
       x_clear_area (FRAME_X_DISPLAY (f), w,
-                    /* x, y, width, height, and exposures.  */
                     VERTICAL_SCROLL_BAR_LEFT_BORDER,
                     VERTICAL_SCROLL_BAR_TOP_BORDER,
-                    inside_width, start,
-                    False);
+                    inside_width, start);
 
     /* Change to proper foreground color if one is specified.  */
     if (f->output_data.x->scroll_bar_foreground_pixel != -1)
@@ -5111,12 +5045,9 @@ x_scroll_bar_set_handle (struct scroll_bar *bar, int start, int end, int rebuild
        clear zero-height areas; that means "clear to end of window." */
     if (end < inside_height)
       x_clear_area (FRAME_X_DISPLAY (f), w,
-                    /* x, y, width, height, and exposures.  */
                     VERTICAL_SCROLL_BAR_LEFT_BORDER,
                     VERTICAL_SCROLL_BAR_TOP_BORDER + end,
-                    inside_width, inside_height - end,
-                    False);
-
+                    inside_width, inside_height - end);
   }
 
   unblock_input ();
@@ -5164,11 +5095,11 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
   int top, height, left, sb_left, width, sb_width;
   int window_y, window_height;
 #ifdef USE_TOOLKIT_SCROLL_BARS
-  int fringe_extended_p;
+  bool fringe_extended_p;
 #endif
 
   /* Get window dimensions.  */
-  window_box (w, -1, 0, &window_y, 0, &window_height);
+  window_box (w, ANY_AREA, 0, &window_y, 0, &window_height);
   top = window_y;
   width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
   height = window_height;
@@ -5197,16 +5128,7 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
 #endif
 
 #ifdef USE_TOOLKIT_SCROLL_BARS
-  if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
-    fringe_extended_p = (WINDOW_LEFTMOST_P (w)
-                         && WINDOW_LEFT_FRINGE_WIDTH (w)
-                         && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-                             || WINDOW_LEFT_MARGIN_COLS (w) == 0));
-  else
-    fringe_extended_p = (WINDOW_RIGHTMOST_P (w)
-                         && WINDOW_RIGHT_FRINGE_WIDTH (w)
-                         && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-                             || WINDOW_RIGHT_MARGIN_COLS (w) == 0));
+  fringe_extended_p = WINDOW_FRINGE_EXTENDED_P (w);
 #endif
 
   /* Does the scroll bar exist yet?  */
@@ -5218,11 +5140,11 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
 #ifdef USE_TOOLKIT_SCROLL_BARS
           if (fringe_extended_p)
             x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                          sb_left, top, sb_width, height, False);
+                          sb_left, top, sb_width, height);
           else
 #endif
             x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                          left, top, width, height, False);
+                          left, top, width, height);
           unblock_input ();
         }
 
@@ -5257,10 +5179,10 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
             {
               if (fringe_extended_p)
                 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                              sb_left, top, sb_width, height, False);
+                              sb_left, top, sb_width, height);
               else
                 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                              left, top, width, height, False);
+                              left, top, width, height);
             }
 #ifdef USE_GTK
           xg_update_scrollbar_pos (f,
@@ -5284,12 +5206,10 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
       if (VERTICAL_SCROLL_BAR_WIDTH_TRIM)
         {
           x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                        left, top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
-                        height, False);
+                        left, top, VERTICAL_SCROLL_BAR_WIDTH_TRIM, height);
           x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
                         left + width - VERTICAL_SCROLL_BAR_WIDTH_TRIM,
-                        top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
-                        height, False);
+                        top, VERTICAL_SCROLL_BAR_WIDTH_TRIM, height);
         }
 
       /* Clear areas not covered by the scroll bar because it's not as
@@ -5303,11 +5223,10 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
           {
             if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
               x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                            left + area_width -  rest, top,
-                            rest, height, False);
+                            left + area_width - rest, top, rest, height);
             else
               x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                            left, top, rest, height, False);
+                            left, top, rest, height);
           }
       }
 
@@ -5342,7 +5261,7 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
 #else /* not USE_TOOLKIT_SCROLL_BARS */
   /* Set the scroll bar's current state, unless we're currently being
      dragged.  */
-  if (NILP (bar->dragging))
+  if (bar->dragging == -1)
     {
       int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height);
 
@@ -5552,14 +5471,13 @@ x_scroll_bar_handle_click (struct scroll_bar *bar, XEvent *event, struct input_e
 
 #ifndef USE_TOOLKIT_SCROLL_BARS
     /* If the user has released the handle, set it to its final position.  */
-    if (event->type == ButtonRelease
-        && ! NILP (bar->dragging))
+    if (event->type == ButtonRelease && bar->dragging != -1)
       {
         int new_start = y - XINT (bar->dragging);
         int new_end = new_start + bar->end - bar->start;
 
         x_scroll_bar_set_handle (bar, new_start, new_end, 0);
-        bar->dragging = Qnil;
+        bar->dragging = -1;
       }
 #endif
 
@@ -5576,20 +5494,20 @@ x_scroll_bar_handle_click (struct scroll_bar *bar, XEvent *event, struct input_e
    mark bits.  */
 
 static void
-x_scroll_bar_note_movement (struct scroll_bar *bar, XEvent *event)
+x_scroll_bar_note_movement (struct scroll_bar *bar, XMotionEvent *event)
 {
   struct frame *f = XFRAME (XWINDOW (bar->window)->frame);
 
-  last_mouse_movement_time = event->xmotion.time;
+  last_mouse_movement_time = event->time;
 
   f->mouse_moved = 1;
   XSETVECTOR (last_mouse_scroll_bar, bar);
 
   /* If we're dragging the bar, display it.  */
-  if (! NILP (bar->dragging))
+  if (bar->dragging != -1)
     {
       /* Where should the handle be now?  */
-      int new_start = event->xmotion.y - XINT (bar->dragging);
+      int new_start = event->y - bar->dragging;
 
       if (new_start != bar->start)
         {
@@ -5641,8 +5559,8 @@ x_scroll_bar_report_motion (struct frame **fp, Lisp_Object *bar_window,
 
       win_y -= VERTICAL_SCROLL_BAR_TOP_BORDER;
 
-      if (! NILP (bar->dragging))
-        win_y -= XINT (bar->dragging);
+      if (bar->dragging != -1)
+        win_y -= bar->dragging;
 
       if (win_y < 0)
         win_y = 0;
@@ -5652,7 +5570,7 @@ x_scroll_bar_report_motion (struct frame **fp, Lisp_Object *bar_window,
       *fp = f;
       *bar_window = bar->window;
 
-      if (! NILP (bar->dragging))
+      if (bar->dragging != -1)
         *part = scroll_bar_handle;
       else if (win_y < bar->start)
         *part = scroll_bar_above_handle;
@@ -5697,18 +5615,7 @@ x_scroll_bar_clear (struct frame *f)
 #endif /* not USE_TOOLKIT_SCROLL_BARS */
 }
 
-
-/* The main X event-reading loop - XTread_socket.  */
-
-/* This holds the state XLookupString needs to implement dead keys
-   and other tricks known as "compose processing".  _X Window System_
-   says that a portable program can't use this, but Stephen Gildea assures
-   me that letting the compiler initialize it to zeros will work okay.
-
-   This must be defined outside of XTread_socket, for the same reasons
-   given for enter_timestamp, above.  */
-
-static XComposeStatus compose_status;
+#ifdef ENABLE_CHECKING
 
 /* Record the last 100 characters stored
    to help debug the loss-of-chars-during-GC problem.  */
@@ -5721,6 +5628,12 @@ static short temp_buffer[100];
     temp_index = 0;                                             \
   temp_buffer[temp_index++] = (keysym)
 
+#else /* not ENABLE_CHECKING */
+
+#define STORE_KEYSYM_FOR_DEBUG(keysym) ((void)0)
+
+#endif /* ENABLE_CHECKING */
+
 /* Set this to nonzero to fake an "X I/O error"
    on a particular display.  */
 
@@ -5858,6 +5771,12 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
   struct coding_system coding;
   XEvent event = *eventptr;
   Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
+  /* This holds the state XLookupString needs to implement dead keys
+     and other tricks known as "compose processing".  _X Window System_
+     says that a portable program can't use this, but Stephen Gildea assures
+     me that letting the compiler initialize it to zeros will work okay.  */
+  static XComposeStatus compose_status;
+
   USE_SAFE_ALLOCA;
 
   *finish = X_EVENT_NORMAL;
@@ -6151,11 +6070,10 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
         {
 #ifdef USE_GTK
           /* This seems to be needed for GTK 2.6.  */
-          x_clear_area (event.xexpose.display,
-                        event.xexpose.window,
-                        event.xexpose.x, event.xexpose.y,
-                        event.xexpose.width, event.xexpose.height,
-                        FALSE);
+          x_clear_area (event.xexpose.display,
+                        event.xexpose.window,
+                        event.xexpose.x, event.xexpose.y,
+                        event.xexpose.width, event.xexpose.height);
 #endif
           if (!FRAME_VISIBLE_P (f))
             {
@@ -6227,7 +6145,7 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
 
     case UnmapNotify:
       /* Redo the mouse-highlight after the tooltip has gone.  */
-      if (event.xmap.window == tip_window)
+      if (event.xunmap.window == tip_window)
         {
           tip_window = 0;
           redo_mouse_highlight ();
@@ -6731,18 +6649,16 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
             /* Generate SELECT_WINDOW_EVENTs when needed.
                Don't let popup menus influence things (bug#1261).  */
             if (!NILP (Vmouse_autoselect_window) && !popup_activated ())
-              {
-                Lisp_Object window;
-
-                window = window_from_coordinates (f,
-                                                  event.xmotion.x, event.xmotion.y,
-                                                  0, 0);
-
-                /* Window will be selected only when it is not selected now and
-                   last mouse movement event was not in it.  Minibuffer window
-                   will be selected only when it is active.  */
-                if (WINDOWP (window)
-                    && !EQ (window, last_window)
+              {
+                static Lisp_Object last_mouse_window;
+                Lisp_Object window = window_from_coordinates
+                  (f, event.xmotion.x, event.xmotion.y, 0, 0);
+
+                /* Window will be selected only when it is not selected now and
+                   last mouse movement event was not in it.  Minibuffer window
+                   will be selected only when it is active.  */
+                if (WINDOWP (window)
+                    && !EQ (window, last_mouse_window)
                     && !EQ (window, selected_window)
                     /* For click-to-focus window managers
                        create event iff we don't leave the
@@ -6750,13 +6666,13 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
                     && (focus_follows_mouse
                         || (EQ (XWINDOW (window)->frame,
                                 XWINDOW (selected_window)->frame))))
-                  {
-                    inev.ie.kind = SELECT_WINDOW_EVENT;
-                    inev.ie.frame_or_window = window;
-                  }
-
-                last_window=window;
-              }
+                  {
+                    inev.ie.kind = SELECT_WINDOW_EVENT;
+                    inev.ie.frame_or_window = window;
+                  }
+                /* Remember the last window where we saw the mouse.  */
+                last_mouse_window = window;
+              }
             if (!note_mouse_movement (f, &event.xmotion))
               help_echo_string = previous_help_echo_string;
           }
@@ -6768,7 +6684,7 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
                                         event.xmotion.window);
 
             if (bar)
-              x_scroll_bar_note_movement (bar, &event);
+              x_scroll_bar_note_movement (bar, &event.xmotion);
 #endif /* USE_TOOLKIT_SCROLL_BARS */
 
             /* If we move outside the frame, then we're
@@ -7200,7 +7116,8 @@ XTread_socket (struct terminal *terminal, struct input_event *hold_quit)
    mode lines must be clipped to the whole window.  */
 
 static void
-x_clip_to_row (struct window *w, struct glyph_row *row, int area, GC gc)
+x_clip_to_row (struct window *w, struct glyph_row *row,
+               enum glyph_row_area area, GC gc)
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   XRectangle clip_rect;
@@ -7377,8 +7294,7 @@ x_define_frame_cursor (struct frame *f, Cursor cursor)
 static void
 x_clear_frame_area (struct frame *f, int x, int y, int width, int height)
 {
-  x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                x, y, width, height, False);
+  x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), x, y, width, height);
 #ifdef USE_GTK
   /* Must queue a redraw, because scroll bars might have been cleared.  */
   if (FRAME_GTK_WIDGET (f))
@@ -7390,7 +7306,9 @@ x_clear_frame_area (struct frame *f, int x, int y, int width, int height)
 /* RIF: Draw cursor on window W.  */
 
 static void
-x_draw_window_cursor (struct window *w, struct glyph_row *glyph_row, int x, int y, int cursor_type, int cursor_width, int on_p, int active_p)
+x_draw_window_cursor (struct window *w, struct glyph_row *glyph_row, int x,
+                      int y, enum text_cursor_kinds cursor_type,
+                      int cursor_width, bool on_p, bool active_p)
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
 
@@ -7817,9 +7735,8 @@ static int
 x_error_handler (Display *display, XErrorEvent *event)
 {
 #if defined USE_GTK && defined HAVE_GTK3
-  if (event->error_code == BadMatch
-      && event->request_code == X_SetInputFocus
-      && event->minor_code == 0)
+  if ((event->error_code == BadMatch || event->error_code == BadWindow)
+      && event->request_code == X_SetInputFocus)
     {
       return 0;
     }
@@ -8090,13 +8007,10 @@ xim_initialize (struct x_display_info *dpyinfo, char *resource_name)
     {
 #ifdef HAVE_X11R6_XIM
       struct xim_inst_t *xim_inst = xmalloc (sizeof *xim_inst);
-      ptrdiff_t len;
 
       dpyinfo->xim_callback_data = xim_inst;
       xim_inst->dpyinfo = dpyinfo;
-      len = strlen (resource_name);
-      xim_inst->resource_name = xmalloc (len + 1);
-      memcpy (xim_inst->resource_name, resource_name, len + 1);
+      xim_inst->resource_name = xstrdup (resource_name);
       XRegisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
                                       resource_name, emacs_class,
                                       xim_instantiate_callback,
@@ -8202,9 +8116,6 @@ x_set_offset (struct frame *f, register int xoff, register int yoff, int change_
 
   if (change_gravity > 0)
     {
-      FRAME_X_OUTPUT (f)->left_before_move = f->left_pos;
-      FRAME_X_OUTPUT (f)->top_before_move = f->top_pos;
-
       f->top_pos = yoff;
       f->left_pos = xoff;
       f->size_hint_flags &= ~ (XNegative | YNegative);
@@ -8703,8 +8614,8 @@ x_wait_for_event (struct frame *f, int eventtype)
 {
   int level = interrupt_input_blocked;
 
-  SELECT_TYPE fds;
-  EMACS_TIME tmo, tmo_at, time_now;
+  fd_set fds;
+  struct timespec tmo, tmo_at, time_now;
   int fd = ConnectionNumber (FRAME_X_DISPLAY (f));
 
   pending_event_wait.f = f;
@@ -8712,8 +8623,8 @@ x_wait_for_event (struct frame *f, int eventtype)
 
   /* Set timeout to 0.1 second.  Hopefully not noticeable.
      Maybe it should be configurable.  */
-  tmo = make_emacs_time (0, 100 * 1000 * 1000);
-  tmo_at = add_emacs_time (current_emacs_time (), tmo);
+  tmo = make_timespec (0, 100 * 1000 * 1000);
+  tmo_at = timespec_add (current_timespec (), tmo);
 
   while (pending_event_wait.eventtype)
     {
@@ -8726,11 +8637,11 @@ x_wait_for_event (struct frame *f, int eventtype)
       FD_ZERO (&fds);
       FD_SET (fd, &fds);
 
-      time_now = current_emacs_time ();
-      if (EMACS_TIME_LT (tmo_at, time_now))
+      time_now = current_timespec ();
+      if (timespec_cmp (tmo_at, time_now) < 0)
         break;
 
-      tmo = sub_emacs_time (tmo_at, time_now);
+      tmo = timespec_sub (tmo_at, time_now);
       if (pselect (fd + 1, &fds, NULL, NULL, &tmo, NULL) == 0)
         break; /* Timeout */
     }
@@ -9466,16 +9377,8 @@ x_free_frame_resources (struct frame *f)
     dpyinfo->x_focus_event_frame = 0;
   if (f == dpyinfo->x_highlight_frame)
     dpyinfo->x_highlight_frame = 0;
-
   if (f == hlinfo->mouse_face_mouse_frame)
-    {
-      hlinfo->mouse_face_beg_row
-        = hlinfo->mouse_face_beg_col = -1;
-      hlinfo->mouse_face_end_row
-        = hlinfo->mouse_face_end_col = -1;
-      hlinfo->mouse_face_window = Qnil;
-      hlinfo->mouse_face_mouse_frame = 0;
-    }
+    reset_mouse_highlight (hlinfo);
 
   unblock_input ();
 }
@@ -9847,7 +9750,6 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   struct terminal *terminal;
   struct x_display_info *dpyinfo;
   XrmDatabase xrdb;
-  Mouse_HLInfo *hlinfo;
   ptrdiff_t lim;
 
   block_input ();
@@ -9988,8 +9890,6 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   /* We have definitely succeeded.  Record the new connection.  */
 
   dpyinfo = xzalloc (sizeof *dpyinfo);
-  hlinfo = &dpyinfo->mouse_highlight;
-
   terminal = x_create_terminal (dpyinfo);
 
   {
@@ -10060,9 +9960,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   dpyinfo->display = dpy;
 
   /* Set the name of the terminal. */
-  terminal->name = xmalloc (SBYTES (display_name) + 1);
-  memcpy (terminal->name, SSDATA (display_name), SBYTES (display_name));
-  terminal->name[SBYTES (display_name)] = 0;
+  terminal->name = xlispstrdup (display_name);
 
 #if 0
   XSetAfterFunction (x_current_display, x_trace_wire);
@@ -10104,33 +10002,12 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   select_visual (dpyinfo);
   dpyinfo->cmap = DefaultColormapOfScreen (dpyinfo->screen);
   dpyinfo->root_window = RootWindowOfScreen (dpyinfo->screen);
-  dpyinfo->client_leader_window = 0;
-  dpyinfo->grabbed = 0;
-  dpyinfo->reference_count = 0;
   dpyinfo->icon_bitmap_id = -1;
-  dpyinfo->n_fonts = 0;
-  dpyinfo->bitmaps = 0;
-  dpyinfo->bitmaps_size = 0;
-  dpyinfo->bitmaps_last = 0;
-  dpyinfo->scratch_cursor_gc = 0;
-  hlinfo->mouse_face_mouse_frame = 0;
-  hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
-  hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
-  hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
-  hlinfo->mouse_face_window = Qnil;
-  hlinfo->mouse_face_overlay = Qnil;
-  hlinfo->mouse_face_mouse_x = hlinfo->mouse_face_mouse_y = 0;
-  hlinfo->mouse_face_defer = 0;
-  hlinfo->mouse_face_hidden = 0;
-  dpyinfo->x_focus_frame = 0;
-  dpyinfo->x_focus_event_frame = 0;
-  dpyinfo->x_highlight_frame = 0;
   dpyinfo->wm_type = X_WMTYPE_UNKNOWN;
 
-  /* See if we can construct pixel values from RGB values.  */
-  dpyinfo->red_bits = dpyinfo->blue_bits = dpyinfo->green_bits = 0;
-  dpyinfo->red_offset = dpyinfo->blue_offset = dpyinfo->green_offset = 0;
+  reset_mouse_highlight (&dpyinfo->mouse_highlight);
 
+  /* See if we can construct pixel values from RGB values.  */
   if (dpyinfo->visual->class == TrueColor)
     {
       get_bits_and_offset (dpyinfo->visual->red_mask,
@@ -10291,14 +10168,9 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   }
 
   dpyinfo->x_dnd_atoms_size = 8;
-  dpyinfo->x_dnd_atoms_length = 0;
   dpyinfo->x_dnd_atoms = xmalloc (sizeof *dpyinfo->x_dnd_atoms
                                   * dpyinfo->x_dnd_atoms_size);
 
-  dpyinfo->net_supported_atoms = NULL;
-  dpyinfo->nr_net_supported_atoms = 0;
-  dpyinfo->net_supported_window = 0;
-
   connection = ConnectionNumber (dpyinfo->display);
   dpyinfo->connection = connection;
   dpyinfo->gray
@@ -10491,7 +10363,7 @@ x_activate_timeout_atimer (void)
   block_input ();
   if (!x_timeout_atimer_activated_flag)
     {
-      EMACS_TIME interval = make_emacs_time (0, 100 * 1000 * 1000);
+      struct timespec interval = make_timespec (0, 100 * 1000 * 1000);
       start_atimer (ATIMER_RELATIVE, interval, x_process_timeouts, 0);
       x_timeout_atimer_activated_flag = 1;
     }
@@ -10514,7 +10386,6 @@ static struct redisplay_interface x_redisplay_interface =
     x_after_update_window_line,
     x_update_window_begin,
     x_update_window_end,
-    x_cursor_to,
     x_flush,
 #ifdef XFlush
     x_flush,
@@ -10627,11 +10498,11 @@ x_create_terminal (struct x_display_info *dpyinfo)
   terminal->delete_glyphs_hook = x_delete_glyphs;
   terminal->ring_bell_hook = XTring_bell;
   terminal->toggle_invisible_pointer_hook = XTtoggle_invisible_pointer;
-  terminal->reset_terminal_modes_hook = XTreset_terminal_modes;
-  terminal->set_terminal_modes_hook = XTset_terminal_modes;
+  terminal->reset_terminal_modes_hook = NULL;
+  terminal->set_terminal_modes_hook = NULL;
   terminal->update_begin_hook = x_update_begin;
   terminal->update_end_hook = x_update_end;
-  terminal->set_terminal_window_hook = XTset_terminal_window;
+  terminal->set_terminal_window_hook = NULL;
   terminal->read_socket_hook = XTread_socket;
   terminal->frame_up_to_date_hook = XTframe_up_to_date;
   terminal->mouse_position_hook = XTmouse_position;
diff --git a/src/xterm.h b/src/xterm.h
index 5324ef628e7..c579d342215 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -71,14 +71,13 @@ typedef GtkWidget *xt_or_gtk_widget;
 #define USE_GTK_TOOLTIP
 #endif
 
-
-/* Bookkeeping to distinguish X versions.  */
-
-
 #ifdef HAVE_X_I18N
 #include <X11/Xlocale.h>
 #endif
-
+
+#include "dispextern.h"
+#include "termhooks.h"
+
 #define BLACK_PIX_DEFAULT(f) BlackPixel (FRAME_X_DISPLAY (f), \
                                          XScreenNumberOfScreen (FRAME_X_SCREEN (f)))
 #define WHITE_PIX_DEFAULT(f) WhitePixel (FRAME_X_DISPLAY (f), \
@@ -407,9 +406,6 @@ extern bool x_display_ok (const char *);
 
 extern void select_visual (struct x_display_info *);
 
-
-struct font;
-
 /* Each X frame object points to its own struct x_output object
    in the output_data.x field.  The x_output structure contains
    the information that is specific to X windows.  */
@@ -630,11 +626,6 @@ struct x_output
   int move_offset_top;
   int move_offset_left;
 
-  /* The frame's left/top offsets before we call XMoveWindow.  See
-     x_check_expected_move.  */
-  int left_before_move;
-  int top_before_move;
-
   /* Non-zero if _NET_WM_STATE_HIDDEN is set for this frame.  */
   unsigned net_wm_state_hidden_seen : 1;
 };
@@ -810,12 +801,12 @@ struct scroll_bar
   /* If the scroll bar handle is currently being dragged by the user,
      this is the number of pixels from the top of the handle to the
      place where the user grabbed it.  If the handle isn't currently
-     being dragged, this is Qnil.  */
-  Lisp_Object dragging;
+     being dragged, this is -1.  */
+  int dragging;
 
   /* 1 if the background of the fringe that is adjacent to a scroll
      bar is extended to the gap between the fringe and the bar.  */
-  unsigned int fringe_extended_p : 1;
+  unsigned fringe_extended_p : 1;
 };
 
 /* Turning a lisp vector value into a pointer to a struct scroll_bar.  */
@@ -917,14 +908,6 @@ struct selection_input_event
 #define SELECTION_EVENT_TIME(eventp)    \
   (((struct selection_input_event *) (eventp))->time)
 
-
-struct window;
-struct glyph_matrix;
-struct frame;
-struct input_event;
-struct face;
-struct image;
-
 /* From xselect.c.  */
 
 void x_handle_selection_notify (XSelectionEvent *);
@@ -966,7 +949,7 @@ extern bool x_alloc_lighter_color_for_widget (Widget, Display *, Colormap,
 #endif
 extern bool x_alloc_nearest_color (struct frame *, Colormap, XColor *);
 extern void x_query_color (struct frame *f, XColor *);
-extern void x_clear_area (Display *, Window, int, int, int, int, int);
+extern void x_clear_area (Display *, Window, int, int, int, int);
 #if defined HAVE_MENUS && !defined USE_X_TOOLKIT && !defined USE_GTK
 extern void x_mouse_leave (struct x_display_info *);
 #endif
@@ -1076,10 +1059,6 @@ extern Lisp_Object Qx_gtk_map_stock;
 
 #define FRAME_X_EMBEDDED_P(f) (FRAME_X_OUTPUT(f)->explicit_parent != 0)
 
-
-#define FONT_TYPE_FOR_UNIBYTE(font, ch) 0
-#define FONT_TYPE_FOR_MULTIBYTE(font, ch) 0
-
 #define STORE_XCHAR2B(chp, b1, b2) \
   ((chp)->byte1 = (b1), (chp)->byte2 = (b2))
 
@@ -1089,7 +1068,6 @@ extern Lisp_Object Qx_gtk_map_stock;
 #define XCHAR2B_BYTE2(chp) \
   ((chp)->byte2)
 
-
 #define STORE_NATIVE_RECT(nr,rx,ry,rwidth,rheight)      \
   ((nr).x = (rx),                                       \
    (nr).y = (ry),                                       \