104 files changed, 8269 insertions, 5774 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 5d2e75577b9..c1b7c6cc8c3 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,1648 @@
+2014-10-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Cleanup terminal handling code.
+        * dispextern.h (get_named_tty): Remove prototype but...
+        * termhooks.h (get_named_terminal): ...resurrect it under
+        more meaningful name.
+        (get_terminal): Likewise, but with...
+        (decode_live_terminal): ...this name.
+        (decode_tty_terminal): Add prototype.
+        * term.c (get_tty_terminal): Remove.
+        (get_named_tty): Remove.
+        (Ftty_display_color_p, Ftty_display_color_cells, Ftty_type)
+        (Fcontrolling_tty_p, Fsuspend_tty, Fresume_tty):
+        Use decode_tty_terminal.
+        (Ftty_no_underline, Ftty_top_frame): Use decode_live_terminal.
+        * terminal.c (get_terminal): Refactor to...
+        (decode_terminal, decode_live_terminal): ...new functions.
+        (decode_tty_terminal): Replacement for get_tty_terminal.
+        (get_named_terminal): Likewise for get_named_tty.
+        * coding.c (Fset_terminal_coding_system_internal)
+        (Fterminal_coding_system, Fset_keyboard_coding_system_internal):
+        (Fkeyboard_coding_system):
+        * composite.c (Fcomposition_get_gstring):
+        * dispnew.c (Fsend_string_to_terminal):
+        * frame.c (Fmake_terminal_frame):
+        * nsfns.m (check_ns_display_info):
+        * w32fns.c, xfns.c (check_x_display_info):
+        * xselect.c (frame_for_x_selection): Use decode_live_terminal.
+        * keyboard.c (handle_interrupt_signal, handle_interrupt)
+        (Fset_quit_char): Use get_named_terminal.
+        (Fset_output_flow_control, Fset_input_meta_mode):
+        Use decode_tty_terminal.
+
+2014-10-13  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32term.h (ALIGN_STACK): Use _WIN64, not _W64, to distinguish
+        between 32-bit and 64-bit MinGW builds.  (Bug#18699)
+
+2014-10-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix port to Debian GNU/kFreeBSD 7 (wheezy) (Bug#18666).
+        * process.c (accept4) [!HAVE_ACCEPT4]: New macro.
+
+2014-10-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * frame.c (Fmouse_pixel_position): Call Vmouse_position_function
+        (bug#18638).
+
+2014-10-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * editfns.c (dump_tz_string): No longer const.
+        It might be modified.
+
+        * nsmenu.m (clear): Assume OS X 10.6 or later.
+
+2014-10-12  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * unexmacosx.c: Remove include ppc/reloc.h.
+        (unrelocate, copy_dysymtab): Remove PPC code.
+        (rebase_reloc_address): Remove, only used for PPC:
+
+        * nsterm.m: Always include macfont.h on COCOA.
+        (ns_update_auto_hide_menu_bar, ns_draw_fringe_bitmap)
+        (ns_dumpglyphs_image, ns_check_menu_open)
+        (applicationDidFinishLaunching)
+        (antialiasThresholdDidChange:)
+        (keyDown:, toggleFullScreen:, setPosition:portion:whole:): Remove
+        checks for OSX <= 10.5/10.6.
+        (changeFont:): Use macfont on COCOA, nsfont on GNUSTEP.
+        (syms_of_nsterm): Call syms_of_macfont on COCOA, syms_of_nsfont on
+        GNUSTEP.
+
+        * nsterm.h (MAC_OS_X_VERSION_10_4, MAC_OS_X_VERSION_10_5): Remove.
+        (NS_HAVE_NSINTEGER): Remove block.
+        Remove >= OSX 10.6 tests.
+
+        * nsmenu.m (NSMenuDidBeginTrackingNotification): Remove.
+        (x_activate_menubar, trackingNotification:): Remove check for
+        OSX >= 10.5.
+        (menuNeedsUpdate:): Remove check for OSX < 10.5.
+
+        * nsimage.m (allocInitFromFile:): Remove code for OSX < 10.6.
+
+        * nsfns.m: Always include macfont.h on COCOA.
+        (ns_filename_from_panel, ns_directory_from_panel)
+        (Fx_create_frame, Fns_popup_font_panel, ns_run_file_dialog)
+        (Fns_read_file_name, Fns_list_services): Remove code for OSX < 10.6
+
+        * macfont.m: Remove >= 1050 check.
+        (macfont_create_family_with_symbol)
+        (macfont_get_glyph_for_character)
+        (mac_font_get_glyphs_for_variants)
+        (mac_ctfont_create_available_families, syms_of_macfont): Remove
+        code for OSX < 10.6.
+        (mac_font_family_group, mac_font_family_compare): Remove, only used
+        for OSX < 10.6.
+
+        * macfont.h (MAC_FONT_FORMAT_ATTRIBUTE, MAC_FONT_FORMAT_BITMAP)
+        (mac_font_copy_non_synthetic_table): Remove versions for OSX < 10.6
+
+        * Makefile.in: Replace nsfont.o macfont.o with ns_fontfile in
+        comment.
+
+2014-10-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix putenv race conditions with undefined behavior (Bug#8705).
+        Do all putenv calls before Emacs creates any threads.
+        Use a safer way to modify the TZ environment variable in the
+        presence of multiple threads.  For further thread-safety,
+        prefer localtime_r and gmtime_r to localtime and gmtime,
+        and prefer struct tm's tm_gmtoff (if available) to calling
+        both localtime_r and gmtime_r.
+        * dbusbind.c (Fdbus__init_bus): Move xputenv call from here ...
+        (init_dbusbind): ... to this new function.
+        * emacs.c (main) [HAVE_DBUS]: Call it before creating threads.
+        * xterm.c (x_term_init): Move xputenv call from here ...
+        (init_xterm): ... to this new function.
+        * emacs.c (main) [USE_GTK]: Call it before creating threads.
+        * editfns.c (HAVE_TM_GMTOFF): Default to false.
+        (dump_tz_string): New constant.
+        (init_editfns): Use it.  This centralizes the dump_tz stuff.
+        Call set_time_zone_rule here, so that its xputenv is done
+        before Emacs goes multithreaded.
+        (mktime_z) [!HAVE_TZALLOC]: New function, which is typically
+        thread-safe enough for Emacs.
+        (format_time_string, Fdecode_time, Fcurrent_time_string)
+        (Fcurrent_time_zone):
+        Prefer localtime_r and gmtime_r, which are more thread-safe, to
+        localtime and gmtime.  Remove now-unnecessary calls to block_input.
+        (tm_gmtoff): New static function.
+        (Fdecode_time, Fcurrent_time_zone): Use it.
+        (Fencode_time): Use mktime_z, for better thread-safety.
+        (set_time_zone_rule): Now static.  Rewrite to be mostly thread-safe,
+        i.e., not quite thread-safe but good enough for Emacs typical usage.
+        Do not reclaim storage that is in the environment; let it leak.
+        Always call tzset, since localtime_r does not.
+        * emacs.c (dump_tz, Fdump_emacs) [HAVE_TZSET]: Remove dump_tz stuff.
+        This is now done in init_editfns.
+        * systime.h (mktime_z, timezone_t, tzalloc, tzfree) [!HAVE_TZALLOC]:
+        New macros and declarations, for platforms lacking tzalloc & friends.
+
+2014-10-09  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * lisp.h (USE_STACK_STRING): Now true only if USE_STACK CONS.
+        On x86 platforms this works around GCC bug 63495
+        <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63495>,
+        and more generally should fix a portability problem in Emacs.
+        Problem reported by Stefan Monnier in:
+        http://lists.gnu.org/archive/html/emacs-devel/2014-10/msg00261.html
+
+2014-10-08  Leo Liu  <sdl.web@gmail.com>
+
+        Enhance terpri to allow conditionally output a newline.  (Bug#18652)
+        * keymap.c (describe_vector_princ):
+        * keyboard.c (Fcommand_error_default_function): Adapt to change to
+        Fterpri.
+
+        * print.c (printchar_stdout_last): Declare.
+        (printchar): Record the last char written to stdout.
+        (Fterpri): Add optional argument ENSURE.
+
+2014-10-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32inevt.c (maybe_generate_resize_event): Pass non-zero as the
+        DELAY argument to change_frame_size, so that the frame size
+        changes, if any are needed, are delayed until the next redisplay.
+        This is to avoid a too early QUIT inside change_frame_size, when
+        it calls Lisp in frame_windows_min_size, in case one of the events
+        we've read sets the quit-flag.  (Bug#18649)
+
+        * w32fns.c (check_x_display_info): Accept terminal objects as
+        argument, to follow what xfns.c does.
+
+2014-10-07  Glenn Morris  <rgm@gnu.org>
+
+        * Makefile.in ($(srcdir)/macuvs.h)
+        ($(lispsource)/international/charprop.el): Add explicit FORCE.
+
+2014-10-07  Eli Zaretskii  <eliz@gnu.org>
+
+        * decompress.c (init_zlib_functions): Move the message about zlib
+        being unavailable from here...
+        (Fzlib_decompress_region): ...to here.  (Bug#18650)
+
+2014-10-07  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * font.c (Ffont_get_glyphs): Use validate_subarray and fix
+        the case where an optional string is used.  Adjust docstring.
+
+2014-10-06  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lisp.mk (lisp): Remove w32-common-fns.elc.
+
+2014-10-05  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * keyboard.c (Qleft, Qright): Remove duplicate definitions (Bug#9927).
+        These were already defined in buffer.c, and the duplicate
+        definitions cause problems on platforms like 'gcc -fno-common'.
+        Reported by Peter Dyballa in: http://bugs.gnu.org/9927#137
+
+2014-10-05  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (updateFrameSize:): Only call update_frame_tool_bar
+        if toolbar is visible.
+
+        * nsfont.m (nsfont_draw): Use CGFloat for GNUstep newer than
+        0.23 (Bug#18030).
+
+        * nsterm.m (syms_of_nsterm): ns-use-fullscreen-animation is new.
+        (toggleFullScreen:): Use ns-use-fullscreen-animation for animate.
+        (ns_select, ns_read_socket): Use unwind_protect to decrease
+        apploopnr (Bug#18345).
+        (ns_draw_window_cursor): Adjust y for hbar cursor only if smaller than
+        line height (Bug#17977).
+
+        * macfont.m: Fix indentation and import changes from macport 24.3.94.
+        (macfont_closest_traits_index): New function.
+        (macfont_closest_traits_index_p): Rename from
+        macfont_closest_traits_index.
+        (macfont_list): Use macfont_closest_traits_index_p.
+
+2014-10-05  K. Handa  <handa@gnu.org>
+
+        * coding.c (detect_coding_iso_2022): Set coding->rejected
+        correctly when an invalid escape sequence is found (Bug#18610).
+
+2014-10-04  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (create_menus): Only add tearoffs to empty menus.
+        (xg_update_submenu): Remove has_tearoff_p, pass 1 to create_menus
+        for add_tearoff_p.
+
+2014-10-04  Martin Rudalics  <rudalics@gmx.at>
+
+        * buffer.c (scroll_bar_width, scroll_bar_height):
+        Fix doc-strings.
+        * window.c (Fset_window_scroll_bars): Fix doc-string.
+        (Fwindow_scroll_bars): Have it return what the doc-string says.
+
+2014-10-03  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (move_it_by_lines): Call reseat_1 after moving the
+        iterator backwards, to resync the bidi iterator.  (Bug#18584)
+
+2014-10-03  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Consistently use min and max macros from lisp.h.
+        * coding.c (min, max):
+        * font.c (MAX):
+        * unexhp9k800.c (min):
+        * unexw32.c (min, max): Use definitions from lisp.h.
+        * regex.c (MAX, MIN) [!emacs]: Define own max and min as such.
+        Adjust users.
+        * gmalloc.c (min): Tiny style change.
+
+        * fileio.c (emacs_readlinkat, Finsert_file_contents):
+        * w32fns.c, xfns.c (x_create_tip_frame): Use AUTO_STRING.
+
+2014-10-03  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix x-focus-frame bug with "Not an in-range integer" (Bug#18586).
+        * xselect.c (X_SHRT_MAX, X_SHRT_MIN, X_LONG_MAX, X_LONG_MIN)
+        (X_ULONG_MAX): Move these macros to xterm.h.
+        (x_fill_property_data): Be more generous about allowing either
+        signed or unsigned data of the appropriate width.
+        * xterm.h (x_display_set_last_user_time): New function.
+        All setters of last_user_time changd to use this function.
+        If ENABLE_CHECKING, check that the times are in range.
+
+2014-10-02  Eli Zaretskii  <eliz@gnu.org>
+
+        * dispnew.c (adjust_decode_mode_spec_buffer): Use 'int' instead of
+        'ssize_t'.  Suggested by Paul Eggert <eggert@cs.ucla.edu>.
+
+2014-10-02  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xfaces.c (Finternal_set_lisp_face_attribute): Don't try to
+        make a font_object from a tty frame (Bug#18573).
+        (Finternal_set_lisp_face_attribute): Add FIXME comment.
+
+2014-10-02  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * alloc.c (mark_overlay): Assume that overlay boundaries are
+        always markers.  Add comment.
+        * lread.c (read_internal_start): Use convenient validate_subarray.
+        Adjust docstring.
+        (Fread_from_string): Adjust docstring.
+
+2014-10-02  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lisp.h: Fix up compilation for USE_STACK_LISP_OBJECTS=false.
+
+        * nsselect.m (ns-own-selection-internal, ns-disown-selection-internal):
+        Rename from the "x-" prefix.
+
+2014-10-01  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xselect.c (selection-converter-alist): Fix docstring.
+
+2014-10-01  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32proc.c (sys_spawnve): Avoid modification of the CMDNAME
+        argument passed by the caller, when we mirror all slashes into
+        backslashes.
+
+2014-10-01  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * gtkutil.c (xg_set_toolkit_horizontal_scroll_bar_thumb):
+        Resurrect old code and fix compilation with GTK < 2.13.6.
+
+2014-10-01  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use AUTO_CONS instead of SCOPED_CONS, etc.
+        * frame.h (AUTO_FRAME_ARG): Rename from FRAME_PARAMETER.
+        * lisp.h (AUTO_CONS): Rename from scoped_cons.
+        (AUTO_LIST1): Rename from scoped_list1.
+        (AUTO_LIST2): Rename from scoped_list2.
+        (AUTO_LIST3): Rename from scoped_list3.
+        (AUTO_LIST4): Rename from scoped_list4.
+        (AUTO_STRING): Rename from SCOPED_STRING.
+        * frame.h (AUTO_FRAME_ARG):
+        * lisp.h (AUTO_CONS, AUTO_LIST1, AUTO_LIST2, AUTO_LIST3)
+        (AUTO_LIST4, AUTO_STRING):
+        Prepend a new argument 'name'.
+        Declare a variable instead of yielding a value.
+        All uses changed.
+        * lisp.h (STACK_CONS, AUTO_CONS_EXPR): New internal macros.
+
+2014-09-30  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32fns.c (w32_createwindow): Accept an additional argument, an
+        array of 2 values specifying the coordinates of the frame's
+        top-left corner.  Use these values instead of calling x_get_arg,
+        which can cons Lisp objects, and therefore cannot be called except
+        from the main thread.  Remove redundant tests for the default
+        values.
+        (my_create_window): Move the calculation of the coordinates of the
+        frame's top-left edge here.  Pass them to the input thread via the
+        second parameter of the WM_EMACS_CREATEWINDOW message.
+        See http://lists.gnu.org/archive/html/emacs-devel/2014-09/msg00892.html
+        for the details.
+
+2014-09-30  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (cursor_row_fully_visible_p): Update commentary.
+        (redisplay_window): Treat the frame's frozen_window_starts flag
+        the same way as the optional_new_start flag for the window: only
+        obey it if the glyph row showing point will be fully visible.
+        Likewise when the window start is in a continuation line.  If,
+        after trying everything under the 'force_start' label, point is
+        still not fully visible, give up and scroll the window.
+        Add debugging traces.  (Bug#18545)
+
+        * window.c (Frecenter): Set the window's redisplay flag.
+
+2014-09-30  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32term.c (w32_read_socket): Don't use frame dimensions for
+        resizing if GetClientRect returned an empty (0, 0, 0, 0)
+        rectangle.  Check the return value of GetClientRect, and don't use
+        the results if it didn't succeed.
+
+        * dispnew.c (change_frame_size_1): Recompute the frame dimensions
+        in columns and lines after correcting the pixel dimensions in
+        check_frame_size.
+        (adjust_decode_mode_spec_buffer): Add assertion to avoid passing
+        negative values to xrealloc.  (Bug#18528)
+
+2014-09-30  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * alloc.c: Remove now-unnecessary check.
+        Suggested by Dmitry Antipov in:
+        http://lists.gnu.org/archive/html/emacs-devel/2014-09/msg00891.html
+
+        * xterm.c (x_term_init): Allocate temps on stack, not on heap.
+
+        * frame.c (x_set_frame_parameters): Port --enable-gcc-warnings
+        to Ubuntu 14.04.1 x86-64.
+
+        Simplify stack-allocated Lisp objects, and make them more portable.
+        The build_local_string macro was used in two ways: (1) string
+        literals for which scoped allocation suffices, and (2) file name
+        components, where it's not safe in general to assume bounded-size
+        ASCII data.  Simplify by defining a new macro SCOPED_STRING that
+        allocates a block-scope string, and by using SCOPED_STRING for (1)
+        and build_string for (2).  Furthermore, actually use stack
+        allocation only for objects known to have sufficient alignment.
+        This simpler implementation means Emacs can make
+        USE_STACK_LISP_OBJECTS the default unless GC_MARK_STACK !=
+        GC_MAKE_GCPROS_NOOPS.
+        * lisp.h (GCALIGNED): Align even if !USE_STACK_LISP_OBJECTS,
+        for fewer differences among implementations.
+        (struct Lisp_String): Now GCALIGNED.
+        (USE_STACK_LISP_OBJECTS): Default to true, since the
+        implementation no longer insists on a nonempty GCALIGNED.
+        But make it false if GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS.
+        (SCOPED_CONS_INITIALIZER): Remove, since it's no longer needed
+        separately.  Move definiens to scoped_cons.  The old definition
+        was incorrect when GCALIGNED was defined to be empty.
+        (union Aligned_String): New type.
+        (USE_STACK_CONS, USE_STACK_STRING): New constants, so that the
+        implementation ports to compilers that don't align strictly enough.
+        Don't worry about the union sizes; it's not worth bothering about.
+        (scoped_cons, scoped_list1, scoped_list3, scoped_list4):
+        Rewrite using USE_STACK_CONS.
+        (scoped_cons): Assume the use of union Aligned_Cons.
+        (lisp_string_size, make_local_string, build_local_string): Remove.
+        Unless otherwise specified, all callers of build_local_string
+        changed to use SCOPED_STRING.
+        (SCOPED_STRING): New macro.
+        * data.c (wrong_choice):
+        * menu.c (single_menu_item):
+        * process.c (Fformat_network_address):
+        Hoist use of SCOPED_STRING out of a scope, so that its returned
+        object lives long enough.
+        * fileio.c (Fexpand_file_name): Use build_string, not SCOPED_STRING,
+        as the string might be long or might not be ASCII.
+
+2014-09-29  Eli Zaretskii  <eliz@gnu.org>
+
+        * msdos.c (internal_terminal_init): Bump version to 25.
+
+2014-09-29  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Keep stack-allocated Lisp objects fast rather than versatile.
+        * lisp.h (union Aligned_Cons) [!GCALIGNED]: Define as such.
+        (SCOPED_CONS_INITIALIZER): New macro.
+        (scoped_cons) [USE_STACK_LISP_OBJECTS]: Use it.
+        (USE_LOCAL_ALLOCA): Remove.
+        (local_cons, local_list1, local_list2, local_list3, local_list4):
+        Remove.  Stack overflow checking makes them too slow.
+        (make_local_vector): Likewise.  Also we just don't have enough
+        users for it.
+        (enum LISP_STRING_OVERHEAD): Remove.
+        (local_string_init, local_vector_init): Remove prototypes.
+        (make_local_string, build_local_string): Redesign to target short
+        compile-time string constants, fall back to regular string allocation
+        where appropriate.
+        (lisp_string_size): New function.
+        (verify_ascii) [ENABLE_CHECKING]: Add prototype.
+        * alloc.c (local_string_init, local_vector_init): Remove.
+        (verify_ascii) [ENABLE_CHECKING]: New function.
+        * buffer.c, charset.c, chartab.c, data.c, editfns.c, emacs.c, fileio.c:
+        * fns.c, font.c, fontset.c, frame.c, keyboard.c, keymap.c, lread.c:
+        * menu.c, minibuf.c, process.c, textprop.c, xdisp.c, xfns.c, xfont.c:
+        * xselect.c, xterm.c: All related users changed.
+
+2014-09-28  Ken Brown  <kbrown@cornell.edu>
+
+        * sheap.c (bss_sbrk_buffer_beg): Remove redundant variable.
+        * gmalloc.c [CYGWIN]: Adapt to change in sheap.c.
+
+2014-09-27  Ken Brown  <kbrown@cornell.edu>
+
+        Fix implementation of HYBRID_MALLOC on Cygwin.
+        * sheap.c (bss_sbrk_buffer_end): Cast to void *.
+        (bss_sbrk_buffer_beg): New variable.  Use it...
+        * gmalloc.c (ALLOCATED_BEFORE_DUMPING) [CYGWIN]: ...here, to fix
+        incorrect definition.
+
+2014-09-27  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (track-mouse): Rename to internal--track-mouse.
+        Make it into a function and change arg to be a function.
+
+        * lisp.mk (lisp): Add elisp-mode.elc.
+
+2014-09-26  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xfns.c (x_default_scroll_bar_color_parameter):
+        Use USE_LOCAL_ALLOCA only if USE_TOOLKIT_SCROLL_BARS,
+        to pacify --enable-gcc-warnings in non-scrollbar builds.
+
+2014-09-26  Ken Brown  <kbrown@cornell.edu>
+
+        * w32term.h (ALIGN_STACK): Fix the cpp condition.
+
+2014-09-25  Eli Zaretskii  <eliz@gnu.org>
+
+        * lisp.h (USE_STACK_LISP_OBJECTS): Default to false for 32-bit
+        MinGW builds that use GCC before 4.2.
+
+        Default to stack objects on DOS_NT platforms as well.
+        * w32term.h (ALIGN_STACK) [__GNUC__]: Define to
+        __attribute__((force_align_arg_pointer)) for GCC 4.2 and later.
+
+        * lisp.h (USE_STACK_LISP_OBJECTS): Remove the !DOS_NT condition.
+
+        * w32proc.c (enum_locale_fn, enum_codepage_fn): Add the
+        ALIGN_STACK attribute.
+
+        * w32fns.c (w32_monitor_enum): Add the ALIGN_STACK attribute.
+
+        * w32uniscribe.c (add_opentype_font_name_to_list): Add the
+        ALIGN_STACK attribute.
+
+        * w32font.c (add_font_name_to_list, add_font_entity_to_list)
+        (add_one_font_entity_to_list): Add the ALIGN_STACK attribute.
+
+2014-09-25  Martin Rudalics  <rudalics@gmx.at>
+
+        * frame.c (frame_inhibit_resize):
+        * widget.c (EmacsFrameResize):
+        * window.c (resize_frame_windows, Fset_window_configuration):
+        * xdisp.c (expose_frame):
+        * xfns.c (x_change_tool_bar_height):
+        * xmenu.c (update_frame_menubar):
+        * xterm.c (handle_one_xevent, x_new_font, x_set_window_size_1):
+        Remove code left dead after 2014-07-27 changes.
+
+2014-09-25  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix local_cons etc. to not exhaust the stack when in a loop.
+        Problem reported in:
+        http://lists.gnu.org/archive/html/emacs-devel/2014-09/msg00696.html
+        * buffer.c (Fother_buffer, other_buffer_safely, init_buffer):
+        * charset.c (load_charset_map_from_file, Ffind_charset_region)
+        (Ffind_charset_string):
+        * chartab.c (uniprop_encode_value_numeric, uniprop_table):
+        * data.c (wrong_range):
+        * editfns.c (Fpropertize, format2):
+        * emacs.c (init_cmdargs, decode_env_path):
+        * fileio.c (auto_save_error):
+        * fns.c (Fyes_or_no_p):
+        * font.c (font_style_to_value, font_parse_xlfd)
+        (font_parse_family_registry, font_delete_unmatched)
+        (font_add_log):
+        * fontset.c (Fset_fontset_font):
+        * frame.c (x_get_arg):
+        * keyboard.c (echo_dash, safe_run_hooks_error, parse_menu_item)
+        (read_char_minibuf_menu_prompt):
+        * keymap.c (silly_event_symbol_error, describe_vector):
+        * lread.c (load_warn_old_style_backquotes):
+        * menu.c (single_menu_item):
+        * minibuf.c (Fread_buffer):
+        * process.c (status_message, Fformat_network_address)
+        (server_accept_connection):
+        * textprop.c (copy_text_properties):
+        * xdisp.c (Fcurrent_bidi_paragraph_direction):
+        * xfns.c (x_default_scroll_bar_color_parameter):
+        * xfont.c (xfont_open):
+        * xselect.c (x_clipboard_manager_error_1):
+        * xterm.c (x_term_init):
+        Put USE_LOCAL_ALLOCA at the start of the function.
+        * fns.c (maybe_resize_hash_table): Use build_string instead of
+        build_local_string, since we'd otherwise need a conditional
+        USE_LOCAL_ALLOCA here, but this is just debugging output and is
+        not worth the bother of optimization.
+        * font.c (font_delete_unmatched): Remove by-hand code that
+        observed MAX_ALLOCA limit, since it's now done automatically.
+        * keymap.c (Fsingle_key_description): Put USE_SAFE_ALLOCA at top,
+        since build_local_string needs its sa_alloc.
+        * lisp.h (lisp_word_count): New function.
+        (SAFE_ALLOCA_LISP): Use it.
+        (USE_LOCAL_ALLOCA): New macro.
+        (local_cons, make_local_vector, make_local_string):
+        Observe the MAX_ALLOCA limit.
+        (LISP_STRING_OVERHEAD): New constant.
+        (make_local_string): Use it.
+
+2014-09-24  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Default to stack objects on non-GNU/Linux, non-DOS_NT platforms.
+        * lisp.h (USE_STACK_LISP_OBJECTS): Also default to true
+        if !defined DOS_NT && !defined GNU_LINUX.  I've tested this on AIX
+        and Solaris and it's likely to work on similar platforms.
+
+        Avoid signed integer overflow when converting Time to ptrdiff_t.
+        * keyboard.c (INPUT_EVENT_POS_MAX, INPUT_EVENT_POS_MIN):
+        New macros.
+        (position_to_Time, Time_to_position): New functions.
+        (gen_help_event, kbd_buffer_get_event): Use them.
+        * systime.h (Time) [emacs && !HAVE_X_WINDOWS]:
+        Go back to plain 'unsigned long', so that 'Time' is the same
+        for both X and non-X builds; this is less likely to cause surprise.
+        * termhooks.h: Remove compile-time check that Time and ptrdiff_t
+        are the same size; this is no longer required.
+
+        * keyboard.c (make_lispy_event): Avoid unnecessary tests
+        of bit 28 and of whether an unsigned value is negative.
+        This simplifies the code a bit, and pacifies clang 3.4.
+
+2014-09-24  Eli Zaretskii  <eliz@gnu.org>
+
+        * systime.h (Time): Define as size_t, to be consistent with 64-bit
+        Windows builds, where 'long' is a 32-bit type.
+
+        * w32inevt.h (w32_console_mouse_position): Update the argument
+        types to use 'Time'.
+
+        * w32term.c (w32_mouse_position)
+        (x_horizontal_scroll_bar_report_motion)
+        (x_scroll_bar_report_motion): Update the argument types to use
+        'Time'.
+
+2014-09-24  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * termhooks.h (enum scroll_bar_part): Begin from 0 to allow...
+        (struct input_event): ...unsigned bitfields.  Likewise for
+        `event_kind' member.  Prefer unsigned for `code' and 'modifiers'.
+        Use `timestamp' for HELP_EVENT position.  Add compile-time assert.
+        * keyboard.c (gen_help_event, kbd_buffer_store_help_event)
+        (kbd_buffer_get_event): Adjust users.
+        (scroll_bar_parts): Add Qnil to match scroll_bar_nowhere.
+        (make_scroll_bar_position): New function, refactored out of...
+        (make_lispy_event): ...adjusted user.
+        * nsterm.h (EmacsScroller): Use enum for `last_hit_part' member.
+        * nsterm.m (ns_mouse_position, mouseUp):
+        * term.c (term_mouse_position):
+        * w32inevt.c (w32_console_mouse_position):
+        * w32term.c (w32_mouse_position):
+        * xterm.c (XTmouse_position): Use scroll_bar_above_handle.
+        (x_send_scroll_bar_event, xm_scroll_callback, xg_scroll_callback):
+        Prefer enum and explicit enum members to integers and numeric values.
+
+        * chartab.c (uniprop_encode_value_numeric):
+        * font.c (font_style_to_value): Use make_local_vector.
+        (font_delete_unmatched): Use local_cons but respect MAX_ALLOCA.
+        * keymap.c (append_key): Use scoped_list1.
+
+        * lisp.h (USE_STACK_LISP_OBJECTS): Enable by default if GNU_LINUX
+        && __GNUC__ && !__clang__.  Mention known problems.  Adjust comment.
+
+2014-09-24  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix some slow uses and misuses of strcat.
+        * doc.c (get_doc_string):
+        * gtkutil.c (get_utf8_string):
+        * xsmfns.c (x_session_initialize):
+        Avoid recomputation of string length.
+        * ftfont.c (ftfont_spec_pattern):
+        * xfns.c (xic_create_fontsetname):
+        Don't assume output buffer is initially zero.
+
+2014-09-23  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * lisp.h (lispstpcpy): Rename from lispstrcpy, and act like stpcpy.
+        All callers changed.
+        * xterm.c (x_term_init): Use new functionality to avoid two needs
+        to compute a string length.
+
+        * dispextern.h, xdisp.c (window_box_right_offset): Now static.
+
+2014-09-23  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Use known length of a Lisp string to copy it faster.
+        * lisp.h (lispstrcpy): New function.  Add comment.
+        * callproc.c (child_setup):
+        * dbusbind.c (xd_append_arg):
+        * doc.c (get_doc_string):
+        * font.c (Ffont_xlfd_name):
+        * frame.c (xrdb_get_resource):
+        * process.c (Fmake_network_process, network_interface_info):
+        * w32fns.c (Fx_open_connection):
+        * w32proc.c (sys_spawnve):
+        * xfns.c (select_visual):
+        * xfont.c (xfont_list):
+        * xsmfns.c (x_session_initialize):
+        * xterm.c (x_term_init): Use it.
+
+2014-09-23  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix SAFE_ALLOCA to not exhaust the stack when in a loop.
+        Problem reported by Dmitry Antipov in thread leading to:
+        http://lists.gnu.org/archive/html/emacs-devel/2014-09/msg00713.html
+        This patch fixes only SAFE_ALLOCA, SAFE_NALLOCA, and SAFE_ALLOCA_LISP;
+        the experimental local_* macros enabled by USE_LOCAL_ALLOCATORS
+        remain unfixed.
+        * callproc.c (call_process): Save and restore sa_avail.
+        * lisp.h (USE_SAFE_ALLOCA): Define sa_avail.
+        (AVAIL_ALLOCA): New macro.
+        (SAFE_ALLOCA, SAFE_NALLOCA, SAFE_ALLOCA_LISP):
+        Use it, and check against sa_avail rather than MAX_ALLOCA.
+
+2014-09-22  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        On OSX, do not free font-specific data more than once (Bug#18501).
+        * macfont.m (macfont_close): Release and free font-specific data
+        only if it wasn't previously freed.
+
+2014-09-22  David Caldwell <david@porkrind.org>  (tiny change)
+
+        * unexmacosx.c (dump_it): Improve error message.
+
+2014-09-22  Juri Linkov  <juri@jurta.org>
+
+        * image.c (imagemagick_load_image): Add delay to imagemagick metadata.
+        (Bug#10747, bug#18334)
+
+2014-09-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * frame.c (Fmouse_position, Fset_mouse_position): Clarify the
+        units in which the position is measured.  (Bug#18493)
+
+        * xdisp.c (redisplay_internal): Force redisplay of all windows
+        that show a buffer whose narrowing has changed.  (Bug#18490)
+
+2014-09-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * xterm.c (x_draw_hollow_cursor, x_draw_bar_cursor):
+        * w32term.c (x_draw_hollow_cursor, x_draw_bar_cursor): In R2L
+        lines, draw the hollow-box and hbar cursors on the right side of
+        cursor-glyph.  Thanks to martin rudalics <rudalics@gmx.at> for
+        testing on X.
+
+        * xterm.c (x_draw_stretch_glyph_string):
+        * w32term.c (x_draw_stretch_glyph_string): Fix a thinko that
+        caused the block cursor to disappear on a TAB in R2L lines in
+        every window except the leftmost one.  Reported by Martin Rudalics
+        <rudalics@gmx.at>.
+
+2014-09-22  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Always use matched specpdl entry to record call arguments (Bug#18473).
+        * lisp.h (record_in_backtrace): Adjust prototype.
+        * eval.c (record_in_backtrace): Return current specpdl level.
+        (set_backtrace_args, set_backtrace_nargs): Merge.  Adjust all users.
+        (eval_sub, Ffuncall): Record call arguments in matched specpdl
+        entry and use that entry in call to backtrace_debug_on_exit.
+        (apply_lambda): Likewise.  Get current specpdl level as 3rd arg.
+        (do_debug_on_call): Get current specpdl level as 2nd arg.
+
+        Prefer ptrdiff_t to int and avoid integer overflows.
+        * fileio.c (make_temp_name):
+        * font.c (font_parse_family_registry): Avoid integer
+        overflow on string size calculation.
+        * data.c (Faset): Likewise for byte index.
+
+2014-09-22  Eli Zaretskii  <eliz@gnu.org>
+
+        Fix display of R2L lines in partial-width windows.
+        * xdisp.c (init_iterator): Don't use it->bidi_p before it is
+        assigned the correct value.
+        (extend_face_to_end_of_line): Account for truncation and
+        continuation glyphs in R2L rows when one of the fringes is not
+        displayed.
+        (display_line): Don't assign negative X offset to a row if we are
+        going to produce a truncation glyph for it.  When handling
+        truncated R2L rows, consider the width of the left fringe instead
+        of the right one.
+        (produce_special_glyphs): Fix bogus assignments.
+
+2014-09-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (fcntl): Support O_NONBLOCK fcntl on the write side of pipes.
+
+2014-09-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * fileio.c (Fexpand_file_name) [DOS_NT]: Make sure newdirlim is
+        always set to a valid value.  Make sure the size passed to alloca
+        is always positive.  (Bug#18516)
+
+2014-09-22  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Avoid extra call to oblookup when interning symbols.
+        * lisp.h (intern_driver): Add prototype.
+        * lread.c (intern_driver): New function.
+        (intern1, intern_c_string_1, Fintern):
+        * font.c (font_intern_prop):
+        * w32font.c (intern_font_name): Use it.
+
+2014-09-21  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Minor improvements to new stack-allocated Lisp objects.
+        * frame.h (FRAME_PARAMETER):
+        Prefer scoped_list1 to local_list1 where either would do.
+        * lisp.h (scoped_list4): New macro.
+        (local_cons, local_list1, local_list2, local_list3, local_list4)
+        (make_local_vector, make_local_string, build_local_string):
+        Prefer functions to macros where either would do.
+        * xdisp.c (build_desired_tool_bar_string):
+        Prefer scoped_list4 to local_list4 where either would do.
+
+2014-09-18  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        More and more stack-allocated Lisp objects if USE_LOCAL_ALLOCATORS.
+        * lisp.h (local_list4) [USE_LOCAL_ALLOCATORS]: New macro.
+        [!USE_LOCAL_ALLOCATORS]: Fall back to regular list4.
+        * frame.h (FRAME_PARAMETER): New macro.
+        * dispnew.c (init_display):
+        * fontset.c (Fset_fontset_font):
+        * frame.c (x_default_parameter):
+        * xfaces.c (set_font_frame_param, Finternal_merge_in_global_face):
+        * xfns.c (x_default_scroll_bar_color_parameter)
+        (x_default_font_parameter, x_create_tip_frame): Use it.
+        * editfns.c (Fpropertize): Use local_cons.
+        * process.c (status_message): Use build_local_string.
+        * xfont.c (xfont_open): Use make_local_string.
+        * xdisp.c (build_desired_tool_bar_string): Use local_list4.
+
+2014-09-18  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Port USE_LOCAL_ALLOCATORS code to clang 3.4 x86-64.
+        * lisp.h (USE_LOCAL_ALLOCATORS): Define only if __GNUC__ &&
+        !__clang__.  This works with GCC and with clang and is safer for
+        compilers we don't know about.
+        (local_cons): Rename parameter to make capture less likely.
+
+2014-09-17  Samuel Bronson  <naesten@gmail.com>
+
+        * unexmacosx.c (copy_data_segment): Port to GCC 4.6+ (Bug#9927).
+
+2014-09-17  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor problems found by static checking.
+        * alloc.c, lisp.h (SAVE_TYPE_INT_OBJ, make_save_int_obj):
+        Remove; now unused.
+        * buffer.h (decode_buffer): Doc and indentation fixes.
+        * fns.c (Qstring_collate_lessp, Qstring_collate_equalp): Now static.
+
+2014-09-17  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Avoid clang-specific warnings.
+        * buffer.c (init_buffer): Shut up -Wself-assign.
+        * process.c (server_accept_connection): Shut up -Wunsequenced.
+
+2014-09-16  Daniel Colascione  <dancol@dancol.org>
+
+        * fns.c (sxhash): For symbols, use address as hash code.
+
+2014-09-16  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        If USE_LOCAL_ALLOCATORS, allocate even more Lisp objects on stack.
+        * charset.c (load_charset_map_from_file): Use scoped_list2
+        and build_local_string.
+        * buffer.c (Fother_buffer, other_buffer_safely, init_buffer):
+        * emacs.c (init_cmdargs, decode_env_path):
+        * fileio.c (Fexpand_file_name):
+        * fns.c (maybe_resize_hash_table) [ENABLE_CHECKING]:
+        * frame.c (x_get_arg):
+        * keyboard.c (safe_run_hooks_error):
+        * lread.c (load_warn_old_style_backquotes):
+        * xdisp.c (Fcurrent_bidi_paragraph_direction):
+        * xfns.c (x_default_scroll_bar_color_parameter, select_visual):
+        * xselect.c (x_clipboard_manager_error_1)
+        (x_clipboard_manager_save_all):
+        * xterm.c (x_term_init): Use build_local_string.
+
+        Avoid more integer overflows on string size calculations.
+        * category.c (Fmake_category_set):
+        * xdisp.c (get_overlay_arrow_glyph_row):
+        * w32font.c (intern_font_name): Prefer ptrdiff_t to int.
+
+2014-09-15  Eli Zaretskii  <eliz@gnu.org>
+
+        * sound.c [WINDOWSNT]: Include w32common.h and mbstring.h.
+        (SOUND_WARNING) [WINDOWSNT]: Include in do..while and improve the
+        error message format.  Use message_with_string to have non-ASCII
+        file names properly displayed.
+        (do_play_sound) [WINDOWSNT]: Use Unicode APIs to play sound files
+        when w32-unicode-filenames is non-nil, but not on Windows 9X,
+        where these APIs are not available even in UNICOWS.DLL.
+        Improve the format of error messages and include the file name in them
+        where appropriate.
+        (Fplay_sound_internal) [WINDOWSNT]: Make the MS-Windows branch
+        call play-sound-functions, per documentation.
+
+        * w32.c (w32_get_long_filename, w32_get_short_filename):
+        Constify the input file name arguments.
+
+        * w32.h (w32_get_long_filename, w32_get_short_filename):
+        Update prototypes.
+
+2014-09-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        If USE_LOCAL_ALLOCATORS, allocate some Lisp objects on stack.
+        * lisp.h (local_cons, local_list1, local_list2, local_list3)
+        [USE_LOCAL_ALLOCATORS]: New macros.
+        [!USE_LOCAL_ALLOCATORS]: Fall back to regular functions.
+        (build_local_string): Avoid argument name expansion clash with
+        make_local_string.
+        * alloc.c (toplevel)
+        [USE_LOCAL_ALLOCATORS && GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS]:
+        Preprocessor guard to avoid impossible configuration.
+        * charset.c (Ffind_charset_region, Ffind_charset_string):
+        Use make_local_vector.
+        * lread.c (read1, substitute_object_recurse): Use scoped_cons.
+        * textprop.c (Fput_text_property, Fadd_face_text_property):
+        Use scoped_list2.
+        (copy_text_properties): Use local_cons and local_list3.
+        * chartab.c (uniprop_table):
+        * data.c (wrong_choice, wrong_range):
+        * doc.c (get_doc_string):
+        * editfns.c (format2):
+        * fileio.c (Fexpand_file_name, auto_save_error):
+        * fns.c (Fyes_or_no_p):
+        * font.c (font_parse_xlfd, font_parse_family_registry, font_add_log):
+        * fontset.c (Fset_fontset_font):
+        * keyboard.c (echo_add_key, echo_dash, parse_menu_item)
+        (read_char_minibuf_menu_prompt):
+        * keymap.c (silly_event_symbol_error, describe_vector):
+        * menu.c (single_menu_item):
+        * minibuf.c (Fread_buffer):
+        * process.c (status_message, Fformat_network_address)
+        (server_accept_connection): Use make_local_string and
+        build_local_string.  Prefer compound literals where appropriate.
+
+2014-09-15  Daniel Colascione  <dancol@dancol.org>
+
+        * fns.c (Fsort): Tweak sort docstring.
+
+2014-09-15  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (fcntl): Support O_NONBLOCK fcntl on the write side of pipes.
+        (sys_write): When a write to a non-blocking pipe returns ENOSPC,
+        set errno to EAGAIN instead, to allow the caller to retry the
+        write after some waiting.  Fixes deadlocks when Emacs exchanges a
+        lot of data through the pipe.  (Bug#18420)
+
+        * sound.c (Fplay_sound_internal): Encode the sound file name in
+        the ANSI codepage.  Expand it against data-directory, as per docs,
+        not against the current directory.  No need to make a local copy
+        of the file name; pass the encoded file name directly to
+        do_play_sound.  (Bug#18463)
+
+        * w32.c (ansi_encode_filename): If w32_get_short_filename returns
+        NULL, and the file name is not encodable in ANSI codepage, return
+        the string with "?" replacement characters, which will fail the
+        caller.  This avoids returning a random value in that case.
+
+2014-09-15  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.c (Fresize_mini_window_internal): Set w->total_lines
+        from w->pixel_height (Bug#18422).
+
+2014-09-15  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (updateFrameSize:, initFrameFromEmacs:)
+        (toggleFullScreen:): Take frame_resize_pixelwise into account when
+        setting resize increments (Bug#18435).
+
+2014-09-15  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (pos_visible_p): Properly save and restore the iterator
+        state around the call to line_bottom, since it can move the
+        iterator to another screen line.  This fixes off-by-one errors in
+        the reported row in some rare cases.
+
+2014-09-14  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * callproc.c (init_callproc): Fix bug introduced at
+        2014-09-07 (Bug#18474).
+
+2014-09-13  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Prefer ptrdiff_t to int and avoid integer overflows.
+        * fileio.c (make_temp_name):
+        * font.c (font_parse_family_registry): Avoid integer
+        overflow on string size calculation.
+        * data.c (Faset): Likewise for byte index.
+
+2014-09-12  Detlev Zundel  <dzu@member.fsf.org>
+
+        * buffer.c (syms_of_buffer): DEFSYM Qchoice (Bug#18337).
+
+2014-09-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (make_local_string): Nitpick indent.
+        * print.c (Fprin1_to_string): Remove unused GCPROs.
+
+        More debugging aids around GCPROs.
+        * lisp.h (struct gcpro) [DEBUG_GCPRO]: Add extra members.
+        (GCPRO1, GCPRO2, GCPRO3, GCPRO4, GCPRO5, GCPRO6, GCPRO7):
+        Minor restyle.  If DEBUG_GCPRO, initialize extra fields.
+
+        * lread.c (readevalloop_eager_expand_eval): Add GCPRO and fix
+        bootstrap broken if GC_MARK_STACK == GC_USE_GCPROS_AS_BEFORE.
+
+        Remove redundant GCPROs around Ffuncall and Fapply calls.
+        This is safe because Ffuncall protects all of its arguments by itself.
+        * charset.c (map_charset_for_dump): Remove redundant GCPRO.
+        * eval.c (Fapply, apply1, call0, call1, call2, call3, call4, call5)
+        (call6, call7): Likewise.  Use compound literals where applicable.
+        (run_hook_with_args_2): Use compound literal.
+
+2014-09-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Pacify --enable-gcc-warnings when no window system is used.
+        These warnings found that subscript error, so they seem worthwhile.
+        * composite.c (char_composable_p): Simplify a bit.
+        * frame.c (x_set_frame_parameters): Add an IF_LINT.
+        * frame.c (x_set_horizontal_scroll_bars, x_set_scroll_bar_height):
+        * frame.h (FRAME_HAS_HORIZONTAL_SCROLL_BARS):
+        * window.c (set_window_scroll_bars):
+        Use USE_HORIZONTAL_SCROLL_BARS for simplicity.
+        * frame.h [! USE_HORIZONTAL_SCROLL_BARS]:
+        Ignore -Wsuggest-attribute=const.
+        * window.h (USE_HORIZONTAL_SCROLL_BARS): New macro.
+        (WINDOW_HAS_HORIZONTAL_SCROLL_BAR): Use it.
+
+2014-09-10  Paul Eggert  <eggert@penguin.cs.ucla.edu>
+
+        * charset.c (Fget_unused_iso_final_char): Fix subscript error.
+        Use check_iso_charset_parameter instead of doing the checks by hand.
+        (check_iso_charset_parameter): Move up.  Check parameters a bit
+        more carefully, and return true for 96-char sets.  All callers changed.
+
+2014-09-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Simplify lisp.h by removing the __COUNTER__ business.
+        Problem reported by Dmitry Antipov in:
+        http://lists.gnu.org/archive/html/emacs-devel/2014-09/msg00220.html
+        * lisp.h (make_local_vector, make_local_string)
+        (build_local_string): Simplify by not bothering with __COUNTER__.
+        The __COUNTER__ business wasn't working properly, and was needed
+        only for hypothetical future expansion anyway.
+
+2014-09-10  Alp Aker  <alp.tekin.aker@gmail.com>
+
+        * nsterm.m (ns_draw_fringe_bitmap): Use the same logic as other
+        terms to determine bitmap color.  (Bug#18437)
+
+2014-09-10  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (sys_write): Use SAFE_NALLOCA for the NL -> CRLF
+        translation buffer.
+
+2014-09-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xterm.c (handle_one_xevent): Add braces to pacify gcc -Wall.
+
+2014-09-10  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xterm.c (handle_one_xevent): Detect iconified by looking at
+        _NET_WM_STATE_HIDDEN.
+
+2014-09-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * lisp.h (DEFINE_GDB_SYMBOL_ENUM): Remove.
+        These can generate a constant with the correct value but the wrong
+        width, which doesn't work as a printf argument.  All uses removed.
+        Problem reported by Dmitry Antipov in:
+        http://lists.gnu.org/archive/html/emacs-devel/2014-09/msg00213.html
+        (ENUMABLE): Remove; no longer needed.
+        (ARRAY_MARK_FLAG_val, PSEUDOVECTOR_FLAG_val, VALMASK_val):
+        Remove; no longer needed because of the above change.
+        Each definiens moved to the only use.
+
+        Improve the experimental local and scoped allocation.
+        * alloc.c (local_string_init, local_vector_init):
+        New functions, defined if USE_LOCAL_ALLOCATORS.
+        Mostly, these are moved here from lisp.h, as it's not
+        clear it's worth making them inline.
+        * lisp.h (USE_STACK_LISP_OBJECTS): Default to false.
+        (GCALIGNED): Depend on HAVE_STRUCT_ATTRIBUTE_ALIGNED and
+        USE_STACK_LISP_OBJECTS, not on a laundry list.
+        (local_string_init, local_vector_init): New decls.
+        (union Aligned_Cons): New type.
+        (scoped_cons): Use it.  Give up on the char trick, as it's a too
+        much of a maintenance hassle; if someone wants this speedup
+        they'll just need to convince their compiler to align properly.
+        Conversely, use the speedup if struct Lisp_Cons happens to
+        be aligned even without a directive.  Better yet, help it along
+        by using union Aligned_Cons rather than struct Lisp_Cons.
+        (pointer_valid_for_lisp_object): Remove.  This check is not
+        necessary, since make_lisp_ptr is already doing it.  All uses removed.
+        (local_vector_init, local_string_init): Move to alloc.c.
+        (build_local_vector): Remove this awkward macro, replacing with ...
+        (make_local_vector): New macro, which acts more like a function.
+        Use statement expressions and use __COUNTER__ to avoid macro
+        capture.  Fall back on functions if these features are not supported.
+        (build_local_string, make_local_string): Likewise.
+
+2014-09-09  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xterm.c (x_term_init): Consolidate duplicated code.
+        [USE_LUCID]: Revert 2014-04-02 change (Bug#18403).  Add comment.
+        (x_delete_terminal): Do not close X connection fd (Bug#18403).
+        Add eassert and mark dpyinfo as dead only if it was alive.
+
+        Add macros to allocate temporary Lisp objects with alloca.
+        Respect MAX_ALLOCA and fall back to regular GC for large objects.
+        * character.h (parse_str_as_multibyte): Move prototype to ...
+        * lisp.h (parse_str_as_multibyte): ... here.
+        (struct Lisp_Cons): Add GCALIGNED attribute if supported.
+        (scoped_cons, scoped_list2, build_local_vector, build_local_string):
+        New macros.
+        (scoped_cons_init, pointer_valid_for_lisp_object, local_vector_init)
+        (local_string_init): New functions.
+        * alloc.c (verify_alloca) [ENABLE_CHECKING]: New function.
+        (init_alloc_once): Call it.
+
+        Cleanup last change and make all new stuff conditional.
+        * lisp.h (build_local_string): Rename to ...
+        (make_local_string): ... this macro.
+        (build_local_string, scoped_list1, scoped_list3): New macros.
+        (toplevel) [USE_STACK_LISP_OBJECTS]: Define all new macros
+        and functions as such, use regular fallbacks otherwise.
+        * alloc.c (verify_alloca) [USE_STACK_LISP_OBJECTS]: Define
+        conditionally.
+
+2014-09-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * dispnew.c (prepare_desired_row): When MODE_LINE_P is zero,
+        always make sure the marginal areas of the row are in sync with
+        what the window wants.  (Bug#18419)
+
+        * data.c (set_internal): Use assq_no_quit, not Fassq, to find an
+        existing binding of a variable, to avoid silently aborting
+        commands that use specbind.  (Bug#18331)
+
+2014-09-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix bug uncovered by changing alloca to auto buffer (Bug#18410).
+        * coding.c (growable_destination): New function.
+        (produce_chars): Use it for sanity checks.  Do not fiddle with
+        dst_end if the source and destination are both nil, as it's
+        the caller's responsibility to avoid overlap.
+        * keyboard.c (read_decoded_event_from_main_queue):
+        The destination must be MAX_MULTIBYTE_LENGTH times the max source
+        length, not 4 times, to prevent decode_coding_c_string from trying
+        to reallocate a destination.  This removes the need for the FIXME.
+
+        * callproc.c (exec_failed) [DOS_NT]: Define a dummy.
+        All callers simplified.  Add a comment about exec_failed, vfork,
+        and alloca.
+
+        Adjust drag-and-drop fix when window is above top (Bug#18303).
+        * xselect.c (x_fill_property_data): Don't let sign bit of negative
+        XCDR bleed into XCAR's encoded value.  Improve checks for
+        out-of-range data while we're at it.
+
+2014-09-07  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xselect.c (x_fill_property_data): Handle negative XCDR when data
+        is CONSP (Bug#18303).
+
+2014-09-07  Eli Zaretskii  <eliz@gnu.org>
+
+        * callproc.c (child_setup) [WINDOWSNT]: Don't call exec_failed if
+        'alloca' gets passed arguments larger than MAX_ALLOCA.
+
+        * font.c (MAX): Define if not defined elsewhere.
+
+2014-09-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * keyboard.c (read_decoded_event_from_main_queue): Reinstitute alloca
+        here for destination buffer, to work around what appears to be a
+        bug in decode_coding_c_string when the source and destination are
+        both C strings.
+
+        Use SAFE_ALLOCA etc. to avoid unbounded stack allocation (Bug#18410).
+        This follows up on the recent thread in emacs-devel on alloca; see:
+        http://lists.gnu.org/archive/html/emacs-devel/2014-09/msg00042.html
+        This patch also cleans up alloca-related glitches noted while
+        examining the code looking for unbounded alloca.
+        * alloc.c (listn):
+        * callproc.c (init_callproc):
+        Rewrite to avoid need for alloca.
+        * buffer.c (mouse_face_overlay_overlaps)
+        (report_overlay_modification):
+        * buffer.h (GET_OVERLAYS_AT):
+        * coding.c (make_subsidiaries):
+        * doc.c (Fsnarf_documentation):
+        * editfns.c (Fuser_full_name):
+        * fileio.c (Ffile_name_directory, Fexpand_file_name)
+        (search_embedded_absfilename, Fsubstitute_in_file_name):
+        * fns.c (Fmake_hash_table):
+        * font.c (font_vconcat_entity_vectors, font_update_drivers):
+        * fontset.c (fontset_pattern_regexp, Ffontset_info):
+        * frame.c (Fmake_terminal_frame, x_set_frame_parameters)
+        (xrdb_get_resource, x_get_resource_string):
+        * ftfont.c (ftfont_get_charset, ftfont_check_otf, ftfont_drive_otf):
+        * ftxfont.c (ftxfont_draw):
+        * image.c (xbm_load, xpm_load, jpeg_load_body):
+        * keyboard.c (echo_add_key, menu_bar_items, tool_bar_items)
+
+        * keymap.c (Fdescribe_buffer_bindings, describe_map):
+        * lread.c (openp):
+        * menu.c (digest_single_submenu, find_and_call_menu_selection)
+        (find_and_return_menu_selection):
+        * print.c (PRINTFINISH):
+        * process.c (Fformat_network_address):
+        * scroll.c (do_scrolling, do_direct_scrolling, scrolling_1):
+        * search.c (search_buffer, Fmatch_data, Fregexp_quote):
+        * sound.c (wav_play, au_play):
+        * syntax.c (skip_chars):
+        * term.c (tty_menu_activate, tty_menu_show):
+        * textprop.c (get_char_property_and_overlay):
+        * window.c (Fset_window_configuration):
+        * xdisp.c (safe__call, next_overlay_change, vmessage)
+        (compute_overhangs_and_x, draw_glyphs, note_mouse_highlight):
+        * xfaces.c (face_at_buffer_position):
+        * xmenu.c (x_menu_show):
+        Use SAFE_ALLOCA etc. instead of plain alloca, since the
+        allocation size isn't bounded.
+        * callint.c (Fcall_interactively): Redo memory_full check
+        so that it can be done at compile-time on some platforms.
+        * coding.c (MAX_LOOKUP_MAX): New constant.
+        (get_translation_table): Use it.
+        * callproc.c (call_process): Use SAFE_NALLOCA instead of
+        SAFE_ALLOCA, to catch integer overflows on size calculation.
+        (exec_failed) [!DOS_NT]: New function.
+        (child_setup) [!DOS_NT]: Use it.
+        * editfns.c (Ftranspose_regions):
+        Hoist USE_SAFE_ALLOC + SAFE_FREE out of 'if'.
+        * editfns.c (check_translation):
+        Allocate larger buffers on the heap.
+        * eval.c (internal_lisp_condition_case):
+        Check for MAX_ALLOCA overflow.
+        * fns.c (sort_vector): Use SAFE_ALLOCA_LISP rather than Fmake_vector.
+        (Fbase64_encode_region, Fbase64_decode_region):
+        Avoid unnecessary calls to SAFE_FREE before 'error'.
+        * buffer.c (mouse_face_overlay_overlaps):
+        * editfns.c (Fget_pos_property, check_translation):
+        * eval.c (Ffuncall):
+        * font.c (font_unparse_xlfd, font_find_for_lface):
+        * ftfont.c (ftfont_drive_otf):
+        * keyboard.c (echo_add_key, read_decoded_event_from_main_queue)
+        (menu_bar_items, tool_bar_items):
+        * sound.c (Fplay_sound_internal):
+        * xdisp.c (load_overlay_strings, dump_glyph_row):
+        Use an ordinary auto buffer rather than alloca, since the
+        allocation size is fixed and small.
+        * ftfont.c: Include <c-strcase.h>.
+        (matching_prefix): New function.
+        (get_adstyle_property): Use it, to avoid need for alloca.
+        * keyboard.c (echo_add_key):
+        * keymap.c (describe_map): Use ptrdiff_t, not int.
+        * keyboard.c (echo_add_key): Prefer sizeof to strlen.
+        * keymap.c (Fdescribe_buffer_bindings): Use SBYTES, not SCHARS,
+        when counting bytes.
+        * lisp.h (xlispstrdupa): Remove, replacing with ...
+        (SAFE_ALLOCA_STRING): ... new macro with different API.
+        This fixes a portability problem, namely, alloca result
+        passed to another function.  All uses changed.
+        (SAFE_ALLOCA, SAFE_ALLOCA_LISP): Check for MAX_ALLOCA,
+        not MAX_ALLOCA - 1.
+        * regex.c (REGEX_USE_SAFE_ALLOCA, REGEX_SAFE_FREE)
+        (REGEX_ALLOCATE): New macros.
+        (REGEX_REALLOCATE, REGEX_ALLOCATE_STACK, REGEX_REALLOCATE_STACK)
+        (REGEX_FREE_STACK, FREE_VARIABLES, re_match_2_internal):
+        Use them.
+        * xdisp.c (message3): Use SAFE_ALLOCA_STRING rather than doing it
+        by hand.
+        (decode_mode_spec_coding): Store directly into buf rather than
+        into an alloca temporary and copying the temporary to the buf.
+
+2014-09-06  Eli Zaretskii  <eliz@gnu.org>
+
+        * Makefile.in (EMACS_HEAPSIZE): Remove, no longer used.  (Bug#18416)
+
+2014-09-04  Jan D  <jan.h.d@swipnet.se>
+
+        * xterm.c (x_term_init): Don't call x_session_initialize if running
+        as a daemon (Bug#18375).
+
+        * xsmfns.c: Initialize ice_fd.
+
+2014-09-04  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Less chatter in 'make' output.
+        * Makefile.in (AM_V_GEN, am__v_GEN_, am__v_GEN_0, am__v_GEN_1, AM_V_at)
+        (am__v_at_, am__v_at_0, am__v_at_1):  New macros, taken from Automake.
+        ($(etc)/DOC, buildobj.h, gl-stamp): Use them.
+
+2014-09-03  Martin Rudalics  <rudalics@gmx.at>
+
+        * buffer.c (scroll-bar-height): Fix typo in doc-string.
+        * frame.c (Vdefault_frame_horizontal_scroll_bars):
+        Remove variable.
+        * nsfns.m (Fx_create_frame):
+        * w32fns.c (Fx_create_frame):
+        * xfns.c (Fx_create_frame): Default horizontal scroll bars to
+        nil.
+
+2014-09-03  Eli Zaretskii  <eliz@gnu.org>
+
+        * dispnew.c (buffer_posn_from_coords): Fix an off-by-one error in
+        the reported row in the case of a window with a header line, by
+        improving on the fix committed in 2011-10-08T10:58:50Z!eliz@gnu.org
+        eliz@gnu.org-20111008105850-ht4tvsayohvr1kjc.  (Bug#18384)
+
+2014-09-03  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * eval.c (internal_lisp_condition_case): Don't overrun the stack
+        when configured --with-wide-int on typical 32-bit platforms.
+
+2014-09-03  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (display_and_set_cursor): Call erase_phys_cursor also
+        when HPOS is negative, for the benefit of R2L glyph rows whose
+        newline overflows into the fringe.
+
+2014-09-03  Ken Brown  <kbrown@cornell.edu>
+
+        * conf_post.h (strnicmp) [CYGWIN && HAVE_NTGUI]: Define.  (Bug#18366)
+
+2014-09-02  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Minor cleanup of recent strlen-avoiding patch.
+        * fileio.c (CHECK_LENGTH): Remove.
+        Rewrite callers so that they don't need it.
+        (Fexpand_file_name) [DOS_NT]: Fix a case where directory length
+        variable wasn't set.
+
+2014-09-02  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * fileio.c (CHECK_LENGTH): New macro.
+        (Fexpand_file_name): Use it and get rid of a few more calls
+        to strlen and strcat.
+        * callproc.c (egetenv_internal): Add arg and rename from egetenv ...
+        * lisp.h (egetenv): ... because of a new inline function used to
+        avoid calls to strlen for a compile-time constants.
+
+        * buffer.h (decode_buffer): New function.
+        * buffer.c (Fbuffer_name, Fbuffer_file_name, Fbuffer_base_buffer)
+        (Fbuffer_local_variables, Fbuffer_modified_p, Fbuffer_modified_tick)
+        (Fbuffer_chars_modified_tick, Fdelete_all_overlays):
+        * data.c (Flocal_variables_p):
+        * fileio.c (Fverify_visited_file_modtime):
+        * marker.c (live_buffer): Use it.
+
+2014-09-01  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Avoid extra calls to strlen in filesystem I/O routines.
+        * fileio.c (Fexpand_file_name): Avoid calls to strlen if
+        the length of 'newdir' is known or may be precalculated.
+        (file_accessible_directory_p): Prefer to pass Lisp_Object,
+        not 'char *', and so use precalculated length.
+        (Ffile_accessible_directory_p):
+        * callproc.c (encode_current_directory, init_callproc):
+        * charset.c (init_charset):
+        * lread.c (load_path_check, load_path_default): Adjust users.
+        * lisp.h (file_accessible_directory_p): Tweak prototype.
+
+2014-09-01  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32proc.c (w32_compare_strings): Support "C" and "POSIX"
+        locales.
+
+2014-09-01  Paul Eggert  <eggert@cs.ucla.edu>
+
+        --enable-silent-rules now suppresses more chatter.
+        * Makefile.in (AM_DEFAULT_VERBOSITY, AM_V_CC, am__v_CC_)
+        (am__v_CC_0, am__v_CC_1, AM_V_CCLD, am__v_CCLD_, am__v_CCLD_0)
+        (am__v_CCLD_1): New macros, taken from Automake.
+        (.c.o, .m.o, temacs$(EXEEXT)): Use them.
+
+        Clean up extern decls a bit.
+        * bytecode.c: Include blockinput.h and keyboard.h rather
+        than rolling their APIs by hand.
+        * emacs.c: Include regex.h and rely on its and lisp.h's API
+        rather than rolling them by hand.
+        * lastfile.c: Include lisp.h, to check this file's API.
+        * lisp.h (lisp_eval_depth, my_edata, my_endbss, my_endbss_static):
+        New decls.
+        * regex.h (re_max_failures): New decl.
+        * unexcw.c, unexmacosx.c, unexw32.c:
+        Rely on lisp.h's API rather than rolling it by hand.
+        * vm-limit.c (__after_morecore_hook, __morecore, real_morecore):
+        Declare at top level, to pacify GCC -Wnested-externs.
+
+2014-08-31  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (get_glyph_string_clip_rects): Don't let the width of a
+        clipping rectangle become negative (i.e. large positive, since
+        it's an unsigned data type).  This can happen in R2L hscrolled
+        glyph rows, and caused us to draw the cursor glyph on the fringe.
+        For the details, see
+        http://lists.gnu.org/archive/html/emacs-devel/2014-08/msg00543.html.
+
+2014-08-31  Ken Brown  <kbrown@cornell.edu>
+
+        * gmalloc.c: Don't include <stdlib.h>.  Declare system malloc and
+        friends before defining hybrid_malloc and friends if HYBRID_MALLOC
+        is defined.  (Bug#18368)
+
+2014-08-30  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Vector-sorting fixes (Bug#18361).
+        It's not safe to call qsort or qsort_r, since they have undefined
+        behavior if the user-specified predicate is not a total order.
+        Also, watch out for garbage-collection while sorting vectors.
+        * fns.c: Include <vla.h>.
+        (sort_vector_predicate) [!HAVE_QSORT_R]: Remove.
+        (sort_vector_compare): Remove, replacing with ....
+        (inorder, merge_vectors, sort_vector_inplace, sort_vector_copy):
+        ... these new functions.
+        (sort_vector): Rewrite to use the new functions.
+        GCPRO locals, since the predicate can invoke the GC.
+        Since it's in-place return void; caller changed.
+        (merge): Use 'inorder', for clarity.
+
+        * sysdep.c (str_collate): Clear errno just before wcscoll(_l).
+        One can't hoist this out of the 'if', because intervening calls to
+        newlocale, twolower, etc. can change errno.
+
+2014-08-30  Eli Zaretskii  <eliz@gnu.org>
+
+        * sysdep.c (str_collate) [__STDC_ISO_10646__]: Improve the
+        wording of the error messages.
+        (str_collate) [WINDOWSNT]: Signal an error if w32_compare_strings
+        sets errno.
+
+        * w32proc.c (get_lcid_callback): Accept locale specifications
+        without the country part, as in "enu" vs "enu_USA".
+        (w32_compare_strings): Signal an error if a locale was specified,
+        but couldn't be translated into a valid LCID.
+
+2014-08-29  Michael Albinus  <michael.albinus@gmx.de>
+
+        * sysdep.c (str_collate) [__STDC_ISO_10646__]: Move up setting errno.
+
+2014-08-29  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * sysdep.c (str_collate) [__STDC_ISO_10646__]: Do not look at
+        errno after towlower_l.  errno's value is not specified after
+        towlower_l.  Instead, assume that towlower_l returns its argument
+        on failure, which is portable in practice.
+
+2014-08-29  Eli Zaretskii  <eliz@gnu.org>
+
+        * fns.c (Fstring_collate_lessp, Fstring_collate_equalp): Doc fix.
+
+        * w32proc.c (w32_compare_strings): Accept additional argument
+        IGNORE_CASE.  Set up the flags for CompareStringW to ignore case
+        if requested.  If w32-collate-ignore-punctuation is non-nil, add
+        NORM_IGNORESYMBOLS to the flags.
+        (LINGUISTIC_IGNORECASE): Define if not already defined.
+        (syms_of_ntproc) <Vw32_collate_ignore_punctuation>: New variable.
+
+        * sysdep.c (str_collate) [WINDOWSNT]: Adapt to the interface
+        change.
+
+2014-08-29  Michael Albinus  <michael.albinus@gmx.de>
+
+        * sysdep.c (LC_CTYPE, LC_CTYPE_MASK, towlower_l):
+        Define substitutes for platforms that lack them.
+        (str_collate): Add arguments locale and ignore_case.
+
+        * fns.c (Fstring_collate_lessp, Fstring_collate_equalp):
+        Add optional arguments LOCALE and IGNORE-CASE.
+
+        * lisp.h (str_collate): Adapt argument list.
+
+2014-08-29  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Add vectors support to Fsort.
+        * fns.c (sort_vector, sort_vector_compare): New functions.
+        (sort_list): Likewise, refactored out of ...
+        (Fsort): ... adjusted user.  Mention vectors in docstring.
+        (sort_vector_predicate) [!HAVE_QSORT_R]: New variable.
+        * alloc.c (make_save_int_obj): New function.
+        * lisp.h (enum Lisp_Save_Type): New member SAVE_TYPE_INT_OBJ.
+        (make_save_int_obj): Add prototype.
+
+        Fix last change to support Darwin/OSX and FreeBSD (Bug#18354).
+        * sysdep.c (sort_vector_compare) [DARWIN_OS || __FreeBSD__]:
+        Conditionally define to match system's qsort_r signature.
+        (sort_vector) [DARWIN_OS || __FreeBSD__]: Likewise in call to qsort_r.
+
+2014-08-28  Ken Brown  <kbrown@cornell.edu>
+
+        Add support for HYBRID_MALLOC, allowing the use of gmalloc before
+        dumping and the system malloc after dumping.  (Bug#18222)
+
+        * conf_post.h (malloc, realloc, calloc, free) [HYBRID_MALLOC]:
+        Define as macros, expanding to hybrid_malloc, etc.
+        (HYBRID_GET_CURRENT_DIR_NAME): New macro.
+        (get_current_dir_name) [HYBRID_GET_CURRENT_DIR_NAME]: Define as
+        macro.
+        * gmalloc.c: Set up the infrastructure for HYBRID_MALLOC, with a
+        full implementation on Cygwin.  Remove Cygwin-specific code that
+        is no longer needed.
+        (malloc, realloc, calloc, free, aligned_alloc) [HYBRID_MALLOC]:
+        Redefine as macros expanding to gmalloc, grealloc, etc.
+        (DUMPED, ALLOCATED_BEFORE_DUMPING) [CYGWIN]: New macros.
+        (get_current_dir_name) [HYBRID_GET_CURRENT_DIR_NAME]: Undefine.
+        (USE_PTHREAD, posix_memalign) [HYBRID_MALLOC]: Don't define.
+        (hybrid_malloc, hybrid_calloc, hybrid_free, hybrid_realloc)
+        [HYBRID_MALLOC]:
+        (hybrid_get_current_dir_name) [HYBRID_GET_CURRENT_DIR_NAME]:
+        (hybrid_aligned_alloc) [HYBRID_MALLOC && (HAVE_ALIGNED_ALLOC ||
+        HAVE_POSIX_MEMALIGN)]: New functions.
+        * alloc.c (aligned_alloc) [HYBRID_MALLOC && (ALIGNED_ALLOC ||
+        HAVE_POSIX_MEMALIGN)]: Define as macro expanding to
+        hybrid_aligned_alloc; declare.
+        (USE_ALIGNED_ALLOC) [HYBRID_MALLOC && (ALIGNED_ALLOC ||
+        HAVE_POSIX_MEMALIGN)]: Define.
+        (refill_memory_reserve) [HYBRID_MALLOC]: Do nothing.
+        * sysdep.c (get_current_dir_name) [HYBRID_GET_CURRENT_DIR_NAME]:
+        Define as macro, expanding to gget_current_dir_name, and define
+        the latter.
+        * emacs.c (main) [HYBRID_MALLOC]: Don't call memory_warnings() or
+        malloc_enable_thread().  Don't initialize malloc.
+        * lisp.h (NONPOINTER_BITS) [CYGWIN]: Define (because GNU_MALLOC is
+        no longer defined on Cygwin).
+        (refill_memory_reserve) [HYBRID_MALLOC]: Don't declare.
+        * sheap.c (bss_sbrk_buffer_end): New variable.
+        * unexcw.c (__malloc_initialized): Remove variable.
+        * ralloc.c: Throughout, treat HYBRID_MALLOC the same as
+        SYSTEM_MALLOC.
+        * xdisp.c (decode_mode_spec) [HYBRID_MALLOC]: Don't check
+        Vmemory_full.
+
+2014-08-28  Martin Rudalics  <rudalics@gmx.at>
+
+        * w32term.c (w32_horizontal_scroll_bar_handle_click):
+        In `event->y' return entire range (the size of the scroll bar minus
+        that of the thumb).
+        * xterm.c (xm_scroll_callback, xaw_jump_callback): In `whole'
+        return entire range (the scaled size of the scroll bar minus
+        that of the slider).  In `portion' return the scaled position of
+        the slider.
+        (xaw_jump_callback): Restore part of code for vertical scroll
+        bar broken in change from 2014-07-27.
+        (xaw_scroll_callback): Provide incremental scrolling with
+        horizontal scroll bars.
+
+2014-08-28  Eli Zaretskii  <eliz@gnu.org>
+
+        * conf_post.h (_GL_EXECINFO_INLINE) [MSDOS]: Don't define.
+
+        * indent.c (Fvertical_motion): Fix vertical motion up through a
+        display property after a newline.  (Bug#18276)
+
+        * xdisp.c (display_line): Don't assume that the call to
+        reseat_at_next_visible_line_start ends up at a character
+        immediately following the newline on the previous line.
+        Avoids setting the ends_at_zv_p flag on screen lines that are not at or
+        beyond ZV, which causes infloop in redisplay.  For the details, see
+        http://lists.gnu.org/archive/html/emacs-devel/2014-08/msg00368.html.
+
+        * dispnew.c (buffer_posn_from_coords): Fix mirroring of X
+        coordinate for hscrolled R2L screen lines.  (Bug#18277)
+
+2014-08-28  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * sysdep.c (LC_COLLATE, LC_COLLATE_MASK): Give individual defaults
+        (Bug#18051).
+
+2014-08-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * syntax.c (scan_lists): Don't examine positions before BEGV.
+        (Bug#18339)
+
+2014-08-27  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Improve robustness of new string-collation code (Bug#18051).
+        * sysdep.c (LC_COLLATE, LC_COLLATE_MASK, freelocale, locale_t)
+        (newlocale, wcscoll_l): Define substitutes for platforms that
+        lack them, so as to simplify the mainline code.
+        (str_collate): Simplify the code by assuming the above definitions.
+        Use wcscoll_l, not uselocale, as uselocale is too fragile.
+        For example, the old version left the Emacs in the wrong locale if
+        wcscoll reported an error.  Use 'int', not ptrdiff_t, for the int
+        result.  Report an error if newlocale fails.
+
+2014-08-27  Michael Albinus  <michael.albinus@gmx.de>
+
+        * lisp.h (str_collate):
+        * sysdep.c (str_collate): Return int.
+        (str_collate) [__STDC_ISO_10646__]: Propagate error of wcscoll.
+
+2014-08-27  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix some glitches in previous change.
+        * sysdep.c (stack_direction): Replace stack_grows_down
+        to simplify calculation of stack boundaries.
+        (handle_sigsegv): Check whether we really crash somewhere near
+        to stack boundary, and handle fatal signal as usual if not.
+        (init_sigsegv): Adjust accordingly.
+        * keyboard.c (Vtop_level_message): Rename to
+        Vinternal__top_level_message, as suggested by Stefan Monnier in
+        http://lists.gnu.org/archive/html/emacs-devel/2014-08/msg00493.html
+        All related users changed.
+
+2014-08-26  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Handle C stack overflow caused by too nested Lisp evaluation.
+        * lisp.h (toplevel) [HAVE_STACK_OVERFLOW_HANDLING]: Declare
+        siglongjmp point to transfer control from SIGSEGV handler.
+        * keyboard.c (return_to_command_loop, recover_top_level_message)
+        [HAVE_STACK_OVERFLOW_HANDLING]: New variables.
+        (regular_top_level_message): New variable.
+        (command_loop) [HAVE_STACK_OVERFLOW_HANDLING]: Handle non-local
+        exit from SIGSEGV handler and adjust message displayed by Vtop_level
+        if appropriate.
+        (syms_of_keyboard): DEFVAR Vtop_level_message and initialize
+        new variables described above.
+        * sysdep.c [HAVE_SYS_RESOURCE_H]: Include sys/resource.h as such.
+        (stack_grows_down, sigsegv_stack, handle_sigsegv)
+        [HAVE_STACK_OVERFLOW_HANDLING]: New variables and function.
+        (init_sigsegv): New function.
+        (init_signals): Use it.
+
+2014-08-25  Ken Brown  <kbrown@cornell.edu>
+
+        * emacs.c (main): Remove use of obsolete macro
+        G_SLICE_ALWAYS_MALLOC.
+
+2014-08-25  Eli Zaretskii  <eliz@gnu.org>
+
+        Implement locale-sensitive string collation for MS-Windows.
+        * w32proc.c (get_lcid_callback, get_lcid, w32_compare_strings):
+        New functions.  (Bug#18051)
+
+        * w32.h (w32_compare_strings): Add prototype.
+
+        * w32.c <g_b_init_compare_string_w>: New global flag.
+        (globals_of_w32): Initialize it.
+
+        * sysdep.c (str_collate) [WINDOWSNT]: Implementation for MS-Windows.
+
+        * fns.c (Fstring_collate_lessp, Fstring_collate_equalp)
+        [WINDOWSNT]: Call str_collate on MS-Windows.
+
+2014-08-25  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        One more minor cleanup of font subsystem.
+        * font.h (struct font_driver): Convert text_extents to
+        return void because returned value is never actually used.
+        * macfont.m (macfont_text_extents):
+        * w32font.c (w32font_text_extents):
+        * xftfont.c (xftfont_text_extents): Adjust to return void
+        and assume that 'metrics' argument is always non-NULL.
+        * ftfont.c (ftfont_text_extents):
+        * xfont.c (xfont_text_extents): Likewise.  Avoid redundant memset.
+
+2014-08-25  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Minor cleanups of str_collate fix (Bug#18051).
+        * fns.c (str_collate): Move decl from here ...
+        * lisp.h (str_collate): ... to here.
+        * sysdep.c (str_collate): Prune away some of the forest of ifdefs.
+        Remove unnecessary casts.  Use SAFE_NALLOCA to avoid
+        potential problems with integer overflow.  Don't assume
+        setlocale succeeds.  Remove unnecessary test before restoring
+        locale via setlocale, and free the copied setlocale string
+        when done with it.
+
+2014-08-24  Michael Albinus  <michael.albinus@gmx.de>
+
+        * fns.c (Fstring_collate_lessp, Fstring_collate_equalp): New DEFUNs.
+
+        * sysdep.c (str_collate): New function.  (Bug#18051)
+
+2014-08-23  Karol Ostrovsky  <karol.ostrovsky@gmail.com>  (tiny change)
+
+        * Makefile.in (emacs$(EXEEXT)): Retry deletion of bootstrap-emacs
+        if the initial "rm -f" fails.  This is for MinGW builds, where
+        MS-Windows will not allow deleting the executable file of a
+        running program.
+
 2014-08-20  Eli Zaretskii  <eliz@gnu.org>
 
         * w32term.c (w32_scroll_bar_handle_click)
@@ -117,8 +1762,8 @@
         * term.c (OUTPUT, tty_set_terminal_modes)
         (tty_set_terminal_window, tty_set_scroll_region)
         (tty_clear_to_end, tty_write_glyphs, tty_write_glyphs_with_face)
-        (tty_ins_del_lines, tty_menu_display, tty_menu_activate): Use
-        FRAME_TOTAL_LINES instead of FRAME_LINES.
+        (tty_ins_del_lines, tty_menu_display, tty_menu_activate):
+        Use FRAME_TOTAL_LINES instead of FRAME_LINES.
         (Fresume_tty): Use FRAME_TOTAL_LINES instead of FRAME_LINES.
         Call change_frame_size with frame's menu bar lines subtracted
         from height.
@@ -129,9 +1774,10 @@
 2014-08-09  Reuben Thomas  <rrt@sc3d.org>
 
         * alloc.c (Fmemory_info): Remove a stray brace.
+
         * process.c: Fix a comment typo.
-        * msdos.c:
-        * dosfns.c (init_dosfns): Remove support for DJGPP < 2.02.
+
+        * msdos.c, dosfns.c (init_dosfns): Remove support for DJGPP < 2.02.
 
 2014-08-09  Jan Djärv  <jan.h.d@swipnet.se>
 
@@ -168,14 +1814,14 @@
 
 2014-08-04  Martin Rudalics  <rudalics@gmx.at>
 
-        * frame.h (FRAME_HAS_HORIZONTAL_SCROLL_BARS): Condition
-        correctly according to toolkit used.
+        * frame.h (FRAME_HAS_HORIZONTAL_SCROLL_BARS):
+        Condition correctly according to toolkit used.
         * frame.c (make_initial_frame, make_terminal_frame)
         (x_set_horizontal_scroll_bars, x_set_scroll_bar_height)
         (Vdefault_frame_horizontal_scroll_bars): Correctly condition
         assignments according to presence of toolkit scrollbars.
-        * window.h (WINDOW_HAS_HORIZONTAL_SCROLL_BAR): Condition
-        correctly according to toolkit used.
+        * window.h (WINDOW_HAS_HORIZONTAL_SCROLL_BAR):
+        Condition correctly according to toolkit used.
         * window.c (set_window_scroll_bars): Set horizontal scroll bar
         only if toolkit supports it.
         * w32term.c (w32_redeem_scroll_bar): Always redeem scroll bar if
@@ -431,15 +2077,15 @@
         (x_set_scroll_bar_height): Add external declarations.
         * frame.c: (frame_inhibit_resize, frame_windows_min_size)
         (adjust_frame_size): New functions.
-        (make_frame): Initial horizontal_scroll_bars field.  Use
-        SET_FRAME_LINES.  Don't allow horizontal scroll bar in
+        (make_frame): Initial horizontal_scroll_bars field.
+        Use SET_FRAME_LINES.  Don't allow horizontal scroll bar in
         minibuffer window.
         (make_initial_frame, make_terminal_frame): No horizontal scroll
         bar in initial and terminal frames.  Use adjust_frame_size.
         (Fframe_total_cols): Fix doc-string.
         (Fframe_total_lines, Fscroll_bar_height): New Lisp functions.
-        (Fset_frame_height, Fset_frame_width, Fset_frame_size): Rewrite
-        using adjust_frame_size.
+        (Fset_frame_height, Fset_frame_width, Fset_frame_size):
+        Rewrite using adjust_frame_size.
         (Qscroll_bar_height, Qhorizontal_scroll_bars)
         (Qframe_windows_min_size): New symbols.
         (x_set_frame_parameters): Remove call of check_frame_size.
@@ -450,8 +2096,8 @@
         (x_set_internal_border_width, x_set_vertical_scroll_bars)
         (x_set_scroll_bar_width, x_set_right_divider_width)
         (x_set_bottom_divider_width): Rewrite using adjust_frame_size.
-        (x_set_horizontal_scroll_bars, x_set_scroll_bar_height): New
-        functions.
+        (x_set_horizontal_scroll_bars, x_set_scroll_bar_height):
+        New functions.
         (x_figure_window_size): Rewrite to make frame display the
         expected number of lines.
         (Vdefault_frame_scroll_bars): Rewrite doc-string.
@@ -498,8 +2144,8 @@
         compute_fringe_widths.
         * term.c (Fresume_tty): When changing the size of a tty frame do
         not pass height of menu bar.
-        (clear_tty_hooks, set_tty_hooks): Clear
-        horizontal_scroll_bar_hook.
+        (clear_tty_hooks, set_tty_hooks):
+        Clear horizontal_scroll_bar_hook.
         (init_tty): Frame has no horizontal scroll bars.
         * termhooks.h (enum scroll_bar_part): Add scroll_bar_move_ratio,
         scroll_bar_before_handle, scroll_bar_horizontal_handle,
@@ -508,25 +2154,25 @@
         scroll_bar_to_rightmost entries.
         (enum event_kind): Add HORIZONTAL_SCROLL_BAR_CLICK_EVENT
         (struct terminal): Add set_horizontal_scroll_bar_hook.
-        * w32console.c (initialize_w32_display): Clear
-        horizontal_scroll_bar_hook.
+        * w32console.c (initialize_w32_display):
+        Clear horizontal_scroll_bar_hook.
         * w32fns.c (x_set_mouse_color): Use FRAME_W32_DISPLAY instead of
         FRAME_X_DISPLAY.
         (x_clear_under_internal_border, x_set_internal_border_width):
         New functions.
-        (x_set_menu_bar_lines): Rewrite using frame_inhibit_resize.  Set
-        windows_or_buffers_changed when adding the menu bar.
+        (x_set_menu_bar_lines): Rewrite using frame_inhibit_resize.
+        Set windows_or_buffers_changed when adding the menu bar.
         (x_set_tool_bar_lines): Rewrite using adjust_frame_size.
         (x_change_tool_bar_height, x_set_scroll_bar_default_height)
         (w32_createhscrollbar): New functions.
         (w32_createscrollbar): Rename to w32_createvscrollbar.
         (w32_createwindow): Init WND_HSCROLLBAR_INDEX.
         (w32_name_of_message): Replace WM_EMACS_CREATESCROLLBAR by
-        WM_EMACS_CREATEVSCROLLBAR and WM_EMACS_CREATEHSCROLLBAR.  Add
-        WM_EMACS_SHOWCURSOR.
+        WM_EMACS_CREATEVSCROLLBAR and WM_EMACS_CREATEHSCROLLBAR.
+        Add WM_EMACS_SHOWCURSOR.
         (w32_wnd_proc): Handle WM_HSCROLL case.  In WM_WINDOWPOSCHANGING
-        case do not artificially impose WM size hints.  Handle
-        WM_EMACS_SHOWCURSOR case.  Replace WM_EMACS_CREATESCROLLBAR case
+        case do not artificially impose WM size hints.
+        Handle WM_EMACS_SHOWCURSOR case.  Replace WM_EMACS_CREATESCROLLBAR case
         by WM_EMACS_CREATEVSCROLLBAR and WM_EMACS_CREATEHSCROLLBAR
         cases.
         (my_create_tip_window): Replace WND_SCROLLBAR_INDEX by
@@ -545,8 +2191,8 @@
         pass height of menu bar to change_frame_size.
         * w32menu.c (set_frame_menubar): Rewrite using
         frame_inhibit_resize.
-        * w32term.h (struct w32_display_info): Add
-        horizontal_scroll_bar_cursor and cursor_display_counter.
+        * w32term.h (struct w32_display_info):
+        Add horizontal_scroll_bar_cursor and cursor_display_counter.
         (struct scroll_bar): Add horizontal.
         (HORIZONTAL_SCROLL_BAR_INSIDE_HEIGHT)
         (HORIZONTAL_SCROLL_BAR_LEFT_RANGE)
@@ -556,8 +2202,8 @@
         (HORIZONTAL_SCROLL_BAR_TOP_BORDER)
         (HORIZONTAL_SCROLL_BAR_BOTTOM_BORDER)
         (HORIZONTAL_SCROLL_BAR_MIN_HANDLE): New macros.
-        (WM_EMACS_CREATEVSCROLLBAR, WM_EMACS_CREATEHSCROLLBAR): Define
-        instead of WM_EMACS_CREATESCROLLBAR.
+        (WM_EMACS_CREATEVSCROLLBAR, WM_EMACS_CREATEHSCROLLBAR):
+        Define instead of WM_EMACS_CREATESCROLLBAR.
         (WND_VSCROLLBAR_INDEX, WND_HSCROLLBAR_INDEX): Define instead of
         WND_SCROLLBAR_INDEX.
         * w32term.c (horizontal_scroll_bar_min_handle)
@@ -576,18 +2222,18 @@
         scrollbar cases.
         (my_create_scrollbar): Replace with two new functions
         my_create_vscrollbar and my_create_hscrollbar.
-        (x_scroll_bar_create): New argument "horizontal".  Update
-        callers accordingly.
+        (x_scroll_bar_create): New argument "horizontal".
+        Update callers accordingly.
         (x_scroll_bar_remove, w32_condemn_scroll_bars)
         (w32_redeem_scroll_bar, x_scroll_bar_clear): Handle horizontal
         scroll bar case.
         (w32_read_socket): Handle WM_HSCROLL cae.
-        (x_new_font): Don't recompute fringe widths.  Use
-        frame_inhibit_resize.  Calculate new menu bar height iff we
+        (x_new_font): Don't recompute fringe widths.
+        Use frame_inhibit_resize.  Calculate new menu bar height iff we
         build without toolkit.  Always clear under internal border.
         (x_set_window_size): Don't check frame size or recompute
-        fringes.  Reset fullscreen status before applying sizes.  Always
-        resize as requested by pixelwise argument.  Don't call
+        fringes.  Reset fullscreen status before applying sizes.
+        Always resize as requested by pixelwise argument.  Don't call
         do_pending_window_change.
         (x_wm_set_size_hint): Add call for FRAME_SCROLL_BAR_AREA_HEIGHT.
         (w32_initialize_display_info): Initialize dpyinfo's
@@ -613,8 +2259,8 @@
         (WINDOW_TOPMOST_P, WINDOW_HAS_HORIZONTAL_SCROLL_BAR)
         (WINDOW_CONFIG_SCROLL_BAR_HEIGHT)
         (WINDOW_CONFIG_SCROLL_BAR_LINES)
-        (WINDOW_SCROLL_BAR_LINES, WINDOW_SCROLL_BAR_AREA_HEIGHT): New
-        macros.
+        (WINDOW_SCROLL_BAR_LINES, WINDOW_SCROLL_BAR_AREA_HEIGHT):
+        New macros.
         (WINDOW_LEFT_FRINGE_COLS, WINDOW_RIGHT_FRINGE_COLS)
         (WINDOW_FRINGE_COLS, WINDOW_FRINGE_EXTENDED_P): Remove macros.
         (WINDOW_VERTICAL_SCROLL_BAR_TYPE)
@@ -627,11 +2273,11 @@
         (Fwindow_old_point, sanitize_window_sizes): New functions.
         (Qwindow_sanitize_window_sizes): New symbol.
         (window_body_height): Count in horizontal scroll bar.
-        (set_window_hscroll, Fscroll_left, Fscroll_right): Set
-        suspend_auto_hscroll slot.
+        (set_window_hscroll, Fscroll_left, Fscroll_right):
+        Set suspend_auto_hscroll slot.
         (Fwindow_inside_edges): Count fringes pixelwise.
-        (coordinates_in_window, Fcoordinates_in_window_p): Consider
-        horizontal scroll bar.
+        (coordinates_in_window, Fcoordinates_in_window_p):
+        Consider horizontal scroll bar.
         (check_frame_size, adjust_window_margins): Remove functions and
         corresponding calls.
         (set_window_buffer): Initialize old_pointm and horizontal scroll
@@ -647,8 +2293,8 @@
         (Fsplit_window_internal): Inherit horizontal scroll bar type and
         height.
         (Fdelete_window_internal): Unchain old_pointm marker.
-        (window_scroll_pixel_based, Fscroll_other_window): Adjust
-        old_pointm.
+        (window_scroll_pixel_based, Fscroll_other_window):
+        Adjust old_pointm.
         (Fwindow_text_width, Fwindow_text_height): New argument
         "pixelwise".
         (struct saved_window): New fields, old_pointm, hscroll_whole,
@@ -703,10 +2349,10 @@
         (x_frame_parm_handlers): Add x_set_scroll_bar_height,
         x_set_horizontal_scroll_bars, x_set_left_fringe,
         x_set_right_fringe.
-        * xmenu.c (update_frame_menubar, free_frame_menubar): Use
-        adjust_frame_size.
-        * xterm.h (struct x_display_info): Add
-        horizontal_scroll_bar_cursor and Xatom_Horizontal_Scrollbar
+        * xmenu.c (update_frame_menubar, free_frame_menubar):
+        Use adjust_frame_size.
+        * xterm.h (struct x_display_info):
+        Add horizontal_scroll_bar_cursor and Xatom_Horizontal_Scrollbar
         slots.
         (struct scroll_bar): Add horizontal slot.
         (HORIZONTAL_SCROLL_BAR_INSIDE_HEIGHT)
@@ -729,15 +2375,15 @@
         (x_set_toolkit_horizontal_scroll_bar_thumb)
         (XTset_horizontal_scroll_bar, x_net_wm_state)
         (x_horizontal_scroll_bar_report_motion): New functions.
-        (xg_scroll_callback, x_scroll_bar_handle_click): Handle
-        horizontal scroll bars.
+        (xg_scroll_callback, x_scroll_bar_handle_click):
+        Handle horizontal scroll bars.
         (SCROLL_BAR_HORIZONTAL_NAME): Define.
         (XTset_vertical_scroll_bar): Attempt to clear areas not covered
         by scroll bar.
-        (XTcondemn_scroll_bars, XTredeem_scroll_bar): Rewrite.  Handle
-        horizontal scroll bars.
-        (handle_one_xevent): Handle horizontal scroll bar events.  Call
-        x_net_wm_state.
+        (XTcondemn_scroll_bars, XTredeem_scroll_bar): Rewrite.
+        Handle horizontal scroll bars.
+        (handle_one_xevent): Handle horizontal scroll bar events.
+        Call x_net_wm_state.
         (x_set_window_size_1, x_wm_set_size_hint): Don't call
         check_frame_size.
         (x_set_window_size): Don't call check_frame_size and
@@ -787,8 +2433,8 @@
 
 2014-07-25  Eli Zaretskii  <eliz@gnu.org>
 
-        * w32term.h (current_popup_menu, menubar_in_use): Move
-        declarations from w32term.c.
+        * w32term.h (current_popup_menu, menubar_in_use):
+        Move declarations from w32term.c.
 
 2014-07-25  Martin Rudalics  <rudalics@gmx.at>
 
@@ -842,8 +2488,8 @@
         * xterm.c (handle_one_xevent):
         * gtkutil.c (xg_event_is_for_menubar):
         * xfns.c (x_window) [USE_X_TOOLKIT]:
-        * xmenu.c (set_frame_menubar, free_frame_menubar): Prefer
-        to use FRAME_MENUBAR_HEIGHT.
+        * xmenu.c (set_frame_menubar, free_frame_menubar):
+        Prefer to use FRAME_MENUBAR_HEIGHT.
 
 2014-07-21  Dmitry Antipov  <dmantipov@yandex.ru>
 
@@ -864,12 +2510,12 @@
 
 2014-07-21  Eli Zaretskii  <eliz@gnu.org>
 
-        * w32select.c (setup_windows_coding_system): Apply
-        CODING_ANNOTATION_MASK to the common_flags member of struct
+        * w32select.c (setup_windows_coding_system):
+        Apply CODING_ANNOTATION_MASK to the common_flags member of struct
         coding_system.  Reported by martin rudalics <rudalics@gmx.at>.
 
-        * w16select.c (Fw16_get_clipboard_data): Apply
-        CODING_ANNOTATION_MASK to the common_flags member of struct
+        * w16select.c (Fw16_get_clipboard_data):
+        Apply CODING_ANNOTATION_MASK to the common_flags member of struct
         coding_system.
 
         * xdisp.c (init_iterator): Initialize it->stop_charpos to the
@@ -877,8 +2523,8 @@
         (handle_invisible_prop): Record in it->stop_charpos the position
         where the invisible text ends.  (Bug#18035)
         (hscroll_window_tree): Don't try hscrolling windows whose cursor
-        row has zero buffer position as their start position.  Reported by
-        martin rudalics <rudalics@gmx.at>.
+        row has zero buffer position as their start position.
+        Reported by martin rudalics <rudalics@gmx.at>.
 
         * xdisp.c (move_it_vertically_backward, move_it_by_lines): Prevent
         infinite looping in redisplay when display lines don't have enough
@@ -1318,8 +2964,8 @@
         are in sync with what the window wants.
         (Bug#17892)
 
-        * xdisp.c (display_line, display_mode_line): Call
-        prepare_desired_row with additional arguments, as appropriate.
+        * xdisp.c (display_line, display_mode_line):
+        Call prepare_desired_row with additional arguments, as appropriate.
 
         * dispextern.h (prepare_desired_row): Adjust prototype.
 
@@ -1408,7 +3054,7 @@
 
 2014-06-28  K. Handa  <handa@gnu.org>
 
-        * coding.c (MAX_CHARBUF_SIZE): Renamed from CHARBUF_SIZE.
+        * coding.c (MAX_CHARBUF_SIZE): Rename from CHARBUF_SIZE.
         (MIN_CHARBUF_SIZE): New macro.
         (ALLOC_CONVERSION_WORK_AREA): New arg SIZE.  Callers changed.
 
@@ -1674,7 +3320,7 @@
 
         * dispextern.h (struct face) [HAVE_XFT]: Ifdef 'extra' member.
         * font.c (font_done_for_face):
-        * xface.c (realize_non_ascii_face): Adjust user.
+        * xfaces.c (realize_non_ascii_face): Adjust user.
         * font.h (struct font_driver): Convert 'prepare_face' to return
         void because its return value is never used anyway.
         * xfont.c (xfont_prepare_face): Return void.
@@ -2167,7 +3813,7 @@
 
         Use mmap(2) emulation for allocating buffer text on MS-Windows.
         * Makefile.in (C_HEAP_SWITCH): Get the predefined heap size from
-        configure.
+        configure, not from HEAPSIZE.
         (ADDSECTION, MINGW_TEMACS_POST_LINK): Remove, no longer used.
 
         * lisp.h (NONPOINTER_BITS): Modify the condition to define to zero
@@ -3211,8 +4857,7 @@
         * doc.c (store_function_docstring): Warn when we don't know where to
         put a docstring.
         (Fsubstitute_command_keys): Don't advertise the fact that
-        text-properties are dropped, since we think it's a bug that we'll fix
-        in 24.5.
+        text-properties are dropped, since we think it's a bug that we'll fix.
 
         * frame.h (SET_FRAME_VISIBLE): Keep frame_garbaged up to date.
         * xterm.c (handle_one_xevent) <MapNotify>: Don't garbage the frame.
@@ -8443,7 +10088,7 @@
         * eval.c (Ffuncall): Fix handling of ((lambda ..) ..) in lexically
         scoped code (bug#11258).
 
-2013-08-28  Davor Cubranic  <cubranic@stat.ubc.ca> (tiny change)
+2013-08-28  Davor Cubranic  <cubranic@stat.ubc.ca>  (tiny change)
 
         * nsterm.m (last_window): New variable.
         (EV_TRAILER2): New macro.
@@ -8851,7 +10496,7 @@
         (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.
+        everything else.  Optimize for the common case.
 
 2013-08-16  Xue Fuqiao  <xfq.free@gmail.com>
 
diff --git a/src/ChangeLog.10 b/src/ChangeLog.10
index 19adb22b869..1b77eaf5803 100644
--- a/src/ChangeLog.10
+++ b/src/ChangeLog.10
@@ -3264,7 +3264,7 @@
         * w32term.c (x_make_frame_visible): Use SystemParametersInfo with
         SPI_GETWORKAREA to find the dimensions of the screen work area,
         and adjust vertical position of the frame in order to avoid being
-        covered by the task bar.
+        covered by the taskbar.
 
         * w32fns.c (w32_createwindow): Use CW_USEDEFAULT instead of
         f->left_pos and SH_SHOW instead of f->top_pos in the call to
diff --git a/src/ChangeLog.11 b/src/ChangeLog.11
index ac886d38966..fc6ff1fda6a 100644
--- a/src/ChangeLog.11
+++ b/src/ChangeLog.11
@@ -2241,7 +2241,7 @@
         * xdisp.c (try_scrolling): Avoid infloop if the first line is
         obscured due to a vscroll (Bug#7537).
 
-2010-12-13  Jan Djärv  <jhd@zeplinf.localdomain>
+2010-12-13  Jan Djärv  <jan.h.d@swipnet.se>
 
         * nsterm.h (FRAME_NS_TOOLBAR_HEIGHT): Rename to FRAME_TOOLBAR_HEIGHT.
 
diff --git a/src/ChangeLog.8 b/src/ChangeLog.8
index a483a561d06..fd8ae6caa20 100644
--- a/src/ChangeLog.8
+++ b/src/ChangeLog.8
@@ -73,8 +73,8 @@
 
         * msdos.c (dos_set_window_size) [__DJGPP__ > 1]: If the frame
         dimensions changed, invalidate the mouse highlight info.
-        (disable_mouse_highlight, help_echo, previous_help_echo): New
-        variables.
+        (disable_mouse_highlight, help_echo, previous_help_echo):
+        New variables.
         (IT_set_mouse_pointer, show_mouse_face, clear_mouse_face)
         (fast_find_position, IT_note_mode_line_highlight)
         (IT_note_mouse_highlight): New functions.
@@ -89,8 +89,8 @@
         (internal_terminal_init): Initialize mouse-highlight related
         members of the_only_x_display.  Assign IT_frame_up_to_date to
         frame_up_to_date_hook.
-        (dos_rawgetc): If the mouse moved, update mouse highlight.  If
-        help_echo changed value, generate a HELP_EVENT event.
+        (dos_rawgetc): If the mouse moved, update mouse highlight.
+        If help_echo changed value, generate a HELP_EVENT event.
         (syms_of_msdos): Staticpro help_echo and previous_help_echo.
 
         * msdos.h (struct display_info): New.
@@ -116,7 +116,7 @@
         * lisp.h (GLYPH): Defined as `int', not `unsigned int'.  Now the
         lowest 8 bits are single byte character code, the bits above are
         face ID.
-        (GLYPH_MASK_FACE, GLYPH_MASK_CHAR): Adjusted for the change
+        (GLYPH_MASK_FACE, GLYPH_MASK_CHAR): Adjust for the change
         above.
         (FAST_MAKE_GLYPH, FSST_GLYPH_FACE): Likewise.
         (GLYPH_MASK_REV_DIR, GLYPH_MASK_PADDING): Macros deleted.
@@ -131,20 +131,20 @@
         level members.  Change members in union `u'.
         (GLYPH_EQUAL_P): Check also members face_id and padding_p.
         (GLYPH_CHAR_AND_FACE_EQUAL_P): New macro.
-        (SET_CHAR_GLYPH): Adjusted for the change of struct glyph.
+        (SET_CHAR_GLYPH): Adjust for the change of struct glyph.
         (CHAR_GLYPH_PADDING_P): Likewise.
         (GLYPH_FROM_CHAR_GLYPH): Likewise.  Always return -1 for multibyte
         characters.
 
-        * dispnew.c (line_hash_code, direct_output_for_insert): Adjusted
-        for the change of struct glyph.
-        (line_draw_cost): Adjusted for the change of
+        * dispnew.c (line_hash_code, direct_output_for_insert):
+        Adjust for the change of struct glyph.
+        (line_draw_cost): Adjust for the change of
         GLYPH_FROM_CHAR_GLYPH.
         (count_match): Use macro GLYPH_CHAR_AND_FACE_EQUAL_P.
 
-        * term.c (encode_terminal_code): Adjusted for the change of struct
+        * term.c (encode_terminal_code): Adjust for the change of struct
         glyph and GLYPH_FROM_CHAR_GLYPH.
-        (write_glyphs, insert_glyphs, append_glyph): Adjusted for the
+        (write_glyphs, insert_glyphs, append_glyph): Adjust for the
         change of struct glyph.
 
         * xdisp.c: All codes adjusted for the change of struct glyph.
@@ -284,8 +284,8 @@
 
 1999-12-15  Kenichi Handa  <handa@etl.go.jp>
 
-        The following changes are for the new composition mechanism.  We
-        have deleted `composition' charset and composite characters,
+        The following changes are for the new composition mechanism.
+        We have deleted `composition' charset and composite characters,
         instead introduced a special text property `composition'.
 
         * Makefile.in (INTERVAL_SRC): Include composite.h.
@@ -298,7 +298,7 @@
         (keyboard.o) (textprop.o) (intervals.o): Depend on INTERVAL_SRC.
         (composite.o): New target.
 
-        * alloc.c (Fmake_string): Adjusted for the change of CHAR_STRING.
+        * alloc.c (Fmake_string): Adjust for the change of CHAR_STRING.
 
         * callproc.c (Fcall_process): Call code_convert_string to encode
         arguments.  Use CODING_REQUIRE_DECODING to check if the process
@@ -317,7 +317,7 @@
         (Fmake_category_table): New function.
         (syms_of_category): Defsubr it.
 
-        * ccl.c (CCL_WRITE_CHAR): Adjusted for the change of CHAR_STRING.
+        * ccl.c (CCL_WRITE_CHAR): Adjust for the change of CHAR_STRING.
         (ccl_driver): Delete codes for a composite character.
 
         * charset.h: In this entry, just `Modified' means that codes for a
@@ -326,49 +326,49 @@
         (charset_composition) (MIN_CHAR_COMPOSITION)
         (MAX_CHAR_COMPOSITION) (GENERIC_COMPOSITION_CHAR)
         (COMPOSITE_CHAR_P) (MAKE_COMPOSITE_CHAR) (COMPOSITE_CHAR_ID)
-        (PARSE_COMPOSITE_SEQ) (PARSE_CHARACTER_SEQ): Deleted.
+        (PARSE_COMPOSITE_SEQ) (PARSE_CHARACTER_SEQ): Delete.
         (MAX_CHAR) (CHARSET_VALID_P) (CHARSET_DEFINED_P) (CHARSET_AT)
         (FIRST_CHARSET_AT) (SAME_CHARSET_P) (MAKE_NON_ASCII_CHAR)
         (PARSE_MULTIBYTE_SEQ) (SPLIT_NON_ASCII_CHAR) (CHAR_PRINTABLE_P):
-        Modified.
+        Modify.
         (SPLIT_STRING): Call split_string, not split_non_ascii_string.
         (CHAR_STRING): Delete WORKBUF argument.  Call char_string, not
         non_ascii_char_to_string.
         (STRING_CHAR): Call string_to_char, not string_to_non_ascii_char.
         (STRING_CHAR_AND_LENGTH): Likewise.
         (FETCH_CHAR_ADVANCE): New macro.
-        (MAX_COMPONENT_COUNT) (struct cmpchar_info): Deleted.
+        (MAX_COMPONENT_COUNT) (struct cmpchar_info): Delete.
         (MAX_MULTIBYTE_LENGTH): New macro.
-        (MAX_LENGTH_OF_MULTI_BYTE_FORM): Deleted.
+        (MAX_LENGTH_OF_MULTI_BYTE_FORM): Delete.
         (find_charset_in_str): Argument adjusted.
-        (CHAR_LEN): Modified.
+        (CHAR_LEN): Modify.
 
         * charset.c: In this entry, just `Modified' means that codes for a
         composite character is deleted.
         (Qcomposition) (leading_code_composition)
         (charset_composition) (min_composite_char) (cmpchar_table)
-        (cmpchar_table_size) (n_cmpchars): Deleted.
-        (SPLIT_COMPOSITE_SEQ): Deleted.
-        (SPLIT_MULTIBYTE_SEQ): Modified.
-        (char_to_string): Renamed from non_ascii_char_to_string.
+        (cmpchar_table_size) (n_cmpchars): Delete.
+        (SPLIT_COMPOSITE_SEQ): Delete.
+        (SPLIT_MULTIBYTE_SEQ): Modify.
+        (char_to_string): Rename from non_ascii_char_to_string.
         Modified.
-        (string_to_char): Renamed from string_to_non_ascii_char.
-        (split_string): Renamed from split_non_ascii_string.
+        (string_to_char): Rename from string_to_non_ascii_char.
+        (split_string): Rename from split_non_ascii_string.
         (char_printable_p) (Fsplit_char)
         (Ffind_charset_region) (Ffind_charset_string) (char_valid_p)
-        (char_bytes) (Fchar_width) (strwidth): Modified.
+        (char_bytes) (Fchar_width) (strwidth): Modify.
         (find_charset_in_str): Argument CMPCHARP deleted.  Modified.
-        (Fstring): Adjusted for the change of CHAR_STRING.  Modified.
+        (Fstring): Adjust for the change of CHAR_STRING.  Modified.
         (hash_string) (CMPCHAR_HASH_TABLE_SIZE) (cmpchar_hash_table)
         (CMPCHAR_HASH_SIZE) (CMPCHAR_HASH_USED) (CMPCHAR_HASH_CMPCHAR_ID)
         (str_cmpchar_id) (cmpchar_component) (Fcmpcharp)
         (Fcmpchar_component) (Fcmpchar_cmp_rule) (Fcmpchar_cmp_rule_p)
-        (Fcmpchar_cmp_count): Deleted.
+        (Fcmpchar_cmp_count): Delete.
         (Fcompose_string): Implemented by Emacs Lisp in composite.el.
-        (init_charset_once): Modified.
-        (syms_of_charset): Modified.
+        (init_charset_once): Modify.
+        (syms_of_charset): Modify.
 
-        * cmds.c (internal_self_insert): Adjusted for the change of
+        * cmds.c (internal_self_insert): Adjust for the change of
         CHAR_STRING.
 
         * coding.h (emacs_code_class_type): Delete the member
@@ -377,8 +377,8 @@
         (COMPOSING_WITH_RULE_TAIL) (COMPOSING_NO_RULE_TAIL)
         (COMPOSING_WITH_RULE_RULE) (COMPOSING_HEAD_P)
         (COMPOSING_WITH_RULE_P): Macros deleted.
-        (COMPOSITION_DATA_SIZE) (COMPOSITION_DATA_MAX_BUNCH_LENGTH): New
-        macros.
+        (COMPOSITION_DATA_SIZE) (COMPOSITION_DATA_MAX_BUNCH_LENGTH):
+        New macros.
         (struct composition_data): New structure.
         (CODING_FINISH_INSUFFICIENT_CMP): New macro.
         (struct coding_system): New members composition_rule_follows,
@@ -395,7 +395,7 @@
         EMACS_leading_code_composition to 0x80.
         (detect_coding_iso2022): Handle new composition sequence.
         (DECODE_ISO_CHARACTER): Likewise.
-        (check_composing_code): Deleted.
+        (check_composing_code): Delete.
         (coding_allocate_composition_data): New function.
         (CODING_ADD_COMPOSITION_START) (CODING_ADD_COMPOSITION_END)
         (CODING_ADD_COMPOSITION_COMPONENT) (DECODE_COMPOSITION_START)
@@ -404,7 +404,7 @@
         (ENCODE_ISO_CHARACTER): Don't check composition here.
         (ENCODE_COMPOSITION_RULE) (ENCODE_COMPOSITION_START): New macros.
         (ENCODE_COMPOSITION_NO_RULE_START)
-        (ENCODE_COMPOSITION_WITH_RULE_START): Deleted.
+        (ENCODE_COMPOSITION_WITH_RULE_START): Delete.
         (ENCODE_COMPOSITION_END): Handle new composition sequence.
         (ENCODE_COMPOSITION_FAKE_START): New macro.
         (encode_coding_iso2022): Handle new composition sequence.
@@ -414,12 +414,12 @@
         coding_system.  Enable composition only when the coding system has
         `composition' property t.
         (coding_free_composition_data) (coding_adjust_composition_offset)
-        (coding_save_composition) (coding_restore_composition): New
-        functions.
+        (coding_save_composition) (coding_restore_composition):
+        New functions.
         (code_convert_region): Call coding_save_composition for encoding
         and coding_allocate_composition_data for decoding.  Don't skip
-        ASCII characters if we handle composition on encoding.  Call
-        signal_after_change with Check_BORDER.
+        ASCII characters if we handle composition on encoding.
+        Call signal_after_change with Check_BORDER.
         (code_convert_string): Call coding_save_composition for encoding
         and coding_allocate_composition_data for decoding.  Don't skip
         ASCII characters if we handle composition on encoding.
@@ -448,9 +448,9 @@
         * dispnew.c (direct_output_forward_char): Check point moving into
         or out of a composition.  If so, give up direct method.
 
-        * doprnt.c (doprnt1): Adjusted for the change of CHAR_STRING.
+        * doprnt.c (doprnt1): Adjust for the change of CHAR_STRING.
 
-        * editfns.c (Fchar_to_string): Adjusted for the change of
+        * editfns.c (Fchar_to_string): Adjust for the change of
         CHAR_STRING.
         (general_insert_function): Likewise.
         (Finsert_char): Likewise.
@@ -460,19 +460,19 @@
 
         * emacs.c (main): Call syms_of_composite.
 
-        * fileio.c (Fsubstitute_in_file_name): Adjusted for the change of
+        * fileio.c (Fsubstitute_in_file_name): Adjust for the change of
         CHAR_STRING.
         (Finsert_file_contents): Set Vlast_coding_system_used before
         calling signal_after_change.  Call update_compositions if some
         texts are inserted..
-        (Fwrite_region): Adjusted for the change of a_write and e_write.
+        (Fwrite_region): Adjust for the change of a_write and e_write.
         (a_write): Argument changed.  Work based on character position,
         not byte position.
         (e_write): Argument changed.  Handle new way of composition.
 
         * fns.c (Flength): The length of char-table is MAX_CHAR.
-        (concat): Adjusted for the change of CHAR_STRING.
-        (Ffillarray): Adjusted for the change of CHAR_STRING.
+        (concat): Adjust for the change of CHAR_STRING.
+        (Ffillarray): Adjust for the change of CHAR_STRING.
         (Fset_char_table_default): Delete codes for a composite character.
         (hash_put): Return hash index.
 
@@ -492,7 +492,7 @@
         (Fmove_to_column): Likewise.
         (compute_motion): Likewise.
 
-        * insdel.c (copy_text): Adjusted for the change of CHAR_STRING.
+        * insdel.c (copy_text): Adjust for the change of CHAR_STRING.
         (insert_char): Likewise.
         (insert): Call update_compositions.
         (insert_and_inherit): Likewise.
@@ -502,7 +502,7 @@
         (insert_from_string_before_markers): Likewise.
         (insert_from_buffer): Likewise.
         (replace_range): Likewise.
-        (count_combining_composition): Deleted.
+        (count_combining_composition): Delete.
         (count_combining_before): Delete codes for a composite character.
         (count_combining_after): Likewise.
         (del_range_1): Call update_compositions.
@@ -526,16 +526,16 @@
         necessary.
         (adjust_point_for_property): New function.
 
-        * keymap.c (push_key_description): Adjusted for the change of
+        * keymap.c (push_key_description): Adjust for the change of
         CHAR_STRING.
         (Ftext_char_description): Likewise.
 
         * lisp.h (QCtest, QCweakness, Qequal): Extern them.
-        (hash_put): Adjusted for the change of the definition.
+        (hash_put): Adjust for the change of the definition.
         (signal_after_change): Likewise.
         (check_point_in_composition): Extern it.
 
-        * lread.c (readchar): Adjusted for the change of CHAR_STRING.
+        * lread.c (readchar): Adjust for the change of CHAR_STRING.
         Delete a code that handles an invalid too-long multibyte sequence
         because we are now sure that we never encounter with such a
         sequence.
@@ -544,14 +544,14 @@
         (init_obarray): Likewise.
         (read1): Likewise.  Adjusted for the change of CHAR_STRING.
 
-        * print.c (printchar): Adjusted for the change of CHAR_STRING.
+        * print.c (printchar): Adjust for the change of CHAR_STRING.
 
         * process.c: Include composite.h.
         (read_process_output): Call update_compositions.
 
-        * regex.c (regex_compile): Adjusted for the change of CHAR_STRING.
+        * regex.c (regex_compile): Adjust for the change of CHAR_STRING.
 
-        * search.c (search_buffer): Adjusted for the change of CHAR_STRING.
+        * search.c (search_buffer): Adjust for the change of CHAR_STRING.
 
         * syntax.h (SYNTAX_ENTRY_INT): Delete codes for a composite
         character.
@@ -570,19 +570,19 @@
         (face_before_or_after_it_pos): For composition, check face of a
         character after the composition.
         (handle_composition_prop): New function.
-        (get_next_display_element): Adjusted for the change of
+        (get_next_display_element): Adjust for the change of
         CHAR_STRING.
         (set_iterator_to_next): Handle the case that it->method ==
         next_element_from_composition.
         (next_element_from_composition): New function.
-        (message_dolog): Adjusted for the change of CHAR_STRING.
+        (message_dolog): Adjust for the change of CHAR_STRING.
         (set_message_1): Likewise.
         (check_point_in_composition): New function.
         (reconsider_clip_changes): If point moved into or out of
         composition, set b->clip_changed to 1 to force updating of the
         screen.
         (disp_char_vector): Delete codes for a composite character.
-        (decode_mode_spec_coding): Adjusted for the change of CHAR_STRING.
+        (decode_mode_spec_coding): Adjust for the change of CHAR_STRING.
 
         * xfaces.c (choose_face_fontset_font): Delete codes for a
         composite character.
@@ -592,7 +592,7 @@
         * xfns.c: Include intervals.h.
         (syms_of_xfns): Make `display' property nonsticky by default.
 
-        * xselect.c (lisp_data_to_selection_data): Adjusted for the change
+        * xselect.c (lisp_data_to_selection_data): Adjust for the change
         for find_charset_in_str.
 
         * xterm.h (struct x_output): Change member font_baseline to
@@ -618,9 +618,9 @@
         (x_draw_composite_glyph_string_foreground): New function.
         (x_draw_glyph_string_box): Check s->cmp, not s->cmpcharp.
         (x_draw_glyph_string): Handle the case of COMPOSITE_GLYPH.
-        (struct work): Deleted.
-        (x_fill_composite_glyph_string): Argument changed.  Mostly
-        rewritten for that.
+        (struct work): Delete.
+        (x_fill_composite_glyph_string): Argument changed.
+        Mostly rewritten for that.
         (x_fill_glyph_string): Don't check CHARSET_COMPOSITION.
         (BUILD_CHAR_GLYPH_STRINGS): Don't handle composition here.
         (BUILD_COMPOSITE_GLYPH_STRING): New macro.
@@ -656,8 +656,8 @@
         * frame.h (FRAME_FOREGROUND_PIXEL, FRAME_BACKGROUND_PIXEL)
         [!MSDOS && !WINDOWSNT && !macintosh]: Moved here from xterm.h.
 
-        * xterm.h (FRAME_FOREGROUND_PIXEL, FRAME_BACKGROUND_PIXEL): Moved
-        to frame.h.
+        * xterm.h (FRAME_FOREGROUND_PIXEL, FRAME_BACKGROUND_PIXEL):
+        Move to frame.h.
 
 1999-12-09  Stefan Monnier  <monnier@cs.yale.edu>
 
@@ -668,11 +668,11 @@
         * xterm.c (#includes): Allow compilation with only Xaw.
         (xaw3d_arrow_scroll, xaw3d_pick_top): New variables.
         (xt_action_hook): Replace XAW3D by XAW.
-        (xaw3d_jump_callback): Renamed to xaw_jump_callback.
-        (xaw_jump_callback): Renamed from xaw3d_jump_callback.
+        (xaw3d_jump_callback): Rename to xaw_jump_callback.
+        (xaw_jump_callback): Rename from xaw3d_jump_callback.
         Determine epsilon dynamically and don't try to be too clever.
-        (xaw3d_scroll_callback): Renamed to xaw_scroll_callback.
-        (xaw_scroll_callback): Renamed from xaw3d_scroll_callback.
+        (xaw3d_scroll_callback): Rename to xaw_scroll_callback.
+        (xaw_scroll_callback): Rename from xaw3d_scroll_callback.
         Handle both Xaw3d with arrow-scrollbars and with Xaw-style
         scrollbar (using `ratio').
         (x_create_toolkit_scroll_bar): Try to detect which style of Xaw3d
@@ -710,9 +710,9 @@
 
 1999-12-07  Alexandre Oliva  <oliva@dcc.unicamp.br>
 
-        * unexelf.c: Include <syms.h>, not <sym.h> on IRIX.  Removed
-        duplicate definition of ElfW.
-        (find_section): Copied from unexsgi.c.
+        * unexelf.c: Include <syms.h>, not <sym.h> on IRIX.
+        Removed duplicate definition of ElfW.
+        (find_section): Copy from unexsgi.c.
         (unexec): Use find_section.  Adjust whitespace.  Initialize
         new_data2_offset based on old_data, not sbss (this fixes a bug on
         IRIX6).  Change #ifdef __mips to __sgi, since it's IRIX-specific.
@@ -798,8 +798,8 @@
         (FRAME_PARAM_FACES, FRAME_N_PARAM_FACES, FRAME_DEFAULT_PARAM_FACE)
         (FRAME_MODE_LINE_PARAM_FACE, FRAME_COMPUTED_FACES)
         (FRAME_N_COMPUTED_FACES, FRAME_SIZE_COMPUTED_FACES)
-        (FRAME_DEFAULT_FACE, FRAME_MODE_LINE_FACE, unload_color): Remove
-        unused macro definitions.
+        (FRAME_DEFAULT_FACE, FRAME_MODE_LINE_FACE, unload_color):
+        Remove unused macro definitions.
 
         * msdos.c (IT_set_frame_parameters): Don't call
         recompute_basic_faces, the next redisplay will, anyway.
@@ -818,13 +818,13 @@
 
         * Makefile.in (lisp, shortlisp): Add lisp/term/tty-colors.elc.
 
-        * xfns.c (x_defined_color): Rename from defined_color.  All
-        callers changed.
-        (Fxw_color_defined_p): Renamed from Fx_color_defined_p;
+        * xfns.c (x_defined_color): Rename from defined_color.
+        All callers changed.
+        (Fxw_color_defined_p): Rename from Fx_color_defined_p;
         all callers changed.
-        (Fxw_color_values): Renamed from Fx_color_values; all callers
+        (Fxw_color_values): Rename from Fx_color_values; all callers
         changed.
-        (Fxw_display_color_p): Renamed from Fx_display_color_p; all
+        (Fxw_display_color_p): Rename from Fx_display_color_p; all
         callers changed.
         (x_window_to_frame, x_any_window_to_frame)
         (x_non_menubar_window_to_frame, x_menubar_window_to_frame)
@@ -834,11 +834,11 @@
 
         * w32fns.c (x_window_to_frame): Use FRAME_W32_P instead of
         f->output_data.nothing.
-        (Fxw_color_defined_p): Renamed from Fx_color_defined_p;
+        (Fxw_color_defined_p): Rename from Fx_color_defined_p;
         all callers changed.
-        (Fxw_color_values): Renamed from Fx_color_values; all callers
+        (Fxw_color_values): Rename from Fx_color_values; all callers
         changed.
-        (Fxw_display_color_p): Renamed from Fx_display_color_p; all
+        (Fxw_display_color_p): Rename from Fx_display_color_p; all
         callers changed.
 
         * dispextern.h (tty_color_name): Add prototype.
@@ -856,7 +856,7 @@
 
 1999-12-06  Kenichi Handa  <handa@etl.go.jp>
 
-        * fileio.c (decide_coding_unwind): Renamed from
+        * fileio.c (decide_coding_unwind): Rename from
         set_auto_coding_unwind.
         (Finsert_file_contents): Make single unwind protect to call both
         Vset_auto_coding_function and Ffind_operation_coding_system.
@@ -868,7 +868,7 @@
         * regex.c (regex_compile): Recognize *?, +? and ?? as non-greedy
         operators and handle them properly.
         * regex.h (RE_ALL_GREEDY): New option.
-        (RE_UNMATCHED_RIGHT_PAREN_ORD): Moved to the end where alphabetic
+        (RE_UNMATCHED_RIGHT_PAREN_ORD): Move to the end where alphabetic
         sorting would put it.
         (RE_SYNTAX_AWK, RE_SYNTAX_GREP, RE_SYNTAX_EGREP)
         (_RE_SYNTAX_POSIX_COMMON): Use the new option to keep old behavior.
@@ -898,8 +898,8 @@
 1999-11-28  Gerd Moellmann  <gerd@gnu.org>
 
         * systime.h (EMACS_TIME_CMP, EMACS_TIME_EQ, EMACS_TIME_NE)
-        (EMACS_TIME_GT, EMACS_TIME_GE, EMACS_TIME_LT, EMACS_TIME_LE): New
-        macros.
+        (EMACS_TIME_GT, EMACS_TIME_GE, EMACS_TIME_LT, EMACS_TIME_LE):
+        New macros.
 
         * config.in (HAVE_SETITIMER, HAVE_UALARM): New.
 
@@ -932,8 +932,8 @@
 
         * puresize.h (BASE_PURESIZE): Increase to 550000.
 
-        * textprop.c (set_text_properties): New function.  Like
-        Fset_text_properties, but with additional parameter
+        * textprop.c (set_text_properties): New function.
+        Like Fset_text_properties, but with additional parameter
         SIGNAL_AFTER_CHANGE_P.  If that is nil, don't signal after
         changes.
         (Fset_text_properties): Use it.
@@ -1018,7 +1018,7 @@
         * fileio.c (strerror): Likewise.
         * process.c (strerror): Likewise.
         * emacs.c (strerror): Likewise.
-        (Vsystem_messages_locale): Renamed from Vmessages_locale.
+        (Vsystem_messages_locale): Rename from Vmessages_locale.
         All uses changed.
         (Vprevious_system_messages_locale): Likewise, from
         Vprevious_messages_locale.
@@ -1041,7 +1041,7 @@
         (FREE_RETURN_TYPE): New macro.
         (free): Return type is now FREE_RETURN_TYPE.
 
-        * lisp.h (synchronize_system_time_locale): Renamed from
+        * lisp.h (synchronize_system_time_locale): Rename from
         synchronize_time_locale.  All uses changed.
         (synchronize_system_messages_locale): Likewise, from
         synchronize_messages_locale.
@@ -1135,13 +1135,13 @@
 
 1999-11-10  Gerd Moellmann  <gerd@gnu.org>
 
-        * xfns.c (QCuser_data): Removed.
+        * xfns.c (QCuser_data): Remove.
         (syms_of_xfns): Initialization of QCuser_data removed.
-        (parse_image_spec): Don't handle :user-data specially.  Allow
-        unknown keys.  Remove parameter ALLOW_OTHER_KEYS.
+        (parse_image_spec): Don't handle :user-data specially.
+        Allow unknown keys.  Remove parameter ALLOW_OTHER_KEYS.
         (xbm_image_p, xbm_load, xpm_image_p, pbm_image_p, png_image_p)
-        (tiff_image_p, jpeg_image_p, gif_image_p, gs_image_p): Call
-        parse_image_spec accordingly.
+        (tiff_image_p, jpeg_image_p, gif_image_p, gs_image_p):
+        Call parse_image_spec accordingly.
 
 1999-11-09  Richard M. Stallman  <rms@gnu.org>
 
@@ -1178,8 +1178,8 @@
         * lisp.h: Add prototype for unmark_byte_stack.
 
         * bytecode.c (mark_byte_stack): Use XMARKBIT and XMARK.
-        (unmark_byte_stack): Renamed from relocate_byte_pcs.  Use
-        XUNMARK.
+        (unmark_byte_stack): Rename from relocate_byte_pcs.
+        Use XUNMARK.
 
         * xdisp.c (resize_mini_window): Fix computation of needed
         mini-window height.
@@ -1214,7 +1214,7 @@
         (byte_stack_list, mark_byte_stack, relocate_byte_pcs): New.
         (BEFORE_POTENTIAL_GC, AFTER_POTENTIAL_GC): New.
         (FETCH, PUSH, POP, DISCARD, TOP, MAYBE_GC): Rewritten.
-        (HANDLE_RELOCATION): Removed.
+        (HANDLE_RELOCATION): Remove.
         (Fbyte_code): Use byte_stack structures.
 
         * filelock.c (Ffile_locked_p): Make FILENAME a required argument.
@@ -1224,10 +1224,10 @@
 
 1999-11-04  Gerd Moellmann  <gerd@gnu.org>
 
-        * editfns.c (Fdelete_field): Renamed from Ferase_field.
+        * editfns.c (Fdelete_field): Rename from Ferase_field.
 
-        * minibuf.c (do_completion, Fminibuffer_complete_word): Use
-        Ferase_field instead of Fdelete_field.
+        * minibuf.c (do_completion, Fminibuffer_complete_word):
+        Use Ferase_field instead of Fdelete_field.
 
 1999-11-03  Gerd Moellmann  <gerd@gnu.org>
 
@@ -1279,7 +1279,7 @@
         * xfns.c (png_load) [PNG_READ_sRGB_SUPPORTED]: Put code using
         png_get_sRGB in #ifdef.
 
-        * dispnew.c (Finternal_show_cursor): Renamed from Fshow_cursor.
+        * dispnew.c (Finternal_show_cursor): Rename from Fshow_cursor.
         (syms_of_display): Use the new name.
 
         * textprop.c (verify_interval_modification): Signal text-read-only
@@ -1346,7 +1346,7 @@
 
 1999-10-27  Richard M. Stallman  <rms@gnu.org>
 
-        * data.c (Qad_activate_internal): Renamed from Qad_activate.
+        * data.c (Qad_activate_internal): Rename from Qad_activate.
         (Ffset): Call Qad_activate_internal.
         (syms_of_data): Initialize Qad_activate_internal.
 
@@ -1493,12 +1493,12 @@
         * editfns.c: Include coding.h.
         (emacs_strftime): Remove decl.
         (emacs_strftimeu): New decl.
-        (emacs_memftimeu): Renamed from emacs_memftime; new arg UT.
+        (emacs_memftimeu): Rename from emacs_memftime; new arg UT.
         Use emacs_strftimeu instead of emacs_strftime.
         (Fformat_time_string): Convert format string using
         Vlocale_coding_system, and convert result back.  Synchronize time
-        locale before invoking lower level function.  Invoke
-        emacs_memftimeu, passing ut, instead of emacs_memftime.
+        locale before invoking lower level function.
+        Invoke emacs_memftimeu, passing ut, instead of emacs_memftime.
 
         * emacs.c: Include <locale.h> if HAVE_SETLOCALE is defined.
         (Vmessages_locale, Vprevious_messages_locale, Vtime_locale)
@@ -1506,7 +1506,7 @@
         (main): Invoke setlocale early, so that initial error messages are
         localized properly.  But skip locale-setting if LC_ALL is "C".
         Fix up locale when it's safe to do so.
-        (fixup_locale): Moved here from xterm.c.
+        (fixup_locale): Move here from xterm.c.
         (synchronize_locale, synchronize_time_locale)
         (synchronize_messages_locale): New functions.
         (syms_of_emacs): Accommodate above changes.
@@ -1534,8 +1534,8 @@
 
         * lread.c (file_offset, file_tell): New macros.  All uses of ftell
         changed to file_tell.
-        (saved_doc_string_position, prev_saved_doc_string_position): Now
-        of type file_offset.
+        (saved_doc_string_position, prev_saved_doc_string_position):
+        Now of type file_offset.
         (init_lread): Do not fix locale here; fixup_locale now does this.
 
         * m/amdahl.h, s/usg5-4.h:
@@ -1589,10 +1589,10 @@
         (emacs_open, emacs_close, emacs_read, emacs_write): Always define;
         the old INTERRUPTIBLE_OPEN, INTERRUPTIBLE_CLOSE, and INTERRUPTIBLE_IO
         macros are no longer used.
-        (emacs_open): Renamed from sys_open.  Merge BSD4_1 version.
-        (emacs_close): Renamed from sys_close.
-        (emacs_read): Renamed from sys_read.
-        (emacs_write): Renamed from sys_write.
+        (emacs_open): Rename from sys_open.  Merge BSD4_1 version.
+        (emacs_close): Rename from sys_close.
+        (emacs_read): Rename from sys_read.
+        (emacs_write): Rename from sys_write.
         (sys_siglist): Do not declare if HAVE_STRSIGNAL.
         (dup2): Do not print error on failure; the real dup2 doesn't.
         (strsignal): New function, defined if !HAVE_STRSIGNAL.
@@ -1638,8 +1638,8 @@
 1999-10-18  Kenichi Handa  <handa@etl.go.jp>
 
         * coding.c (code_convert_string): Add record_unwind_protect to
-        assure setting inhibit_pre_post_conversion back to zero.  Take
-        care of the multibyteness of the working buffer.
+        assure setting inhibit_pre_post_conversion back to zero.
+        Take care of the multibyteness of the working buffer.
 
         * coding.c (inhibit_pre_post_conversion): New variable.
         (setup_coding_system): If inhibit_pre_post_conversion is nonzero,
@@ -1666,13 +1666,13 @@
         * minibuf.c (Fminibuffer_complete_and_exit): Supply value for new
         ESCAPE_FROM_EDGE parameter to Ffield_beginning.
 
-        * editfns.c (text_property_eq, text_property_stickiness): Don't
-        use initializers for auto variables of type Lisp_Object.
+        * editfns.c (text_property_eq, text_property_stickiness):
+        Don't use initializers for auto variables of type Lisp_Object.
         (find_field): Likewise.  Use braces around nested ifs.
         (Fline_end_position): Store the raw eol in a variable, so that the
         final expression doesn't look so ugly.
         (Fconstrain_to_field): Doc fix.
-        (preceding_pos): Renamed from `preceeding_pos'.
+        (preceding_pos): Rename from `preceeding_pos'.
         (text_property_stickiness, find_field): Call preceding_pos,
         not preceeding_pos.
 
@@ -1696,8 +1696,8 @@
         * syntax.c (Fforward_word): Supply new ESCAPE_FROM_EDGE parameter
         to Fconstrain_to_field.
 
-        * minibuf.c (Fminibuffer_complete_word): Use
-        Ffield_beginning to find the prompt end.
+        * minibuf.c (Fminibuffer_complete_word):
+        Use Ffield_beginning to find the prompt end.
 
 1999-10-17  Miles Bader  <miles@gnu.org>
 
@@ -1746,8 +1746,8 @@
 1999-10-16  Gerd Moellmann  <gerd@gnu.org>
 
         * window.c (enum save_restore_action): New.
-        (save_restore_orig_size): Change parameter list.  Add
-        functionality to check for valid orig_top and orig_height members
+        (save_restore_orig_size): Change parameter list.
+        Add functionality to check for valid orig_top and orig_height members
         in a window tree.
         (grow_mini_window): Call save_restore_orig_size with new parameter
         list.
@@ -1848,8 +1848,8 @@
         (Finternal_set_lisp_face_attribute): Ditto.
         (Fpixmap_spec_p): Rewritten.  Extend doc string.
 
-        * xmenu.c (set_frame_menubar, xmenu_show): Call
-        x_set_menu_resources_from_menu_face.
+        * xmenu.c (set_frame_menubar, xmenu_show):
+        Call x_set_menu_resources_from_menu_face.
 
         * dispextern.h (enum face_id): Add MENU_FACE_ID.
         (toplevel): Include X11/Intrinsic.h.
@@ -1869,7 +1869,7 @@
 
 1999-09-29  Gerd Moellmann  <gerd@gnu.org>
 
-        * editfns.c (Fpropertize): Renamed from Fproperties.
+        * editfns.c (Fpropertize): Rename from Fproperties.
 
 1999-09-29  Gerd Moellmann  <gerd@gnu.org>
 
@@ -1897,8 +1897,8 @@
 
         * textprop.c (next_single_char_property_change): New.
 
-        * xdisp.c (display_prop_end, invisible_text_between_p): Use
-        next_single_char_property_change.
+        * xdisp.c (display_prop_end, invisible_text_between_p):
+        Use next_single_char_property_change.
 
 1999-09-25  Gerd Moellmann  <gerd@gnu.org>
 
@@ -1928,7 +1928,7 @@
 
         * xfaces.c (add_to_log): Move to xdisp.c.
 
-        * xdisp.c (add_to_log): Moved from xfaces.c.  Remove frame
+        * xdisp.c (add_to_log): Move from xfaces.c.  Remove frame
         parameter.
 
 1999-09-23  Gerd Moellmann  <gerd@gnu.org>
@@ -1945,10 +1945,10 @@
         (grow_mini_window, shrink_mini_window): New.
         (make_window, replace_window): Initialize orig_top and
         orig_height.
-        (enlarge_window): Renamed from change_window_height.  Make it
+        (enlarge_window): Rename from change_window_height.  Make it
         static.
-        (Fdisplay_buffer, Fenlage_window, Fshrink_window): Call
-        enlarge_window instead of change_window_height.
+        (Fdisplay_buffer, Fenlage_window, Fshrink_window):
+        Call enlarge_window instead of change_window_height.
 
         * window.h (struct window): New members orig_top, orig_height.
         (toplevel): Add prototypes for grow_mini_window and
@@ -2003,8 +2003,8 @@
 
         * xdisp.c (compute_window_start_on_continuation_line): Handle case
         that window start is out of range.
-        (handle_display_prop, handle_single_display_prop): Replace
-        marginal area specifications like `left-margin' with `(margin
+        (handle_display_prop, handle_single_display_prop):
+        Replace marginal area specifications like `left-margin' with `(margin
         left-margin)'.
         (Qmargin): New.
         (syms_of_xdisp): Initialize Qmargin.
@@ -2020,7 +2020,7 @@
         (Fopen_network_stream, create_process): Add parentheses to
         conditional expressions.
         (create_process): Put declaration of sigchld in #if 0.
-        (Fopen_network_stream): Removed unused variables.
+        (Fopen_network_stream): Remove unused variables.
         (Fopen_network_stream, wait_reading_process_input)
         (wait_reading_process_input, send_process, send_process): Ditto.
         (toplevel): Add prototypes for set_waiting_for_input and
@@ -2057,7 +2057,7 @@
 
         * buffer.h: Add prototype for r_re_alloc.
 
-        * insdel.c (copy_text): Removed unused variables.
+        * insdel.c (copy_text): Remove unused variables.
         (count_combining_after, count_combining_after, insert_1_both)
         (insert_from_string_1, insert_from_buffer_1, check_markers): Ditto.
         (adjust_after_replace, replace_range): Add parentheses to logical
@@ -2177,8 +2177,8 @@
         * xdisp.c (resize_mini_window): Don't report changed window
         height if it actually hasn't changed.
 
-        * widget.c (set_frame_size, EmacsFrameSetCharSize): Remove
-        unused variables.
+        * widget.c (set_frame_size, EmacsFrameSetCharSize):
+        Remove unused variables.
         (mark_shell_size_user_specified): Put in #if 0 because not used.
         (create_frame_gcs): Put in #if 0 because currently unused.
         (first_frame_p): Ditto.
@@ -2188,7 +2188,7 @@
         (free_frame_menubar, xmenu_show, xdialog_show): Remove unused
         variables.
 
-        * print.c (PRINTFULLP): Removed because it is no longer used and
+        * print.c (PRINTFULLP): Remove because it is no longer used and
         is misleading.
         (Ferror_message_string): Remove unused variables.
         (print_object): Cast argument of sprintf to long for `%ld'
@@ -2297,7 +2297,7 @@
 
         * xterm.c (XTcursor_to): Change for Lisp_Object selected_frame.
         (x_clear_frame, XTring_bell, XTmouse_position, XTread_socket): Ditto.
-        (XRINGBELL): Removed.
+        (XRINGBELL): Remove.
 
 1999-09-13  Dave Love  <fx@gnu.org>
 
@@ -2307,7 +2307,7 @@
 
 1999-09-13  Gerd Moellmann  <gerd@delysid.gnu.org>
 
-        * xfns.c (QCfile): Moved to xdisp.c.
+        * xfns.c (QCfile): Move to xdisp.c.
         (syms_of_xfns): Don't initialize QCfile.
         (check_x_frame): Change for Lisp_Object selected_frame.
         (check_x_display_info, x_get_resource_string): Ditto.
@@ -2317,7 +2317,7 @@
         * minibuf.c (choose_minibuf_frame): Don't try to set the
         mini-buffer window's buffer, if the buffer is invalid.
 
-        * xfns.c (QCfile): Moved to xdisp.c.
+        * xfns.c (QCfile): Move to xdisp.c.
         (syms_of_xfns): Don't initialize QCfile.
 
         * xdisp.c (QCfile): Move here from xfns.c.
@@ -2401,7 +2401,7 @@
 
         * xterm.c (XTcursor_to): Change for Lisp_Object selected_frame.
         (x_clear_frame, XTring_bell, XTmouse_position, XTread_socket): Ditto.
-        (XRINGBELL): Removed.
+        (XRINGBELL): Remove.
 
         * window.c (Fminibuffer_window): Change for Lisp_Object
         selected_frame.
@@ -2456,8 +2456,8 @@
         * keyboard.c (command_loop_1): Resize mini-window to the
         exact size of a message displayed, if any.
 
-        * xdisp.c (resize_mini_window): Add parameter exact_p.  Resize
-        to exact size if exact_p is non-zero.
+        * xdisp.c (resize_mini_window): Add parameter exact_p.
+        Resize to exact size if exact_p is non-zero.
         (display_echo_area_1): Call resize_mini_window with
         new parameter.
         (redisplay_internal): Ditto.
@@ -2498,8 +2498,8 @@
         (Fkill_buffer): Ditto.
         (Ferase_buffer): Ditto.
 
-        * buffer.h (prompt_end_charpos): Replaces
-        minibuffer_prompt_length.
+        * buffer.h (prompt_end_charpos):
+        Replaces minibuffer_prompt_length.
 
         * minibuf.c (read_minibuf): Return mini-buffer contents
         without the prompt.
@@ -2582,8 +2582,8 @@
         (x_load_font, x_find_ccl_program, x_term_init, x_delete_display):
         Likewise.
 
-        * alloc.c (make_float, make_pure_float, Fpurecopy): Use
-        XFLOAT_DATA.
+        * alloc.c (make_float, make_pure_float, Fpurecopy):
+        Use XFLOAT_DATA.
         * bytecode.c (Fbyte_code): Likewise.
         * floatfns.c (extract_float, Fexpt, Fabs, rounding_driver)
         (fmod_float): Likewise.
@@ -2614,7 +2614,7 @@
 1999-09-10  Keisuke Nishida  <kxn30@po.cwru.edu>
 
         * print.c: Support print-circle and related features.
-        (Vprint_gensym_alist): Removed.
+        (Vprint_gensym_alist): Remove.
         (Vprint_circle, Vprint_continuous_numbering, print_number_index)
         (Vprint_number_table): New variables.
         (PRINT_NUMBER_OBJECT, PRINT_NUMBER_STATUS): New macros.
@@ -2703,8 +2703,8 @@
 
 1999-09-07  Gerd Moellmann  <gerd@gnu.org>
 
-        * xfns.c (x_set_foreground_color): Call
-        update_face_from_frame_parameter.
+        * xfns.c (x_set_foreground_color):
+        Call update_face_from_frame_parameter.
         (x_set_background_color): Ditto.
         (x_set_mouse_color): Ditto.
         (x_set_cursor_color): Ditto.
@@ -2926,7 +2926,7 @@
         (Fset_window_start): Ditto.
 
         * xdisp.c (Vresize_mini_config, resize_mini_frame)
-        (resize_mini_initial_height): Removed.
+        (resize_mini_initial_height): Remove.
         (syms_of_xdisp): Remove references to these variables.
         (resize_mini_window): Don't save window configuration, freeze
         window starts instead.  Enlarge window until displaying an empty
@@ -2952,16 +2952,16 @@
 
         * xterm.c (x_scroll_bar_create): Don't clear under scroll bar
         here.
-        (XTset_vertical_scroll_bar): Clarify position computations.  Clear
-        under newly created scroll bar.  Put toolkit scroll bars in the
+        (XTset_vertical_scroll_bar): Clarify position computations.
+        Clear under newly created scroll bar.  Put toolkit scroll bars in the
         middle of the area reserved for the scroll bar.
 
 1999-09-03  Kenichi Handa  <handa@etl.go.jp>
 
         The following changes are for the new handling of multibyte
         sequence.  Now, except for a composite character, no multibyte
-        character in string/buffer has trailing garbage bytes.  For
-        instance, the length of string "\201\300\300" is now 2, the first
+        character in string/buffer has trailing garbage bytes.
+        For instance, the length of string "\201\300\300" is now 2, the first
         character is Latin-1 A-grave, the second is raw \300.
 
         * charset.h (MAKE_NON_ASCII_CHAR): Handle the case that C1 or C2
@@ -2972,7 +2972,7 @@
         (PARSE_CHARACTER_SEQ): New macro.
         (PARSE_MULTIBYTE_SEQ): New macro.
         (CHAR_PRINTABLE_P): New macro.
-        (STRING_CHAR): Adjusted for the change of string_to_non_ascii_char.
+        (STRING_CHAR): Adjust for the change of string_to_non_ascii_char.
         (STRING_CHAR_AND_LENGTH): Likewise.
         (STRING_CHAR_AND_CHAR_LENGTH): Define it as STRING_CHAR_AND_LENGTH.
         (INC_POS): Use the macro PARSE_MULTIBYTE_SEQ.
@@ -3016,8 +3016,8 @@
 
         * insdel.c (count_combining_composition): New function.
         (count_combining_before): Adjust the way to check byte-combining
-        possibility for the new handling of multibyte sequence.  Call
-        count_combining_composition for a composite character.
+        possibility for the new handling of multibyte sequence.
+        Call count_combining_composition for a composite character.
         (count_combining_after): Likewise.
 
         * print.c (print_string): Use the macro STRING_CHAR_AND_LENGTH.
@@ -3093,8 +3093,8 @@
         (window_box_left): Use FRAME_LEFT_FLAGS_AREA_WIDTH instead of
         FRAME_FLAGS_AREA_WIDTH.
 
-        * window.c (coordinates_in_window): Use
-        FRAME_LEFT_FLAGS_AREA_WIDTH instead of FRAME_FLAGS_AREA_WIDTH.
+        * window.c (coordinates_in_window):
+        Use FRAME_LEFT_FLAGS_AREA_WIDTH instead of FRAME_FLAGS_AREA_WIDTH.
         (window_internal_width): Subtract FRAME_FLAGS_AREA_WIDTH once
         instead of twice.
 
@@ -3105,14 +3105,14 @@
         * dispnew.c (mode_line_string): Add FRAME_LEFT_FLAGS_AREA_WIDTH
         instead of FRAME_FLAGS_AREA_WIDTH.
 
-        * dispextern.h (WINDOW_DISPLAY_PIXEL_WIDTH): Subtract
-        FRAME_FLAGS_AREA_COLS once.
-        (WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X): Add
-        FRAME_LEFT_FLAGS_AREA_WIDTH instead of FRAME_FLAGS_AREA_WIDTH.
+        * dispextern.h (WINDOW_DISPLAY_PIXEL_WIDTH):
+        Subtract FRAME_FLAGS_AREA_COLS once.
+        (WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X):
+        Add FRAME_LEFT_FLAGS_AREA_WIDTH instead of FRAME_FLAGS_AREA_WIDTH.
 
 1999-08-30  Gerd Moellmann  <gerd@gnu.org>
 
-        * s/freebsd.h (C_SWITCH_SYSTEM): Added to let configure find headers
+        * s/freebsd.h (C_SWITCH_SYSTEM): Add to let configure find headers
         in /usr/X11R6/include which are checked for with AC_CHECK_HEADER.
 
 1999-08-30  Gerd Moellmann  <gerd@gnu.org>
@@ -3139,8 +3139,8 @@
 
 1999-08-28  Ken Raeburn  <raeburn@gnu.org>
 
-        * lisp.h (struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change
-        names of structure elements if HIDE_LISP_IMPLEMENTATION is
+        * lisp.h (struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float):
+        Change names of structure elements if HIDE_LISP_IMPLEMENTATION is
         defined, to help detect code that uses knowledge of the Lisp
         internals that it shouldn't have.
         (XFLOAT_DATA): New macro.
@@ -3226,8 +3226,8 @@
 
 1999-08-22  Gerd Moellmann  <gerd@gnu.org>
 
-        * xdisp.c (unwind_with_echo_area_buffer): Use
-        set_buffer_internal_1 instead of set_buffer_internal.
+        * xdisp.c (unwind_with_echo_area_buffer):
+        Use set_buffer_internal_1 instead of set_buffer_internal.
         (with_echo_area_buffer): Ditto.
 
         * buffer.c (set_buffer_internal): Set windows_or_buffers_changed
@@ -3255,8 +3255,8 @@
         (mark_window_display_accurate, redisplay_internal): Set current
         matrix' buffer, begv, zv.
 
-        * window.c (Fset_window_hscroll): Set
-        prevent_redisplay_optimizations_p instead of clip_changed.
+        * window.c (Fset_window_hscroll):
+        Set prevent_redisplay_optimizations_p instead of clip_changed.
         (Fset_window_hscroll): Ditto.
         (temp_output_buffer_show): Ditto.
         (Fset_window_vscroll): Ditto.
@@ -3273,7 +3273,7 @@
         unchanged_modified, overlay_unchanged_modified.
 
         * window.h (beg_unchanged, end_unchanged, unchanged_modified)
-        (overlay_unchanged_modified): Removed.
+        (overlay_unchanged_modified): Remove.
         (with_echo_area_unwind_data): Don't save beg/end_unchanged.
         (unwind_with_echo_area_buffer): Don't restore them.
         (debug_beg_unchanged, debug_end_unchanged) [GLYPH_DEBUG]: Removed.
@@ -3310,8 +3310,8 @@
 
         * lisp.h: Add prototype for copy_hash_table and Fcopy_hash_table.
 
-        * fns.c (Qkey, Qvalue): Renamed from Qkey_weak, and Qvalue_weak.
-        (Qkey_value_weak): Removed.
+        * fns.c (Qkey, Qvalue): Rename from Qkey_weak, and Qvalue_weak.
+        (Qkey_value_weak): Remove.
         (make_hash_table): Use nil, `key', `value', t for weakness.
         (Fmake_hash_table): Ditto.
         (copy_hash_table): New.
@@ -3336,7 +3336,7 @@
         * fns.c (hash_lookup): Test with EQ before calling key comparison
         function.
         (hash_remove): Ditto.
-        (cmpfn_eq): Removed.
+        (cmpfn_eq): Remove.
         (cmpfn_eql): Don't test with EQ.
         (cmpfn_equal): Ditto.
         (make_hash_table): Set comparison function for `eq' to null.
@@ -3344,7 +3344,7 @@
         * buffer.c, cmds.c, editfns.c, indent.c, insdel.c, buffer.h:
         Remove conditional compilation on NO_PROMPT_IN_BUFFER.
 
-        * dispextern.h (NO_PROMPT_IN_BUFFER): Removed.
+        * dispextern.h (NO_PROMPT_IN_BUFFER): Remove.
 
         * window.c, widget.c, process.c, keyboard.c, frame.c, xdisp.c,
         xterm.c: Call change_frame_size and do_pending_window_change with
@@ -3369,8 +3369,8 @@
         NO_PROMPT_IN_BUFFER.
 
         * minibuf.c (Fminibuffer_prompt_end): New.
-        (syms_of_minibuf): Defsubr it.  Remove
-        minibuffer-prompt-in-buffer.
+        (syms_of_minibuf): Defsubr it.
+        Remove minibuffer-prompt-in-buffer.
         (Fminibuffer_prompt_width): Return 0 if not in mini-buffer.
         Extend documentation.
 
@@ -3381,7 +3381,7 @@
 
 1999-08-21  Gerd Moellmann  <gerd@gnu.org>
 
-        * xdisp.c (minibuffer_scroll_overlap): Removed because not used
+        * xdisp.c (minibuffer_scroll_overlap): Remove because not used
         anywhere.
         (unwind_redisplay): Return nil.
         (clear_garbaged_frames): New.
@@ -3400,7 +3400,7 @@
         * xdisp.c (echo_area_glyphs, echo_area_message)
         (echo_area_glyphs_length, previous_echo_glyphs)
         (previous_echo_area_message, previous_echo_area_glyphs_length):
-        Removed.
+        Remove.
         (Vmessage_stack, echo_area_buffer, echo_buffer)
         (display_last_displayed_message_p, Vwith_echo_area_save_vector): New.
         (message2_nolog): Use set_message and clear_message.
@@ -3426,7 +3426,7 @@
         Remove initialization of removed variables.
         (init_xdisp): Remove references to removed variables.
 
-        * dispnew.c (adjust_frame_message_buffer): Removed references
+        * dispnew.c (adjust_frame_message_buffer): Remove references
         to echo_area_glyphs and previous_echo_glyphs.
         (direct_output_for_insert): Check for mini-window displaying
         echo area message differently.
@@ -3440,7 +3440,7 @@
         longer used in that way.
         (PRINTDECLARE): Add multibyte.
         (PRINTPREPARE, PRINTFINISH): Handle printcharfun t differently.
-        (printbufidx): Removed.
+        (printbufidx): Remove.
         (printchar, strout): Rewritten.
 
         * keyboard.c (ok_to_echo_at_next_pause): Make it a pointer to
@@ -3493,8 +3493,8 @@
 
 1999-08-19  Gerd Moellmann  <gerd@gnu.org>
 
-        * xterm.c (XTset_vertical_scroll_bar): Fix previous change.  Clear
-        under scroll bar with width FRAME_SCROLL_BAR_COLS.
+        * xterm.c (XTset_vertical_scroll_bar): Fix previous change.
+        Clear under scroll bar with width FRAME_SCROLL_BAR_COLS.
 
 1999-08-18  Dave Love  <fx@gnu.org>
 
@@ -3511,8 +3511,8 @@
 
         * xfns.c (x_window) [USE_X_TOOLKIT]: Remove test for
         FRAME_X_WINDOW (f) being null at the of the function.  If widgets
-        cannot be created we will already have crashed earlier.  Call
-        lw_set_main_areas with a null menu-bar widget, so that we have
+        cannot be created we will already have crashed earlier.
+        Call lw_set_main_areas with a null menu-bar widget, so that we have
         a reasonable default.
         (Fx_create_frame): Rearranged so that Lisp errors during frame
         initialization cause less damage.  Initialize menu bar widget
@@ -3526,8 +3526,8 @@
 1999-08-17  Gerd Moellmann  <gerd@gnu.org>
 
         * window.c (Fcoordinates_in_window_p): Return `left-bitmap-area'
-        and `right-bitmap-area' if position is in the bitmap areas.  This
-        avoids an error when clicking on the bitmap areas.  Instead, they
+        and `right-bitmap-area' if position is in the bitmap areas.
+        This avoids an error when clicking on the bitmap areas.  Instead, they
         are currently treated like clicks inside the window.
         (coordinates_in_window): Return 5 and 6 for bitmap areas.
         (Qleft_bitmap_area, Qright_bitmap_area): New.
@@ -3553,14 +3553,14 @@
         * dispextern.h (struct it): Remove member
         show_trailing_whitespace_p.
 
-        * dispnew.c (direct_output_for_insert): Use
-        Vshow_trailing_whitespace instead of former iterator member
+        * dispnew.c (direct_output_for_insert):
+        Use Vshow_trailing_whitespace instead of former iterator member
         show_trailing_whitespace_p.
         (direct_output_forward_char): Don't do it if highlighting
         trailing whitespace.
 
-        * xdisp.c (Qshow_trailing_whitespace): Removed.
-        (Vshow_trailing_whitespace): Added.
+        * xdisp.c (Qshow_trailing_whitespace): Remove.
+        (Vshow_trailing_whitespace): Add.
         (init_iterator): Remove initialization code for
         show_trailing_whitespace_p.
         (redisplay_internal): Don't try cursor movement in this_line
@@ -3578,7 +3578,7 @@
 
         * window.c (Fpos_visible_in_window_p): Rewritten.
 
-        * xfaces.c (add_to_log): Renamed from display_message.
+        * xfaces.c (add_to_log): Rename from display_message.
         Don't display messages in echo area.
 
         * xterm.c (x_draw_glyph_string_box): Use the background width
@@ -3650,7 +3650,7 @@
 
 1999-08-13  Gerd Moellmann  <gerd@gnu.org>
 
-        * window.c (MINSIZE): Removed.
+        * window.c (MINSIZE): Remove.
         (window_min_size): New.
         (set_window_height): Use window_min_size.
         (change_window_height): Ditto.
@@ -3819,8 +3819,8 @@
 
         * dispextern.h (MATRIX_ROW_OVERLAPPING_P): New.
 
-        * dispextern.h (struct redisplay_interface): Add
-        fix_overlapping_area.
+        * dispextern.h (struct redisplay_interface):
+        Add fix_overlapping_area.
 
         * xterm.c (x_append_glyph): Set glyph flag overlaps_vertically_p.
 
@@ -3869,7 +3869,7 @@
 
 1999-08-03  Tom Breton  <tob@world.std.com>
 
-        * lread.c (read1): Added circular reading code to #N=.
+        * lread.c (read1): Add circular reading code to #N=.
         (SUBSTITUTE): New macro.
         (seen_list): New variable.
         (substitute_object_in_subtree): New function.
@@ -4068,7 +4068,7 @@
         * ccl.c (ccl_driver) <CCL_Call>: Now CCL program ID to call may be
         stored in the following CCL code.  Adjusted for the change of
         Vccl_program_table.
-        (resolve_symbol_ccl_program): Adjusted for the new style of
+        (resolve_symbol_ccl_program): Adjust for the new style of
         embedded symbols (SYMBOL . PROP) in CCL compiled code.   Return Qt
         is resolving failed.
         (ccl_get_compiled_code): New function.
@@ -4078,7 +4078,7 @@
         (Fccl_execute): Get compiled CCL code by just calling
         setup_ccl_program.
         (Fccl_execute_on_string): Likewise.
-        (Fregister_ccl_program): Adjusted for the change of
+        (Fregister_ccl_program): Adjust for the change of
         Vccl_program_table.
 
         * coding.c (setup_coding_system): Get compiled CCL code by just
@@ -4125,7 +4125,7 @@
         * xrdb.c (x_load_resources): Set double-click time defaults
         for Motif list boxes from double-click-time.
 
-        * fns.c (Vhash_table_tests): Removed.
+        * fns.c (Vhash_table_tests): Remove.
         (Qhash_table_test): New.
         (syms_of_fns): Initialize Qhash_table_test.
         (Fmake_hash_table): Look up user-defined tests in symbol prop
@@ -4152,7 +4152,7 @@
 
 1999-07-16  Gerd Moellmann  <gerd@gnu.org>
 
-        * frame.h (FRAME_WINDOW_REDISPLAY_P): Removed.  Use FRAME_WINDOW_P
+        * frame.h (FRAME_WINDOW_REDISPLAY_P): Remove.  Use FRAME_WINDOW_P
         instead.
 
         * fns.c (cmpfn_eq): Add hash code parameters.
@@ -4162,7 +4162,7 @@
 
 1999-07-15  Gerd Moellmann  <gerd@gnu.org>
 
-        * lisp.h (DEFAULT_REHASH_THRESHOLD): Changed to 0.8.
+        * lisp.h (DEFAULT_REHASH_THRESHOLD): Change to 0.8.
 
         * fns.c (maybe_resize_hash_table): Correct computation of
         index vector size.
@@ -4175,19 +4175,19 @@
         (survives_gc_p): Make it externally visible.
         (mark_object): Ditto.
 
-        * fns.c (remove_hash_entry): Removed.
+        * fns.c (remove_hash_entry): Remove.
         (sweep_weak_hash_tables): New.
 
         * print.c (print): Print more information about hash tables.
 
-        * xfns.c (image_spec_hash): Removed.
+        * xfns.c (image_spec_hash): Remove.
         (lookup_image): Use sxhash instead of image_spec_hash.
-        (image_spec_equal_p): Removed.
+        (image_spec_equal_p): Remove.
         (lookup_image): Use Fequal instead of image_spec_equal_p.
 
 1999-07-14  Gerd Moellmann  <gerd@gnu.org>
 
-        * lisp.h (P_): Moved to top of file.
+        * lisp.h (P_): Move to top of file.
 
         * fns.c (make_hash_table): Set new members.
 
@@ -4197,8 +4197,8 @@
         * lisp.h (struct Lisp_Hash_Table): Add user_cmp_function,
         user_hash_function, cmpfn, and hashfn.
 
-        * fns.c (build_hash): Removed.
-        (hash_test): Removed.
+        * fns.c (build_hash): Remove.
+        (hash_test): Remove.
         (cmpfn_eq, cmpfn_eql, cmpfn_equal, cmpfn_user_defined): New.
         (hashfn_eq, hashfn_eql, hashfn_equal, hashfn_user_defined): New.
 
@@ -4261,7 +4261,7 @@
         properties.
         (handle_single_display_prop): Handle some display property
         forms for terminal frames.
-        (Qimage): Moved here from xfns.c.
+        (Qimage): Move here from xfns.c.
 
         * dispextern.h (struct it): New field string_from_display_prop_p.
 
@@ -4331,8 +4331,8 @@
 
 1999-07-05  Gerd Moellmann  <gerd@gnu.org>
 
-        * term.c (TS_cursor_visible): Renamed from TS_visual_mode.
-        (TS_cursor_normal): Renamed from TS_end_visual_mode.
+        * term.c (TS_cursor_visible): Rename from TS_visual_mode.
+        (TS_cursor_normal): Rename from TS_end_visual_mode.
         (TS_cursor_invisible): New.
         (term_init): Initialize TS_cursor_invisible.
         (tty_hide_cursor): New.
@@ -4364,7 +4364,7 @@
 
 1999-07-02  Gerd Moellmann  <gerd@gnu.org>
 
-        * dispextern.h (HSCROLL_WINDOWS): Removed.
+        * dispextern.h (HSCROLL_WINDOWS): Remove.
 
         * xdisp.c (mark_window_display_accurate): Don't set
         w->region_showing.
@@ -4378,12 +4378,12 @@
         up when cursor is partially visible, make it fully visible.
         (mark_window_display_accurate): Some cleanup.  Record window's
         last cursor information.
-        (debug_method_add): Improved.
+        (debug_method_add): Improve.
         (redisplay_internal): Record last cursor info only if not
         consider_all_windows_p.
 
         * dispnew.c (update_window): Update top line after scrolling.
-        (blank_row): Renamed from make_empty_enabled_row.
+        (blank_row): Rename from make_empty_enabled_row.
         (increment_glyph_row_buffer_positions): Increment positions
         in buffers, only.
 
@@ -4406,7 +4406,7 @@
         * dispextern.h (struct glyph_matrix): Add member window_vscroll.
 
         * xdisp.c (debug_method_add): New.
-        (debug_redisplay_method): Removed.
+        (debug_redisplay_method): Remove.
         (try_window_reusing_current_matrix): Handle case where old
         window start is the same as new window start.
 
@@ -4550,8 +4550,8 @@
         (CURRENT_TOP_LINE_HEIGHT): New.
         (DESIRED_TOP_LINE_HEIGHT): New.
         (WINDOW_DISPLAY_TOP_LINE_HEIGHT): New.
-        (WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE): Replaces
-        WINDOW_DISPLAY_TEXT_AREA_PIXEL_HEIGHT.
+        (WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE):
+        Replaces WINDOW_DISPLAY_TEXT_AREA_PIXEL_HEIGHT.
         (WINDOW_DISPLAY_TEXT_HEIGHT): New.
 
         * xterm.c (x_after_update_window_line): Don't draw bitmaps for top
@@ -4562,8 +4562,8 @@
         x_frame_mode_line_height.
         (x_get_glyph_string_clip_rect): Take top line into account.
         (x_clear_end_of_line): Ditto.
-        (note_mode_line_highlight): Add parameter mode_line_p.  Handle
-        top lines.
+        (note_mode_line_highlight): Add parameter mode_line_p.
+        Handle top lines.
         (note_mouse_highlight): Call note_mode_line_highlight for top lines.
         (x_erase_phys_cursor): Take top line into account.
 
@@ -4578,12 +4578,12 @@
 
         * xterm.c (x_frame_mode_line_height): Add parameter face_id.
 
-        * term.c (estimate_mode_line_height): Renamed from
+        * term.c (estimate_mode_line_height): Rename from
         frame_mode_line_height.  Add parameter face_id.
-        (estimate_mode_line_height_hook): Renamed from
+        (estimate_mode_line_height_hook): Rename from
         frame_mode_line_height_hook.
-        (produce_special_glyphs_hook): Removed.
-        (produce_glyphs_hook): Removed.
+        (produce_special_glyphs_hook): Remove.
+        (produce_glyphs_hook): Remove.
 
 1999-06-23  Gerd Moellmann  <gerd@gnu.org>
 
@@ -4604,7 +4604,7 @@
 
         * buffer.h: Add top_line_format.
 
-        * xdisp.c (overlay_arrow_changed_p): Removed because not used.
+        * xdisp.c (overlay_arrow_changed_p): Remove because not used.
 
 1999-06-17  Dave Love  <fx@gnu.org>
 
@@ -4629,8 +4629,8 @@
 
         * Makefile.in (LIBGIF): Use libungif.
 
-        * xdisp.c (compute_window_start_on_continuation_line): Don't
-        do it if line start is too far away from window start.
+        * xdisp.c (compute_window_start_on_continuation_line):
+        Don't do it if line start is too far away from window start.
 
 1999-06-14  Gerd Moellmann  <gerd@gnu.org>
 
@@ -4714,8 +4714,8 @@
         * xfaces.c (SCALABLE_FONTS): Define this to enable scalable
         font support.
         (Vscalable_fonts_allowed) [SCALABLE_FONTS]: New.
-        (x_face_list_fonts): Add parameter scalable_fonts_p.  Handle
-        scalable fonts depending on the setting of SCALABLE_FONTS.
+        (x_face_list_fonts): Add parameter scalable_fonts_p.
+        Handle scalable fonts depending on the setting of SCALABLE_FONTS.
         (first_font_matching): List more than one font to find the
         first non-scalable matching font.
         (sorted_font_list): Let x_face_list_fonts return scalable fonts
@@ -4730,8 +4730,8 @@
 
 1999-05-26  Gerd Moellmann  <gerd@gnu.org>
 
-        * xfns.c (png_load): Let PNG lib handle gamma.  Construct
-        mask only if image contains simple transparency information.
+        * xfns.c (png_load): Let PNG lib handle gamma.
+        Construct mask only if image contains simple transparency information.
         Otherwise, combine image with frame background color.
 
         * configure.in (--with-png, HAVE_PNG): New.
@@ -4829,7 +4829,7 @@
 
 1999-03-29  Gerd Moellmann  <gerd@gnu.org>
 
-        * xfaces.c (Qraised, Qsunken, QCshadow): Removed.
+        * xfaces.c (Qraised, Qsunken, QCshadow): Remove.
         (QCline_width, QCstyle, Qpressed_button, Qreleased_button): New.
         Use these symbols for the box face attribute instead of the
         removed ones.
@@ -4852,7 +4852,7 @@
         * xfaces.c (x_face_list_fonts): New parameter try_alternatives_p.
         (first_font_matching): New.
         (set_lface_from_font_name): Use it if font name is a pattern.
-        (font_field_wildcard_p): Removed.
+        (font_field_wildcard_p): Remove.
 
         * dispnew.c (shift_glyph_matrix): Add `window' parameter.
         Recompute visible height of rows.
@@ -4881,12 +4881,12 @@
         (update_window_line): Call after_update_window_line_hook
         if visible row height has changed.
 
-        * dispextern.h (MATRIX_ROW_VISIBLE_HEIGHT): Removed.
+        * dispextern.h (MATRIX_ROW_VISIBLE_HEIGHT): Remove.
         (struct glyph_row): New member visible_height.
 
         * xfaces.c (font_field_wildcard_p): New.
-        (set_lface_from_font_name): Remove parameter force_p.  Accept
-        font names containing wildcards.
+        (set_lface_from_font_name): Remove parameter force_p.
+        Accept font names containing wildcards.
 
 1999-03-04  Gerd Moellmann  <gerd@gnu.org>
 
@@ -4906,7 +4906,7 @@
         * dispextern.h (struct face): Add use_box_color_for_shadows_p.
 
         * xterm.c (x_draw_box_rect): New.
-        (x_draw_glyph_string_box): Renamed from
+        (x_draw_glyph_string_box): Rename from
         x_draw_glyph_string_relief.  Call x_draw_box_rect.
 
         * xfns.c (QCrelief): New.
@@ -4914,20 +4914,20 @@
 
         * dispextern.h (struct glyph): Rename left_shadow_p to
         left_box_line_p, right_shadow_p to right_box_line_p.
-        (MAX_RELIEF_THICKNESS): Removed.
+        (MAX_RELIEF_THICKNESS): Remove.
         (struct it): Rename members having `relief' in their names
         to contain `box' instead.
 
         * xfaces.c (realize_x_face): Handle new box attribute values.
-        (QCrelief, Qbox): Removed.
+        (QCrelief, Qbox): Remove.
         (QCshadow, QCcolor, Qraised, Qsunken): New.
         (syms_of_xfaces): Initialize new symbols.
 
 1999-03-02  Gerd Moellmann  <gerd@gnu.org>
 
-        * dispextern.h (LFACE_RELIEF_INDEX): Removed.
+        * dispextern.h (LFACE_RELIEF_INDEX): Remove.
 
-        * xfaces.c (LFACE_RELIEF): Removed.
+        * xfaces.c (LFACE_RELIEF): Remove.
         (merge_face_vector_with_property): Remove handling of `:relief'.
         (Finternal_set_lisp_face_attribute): Ditto.
         (Finternal_set_lisp_face_attribute_from_resource): Ditto.
@@ -4946,7 +4946,7 @@
 
         * xterm.c (x_draw_glyph_string): Draw underline, overline,
         strike-through, and boxes.
-        (x_draw_glyph_string_underline): Removed.
+        (x_draw_glyph_string_underline): Remove.
 
         * xfaces.c (QCoverline, QCstrike_through, QCbox): New.
         (Qoverline, Qstrike_through, Qbox): New.
@@ -5019,7 +5019,7 @@
 1999-01-03  Masatake Yamato  <masata-y@is.aist-nara.ac.jp>
 
         * dispextern.h (UNDERLINE_COLOR): Defined.
-        (struct face): Added two new members.
+        (struct face): Add two new members.
         underline_color, underline_defaulted_p.
 
         * xfaces.c (merge_face_vector_with_property):
@@ -5032,7 +5032,7 @@
 
 1999-02-12  Gerd Moellmann  <gerd@gnu.org>
 
-        * xfns.c (Fx_image_header): Removed.
+        * xfns.c (Fx_image_header): Remove.
 
 1999-02-07  Gerd Moellmann  <gerd@gnu.org>
 
@@ -5073,16 +5073,16 @@
 
         * xdisp.c (handle_single_display_prop): New.
         (handle_display_prop): Call it.
-        (handle_raise_prop): Removed.
-        (handle_height_prop): Removed.
-        (handle_space_width_prop): Removed.
+        (handle_raise_prop): Remove.
+        (handle_height_prop): Remove.
+        (handle_space_width_prop): Remove.
         (handle_face_prop): Remove handling of raised text.
         (handle_display_prop): Do it here.
 
         * dispextern.h (DISPLAY_PROP_IDX): Replaces GLYPH_PROP_IDX.
-        (RAISE_PROP_IDX): Removed.
-        (HEIGHT_PROP_IDX): Removed.
-        (SPACE_WIDTH_PROP_IDX): Removed.
+        (RAISE_PROP_IDX): Remove.
+        (HEIGHT_PROP_IDX): Remove.
+        (SPACE_WIDTH_PROP_IDX): Remove.
 
         * xdisp.c (Qdisplay): Replaces Qglyph.
         (handle_display_prop): Formerly handle_glyph_prop.
@@ -5090,8 +5090,8 @@
 1999-01-11  Gerd Moellmann  <gerd@gnu.org>
 
         * xdisp.c (reseat_to_string): Set position in display vector to -1.
-        (handle_stop): Set position in display vector to -1.  Don't
-        check overlay strings when set up to deliver characters from a
+        (handle_stop): Set position in display vector to -1.
+        Don't check overlay strings when set up to deliver characters from a
         display vector.
         (set_iterator_to_next): At the end of a run of characters from a
         display vector, check whether the display vector display replaces
@@ -5124,7 +5124,7 @@
         * buffer.h (struct buffer): indicate_empty_lines renamed from
         indicate_zv_lines.
 
-        * buffer.c (indicate-empty-lines): Renamed from indicate_zv_lines.
+        * buffer.c (indicate-empty-lines): Rename from indicate_zv_lines.
         (default-indicate-zv-lines): Likewise.
 
         * dispextern.h (struct glyph_row): Rename indicate_zv_line_p
@@ -5139,7 +5139,7 @@
         and `N-'.
 
         * xfns.c (xbm_scan): New.
-        (xbm_read_hexint): Removed.
+        (xbm_read_hexint): Remove.
         (xbm_read_bitmap_file_data): Use xbm_scan.
 
         * fileio.c (Finsert_file_contents): Prevent redisplay optimizations.
@@ -5155,8 +5155,8 @@
 
         * xfaces.c (face_with_height): New.
 
-        * xdisp.c (eval_handler): Renamed from eval_mode_handler.
-        (eval_form): Renamed from eval_mode_element.
+        * xdisp.c (eval_handler): Rename from eval_mode_handler.
+        (eval_form): Rename from eval_mode_element.
         (handle_face_prop): Use it.
         (Qheight): Replaces Qsmaller.
         (handle_height_prop): Replaces handle_smaller_prop.
@@ -5183,7 +5183,7 @@
 
 1998-11-28  Gerd Moellmann  <gerd@gnu.org>
 
-        * config.in (PROTO): Removed.
+        * config.in (PROTO): Remove.
 
         * xterm.h: Change PROTO to P_.
 
@@ -5225,7 +5225,7 @@
 
         * xterm.c (x_scroll_bar_move): Clear to the left and right
         of toolkit scroll bars differently.
-        (x_scroll_bar_move): Removed.
+        (x_scroll_bar_move): Remove.
         (XTset_vertical_scroll_bar): Move code from x_scroll_bar_move here.
 
         * dispextern.h: Make it compilable --with-x=no.
@@ -5256,8 +5256,8 @@
 
 1998-11-23  Gerd Moellmann  <gerd@gnu.org>
 
-        * xdisp.c (restore_overlay_strings): Removed.
-        (restore_dpvec): Removed.
+        * xdisp.c (restore_overlay_strings): Remove.
+        (restore_dpvec): Remove.
         (init_from_display_pos): Inline both functions above.
 
         * xfns.c (IMAGE_NON_NEGATIVE_INTEGER_VALUE): New.
@@ -5270,7 +5270,7 @@
         (gif_format): Ditto.
         (gs_format): Ditto.
 
-        * xdisp.c (set_window_cursor): Removed.
+        * xdisp.c (set_window_cursor): Remove.
         (redisplay_internal): Case cursor motion in cursor line of
         selected window; use set_cursor_from_row.
 
@@ -5641,7 +5641,7 @@
 
         * xdisp.c (redisplay_window): Always resize toolbar window if
         auto_resize_toolbar_p is non-zero.
-        (auto_resize_toolbar_p): Renamed from auto_resize_toolbar.
+        (auto_resize_toolbar_p): Rename from auto_resize_toolbar.
         (window_box): New.
         (window_box_height): New.
         (window_box_width): New.
@@ -5735,12 +5735,12 @@
         * xfns.c (x_laplace): New.
         (x_laplace_read_row): New.
         (x_laplace_write_row): New.
-        (lookup_image): Handle common image attributes here.  New
-        attribute `:algorithm'.
+        (lookup_image): Handle common image attributes here.
+        New attribute `:algorithm'.
 
         * xfaces.c (clear_face_cache): Call clear_image_cache.
 
-        * xterm.c (x_inverted_image_mask): Removed.
+        * xterm.c (x_inverted_image_mask): Remove.
         (x_draw_image_foreground_1): New.
         (x_draw_image_glyph_string): Draw images with mask to a temporary
         pixmap to reduce flickering.
@@ -5755,7 +5755,7 @@
 
         * xfns.c (cache_image): Correct call to xrealloc.
 
-        * dispnew.c (Fset_toolbar_height): Removed.
+        * dispnew.c (Fset_toolbar_height): Remove.
 
         * xdisp.c (init_xdisp): Use FRAME_TOP_MARGIN instead of
         FRAME_MENU_BAR_LINES.
@@ -5838,8 +5838,8 @@
         (clear_image_cache): Additional parameter force_p.
         (Fclear_image_cache): New.
         (x_find_image_file): New.
-        (xbm_load): Handle `:margin' and `:relief'.  Use
-        x_find_image_file.
+        (xbm_load): Handle `:margin' and `:relief'.
+        Use x_find_image_file.
         (xpm_load): Likewise.
         (pbm_load): Likewise.
         (jpeg_load): Likewise.
@@ -5939,8 +5939,8 @@
         * frame.h (struct frame): Add toolbar-related members
         toolbar_window, desired_toolbar_items, current_toolbar_items,
         desired_toolbar_string, current_toolbar_string,
-        n_desired_toolbar_items, n_current_toolbar_items.  Add
-        window_height.
+        n_desired_toolbar_items, n_current_toolbar_items.
+        Add window_height.
 
         * xterm.c (x_after_update_window_line): Don't draw bitmap
         areas for pseudo-windows.
@@ -6024,17 +6024,17 @@
 
 1998-09-06  Gerd Moellmann  <gerd@gnu.org>
 
-        * lisp.h (HAVE_FACES): Removed.
+        * lisp.h (HAVE_FACES): Remove.
 
-        * dispextern.h (HAVE_FACES): Removed.
+        * dispextern.h (HAVE_FACES): Remove.
 
-        * config.in (HAVE_FACES): Removed.
+        * config.in (HAVE_FACES): Remove.
 
-        * dispnew.c (HAVE_FACES): Removed.
+        * dispnew.c (HAVE_FACES): Remove.
 
-        * xdisp.c (HAVE_FACES): Removed.
+        * xdisp.c (HAVE_FACES): Remove.
 
-        * xfaces.c (HAVE_FACES): Removed.
+        * xfaces.c (HAVE_FACES): Remove.
 
 1998-09-05  Gerd Moellmann  <gerd@gnu.org>
 
@@ -6042,8 +6042,8 @@
         free realized faces.
 
         * xfaces.c (free_all_realized_faces): Make it externally visible.
-        (Finternal_set_lisp_face_attribute): Increment
-        windows_or_buffers_changed.
+        (Finternal_set_lisp_face_attribute):
+        Increment windows_or_buffers_changed.
 
         * dispnew.c (direct_output_for_insert): Give up if
         face_change_count is non-zero.
@@ -6076,9 +6076,9 @@
 
         * term.c (OUTPUT_IF): Make replacement text have statement form.
         (OUTPUT1_IF): Ditto.
-        (TS_italic_mode, TS_end_italic_mode): Removed.
-        (TS_bold_mode): Removed.
-        (TS_underscore_mode, TS_end_underscore_mode): Removed.
+        (TS_italic_mode, TS_end_italic_mode): Remove.
+        (TS_bold_mode): Remove.
+        (TS_underscore_mode, TS_end_underscore_mode): Remove.
         (TS_enter_bold_mode, TS_enter_dim_mode, TS_enter_blink_mode): New.
         (TS_enter_reverse_mode): New.
         (TS_enter_underline_mode, TS_exit_underline_mode): New.
@@ -6187,8 +6187,8 @@
 
         * frame.h (FRAME_WINDOW_WIDTH_ARG): Add bitmap area widths.
 
-        * dispnew.c (allocate_matrices_for_window_redisplay): Compute
-        total pixel width of window differently.
+        * dispnew.c (allocate_matrices_for_window_redisplay):
+        Compute total pixel width of window differently.
 
         * xdisp.c (init_iterator): Compute width of mode line differently.
 
@@ -6209,7 +6209,7 @@
         (update_window_tree): Parameter no_scrolling_p removed.
         (update_single_window): Ditto.
 
-        * xterm.c (x_get_char_font_and_encoding): Renamed to
+        * xterm.c (x_get_char_font_and_encoding): Rename to
         x_get_char_face_and_encoding.
 
         * dispnew.c (update_text_area): Don't call get_glyph_overhangs
@@ -6254,8 +6254,8 @@
 
         * xterm.c (note_mouse_highlight): Set BEGV_BYTE, ZV_BYTE.
 
-        * xfaces.c (Vx_unibyte_registry_and_encoding): Removed.  Use
-        face_default_registry instead.
+        * xfaces.c (Vx_unibyte_registry_and_encoding): Remove.
+        Use face_default_registry instead.
 
         * syntax.c (scan_sexps_forward): Set up syntax table before
         jumping to initial state label.
@@ -6372,13 +6372,13 @@
         (struct iterator_stack_entry): Add multibyte_p.
 
         * xdisp.c (string_pos): Use string_char_to_byte.
-        (char_charset): Removed.
+        (char_charset): Remove.
 
 1998-08-03  Gerd Moellmann  <gerd@gnu.org>
 
         * xterm.c (x_draw_image_glyph_string_foreground): Draw a
         rectangle for a block cursor over an image without a mask.
-        (x_stretch_block_cursor): Added.  Non-zero means don't draw
+        (x_stretch_block_cursor): Add.  Non-zero means don't draw
         a block cursor over a stretch as wide as that stretch.
         (x_draw_stretch_glyph_string): Use it.
         (x_draw_hollow_cursor): Ditto.
@@ -6389,7 +6389,7 @@
         * xdisp.c (char_charset): Return charset of a character,
         depending on whether or not multi-byte characters are enabled.
 
-        * xfaces.c (Fset_face_charset_registry): Removed.
+        * xfaces.c (Fset_face_charset_registry): Remove.
         (x_charset_registry): Determine registry from charset plist.
 
 1998-08-02  Gerd Moellmann  <gerd@gnu.org>
@@ -6401,7 +6401,7 @@
         redisplay interface.
         * keyboard.c (detect_input_pending_run_timers): Likewise.
 
-        * dispextern.h (produce_*glyphs_hook): Removed.
+        * dispextern.h (produce_*glyphs_hook): Remove.
         * term.c (produce_*glyphs): Ditto.
         (cursor_to): Remove pixel position parameters.
 
@@ -6457,7 +6457,7 @@
         * xterm.c (x_flush): Flush X output buffer.
         (XTflash): Use it.
 
-        * xfaces.c (lface_from_face_name): Renamed from lface_from_symbol.
+        * xfaces.c (lface_from_face_name): Rename from lface_from_symbol.
         Allow strings as face names.
 
         * xfns.c (forall_images_in_image_cache): Check that frame is
@@ -6493,7 +6493,7 @@
         (Finternal_lisp_face_attribute_values): Ditto.
         (syms_of_xfaces): Define the symbol `:reverse-video'.
 
-        * xdisp.c (get_glyph_property): Renamed from
+        * xdisp.c (get_glyph_property): Rename from
         fill_iterator_from_glyph_property.
         (next_element_from_buffer): Handle case that no `glyph' property
         was found correctly.
@@ -6501,28 +6501,28 @@
 
 1998-07-29  Gerd Moellmann  <gerd@gnu.org>
 
-        * dispnew.c (Fshow_cursor): Renamed from blink_cursor.  Take
-        additional window argument.
+        * dispnew.c (Fshow_cursor): Rename from blink_cursor.
+        Take additional window argument.
 
-        * xdisp.c (reseat_at_previous_visible_line_start): Renamed from
+        * xdisp.c (reseat_at_previous_visible_line_start): Rename from
         set_iterator_to_previous_visible_line_start.
         (reseat_at_next_visible_line_start): Likewise.
-        (compute_stop_pos): Renamed from set_iterator_stop_pos.
-        (face_before_or_after_it_pos): Renamed from get_face_at_it_pos.
-        (compute_face_in_buffer): Renamed from
+        (compute_stop_pos): Rename from set_iterator_stop_pos.
+        (face_before_or_after_it_pos): Rename from get_face_at_it_pos.
+        (compute_face_in_buffer): Rename from
         compute_face_at_iterator_position.
-        (compute_face_in_string): Renamed from
+        (compute_face_in_string): Rename from
         compute_face_at_iterator_string_position.
-        (get_space_width): Renamed from get_iterator_space_width.
-        (next_overlay_string): Renamed from
+        (get_space_width): Rename from get_iterator_space_width.
+        (next_overlay_string): Rename from
         set_iterator_to_next_overlay_string.
-        (get_overlay_strings): Renamed from
+        (get_overlay_strings): Rename from
         get_overlay_strings_at_iterator_position.
-        (restore_overlay_strings): Renamed from
+        (restore_overlay_strings): Rename from
         setup_overlay_strings_from_glyph_pos.
-        (restore_dpvec): Renamed from setup_iterator_dpvec_from_glyph_pos.
-        (init_from_display_pos): Renamed from init_iterator_from_glyph_pos.
-        (init_to_row_start): Renamed from init_iterator_to_row_start.
+        (restore_dpvec): Rename from setup_iterator_dpvec_from_glyph_pos.
+        (init_from_display_pos): Rename from init_iterator_from_glyph_pos.
+        (init_to_row_start): Rename from init_iterator_to_row_start.
         (init_to_row_end): Formerly init_iterator_to_next_row_start.
 
         * xterm.c: Merge with 20.2.97.
@@ -6532,26 +6532,26 @@
         simple charpos.
 
         * xdisp.c (this_line_start_pos): Use struct text_pos.
-        (this_line_end_pos): Renamed from .*endpos; use struct text_pos.
-        (enum move_it_result): Renamed from move_iterator_result.
+        (this_line_end_pos): Rename from .*endpos; use struct text_pos.
+        (enum move_it_result): Rename from move_iterator_result.
         (string_pos_nchars_ahead): Compute text_pos in a string from a
         known text_pos plus a character delta.
         (string_pos): Compute text_pos in string from charpos.
         (c_string_pos): Likewise for a C string.
         (number_of_chars): Return number of characters in a possibly
         multi-byte C string.
-        (check_it): Renamed from check_iterator.  Check that charpos and
+        (check_it): Rename from check_iterator.  Check that charpos and
         bytepos are in sync.
-        (push_it): Renamed from save_iterator_settings.
-        (pop_it): Renamed from restore_iterator_settings.
-        (move_it_.*): Renamed from move_iterator_.*.
+        (push_it): Rename from save_iterator_settings.
+        (pop_it): Rename from restore_iterator_settings.
+        (move_it_.*): Rename from move_iterator_.*.
         (charset_at_position): Take charpos/bytepos into account.
         (back_to_previous_line_start): Set iterator to previous line start.
         (forward_to_next_line_start): Set iterator to next line start.
-        (back_to_previous_visible_line_start): Renamed from
+        (back_to_previous_visible_line_start): Rename from
         move_iterator_previous_visible_line_start.
         (set_iterator_to_next_visible_line_start): Handle charpos/bytepos.
-        (get_face_at_it_pos): Renamed from get_face_from_cursor_pos.
+        (get_face_at_it_pos): Rename from get_face_from_cursor_pos.
         Handle charpos/bytepos.
         (compute_face_at_iterator_position): Handle charpos/bytepos.
         (compute_face_at_iterator_string_position): Likewise.
@@ -6593,7 +6593,7 @@
         (copy_glyph_row_contents): Ditto.
         (check_matrix_invariants): Add additional checks for charpos/
         bytepos consistency.
-        (direct_output_for_insert): Changed for charpos/bytepos.
+        (direct_output_for_insert): Change for charpos/bytepos.
         (buffer_posn_from_coords): Likewise.  Put code dealing with
         `direction-reversed' in #if 0.
 
@@ -6630,10 +6630,10 @@
         (SET_TEXT_POS_FROM_MARKER): Set a text_pos from a marker.
         (SET_MARKER_FROM_TEXT_POS): Set a marker from a text_pos.
         (TEXT_POS_EQUAL_P): Compare two text_pos structures for equality.
-        (struct display_pos): Renamed from glyph_pos.  Use struct text_pos
+        (struct display_pos): Rename from glyph_pos.  Use struct text_pos
         for buffer and string positions.
         (struct glyph): Use text_pos.
-        (struct it): Renamed from display_iterator.  Use text_pos.
+        (struct it): Rename from display_iterator.  Use text_pos.
 
 1998-07-23  Gerd Moellmann  <gerd@gnu.org>
 
@@ -6650,7 +6650,7 @@
         * xfns.c (prepare_image_for_display): Don't set loading_failed_p
         flag of images.
 
-        * dispextern.h (struct image): Removed member loading_failed_p.
+        * dispextern.h (struct image): Remove member loading_failed_p.
         It's probably better to have the chance to try to load an image
         again.
 
@@ -6703,28 +6703,28 @@
         * xfns.c (tiff_image_p, tiff_load): Support TIFF images via
         libtiff34.
 
-        * configure.in (--with-tiff, HAVE_TIFF): Added.
+        * configure.in (--with-tiff, HAVE_TIFF): Add.
 
-        * config.in (HAVE_TIFF): Added.
+        * config.in (HAVE_TIFF): Add.
 
-        * Makefile.in (LIBTIFF): Added.
+        * Makefile.in (LIBTIFF): Add.
 
         * xfns.c (jpeg_image_p, jpeg_load): Support JPEG images.
 
-        * Makefile.in (LIBJPEG): Added.
+        * Makefile.in (LIBJPEG): Add.
 
         * xfns.c (resource_types): Enumerators renamed to RES_TYPE_NUMBER,
         RES_TYPE_BOOLEAN etc. because of conflict of `boolean' with
         jpeglib.h.
 
-        * configure.in (HAVE_JPEG, --with-jpeg): Added.  On systems
+        * configure.in (HAVE_JPEG, --with-jpeg): Add.  On systems
         where the library is installed in /usr/local/lib, e.g. FreeBSD,
         configure must be run with `--x-includes=/usr/X11R6/include:
         /usr/local/include --x-libraries=/usr/X11R6/lib:/usr/local/lib'.
 
 1998-07-18  Gerd Moellmann  <gerd@gnu.org>
 
-        * config.in (HAVE_JPEG): Added.
+        * config.in (HAVE_JPEG): Add.
 
         * xfns.c (ct_init): Initialize color table used to map RGB colors
         from images to X pixel colors.
@@ -6837,20 +6837,20 @@
         (redisplay_window): Case cursor movement.  Don't try it if
         last_cursor.vpos is out of range.
 
-        * xdisp.c (set_cursor_from_row): Set this_line_.* variables.  This
-        way, the display optimization for the line containing the cursor
+        * xdisp.c (set_cursor_from_row): Set this_line_.* variables.
+        This way, the display optimization for the line containing the cursor
         is used more frequently, esp. when we have a blinking cursor.
         (display_line): Don't set this_line_.* variables.
 
-        * xterm.c (x_redraw_cursor): Removed.
+        * xterm.c (x_redraw_cursor): Remove.
         (x_display_and_set_cursor): Set cursor type depending on
         cursor_off_p flag of window.
 
-        * dispnew.c (redraw_cursor_hook): Removed.
+        * dispnew.c (redraw_cursor_hook): Remove.
         (Fblink_cursor): Additional parameter on_p to set the cursor_off_p
         member of the selected window.
 
-        * xfaces.c (Fface_font): Added for compatibility with 20.2.
+        * xfaces.c (Fface_font): Add for compatibility with 20.2.
 
         * xterm.c (x_y_to_hpos_vpos): Return null if not over text.
         Return glyph area under x/y.
@@ -6880,8 +6880,8 @@
 
 1998-06-29  Gerd Moellmann  <gerd@gnu.org>
 
-        * xfaces.c (Finternal_make_lisp_face): Increment
-        lface_id_to_name_size when lface_id_to_name is reallocated.
+        * xfaces.c (Finternal_make_lisp_face):
+        Increment lface_id_to_name_size when lface_id_to_name is reallocated.
 
 1998-06-27  Gerd Moellmann  <gerd@gnu.org>
 
@@ -6892,12 +6892,12 @@
 
 1998-05-09  Gerd Moellmann  <gerd@gnu.org>
 
-        * xdisp.c (set_iterator_to_next_visible_line_start): Don't
-        do anything if iterator is at ZV because scan_buffer doesn't
+        * xdisp.c (set_iterator_to_next_visible_line_start):
+        Don't do anything if iterator is at ZV because scan_buffer doesn't
         work otherwise.
 
         * xterm.c (x_encode_char): Inline it.
-        (x_get_char_font_and_encoding): Simplified.
+        (x_get_char_font_and_encoding): Simplify.
         (x_per_char_metric): Inline it.
 
         * xterm.c (x_draw_glyph_string_relief): Use clipping.
@@ -6926,15 +6926,15 @@
         * xdisp.c (display_line): Compute row height from glyphs in
         marginal areas.
 
-        * xterm.c (x_draw_image_glyph_string_background): Draw
-        background of an image glyph string.
+        * xterm.c (x_draw_image_glyph_string_background):
+        Draw background of an image glyph string.
         (x_draw_glyph_string_bg_rect): Draw a rectangular region of
         the background of a glyph string.
         (x_draw_image_glyph_string_foreground): Draw the foreground of
         an image glyph string.
         (x_inverted_image_mask): Return the inverted mask of an image.
 
-        * xfns.c (x_draw_image): Removed.
+        * xfns.c (x_draw_image): Remove.
 
         * dispextern.h (struct image_type): Remove drawing function.
 
@@ -6966,8 +6966,8 @@
         image drawing function.
 
         * xdisp.c (fill_iterator_from_glyph_property): Use position of
-        first character with `glyph' property as image position.  Set
-        iterator back to that position as long as the image hasn't been
+        first character with `glyph' property as image position.
+        Set iterator back to that position as long as the image hasn't been
         consumed with set_iterator_to_next.
         (set_cursor_from_row): Accept when glyph with given position is
         not found in the row.  Set cursor x to end of line in that case,
@@ -6993,7 +6993,7 @@
 
         * dispextern.h (struct glyph_row): Use unsigned hash value.
 
-        * xdisp.c (display_line): Simplified and made faster by setting
+        * xdisp.c (display_line): Simplify and made faster by setting
         the cursor with set_cursor_from_row.
         (set_cursor_from_row): Handle rows of desired matrix.
 
@@ -7001,8 +7001,8 @@
 
         * xdisp.c (set_cursor_from_row): Don't put cursor on glyphs
         with type != CHAR_GLYPH.
-        (fill_iterator_from_glyph_property): Return void.  Set
-        method to next_element_from_image.
+        (fill_iterator_from_glyph_property): Return void.
+        Set method to next_element_from_image.
         (next_element_from_image): Dummy function for delivering a
         single image id.
         (set_iterator_to_next): Add method next_element_from_image.
@@ -7037,7 +7037,7 @@
 
         * xterm.c (x_produce_glyphs): Use ASCII face for spaces of a TAB.
 
-        * xdisp.c (fill_iterator_from_glyph_property): Renamed from
+        * xdisp.c (fill_iterator_from_glyph_property): Rename from
         setup_iterator_from_glyph_property.  Don't do it for terminal
         frames.
 
@@ -7073,12 +7073,12 @@
 
         * config.in: Add HAVE_XPM.
 
-        * xfns.c (xbm_draw): Removed.
+        * xfns.c (xbm_draw): Remove.
         (x_draw_image): Default implementation for drawing images.
         (xbm_keyword_index): Remove XBM_DEPTH.
         (xbm_format): Remove `:depth'.
-        (xbm_image_spec_from_file): Removed to reduce consing.
-        (xbm_load_image_from_file): Added for the same reason.
+        (xbm_image_spec_from_file): Remove to reduce consing.
+        (xbm_load_image_from_file): Add for the same reason.
 
         * xterm.c (x_fill_image_glyph_string): Don't set ybase of
         glyph string.
@@ -7148,8 +7148,8 @@
 
         * widget.c (widget_store_internal_border): Return void.
 
-        * xfns.c (x_destroy_bitmap): Use xfree instead of free.  Return
-        void.
+        * xfns.c (x_destroy_bitmap): Use xfree instead of free.
+        Return void.
         (init_x_parm_symbols): Return void.
         (x_report_frame_params): Ditto.
         (x_set_border_pixel): Ditto.
@@ -7220,7 +7220,7 @@
         * dispnew.c (adjust_frame_glyphs_for_window_redisplay): Use these
         macros.
 
-        * xterm.c (x_font_min_bounds): Moved here from xfaces.c.
+        * xterm.c (x_font_min_bounds): Move here from xfaces.c.
         (x_compute_min_char_bounds): Formerly min_char_bounds in xfaces.c.
         (x_load_font): Use x_compute_min_char_bounds.
 
@@ -7238,7 +7238,7 @@
         for characters < 0177 in default face.  Prepare face for
         display before returning it.
         (x_produce_glyphs): Use it->charset.
-        (x_get_char_font_and_encoding): Simplified.
+        (x_get_char_font_and_encoding): Simplify.
         (x_encode_char): Remove parameter `font'.
 
         * xfaces.c (choose_face_font): If registry from charset symbol
@@ -7309,8 +7309,8 @@
         * dispextern.h (FACE_FOR_CHARSET): Replacement for function
         lookup_face_for_charset.
 
-        * xfaces.c (free_font_names): Renamed from free_split_font_names.
-        (free_all_realized_faces): Renamed from remove_all_realized_faces.
+        * xfaces.c (free_font_names): Rename from free_split_font_names.
+        (free_all_realized_faces): Rename from remove_all_realized_faces.
 
 1998-04-25  Gerd Moellmann  <gerd@gnu.org>
 
@@ -7329,8 +7329,8 @@
 
 1998-04-24  Gerd Moellmann  <gerd@gnu.org>
 
-        * dispextern.h (struct face): Member
-        fontset_chosen_for_realization_p removed.
+        * dispextern.h (struct face):
+        Member fontset_chosen_for_realization_p removed.
 
         * xfaces.c (cache_face): If face->fontset >= 0, add face to the
         end of the collision list, so that we find more specific faces
@@ -7365,8 +7365,8 @@
         (xlfd_point_size): Return -1 if resolution or point size of
         font unknown.
 
-        * xfaces.c (free_font): Removed.
-        (load_face_font_or_fontset): Renamed from load_font.
+        * xfaces.c (free_font): Remove.
+        (load_face_font_or_fontset): Rename from load_font.
         (load_face_font_or_fontset): Use message2 instead of signaling.
         (load_color): Likewise.
         (load_pixmap): Likewise.
@@ -7408,8 +7408,8 @@
         to -1 so that it will compute the right face for the truncation
         glyphs.
 
-        * xfaces.c (realize_face): Set
-        face->fontset_chosen_for_realization_p.
+        * xfaces.c (realize_face):
+        Set face->fontset_chosen_for_realization_p.
         (lookup_face_for_charset): If fontset wasn't specified originally
         and new charset != CHARSET_COMPOSITION, get a new face for that
         charset.
@@ -7461,9 +7461,9 @@
         (lface_hash): Add weight, slant, swidth and relief to hash value.
         (lface_equal_p): Make it faster.
         (lface_from_symbol): Use assq_no_quit.
-        (Fnote_default_face_changed): Removed.
+        (Fnote_default_face_changed): Remove.
         (cmp_font_names): Use strcmp instead of xstricmp.
-        (face_charset_registries): Removed.
+        (face_charset_registries): Remove.
 
 1998-04-20  Gerd Moellmann  <gerd@gnu.org>
 
@@ -7487,8 +7487,8 @@
 
         * xfaces.c (Finternal_set_lisp_face_attribute): Add :bold
         and :italic for compatibility.
-        (Finternal_set_lisp_face_attribute_from_resource): Handle
-        :bold and :italic.  Handle boolean resource values for
+        (Finternal_set_lisp_face_attribute_from_resource):
+        Handle :bold and :italic.  Handle boolean resource values for
         :underline and :italic.
 
         * xfns.c (display_x_get_resource): Make it externally visible.
@@ -7500,7 +7500,7 @@
         definitions.
         (Finternal_lisp_face_equal_p): Additional frame argument.
         (merge_lisp_face_vector_with_property): Ditto.
-        (Frealize_basic_faces): Removed.
+        (Frealize_basic_faces): Remove.
         (Finternal_get_lisp_face_attribute): Additional frame argument.
         (Finternal_lisp_face_p): Ditto.
         (load_color) [MSDOS]: Removed because it isn't clear how
@@ -7531,8 +7531,8 @@
         * xdisp.c (redisplay_internal, echo_area-display): If realized
         faces have been cleared, call recompute_basic_faces.
 
-        * xfaces.c (recompute_basic_faces): Free realized faces.  Reset
-        face_attributes_changed_p.
+        * xfaces.c (recompute_basic_faces): Free realized faces.
+        Reset face_attributes_changed_p.
         (remove_all_realized_faces): Remove all realized faces on
         all frames.
         (Finternal_set_lisp_face_attribute): Call remove_all_realized_faces.
@@ -7541,7 +7541,7 @@
         changed since the last redisplay, recompute basic faces.
         (echo_area_display): Ditto.
 
-        * xfaces.c (clear_face_gcs): Renamed from clear_realized_face_cache.
+        * xfaces.c (clear_face_gcs): Rename from clear_realized_face_cache.
 
         * xfaces.c (min_char_bounds): If face cache not yet present,
         don't try to get font dimensions from faces.
@@ -7549,11 +7549,11 @@
         * xterm.c (x_frame_mode_line_height): If face cache not present
         set, return default height.
 
-        * alloc.c (mark_face_cache): Check for null faces.  Correct
-        index bug.
+        * alloc.c (mark_face_cache): Check for null faces.
+        Correct index bug.
 
-        * dispextern.h (struct face): Renamed from struct rface.  Member
-        underline renamed underline_p.  Make it a bit-field.
+        * dispextern.h (struct face): Rename from struct rface.
+        Member underline renamed underline_p.  Make it a bit-field.
 
         * xfaces.c (init_frame_faces): Allocate face cache.
         (free_frame_faces): Free face cache.
@@ -7562,7 +7562,7 @@
 
         * frame.c (make_frame): Initialze face cache with null.
 
-        * xfaces.c (same_size_fonts): Removed.
+        * xfaces.c (same_size_fonts): Remove.
 
         * xterm.c (x_set_glyph_string_gc): Add post-condition
         s->gc != 0.
@@ -7584,56 +7584,56 @@
 
         * xfaces.c (syms_of_xfaces): Correct calls to defsubr.
 
-        * xfns.c (Fx_face_fixed_p): Removed.
-        (Fx_list_fonts): Moved to xfaces.c.
+        * xfns.c (Fx_face_fixed_p): Remove.
+        (Fx_list_fonts): Move to xfaces.c.
 
-        * xfaces.c (compute_face_at_buffer_pos): Renamed to
+        * xfaces.c (compute_face_at_buffer_pos): Rename to
         face_at_buffer_position.  Parameter charset removed; always
         compute face for CHARSET_ASCII.
-        (face_at_string_position): Renamed from
+        (face_at_string_position): Rename from
         compute_face_at_string_pos.  Parameter charset removed; always
         compute for CHARSET_ASCII.
         (lookup_face_for_charset): Take frame parameter instead of
         face_cache.
         (lookup_face): Ditto.
-        (compute_char_face): Renamed from compute_glyph_face.
+        (compute_char_face): Rename from compute_glyph_face.
 
         * xdisp.c (init_iterator): Initialize charset member.
         (reseat_iterator_to_string): Ditto.
         (get_charset_at_buffer_position): Determine charset at
         buffer position in current_buffer.
         (reseat_iterator): Call above function.
-        (compute_face_at_iterator_position): Call
-        compute_face_at_buffer_pos.
-        (compute_face_at_iterator_string_position): Call
-        compute_face_at_string_pos.
-        (get_face_from_id): Removed.
+        (compute_face_at_iterator_position):
+        Call compute_face_at_buffer_pos.
+        (compute_face_at_iterator_string_position):
+        Call compute_face_at_string_pos.
+        (get_face_from_id): Remove.
         (get_face_from_cursor_pos): Call compute_face_at_buffer_pos.
         Call get_charset_at_buffer_position.
         (reseat_iterator): Determine face if charset at pos differs
         from iterator's charset.
-        (reseat_iterator_to_glyph_pos): Removed.
+        (reseat_iterator_to_glyph_pos): Remove.
 
         * xfaces.c (compute_face_at_bufpos): Remove parameter charset.
         Determine charset from buffer position.
-        (compute_string_char_face): Renamed to compute_face_at_string_pos.
-        (compute_face_at_bufpos): Renamed to compute_face_at_buffer_pos.
+        (compute_string_char_face): Rename to compute_face_at_string_pos.
+        (compute_face_at_bufpos): Rename to compute_face_at_buffer_pos.
 
         * dispextern.h (struct display_iterator): Add member charset.
 
 1998-04-15  Gerd Moellmann  <gerd@gnu.org>
 
-        * xfaces.c (compute_char_face): Removed.
+        * xfaces.c (compute_char_face): Remove.
 
         * xdisp.c (get_overlay_arrow_glyph_row): Use compute_glyph_face
         with new parameter list.
 
-        * xfaces.c (region_face): Removed.
-        (allocate_face): Removed.
+        * xfaces.c (region_face): Remove.
+        (allocate_face): Remove.
         (copy_face): Ditto.
-        (face_eql): Removed.
-        (intern_face): Removed.
-        (clear_face_cache): Removed.
+        (face_eql): Remove.
+        (intern_face): Remove.
+        (clear_face_cache): Remove.
         (load_font): Ditto.
         (unload_font): Ditto.
         (load_color): Ditto.
@@ -7644,9 +7644,9 @@
         (merge_faces): Ditto.
         (compute_base_face): Ditto.
         (merge_face_list): Ditto.
-        (Fmake_face_internal): Removed.
+        (Fmake_face_internal): Remove.
         (Fset_face_attribute_internal): Ditto.
-        (face_name_id_number): Removed.
+        (face_name_id_number): Remove.
         (Fframe_face_alist): Ditto.
         (Fset_frame_face_alist): Ditto.
         (Finternal_next_face_id): Ditto.
@@ -7693,7 +7693,7 @@
         * fontset.h: Add external declarations for Vfontset_alias_alist
         and Vglobal_fontset_alist.
 
-        * xfaces.c (merge_lisp_face_vector_with_property): Simplified.
+        * xfaces.c (merge_lisp_face_vector_with_property): Simplify.
         (realize_default_face): If frame parameters contain an artificial
         font name naming a fontset, set the family of the default face to
         the fontset name given by the registry.
@@ -7741,11 +7741,11 @@
         * xdisp.c (set_cursor_from_row): If PT is not found in the
         row, display the cursor at the start of the row.
 
-        * dispnew.c (direct_output_forward_char): Call
-        set_cursor_from_row.
+        * dispnew.c (direct_output_forward_char):
+        Call set_cursor_from_row.
 
-        * xdisp.c (setup_iterator_overlay_strings_from_glyph_pos): If
-        position is not in an overlay string, set iterator's position and
+        * xdisp.c (setup_iterator_overlay_strings_from_glyph_pos):
+        If position is not in an overlay string, set iterator's position and
         method explicitly so.
         (set_cursor_from_row): Correct cursor position calculation.
         Make it externally visible.
@@ -7907,7 +7907,7 @@
         * dispnew.c: Make compilable with -Wall.
         * term.c: Ditto.
 
-        * charset.h (CHAR_LEN): Moved here from dispextern.h.
+        * charset.h (CHAR_LEN): Move here from dispextern.h.
 
 1998-03-14  Gerd Moellmann  <gerd@gnu.org>
 
@@ -7939,8 +7939,8 @@
         * xdisp.c (init_iterator): Increase last_visible_x by vertical
         scroll bar width for mode lines.
 
-        * dispnew.c (allocate_matrices_for_window_redisplay): Include
-        vertical scroll bar width in width calculation so that we can
+        * dispnew.c (allocate_matrices_for_window_redisplay):
+        Include vertical scroll bar width in width calculation so that we can
         display mode lines wider.
 
         * xdisp.c (redisplay_window): Restore buffers before returning
@@ -7958,7 +7958,7 @@
         * dispextern.h (struct glyph_row): Member max_ascent renamed
         ascent.  Member max_descent replaced by height.
         (struct display_iterator): Member max_descent replaced by height.
-        (MATRIX_ROW_PIXEL_HEIGHT): Removed.
+        (MATRIX_ROW_PIXEL_HEIGHT): Remove.
 
         * xterm.c (x_alloc_lighter_color): Don't free colors if visual
         class makes it unnecessary or dangerous.
@@ -7999,10 +7999,10 @@
         * xterm.c (x_scroll_run): Don't set updated_window to null.
         This resets updated_window when called from scrolling_window.
 
-        * dispextern.h (scroll_run_hook): Renamed from line_dance_hook.
+        * dispextern.h (scroll_run_hook): Rename from line_dance_hook.
 
-        * xterm.c (x_scroll_run): Additional window parameter.  Set
-        and reset updated_window.
+        * xterm.c (x_scroll_run): Additional window parameter.
+        Set and reset updated_window.
 
         * dispnew.c (line_dance_hook): Additional window parameter.
 
@@ -8016,7 +8016,7 @@
         * dispnew.c (Fblink_cursor): Remove call to detect_input_pending.
         Don't redraw cursor during redisplay.
 
-        * xterm.c (x_scroll_run): Renamed from do_line_dance.
+        * xterm.c (x_scroll_run): Rename from do_line_dance.
 
         * xdisp.c (redisplay_window): For window-based redisplay, always
         try try_window_id.
@@ -8080,8 +8080,8 @@
 
         * xdisp.c (set_next_iterator_stop_pos): No longer static.
 
-        * dispnew.c (direct_output_for_insert): Call
-        set_next_iterator_stop_pos after having changed it2.endpos.
+        * dispnew.c (direct_output_for_insert):
+        Call set_next_iterator_stop_pos after having changed it2.endpos.
 
 1998-02-17  Gerd Moellmann  <gerd@gnu.org>
 
@@ -8102,22 +8102,22 @@
         enough glyphs to display a mode line or menu line which draws over
         flags areas.
 
-        * xterm.c (XTset_vertical_scroll_bar): Use
-        WINDOW_DISPLAY_TEXT_AREA_PIXEL_HEIGHT instead of
+        * xterm.c (XTset_vertical_scroll_bar):
+        Use WINDOW_DISPLAY_TEXT_AREA_PIXEL_HEIGHT instead of
         VERTICAL_SCROLL_BAR_PIXEL_HEIGHT.
         (x_draw_glyphs): Draw over flags areas when drawing a mode line
         or menu.
         (x_set_glyph_string_clipping): Set clipping differently if drawing
         a mode line or menu line.
 
-        * xterm.h (VERTICAL_SCROLL_BAR_PIXEL_HEIGHT): Removed.
+        * xterm.h (VERTICAL_SCROLL_BAR_PIXEL_HEIGHT): Remove.
 
         * xterm.c (expose_line): Don't draw bitmaps for mode lines and
         menu lines.
         (x_scroll_bar_create): Don't clear flags areas.
         (x_draw_row_bitmaps): Clear visible row height, only.
 
-        * dispnew.c (Fblink_cursor): Moved here from xdisp.c.
+        * dispnew.c (Fblink_cursor): Move here from xdisp.c.
 
 1998-02-15  Gerd Moellmann  <gerd@gnu.org>
 
@@ -8137,21 +8137,21 @@
         * dispnew.c (update_window_line): Special handling of inverse
         lines in #if 0 removed.
 
-        * xterm.c (x_write_glyphs): Renamed from XTwrite_glyphs.
-        (x_insert_glyphs): Renamed from XTinsert_glyphs.
-        (x_clear_frame): Renamed from XTclear_frame.
-        (x_clear_end_of_line): Renamed from XTclear_end_of_line.
-        (x_ins_del_lines): Renamed from XTins_del_lines.
-        (x_change_line_height): Renamed from XTchange_line_height.
-        (x_delete_glyphs): Renamed from XTdelete_glyphs.
-        (x_clear_cursor): Renamed from clear_cursor.
-        (x_update_begin): Renamed from XTupdate_begin.
-        (x_update_end): Renamed from XTupdate_end.
-        (x_update_window_begin): Renamed from XTupdate_window_begin.
-        (x_update_window_end): Renamed from XTupdate_window_end.
-        (x_frame_mode_line_height): Renamed from XTframe_mode_line_height.
-        (x_produce_glyphs): Renamed from XTproduce_glyphs.
-        (x_produce_special_glyphs): Renamed from XTproduce_special_glyphs.
+        * xterm.c (x_write_glyphs): Rename from XTwrite_glyphs.
+        (x_insert_glyphs): Rename from XTinsert_glyphs.
+        (x_clear_frame): Rename from XTclear_frame.
+        (x_clear_end_of_line): Rename from XTclear_end_of_line.
+        (x_ins_del_lines): Rename from XTins_del_lines.
+        (x_change_line_height): Rename from XTchange_line_height.
+        (x_delete_glyphs): Rename from XTdelete_glyphs.
+        (x_clear_cursor): Rename from clear_cursor.
+        (x_update_begin): Rename from XTupdate_begin.
+        (x_update_end): Rename from XTupdate_end.
+        (x_update_window_begin): Rename from XTupdate_window_begin.
+        (x_update_window_end): Rename from XTupdate_window_end.
+        (x_frame_mode_line_height): Rename from XTframe_mode_line_height.
+        (x_produce_glyphs): Rename from XTproduce_glyphs.
+        (x_produce_special_glyphs): Rename from XTproduce_special_glyphs.
         (x_produce_special_glyphs): Implementation in #if 0 removed.
 
         * xdisp.c (Fdump_redisplay_state): Display row's fill_line_p
@@ -8232,14 +8232,14 @@
 
         * dispextern.h (struct glyph_matrix): New member window_width.
 
-        * dispnew.c (adjust_glyph_matrix): Set window_width.  Optimize
-        case of changing window height.
+        * dispnew.c (adjust_glyph_matrix): Set window_width.
+        Optimize case of changing window height.
 
         * xterm.c (x_draw_row_bitmaps): Don't clear vertical window
         border to the left.
 
-        * dispextern.h (struct glyph_row): Remove right_to_left_p.  RMS
-        says this aspect of Emacs is currently redesigned.
+        * dispextern.h (struct glyph_row): Remove right_to_left_p.
+        RMS says this aspect of Emacs is currently redesigned.
 
         * xterm.c (x_clip_to_row): Subtract 1 from clip width if we
         have to draw a vertical border.
@@ -8268,8 +8268,8 @@
         removed.
         (struct glyph): Ditto.
 
-        * xterm.c (x_draw_relief): Removed.
-        (x_draw_bitmap): Renamed from draw_bitmap.
+        * xterm.c (x_draw_relief): Remove.
+        (x_draw_bitmap): Rename from draw_bitmap.
         (x_draw_glyphs): Completely new implementation of draw_glyphs
         capable of handling arbitrary lbearing and rbearing values.
         Several sub-functions not mentioned here.
@@ -8347,11 +8347,11 @@
 
 1998-01-25  Gerd Moellmann  <gerd@gnu.org>
 
-        * dispextern.h (DEFAULT_FACE_ID, MODE_LINE_FACE_ID): Symbolic
-        names for face ids of frame default face and mode line face.
+        * dispextern.h (DEFAULT_FACE_ID, MODE_LINE_FACE_ID):
+        Symbolic names for face ids of frame default face and mode line face.
 
-        * xdisp.c (compute_face_at_iterator_string_position): If
-        displaying a mode line use MODE_LINE_FACE_ID instead of
+        * xdisp.c (compute_face_at_iterator_string_position):
+        If displaying a mode line use MODE_LINE_FACE_ID instead of
         DEFAULT_FACE_ID.
 
         * xdisp.c (reseat_iterator_to_string): Additional parameter start.
@@ -8405,8 +8405,8 @@
         (move_iterator_in_display_line_to): If to_pos specified, move
         over before-strings.
 
-        * dispextern.h (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P): Test
-        start.string_index > 0.
+        * dispextern.h (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P):
+        Test start.string_index > 0.
 
         * xdisp.c (redisplay_internal): Adjust glyphs if fonts_changed_p
         is set.  Retry redisplay if fonts_changed_p is set before update.
@@ -8415,7 +8415,7 @@
 
         * xfaces.c (Fset_face_attribute_internal): Set fonts_changed_p.
 
-        * dispnew.c (adjust_glyphs_for_font_change): Removed.
+        * dispnew.c (adjust_glyphs_for_font_change): Remove.
 
         * xdisp.c (try_window): Check fonts_changed_p.
         (try_window_reusing_current_matrix): Ditto.
@@ -8468,8 +8468,8 @@
         * editfns.c (make_buffer_string): If PROMPT_IN_BUFFER, add prompt
         length to start position.
 
-        * buffer.c (Fget_buffer_create): Initialize
-        minibuffer_prompt_length.
+        * buffer.c (Fget_buffer_create):
+        Initialize minibuffer_prompt_length.
         (Fmake_indirect_buffer): Ditto.
         (Fkill_buffer): Ditto.
 
@@ -8489,15 +8489,15 @@
         * xfaces.c (compute_string_char_face): Compute face for
         arbitrary Lisp string.  Renamed from compute_overlay_string_char_face.
 
-        * xdisp.c (next_element_from_string): Renamed from
+        * xdisp.c (next_element_from_string): Rename from
         next_element_from_overlay_string.
-        (compute_face_at_iterator_string_position): Renamed from
+        (compute_face_at_iterator_string_position): Rename from
         compute_face_at_iterator_overlay_string_position.
 
         * dispextern.h (struct display_iterator): Member overlay_string
         renamed string.
 
-        * xdisp.c (next_element_from_c_string): Renamed from
+        * xdisp.c (next_element_from_c_string): Rename from
         next_element_from_string.
 
         * dispextern.h (struct glyph_pos): Reversed meaning of
@@ -8535,8 +8535,8 @@
 
 1998-01-17  Gerd Moellmann  <gerd@gnu.org>
 
-        * xdisp.c (move_iterator_vertically): Check post-condition.  Move
-        to start of line if ending at ZV and no newline in front.
+        * xdisp.c (move_iterator_vertically): Check post-condition.
+        Move to start of line if ending at ZV and no newline in front.
         (move_iterator_to): If to_y specified, always first move to x = 0,
         so that move stops at line start instead of line end.  This is
         probably what callers would expect to happen.
@@ -8561,19 +8561,19 @@
         try_window_reusing_current_matrix if window scroll functions
         exist.
 
-        * dispextern.h (struct display_iterator): Member
-        redisplay_end_trigger_p removed.
+        * dispextern.h (struct display_iterator):
+        Member redisplay_end_trigger_p removed.
 
         * dispextern.h (WINDOW_DISPLAY_PIXEL_HEIGHT_WITHOUT_MODE_LINE):
-        Renamed to WINDOW_DISPLAY_TEXT_AREA_PIXEL_HEIGHT.
+        Rename to WINDOW_DISPLAY_TEXT_AREA_PIXEL_HEIGHT.
 
 1998-01-16  Gerd Moellmann  <gerd@gnu.org>
 
         * xdisp.c (move_iterator_by_lines): Optimize for truncate-lines
         nil.  Optimize truncate-lines t and moving backward.
         (move_iterator_to_previous_visible_line_start): Contains the heart
-        of the previous set_iterator_to_previous_visible_line_end.  Don't
-        reseat the iterator.  Used by move_iterator_by_lines.
+        of the previous set_iterator_to_previous_visible_line_end.
+        Don't reseat the iterator.  Used by move_iterator_by_lines.
         (set_iterator_to_previous_visible_line_start): Call function
         above.
         (move_iterator_in_display_line_to): Check TO_POS before doing
@@ -8608,8 +8608,8 @@
         (Fset_face_attribute_internal): Use XINT instead of XFASTINT
         to get a relief because they can be negative.
 
-        * xterm.c (x_draw_relief): Correct line drawing positions.  Pixel
-        positions are for the middle of lines under X.
+        * xterm.c (x_draw_relief): Correct line drawing positions.
+        Pixel positions are for the middle of lines under X.
 
         * xdisp.c (try_window_id): Always search for the cursor by setting
         w->cursor.vpos = -1.  Search in unchanged rows at the top and
@@ -8642,16 +8642,16 @@
 
         * xdisp.c (display_line): Bug fix cursor positioning.
 
-        * xfns.c (x-list-fonts): Copied from x-list-fonts.c; #include
+        * xfns.c (x-list-fonts): Copy from x-list-fonts.c; #include
         removed.  x-list-fonts.c is now obsolete.
-        (Qfixed, Qvariable): Moved here from xfaces.c.
+        (Qfixed, Qvariable): Move here from xfaces.c.
 
 1998-01-14  Gerd Moellmann  <gerd@gnu.org>
 
         * xdisp.c (display_line): Set row->ends_at_zv_p based on
         FETCH_BYTE for truncated lines.
         (display_line): Set cursor differently.
-        (display_line): Fixed bug setting last_pos_on_this_line wrong
+        (display_line): Fix bug setting last_pos_on_this_line wrong
         for truncated lines.
 
         * dispnew.c (adjust_glyph_matrix): Always adjust for frame-based
@@ -8659,8 +8659,8 @@
 
         * window.c (Fsplit_window): Adjust glyphs before setting buffer.
 
-        * dispnew.c (adjust_frame_glyphs_for_window_redisplay): Add
-        assertion that character dimensions are not zero.
+        * dispnew.c (adjust_frame_glyphs_for_window_redisplay):
+        Add assertion that character dimensions are not zero.
 
         * xterm.c (x_load_font): adjust_glyphs_for_font_change while
         input is blocked.
@@ -8680,7 +8680,7 @@
 
         * xterm.h (FRAME_FLAGS_BITMAP_WIDTH): Macro giving the width
         in pixels of a flags area of a frame.
-        (FRAME_X_FLAGS_AREA_WIDTH): Removed.
+        (FRAME_X_FLAGS_AREA_WIDTH): Remove.
         (FRAME_X_FLAGS_AREA_COLS): Macro giving the number of columns
         occupied by a flags area.
 
@@ -8694,7 +8694,7 @@
 
         * xdisp.c (display_line): Correct wrong calculation of row->x for
         the case of nglyphs == 1.
-        (hscroll_window_tree): Renamed from hscroll_windows.
+        (hscroll_window_tree): Rename from hscroll_windows.
         (hscroll_windows): New function calling hscroll_window_tree that
         clears desired matrices on a frame when hscroll has been changed.
         (redisplay_p): Global flag set during redisplay.
@@ -8725,8 +8725,8 @@
         * xfaces.c (Qfixed, Qvariable): Symbols for use by x-list-fonts.
         (syms_of_xfaces): Initialize them.
 
-        * xterm.c (x_list_fonts): Include auto-scaled fonts.  Extend
-        cached information.
+        * xterm.c (x_list_fonts): Include auto-scaled fonts.
+        Extend cached information.
 
 1998-01-11  Gerd Moellmann  <gerd@acm.org>
 
@@ -8742,7 +8742,7 @@
 
 1998-01-05  Gerd Moellmann  <gerd@acm.org>
 
-        * xdisp.c (get_row_start_continuation_line_width): Removed.
+        * xdisp.c (get_row_start_continuation_line_width): Remove.
         (init_iterator_to_row_start): Set it.current_x from row.
         (try_window_id): Set it.continuation_lines_width directly from
         row.
@@ -8768,7 +8768,7 @@
 
 1998-01-02  Gerd Moellmann  <gerd@acm.org>
 
-        * xterm.c (x_get_mode_line_face_gc): Renamed from
+        * xterm.c (x_get_mode_line_face_gc): Rename from
         x_get_modeline_face_gc.
 
         * xdisp.c (TEXT_PROP_DISTANCE_LIMIT): Max. distance from current
@@ -8820,22 +8820,22 @@
         * xterm.c (x_get_cursor_gc): Don't return cursor_gc for font ==
         frame font if line height differs from font height.
 
-        * xdisp.c (set_iterator_to_next): Renamed from
+        * xdisp.c (set_iterator_to_next): Rename from
         move_iterator_forward to avoid confusion with other move_.*
         functions.
 
-        * dispextern.h (FACE_RELIEF_P): Renamed from FACE_3D_P.
+        * dispextern.h (FACE_RELIEF_P): Rename from FACE_3D_P.
 
 1997-12-31  Gerd Moellmann  <gerd@acm.org>
 
-        * xterm.c (x_get_cursor_gc): Renamed from x_cursor_gc to use the
+        * xterm.c (x_get_cursor_gc): Rename from x_cursor_gc to use the
         same naming convention as for other GC functions.
         (draw_glyphs): Don't fill background when drawing a cursor and
         font height is less than line height.
 
 1997-12-30  Gerd Moellmann  <gerd@acm.org>
 
-        * xdisp.c (init_display_iterator.*): Renamed to shorter names
+        * xdisp.c (init_display_iterator.*): Rename to shorter names
         init_iterator_.*.
 
         * xdisp.c (move_iterator_forward): Restore it->len from
@@ -8918,8 +8918,8 @@
         (x_get_char_font_and_encoding): Return null if font could not be
         loaded.  Reset font to null if fontset could not be loaded.
         (draw_glyphs): Fill background if font not found.
-        (draw_glyphs): Unused parameter just_foreground_p removed.  New
-        parameter composite_glyph.
+        (draw_glyphs): Unused parameter just_foreground_p removed.
+        New parameter composite_glyph.
         (draw_glyphs): Use enumeration for parameter hl.
         (draw_glyphs): Pass a display area relative x-position to
         draw_glyphs when calling it recursively for composite chars.
@@ -8961,8 +8961,8 @@
         * xterm.c (x_after_update_window_line): Draw continuation line
         bitmap.
 
-        * dispnew.c (update_window_line): Call
-        after_update_window_line_hook when row's continuation_line_p
+        * dispnew.c (update_window_line):
+        Call after_update_window_line_hook when row's continuation_line_p
         changes.
 
         * xterm.c (draw_bitmap): Draw new bitmap CONTINUATION_LINE_BITMAP.
@@ -8999,27 +8999,27 @@
 
 1997-12-14  Gerd Moellmann  <gerd@acm.org>
 
-        * frame.h (FRAME_MODE_LINE_PIXEL_HEIGHT): Removed.
+        * frame.h (FRAME_MODE_LINE_PIXEL_HEIGHT): Remove.
 
         * window.c (coordinates_in_window): Call frame_mode_line_height.
 
-        * xterm.c (x_draw_3d_border): Removed.
-        (x_draw_row_borders): Removed.
+        * xterm.c (x_draw_3d_border): Remove.
+        (x_draw_row_borders): Remove.
 
         * dispnew.c (update_window): References to
         FRAME_MODE_LINE_BORDER_WIDTH removed.
 
-        * xterm.h (FRAME_MODE_LINE_BORDER_WIDTH): Removed.
-        (FRAME_MODE_LINE_HEIGHT): Removed.
+        * xterm.h (FRAME_MODE_LINE_BORDER_WIDTH): Remove.
+        (FRAME_MODE_LINE_HEIGHT): Remove.
 
-        * xterm.c (draw_3d_borders_p): Removed.
+        * xterm.c (draw_3d_borders_p): Remove.
         (draw_glyphs): Ditto.
         (XTwrite_glyphs): Ditto.
         (expose_line): Ditto.
         (x_initialize): Ditto.
 
-        * dispextern.h (WINDOW_DISPLAY_MODE_LINE_HEIGHT): Call
-        frame_mode_line_height.
+        * dispextern.h (WINDOW_DISPLAY_MODE_LINE_HEIGHT):
+        Call frame_mode_line_height.
 
         * term.c (frame_mode_line_height): Get the pixel height of a
         frame's mode line.
@@ -9047,8 +9047,8 @@
         * xdisp.c (compute_face_at_iterator_overlay_string_position):
         Use it.
 
-        * xdisp.c (set_iterator_to_next_overlay_string): Formerly
-        set_iterator_to_next_overlay.
+        * xdisp.c (set_iterator_to_next_overlay_string):
+        Formerly set_iterator_to_next_overlay.
         (struct overlay_entry): Structure used to sort overlay strings.
         (compare_overlay_entries): Compare overlay strings.
         (load_iterator_with_overlay_strings): Load a chunk of overlay
@@ -9056,11 +9056,11 @@
         (get_overlay_strings_at_iterator_position): Call it.
         (next_element_from_overlay_string): Set it->object to the overlay
         string.  Prepare for setting it->position to a string position.
-        (get_overlay_strings_at_iterator_position): Renamed from
+        (get_overlay_strings_at_iterator_position): Rename from
         get_overlays_at_iterator_position.
-        (setup_iterator_overlay_strings_from_glyph_pos): Changed to load
+        (setup_iterator_overlay_strings_from_glyph_pos): Change to load
         chunks of overlay strings.
-        (load_overlay_strings): Renamed from load_iterator_overlay_strings.
+        (load_overlay_strings): Rename from load_iterator_overlay_strings.
 
         * dispextern.h (struct display_iterator): New vector
         overlay_strings and new member n_overlay_strings---formerly
@@ -9072,9 +9072,9 @@
 
         * xdisp.c (copy_iterator): Increment n_iterator_overlay_vectors
         when allocating a vector.
-        (release_iterator): Removed.
-        (restore_iterator): Removed.
-        (copy_iterator): Removed.
+        (release_iterator): Remove.
+        (restore_iterator): Remove.
+        (copy_iterator): Remove.
 
 1997-12-08  Gerd Moellmann  <gerd@acm.org>
 
@@ -9087,10 +9087,10 @@
 
         * xterm.h (struct x_output): trunc_area_extra renamed
         flags_areas_extra.
-        (FRAME_X_FLAGS_AREA_WIDTH): Renamed from FRAME_X_TRUNC_WIDTH.
+        (FRAME_X_FLAGS_AREA_WIDTH): Rename from FRAME_X_TRUNC_WIDTH.
 
-        * dispnew.c (update_window_line): Call
-        after_update_window_line_hook when current row is not enabled
+        * dispnew.c (update_window_line):
+        Call after_update_window_line_hook when current row is not enabled
         which is the case after a frame has been cleared.
 
         * xdisp.c (display_mode_line): Reset row flags for truncation
@@ -9129,8 +9129,8 @@
         face changes and changes in invisible text property.
         (struct glyph_pos): Former ovlen now overlay_string_index.
 
-        * xdisp.c (setup_iterator_overlays_from_glyph_pos): Set
-        overlay_string.
+        * xdisp.c (setup_iterator_overlays_from_glyph_pos):
+        Set overlay_string.
         (set_iterator_to_next_overlay_string): Set overlay_string and
         pos.overlay_string_index.
         (get_overlays_at_iterator_position): Use overlay_string and
@@ -9167,7 +9167,7 @@
         * buffer.h (overlays_at): Function prototype.
 
         * xdisp.c (reseat_iterator_to_string): Clear iterator position.
-        * dispextern.h (GET_NEXT_DISPLAY_ELEMENT): Removed.
+        * dispextern.h (GET_NEXT_DISPLAY_ELEMENT): Remove.
 
         * xdisp.c (release_iterator): Release dynamically allocated
         memory of a display_iterator.
@@ -9187,23 +9187,23 @@
         * buffer.c (overlays_at): Make it work when extending vectors
         and an initial vector of zero size.
 
-        * xdisp.c (set_iterator_to_previous_visible_line_end): Renamed
-        from set_cursor_to_previous_visible_line_end.
-        (set_iterator_to_next_visible_line_start): Renamed from
+        * xdisp.c (set_iterator_to_previous_visible_line_end):
+        Rename from set_cursor_to_previous_visible_line_end.
+        (set_iterator_to_next_visible_line_start): Rename from
         set_cursor_to_next_visible_line_end.
-        (set_next_iterator_stop_pos): Renamed from set_next_stop_pos.
-        (compute_face_at_iterator_position): Renamed from
+        (set_next_iterator_stop_pos): Rename from set_next_stop_pos.
+        (compute_face_at_iterator_position): Rename from
         compute_cursor_face.
-        (set_iterator_to_next_overlay_string): Renamed from
+        (set_iterator_to_next_overlay_string): Rename from
         cursor_to_next_overlay_string.
-        (get_overlays_at_iterator_position): Renamed from
+        (get_overlays_at_iterator_position): Rename from
         get_overlays_for_cursor.
-        (reseat_iterator): Renamed from reseat_cursor.
-        (setup_iterator_overlays_from_glyph_pos): Renamed from
+        (reseat_iterator): Rename from reseat_cursor.
+        (setup_iterator_overlays_from_glyph_pos): Rename from
         setup_overlays_from_pos.
-        (init_string_iterator): Renamed from init_string_cursor.
-        (get_next_display_element): Renamed from next_display_element.
-        (move_iterator_forward): Renamed from advance_display_cursor.
+        (init_string_iterator): Rename from init_string_cursor.
+        (get_next_display_element): Rename from next_display_element.
+        (move_iterator_forward): Rename from advance_display_cursor.
         (get_overlays_at_iterator_position): Allocate overlays vector
         dynamically.
 
@@ -9214,7 +9214,7 @@
 1997-12-01  Gerd Moellmann  <gerd@acm.org>
 
         * window.c (mark_window_cursors_off): Function comment added.
-        (window_topmost_p, window_rightmost_p): Removed because not used.
+        (window_topmost_p, window_rightmost_p): Remove because not used.
 
 1997-11-30  Gerd Moellmann  <gerd@acm.org>
 
@@ -9229,7 +9229,7 @@
         frame_title_buf.
         (init_xdisp): Initialize frame_title_.* variables to null.
 
-        * dispnew.c (quit_error_check): Removed.
+        * dispnew.c (quit_error_check): Remove.
 
         * eval.c (Fsignal): Call to quit_error_check removed.
         * keyboard.c (quit_throw_to_read_char): Ditto.
@@ -9275,8 +9275,8 @@
         * xterm.c (XTupdate_window_end): Don't display cursor if
         pseudo_window_p.
 
-        * dispnew.c (adjust_frame_glyphs_for_window_redisplay): Don't
-        set mini_p.
+        * dispnew.c (adjust_frame_glyphs_for_window_redisplay):
+        Don't set mini_p.
         (update_window): Don't set cursor if pseudo_window_p.
 
         * dispextern.h (WINDOW_WANTS_MODELINE_P): Test pseudo_window_p.
@@ -9307,8 +9307,8 @@
         f->menu_bar_window if appropriate.
         (display_mode_line): Use MATRIX_MODE_LINE_ROW.
 
-        * dispnew.c (adjust_frame_glyphs_for_window_redisplay): Allocate
-        dummy window and window matrices for f->menu_bar_window.
+        * dispnew.c (adjust_frame_glyphs_for_window_redisplay):
+        Allocate dummy window and window matrices for f->menu_bar_window.
         (free_glyphs): Free the dummy window and its glyph matrices.
 
         * frame.h (struct frame): New member menu_bar_window.
@@ -9323,8 +9323,8 @@
         first_row_to_display.  The previous scheme failed if the last row
         was fully visible.
 
-        * dispnew.c (update_window): Remove cost calculations.  Remove
-        redundant preempt_count calculations.
+        * dispnew.c (update_window): Remove cost calculations.
+        Remove redundant preempt_count calculations.
 
         * xterm.c (x_clip_to_row): Set clipping for non-text rows
         differently.
@@ -9345,7 +9345,7 @@
         try_window_id.
         (try_window_reusing_current_matrix): Give up for terminal frames
         if window is not full width or we cannot insert/delete lines.
-        (try_window_reusing_current_matrix): Fixed scrolling for terminal
+        (try_window_reusing_current_matrix): Fix scrolling for terminal
         frames.
 
         * alloc.c (mark_glyph_matrix): Bug fix - pass pointer to
@@ -9407,8 +9407,8 @@
         (update_window_line): Set it.
         (update_marginal_area): Clear to end of line if not in text area.
 
-        * window.c (Fset_window_margins): Increment
-        windows_or_buffer_changed.  Adjust glyphs.
+        * window.c (Fset_window_margins):
+        Increment windows_or_buffer_changed.  Adjust glyphs.
 
         * dispextern.h (WINDOW_TEXT_TO_FRAME_PIXEL_X): Convert text
         area X coordinates to frame coordinates.
@@ -9496,8 +9496,8 @@
 
 1997-10-27  Gerd Moellmann  <gerd@acm.org>
 
-        * dispnew.c (update_window_line): Call
-        after_update_window_line_hook only for interesting constellations.
+        * dispnew.c (update_window_line):
+        Call after_update_window_line_hook only for interesting constellations.
         (free_glyph_matrix): Fix memory leak.
 
         * window.h: Include blocker WINDOW_H_INCLUDED, include
@@ -9507,7 +9507,7 @@
         (replace_window): Ditto.
         * dispnew.c (free_window_matrices): Remove freeing of
         phys_cursor_glyph.
-        (check_matrix_invariants): Renamed from check_current_matrix_...
+        (check_matrix_invariants): Rename from check_current_matrix_...
         * xterm.c: All references to phys_cursor_glyph changed.
 
         * dispextern.h (DISPEXTERN_H_INCLUDED): New include blocker.
@@ -9665,8 +9665,8 @@
 
         * dispextern.h (MATRIX_ROW_FIRST_POS): Use row start.
 
-        * dispnew.c (increment_glyph_row_buffer_positions): Adjust
-        start and end positions in rows.
+        * dispnew.c (increment_glyph_row_buffer_positions):
+        Adjust start and end positions in rows.
         (increment_glyph_row_buffer_positions): Stop adjusting at
         glyphs with positions <= 0.
 
@@ -9682,8 +9682,8 @@
 
 1997-10-21  Gerd Moellmann  <gerd@acm.org>
 
-        * dispnew.c (update_window): Add scrolling_window again.  It's
-        necessary for scroll_step != 0.
+        * dispnew.c (update_window): Add scrolling_window again.
+        It's necessary for scroll_step != 0.
 
         * xdisp.c (redisplay_window): Use vmotion for scroll_step
         scrolling.
@@ -9745,7 +9745,7 @@
 1997-10-19  Gerd Moellmann  <gerd@acm.org>
 
         * dispnew.c (update_window): Remove unused variable.
-        (update_window_line): Simplified.
+        (update_window_line): Simplify.
 
         * xterm.c (x_get_char_font_and_encoding): Handle most common
         case at the beginning.
@@ -9756,8 +9756,8 @@
 
         * xdisp.c (try_window_id): New implementation.
 
-        * dispnew.c (increment_glyph_row_buffer_positions): Capture
-        rows displaying a line end, only.
+        * dispnew.c (increment_glyph_row_buffer_positions):
+        Capture rows displaying a line end, only.
 
 1997-10-18  Gerd Moellmann  <gerd@acm.org>
 
@@ -9850,8 +9850,8 @@
 
         * term.c: Some hooks with function prototypes.
 
-        * xdisp.c (reseat_cursor): Additional argument force_p.  Avoid
-        computing face if possible.
+        * xdisp.c (reseat_cursor): Additional argument force_p.
+        Avoid computing face if possible.
 
         * xdisp.c (next_display_element): Use face from glyph from display
         table only if != 0.
@@ -9883,7 +9883,7 @@
         (init_display_info): Subtract vertical border glyph from
         last_visible_x.
 
-        * scroll.c (scrolling_window_1): Removed.
+        * scroll.c (scrolling_window_1): Remove.
 
         * dispnew.c (adjust_frame_glyphs): Split into two functions,
         based on redisplay method used.
@@ -9892,7 +9892,7 @@
         (adjust_frame_glyphs_for_window_redisplay): Part for purely
         window based redisplay.
 
-        * frame.h (FRAME_WINDOW_REDISPLAY_P): Changed to not depend
+        * frame.h (FRAME_WINDOW_REDISPLAY_P): Change to not depend
         on data structures.
 
         * dispnew.c (adjust_glyph_matrix): Additional parameter W.
@@ -9904,8 +9904,8 @@
         * dispextern.h (struct glyph_matrix): window_top_y,
         window_height.
 
-        * dispnew.c (allocate_matrices_for_window_redisplay): Detect
-        and optimize some common cases of window changes.
+        * dispnew.c (allocate_matrices_for_window_redisplay):
+        Detect and optimize some common cases of window changes.
 
         * emacs.c (main): Remove own profiling code because 0.95 now
         has it in.
@@ -9965,9 +9965,9 @@
         * xterm.c (x_draw_row_borders): Use FRAME_MODE_LINE_HEIGHT height
         value.
         (x_clip_to_row): Use MATRIX_ROW_VISIBLE_HEIGHT.  Simplified.
-        (do_line_dance): Simplified and pixel corrected.
+        (do_line_dance): Simplify and pixel corrected.
 
-        * dispnew.c (scrolling_window): Simplified.
+        * dispnew.c (scrolling_window): Simplify.
 
         * xterm.c (x_draw_3d_border): Insert rectangle by line width.
 
@@ -10049,15 +10049,15 @@
 
         * xterm.h (WINDOW_COL_PIXEL_X etc.) Removed.
 
-        * dispextern.h (WINDOW_TO_FRAME_HPOS/VPOS): Moved to dispnew.c.
+        * dispextern.h (WINDOW_TO_FRAME_HPOS/VPOS): Move to dispnew.c.
 
         * xfns.c (x_contour_region): Use pixel coordinates from window
         cursor instead of WINDOW_TO_FRAME_H/VPOS.
 
         * dispextern.h (FRAME_TO_WINDOW_HPOS, FRAME_TO_WINDOW_VPOS):
-        Removed.
+        Remove.
 
-        * dispnew.c (frame_to_window_hpos, frame_to_window_vpos): Removed.
+        * dispnew.c (frame_to_window_hpos, frame_to_window_vpos): Remove.
 
         * xterm.c (x_y_to_hpos_vpos): Get hpos/vpos from window relative
         pixel coordinates.
@@ -10541,16 +10541,16 @@
         * xfns.c (Fx_create_frame): Don't set PHYS_CURSOR_X to -1.
         I don't believe this is really necessary.
 
-        * dispnew.c (build_frame_matrix_from_leaf_window): Determine
-        border glyph once.
+        * dispnew.c (build_frame_matrix_from_leaf_window):
+        Determine border glyph once.
 
 1997-07-15  Gerd Moellmann  <gerd@acm.org>
 
         * window.c (mark_window_cursors_off): Mark all cursors in
         window tree off.
 
-        * xterm.c (x_display_box_cursor): Window parameter.  Use
-        window matrix.
+        * xterm.c (x_display_box_cursor): Window parameter.
+        Use window matrix.
         (glyph_to_pixel_pos): Convert matrix pos -> pixels.
         (pixel_to_glyph_pos): Convert pixel pos -> matrix pos.
         (x_update_cursor): Work on windows.
@@ -10576,7 +10576,7 @@
 
         * frame.h (struct frame): Cursor information removed.
 
-        * frame.h (FRAME_SCROLL_BAR_WIDTH): Removed because unused.
+        * frame.h (FRAME_SCROLL_BAR_WIDTH): Remove because unused.
         (FRAME_WINDOW_WIDTH_ARG): Don't add scroll bar width.
 
         * window.h (WINDOW_LEFT_MARGIN): Remove FRAME_LEFT_SCROLL_BAR.
@@ -10650,7 +10650,7 @@
         * window.h: CURSOR_VPOS/HPOS added.
 
         * frame.h (struct frame): CURSOR_X/Y removed.
-        (FRAME_CURSOR_X): Removed.
+        (FRAME_CURSOR_X): Remove.
         (FRAME_CURSOR_Y): Ditto.
 
         * dispnew.c (direct_output_for_insert): LAST_POINT_X removed.
@@ -10687,10 +10687,10 @@
 
         * minibuf.c (read_minibuf): Build frame matrix.
 
-        * xdisp.c (this_line_start_hpos): Renamed to
+        * xdisp.c (this_line_start_hpos): Rename to
         THIS_LINE_START_WINDOW_HPOS to make it clear that this is window
         relative.
-        (this_line_vpos): Renamed to THIS_LINE_WINDOW_VPOS for the same
+        (this_line_vpos): Rename to THIS_LINE_WINDOW_VPOS for the same
         reason.
 
         * dispnew.c (build_frame_matrix): Don't clear rows of the
@@ -10717,7 +10717,7 @@
 
         * lisp.h: Prototype for SCAN_BUFFER.
 
-        * xdisp.c (redisplay_windows): Simplified.
+        * xdisp.c (redisplay_windows): Simplify.
 
         * dispnew.c (window_to_frame_vpos): Convert window to frame vpos
         with debug checks.
@@ -10739,8 +10739,8 @@
         * xdisp.c (try_window_id): Use CANCEL_WINDOW_LINE.
         (redisplay_internal): Ditto.
 
-        * dispnew.c (cancel_window_line): Use window matrix.  Changed
-        name to CANCEL_WINDOW_LINE.
+        * dispnew.c (cancel_window_line): Use window matrix.
+        Changed name to CANCEL_WINDOW_LINE.
 
         * xdisp.c (try_window_id): Use DISPLAY_TEXT_LINE with window
         relative VPOS.
@@ -10790,7 +10790,7 @@
         (allocate_leaf_matrix): Add FRAME_MENU_BAR_LINES to the height of
         top-most windows.
 
-        * window.h (WINDOW_TOPMOST_P): Added.
+        * window.h (WINDOW_TOPMOST_P): Add.
 
         * xdisp.c (echo_area_display): Use PREPARE_DESIRED_ROW.
         (redisplay_window): Ditto.
@@ -10860,25 +10860,25 @@
 
         * dispnew.c (check_matrix_pointer_lossage): Check against
         pointer lossage in matrices.
-        (get_glyph_matrix_row): Removed.
+        (get_glyph_matrix_row): Remove.
 
-        * scroll.c (do_scrolling): Simplified.
-        (do_direct_scrolling): Simplified.
+        * scroll.c (do_scrolling): Simplify.
+        (do_direct_scrolling): Simplify.
         (scrolling_1): Pass CURRENT_MATRIX instead of FRAME to
         DO_.*SCROLLING.
 
 
         * dispnew.c (ins_del_glyph_rows): Insert/delete rows in a matrix.
-        (rotate_vector): Removed.
-        (rotate_pointers): Removed.
-        (scroll_frame_lines): Simplified.
+        (rotate_vector): Remove.
+        (rotate_pointers): Remove.
+        (scroll_frame_lines): Simplify.
 
 1997-07-03  Gerd Moellmann  <gerd@acm.org>
 
-        * dispextern.h (MATRIX_ROW_SWAP_CONTENTS): Removed.
+        * dispextern.h (MATRIX_ROW_SWAP_CONTENTS): Remove.
 
-        * dispnew.c (increment_glyph_matrix_buffer_positions): Does
-        what the name says.
+        * dispnew.c (increment_glyph_matrix_buffer_positions):
+        Does what the name says.
         (clear_glyph_row): Make a glyph row structure empty.
         (make_matrix_row_current): Make a glyph row current.
         (make_window_matrix_row_current): Perform analogous row swaps
@@ -10895,11 +10895,11 @@
 
         * All files: Use above new names.
 
-        * dispnew.c (scroll_frame_lines): Simplified.  Use
-        SCROLL_GLYPH_MATRIX.
+        * dispnew.c (scroll_frame_lines): Simplify.
+        Use SCROLL_GLYPH_MATRIX.
         (make_glyph_row_empty): Mark a glyph row empty.
-        (increment_glyph_row_buffer_positions): Increment
-        buffer positions in a glyph row.
+        (increment_glyph_row_buffer_positions):
+        Increment buffer positions in a glyph row.
         (increment_glyph_matrix_buffer_positions): Increment buffer
         positions in a range of rows.
         (scroll_glyph_matrix): Scroll a glyph matrix.
@@ -10942,7 +10942,7 @@
         (MATRIX_ROW_USED): Ditto.
         (MATRIX_ROW_SET_USED): Ditto.
 
-        * dispnew.c (line_hash_code): Simplified.
+        * dispnew.c (line_hash_code): Simplify.
 
 1997-06-30  Gerd Moellmann  <gerd@acm.org>
 
@@ -10966,8 +10966,8 @@
         DO_PENDING_WINDOW_CHANGE, CHANGE_FRAME_SIZE, BITCH_AT_USER,
         SIT_FOR, INIT_DISPLAY, SYMS_OF_DISPLAY,
 
-        * dispnew.c (redraw_frame): FRAME_PTR -> struct frame.  Return
-        void.
+        * dispnew.c (redraw_frame): FRAME_PTR -> struct frame.
+        Return void.
         (cancel_line): Return void.
         (clear_frame_records): Return void.
 
@@ -11085,13 +11085,13 @@
         WRITE_GLYPHS_HOOK, DELETE_GLYPHS_HOOK,
 
         * xdisp.c (redisplay_internal): Remove call to VERIFY_CHARSTARTS.
-        (do_verify_charstarts): Removed.
+        (do_verify_charstarts): Remove.
 
         * frame.c (Fmake_terminal_frame): Adjust glyphs.
         (Fdelete_frame): Free glyphs.
         (make_frame): Initialize matrix fields in frame.
 
-        * config.in (PROTO): Added.
+        * config.in (PROTO): Add.
 
         * emacs.c (shut_down_emacs): Check glyph memory.
 
@@ -11261,7 +11261,7 @@
 
         * emacs.c [DOUG_LEA_MALLOC] (malloc_initialize_hook):
         Move the handling of MALLOC_CHECK_ envvar here.
-        (main): Moved from here.
+        (main): Move from here.
 
 1999-06-29  Wolfram Gloger  <wmglo@dent.med.uni-muenchen.de>
 
@@ -11414,8 +11414,8 @@
 
         * w32console.c (clear_frame): Remember that the window width might
         be smaller than the screen buffer width.
-        (write_glyphs): Remove redundant variable attrs.  Use
-        FillConsoleOutputAttribute instead of WriteConsoleOutputAttribute.
+        (write_glyphs): Remove redundant variable attrs.
+        Use FillConsoleOutputAttribute instead of WriteConsoleOutputAttribute.
 
 1999-05-20  Andrew Innes  <andrewi@gnu.org>
 
@@ -11423,8 +11423,8 @@
         loses focus.
 
         * w32fns.c (w32_wnd_proc): Ensure mouse capture is released if
-        frame loses focus, and that mouse button state is reset.  Ditto
-        when the menu bar is activated.
+        frame loses focus, and that mouse button state is reset.
+        Ditto when the menu bar is activated.
 
 1999-05-18  Richard Stallman  <rms@gnu.org>
 
@@ -11599,7 +11599,7 @@
         (w32_clear_frame, clear_cursor, x_display_bar_cursor)
         (x_display_box_cursor, x_set_window_size): Use phys_cursor_on
         field in frame.
-        (do_line_dance): Updated WRT xterm.c.  Use macros where possible.
+        (do_line_dance): Update WRT xterm.c.  Use macros where possible.
         (dumprectangle): Take into account the width of a left-side
         scroll bar.
 
@@ -11617,8 +11617,8 @@
 
 1999-05-02  Kenichi HANDA  <handa@etl.go.jp>
 
-        * coding.c (setup_raw_text_coding_system): Call
-        setup_coding_system to initialize the fields of struct
+        * coding.c (setup_raw_text_coding_system):
+        Call setup_coding_system to initialize the fields of struct
         coding_system correctly.
 
 1999-04-26  Kenichi HANDA  <handa@etl.go.jp>
@@ -11773,11 +11773,11 @@
 1999-03-25  Andrew Innes  <andrewi@gnu.org>
 
         * makefile.nt (PREPARED_HEADERS): Change name of paths.h to epaths.h.
-        (epaths.h): Renamed from paths.h.
+        (epaths.h): Rename from paths.h.
         (clean):
         ($(BLD)\filelock.obj):
         ($(BLD)\lread.obj):
-        ($(BLD)\w32fns.obj): Renamed paths.h to epaths.h.
+        ($(BLD)\w32fns.obj): Rename paths.h to epaths.h.
 
 1999-03-23  Ken'ichi Handa  <handa@gnu.org>
 
@@ -11791,8 +11791,8 @@
 
 1999-03-20  Kenichi HANDA  <handa@etl.go.jp>
 
-        * coding.c (ENCODE_ISO_CHARACTER): Check validity of CHARSET.  If
-        invalid, produce the buffer internal byte sequence without encoding.
+        * coding.c (ENCODE_ISO_CHARACTER): Check validity of CHARSET.
+        If invalid, produce the buffer internal byte sequence without encoding.
 
 1999-03-19  Karl Heuer  <kwzh@gnu.org>
 
@@ -11965,8 +11965,8 @@
 1999-02-24  Kenichi Handa  <handa@etl.go.jp>
 
         * keymap.c (push_key_description): If enable-multibyte-characters
-        is non-nil, try to convert unibyte character to multibyte.  For
-        invalid multibyte character, show all bits by octal form.
+        is non-nil, try to convert unibyte character to multibyte.
+        For invalid multibyte character, show all bits by octal form.
         (Fsingle_key_description): Check the validity of charset for a
         generic character.
 
@@ -12083,8 +12083,8 @@
 
 1999-02-15  Kenichi Handa  <handa@etl.go.jp>
 
-        * coding.c (Fdecode_sjis_char, Fencode_sjis_char): Handle
-        ASCII correctly.  Signal error on invalid characters.
+        * coding.c (Fdecode_sjis_char, Fencode_sjis_char):
+        Handle ASCII correctly.  Signal error on invalid characters.
         (Fdecode_big5_char, Fencode_big5_char): Likewise.
 
 1999-02-15  Eli Zaretskii  <eliz@gnu.org>
@@ -12146,8 +12146,8 @@
 
 1999-02-04  Eli Zaretskii  <eliz@gnu.org>
 
-        * w16select.c (last_clipboard_text, clipboard_storage_size): New
-        static variables.
+        * w16select.c (last_clipboard_text, clipboard_storage_size):
+        New static variables.
         (set_clipboard_data): Save a copy of the text we put into
         clipboard in last_clipboard_text.
         (get_clipboard_data): If the clipboard text is identical to what
@@ -12305,8 +12305,8 @@
         (x_destroy_bitmap): Returns void not int.
         (x_set_border_pixel): Returns void.
         (w32_load_bdf_font): New function.
-        (w32_load_system_font): New function, was w32_load_font.  List
-        fonts before loading.  Explicitly set encoding for SJIS fonts.
+        (w32_load_system_font): New function, was w32_load_font.
+        List fonts before loading.  Explicitly set encoding for SJIS fonts.
         Set default_ascent to 0 as comment indicates.
         (w32_load_font): Call w32_load_system_font and w32_load_bdf_font.
         (w32_unload_font): Support BDF fonts.
@@ -12350,7 +12350,7 @@
         w32_codepage_for_charset.  Add cast to int where float
         operation is assigned to int.
         (Vw32_charset_to_codepage_alist): New variable.
-        (w32_codepage_for_charset): Removed.
+        (w32_codepage_for_charset): Remove.
         (w32_codepage_for_font): New function, replacing
         w32_codepage_for_charset.
         (syms_of_w32term): Add and initialize
@@ -12369,7 +12369,7 @@
 
         * w32heap.h (ROUND_UP):
         (ROUND_DOWN): New macros.
-        (need_to_recreate_heap): Renamed to using_dynamic_heap.
+        (need_to_recreate_heap): Rename to using_dynamic_heap.
         (init_heap): New extern.
         (data_region_size):
         (recreate_heap):
@@ -12384,11 +12384,11 @@
         (round_to_next): Obsolete function removed.
         (preload_heap_section): New variable.
         (data_region_size): Obsolete variable removed.
-        (allocate_heap): Modified to determine end of static heap section
+        (allocate_heap): Modify to determine end of static heap section
         used during preload, and use that as initial base address for
         dynamic heap instead of hard-coded value.
-        (sbrk): Remove call to allocate_heap; handled by init_heap.  Skip
-        calls to commit or decommit pages when allocating from static heap
+        (sbrk): Remove call to allocate_heap; handled by init_heap.
+        Skip calls to commit or decommit pages when allocating from static heap
         section during preload.
         (recreate_heap): Obsolete function removed.
         (init_heap): New function to initialize internal sbrk heap
@@ -12399,10 +12399,10 @@
         * unexw32.c: Major rewrite to support cleaner method of dumping; a
         static "bss" section is used for heap space during preload, and
         bss data is now written to the proper section area when dumping.
-        (need_to_recreate_heap): Renamed to using_dynamic_heap.
+        (need_to_recreate_heap): Rename to using_dynamic_heap.
         (heap_index_in_executable): Obsolete variable removed.
         (data_section): New variable.
-        (data_start_va): Renamed to data_start.
+        (data_start_va): Rename to data_start.
         (data_start_file): Obsolete variable removed.
         (bss_section):
         (extra_bss_size):
@@ -12432,8 +12432,8 @@
         sections where data will be dumped.  Allows for static and global
         bss data to be in separate ranges.  No longer relies on knowledge
         of section names.
-        (copy_executable_and_dump_data_section): Renamed
-        copy_executable_and_dump_data.  Completely rewritten to copy
+        (copy_executable_and_dump_data_section):
+        Rename copy_executable_and_dump_data.  Completely rewritten to copy
         executable section by section, so that raw data areas can be
         expanded to hold dumped data as necessary.  Allows for bss data to
         be in same section as initialized data.  Reduces size of static
@@ -12511,8 +12511,8 @@
         Return zero in case of success, 1 or 2 otherwise.
         (get_clipboard_data): Only bail out if the null character is in
         the last 32-byte chunk of clipboard data.
-        (Fw16_set_clipboard_data): Make ok and put_status be unsigned.  If
-        they save binary data, print a message in the echo area saying the
+        (Fw16_set_clipboard_data): Make ok and put_status be unsigned.
+        If they save binary data, print a message in the echo area saying the
         text was not put into the clipboard.
 
         * msdos.c (IT_write_glyphs): Move constant expression out of the loop.
@@ -12688,8 +12688,8 @@
         based on VEC.
 
         * charset.c (Qunknown): New variable.
-        (init_charset_once): Intern and staticpro Qunknown.  Initialize
-        all elements of Vcharset_symbol_table to Qunknown.
+        (init_charset_once): Intern and staticpro Qunknown.
+        Initialize all elements of Vcharset_symbol_table to Qunknown.
         (find_charset_in_str): New arg MULTIBYTE.  If it is zero, check
         unibyte characters only.  For an invalid composition sequence, set
         CHARSETS[1] to 1.
@@ -12997,8 +12997,8 @@
         (RIGHT_WIN_PRESSED):
         (APPS_PRESSED): New console keyboard modifier flags.
 
-        * w32term.c (convert_to_key_event): Removed.
-        (is_dead_key): Copied to w32fns.c.
+        * w32term.c (convert_to_key_event): Remove.
+        (is_dead_key): Copy to w32fns.c.
         (w32_read_socket): Generate language_change_event.  Modify to work
         with keyboard handling changes in w32_wnd_proc.
 
@@ -13037,10 +13037,10 @@
         code.
         (is_dead_key): Copy from w32fns.c.
         (w32_kbd_patch_key): Comment attempt to improve handling of
-        dead-keys, and system bug relating to same on Windows NT.  Work
-        around the bug by calling ToUnicode and then converting to the
+        dead-keys, and system bug relating to same on Windows NT.
+        Work around the bug by calling ToUnicode and then converting to the
         correct codepage.
-        (map_virt_key): Removed obsolete variable.
+        (map_virt_key): Remove obsolete variable.
         (lispy_function_keys): Add extern.
         (key_event): Major rework of keyboard input handling: optionally
         recognize Windows keys and Apps key as modifiers; optionally treat
@@ -13066,7 +13066,7 @@
         for given key.
         (w32_get_modifiers): Returns modifier flags for
         non-keyboard input events.
-        (construct_console_modifiers): Renamed from construct_modifiers;
+        (construct_console_modifiers): Rename from construct_modifiers;
         recognize Windows and Apps keys as modifiers.
         (w32_get_key_modifiers): New function.  Returns modifier flags for
         keyboard input events.
@@ -13098,12 +13098,12 @@
 
 1998-11-10  Kenichi Handa  <handa@etl.go.jp>
 
-        * category.h (CATEGORY_SET): Adjusted for the change of
+        * category.h (CATEGORY_SET): Adjust for the change of
         cmpchar_component.
         (CATEGORY_SET): Likewise.
 
-        * charset.c (cmpchar_component): New arg NOERROR.  Check
-        composition char ID more strictly.
+        * charset.c (cmpchar_component): New arg NOERROR.
+        Check composition char ID more strictly.
         (Fcmpchar_component): Call cmpchar_component with NOERROR arg zero.
         (Fcmpchar_cmp_rule): If CHARACTER should be composed relatively,
         return 255.
@@ -13303,8 +13303,8 @@
         (insert_from_buffer_1): Likewise.
         (adjust_after_replace): Inhibit bytes combined across region
         boundary.  Update end_unchanged correctly.
-        (replace_range): Call CHECK_BYTE_COMBINING_FOR_INSERT.  Update
-        end_unchanged correctly.
+        (replace_range): Call CHECK_BYTE_COMBINING_FOR_INSERT.
+        Update end_unchanged correctly.
         (del_range_2): Inhibit bytes combined across region boundary.
         Update end_unchanged correctly.
 
@@ -13333,8 +13333,8 @@
 
 1998-10-27  Dave Love  <fx@gnu.org>
 
-        * fns.c (Fbase64_decode_region, Fbase64_encode_region): Fix
-        newline in doc string.
+        * fns.c (Fbase64_decode_region, Fbase64_encode_region):
+        Fix newline in doc string.
 
 1998-10-27  Kenichi Handa  <handa@etl.go.jp>
 
@@ -13415,28 +13415,28 @@
         * w32fns.c (Vx_pixel_size_width): New global variable.
         (unibyte_display_via_language_environment): New global variable.
         (x_set_font): Add support for setting fontsets.
-        (Fx_create_frame): Add check_w32().  Initialize fontsets.  Fix
-        font names to match xlfd-tight-regexp.
+        (Fx_create_frame): Add check_w32().  Initialize fontsets.
+        Fix font names to match xlfd-tight-regexp.
         (w32_load_font): Rewrite based on x_load_font.
-        (x_to_w32_charset, w32_to_x_charset): Add character sets.  Use
-        `iso8859-1' rather than `ansi'.
+        (x_to_w32_charset, w32_to_x_charset): Add character sets.
+        Use `iso8859-1' rather than `ansi'.
         (w32_to_x_font): Remove `-' from font name.  Remove the `-' off the
         end.  Move charset into `charset registry' field.
         (enum_font_cb2): Check charsets match.  Include width in font list.
         (w32_list_fonts): Rewrite based on x_list_fonts.
         Moved from w32term.c to have access to enumfont_t struct.
-        (Fx_list_fonts): w32 specific version eliminated.  Include
-        `x-list-fonts.c'.
-        (w32_get_font_info, w32_query_font, w32_find_ccl_program): New
-        functions for fontset support - adapted from x_ equivalents.
-        (syms_of_w32fns): New lisp variables initialized.  Function
-        pointers for fontset.c set up.
+        (Fx_list_fonts): w32 specific version eliminated.
+        Include `x-list-fonts.c'.
+        (w32_get_font_info, w32_query_font, w32_find_ccl_program):
+        New functions for fontset support - adapted from x_ equivalents.
+        (syms_of_w32fns): New lisp variables initialized.
+        Function pointers for fontset.c set up.
 
         * w32term.c: Include fontset.h.  Define codepage macros.
         Add ENCODE_BIG5 macro from coding.c.
         (w32_no_unicode_output): New variable.
-        (w32_codepage_for_charset, w32_use_unicode_for_codepage): New
-        functions.
+        (w32_codepage_for_charset, w32_use_unicode_for_codepage):
+        New functions.
         (BUILD_WCHAR_T, BYTE1, BYTE2): New macros.
         (dumpglyphs): Rewrite based on xterm.c equivalent.
         (x_new_font): Use functionality provided in fontset.c.
@@ -13552,8 +13552,8 @@
 
         * lisp.h (clear_string_char_byte_cache): Extern it.
 
-        * xselect.c (lisp_data_to_selection_data): Call
-        find_charset_in_str with CMPCHARP arg 0.
+        * xselect.c (lisp_data_to_selection_data):
+        Call find_charset_in_str with CMPCHARP arg 0.
         * w16select.c (Fw16_set_clipboard_data): Likewise.
         * w32select.c (Fw32_set_clipboard_data): Likewise.
 
@@ -13623,7 +13623,7 @@
 
         * coding.c (check_composing_code): Fix previous change.  Now it
         always returns 0 or -1.
-        (decode_coding_iso2022): Adjusted for the above change.
+        (decode_coding_iso2022): Adjust for the above change.
         (encode_coding_iso2022): When encoding the last block, flush out
         tailing garbage bytes.
         (setup_coding_system): Delete unnecessary code.
@@ -13700,8 +13700,8 @@
 
         * ccl.c (CCL_WRITE_CHAR): Don't use bcopy.
         (ccl_driver): If BUFFER-MAGNIFICATION of the CCL program is 0,
-        cause error if the program is going to output some bytes.  When
-        outputting a string to notify an error, check the case that
+        cause error if the program is going to output some bytes.
+        When outputting a string to notify an error, check the case that
         DST_BYTES is zero.
 
         * coding.h (CODING_FINISH_INTERRUPT): New macro.
@@ -13838,8 +13838,8 @@
         * w16select.c (Vnext_selection_coding_system): New variable.
         (syms_of_win16select): DEFVAR_LISP it.  No need to staticpro
         Vselection_coding_system.
-        (Fw16_set_clipboard_data): Always convert multibyte strings.  Use
-        Vnext_selection_coding_system if non-nil.
+        (Fw16_set_clipboard_data): Always convert multibyte strings.
+        Use Vnext_selection_coding_system if non-nil.
         (Fw16_get_clipboard_data): Always convert a string that includes
         non-ASCII characters.  Use Vnext_selection_coding_system if
         non-nil.
@@ -13911,8 +13911,8 @@
 1998-08-28  Kenichi Handa  <handa@etl.go.jp>
 
         * insdel.c (adjust_after_replace): Fix the code to record undo
-        information for the case that `before combining' happens.  Remove
-        text properties which are added to the new text by
+        information for the case that `before combining' happens.
+        Remove text properties which are added to the new text by
         offset_intervals.
 
         * coding.c (code_convert_region1): Remove all text properties of
diff --git a/src/Makefile.in b/src/Makefile.in
index 0dc48868dd8..36e145744b3 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -250,7 +250,7 @@ MSDOS_OBJ =
 MSDOS_X_OBJ =
 
 NS_OBJ=@NS_OBJ@
-## nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o macfont.o if HAVE_NS.
+## nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o ns_fontfile if HAVE_NS.
 NS_OBJC_OBJ=@NS_OBJC_OBJ@
 ## Only set if NS_IMPL_GNUSTEP.
 GNU_OBJC_CFLAGS=@GNU_OBJC_CFLAGS@
@@ -297,13 +297,33 @@ GETLOADAVG_LIBS = @GETLOADAVG_LIBS@
 
 RUN_TEMACS = ./temacs
 
-## Static heap size for temacs on MinGW.
-EMACS_HEAPSIZE = @EMACS_HEAPSIZE@
-
 UNEXEC_OBJ = @UNEXEC_OBJ@
 
 CANNOT_DUMP=@CANNOT_DUMP@
 
+# 'make' verbosity.
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC      " $@;
+am__v_CC_1 =
+
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD    " $@;
+am__v_CCLD_1 =
+
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 =
+
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+
 DEPDIR=deps
 ## -MMD -MF $(DEPDIR)/$*.d if AUTO_DEPEND; else empty.
 DEPFLAGS=@DEPFLAGS@
@@ -334,10 +354,10 @@ ALL_OBJC_CFLAGS=$(ALL_CFLAGS) $(GNU_OBJC_CFLAGS)
 .SUFFIXES: .m
 .c.o:
         @$(MKDEPDIR)
-        $(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $(PROFILING_CFLAGS) $<
+        $(AM_V_CC)$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $(PROFILING_CFLAGS) $<
 .m.o:
         @$(MKDEPDIR)
-        $(CC) -c $(CPPFLAGS) $(ALL_OBJC_CFLAGS) $(PROFILING_CFLAGS) $<
+        $(AM_V_CC)$(CC) -c $(CPPFLAGS) $(ALL_OBJC_CFLAGS) $(PROFILING_CFLAGS) $<
 
 ## lastfile must follow all files whose initialized data areas should
 ## be dumped as pure by dump-emacs.
@@ -417,8 +437,12 @@ all: emacs$(EXEEXT) $(OTHER_FILES)
 $(leimdir)/leim-list.el: bootstrap-emacs$(EXEEXT)
         $(MAKE) -C ../leim leim-list.el EMACS="$(bootstrap_exe)"
 
+## FORCE it so that admin/unidata can decide whether these files
+## are up-to-date.  Although since charprop depends on bootstrap-emacs,
+## and emacs (which recreates bootstrap-emacs) depends on charprop,
+## in practice this rule was always run anyway.
 $(srcdir)/macuvs.h $(lispsource)/international/charprop.el: \
-  bootstrap-emacs$(EXEEXT)
+  bootstrap-emacs$(EXEEXT) FORCE
         $(MAKE) -C ../admin/unidata all EMACS="../$(bootstrap_exe)"
 
 ## The dumped Emacs is as functional and more efficient than
@@ -435,7 +459,9 @@ emacs$(EXEEXT): temacs$(EXEEXT) \
         else \
           LC_ALL=C $(RUN_TEMACS) -batch -l loadup dump || exit 1; \
           test "X$(PAXCTL)" = X || $(PAXCTL) -zex emacs$(EXEEXT); \
-          rm -f bootstrap-emacs$(EXEEXT); \
+          while test -f bootstrap-emacs$(EXEEXT); do \
+            rm -f bootstrap-emacs$(EXEEXT); \
+          done; \
           ln emacs$(EXEEXT) bootstrap-emacs$(EXEEXT); \
         fi
 
@@ -454,29 +480,32 @@ emacs$(EXEEXT): temacs$(EXEEXT) \
 ## in the contents of the DOC file.
 ##
 $(etc)/DOC: $(libsrc)/make-docfile$(EXEEXT) $(obj) $(lisp)
-        $(MKDIR_P) $(etc)
-        -rm -f $(etc)/DOC
-        $(libsrc)/make-docfile -d $(srcdir) $(SOME_MACHINE_OBJECTS) $(obj) > $(etc)/DOC
-        $(libsrc)/make-docfile -a $(etc)/DOC -d $(lispsource) `sed -n -e 's| \\\\||' -e 's|^[   ]*$$(lispsource)/||p' $(srcdir)/lisp.mk`
+        $(AM_V_GEN)$(MKDIR_P) $(etc)
+        -$(AM_V_at)rm -f $(etc)/DOC
+        $(AM_V_at)$(libsrc)/make-docfile -d $(srcdir) \
+          $(SOME_MACHINE_OBJECTS) $(obj) > $(etc)/DOC
+        $(AM_V_at)$(libsrc)/make-docfile -a $(etc)/DOC -d $(lispsource) \
+          `sed -n -e 's| \\\\||' -e 's|^[       ]*$$(lispsource)/||p' \
+             $(srcdir)/lisp.mk`
 
 $(libsrc)/make-docfile$(EXEEXT):
         $(MAKE) -C $(libsrc) make-docfile$(EXEEXT)
 
 buildobj.h: Makefile
-        for i in $(ALLOBJS); do \
+        $(AM_V_GEN)for i in $(ALLOBJS); do \
           echo "$$i" | sed 's,.*/,,; s/\.obj$$/\.o/; s/^/"/; s/$$/",/' \
             || exit; \
         done >$@.tmp
-        mv $@.tmp $@
+        $(AM_V_at)mv $@.tmp $@
 
 globals.h: gl-stamp; @true
 
 GLOBAL_SOURCES = $(base_obj:.o=.c) $(NS_OBJC_OBJ:.o=.m)
 
 gl-stamp: $(libsrc)/make-docfile$(EXEEXT) $(GLOBAL_SOURCES)
-        $(libsrc)/make-docfile -d $(srcdir) -g $(obj) > gl.tmp
-        $(top_srcdir)/build-aux/move-if-change gl.tmp globals.h
-        echo timestamp > $@
+        $(AM_V_GEN)$(libsrc)/make-docfile -d $(srcdir) -g $(obj) > gl.tmp
+        $(AM_V_at)$(top_srcdir)/build-aux/move-if-change gl.tmp globals.h
+        $(AM_V_at)echo timestamp > $@
 
 $(ALLOBJS): globals.h
 
@@ -489,7 +518,7 @@ $(lib)/libgnu.a: $(config_h)
 ## to start if Vinstallation_directory has the wrong value.
 temacs$(EXEEXT): $(LIBXMENU) $(ALLOBJS) \
                  $(lib)/libgnu.a $(EMACSRES)
-        $(CC) $(ALL_CFLAGS) $(TEMACS_LDFLAGS) $(LDFLAGS) \
+        $(AM_V_CCLD)$(CC) $(ALL_CFLAGS) $(TEMACS_LDFLAGS) $(LDFLAGS) \
           -o temacs $(ALLOBJS) $(lib)/libgnu.a $(W32_RES_LINK) $(LIBES)
         $(MKDIR_P) $(etc)
         test "$(CANNOT_DUMP)" = "yes" || \
diff --git a/src/alloc.c b/src/alloc.c
index ac154b587e6..faad0b59c87 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -80,7 +80,7 @@ static bool valgrind_p;
    marked objects.  */
 
 #if (defined SYSTEM_MALLOC || defined DOUG_LEA_MALLOC \
-     || defined GC_CHECK_MARKED_OBJECTS)
+     || defined HYBRID_MALLOC || defined GC_CHECK_MARKED_OBJECTS)
 #undef GC_MALLOC_CHECK
 #endif
 
@@ -285,7 +285,7 @@ static void gc_sweep (void);
 static Lisp_Object make_pure_vector (ptrdiff_t);
 static void mark_buffer (struct buffer *);
 
-#if !defined REL_ALLOC || defined SYSTEM_MALLOC
+#if !defined REL_ALLOC || defined SYSTEM_MALLOC || defined HYBRID_MALLOC
 static void refill_memory_reserve (void);
 #endif
 static void compact_small_strings (void);
@@ -453,7 +453,7 @@ mmap_lisp_allowed_p (void)
   /* If we can't store all memory addresses in our lisp objects, it's
      risky to let the heap use mmap and give us addresses from all
      over our address space.  We also can't use mmap for lisp objects
-     if we might dump: unexec doesn't preserve the contents of mmaped
+     if we might dump: unexec doesn't preserve the contents of mmapped
      regions.  */
   return pointers_fit_in_lispobj_p () && !might_dump;
 }
@@ -1014,10 +1014,17 @@ lisp_free (void *block)
    clang 3.3 anyway.  */
 
 #if ! ADDRESS_SANITIZER
-# if !defined SYSTEM_MALLOC && !defined DOUG_LEA_MALLOC
+# if !defined SYSTEM_MALLOC && !defined DOUG_LEA_MALLOC && !defined HYBRID_MALLOC
 #  define USE_ALIGNED_ALLOC 1
 /* Defined in gmalloc.c.  */
 void *aligned_alloc (size_t, size_t);
+# elif defined HYBRID_MALLOC
+#  if defined ALIGNED_ALLOC || defined HAVE_POSIX_MEMALIGN
+#   define USE_ALIGNED_ALLOC 1
+#   define aligned_alloc hybrid_aligned_alloc
+/* Defined in gmalloc.c.  */
+void *aligned_alloc (size_t, size_t);
+#  endif
 # elif defined HAVE_ALIGNED_ALLOC
 #  define USE_ALIGNED_ALLOC 1
 # elif defined HAVE_POSIX_MEMALIGN
@@ -2219,7 +2226,6 @@ make_string (const char *contents, ptrdiff_t nbytes)
   return val;
 }
 
-
 /* Make an unibyte string from LENGTH bytes at CONTENTS.  */
 
 Lisp_Object
@@ -2611,29 +2617,28 @@ list5 (Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3, Lisp_Object arg4, L
 Lisp_Object
 listn (enum constype type, ptrdiff_t count, Lisp_Object arg, ...)
 {
-  va_list ap;
-  ptrdiff_t i;
-  Lisp_Object val, *objp;
+  Lisp_Object (*cons) (Lisp_Object, Lisp_Object);
+  switch (type)
+    {
+    case CONSTYPE_PURE: cons = pure_cons; break;
+    case CONSTYPE_HEAP: cons = Fcons; break;
+    default: emacs_abort ();
+    }
 
-  /* Change to SAFE_ALLOCA if you hit this eassert.  */
-  eassert (count <= MAX_ALLOCA / word_size);
+  eassume (0 < count);
+  Lisp_Object val = cons (arg, Qnil);
+  Lisp_Object tail = val;
 
-  objp = alloca (count * word_size);
-  objp[0] = arg;
+  va_list ap;
   va_start (ap, arg);
-  for (i = 1; i < count; i++)
-    objp[i] = va_arg (ap, Lisp_Object);
-  va_end (ap);
-
-  for (val = Qnil, i = count - 1; i >= 0; i--)
+  for (ptrdiff_t i = 1; i < count; i++)
     {
-      if (type == CONSTYPE_PURE)
-        val = pure_cons (objp[i], val);
-      else if (type == CONSTYPE_HEAP)
-        val = Fcons (objp[i], val);
-      else
-        emacs_abort ();
+      Lisp_Object elem = cons (va_arg (ap, Lisp_Object), Qnil);
+      XSETCDR (tail, elem);
+      tail = elem;
     }
+  va_end (ap);
+
   return val;
 }
 
@@ -3282,7 +3287,6 @@ See also the function `vector'.  */)
   return vector;
 }
 
-
 DEFUN ("vector", Fvector, Svector, 0, MANY, 0,
        doc: /* Return a newly created vector with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
@@ -3829,7 +3833,7 @@ memory_full (size_t nbytes)
 void
 refill_memory_reserve (void)
 {
-#ifndef SYSTEM_MALLOC
+#if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
   if (spare_memory[0] == 0)
     spare_memory[0] = malloc (SPARE_MEMORY);
   if (spare_memory[1] == 0)
@@ -6011,8 +6015,9 @@ mark_overlay (struct Lisp_Overlay *ptr)
   for (; ptr && !ptr->gcmarkbit; ptr = ptr->next)
     {
       ptr->gcmarkbit = 1;
-      mark_object (ptr->start);
-      mark_object (ptr->end);
+      /* These two are always markers and can be marked fast.  */
+      XMARKER (ptr->start)->gcmarkbit = 1;
+      XMARKER (ptr->end)->gcmarkbit = 1;
       mark_object (ptr->plist);
     }
 }
@@ -7072,7 +7077,7 @@ detect_suspicious_free (void* ptr)
 
 DEFUN ("suspicious-object", Fsuspicious_object, Ssuspicious_object, 1, 1, 0,
        doc: /* Return OBJ, maybe marking it for extra scrutiny.
-If Emacs is compiled with suspicous object checking, capture
+If Emacs is compiled with suspicious object checking, capture
 a stack trace when OBJ is freed in order to help track down
 garbage collection bugs.  Otherwise, do nothing and return OBJ.   */)
    (Lisp_Object obj)
@@ -7100,8 +7105,48 @@ die (const char *msg, const char *file, int line)
            file, line, msg);
   terminate_due_to_signal (SIGABRT, INT_MAX);
 }
-#endif
-
+
+#endif /* ENABLE_CHECKING */
+
+#if defined (ENABLE_CHECKING) && USE_STACK_LISP_OBJECTS
+
+/* Debugging check whether STR is ASCII-only.  */
+
+const char *
+verify_ascii (const char *str)
+{
+  const unsigned char *ptr = (unsigned char *) str, *end = ptr + strlen (str);
+  while (ptr < end)
+    {
+      int c = STRING_CHAR_ADVANCE (ptr);
+      if (!ASCII_CHAR_P (c))
+        emacs_abort ();
+    }
+  return str;
+}
+
+/* Stress alloca with inconveniently sized requests and check
+   whether all allocated areas may be used for Lisp_Object.  */
+
+NO_INLINE static void
+verify_alloca (void)
+{
+  int i;
+  enum { ALLOCA_CHECK_MAX = 256 };
+  /* Start from size of the smallest Lisp object.  */
+  for (i = sizeof (struct Lisp_Cons); i <= ALLOCA_CHECK_MAX; i++)
+    {
+      void *ptr = alloca (i);
+      make_lisp_ptr (ptr, Lisp_Cons);
+    }
+}
+
+#else /* not ENABLE_CHECKING && USE_STACK_LISP_OBJECTS */
+
+#define verify_alloca() ((void) 0)
+
+#endif /* ENABLE_CHECKING && USE_STACK_LISP_OBJECTS */
+
 /* Initialization.  */
 
 void
@@ -7111,6 +7156,8 @@ init_alloc_once (void)
   purebeg = PUREBEG;
   pure_size = PURESIZE;
 
+  verify_alloca ();
+
 #if GC_MARK_STACK || defined GC_MALLOC_CHECK
   mem_init ();
   Vdead = make_pure_string ("DEAD", 4, 4, 0);
diff --git a/src/buffer.c b/src/buffer.c
index d2c7729d1c2..80791a1fdb1 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1134,10 +1134,7 @@ BUFFER defaults to the current buffer.
 Return nil if BUFFER has been killed.  */)
   (register Lisp_Object buffer)
 {
-  if (NILP (buffer))
-    return BVAR (current_buffer, name);
-  CHECK_BUFFER (buffer);
-  return BVAR (XBUFFER (buffer), name);
+  return BVAR (decode_buffer (buffer), name);
 }
 
 DEFUN ("buffer-file-name", Fbuffer_file_name, Sbuffer_file_name, 0, 1, 0,
@@ -1145,10 +1142,7 @@ DEFUN ("buffer-file-name", Fbuffer_file_name, Sbuffer_file_name, 0, 1, 0,
 No argument or nil as argument means use the current buffer.  */)
   (register Lisp_Object buffer)
 {
-  if (NILP (buffer))
-    return BVAR (current_buffer, filename);
-  CHECK_BUFFER (buffer);
-  return BVAR (XBUFFER (buffer), filename);
+  return BVAR (decode_buffer (buffer), filename);
 }
 
 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer, Sbuffer_base_buffer,
@@ -1158,21 +1152,8 @@ If BUFFER is not indirect, return nil.
 BUFFER defaults to the current buffer.  */)
   (register Lisp_Object buffer)
 {
-  struct buffer *base;
-  Lisp_Object base_buffer;
-
-  if (NILP (buffer))
-    base = current_buffer->base_buffer;
-  else
-    {
-      CHECK_BUFFER (buffer);
-      base = XBUFFER (buffer)->base_buffer;
-    }
-
-  if (! base)
-    return Qnil;
-  XSETBUFFER (base_buffer, base);
-  return base_buffer;
+  struct buffer *base = decode_buffer (buffer)->base_buffer;
+  return base ? (XSETBUFFER (buffer, base), buffer) : Qnil;
 }
 
 DEFUN ("buffer-local-value", Fbuffer_local_value,
@@ -1295,20 +1276,10 @@ Most elements look like (SYMBOL . VALUE), describing one variable.
 For a symbol that is locally unbound, just the symbol appears in the value.
 Note that storing new VALUEs in these elements doesn't change the variables.
 No argument or nil as argument means use current buffer as BUFFER.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
-  register struct buffer *buf;
-  register Lisp_Object result;
-
-  if (NILP (buffer))
-    buf = current_buffer;
-  else
-    {
-      CHECK_BUFFER (buffer);
-      buf = XBUFFER (buffer);
-    }
-
-  result = buffer_lisp_local_variables (buf, 0);
+  struct buffer *buf = decode_buffer (buffer);
+  Lisp_Object result = buffer_lisp_local_variables (buf, 0);
 
   /* Add on all the variables stored in special slots.  */
   {
@@ -1335,17 +1306,9 @@ DEFUN ("buffer-modified-p", Fbuffer_modified_p, Sbuffer_modified_p,
        0, 1, 0,
        doc: /* Return t if BUFFER was modified since its file was last read or saved.
 No argument or nil as argument means use current buffer as BUFFER.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
-  register struct buffer *buf;
-  if (NILP (buffer))
-    buf = current_buffer;
-  else
-    {
-      CHECK_BUFFER (buffer);
-      buf = XBUFFER (buffer);
-    }
-
+  struct buffer *buf = decode_buffer (buffer);
   return BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf) ? Qt : Qnil;
 }
 
@@ -1451,16 +1414,7 @@ text in that buffer is changed.  It wraps around occasionally.
 No argument or nil as argument means use current buffer as BUFFER.  */)
   (register Lisp_Object buffer)
 {
-  register struct buffer *buf;
-  if (NILP (buffer))
-    buf = current_buffer;
-  else
-    {
-      CHECK_BUFFER (buffer);
-      buf = XBUFFER (buffer);
-    }
-
-  return make_number (BUF_MODIFF (buf));
+  return make_number (BUF_MODIFF (decode_buffer (buffer)));
 }
 
 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick,
@@ -1475,16 +1429,7 @@ between these calls.  No argument or nil as argument means use current
 buffer as BUFFER.  */)
   (register Lisp_Object buffer)
 {
-  register struct buffer *buf;
-  if (NILP (buffer))
-    buf = current_buffer;
-  else
-    {
-      CHECK_BUFFER (buffer);
-      buf = XBUFFER (buffer);
-    }
-
-  return make_number (BUF_CHARS_MODIFF (buf));
+  return make_number (BUF_CHARS_MODIFF (decode_buffer (buffer)));
 }
 
 DEFUN ("rename-buffer", Frename_buffer, Srename_buffer, 1, 2,
@@ -1564,7 +1509,7 @@ frame's buffer list.
 The buffer is found by scanning the selected or specified frame's buffer
 list first, followed by the list of all buffers.  If no other buffer
 exists, return the buffer `*scratch*' (creating it if necessary).  */)
-  (register Lisp_Object buffer, Lisp_Object visible_ok, Lisp_Object frame)
+  (Lisp_Object buffer, Lisp_Object visible_ok, Lisp_Object frame)
 {
   struct frame *f = decode_any_frame (frame);
   Lisp_Object tail = f->buffer_list, pred = f->buffer_predicate;
@@ -1607,10 +1552,11 @@ exists, return the buffer `*scratch*' (creating it if necessary).  */)
     return notsogood;
   else
     {
-      buf = Fget_buffer (build_string ("*scratch*"));
+      AUTO_STRING (scratch, "*scratch*");
+      buf = Fget_buffer (scratch);
       if (NILP (buf))
         {
-          buf = Fget_buffer_create (build_string ("*scratch*"));
+          buf = Fget_buffer_create (scratch);
           Fset_buffer_major_mode (buf);
         }
       return buf;
@@ -1630,10 +1576,11 @@ other_buffer_safely (Lisp_Object buffer)
     if (candidate_buffer (buf, buffer))
       return buf;
 
-  buf = Fget_buffer (build_string ("*scratch*"));
+  AUTO_STRING (scratch, "*scratch*");
+  buf = Fget_buffer (scratch);
   if (NILP (buf))
     {
-      buf = Fget_buffer_create (build_string ("*scratch*"));
+      buf = Fget_buffer_create (scratch);
       Fset_buffer_major_mode (buf);
     }
 
@@ -3108,13 +3055,15 @@ mouse_face_overlay_overlaps (Lisp_Object overlay)
   ptrdiff_t end = OVERLAY_POSITION (OVERLAY_END (overlay));
   ptrdiff_t n, i, size;
   Lisp_Object *v, tem;
+  Lisp_Object vbuf[10];
+  USE_SAFE_ALLOCA;
 
-  size = 10;
-  v = alloca (size * sizeof *v);
+  size = ARRAYELTS (vbuf);
+  v = vbuf;
   n = overlays_in (start, end, 0, &v, &size, NULL, NULL);
   if (n > size)
     {
-      v = alloca (n * sizeof *v);
+      SAFE_NALLOCA (v, 1, n);
       overlays_in (start, end, 0, &v, &n, NULL, NULL);
     }
 
@@ -3124,6 +3073,7 @@ mouse_face_overlay_overlaps (Lisp_Object overlay)
             !NILP (tem)))
       break;
 
+  SAFE_FREE ();
   return i < n;
 }
 
@@ -4137,17 +4087,7 @@ BUFFER omitted or nil means delete all overlays of the current
 buffer.  */)
   (Lisp_Object buffer)
 {
-  register struct buffer *buf;
-
-  if (NILP (buffer))
-    buf = current_buffer;
-  else
-    {
-      CHECK_BUFFER (buffer);
-      buf = XBUFFER (buffer);
-    }
-
-  delete_all_overlays (buf);
+  delete_all_overlays (decode_buffer (buffer));
   return Qnil;
 }
 
@@ -4582,13 +4522,13 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
        First copy the vector contents, in case some of these hooks
        do subsequent modification of the buffer.  */
     ptrdiff_t size = last_overlay_modification_hooks_used;
-    Lisp_Object *copy = alloca (size * sizeof *copy);
+    Lisp_Object *copy;
     ptrdiff_t i;
 
+    USE_SAFE_ALLOCA;
+    SAFE_ALLOCA_LISP (copy, size);
     memcpy (copy, XVECTOR (last_overlay_modification_hooks)->contents,
             size * word_size);
-    gcpro1.var = copy;
-    gcpro1.nvars = size;
 
     for (i = 0; i < size;)
       {
@@ -4597,6 +4537,8 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
         overlay_i = copy[i++];
         call_overlay_mod_hooks (prop_i, overlay_i, after, arg1, arg2, arg3);
       }
+
+    SAFE_FREE ();
   }
   UNGCPRO;
 }
@@ -5346,10 +5288,11 @@ init_buffer (int initialized)
     }
 #else  /* not USE_MMAP_FOR_BUFFERS */
   /* Avoid compiler warnings.  */
-  initialized = initialized;
+  (void) initialized;
 #endif /* USE_MMAP_FOR_BUFFERS */
 
-  Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
+  AUTO_STRING (scratch, "*scratch*");
+  Fset_buffer (Fget_buffer_create (scratch));
   if (NILP (BVAR (&buffer_defaults, enable_multibyte_characters)))
     Fset_buffer_multibyte (Qnil);
 
@@ -5386,9 +5329,12 @@ init_buffer (int initialized)
          However, it is not necessary to turn / into /:/.
          So avoid doing that.  */
       && strcmp ("/", SSDATA (BVAR (current_buffer, directory))))
-    bset_directory
-      (current_buffer,
-       concat2 (build_string ("/:"), BVAR (current_buffer, directory)));
+    {
+      AUTO_STRING (slash_colon, "/:");
+      bset_directory (current_buffer,
+                      concat2 (slash_colon,
+                               BVAR (current_buffer, directory)));
+    }
 
   temp = get_minibuffer (0);
   bset_directory (XBUFFER (temp), BVAR (current_buffer, directory));
@@ -5451,6 +5397,7 @@ syms_of_buffer (void)
   staticpro (&Qpermanent_local);
   staticpro (&Qkill_buffer_hook);
 
+  DEFSYM (Qchoice, "choice");
   DEFSYM (Qleft, "left");
   DEFSYM (Qright, "right");
   DEFSYM (Qrange, "range");
@@ -5978,13 +5925,13 @@ in a window.  To make the change take effect, call `set-window-buffer'.  */);
 
   DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer, scroll_bar_width),
                      Qintegerp,
-                     doc: /* Width of this buffer's scroll bars in pixels.
+                     doc: /* Width of this buffer's vertical scroll bars in pixels.
 A value of nil means to use the scroll bar width from the window's frame.  */);
 
   DEFVAR_PER_BUFFER ("scroll-bar-height", &BVAR (current_buffer, scroll_bar_height),
                      Qintegerp,
-                     doc: /* Height of this buffer's scroll bars in pixels.
-A value of nil means to use the scroll bar heiht from the window's frame.  */);
+                     doc: /* Height of this buffer's horizontal scroll bars in pixels.
+A value of nil means to use the scroll bar height from the window's frame.  */);
 
   DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer, vertical_scroll_bar_type),
                      Qvertical_scroll_bar,
@@ -6003,7 +5950,7 @@ The value takes effect whenever you tell a window to display this buffer;
 for instance, with `set-window-buffer' or when `display-buffer' displays it.
 
 A value of `bottom' means put the horizontal scroll bar at the bottom of
-the window; a value of nil means don't show any horizonal scroll bars.
+the window; a value of nil means don't show any horizontal scroll bars.
 A value of t (the default) means do whatever the window's frame
 specifies.  */);
 
diff --git a/src/buffer.h b/src/buffer.h
index fd989925976..284cfa7b4a8 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -1088,6 +1088,14 @@ extern void mmap_set_vars (bool);
 extern void restore_buffer (Lisp_Object);
 extern void set_buffer_if_live (Lisp_Object);
 
+/* Return B as a struct buffer pointer, defaulting to the current buffer.  */
+
+INLINE struct buffer *
+decode_buffer (Lisp_Object b)
+{
+  return NILP (b) ? current_buffer : (CHECK_BUFFER (b), XBUFFER (b));
+}
+
 /* Set the current buffer to B.
 
    We previously set windows_or_buffers_changed here to invalidate
@@ -1120,15 +1128,15 @@ record_unwind_current_buffer (void)
 #define GET_OVERLAYS_AT(posn, overlays, noverlays, nextp, chrq)         \
   do {                                                                  \
     ptrdiff_t maxlen = 40;                                              \
-    overlays = alloca (maxlen * sizeof *overlays);                      \
-    noverlays = overlays_at (posn, false, &overlays, &maxlen,           \
-                             nextp, NULL, chrq);                        \
-    if (noverlays > maxlen)                                             \
+    SAFE_NALLOCA (overlays, 1, maxlen);                                 \
+    (noverlays) = overlays_at (posn, false, &(overlays), &maxlen,       \
+                               nextp, NULL, chrq);                      \
+    if ((noverlays) > maxlen)                                           \
       {                                                                 \
         maxlen = noverlays;                                             \
-        overlays = alloca (maxlen * sizeof *overlays);                  \
-        noverlays = overlays_at (posn, false, &overlays, &maxlen,       \
-                                 nextp, NULL, chrq);                    \
+        SAFE_NALLOCA (overlays, 1, maxlen);                             \
+        (noverlays) = overlays_at (posn, false, &(overlays), &maxlen,   \
+                                   nextp, NULL, chrq);                  \
       }                                                                 \
   } while (false)
 
diff --git a/src/bytecode.c b/src/bytecode.c
index ca6681f21e9..d3c8b470cc3 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -36,8 +36,10 @@ by Hallvard:
 #include <config.h>
 
 #include "lisp.h"
+#include "blockinput.h"
 #include "character.h"
 #include "buffer.h"
+#include "keyboard.h"
 #include "syntax.h"
 #include "window.h"
 
@@ -1106,9 +1108,6 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           goto pushhandler;
         CASE (Bpushconditioncase): /* New in 24.4.  */
           {
-            extern EMACS_INT lisp_eval_depth;
-            extern int poll_suppress_count;
-            extern int interrupt_input_blocked;
             struct handler *c;
             Lisp_Object tag;
             int dest;
diff --git a/src/callint.c b/src/callint.c
index 817f84d897b..9a4573c77be 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -297,6 +297,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
   Lisp_Object teml;
   Lisp_Object up_event;
   Lisp_Object enable;
+  USE_SAFE_ALLOCA;
   ptrdiff_t speccount = SPECPDL_INDEX ();
 
   /* The index of the next element of this_command_keys to examine for
@@ -366,12 +367,8 @@ invoke it.  If KEYS is omitted or nil, the return value of
       wrong_type_argument (Qcommandp, function);
   }
 
-  /* 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 = xlispstrdupa (specs);
-  else
+  /* If SPECS is not a string, invent one.  */
+  if (! STRINGP (specs))
     {
       Lisp_Object input;
       Lisp_Object funval = Findirect_function (function, Qt);
@@ -416,10 +413,16 @@ invoke it.  If KEYS is omitted or nil, the return value of
         args[0] = Qfuncall_interactively;
         args[1] = function;
         args[2] = specs;
-        return unbind_to (speccount, Fapply (3, args));
+        Lisp_Object result = unbind_to (speccount, Fapply (3, args));
+        SAFE_FREE ();
+        return result;
       }
     }
 
+  /* SPECS is set to a string; use it as an interactive prompt.
+     Copy it so that STRING will be valid even if a GC relocates SPECS.  */
+  SAFE_ALLOCA_STRING (string, specs);
+
   /* Here if function specifies a string to control parsing the defaults.  */
 
   /* Set next_event to point to the first event with parameters.  */
@@ -507,14 +510,15 @@ invoke it.  If KEYS is omitted or nil, the return value of
         break;
     }
 
-  if (min (MOST_POSITIVE_FIXNUM,
-           min (PTRDIFF_MAX, SIZE_MAX) / word_size)
-      < nargs)
+  if (MOST_POSITIVE_FIXNUM < min (PTRDIFF_MAX, SIZE_MAX) / word_size
+      && MOST_POSITIVE_FIXNUM < nargs)
     memory_full (SIZE_MAX);
 
-  args = alloca (nargs * sizeof *args);
-  visargs = alloca (nargs * sizeof *visargs);
-  varies = alloca (nargs * sizeof *varies);
+  /* Allocate them all at one go.  This wastes a bit of memory, but
+     it's OK to trade space for speed.  */
+  SAFE_NALLOCA (args, 3, nargs);
+  visargs = args + nargs;
+  varies = (signed char *) (visargs + nargs);
 
   for (i = 0; i < nargs; i++)
     {
@@ -871,7 +875,9 @@ invoke it.  If KEYS is omitted or nil, the return value of
   {
     Lisp_Object val = Ffuncall (nargs, args);
     UNGCPRO;
-    return unbind_to (speccount, val);
+    val = unbind_to (speccount, val);
+    SAFE_FREE ();
+    return val;
   }
 }
 
diff --git a/src/callproc.c b/src/callproc.c
index 2f68ea6f328..e3dcc7bbcca 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -129,7 +129,7 @@ encode_current_directory (void)
 
   if (STRING_MULTIBYTE (dir))
     dir = ENCODE_FILE (dir);
-  if (! file_accessible_directory_p (SSDATA (dir)))
+  if (! file_accessible_directory_p (dir))
     report_file_error ("Setting current directory",
                        BVAR (current_buffer, directory));
 
@@ -466,7 +466,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
       && SREF (path, 1) == ':')
     path = Fsubstring (path, make_number (2), Qnil);
 
-  new_argv = SAFE_ALLOCA ((nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv);
+  SAFE_NALLOCA (new_argv, 1, nargs < 4 ? 2 : nargs - 2);
 
   {
     struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
@@ -632,6 +632,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
     int volatile fd_error_volatile = fd_error;
     int volatile filefd_volatile = filefd;
     ptrdiff_t volatile count_volatile = count;
+    ptrdiff_t volatile sa_avail_volatile = sa_avail;
     ptrdiff_t volatile sa_count_volatile = sa_count;
     char **volatile new_argv_volatile = new_argv;
     int volatile callproc_fd_volatile[CALLPROC_FDS];
@@ -648,6 +649,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
     fd_error = fd_error_volatile;
     filefd = filefd_volatile;
     count = count_volatile;
+    sa_avail = sa_avail_volatile;
     sa_count = sa_count_volatile;
     new_argv = new_argv_volatile;
 
@@ -1151,6 +1153,39 @@ add_env (char **env, char **new_env, char *string)
   return new_env;
 }
 
+#ifndef DOS_NT
+
+/* 'exec' failed inside a child running NAME, with error number ERR.
+   Possibly a vforked child needed to allocate a large vector on the
+   stack; such a child cannot fall back on malloc because that might
+   mess up the allocator's data structures in the parent.
+   Report the error and exit the child.  */
+
+static _Noreturn void
+exec_failed (char const *name, int err)
+{
+  /* Avoid deadlock if the child's perror writes to a full pipe; the
+     pipe's reader is the parent, but with vfork the parent can't
+     run until the child exits.  Truncate the diagnostic instead.  */
+  fcntl (STDERR_FILENO, F_SETFL, O_NONBLOCK);
+
+  errno = err;
+  emacs_perror (name);
+  _exit (err == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
+}
+
+#else
+
+/* Do nothing.  There is no need to fail, as DOS_NT platforms do not
+   fork and exec, and handle alloca exhaustion in a different way.  */
+
+static void
+exec_failed (char const *name, int err)
+{
+}
+
+#endif
+
 /* This is the last thing run in a newly forked inferior
    either synchronous or asynchronous.
    Copy descriptors IN, OUT and ERR as descriptors 0, 1 and 2.
@@ -1174,8 +1209,6 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
   int cpid;
   HANDLE handles[3];
 #else
-  int exec_errno;
-
   pid_t pid = getpid ();
 #endif /* WINDOWSNT */
 
@@ -1196,11 +1229,13 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
        on that.  */
     pwd_var = xmalloc (i + 5);
 #else
+    if (MAX_ALLOCA - 5 < i)
+      exec_failed (new_argv[0], ENOMEM);
     pwd_var = alloca (i + 5);
 #endif
     temp = pwd_var + 4;
     memcpy (pwd_var, "PWD=", 4);
-    strcpy (temp, SSDATA (current_dir));
+    lispstpcpy (temp, current_dir);
 
 #ifndef DOS_NT
     /* We can't signal an Elisp error here; we're in a vfork.  Since
@@ -1262,6 +1297,8 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
       }
 
     /* new_length + 2 to include PWD and terminating 0.  */
+    if (MAX_ALLOCA / sizeof *env - 2 < new_length)
+      exec_failed (new_argv[0], ENOMEM);
     env = new_env = alloca ((new_length + 2) * sizeof *env);
     /* If we have a PWD envvar, pass one down,
        but with corrected value.  */
@@ -1270,7 +1307,11 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
 
     if (STRINGP (display))
       {
-        char *vdata = alloca (sizeof "DISPLAY=" + SBYTES (display));
+        char *vdata;
+
+        if (MAX_ALLOCA - sizeof "DISPLAY=" < SBYTES (display))
+          exec_failed (new_argv[0], ENOMEM);
+        vdata = alloca (sizeof "DISPLAY=" + SBYTES (display));
         strcpy (vdata, "DISPLAY=");
         strcat (vdata, SSDATA (display));
         new_env = add_env (env, new_env, vdata);
@@ -1345,16 +1386,7 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
   tcsetpgrp (0, pid);
 
   execve (new_argv[0], new_argv, env);
-  exec_errno = errno;
-
-  /* Avoid deadlock if the child's perror writes to a full pipe; the
-     pipe's reader is the parent, but with vfork the parent can't
-     run until the child exits.  Truncate the diagnostic instead.  */
-  fcntl (STDERR_FILENO, F_SETFL, O_NONBLOCK);
-
-  errno = exec_errno;
-  emacs_perror (new_argv[0]);
-  _exit (exec_errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
+  exec_failed (new_argv[0], errno);
 
 #else /* MSDOS */
   pid = run_msdos_command (new_argv, pwd_var + 4, in, out, err, env);
@@ -1488,14 +1520,14 @@ If optional parameter ENV is a list, then search this list instead of
 }
 
 /* A version of getenv that consults the Lisp environment lists,
-   easily callable from C.  */
+   easily callable from C.  This is usually called from egetenv.  */
 char *
-egetenv (const char *var)
+egetenv_internal (const char *var, ptrdiff_t len)
 {
   char *value;
   ptrdiff_t valuelen;
 
-  if (getenv_internal (var, strlen (var), &value, &valuelen, Qnil))
+  if (getenv_internal (var, len, &value, &valuelen, Qnil))
     return value;
   else
     return 0;
@@ -1543,20 +1575,13 @@ init_callproc_1 (void)
 void
 init_callproc (void)
 {
-  char *data_dir = egetenv ("EMACSDATA");
+  bool data_dir = egetenv ("EMACSDATA") != 0;
 
-  register char * sh;
+  char *sh;
   Lisp_Object tempdir;
 #ifdef HAVE_NS
   if (data_dir == 0)
-    {
-      const char *etc_dir = ns_etc_directory ();
-      if (etc_dir)
-        {
-          data_dir = alloca (strlen (etc_dir) + 1);
-          strcpy (data_dir, etc_dir);
-        }
-    }
+    data_dir = ns_etc_directory () != 0;
 #endif
 
   if (!NILP (Vinstallation_directory))
@@ -1625,12 +1650,12 @@ init_callproc (void)
 #endif
     {
       tempdir = Fdirectory_file_name (Vexec_directory);
-      if (! file_accessible_directory_p (SSDATA (tempdir)))
+      if (! file_accessible_directory_p (tempdir))
         dir_warning ("arch-dependent data dir", Vexec_directory);
     }
 
   tempdir = Fdirectory_file_name (Vdata_directory);
-  if (! file_accessible_directory_p (SSDATA (tempdir)))
+  if (! file_accessible_directory_p (tempdir))
     dir_warning ("arch-independent data dir", Vdata_directory);
 
   sh = getenv ("SHELL");
diff --git a/src/category.c b/src/category.c
index 851ae1a4c24..a4610e4d358 100644
--- a/src/category.c
+++ b/src/category.c
@@ -96,7 +96,7 @@ those categories.  */)
   (Lisp_Object categories)
 {
   Lisp_Object val;
-  int len;
+  ptrdiff_t len;
 
   CHECK_STRING (categories);
   val = MAKE_CATEGORY_SET;
diff --git a/src/character.h b/src/character.h
index 66cd4e47ef8..624f4fff3f0 100644
--- a/src/character.h
+++ b/src/character.h
@@ -644,8 +644,6 @@ extern int string_char (const unsigned char *,
                         const unsigned char **, int *);
 
 extern int translate_char (Lisp_Object, int c);
-extern void parse_str_as_multibyte (const unsigned char *,
-                                    ptrdiff_t, ptrdiff_t *, ptrdiff_t *);
 extern ptrdiff_t count_size_as_multibyte (const unsigned char *, ptrdiff_t);
 extern ptrdiff_t str_as_multibyte (unsigned char *, ptrdiff_t, ptrdiff_t,
                                    ptrdiff_t *);
diff --git a/src/charset.c b/src/charset.c
index 341ac356aff..171a00f23d1 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -485,14 +485,12 @@ load_charset_map_from_file (struct charset *charset, Lisp_Object mapfile,
   unsigned max_code = CHARSET_MAX_CODE (charset);
   int fd;
   FILE *fp;
-  Lisp_Object suffixes;
   struct charset_map_entries *head, *entries;
   int n_entries;
-  ptrdiff_t count;
-
-  suffixes = list2 (build_string (".map"), build_string (".TXT"));
-
-  count = SPECPDL_INDEX ();
+  AUTO_STRING (map, ".map");
+  AUTO_STRING (txt, ".txt");
+  AUTO_LIST2 (suffixes, map, txt);
+  ptrdiff_t count = SPECPDL_INDEX ();
   record_unwind_protect_nothing ();
   specbind (Qfile_name_handler_alist, Qnil);
   fd = openp (Vcharset_map_path, mapfile, suffixes, NULL, Qnil, false);
@@ -667,12 +665,8 @@ map_charset_for_dump (void (*c_function) (Lisp_Object, Lisp_Object),
 {
   int from_idx = CODE_POINT_TO_INDEX (temp_charset_work->current, from);
   int to_idx = CODE_POINT_TO_INDEX (temp_charset_work->current, to);
-  Lisp_Object range;
+  Lisp_Object range = Fcons (Qnil, Qnil);
   int c, stop;
-  struct gcpro gcpro1;
-
-  range = Fcons (Qnil, Qnil);
-  GCPRO1 (range);
 
   c = temp_charset_work->min_char;
   stop = (temp_charset_work->max_char < 0x20000
@@ -715,7 +709,6 @@ map_charset_for_dump (void (*c_function) (Lisp_Object, Lisp_Object),
         }
       c++;
     }
-  UNGCPRO;
 }
 
 void
@@ -1400,6 +1393,32 @@ Optional third argument DEUNIFY, if non-nil, means to de-unify CHARSET.  */)
   return Qnil;
 }
 
+/* Check that DIMENSION, CHARS, and FINAL_CHAR specify a valid ISO charset.
+   Return true if it's a 96-character set, false if 94.  */
+
+static bool
+check_iso_charset_parameter (Lisp_Object dimension, Lisp_Object chars,
+                             Lisp_Object final_char)
+{
+  CHECK_NUMBER (dimension);
+  CHECK_NUMBER (chars);
+  CHECK_CHARACTER (final_char);
+
+  if (! (1 <= XINT (dimension) && XINT (dimension) <= 3))
+    error ("Invalid DIMENSION %"pI"d, it should be 1, 2, or 3",
+           XINT (dimension));
+
+  bool chars_flag = XINT (chars) == 96;
+  if (! (chars_flag || XINT (chars) == 94))
+    error ("Invalid CHARS %"pI"d, it should be 94 or 96", XINT (chars));
+
+  int final_ch = XFASTINT (final_char);
+  if (! ('0' <= final_ch && final_ch <= '~'))
+    error ("Invalid FINAL-CHAR '%c', it should be '0'..'~'", final_ch);
+
+  return chars_flag;
+}
+
 DEFUN ("get-unused-iso-final-char", Fget_unused_iso_final_char,
        Sget_unused_iso_final_char, 2, 2, 0,
        doc: /*
@@ -1412,35 +1431,12 @@ If there's no unused final char for the specified kind of charset,
 return nil.  */)
   (Lisp_Object dimension, Lisp_Object chars)
 {
-  int final_char;
-
-  CHECK_NUMBER (dimension);
-  CHECK_NUMBER (chars);
-  if (XINT (dimension) != 1 && XINT (dimension) != 2 && XINT (dimension) != 3)
-    args_out_of_range_3 (dimension, make_number (1), make_number (3));
-  if (XINT (chars) != 94 && XINT (chars) != 96)
-    args_out_of_range_3 (chars, make_number (94), make_number (96));
-  for (final_char = '0'; final_char <= '?'; final_char++)
-    if (ISO_CHARSET_TABLE (XINT (dimension), XINT (chars), final_char) < 0)
-      break;
-  return (final_char <= '?' ? make_number (final_char) : Qnil);
-}
-
-static void
-check_iso_charset_parameter (Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char)
-{
-  CHECK_NATNUM (dimension);
-  CHECK_NATNUM (chars);
-  CHECK_CHARACTER (final_char);
-
-  if (XINT (dimension) > 3)
-    error ("Invalid DIMENSION %"pI"d, it should be 1, 2, or 3",
-           XINT (dimension));
-  if (XINT (chars) != 94 && XINT (chars) != 96)
-    error ("Invalid CHARS %"pI"d, it should be 94 or 96", XINT (chars));
-  if (XINT (final_char) < '0' || XINT (final_char) > '~')
-    error ("Invalid FINAL-CHAR %c, it should be `0'..`~'",
-           (int)XINT (final_char));
+  bool chars_flag = check_iso_charset_parameter (dimension, chars,
+                                                 make_number ('0'));
+  for (int final_char = '0'; final_char <= '?'; final_char++)
+    if (ISO_CHARSET_TABLE (XINT (dimension), chars_flag, final_char) < 0)
+      return make_number (final_char);
+  return Qnil;
 }
 
 
@@ -1454,12 +1450,10 @@ if CHARSET is designated instead.  */)
   (Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char, Lisp_Object charset)
 {
   int id;
-  bool chars_flag;
 
   CHECK_CHARSET_GET_ID (charset, id);
-  check_iso_charset_parameter (dimension, chars, final_char);
-  chars_flag = XINT (chars) == 96;
-  ISO_CHARSET_TABLE (XINT (dimension), chars_flag, XINT (final_char)) = id;
+  bool chars_flag = check_iso_charset_parameter (dimension, chars, final_char);
+  ISO_CHARSET_TABLE (XINT (dimension), chars_flag, XFASTINT (final_char)) = id;
   return Qnil;
 }
 
@@ -2113,13 +2107,9 @@ See the documentation of the function `charset-info' for the meanings of
 DIMENSION, CHARS, and FINAL-CHAR.  */)
   (Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char)
 {
-  int id;
-  bool chars_flag;
-
-  check_iso_charset_parameter (dimension, chars, final_char);
-  chars_flag = XFASTINT (chars) == 96;
-  id = ISO_CHARSET_TABLE (XFASTINT (dimension), chars_flag,
-                          XFASTINT (final_char));
+  bool chars_flag = check_iso_charset_parameter (dimension, chars, final_char);
+  int id = ISO_CHARSET_TABLE (XINT (dimension), chars_flag,
+                              XFASTINT (final_char));
   return (id >= 0 ? CHARSET_NAME (CHARSET_FROM_ID (id)) : Qnil);
 }
 
@@ -2298,7 +2288,7 @@ init_charset (void)
 {
   Lisp_Object tempdir;
   tempdir = Fexpand_file_name (build_string ("charsets"), Vdata_directory);
-  if (! file_accessible_directory_p (SSDATA (tempdir)))
+  if (! file_accessible_directory_p (tempdir))
     {
       /* This used to be non-fatal (dir_warning), but it should not
          happen, and if it does sooner or later it will cause some
diff --git a/src/chartab.c b/src/chartab.c
index 50be063759a..bfbbf798f0c 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -1258,13 +1258,8 @@ uniprop_encode_value_numeric (Lisp_Object table, Lisp_Object value)
       break;
   value = make_number (i);
   if (i == size)
-    {
-      Lisp_Object args[2];
-
-      args[0] = XCHAR_TABLE (table)->extras[4];
-      args[1] = Fmake_vector (make_number (1), value);
-      set_char_table_extras (table, 4, Fvconcat (2, args));
-    }
+    set_char_table_extras (table, 4, Fvconcat (2, ((Lisp_Object []) {
+      XCHAR_TABLE (table)->extras[4], Fmake_vector (make_number (1), value) })));
   return make_number (i);
 }
 
@@ -1307,8 +1302,8 @@ uniprop_table (Lisp_Object prop)
     {
       struct gcpro gcpro1;
       GCPRO1 (val);
-      result = Fload (concat2 (build_string ("international/"), table),
-                      Qt, Qt, Qt, Qt);
+      AUTO_STRING (intl, "international/");
+      result = Fload (concat2 (intl, table), Qt, Qt, Qt, Qt);
       UNGCPRO;
       if (NILP (result))
         return Qnil;
diff --git a/src/coding.c b/src/coding.c
index 8b620af8695..e4b52f6db48 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -642,15 +642,6 @@ static enum coding_category coding_priorities[coding_category_max];
    Nth coding category.  */
 static struct coding_system coding_categories[coding_category_max];
 
-/*** Commonly used macros and functions ***/
-
-#ifndef min
-#define min(a, b) ((a) < (b) ? (a) : (b))
-#endif
-#ifndef max
-#define max(a, b) ((a) > (b) ? (a) : (b))
-#endif
-
 /* Encode a flag that can be nil, something else, or t as -1, 0, 1.  */
 
 static int
@@ -690,6 +681,14 @@ CHECK_NATNUM_CDR (Lisp_Object x)
   XSETCDR (x, tmp);
 }
 
+/* True if CODING's destination can be grown.  */
+
+static bool
+growable_destination (struct coding_system *coding)
+{
+  return STRINGP (coding->dst_object) || BUFFERP (coding->dst_object);
+}
+
 
 /* Safely get one byte from the source text pointed by SRC which ends
    at SRC_END, and set C to that byte.  If there are not enough bytes
@@ -3074,8 +3073,13 @@ detect_coding_iso_2022 (struct coding_system *coding,
                   ONE_MORE_BYTE (c1);
                   if (c1 < ' ' || c1 >= 0x80
                       || (id = iso_charset_table[0][c >= ','][c1]) < 0)
-                    /* Invalid designation sequence.  Just ignore.  */
-                    break;
+                    {
+                      /* Invalid designation sequence.  Just ignore.  */
+                      if (c1 >= 0x80)
+                        rejected |= (CATEGORY_MASK_ISO_7BIT
+                                     | CATEGORY_MASK_ISO_7_ELSE);
+                      break;
+                    }
                 }
               else if (c == '$')
                 {
@@ -3089,16 +3093,29 @@ detect_coding_iso_2022 (struct coding_system *coding,
                       ONE_MORE_BYTE (c1);
                       if (c1 < ' ' || c1 >= 0x80
                           || (id = iso_charset_table[1][c >= ','][c1]) < 0)
-                        /* Invalid designation sequence.  Just ignore.  */
-                        break;
+                        {
+                          /* Invalid designation sequence.  Just ignore.  */
+                          if (c1 >= 0x80)
+                            rejected |= (CATEGORY_MASK_ISO_7BIT
+                                         | CATEGORY_MASK_ISO_7_ELSE);
+                          break;
+                        }
                     }
                   else
-                    /* Invalid designation sequence.  Just ignore it.  */
-                    break;
+                    {
+                      /* Invalid designation sequence.  Just ignore it.  */
+                      if (c >= 0x80)
+                        rejected |= (CATEGORY_MASK_ISO_7BIT
+                                     | CATEGORY_MASK_ISO_7_ELSE);
+                      break;
+                    }
                 }
               else
                 {
                   /* Invalid escape sequence.  Just ignore it.  */
+                  if (c >= 0x80)
+                    rejected |= (CATEGORY_MASK_ISO_7BIT
+                                 | CATEGORY_MASK_ISO_7_ELSE);
                   break;
                 }
 
@@ -3149,7 +3166,7 @@ detect_coding_iso_2022 (struct coding_system *coding,
           if (inhibit_iso_escape_detection)
             break;
           single_shifting = 0;
-          rejected |= CATEGORY_MASK_ISO_7BIT;
+          rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_7_ELSE;
           if (CODING_ISO_FLAGS (&coding_categories[coding_category_iso_8_1])
               & CODING_ISO_FLAG_SINGLE_SHIFT)
             {
@@ -3176,9 +3193,9 @@ detect_coding_iso_2022 (struct coding_system *coding,
               single_shifting = 0;
               break;
             }
+          rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_7_ELSE;
           if (c >= 0xA0)
             {
-              rejected |= CATEGORY_MASK_ISO_7BIT | CATEGORY_MASK_ISO_7_ELSE;
               found |= CATEGORY_MASK_ISO_8_1;
               /* Check the length of succeeding codes of the range
                  0xA0..0FF.  If the byte length is even, we include
@@ -6867,6 +6884,11 @@ decode_eol (struct coding_system *coding)
 }
 
 
+/* MAX_LOOKUP's maximum value.  MAX_LOOKUP is an int and so cannot
+   exceed INT_MAX.  Also, MAX_LOOKUP is multiplied by sizeof (int) for
+   alloca, so it cannot exceed MAX_ALLOCA / sizeof (int).  */
+enum { MAX_LOOKUP_MAX = min (INT_MAX, MAX_ALLOCA / sizeof (int)) };
+
 /* Return a translation table (or list of them) from coding system
    attribute vector ATTRS for encoding (if ENCODEP) or decoding (if
    not ENCODEP). */
@@ -6919,7 +6941,7 @@ get_translation_table (Lisp_Object attrs, bool encodep, int *max_lookup)
         {
           val = XCHAR_TABLE (translation_table)->extras[1];
           if (NATNUMP (val) && *max_lookup < XFASTINT (val))
-            *max_lookup = XFASTINT (val);
+            *max_lookup = min (XFASTINT (val), MAX_LOOKUP_MAX);
         }
       else if (CONSP (translation_table))
         {
@@ -6931,7 +6953,7 @@ get_translation_table (Lisp_Object attrs, bool encodep, int *max_lookup)
               {
                 Lisp_Object tailval = XCHAR_TABLE (XCAR (tail))->extras[1];
                 if (NATNUMP (tailval) && *max_lookup < XFASTINT (tailval))
-                  *max_lookup = XFASTINT (tailval);
+                  *max_lookup = min (XFASTINT (tailval), MAX_LOOKUP_MAX);
               }
         }
     }
@@ -7014,8 +7036,10 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table,
       int *buf = coding->charbuf;
       int *buf_end = buf + coding->charbuf_used;
 
-      if (EQ (coding->src_object, coding->dst_object))
+      if (EQ (coding->src_object, coding->dst_object)
+          && ! NILP (coding->dst_object))
         {
+          eassert (growable_destination (coding));
           coding_set_source (coding);
           dst_end = ((unsigned char *) coding->source) + coding->consumed;
         }
@@ -7054,6 +7078,7 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table,
 
               if ((dst_end - dst) / MAX_MULTIBYTE_LENGTH < to_nchars)
                 {
+                  eassert (growable_destination (coding));
                   if (((min (PTRDIFF_MAX, SIZE_MAX) - (buf_end - buf))
                        / MAX_MULTIBYTE_LENGTH)
                       < to_nchars)
@@ -7098,7 +7123,10 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table,
       const unsigned char *src_end = src + coding->consumed;
 
       if (EQ (coding->dst_object, coding->src_object))
-        dst_end = (unsigned char *) src;
+        {
+          eassert (growable_destination (coding));
+          dst_end = (unsigned char *) src;
+        }
       if (coding->src_multibyte != coding->dst_multibyte)
         {
           if (coding->src_multibyte)
@@ -7114,6 +7142,7 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table,
                   ONE_MORE_BYTE (c);
                   if (dst == dst_end)
                     {
+                      eassert (growable_destination (coding));
                       if (EQ (coding->src_object, coding->dst_object))
                         dst_end = (unsigned char *) src;
                       if (dst == dst_end)
@@ -7144,6 +7173,7 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table,
 
                 if (dst >= dst_end - 1)
                   {
+                    eassert (growable_destination (coding));
                     if (EQ (coding->src_object, coding->dst_object))
                       dst_end = (unsigned char *) src;
                     if (dst >= dst_end - 1)
@@ -9729,7 +9759,7 @@ DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_intern
        doc: /* Internal use only.  */)
   (Lisp_Object coding_system, Lisp_Object terminal)
 {
-  struct terminal *term = get_terminal (terminal, 1);
+  struct terminal *term = decode_live_terminal (terminal);
   struct coding_system *terminal_coding = TERMINAL_TERMINAL_CODING (term);
   CHECK_SYMBOL (coding_system);
   setup_coding_system (Fcheck_coding_system (coding_system), terminal_coding);
@@ -9770,7 +9800,7 @@ frame's terminal device.  */)
   (Lisp_Object terminal)
 {
   struct coding_system *terminal_coding
-    = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
+    = TERMINAL_TERMINAL_CODING (decode_live_terminal (terminal));
   Lisp_Object coding_system = CODING_ID_NAME (terminal_coding->id);
 
   /* For backward compatibility, return nil if it is `undecided'.  */
@@ -9782,7 +9812,7 @@ DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_intern
        doc: /* Internal use only.  */)
   (Lisp_Object coding_system, Lisp_Object terminal)
 {
-  struct terminal *t = get_terminal (terminal, 1);
+  struct terminal *t = decode_live_terminal (terminal);
   CHECK_SYMBOL (coding_system);
   if (NILP (coding_system))
     coding_system = Qno_conversion;
@@ -9801,7 +9831,7 @@ DEFUN ("keyboard-coding-system",
   (Lisp_Object terminal)
 {
   return CODING_ID_NAME (TERMINAL_KEYBOARD_CODING
-                         (get_terminal (terminal, 1))->id);
+                         (decode_live_terminal (terminal))->id);
 }
 
 
@@ -10011,7 +10041,8 @@ make_subsidiaries (Lisp_Object base)
 {
   Lisp_Object subsidiaries;
   ptrdiff_t base_name_len = SBYTES (SYMBOL_NAME (base));
-  char *buf = alloca (base_name_len + 6);
+  USE_SAFE_ALLOCA;
+  char *buf = SAFE_ALLOCA (base_name_len + 6);
   int i;
 
   memcpy (buf, SDATA (SYMBOL_NAME (base)), base_name_len);
@@ -10021,6 +10052,7 @@ make_subsidiaries (Lisp_Object base)
       strcpy (buf + base_name_len, suffixes[i]);
       ASET (subsidiaries, i, intern (buf));
     }
+  SAFE_FREE ();
   return subsidiaries;
 }
 
diff --git a/src/composite.c b/src/composite.c
index 66a20759ec6..8982c904096 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -928,7 +928,7 @@ static bool
 char_composable_p (int c)
 {
   Lisp_Object val;
-  return (c > ' '                       
+  return (c > ' '
           && (c == 0x200C || c == 0x200D
               || (val = CHAR_TABLE_REF (Vunicode_category_table, c),
                   (INTEGERP (val) && (XINT (val) <= UNICODE_CATEGORY_So)))));
@@ -1016,24 +1016,19 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
           val = CHAR_TABLE_REF (Vcomposition_function_table, c);
           if (! NILP (val))
             {
-              Lisp_Object elt;
-              int ridx;
-
-              for (ridx = 0; CONSP (val); val = XCDR (val), ridx++)
+              for (int ridx = 0; CONSP (val); val = XCDR (val), ridx++)
                 {
-                  elt = XCAR (val);
+                  Lisp_Object elt = XCAR (val);
                   if (VECTORP (elt) && ASIZE (elt) == 3
                       && NATNUMP (AREF (elt, 1))
                       && charpos - 1 - XFASTINT (AREF (elt, 1)) >= start)
-                    break;
-                }
-              if (CONSP (val))
-                {
-                  cmp_it->rule_idx = ridx;
-                  cmp_it->lookback = XFASTINT (AREF (elt, 1));
-                  cmp_it->stop_pos = charpos - 1 - cmp_it->lookback;
-                  cmp_it->ch = c;
-                  return;
+                    {
+                      cmp_it->rule_idx = ridx;
+                      cmp_it->lookback = XFASTINT (AREF (elt, 1));
+                      cmp_it->stop_pos = charpos - 1 - cmp_it->lookback;
+                      cmp_it->ch = c;
+                      return;
+                    }
                 }
             }
         }
@@ -1724,7 +1719,7 @@ should be ignored.  */)
   if (! FONT_OBJECT_P (font_object))
     {
       struct coding_system *coding;
-      struct terminal *terminal = get_terminal (font_object, 1);
+      struct terminal *terminal = decode_live_terminal (font_object);
 
       coding = ((TERMINAL_TERMINAL_CODING (terminal)->common_flags
                  & CODING_REQUIRE_ENCODING_MASK)
diff --git a/src/conf_post.h b/src/conf_post.h
index a995acfd915..8667e2554cd 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -80,6 +80,23 @@ typedef bool bool_bf;
 #define vfork fork
 #endif  /* DARWIN_OS */
 
+/* If HYBRID_MALLOC is defined (e.g., on Cygwin), emacs will use
+   gmalloc before dumping and the system malloc after dumping.
+   hybrid_malloc and friends, defined in gmalloc.c, are wrappers that
+   accomplish this.  */
+#ifdef HYBRID_MALLOC
+#ifdef emacs
+#define malloc hybrid_malloc
+#define realloc hybrid_realloc
+#define calloc hybrid_calloc
+#define free hybrid_free
+#if defined HAVE_GET_CURRENT_DIR_NAME && !defined BROKEN_GET_CURRENT_DIR_NAME
+#define HYBRID_GET_CURRENT_DIR_NAME 1
+#define get_current_dir_name hybrid_get_current_dir_name
+#endif
+#endif
+#endif  /* HYBRID_MALLOC */
+
 /* We have to go this route, rather than the old hpux9 approach of
    renaming the functions via macros.  The system's stdlib.h has fully
    prototyped declarations, which yields a conflicting definition of
@@ -123,13 +140,6 @@ You lose; /* Emacs for DOS must be compiled with DJGPP */
    so we could reuse it in readlinkat; see msdos.c.  */
 #define opendir sys_opendir
 
-/* The "portable" definition of _GL_INLINE on config.h does not work
-   with DJGPP GCC 3.4.4: it causes unresolved externals in sysdep.c,
-   although lib/execinfo.h is included and the inline functions there
-   are visible.  */
-#if __GNUC__ < 4
-# define _GL_EXECINFO_INLINE inline
-#endif
 /* End of gnulib-related stuff.  */
 
 #define emacs_raise(sig) msdos_fatal_signal (sig)
@@ -183,6 +193,10 @@ extern void _DebPrint (const char *fmt, ...);
 #if defined CYGWIN && defined HAVE_NTGUI
 # define NTGUI_UNICODE /* Cygwin runs only on UNICODE-supporting systems */
 # define _WIN32_WINNT 0x500 /* Win2k */
+/* The following was in /usr/include/string.h prior to Cygwin 1.7.33.  */
+#ifndef strnicmp
+#define strnicmp strncasecmp
+#endif
 #endif
 
 #ifdef emacs /* Don't do this for lib-src.  */
diff --git a/src/data.c b/src/data.c
index 3e651414e68..9977a3aaadd 100644
--- a/src/data.c
+++ b/src/data.c
@@ -979,17 +979,21 @@ wrong_choice (Lisp_Object choice, Lisp_Object wrong)
 {
   ptrdiff_t i = 0, len = XINT (Flength (choice));
   Lisp_Object obj, *args;
+  AUTO_STRING (one_of, "One of ");
+  AUTO_STRING (comma, ", ");
+  AUTO_STRING (or, " or ");
+  AUTO_STRING (should_be_specified, " should be specified");
 
   USE_SAFE_ALLOCA;
   SAFE_ALLOCA_LISP (args, len * 2 + 1);
 
-  args[i++] = build_string ("One of ");
+  args[i++] = one_of;
 
   for (obj = choice; !NILP (obj); obj = XCDR (obj))
     {
       args[i++] = SYMBOL_NAME (XCAR (obj));
-      args[i++] = build_string (NILP (XCDR (obj)) ? " should be specified"
-                                : (NILP (XCDR (XCDR (obj))) ? " or " : ", "));
+      args[i++] = (NILP (XCDR (obj)) ? should_be_specified
+                   : NILP (XCDR (XCDR (obj))) ? or : comma);
     }
 
   obj = Fconcat (i, args);
@@ -1003,14 +1007,13 @@ wrong_choice (Lisp_Object choice, Lisp_Object wrong)
 static void
 wrong_range (Lisp_Object min, Lisp_Object max, Lisp_Object wrong)
 {
-  Lisp_Object args[4];
-
-  args[0] = build_string ("Value should be from ");
-  args[1] = Fnumber_to_string (min);
-  args[2] = build_string (" to ");
-  args[3] = Fnumber_to_string (max);
-
-  xsignal2 (Qerror, Fconcat (4, args), wrong);
+  AUTO_STRING (value_should_be_from, "Value should be from ");
+  AUTO_STRING (to, " to ");
+  xsignal2 (Qerror,
+            Fconcat (4, ((Lisp_Object [])
+                         {value_should_be_from, Fnumber_to_string (min),
+                          to, Fnumber_to_string (max)})),
+            wrong);
 }
 
 /* Store NEWVAL into SYMBOL, where VALCONTENTS is found in the value cell
@@ -1311,10 +1314,10 @@ set_internal (Lisp_Object symbol, Lisp_Object newval, Lisp_Object where,
 
             /* Find the new binding.  */
             XSETSYMBOL (symbol, sym); /* May have changed via aliasing.  */
-            tem1 = Fassq (symbol,
-                          (blv->frame_local
-                           ? XFRAME (where)->param_alist
-                           : BVAR (XBUFFER (where), local_var_alist)));
+            tem1 = assq_no_quit (symbol,
+                                 (blv->frame_local
+                                  ? XFRAME (where)->param_alist
+                                  : BVAR (XBUFFER (where), local_var_alist)));
             set_blv_where (blv, where);
             blv->found = 1;
 
@@ -1952,19 +1955,11 @@ DEFUN ("local-variable-p", Flocal_variable_p, Slocal_variable_p,
        1, 2, 0,
        doc: /* Non-nil if VARIABLE has a local binding in buffer BUFFER.
 BUFFER defaults to the current buffer.  */)
-  (register Lisp_Object variable, Lisp_Object buffer)
+  (Lisp_Object variable, Lisp_Object buffer)
 {
-  register struct buffer *buf;
+  struct buffer *buf = decode_buffer (buffer);
   struct Lisp_Symbol *sym;
 
-  if (NILP (buffer))
-    buf = current_buffer;
-  else
-    {
-      CHECK_BUFFER (buffer);
-      buf = XBUFFER (buffer);
-    }
-
   CHECK_SYMBOL (variable);
   sym = XSYMBOL (variable);
 
@@ -2318,7 +2313,7 @@ bool-vector.  IDX starts at 0.  */)
         {
           if (! SINGLE_BYTE_CHAR_P (c))
             {
-              int i;
+              ptrdiff_t i;
 
               for (i = SBYTES (array) - 1; i >= 0; i--)
                 if (SREF (array, i) >= 0x80)
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 8997e01b068..4852739d8e4 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -761,7 +761,7 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
                 && STRINGP (CAR_SAFE (XD_NEXT_VALUE (object)))
                 && NILP (CDR_SAFE (XD_NEXT_VALUE (object))))
               {
-                strcpy (signature, SSDATA (CAR_SAFE (XD_NEXT_VALUE (object))));
+                lispstpcpy (signature, CAR_SAFE (XD_NEXT_VALUE (object)));
                 object = CDR_SAFE (XD_NEXT_VALUE (object));
               }
 
@@ -1054,6 +1054,7 @@ xd_remove_watch (DBusWatch *watch, void *data)
 
   /* Unset session environment.  */
 #if 0
+  /* This is buggy, since unsetenv is not thread-safe.  */
   if (XSYMBOL (QCdbus_session_bus) == data)
     {
       XD_DEBUG_MESSAGE ("unsetenv DBUS_SESSION_BUS_ADDRESS");
@@ -1219,9 +1220,6 @@ this connection to those buses.  */)
       XSETFASTINT (val, (intptr_t) connection);
       xd_registered_buses = Fcons (Fcons (bus, val), xd_registered_buses);
 
-      /* We do not want to abort.  */
-      xputenv ("DBUS_FATAL_WARNINGS=0");
-
       /* Cleanup.  */
       dbus_error_free (&derror);
     }
@@ -1738,6 +1736,13 @@ xd_read_queued_messages (int fd, void *data)
 
 
 void
+init_dbusbind (void)
+{
+  /* We do not want to abort.  */
+  xputenv ("DBUS_FATAL_WARNINGS=0");
+}
+
+void
 syms_of_dbusbind (void)
 {
 
diff --git a/src/decompress.c b/src/decompress.c
index cd8a3d1e962..24ce852245c 100644
--- a/src/decompress.c
+++ b/src/decompress.c
@@ -60,10 +60,7 @@ init_zlib_functions (void)
   HMODULE library = w32_delayed_load (Qzlib_dll);
 
   if (!library)
-    {
-      message1 ("zlib library not found");
-      return false;
-    }
+    return false;
 
   LOAD_ZLIB_FN (library, inflateInit2_);
   LOAD_ZLIB_FN (library, inflate);
@@ -150,7 +147,10 @@ This function can be called only in unibyte buffers.  */)
   if (!zlib_initialized)
     zlib_initialized = init_zlib_functions ();
   if (!zlib_initialized)
-    return Qnil;
+    {
+      message1 ("zlib library not found");
+      return Qnil;
+    }
 #endif
 
   /* This is a unibyte buffer, so character positions and bytes are
diff --git a/src/dispextern.h b/src/dispextern.h
index b87ae891a37..c75eb27d635 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -2541,7 +2541,9 @@ struct it
 
   /* First and last visible x-position in the display area.  If window
      is hscrolled by n columns, first_visible_x == n * FRAME_COLUMN_WIDTH
-     (f), and last_visible_x == pixel width of W + first_visible_x.  */
+     (f), and last_visible_x == pixel width of W + first_visible_x.
+     When truncation or continuation glyphs are produced due to lack of
+     fringes, last_visible_x excludes the space required for these glyphs.  */
   int first_visible_x, last_visible_x;
 
   /* Last visible y-position + 1 in the display area without a mode
@@ -3192,7 +3194,6 @@ 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);
 int move_it_to (struct it *, ptrdiff_t, int, int, int, int);
 void pixel_to_glyph_coords (struct frame *, int, int, int *, int *,
@@ -3517,7 +3518,6 @@ extern void calculate_costs (struct frame *);
 extern void produce_glyphs (struct it *);
 extern bool tty_capable_p (struct tty_display_info *, unsigned);
 extern void set_tty_color_mode (struct tty_display_info *, struct frame *);
-extern struct terminal *get_named_tty (const char *);
 extern void create_tty_output (struct frame *);
 extern struct terminal *init_tty (const char *, const char *, bool);
 extern void tty_append_glyph (struct it *);
diff --git a/src/dispnew.c b/src/dispnew.c
index b587852fc6e..3ab8bcf3e64 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -1082,8 +1082,7 @@ prepare_desired_row (struct window *w, struct glyph_row *row, bool mode_line_p)
       if (w->right_margin_cols > 0)
         row->glyphs[RIGHT_MARGIN_AREA] = row->glyphs[LAST_AREA];
     }
-  else if (row == MATRIX_MODE_LINE_ROW (w->desired_matrix)
-           || row == MATRIX_HEADER_LINE_ROW (w->desired_matrix))
+  else
     {
       /* The real number of glyphs reserved for the margins is
          recorded in the glyph matrix, and can be different from
@@ -1093,8 +1092,8 @@ prepare_desired_row (struct window *w, struct glyph_row *row, bool mode_line_p)
       int right = w->desired_matrix->right_margin_glyphs;
 
       /* Make sure the marginal areas of this row are in sync with
-         what the window wants, when the 1st/last row of the matrix
-         actually displays text and not header/mode line.  */
+         what the window wants, when the row actually displays text
+         and not header/mode line.  */
       if (w->left_margin_cols > 0
           && (left != row->glyphs[TEXT_AREA] - row->glyphs[LEFT_MARGIN_AREA]))
         row->glyphs[TEXT_AREA] = row->glyphs[LEFT_MARGIN_AREA] + left;
@@ -2138,8 +2137,11 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f)
 static void
 adjust_decode_mode_spec_buffer (struct frame *f)
 {
+  int frame_message_buf_size = FRAME_MESSAGE_BUF_SIZE (f);
+
+  eassert (frame_message_buf_size >= 0);
   f->decode_mode_spec_buffer = xrealloc (f->decode_mode_spec_buffer,
-                                         FRAME_MESSAGE_BUF_SIZE (f) + 1);
+                                         frame_message_buf_size + 1);
 }
 
 
@@ -5121,7 +5123,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
 #ifdef HAVE_WINDOW_SYSTEM
   struct image *img = 0;
 #endif
-  int x0, x1, to_x;
+  int x0, x1, to_x, it_vpos;
   void *itdata = NULL;
 
   /* We used to set current_buffer directly here, but that does the
@@ -5130,11 +5132,6 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
   itdata = bidi_shelve_cache ();
   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
-     start position.  Adjust for a possible header-line row.  */
-  it.vpos += WINDOW_WANTS_HEADER_LINE_P (w);
-
   x0 = *x;
 
   /* First, move to the beginning of the row corresponding to *Y.  We
@@ -5143,9 +5140,8 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
   move_it_to (&it, -1, 0, *y, -1, MOVE_TO_X | MOVE_TO_Y);
 
   /* TO_X is the pixel position that the iterator will compute for the
-     glyph at *X.  We add it.first_visible_x because iterator
-     positions include the hscroll.  */
-  to_x = x0 + it.first_visible_x;
+     glyph at *X.  */
+  to_x = x0;
   if (it.bidi_it.paragraph_dir == R2L)
     /* For lines in an R2L paragraph, we need to mirror TO_X wrt the
        text area.  This is because the iterator, even in R2L
@@ -5159,6 +5155,10 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
        it should be mirrored into zero pixel position.)  */
     to_x = window_box_width (w, TEXT_AREA) - to_x - 1;
 
+  /* We need to add it.first_visible_x because iterator positions
+     include the hscroll. */
+  to_x += it.first_visible_x;
+
   /* Now move horizontally in the row to the glyph under *X.  Second
      argument is ZV to prevent move_it_in_display_line from matching
      based on buffer positions.  */
@@ -5201,8 +5201,13 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
     }
 #endif
 
-  if (it.vpos < w->current_matrix->nrows
-      && (row = MATRIX_ROW (w->current_matrix, it.vpos),
+  /* IT's vpos counts from the glyph row that includes the window's
+     start position, i.e. it excludes the header-line row, but
+     MATRIX_ROW includes the header-line row.  Adjust for a possible
+     header-line row.  */
+  it_vpos = it.vpos + WINDOW_WANTS_MODELINE_P (w);
+  if (it_vpos < w->current_matrix->nrows
+      && (row = MATRIX_ROW (w->current_matrix, it_vpos),
           row->enabled_p))
     {
       if (it.hpos < row->used[TEXT_AREA])
@@ -5606,16 +5611,13 @@ the currently selected frame.  In batch mode, STRING is sent to stdout
 when TERMINAL is nil.  */)
   (Lisp_Object string, Lisp_Object terminal)
 {
-  struct terminal *t = get_terminal (terminal, 1);
+  struct terminal *t = decode_live_terminal (terminal);
   FILE *out;
 
   /* ??? Perhaps we should do something special for multibyte strings here.  */
   CHECK_STRING (string);
   block_input ();
 
-  if (!t)
-    error ("Unknown terminal device");
-
   if (t->type == output_initial)
     out = stdout;
   else if (t->type != output_termcap && t->type != output_msdos_raw)
@@ -6095,15 +6097,12 @@ init_display (void)
       (*initial_terminal->delete_terminal_hook) (initial_terminal);
 
     /* Update frame parameters to reflect the new type. */
-    Fmodify_frame_parameters
-      (selected_frame, list1 (Fcons (Qtty_type,
-                                     Ftty_type (selected_frame))));
-    if (t->display_info.tty->name)
-      Fmodify_frame_parameters
-        (selected_frame,
-         list1 (Fcons (Qtty, build_string (t->display_info.tty->name))));
-    else
-      Fmodify_frame_parameters (selected_frame, list1 (Fcons (Qtty, Qnil)));
+    AUTO_FRAME_ARG (tty_type_arg, Qtty_type, Ftty_type (selected_frame));
+    Fmodify_frame_parameters (selected_frame, tty_type_arg);
+    AUTO_FRAME_ARG (tty_arg, Qtty, (t->display_info.tty->name
+                                    ? build_string (t->display_info.tty->name)
+                                    : Qnil));
+    Fmodify_frame_parameters (selected_frame, tty_arg);
   }
 
   {
diff --git a/src/doc.c b/src/doc.c
index df8cfba3f2a..1b87c23e949 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -121,8 +121,8 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
       if (minsize < 8)
         minsize = 8;
       name = SAFE_ALLOCA (minsize + SCHARS (file) + 8);
-      strcpy (name, SSDATA (docdir));
-      strcat (name, SSDATA (file));
+      char *z = lispstpcpy (name, docdir);
+      strcpy (z, SSDATA (file));
     }
   else
     {
@@ -146,8 +146,9 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
       if (fd < 0)
         {
           SAFE_FREE ();
-          return concat3 (build_string ("Cannot open doc string file \""),
-                          file, build_string ("\"\n"));
+          AUTO_STRING (cannot_open, "Cannot open doc string file \"");
+          AUTO_STRING (quote_nl, "\"\n");
+          return concat3 (cannot_open, file, quote_nl);
         }
     }
   count = SPECPDL_INDEX ();
@@ -561,6 +562,8 @@ the same file name is found in the `doc-directory'.  */)
   char *p, *name;
   bool skip_file = 0;
   ptrdiff_t count;
+  char const *dirname;
+  ptrdiff_t dirlen;
   /* Preloaded defcustoms using custom-initialize-delay are added to
      this list, but kept unbound.  See http://debbugs.gnu.org/11565  */
   Lisp_Object delayed_init =
@@ -577,15 +580,21 @@ the same file name is found in the `doc-directory'.  */)
       (0)
 #endif /* CANNOT_DUMP */
     {
-      name = alloca (SCHARS (filename) + 14);
-      strcpy (name, "../etc/");
+      static char const sibling_etc[] = "../etc/";
+      dirname = sibling_etc;
+      dirlen = sizeof sibling_etc - 1;
     }
   else
     {
       CHECK_STRING (Vdoc_directory);
-      name = alloca (SCHARS (filename) + SCHARS (Vdoc_directory) + 1);
-      strcpy (name, SSDATA (Vdoc_directory));
+      dirname = SSDATA (Vdoc_directory);
+      dirlen = SBYTES (Vdoc_directory);
     }
+
+  count = SPECPDL_INDEX ();
+  USE_SAFE_ALLOCA;
+  name = SAFE_ALLOCA (dirlen + SBYTES (filename) + 1);
+  strcpy (name, dirname);
   strcat (name, SSDATA (filename));     /*** Add this line ***/
 
   /* Vbuild_files is nil when temacs is run, and non-nil after that.  */
@@ -608,7 +617,6 @@ the same file name is found in the `doc-directory'.  */)
       report_file_errno ("Opening doc string file", build_string (name),
                          open_errno);
     }
-  count = SPECPDL_INDEX ();
   record_unwind_protect_int (close_file_unwind, fd);
   Vdoc_file_name = filename;
   filled = 0;
@@ -637,7 +645,7 @@ the same file name is found in the `doc-directory'.  */)
                   && (end[-1] == 'o' || end[-1] == 'c'))
                 {
                   ptrdiff_t len = end - p - 2;
-                  char *fromfile = alloca (len + 1);
+                  char *fromfile = SAFE_ALLOCA (len + 1);
                   memcpy (fromfile, &p[2], len);
                   fromfile[len] = 0;
                   if (fromfile[len-1] == 'c')
@@ -688,6 +696,8 @@ the same file name is found in the `doc-directory'.  */)
       filled -= end - buf;
       memmove (buf, end, filled);
     }
+
+  SAFE_FREE ();
   return unbind_to (count, Qnil);
 }
 
diff --git a/src/editfns.c b/src/editfns.c
index a906aead09a..be1062dbbc5 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -64,11 +64,17 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 extern Lisp_Object w32_get_internal_run_time (void);
 #endif
 
+static void set_time_zone_rule (char const *);
 static Lisp_Object format_time_string (char const *, ptrdiff_t, struct timespec,
                                        bool, struct tm *);
+static long int tm_gmtoff (struct tm *);
 static int tm_diff (struct tm *, struct tm *);
 static void update_buffer_properties (ptrdiff_t, ptrdiff_t);
 
+#ifndef HAVE_TM_GMTOFF
+# define HAVE_TM_GMTOFF false
+#endif
+
 static Lisp_Object Qbuffer_access_fontify_functions;
 
 /* Symbol for the text property used to mark fields.  */
@@ -79,15 +85,12 @@ Lisp_Object Qfield;
 
 static Lisp_Object Qboundary;
 
-/* The startup value of the TZ environment variable so it can be
-   restored if the user calls set-time-zone-rule with a nil
-   argument.  If null, the TZ environment variable was unset.  */
+/* The startup value of the TZ environment variable; null if unset.  */
 static char const *initial_tz;
 
-/* True if the static variable tzvalbuf (defined in
-   set_time_zone_rule) is part of 'environ'.  */
-static bool tzvalbuf_in_environ;
-
+/* A valid but unlikely setting for the TZ environment variable.
+   It is OK (though a bit slower) if the user chooses this value.  */
+static char dump_tz_string[] = "TZ=UtC0";
 
 void
 init_editfns (void)
@@ -101,13 +104,38 @@ init_editfns (void)
   init_system_name ();
 
 #ifndef CANNOT_DUMP
-  /* Don't bother with this on initial start when just dumping out */
+  /* When just dumping out, set the time zone to a known unlikely value
+     and skip the rest of this function.  */
   if (!initialized)
-    return;
-#endif /* not CANNOT_DUMP */
+    {
+# ifdef HAVE_TZSET
+      xputenv (dump_tz_string);
+      tzset ();
+# endif
+      return;
+    }
+#endif
 
-  initial_tz = getenv ("TZ");
-  tzvalbuf_in_environ = 0;
+  char *tz = getenv ("TZ");
+  initial_tz = tz;
+
+#if !defined CANNOT_DUMP && defined HAVE_TZSET
+  /* If the execution TZ happens to be the same as the dump TZ,
+     change it to some other value and then change it back,
+     to force the underlying implementation to reload the TZ info.
+     This is needed on implementations that load TZ info from files,
+     since the TZ file contents may differ between dump and execution.  */
+  if (tz && strcmp (tz, &dump_tz_string[sizeof "TZ=" - 1]) == 0)
+    {
+      ++*tz;
+      tzset ();
+      --*tz;
+    }
+#endif
+
+  /* Call set_time_zone_rule now, so that its call to putenv is done
+     before multiple threads are active.  */
+  set_time_zone_rule (tz);
 
   pw = getpwuid (getuid ());
 #ifdef MSDOS
@@ -376,13 +404,14 @@ at POSITION.  */)
       set_buffer_temp (XBUFFER (object));
 
       /* First try with room for 40 overlays.  */
-      noverlays = 40;
-      overlay_vec = alloca (noverlays * sizeof *overlay_vec);
+      Lisp_Object overlay_vecbuf[40];
+      noverlays = ARRAYELTS (overlay_vecbuf);
+      overlay_vec = overlay_vecbuf;
       noverlays = overlays_around (posn, overlay_vec, noverlays);
 
       /* If there are more than 40,
          make enough space for all, and try again.  */
-      if (noverlays > 40)
+      if (ARRAYELTS (overlay_vecbuf) < noverlays)
         {
           SAFE_ALLOCA_LISP (overlay_vec, noverlays);
           noverlays = overlays_around (posn, overlay_vec, noverlays);
@@ -1325,17 +1354,16 @@ name, or nil if there is no such user.  */)
   /* Substitute the login name for the &, upcasing the first character.  */
   if (q)
     {
-      register char *r;
-      Lisp_Object login;
-
-      login = Fuser_login_name (make_number (pw->pw_uid));
-      r = alloca (strlen (p) + SCHARS (login) + 1);
+      Lisp_Object login = Fuser_login_name (make_number (pw->pw_uid));
+      USE_SAFE_ALLOCA;
+      char *r = SAFE_ALLOCA (strlen (p) + SBYTES (login) + 1);
       memcpy (r, p, q - p);
       r[q - p] = 0;
       strcat (r, SSDATA (login));
       r[q - p] = upcase ((unsigned char) r[q - p]);
       strcat (r, q + 1);
       full = build_string (r);
+      SAFE_FREE ();
     }
 #endif /* AMPERSAND_FULL_NAME */
 
@@ -1373,6 +1401,30 @@ time_overflow (void)
   error ("Specified time is not representable");
 }
 
+/* A substitute for mktime_z on platforms that lack it.  It's not
+   thread-safe, but should be good enough for Emacs in typical use.  */
+#ifndef HAVE_TZALLOC
+time_t
+mktime_z (timezone_t tz, struct tm *tm)
+{
+  char *oldtz = getenv ("TZ");
+  USE_SAFE_ALLOCA;
+  if (oldtz)
+    {
+      size_t oldtzsize = strlen (oldtz) + 1;
+      char *oldtzcopy = SAFE_ALLOCA (oldtzsize);
+      oldtz = strcpy (oldtzcopy, oldtz);
+    }
+  block_input ();
+  set_time_zone_rule (tz);
+  time_t t = mktime (tm);
+  set_time_zone_rule (oldtz);
+  unblock_input ();
+  SAFE_FREE ();
+  return t;
+}
+#endif
+
 /* Return the upper part of the time T (everything but the bottom 16 bits).  */
 static EMACS_INT
 hi_time (time_t t)
@@ -1768,39 +1820,28 @@ format_time_string (char const *format, ptrdiff_t formatlen,
   size_t len;
   Lisp_Object bufstring;
   int ns = t.tv_nsec;
-  struct tm *tm;
   USE_SAFE_ALLOCA;
 
-  while (1)
-    {
-      time_t *taddr = &t.tv_sec;
-      block_input ();
-
-      synchronize_system_time_locale ();
-
-      tm = ut ? gmtime (taddr) : localtime (taddr);
-      if (! tm)
-        {
-          unblock_input ();
-          time_overflow ();
-        }
-      *tmp = *tm;
+  tmp = ut ? gmtime_r (&t.tv_sec, tmp) : localtime_r (&t.tv_sec, tmp);
+  if (! tmp)
+    time_overflow ();
+  synchronize_system_time_locale ();
 
+  while (true)
+    {
       buf[0] = '\1';
-      len = emacs_nmemftime (buf, size, format, formatlen, tm, ut, ns);
+      len = emacs_nmemftime (buf, size, format, formatlen, tmp, ut, ns);
       if ((0 < len && len < size) || (len == 0 && buf[0] == '\0'))
         break;
 
       /* Buffer was too small, so make it bigger and try again.  */
-      len = emacs_nmemftime (NULL, SIZE_MAX, format, formatlen, tm, ut, ns);
-      unblock_input ();
+      len = emacs_nmemftime (NULL, SIZE_MAX, format, formatlen, tmp, ut, ns);
       if (STRING_BYTES_BOUND <= len)
         string_overflow ();
       size = len + 1;
       buf = SAFE_ALLOCA (size);
     }
 
-  unblock_input ();
   bufstring = make_unibyte_string (buf, len);
   SAFE_FREE ();
   return code_convert_string_norecord (bufstring, Vlocale_coding_system, 0);
@@ -1824,38 +1865,30 @@ DOW and ZONE.)  */)
   (Lisp_Object specified_time)
 {
   time_t time_spec = lisp_seconds_argument (specified_time);
-  struct tm save_tm;
-  struct tm *decoded_time;
-  Lisp_Object list_args[9];
+  struct tm local_tm, gmt_tm;
 
-  block_input ();
-  decoded_time = localtime (&time_spec);
-  if (decoded_time)
-    save_tm = *decoded_time;
-  unblock_input ();
-  if (! (decoded_time
-         && MOST_NEGATIVE_FIXNUM - TM_YEAR_BASE <= save_tm.tm_year
-         && save_tm.tm_year <= MOST_POSITIVE_FIXNUM - TM_YEAR_BASE))
+  if (! (localtime_r (&time_spec, &local_tm)
+         && MOST_NEGATIVE_FIXNUM - TM_YEAR_BASE <= local_tm.tm_year
+         && local_tm.tm_year <= MOST_POSITIVE_FIXNUM - TM_YEAR_BASE))
     time_overflow ();
-  XSETFASTINT (list_args[0], save_tm.tm_sec);
-  XSETFASTINT (list_args[1], save_tm.tm_min);
-  XSETFASTINT (list_args[2], save_tm.tm_hour);
-  XSETFASTINT (list_args[3], save_tm.tm_mday);
-  XSETFASTINT (list_args[4], save_tm.tm_mon + 1);
-  /* On 64-bit machines an int is narrower than EMACS_INT, thus the
-     cast below avoids overflow in int arithmetics.  */
-  XSETINT (list_args[5], TM_YEAR_BASE + (EMACS_INT) save_tm.tm_year);
-  XSETFASTINT (list_args[6], save_tm.tm_wday);
-  list_args[7] = save_tm.tm_isdst ? Qt : Qnil;
 
-  block_input ();
-  decoded_time = gmtime (&time_spec);
-  if (decoded_time == 0)
-    list_args[8] = Qnil;
-  else
-    XSETINT (list_args[8], tm_diff (&save_tm, decoded_time));
-  unblock_input ();
-  return Flist (9, list_args);
+  /* Avoid overflow when INT_MAX < EMACS_INT_MAX.  */
+  EMACS_INT tm_year_base = TM_YEAR_BASE;
+
+  return Flist (9, ((Lisp_Object [])
+                    {make_number (local_tm.tm_sec),
+                     make_number (local_tm.tm_min),
+                     make_number (local_tm.tm_hour),
+                     make_number (local_tm.tm_mday),
+                     make_number (local_tm.tm_mon + 1),
+                     make_number (local_tm.tm_year + tm_year_base),
+                     make_number (local_tm.tm_wday),
+                     local_tm.tm_isdst ? Qt : Qnil,
+                     (HAVE_TM_GMTOFF
+                      ? make_number (tm_gmtoff (&local_tm))
+                      : gmtime_r (&time_spec, &gmt_tm)
+                      ? make_number (tm_diff (&local_tm, &gmt_tm))
+                      : Qnil)}));
 }
 
 /* Return OBJ - OFFSET, checking that OBJ is a valid fixnum and that
@@ -1911,18 +1944,12 @@ usage: (encode-time SECOND MINUTE HOUR DAY MONTH YEAR &optional ZONE)  */)
   if (CONSP (zone))
     zone = XCAR (zone);
   if (NILP (zone))
-    {
-      block_input ();
-      value = mktime (&tm);
-      unblock_input ();
-    }
+    value = mktime (&tm);
   else
     {
       static char const tzbuf_format[] = "XXX%s%"pI"d:%02d:%02d";
       char tzbuf[sizeof tzbuf_format + INT_STRLEN_BOUND (EMACS_INT)];
-      char *old_tzstring;
       const char *tzstring;
-      USE_SAFE_ALLOCA;
 
       if (EQ (zone, Qt))
         tzstring = "UTC0";
@@ -1939,29 +1966,13 @@ usage: (encode-time SECOND MINUTE HOUR DAY MONTH YEAR &optional ZONE)  */)
           tzstring = tzbuf;
         }
       else
-        error ("Invalid time zone specification");
-
-      old_tzstring = getenv ("TZ");
-      if (old_tzstring)
-        {
-          char *buf = SAFE_ALLOCA (strlen (old_tzstring) + 1);
-          old_tzstring = strcpy (buf, old_tzstring);
-        }
-
-      block_input ();
-
-      /* Set TZ before calling mktime; merely adjusting mktime's returned
-         value doesn't suffice, since that would mishandle leap seconds.  */
-      set_time_zone_rule (tzstring);
-
-      value = mktime (&tm);
+        tzstring = 0;
 
-      set_time_zone_rule (old_tzstring);
-#ifdef LOCALTIME_CACHE
-      tzset ();
-#endif
-      unblock_input ();
-      SAFE_FREE ();
+      timezone_t tz = tzstring ? tzalloc (tzstring) : 0;
+      if (! tz)
+        error ("Invalid time zone specification");
+      value = mktime_z (tz, &tm);
+      tzfree (tz);
     }
 
   if (value == (time_t) -1)
@@ -1987,34 +1998,27 @@ but this is considered obsolete.  */)
   (Lisp_Object specified_time)
 {
   time_t value = lisp_seconds_argument (specified_time);
-  struct tm *tm;
-  char buf[sizeof "Mon Apr 30 12:49:17 " + INT_STRLEN_BOUND (int) + 1];
-  int len IF_LINT (= 0);
 
   /* Convert to a string in ctime format, except without the trailing
      newline, and without the 4-digit year limit.  Don't use asctime
      or ctime, as they might dump core if the year is outside the
      range -999 .. 9999.  */
-  block_input ();
-  tm = localtime (&value);
-  if (tm)
-    {
-      static char const wday_name[][4] =
-        { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-      static char const mon_name[][4] =
-        { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
-      printmax_t year_base = TM_YEAR_BASE;
-
-      len = sprintf (buf, "%s %s%3d %02d:%02d:%02d %"pMd,
-                     wday_name[tm->tm_wday], mon_name[tm->tm_mon], tm->tm_mday,
-                     tm->tm_hour, tm->tm_min, tm->tm_sec,
-                     tm->tm_year + year_base);
-    }
-  unblock_input ();
-  if (! tm)
+  struct tm tm;
+  if (! localtime_r (&value, &tm))
     time_overflow ();
 
+  static char const wday_name[][4] =
+    { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+  static char const mon_name[][4] =
+    { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+  printmax_t year_base = TM_YEAR_BASE;
+  char buf[sizeof "Mon Apr 30 12:49:17 " + INT_STRLEN_BOUND (int) + 1];
+  int len = sprintf (buf, "%s %s%3d %02d:%02d:%02d %"pMd,
+                     wday_name[tm.tm_wday], mon_name[tm.tm_mon], tm.tm_mday,
+                     tm.tm_hour, tm.tm_min, tm.tm_sec,
+                     tm.tm_year + year_base);
+
   return make_unibyte_string (buf, len);
 }
 
@@ -2041,6 +2045,17 @@ tm_diff (struct tm *a, struct tm *b)
           + (a->tm_sec - b->tm_sec));
 }
 
+/* Yield A's UTC offset, or an unspecified value if unknown.  */
+static long int
+tm_gmtoff (struct tm *a)
+{
+#if HAVE_TM_GMTOFF
+  return a->tm_gmtoff;
+#else
+  return 0;
+#endif
+}
+
 DEFUN ("current-time-zone", Fcurrent_time_zone, Scurrent_time_zone, 0, 1, 0,
        doc: /* Return the offset and name for the local time zone.
 This returns a list of the form (OFFSET NAME).
@@ -2059,32 +2074,30 @@ the data it can't find.  */)
   (Lisp_Object specified_time)
 {
   struct timespec value;
-  int offset;
-  struct tm *t;
-  struct tm localtm;
+  struct tm local_tm, gmt_tm;
   Lisp_Object zone_offset, zone_name;
 
   zone_offset = Qnil;
   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 (&value.tv_sec);
-  if (t)
-    offset = tm_diff (&localtm, t);
-  unblock_input ();
+  zone_name = format_time_string ("%Z", sizeof "%Z" - 1, value, 0, &local_tm);
 
-  if (t)
+  if (HAVE_TM_GMTOFF || gmtime_r (&value.tv_sec, &gmt_tm))
     {
+      long int offset = (HAVE_TM_GMTOFF
+                         ? tm_gmtoff (&local_tm)
+                         : tm_diff (&local_tm, &gmt_tm));
       zone_offset = make_number (offset);
       if (SCHARS (zone_name) == 0)
         {
           /* No local time zone name is available; use "+-NNNN" instead.  */
-          int m = offset / 60;
-          int am = offset < 0 ? - m : m;
-          char buf[sizeof "+00" + INT_STRLEN_BOUND (int)];
-          zone_name = make_formatted_string (buf, "%c%02d%02d",
+          long int m = offset / 60;
+          long int am = offset < 0 ? - m : m;
+          long int hour = am / 60;
+          int min = am % 60;
+          char buf[sizeof "+00" + INT_STRLEN_BOUND (long int)];
+          zone_name = make_formatted_string (buf, "%c%02ld%02d",
                                              (offset < 0 ? '-' : '+'),
-                                             am / 60, am % 60);
+                                             hour, min);
         }
     }
 
@@ -2123,12 +2136,12 @@ only the former.  */)
 
 /* Set the local time zone rule to TZSTRING.
 
-   This function is not thread-safe, partly because putenv, unsetenv
-   and tzset are not, and partly because of the static storage it
-   updates.  Other threads that invoke localtime etc. may be adversely
-   affected while this function is executing.  */
+   This function is not thread-safe, in theory because putenv is not,
+   but mostly because of the static storage it updates.  Other threads
+   that invoke localtime etc. may be adversely affected while this
+   function is executing.  */
 
-void
+static void
 set_time_zone_rule (const char *tzstring)
 {
   /* A buffer holding a string of the form "TZ=value", intended
@@ -2137,75 +2150,47 @@ set_time_zone_rule (const char *tzstring)
   static ptrdiff_t tzvalbufsize;
 
   int tzeqlen = sizeof "TZ=" - 1;
+  ptrdiff_t tzstringlen = tzstring ? strlen (tzstring) : 0;
+  char *tzval = tzvalbuf;
+  bool new_tzvalbuf = tzvalbufsize <= tzeqlen + tzstringlen;
 
-#ifdef LOCALTIME_CACHE
-  /* These two values are known to load tz files in buggy implementations,
-     i.e., Solaris 1 executables running under either Solaris 1 or Solaris 2.
-     Their values shouldn't matter in non-buggy implementations.
-     We don't use string literals for these strings,
-     since if a string in the environment is in readonly
-     storage, it runs afoul of bugs in SVR4 and Solaris 2.3.
-     See Sun bugs 1113095 and 1114114, ``Timezone routines
-     improperly modify environment''.  */
-
-  static char set_time_zone_rule_tz[][sizeof "TZ=GMT+0"]
-    = { "TZ=GMT+0", "TZ=GMT+1" };
-
-  /* In SunOS 4.1.3_U1 and 4.1.4, if TZ has a value like
-     "US/Pacific" that loads a tz file, then changes to a value like
-     "XXX0" that does not load a tz file, and then changes back to
-     its original value, the last change is (incorrectly) ignored.
-     Also, if TZ changes twice in succession to values that do
-     not load a tz file, tzset can dump core (see Sun bug#1225179).
-     The following code works around these bugs.  */
+  if (new_tzvalbuf)
+    {
+      /* Do not attempt to free the old tzvalbuf, since another thread
+         may be using it.  In practice, the first allocation is large
+         enough and memory does not leak.  */
+      tzval = xpalloc (NULL, &tzvalbufsize,
+                       tzeqlen + tzstringlen - tzvalbufsize + 1, -1, 1);
+      tzvalbuf = tzval;
+      tzval[1] = 'Z';
+      tzval[2] = '=';
+    }
 
   if (tzstring)
     {
-      /* Temporarily set TZ to a value that loads a tz file
-         and that differs from tzstring.  */
-      bool eq0 = strcmp (tzstring, set_time_zone_rule_tz[0] + tzeqlen) == 0;
-      xputenv (set_time_zone_rule_tz[eq0]);
+      /* Modify TZVAL in place.  Although this is dicey in a
+         multithreaded environment, we know of no portable alternative.
+         Calling putenv or setenv could crash some other thread.  */
+      tzval[0] = 'T';
+      strcpy (tzval + tzeqlen, tzstring);
     }
   else
     {
-      /* The implied tzstring is unknown, so temporarily set TZ to
-         two different values that each load a tz file.  */
-      xputenv (set_time_zone_rule_tz[0]);
-      tzset ();
-      xputenv (set_time_zone_rule_tz[1]);
+      /* Turn 'TZ=whatever' into an empty environment variable 'tZ='.
+         Although this is also dicey, calling unsetenv here can crash Emacs.
+         See Bug#8705.  */
+      tzval[0] = 't';
+      tzval[tzeqlen] = 0;
     }
-  tzset ();
-  tzvalbuf_in_environ = 0;
-#endif
 
-  if (!tzstring)
+  if (new_tzvalbuf)
     {
-      unsetenv ("TZ");
-      tzvalbuf_in_environ = 0;
-    }
-  else
-    {
-      ptrdiff_t tzstringlen = strlen (tzstring);
-
-      if (tzvalbufsize <= tzeqlen + tzstringlen)
-        {
-          unsetenv ("TZ");
-          tzvalbuf_in_environ = 0;
-          tzvalbuf = xpalloc (tzvalbuf, &tzvalbufsize,
-                              tzeqlen + tzstringlen - tzvalbufsize + 1, -1, 1);
-          memcpy (tzvalbuf, "TZ=", tzeqlen);
-        }
-
-      strcpy (tzvalbuf + tzeqlen, tzstring);
-
-      if (!tzvalbuf_in_environ)
-        {
-          xputenv (tzvalbuf);
-          tzvalbuf_in_environ = 1;
-        }
+      /* Although this is not thread-safe, in practice this runs only
+         on startup when there is only one thread.  */
+      xputenv (tzval);
     }
 
-#ifdef LOCALTIME_CACHE
+#ifdef HAVE_TZSET
   tzset ();
 #endif
 }
@@ -3012,8 +2997,12 @@ static Lisp_Object
 check_translation (ptrdiff_t pos, ptrdiff_t pos_byte, ptrdiff_t end,
                    Lisp_Object val)
 {
-  int buf_size = 16, buf_used = 0;
-  int *buf = alloca (sizeof (int) * buf_size);
+  int initial_buf[16];
+  int *buf = initial_buf;
+  ptrdiff_t buf_size = ARRAYELTS (initial_buf);
+  int *bufalloc = 0;
+  ptrdiff_t buf_used = 0;
+  Lisp_Object result = Qnil;
 
   for (; CONSP (val); val = XCDR (val))
     {
@@ -3038,12 +3027,11 @@ check_translation (ptrdiff_t pos, ptrdiff_t pos_byte, ptrdiff_t end,
 
                   if (buf_used == buf_size)
                     {
-                      int *newbuf;
-
-                      buf_size += 16;
-                      newbuf = alloca (sizeof (int) * buf_size);
-                      memcpy (newbuf, buf, sizeof (int) * buf_used);
-                      buf = newbuf;
+                      bufalloc = xpalloc (bufalloc, &buf_size, 1, -1,
+                                          sizeof *bufalloc);
+                      if (buf == initial_buf)
+                        memcpy (bufalloc, buf, sizeof initial_buf);
+                      buf = bufalloc;
                     }
                   buf[buf_used++] = STRING_CHAR_AND_LENGTH (p, len1);
                   pos_byte += len1;
@@ -3052,10 +3040,15 @@ check_translation (ptrdiff_t pos, ptrdiff_t pos_byte, ptrdiff_t end,
                 break;
             }
           if (i == len)
-            return XCAR (val);
+            {
+              result = XCAR (val);
+              break;
+            }
         }
     }
-  return Qnil;
+
+  xfree (bufalloc);
+  return result;
 }
 
 
@@ -4354,11 +4347,8 @@ usage: (format STRING &rest OBJECTS)  */)
 Lisp_Object
 format2 (const char *string1, Lisp_Object arg0, Lisp_Object arg1)
 {
-  Lisp_Object args[3];
-  args[0] = build_string (string1);
-  args[1] = arg0;
-  args[2] = arg1;
-  return Fformat (3, args);
+  AUTO_STRING (format, string1);
+  return Fformat (3, (Lisp_Object []) {format, arg0, arg1});
 }
 
 DEFUN ("char-equal", Fchar_equal, Schar_equal, 2, 2, 0,
@@ -4617,11 +4607,11 @@ Transposing beyond buffer boundaries is an error.  */)
       if (tmp_interval3)
         set_text_properties_1 (startr1, endr2, Qnil, buf, tmp_interval3);
 
+      USE_SAFE_ALLOCA;
+
       /* First region smaller than second.  */
       if (len1_byte < len2_byte)
         {
-          USE_SAFE_ALLOCA;
-
           temp = SAFE_ALLOCA (len2_byte);
 
           /* Don't precompute these addresses.  We have to compute them
@@ -4633,21 +4623,19 @@ Transposing beyond buffer boundaries is an error.  */)
           memcpy (temp, start2_addr, len2_byte);
           memcpy (start1_addr + len2_byte, start1_addr, len1_byte);
           memcpy (start1_addr, temp, len2_byte);
-          SAFE_FREE ();
         }
       else
         /* First region not smaller than second.  */
         {
-          USE_SAFE_ALLOCA;
-
           temp = SAFE_ALLOCA (len1_byte);
           start1_addr = BYTE_POS_ADDR (start1_byte);
           start2_addr = BYTE_POS_ADDR (start2_byte);
           memcpy (temp, start1_addr, len1_byte);
           memcpy (start1_addr, start2_addr, len2_byte);
           memcpy (start1_addr + len2_byte, temp, len1_byte);
-          SAFE_FREE ();
         }
+
+      SAFE_FREE ();
       graft_intervals_into_buffer (tmp_interval1, start1 + len2,
                                    len1, current_buffer, 0);
       graft_intervals_into_buffer (tmp_interval2, start1,
diff --git a/src/emacs.c b/src/emacs.c
index a53b4cfd4ed..90182e53e70 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -83,6 +83,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "charset.h"
 #include "composite.h"
 #include "dispextern.h"
+#include "regex.h"
 #include "syntax.h"
 #include "sysselect.h"
 #include "systime.h"
@@ -145,7 +146,7 @@ extern int malloc_set_state (void *);
 /* True if the MALLOC_CHECK_ environment variable was set while
    dumping.  Used to work around a bug in glibc's malloc.  */
 static bool malloc_using_checking;
-#elif defined HAVE_PTHREAD && !defined SYSTEM_MALLOC
+#elif defined HAVE_PTHREAD && !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
 extern void malloc_enable_thread (void);
 #endif
 
@@ -395,10 +396,11 @@ terminate_due_to_signal (int sig, int backtrace_limit)
 static void
 init_cmdargs (int argc, char **argv, int skip_args, char *original_pwd)
 {
-  register int i;
+  int i;
   Lisp_Object name, dir, handler;
   ptrdiff_t count = SPECPDL_INDEX ();
   Lisp_Object raw_name;
+  AUTO_STRING (slash_colon, "/:");
 
   initial_argv = argv;
   initial_argc = argc;
@@ -422,7 +424,7 @@ init_cmdargs (int argc, char **argv, int skip_args, char *original_pwd)
      if it would otherwise be treated as magic.  */
   handler = Ffind_file_name_handler (raw_name, Qt);
   if (! NILP (handler))
-    raw_name = concat2 (build_string ("/:"), raw_name);
+    raw_name = concat2 (slash_colon, raw_name);
 
   Vinvocation_name = Ffile_name_nondirectory (raw_name);
   Vinvocation_directory = Ffile_name_directory (raw_name);
@@ -440,7 +442,7 @@ init_cmdargs (int argc, char **argv, int skip_args, char *original_pwd)
              if it would otherwise be treated as magic.  */
           handler = Ffind_file_name_handler (found, Qt);
           if (! NILP (handler))
-            found = concat2 (build_string ("/:"), found);
+            found = concat2 (slash_colon, found);
           Vinvocation_directory = Ffile_name_directory (found);
         }
     }
@@ -576,12 +578,6 @@ DEFUN ("invocation-directory", Finvocation_directory, Sinvocation_directory,
 }
 
 
-#ifdef HAVE_TZSET
-/* A valid but unlikely value for the TZ environment value.
-   It is OK (though a bit slower) if the user actually chooses this value.  */
-static char const dump_tz[] = "UtC0";
-#endif
-
 /* Test whether the next argument in ARGV matches SSTR or a prefix of
    LSTR (at least MINLEN characters).  If so, then if VALPTR is non-null
    (the argument is supposed to have a value) store in *VALPTR either
@@ -734,12 +730,6 @@ main (int argc, char **argv)
   stack_base = &dummy;
 #endif
 
-#ifdef G_SLICE_ALWAYS_MALLOC
-  /* 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
-
 #ifndef CANNOT_DUMP
   might_dump = !initialized;
 #endif
@@ -747,9 +737,6 @@ main (int argc, char **argv)
 #ifdef GNU_LINUX
   if (!initialized)
     {
-      extern char my_endbss[];
-      extern char *my_endbss_static;
-
       if (my_heap_start == 0)
         my_heap_start = sbrk (0);
 
@@ -878,7 +865,6 @@ main (int argc, char **argv)
       && !getrlimit (RLIMIT_STACK, &rlim))
     {
       long newlim;
-      extern size_t re_max_failures;
       /* Approximate the amount regex.c needs per unit of re_max_failures.  */
       int ratio = 20 * sizeof (char *);
       /* Then add 33% to cover the size of the smaller stacks that regex.c
@@ -912,7 +898,7 @@ main (int argc, char **argv)
 
   clearerr (stdin);
 
-#ifndef SYSTEM_MALLOC
+#if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
   /* Arrange to get warning messages as memory fills up.  */
   memory_warnings (0, malloc_warning);
 
@@ -920,7 +906,7 @@ main (int argc, char **argv)
      Also call realloc and free for consistency.  */
   free (realloc (malloc (4), 4));
 
-#endif  /* not SYSTEM_MALLOC */
+#endif  /* not SYSTEM_MALLOC and not HYBRID_MALLOC */
 
 #ifdef MSDOS
   SET_BINARY (fileno (stdin));
@@ -1145,12 +1131,13 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
 #endif /* DOS_NT */
     }
 
-#if defined HAVE_PTHREAD && !defined SYSTEM_MALLOC && !defined DOUG_LEA_MALLOC
+#if defined HAVE_PTHREAD && !defined SYSTEM_MALLOC \
+  && !defined DOUG_LEA_MALLOC && !defined HYBRID_MALLOC
 # ifndef CANNOT_DUMP
   /* Do not make gmalloc thread-safe when creating bootstrap-emacs, as
-     that causes an infinite recursive loop with FreeBSD.  But do make
-     it thread-safe when creating emacs, otherwise bootstrap-emacs
-     fails on Cygwin.  See Bug#14569.  */
+     that causes an infinite recursive loop with FreeBSD.  See
+     Bug#14569.  The part of this bug involving Cygwin is no longer
+     relevant, now that Cygwin defines HYBRID_MALLOC.  */
   if (!noninteractive || initialized)
 # endif
     malloc_enable_thread ();
@@ -1555,8 +1542,23 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
 
   init_charset ();
 
-  init_editfns (); /* init_process_emacs uses Voperating_system_release. */
-  init_process_emacs (); /* init_display uses add_keyboard_wait_descriptor. */
+  /* This calls putenv and so must precede init_process_emacs.  Also,
+     it sets Voperating_system_release, which init_process_emacs uses.  */
+  init_editfns ();
+
+  /* These two call putenv.  */
+#ifdef HAVE_DBUS
+  init_dbusbind ();
+#endif
+#ifdef USE_GTK
+  init_xterm ();
+#endif
+
+  /* This can create a thread that may call getenv, so it must follow
+     all calls to putenv and setenv.  Also, this sets up
+     add_keyboard_wait_descriptor, which init_display uses.  */
+  init_process_emacs ();
+
   init_keyboard ();     /* This too must precede init_sys_modes.  */
   if (!noninteractive)
     init_display ();    /* Determine terminal type.  Calls init_sys_modes.  */
@@ -1593,26 +1595,6 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
                             build_string ("loadup.el"));
     }
 
-  if (initialized)
-    {
-#ifdef HAVE_TZSET
-      {
-        /* If the execution TZ happens to be the same as the dump TZ,
-           change it to some other value and then change it back,
-           to force the underlying implementation to reload the TZ info.
-           This is needed on implementations that load TZ info from files,
-           since the TZ file contents may differ between dump and execution.  */
-        char *tz = getenv ("TZ");
-        if (tz && !strcmp (tz, dump_tz))
-          {
-            ++*tz;
-            tzset ();
-            --*tz;
-          }
-      }
-#endif
-    }
-
   /* Set up for profiling.  This is known to work on FreeBSD,
      GNU/Linux and MinGW.  It might work on some other systems too.
      Give it a try and tell us if it works on your system.  To compile
@@ -1637,15 +1619,6 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
 
   initialized = 1;
 
-#ifdef LOCALTIME_CACHE
-  /* Some versions of localtime have a bug.  They cache the value of the time
-     zone rather than looking it up every time.  Since localtime() is
-     called to bolt the undumping time into the undumped emacs, this
-     results in localtime ignoring the TZ environment variable.
-     This flushes the new TZ value into localtime.  */
-  tzset ();
-#endif /* defined (LOCALTIME_CACHE) */
-
   /* Enter editor command loop.  This never returns.  */
   Frecursive_edit ();
   /* NOTREACHED */
@@ -2126,27 +2099,16 @@ You must run Emacs in batch mode in order to dump it.  */)
   tem = Vpurify_flag;
   Vpurify_flag = Qnil;
 
-#ifdef HAVE_TZSET
-  set_time_zone_rule (dump_tz);
-#ifndef LOCALTIME_CACHE
-  /* Force a tz reload, since set_time_zone_rule doesn't.  */
-  tzset ();
-#endif
-#endif
-
   fflush (stdout);
   /* Tell malloc where start of impure now is.  */
   /* Also arrange for warnings when nearly out of space.  */
-#ifndef SYSTEM_MALLOC
+#if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
 #ifndef WINDOWSNT
   /* On Windows, this was done before dumping, and that once suffices.
      Meanwhile, my_edata is not valid on Windows.  */
-  {
-    extern char my_edata[];
-    memory_warnings (my_edata, malloc_warning);
-  }
+  memory_warnings (my_edata, malloc_warning);
 #endif /* not WINDOWSNT */
-#endif /* not SYSTEM_MALLOC */
+#endif /* not SYSTEM_MALLOC and not HYBRID_MALLOC */
 #ifdef DOUG_LEA_MALLOC
   malloc_state_ptr = malloc_get_state ();
 #endif
@@ -2334,7 +2296,10 @@ decode_env_path (const char *evarname, const char *defalt, bool empty)
             }
 
           if (! NILP (tem))
-            element = concat2 (build_string ("/:"), element);
+            {
+              AUTO_STRING (slash_colon, "/:");
+              element = concat2 (slash_colon, element);
+            }
         } /* !NILP (element) */
 
       lpath = Fcons (element, lpath);
diff --git a/src/eval.c b/src/eval.c
index 4b2e256a722..77b1db95397 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -104,7 +104,7 @@ union specbinding *backtrace_next (union specbinding *) EXTERNALLY_VISIBLE;
 union specbinding *backtrace_top (void) EXTERNALLY_VISIBLE;
 
 static Lisp_Object funcall_lambda (Lisp_Object, ptrdiff_t, Lisp_Object *);
-static Lisp_Object apply_lambda (Lisp_Object fun, Lisp_Object args);
+static Lisp_Object apply_lambda (Lisp_Object, Lisp_Object, ptrdiff_t);
 
 static Lisp_Object
 specpdl_symbol (union specbinding *pdl)
@@ -172,17 +172,11 @@ backtrace_debug_on_exit (union specbinding *pdl)
 /* Functions to modify slots of backtrace records.  */
 
 static void
-set_backtrace_args (union specbinding *pdl, Lisp_Object *args)
+set_backtrace_args (union specbinding *pdl, Lisp_Object *args, ptrdiff_t nargs)
 {
   eassert (pdl->kind == SPECPDL_BACKTRACE);
   pdl->bt.args = args;
-}
-
-static void
-set_backtrace_nargs (union specbinding *pdl, ptrdiff_t n)
-{
-  eassert (pdl->kind == SPECPDL_BACKTRACE);
-  pdl->bt.nargs = n;
+  pdl->bt.nargs = nargs;
 }
 
 static void
@@ -334,10 +328,10 @@ call_debugger (Lisp_Object arg)
 }
 
 static void
-do_debug_on_call (Lisp_Object code)
+do_debug_on_call (Lisp_Object code, ptrdiff_t count)
 {
   debug_on_next_call = 0;
-  set_backtrace_debug_on_exit (specpdl_ptr - 1, true);
+  set_backtrace_debug_on_exit (specpdl + count, true);
   call_debugger (list1 (code));
 }
 
@@ -1272,8 +1266,11 @@ internal_lisp_condition_case (volatile Lisp_Object var, Lisp_Object bodyform,
 
   { /* The first clause is the one that should be checked first, so it should
        be added to handlerlist last.  So we build in `clauses' a table that
-       contains `handlers' but in reverse order.  */
-    Lisp_Object *clauses = alloca (clausenb * sizeof (Lisp_Object *));
+       contains `handlers' but in reverse order.  SAFE_ALLOCA won't work
+       here due to the setjmp, so impose a MAX_ALLOCA limit.  */
+    if (MAX_ALLOCA / word_size < clausenb)
+      memory_full (SIZE_MAX);
+    Lisp_Object *clauses = alloca (clausenb * sizeof *clauses);
     Lisp_Object *volatile clauses_volatile = clauses;
     int i = clausenb;
     for (val = handlers; CONSP (val); val = XCDR (val))
@@ -1311,7 +1308,7 @@ internal_lisp_condition_case (volatile Lisp_Object var, Lisp_Object bodyform,
             return val;
           }
       }
-    }
+  }
 
   val = eval_sub (bodyform);
   handlerlist = oldhandlerlist;
@@ -2032,9 +2029,11 @@ grow_specpdl (void)
     }
 }
 
-void
+ptrdiff_t
 record_in_backtrace (Lisp_Object function, Lisp_Object *args, ptrdiff_t nargs)
 {
+  ptrdiff_t count = SPECPDL_INDEX ();
+
   eassert (nargs >= UNEVALLED);
   specpdl_ptr->bt.kind = SPECPDL_BACKTRACE;
   specpdl_ptr->bt.debug_on_exit = false;
@@ -2042,6 +2041,8 @@ record_in_backtrace (Lisp_Object function, Lisp_Object *args, ptrdiff_t nargs)
   specpdl_ptr->bt.args = args;
   specpdl_ptr->bt.nargs = nargs;
   grow_specpdl ();
+
+  return count;
 }
 
 /* Eval a sub-expression of the current expression (i.e. in the same
@@ -2052,6 +2053,7 @@ eval_sub (Lisp_Object form)
   Lisp_Object fun, val, original_fun, original_args;
   Lisp_Object funcar;
   struct gcpro gcpro1, gcpro2, gcpro3;
+  ptrdiff_t count;
 
   if (SYMBOLP (form))
     {
@@ -2089,10 +2091,10 @@ eval_sub (Lisp_Object form)
   original_args = XCDR (form);
 
   /* This also protects them from gc.  */
-  record_in_backtrace (original_fun, &original_args, UNEVALLED);
+  count = record_in_backtrace (original_fun, &original_args, UNEVALLED);
 
   if (debug_on_next_call)
-    do_debug_on_call (Qt);
+    do_debug_on_call (Qt, count);
 
   /* At this point, only original_fun and original_args
      have values that will be used below.  */
@@ -2144,8 +2146,7 @@ eval_sub (Lisp_Object form)
               gcpro3.nvars = argnum;
             }
 
-          set_backtrace_args (specpdl_ptr - 1, vals);
-          set_backtrace_nargs (specpdl_ptr - 1, XINT (numargs));
+          set_backtrace_args (specpdl + count, vals, XINT (numargs));
 
           val = (XSUBR (fun)->function.aMANY) (XINT (numargs), vals);
           UNGCPRO;
@@ -2166,8 +2167,7 @@ eval_sub (Lisp_Object form)
 
           UNGCPRO;
 
-          set_backtrace_args (specpdl_ptr - 1, argvals);
-          set_backtrace_nargs (specpdl_ptr - 1, XINT (numargs));
+          set_backtrace_args (specpdl + count, argvals, XINT (numargs));
 
           switch (i)
             {
@@ -2220,7 +2220,7 @@ eval_sub (Lisp_Object form)
         }
     }
   else if (COMPILEDP (fun))
-    val = apply_lambda (fun, original_args);
+    val = apply_lambda (fun, original_args, count);
   else
     {
       if (NILP (fun))
@@ -2237,7 +2237,7 @@ eval_sub (Lisp_Object form)
         }
       if (EQ (funcar, Qmacro))
         {
-          ptrdiff_t count = SPECPDL_INDEX ();
+          ptrdiff_t count1 = SPECPDL_INDEX ();
           Lisp_Object exp;
           /* Bind lexical-binding during expansion of the macro, so the
              macro can know reliably if the code it outputs will be
@@ -2245,19 +2245,19 @@ eval_sub (Lisp_Object form)
           specbind (Qlexical_binding,
                     NILP (Vinternal_interpreter_environment) ? Qnil : Qt);
           exp = apply1 (Fcdr (fun), original_args);
-          unbind_to (count, Qnil);
+          unbind_to (count1, Qnil);
           val = eval_sub (exp);
         }
       else if (EQ (funcar, Qlambda)
                || EQ (funcar, Qclosure))
-        val = apply_lambda (fun, original_args);
+        val = apply_lambda (fun, original_args, count);
       else
         xsignal1 (Qinvalid_function, original_fun);
     }
   check_cons_list ();
 
   lisp_eval_depth--;
-  if (backtrace_debug_on_exit (specpdl_ptr - 1))
+  if (backtrace_debug_on_exit (specpdl + count))
     val = call_debugger (list2 (Qexit, val));
   specpdl_ptr--;
 
@@ -2271,12 +2271,10 @@ Thus, (apply '+ 1 2 '(3 4)) returns 10.
 usage: (apply FUNCTION &rest ARGUMENTS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  ptrdiff_t i;
-  EMACS_INT numargs;
+  ptrdiff_t i, numargs, funcall_nargs;
   register Lisp_Object spread_arg;
   register Lisp_Object *funcall_args;
   Lisp_Object fun, retval;
-  struct gcpro gcpro1;
   USE_SAFE_ALLOCA;
 
   fun = args [0];
@@ -2317,10 +2315,9 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
           /* Avoid making funcall cons up a yet another new vector of arguments
              by explicitly supplying nil's for optional values.  */
           SAFE_ALLOCA_LISP (funcall_args, 1 + XSUBR (fun)->max_args);
-          for (i = numargs; i < XSUBR (fun)->max_args;)
+          for (i = numargs; i < XSUBR (fun)->max_args; /* nothing */)
             funcall_args[++i] = Qnil;
-          GCPRO1 (*funcall_args);
-          gcpro1.nvars = 1 + XSUBR (fun)->max_args;
+          funcall_nargs = 1 + XSUBR (fun)->max_args;
         }
     }
  funcall:
@@ -2329,8 +2326,7 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
   if (!funcall_args)
     {
       SAFE_ALLOCA_LISP (funcall_args, 1 + numargs);
-      GCPRO1 (*funcall_args);
-      gcpro1.nvars = 1 + numargs;
+      funcall_nargs = 1 + numargs;
     }
 
   memcpy (funcall_args, args, nargs * word_size);
@@ -2343,11 +2339,10 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
       spread_arg = XCDR (spread_arg);
     }
 
-  /* By convention, the caller needs to gcpro Ffuncall's args.  */
-  retval = Ffuncall (gcpro1.nvars, funcall_args);
-  UNGCPRO;
-  SAFE_FREE ();
+  /* Ffuncall gcpro's all of its args.  */
+  retval = Ffuncall (funcall_nargs, funcall_args);
 
+  SAFE_FREE ();
   return retval;
 }
 
@@ -2555,41 +2550,22 @@ run_hook_with_args (ptrdiff_t nargs, Lisp_Object *args,
 void
 run_hook_with_args_2 (Lisp_Object hook, Lisp_Object arg1, Lisp_Object arg2)
 {
-  Lisp_Object temp[3];
-  temp[0] = hook;
-  temp[1] = arg1;
-  temp[2] = arg2;
-
-  Frun_hook_with_args (3, temp);
+  Frun_hook_with_args (3, ((Lisp_Object []) { hook, arg1, arg2 }));
 }
-
+
 /* Apply fn to arg.  */
 Lisp_Object
 apply1 (Lisp_Object fn, Lisp_Object arg)
 {
-  struct gcpro gcpro1;
-
-  GCPRO1 (fn);
-  if (NILP (arg))
-    RETURN_UNGCPRO (Ffuncall (1, &fn));
-  gcpro1.nvars = 2;
-  {
-    Lisp_Object args[2];
-    args[0] = fn;
-    args[1] = arg;
-    gcpro1.var = args;
-    RETURN_UNGCPRO (Fapply (2, args));
-  }
+  return (NILP (arg) ? Ffuncall (1, &fn)
+          : Fapply (2, ((Lisp_Object []) { fn, arg })));
 }
 
 /* Call function fn on no arguments.  */
 Lisp_Object
 call0 (Lisp_Object fn)
 {
-  struct gcpro gcpro1;
-
-  GCPRO1 (fn);
-  RETURN_UNGCPRO (Ffuncall (1, &fn));
+  return Ffuncall (1, &fn);
 }
 
 /* Call function fn with 1 argument arg1.  */
@@ -2597,14 +2573,7 @@ call0 (Lisp_Object fn)
 Lisp_Object
 call1 (Lisp_Object fn, Lisp_Object arg1)
 {
-  struct gcpro gcpro1;
-  Lisp_Object args[2];
-
-  args[0] = fn;
-  args[1] = arg1;
-  GCPRO1 (args[0]);
-  gcpro1.nvars = 2;
-  RETURN_UNGCPRO (Ffuncall (2, args));
+  return Ffuncall (2, ((Lisp_Object []) { fn, arg1 }));
 }
 
 /* Call function fn with 2 arguments arg1, arg2.  */
@@ -2612,14 +2581,7 @@ call1 (Lisp_Object fn, Lisp_Object arg1)
 Lisp_Object
 call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
 {
-  struct gcpro gcpro1;
-  Lisp_Object args[3];
-  args[0] = fn;
-  args[1] = arg1;
-  args[2] = arg2;
-  GCPRO1 (args[0]);
-  gcpro1.nvars = 3;
-  RETURN_UNGCPRO (Ffuncall (3, args));
+  return Ffuncall (3, ((Lisp_Object []) { fn, arg1, arg2 }));
 }
 
 /* Call function fn with 3 arguments arg1, arg2, arg3.  */
@@ -2627,15 +2589,7 @@ call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
 Lisp_Object
 call3 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3)
 {
-  struct gcpro gcpro1;
-  Lisp_Object args[4];
-  args[0] = fn;
-  args[1] = arg1;
-  args[2] = arg2;
-  args[3] = arg3;
-  GCPRO1 (args[0]);
-  gcpro1.nvars = 4;
-  RETURN_UNGCPRO (Ffuncall (4, args));
+  return Ffuncall (4, ((Lisp_Object []) { fn, arg1, arg2, arg3 }));
 }
 
 /* Call function fn with 4 arguments arg1, arg2, arg3, arg4.  */
@@ -2644,16 +2598,7 @@ Lisp_Object
 call4 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
        Lisp_Object arg4)
 {
-  struct gcpro gcpro1;
-  Lisp_Object args[5];
-  args[0] = fn;
-  args[1] = arg1;
-  args[2] = arg2;
-  args[3] = arg3;
-  args[4] = arg4;
-  GCPRO1 (args[0]);
-  gcpro1.nvars = 5;
-  RETURN_UNGCPRO (Ffuncall (5, args));
+  return Ffuncall (5, ((Lisp_Object []) { fn, arg1, arg2, arg3, arg4 }));
 }
 
 /* Call function fn with 5 arguments arg1, arg2, arg3, arg4, arg5.  */
@@ -2662,17 +2607,7 @@ Lisp_Object
 call5 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
        Lisp_Object arg4, Lisp_Object arg5)
 {
-  struct gcpro gcpro1;
-  Lisp_Object args[6];
-  args[0] = fn;
-  args[1] = arg1;
-  args[2] = arg2;
-  args[3] = arg3;
-  args[4] = arg4;
-  args[5] = arg5;
-  GCPRO1 (args[0]);
-  gcpro1.nvars = 6;
-  RETURN_UNGCPRO (Ffuncall (6, args));
+  return Ffuncall (6, ((Lisp_Object []) { fn, arg1, arg2, arg3, arg4, arg5 }));
 }
 
 /* Call function fn with 6 arguments arg1, arg2, arg3, arg4, arg5, arg6.  */
@@ -2681,18 +2616,8 @@ Lisp_Object
 call6 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
        Lisp_Object arg4, Lisp_Object arg5, Lisp_Object arg6)
 {
-  struct gcpro gcpro1;
-  Lisp_Object args[7];
-  args[0] = fn;
-  args[1] = arg1;
-  args[2] = arg2;
-  args[3] = arg3;
-  args[4] = arg4;
-  args[5] = arg5;
-  args[6] = arg6;
-  GCPRO1 (args[0]);
-  gcpro1.nvars = 7;
-  RETURN_UNGCPRO (Ffuncall (7, args));
+  return Ffuncall (7, ((Lisp_Object [])
+    { fn, arg1, arg2, arg3, arg4, arg5, arg6 }));
 }
 
 /* Call function fn with 7 arguments arg1, arg2, arg3, arg4, arg5, arg6, arg7.  */
@@ -2701,19 +2626,8 @@ Lisp_Object
 call7 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
        Lisp_Object arg4, Lisp_Object arg5, Lisp_Object arg6, Lisp_Object arg7)
 {
-  struct gcpro gcpro1;
-  Lisp_Object args[8];
-  args[0] = fn;
-  args[1] = arg1;
-  args[2] = arg2;
-  args[3] = arg3;
-  args[4] = arg4;
-  args[5] = arg5;
-  args[6] = arg6;
-  args[7] = arg7;
-  GCPRO1 (args[0]);
-  gcpro1.nvars = 8;
-  RETURN_UNGCPRO (Ffuncall (8, args));
+  return Ffuncall (8, ((Lisp_Object [])
+    { fn, arg1, arg2, arg3, arg4, arg5, arg6, arg7 }));
 }
 
 /* The caller should GCPRO all the elements of ARGS.  */
@@ -2740,7 +2654,7 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
   Lisp_Object lisp_numargs;
   Lisp_Object val;
   register Lisp_Object *internal_args;
-  ptrdiff_t i;
+  ptrdiff_t i, count;
 
   QUIT;
 
@@ -2753,13 +2667,13 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
     }
 
   /* This also GCPROs them.  */
-  record_in_backtrace (args[0], &args[1], nargs - 1);
+  count = record_in_backtrace (args[0], &args[1], nargs - 1);
 
   /* Call GC after setting up the backtrace, so the latter GCPROs the args.  */
   maybe_gc ();
 
   if (debug_on_next_call)
-    do_debug_on_call (Qlambda);
+    do_debug_on_call (Qlambda, count);
 
   check_cons_list ();
 
@@ -2789,10 +2703,11 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
         val = (XSUBR (fun)->function.aMANY) (numargs, args + 1);
       else
         {
+          Lisp_Object internal_argbuf[8];
           if (XSUBR (fun)->max_args > numargs)
             {
-              internal_args = alloca (XSUBR (fun)->max_args
-                                      * sizeof *internal_args);
+              eassert (XSUBR (fun)->max_args <= ARRAYELTS (internal_argbuf));
+              internal_args = internal_argbuf;
               memcpy (internal_args, args + 1, numargs * word_size);
               for (i = numargs; i < XSUBR (fun)->max_args; i++)
                 internal_args[i] = Qnil;
@@ -2878,14 +2793,14 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
     }
   check_cons_list ();
   lisp_eval_depth--;
-  if (backtrace_debug_on_exit (specpdl_ptr - 1))
+  if (backtrace_debug_on_exit (specpdl + count))
     val = call_debugger (list2 (Qexit, val));
   specpdl_ptr--;
   return val;
 }
 
 static Lisp_Object
-apply_lambda (Lisp_Object fun, Lisp_Object args)
+apply_lambda (Lisp_Object fun, Lisp_Object args, ptrdiff_t count)
 {
   Lisp_Object args_left;
   ptrdiff_t i;
@@ -2912,15 +2827,14 @@ apply_lambda (Lisp_Object fun, Lisp_Object args)
 
   UNGCPRO;
 
-  set_backtrace_args (specpdl_ptr - 1, arg_vector);
-  set_backtrace_nargs (specpdl_ptr - 1, i);
+  set_backtrace_args (specpdl + count, arg_vector, i);
   tem = funcall_lambda (fun, numargs, arg_vector);
 
   /* Do the debug-on-exit now, while arg_vector still exists.  */
-  if (backtrace_debug_on_exit (specpdl_ptr - 1))
+  if (backtrace_debug_on_exit (specpdl + count))
     {
       /* Don't do it again when we return to eval.  */
-      set_backtrace_debug_on_exit (specpdl_ptr - 1, false);
+      set_backtrace_debug_on_exit (specpdl + count, false);
       tem = call_debugger (list2 (Qexit, tem));
     }
   SAFE_FREE ();
diff --git a/src/fileio.c b/src/fileio.c
index d9c7397c2de..4ba1c5914e8 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -396,13 +396,6 @@ Otherwise return a directory name.
 Given a Unix syntax file name, returns a string ending in slash.  */)
   (Lisp_Object filename)
 {
-#ifndef DOS_NT
-  register const char *beg;
-#else
-  register char *beg;
-  Lisp_Object tem_fn;
-#endif
-  register const char *p;
   Lisp_Object handler;
 
   CHECK_STRING (filename);
@@ -417,12 +410,8 @@ Given a Unix syntax file name, returns a string ending in slash.  */)
       return STRINGP (handled_name) ? handled_name : Qnil;
     }
 
-#ifdef DOS_NT
-  beg = xlispstrdupa (filename);
-#else
-  beg = SSDATA (filename);
-#endif
-  p = beg + SBYTES (filename);
+  char *beg = SSDATA (filename);
+  char const *p = beg + SBYTES (filename);
 
   while (p != beg && !IS_DIRECTORY_SEP (p[-1])
 #ifdef DOS_NT
@@ -438,6 +427,11 @@ Given a Unix syntax file name, returns a string ending in slash.  */)
     return Qnil;
 #ifdef DOS_NT
   /* Expansion of "c:" to drive and default directory.  */
+  Lisp_Object tem_fn;
+  USE_SAFE_ALLOCA;
+  SAFE_ALLOCA_STRING (beg, filename);
+  p = beg + (p - SSDATA (filename));
+
   if (p[-1] == ':')
     {
       /* MAXPATHLEN+1 is guaranteed to be enough space for getdefdir.  */
@@ -481,6 +475,7 @@ Given a Unix syntax file name, returns a string ending in slash.  */)
       dostounix_filename (beg);
       tem_fn = make_specified_string (beg, -1, p - beg, 0);
     }
+  SAFE_FREE ();
   return tem_fn;
 #else  /* DOS_NT */
   return make_specified_string (beg, -1, p - beg, STRING_MULTIBYTE (filename));
@@ -733,7 +728,7 @@ Lisp_Object
 make_temp_name (Lisp_Object prefix, bool base64_p)
 {
   Lisp_Object val, encoded_prefix;
-  int len;
+  ptrdiff_t len;
   printmax_t pid;
   char *p, *data;
   char pidbuf[INT_BUFSIZE_BOUND (printmax_t)];
@@ -847,8 +842,6 @@ probably use `make-temp-file' instead, except in three circumstances:
   return make_temp_name (prefix, 0);
 }
 
-
-
 DEFUN ("expand-file-name", Fexpand_file_name, Sexpand_file_name, 1, 2, 0,
        doc: /* Convert filename NAME to absolute, and canonicalize it.
 Second arg DEFAULT-DIRECTORY is directory to start with if NAME is relative
@@ -878,7 +871,9 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
   /* These point to SDATA and need to be careful with string-relocation
      during GC (via DECODE_FILE).  */
   char *nm;
+  char *nmlim;
   const char *newdir;
+  const char *newdirlim;
   /* This should only point to alloca'd data.  */
   char *target;
 
@@ -886,10 +881,10 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
   struct passwd *pw;
 #ifdef DOS_NT
   int drive = 0;
-  bool collapse_newdir = 1;
+  bool collapse_newdir = true;
   bool is_escaped = 0;
 #endif /* DOS_NT */
-  ptrdiff_t length;
+  ptrdiff_t length, nbytes;
   Lisp_Object handler, result, handled_name;
   bool multibyte;
   Lisp_Object hdir;
@@ -1018,8 +1013,9 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
     default_directory = Fdowncase (default_directory);
 #endif
 
-  /* Make a local copy of nm[] to protect it from GC in DECODE_FILE below.  */
-  nm = xlispstrdupa (name);
+  /* Make a local copy of NAME to protect it from GC in DECODE_FILE below.  */
+  SAFE_ALLOCA_STRING (nm, name);
+  nmlim = nm + SBYTES (name);
 
 #ifdef DOS_NT
   /* Note if special escape prefix is present, but remove for now.  */
@@ -1104,7 +1100,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           if (IS_DIRECTORY_SEP (nm[1]))
             {
               if (strcmp (nm, SSDATA (name)) != 0)
-                name = make_specified_string (nm, -1, strlen (nm), multibyte);
+                name = make_specified_string (nm, -1, nmlim - nm, multibyte);
             }
           else
 #endif
@@ -1115,18 +1111,19 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
 
               name = make_specified_string (nm, -1, p - nm, multibyte);
               temp[0] = DRIVE_LETTER (drive);
-              name = concat2 (build_string (temp), name);
+              AUTO_STRING (drive_prefix, temp);
+              name = concat2 (drive_prefix, name);
             }
 #ifdef WINDOWSNT
           if (!NILP (Vw32_downcase_file_names))
             name = Fdowncase (name);
 #endif
-          return name;
 #else /* not DOS_NT */
-          if (strcmp (nm, SSDATA (name)) == 0)
-            return name;
-          return make_specified_string (nm, -1, strlen (nm), multibyte);
+          if (strcmp (nm, SSDATA (name)) != 0)
+            name = make_specified_string (nm, -1, nmlim - nm, multibyte);
 #endif /* not DOS_NT */
+          SAFE_FREE ();
+          return name;
         }
     }
 
@@ -1146,7 +1143,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
      return an absolute name, if the final prefix is not absolute we
      append it to the current working directory.  */
 
-  newdir = 0;
+  newdir = newdirlim = 0;
 
   if (nm[0] == '~')             /* prefix ~ */
     {
@@ -1156,7 +1153,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           Lisp_Object tem;
 
           if (!(newdir = egetenv ("HOME")))
-            newdir = "";
+            newdir = newdirlim = "";
           nm++;
           /* `egetenv' may return a unibyte string, which will bite us since
              we expect the directory to be multibyte.  */
@@ -1171,13 +1168,15 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           else
 #endif
             tem = build_string (newdir);
+          newdirlim = newdir + SBYTES (tem);
           if (multibyte && !STRING_MULTIBYTE (tem))
             {
               hdir = DECODE_FILE (tem);
               newdir = SSDATA (hdir);
+              newdirlim = newdir + SBYTES (hdir);
             }
 #ifdef DOS_NT
-          collapse_newdir = 0;
+          collapse_newdir = false;
 #endif
         }
       else                      /* ~user/filename */
@@ -1201,14 +1200,16 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
                  bite us since we expect the directory to be
                  multibyte.  */
               tem = build_string (newdir);
+              newdirlim = newdir + SBYTES (tem);
               if (multibyte && !STRING_MULTIBYTE (tem))
                 {
                   hdir = DECODE_FILE (tem);
                   newdir = SSDATA (hdir);
+                  newdirlim = newdir + SBYTES (hdir);
                 }
               nm = p;
 #ifdef DOS_NT
-              collapse_newdir = 0;
+              collapse_newdir = false;
 #endif
             }
 
@@ -1234,8 +1235,11 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
               Lisp_Object tem = build_string (adir);
 
               tem = DECODE_FILE (tem);
+              newdirlim = adir + SBYTES (tem);
               memcpy (adir, SSDATA (tem), SBYTES (tem) + 1);
             }
+          else
+            newdirlim = adir + strlen (adir);
         }
       if (!adir)
         {
@@ -1245,6 +1249,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           adir[1] = ':';
           adir[2] = '/';
           adir[3] = 0;
+          newdirlim = adir + 3;
         }
       newdir = adir;
     }
@@ -1265,6 +1270,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
       && !newdir)
     {
       newdir = SSDATA (default_directory);
+      newdirlim = newdir + SBYTES (default_directory);
 #ifdef DOS_NT
       /* Note if special escape prefix is present, but remove for now.  */
       if (newdir[0] == '/' && newdir[1] == ':')
@@ -1309,12 +1315,15 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
             }
           if (!IS_DIRECTORY_SEP (nm[0]))
             {
-              ptrdiff_t newlen = strlen (newdir);
-              char *tmp = alloca (newlen + file_name_as_directory_slop
-                                  + strlen (nm) + 1);
-              file_name_as_directory (tmp, newdir, newlen, multibyte);
-              strcat (tmp, nm);
+              ptrdiff_t nmlen = nmlim - nm;
+              ptrdiff_t newdirlen = newdirlim - newdir;
+              char *tmp = alloca (newdirlen + file_name_as_directory_slop
+                                  + nmlen + 1);
+              ptrdiff_t dlen = file_name_as_directory (tmp, newdir, newdirlen,
+                                                       multibyte);
+              memcpy (tmp + dlen, nm, nmlen + 1);
               nm = tmp;
+              nmlim = nm + dlen + nmlen;
             }
           adir = alloca (adir_size);
           if (drive)
@@ -1329,8 +1338,11 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
               Lisp_Object tem = build_string (adir);
 
               tem = DECODE_FILE (tem);
+              newdirlim = adir + SBYTES (tem);
               memcpy (adir, SSDATA (tem), SBYTES (tem) + 1);
             }
+          else
+            newdirlim = adir + strlen (adir);
           newdir = adir;
         }
 
@@ -1349,35 +1361,32 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           if (IS_DIRECTORY_SEP (newdir[0]) && IS_DIRECTORY_SEP (newdir[1])
               && !IS_DIRECTORY_SEP (newdir[2]))
             {
-              char *adir = strcpy (alloca (strlen (newdir) + 1), newdir);
+              char *adir = strcpy (alloca (newdirlim - newdir + 1), newdir);
               char *p = adir + 2;
               while (*p && !IS_DIRECTORY_SEP (*p)) p++;
               p++;
               while (*p && !IS_DIRECTORY_SEP (*p)) p++;
               *p = 0;
               newdir = adir;
+              newdirlim = newdir + strlen (adir);
             }
           else
 #endif
-            newdir = "";
+            newdir = newdirlim = "";
         }
     }
 #endif /* DOS_NT */
 
-  if (newdir)
-    {
-      /* Ignore any slash at the end of newdir, unless newdir is
-         just "/" or "//".  */
-      length = strlen (newdir);
-      while (length > 1 && IS_DIRECTORY_SEP (newdir[length - 1])
-             && ! (length == 2 && IS_DIRECTORY_SEP (newdir[0])))
-        length--;
-    }
-  else
-    length = 0;
+  /* Ignore any slash at the end of newdir, unless newdir is
+     just "/" or "//".  */
+  length = newdirlim - newdir;
+  while (length > 1 && IS_DIRECTORY_SEP (newdir[length - 1])
+         && ! (length == 2 && IS_DIRECTORY_SEP (newdir[0])))
+    length--;
 
   /* Now concatenate the directory and name to new space in the stack frame.  */
-  tlen = length + file_name_as_directory_slop + strlen (nm) + 1;
+  tlen = length + file_name_as_directory_slop + (nmlim - nm) + 1;
+  eassert (tlen > file_name_as_directory_slop + 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
@@ -1388,6 +1397,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
   target = SAFE_ALLOCA (tlen);
 #endif /* not DOS_NT */
   *target = 0;
+  nbytes = 0;
 
   if (newdir)
     {
@@ -1405,13 +1415,14 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
             {
               memcpy (target, newdir, length);
               target[length] = 0;
+              nbytes = length;
             }
         }
       else
-        file_name_as_directory (target, newdir, length, multibyte);
+        nbytes = file_name_as_directory (target, newdir, length, multibyte);
     }
 
-  strcat (target, nm);
+  memcpy (target + nbytes, nm, nmlim - nm + 1);
 
   /* Now canonicalize by removing `//', `/.' and `/foo/..' if they
      appear.  */
@@ -1717,7 +1728,8 @@ search_embedded_absfilename (char *nm, char *endp)
           for (s = p; *s && !IS_DIRECTORY_SEP (*s); s++);
           if (p[0] == '~' && s > p + 1) /* We've got "/~something/".  */
             {
-              char *o = alloca (s - p + 1);
+              USE_SAFE_ALLOCA;
+              char *o = SAFE_ALLOCA (s - p + 1);
               struct passwd *pw;
               memcpy (o, p, s - p);
               o [s - p] = 0;
@@ -1728,6 +1740,7 @@ search_embedded_absfilename (char *nm, char *endp)
               block_input ();
               pw = getpwnam (o + 1);
               unblock_input ();
+              SAFE_FREE ();
               if (pw)
                 return p;
             }
@@ -1776,7 +1789,8 @@ 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 = xlispstrdupa (filename);
+  USE_SAFE_ALLOCA;
+  SAFE_ALLOCA_STRING (nm, filename);
 
 #ifdef DOS_NT
   dostounix_filename (nm);
@@ -1790,8 +1804,13 @@ those `/' is discarded.  */)
     /* Start over with the new string, so we check the file-name-handler
        again.  Important with filenames like "/home/foo//:/hello///there"
        which would substitute to "/:/hello///there" rather than "/there".  */
-    return Fsubstitute_in_file_name
-      (make_specified_string (p, -1, endp - p, multibyte));
+    {
+      Lisp_Object result
+        = (Fsubstitute_in_file_name
+           (make_specified_string (p, -1, endp - p, multibyte)));
+      SAFE_FREE ();
+      return result;
+    }
 
   /* See if any variables are substituted into the string.  */
 
@@ -1813,6 +1832,7 @@ those `/' is discarded.  */)
       if (!NILP (Vw32_downcase_file_names))
         filename = Fdowncase (filename);
 #endif
+      SAFE_FREE ();
       return filename;
     }
 
@@ -1831,14 +1851,14 @@ those `/' is discarded.  */)
     {
       Lisp_Object xname = make_specified_string (xnm, -1, x - xnm, multibyte);
 
-      xname = Fdowncase (xname);
-      return xname;
+      filename = Fdowncase (xname);
     }
   else
 #endif
-  return (xnm == SSDATA (filename)
-          ? filename
-          : make_specified_string (xnm, -1, x - xnm, multibyte));
+  if (xnm != SSDATA (filename))
+    filename = make_specified_string (xnm, -1, x - xnm, multibyte);
+  SAFE_FREE ();
+  return filename;
 }
 
 /* A slightly faster and more convenient way to get
@@ -2671,7 +2691,10 @@ emacs_readlinkat (int fd, char const *filename)
 
   val = build_unibyte_string (buf);
   if (buf[0] == '/' && strchr (buf, ':'))
-    val = concat2 (build_unibyte_string ("/:"), val);
+    {
+      AUTO_STRING (slash_colon, "/:");
+      val = concat2 (slash_colon, val);
+    }
   if (buf != readlink_buf)
     xfree (buf);
   val = DECODE_FILE (val);
@@ -2765,23 +2788,24 @@ searchable directory.  */)
     }
 
   absname = ENCODE_FILE (absname);
-  return file_accessible_directory_p (SSDATA (absname)) ? Qt : Qnil;
+  return file_accessible_directory_p (absname) ? Qt : Qnil;
 }
 
 /* If FILE is a searchable directory or a symlink to a
    searchable directory, return true.  Otherwise return
    false and set errno to an error number.  */
 bool
-file_accessible_directory_p (char const *file)
+file_accessible_directory_p (Lisp_Object file)
 {
 #ifdef DOS_NT
   /* There's no need to test whether FILE is searchable, as the
      searchable/executable bit is invented on DOS_NT platforms.  */
-  return file_directory_p (file);
+  return file_directory_p (SSDATA (file));
 #else
   /* On POSIXish platforms, use just one system call; this avoids a
      race and is typically faster.  */
-  ptrdiff_t len = strlen (file);
+  const char *data = SSDATA (file);
+  ptrdiff_t len = SBYTES (file);
   char const *dir;
   bool ok;
   int saved_errno;
@@ -2793,15 +2817,15 @@ file_accessible_directory_p (char const *file)
      "/" and "//" are distinct on some platforms, whereas "/", "///",
      "////", etc. are all equivalent.  */
   if (! len)
-    dir = file;
+    dir = data;
   else
     {
       /* Just check for trailing '/' when deciding whether to append '/'.
          That's simpler than testing the two special cases "/" and "//",
          and it's a safe optimization here.  */
       char *buf = SAFE_ALLOCA (len + 3);
-      memcpy (buf, file, len);
-      strcpy (buf + len, &"/."[file[len - 1] == '/']);
+      memcpy (buf, data, len);
+      strcpy (buf + len, &"/."[data[len - 1] == '/']);
       dir = buf;
     }
 
@@ -3624,13 +3648,14 @@ by calling `format-decode', which see.  */)
                 report_file_error ("Read error", orig_filename);
               else if (nread > 0)
                 {
+                  AUTO_STRING (name, " *code-converting-work*");
                   struct buffer *prev = current_buffer;
                   Lisp_Object workbuf;
                   struct buffer *buf;
 
                   record_unwind_current_buffer ();
 
-                  workbuf = Fget_buffer_create (build_string (" *code-converting-work*"));
+                  workbuf = Fget_buffer_create (name);
                   buf = XBUFFER (workbuf);
 
                   delete_all_overlays (buf);
@@ -5292,20 +5317,12 @@ If BUF is omitted or nil, it defaults to the current buffer.
 See Info node `(elisp)Modification Time' for more details.  */)
   (Lisp_Object buf)
 {
-  struct buffer *b;
+  struct buffer *b = decode_buffer (buf);
   struct stat st;
   Lisp_Object handler;
   Lisp_Object filename;
   struct timespec mtime;
 
-  if (NILP (buf))
-    b = current_buffer;
-  else
-    {
-      CHECK_BUFFER (buf);
-      b = XBUFFER (buf);
-    }
-
   if (!STRINGP (BVAR (b, filename))) return Qt;
   if (b->modtime.tv_nsec == UNKNOWN_MODTIME_NSECS) return Qt;
 
@@ -5399,7 +5416,7 @@ An argument specifies the modification time value to use
 static Lisp_Object
 auto_save_error (Lisp_Object error_val)
 {
-  Lisp_Object args[3], msg;
+  Lisp_Object msg;
   int i;
   struct gcpro gcpro1;
 
@@ -5407,10 +5424,10 @@ auto_save_error (Lisp_Object error_val)
 
   ring_bell (XFRAME (selected_frame));
 
-  args[0] = build_string ("Auto-saving %s: %s");
-  args[1] = BVAR (current_buffer, name);
-  args[2] = Ferror_message_string (error_val);
-  msg = Fformat (3, args);
+  AUTO_STRING (format, "Auto-saving %s: %s");
+  msg = Fformat (3, ((Lisp_Object [])
+                     {format, BVAR (current_buffer, name),
+                      Ferror_message_string (error_val)}));
   GCPRO1 (msg);
 
   for (i = 0; i < 3; ++i)
diff --git a/src/fns.c b/src/fns.c
index 33c02598359..e891fdbf1d5 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -24,6 +24,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <time.h>
 
 #include <intprops.h>
+#include <vla.h>
 
 #include "lisp.h"
 #include "commands.h"
@@ -41,6 +42,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 Lisp_Object Qstring_lessp;
+static Lisp_Object Qstring_collate_lessp, Qstring_collate_equalp;
 static Lisp_Object Qprovide, Qrequire;
 static Lisp_Object Qyes_or_no_p_history;
 Lisp_Object Qcursor_in_echo_area;
@@ -49,6 +51,8 @@ static Lisp_Object Qcodeset, Qdays, Qmonths, Qpaper;
 
 static Lisp_Object Qmd5, Qsha1, Qsha224, Qsha256, Qsha384, Qsha512;
 
+static void sort_vector_copy (Lisp_Object, ptrdiff_t,
+                              Lisp_Object [restrict], Lisp_Object [restrict]);
 static bool internal_equal (Lisp_Object, Lisp_Object, int, bool, Lisp_Object);
 
 DEFUN ("identity", Fidentity, Sidentity, 1, 1, 0,
@@ -343,6 +347,100 @@ Symbols are also allowed; their print names are used instead.  */)
     }
   return i1 < SCHARS (s2) ? Qt : Qnil;
 }
+
+DEFUN ("string-collate-lessp", Fstring_collate_lessp, Sstring_collate_lessp, 2, 4, 0,
+       doc: /* Return t if first arg string is less than second in collation order.
+Symbols are also allowed; their print names are used instead.
+
+This function obeys the conventions for collation order in your
+locale settings.  For example, punctuation and whitespace characters
+might be considered less significant for sorting:
+
+\(sort '\("11" "12" "1 1" "1 2" "1.1" "1.2") 'string-collate-lessp)
+  => \("11" "1 1" "1.1" "12" "1 2" "1.2")
+
+The optional argument LOCALE, a string, overrides the setting of your
+current locale identifier for collation.  The value is system
+dependent; a LOCALE \"en_US.UTF-8\" is applicable on POSIX systems,
+while it would be, e.g., \"enu_USA.1252\" on MS-Windows systems.
+
+If IGNORE-CASE is non-nil, characters are converted to lower-case
+before comparing them.
+
+To emulate Unicode-compliant collation on MS-Windows systems,
+bind `w32-collate-ignore-punctuation' to a non-nil value, since
+the codeset part of the locale cannot be \"UTF-8\" on MS-Windows.
+
+If your system does not support a locale environment, this function
+behaves like `string-lessp'.  */)
+  (Lisp_Object s1, Lisp_Object s2, Lisp_Object locale, Lisp_Object ignore_case)
+{
+#if defined __STDC_ISO_10646__ || defined WINDOWSNT
+  /* Check parameters.  */
+  if (SYMBOLP (s1))
+    s1 = SYMBOL_NAME (s1);
+  if (SYMBOLP (s2))
+    s2 = SYMBOL_NAME (s2);
+  CHECK_STRING (s1);
+  CHECK_STRING (s2);
+  if (!NILP (locale))
+    CHECK_STRING (locale);
+
+  return (str_collate (s1, s2, locale, ignore_case) < 0) ? Qt : Qnil;
+
+#else  /* !__STDC_ISO_10646__, !WINDOWSNT */
+  return Fstring_lessp (s1, s2);
+#endif /* !__STDC_ISO_10646__, !WINDOWSNT */
+}
+
+DEFUN ("string-collate-equalp", Fstring_collate_equalp, Sstring_collate_equalp, 2, 4, 0,
+       doc: /* Return t if two strings have identical contents.
+Symbols are also allowed; their print names are used instead.
+
+This function obeys the conventions for collation order in your locale
+settings.  For example, characters with different coding points but
+the same meaning might be considered as equal, like different grave
+accent Unicode characters:
+
+\(string-collate-equalp \(string ?\\uFF40) \(string ?\\u1FEF))
+  => t
+
+The optional argument LOCALE, a string, overrides the setting of your
+current locale identifier for collation.  The value is system
+dependent; a LOCALE \"en_US.UTF-8\" is applicable on POSIX systems,
+while it would be \"enu_USA.1252\" on MS Windows systems.
+
+If IGNORE-CASE is non-nil, characters are converted to lower-case
+before comparing them.
+
+To emulate Unicode-compliant collation on MS-Windows systems,
+bind `w32-collate-ignore-punctuation' to a non-nil value, since
+the codeset part of the locale cannot be \"UTF-8\" on MS-Windows.
+
+If your system does not support a locale environment, this function
+behaves like `string-equal'.
+
+Do NOT use this function to compare file names for equality, only
+for sorting them.  */)
+  (Lisp_Object s1, Lisp_Object s2, Lisp_Object locale, Lisp_Object ignore_case)
+{
+#if defined __STDC_ISO_10646__ || defined WINDOWSNT
+  /* Check parameters.  */
+  if (SYMBOLP (s1))
+    s1 = SYMBOL_NAME (s1);
+  if (SYMBOLP (s2))
+    s2 = SYMBOL_NAME (s2);
+  CHECK_STRING (s1);
+  CHECK_STRING (s2);
+  if (!NILP (locale))
+    CHECK_STRING (locale);
+
+  return (str_collate (s1, s2, locale, ignore_case) == 0) ? Qt : Qnil;
+
+#else  /* !__STDC_ISO_10646__, !WINDOWSNT */
+  return Fstring_equal (s1, s2);
+#endif /* !__STDC_ISO_10646__, !WINDOWSNT */
+}
 
 static Lisp_Object concat (ptrdiff_t nargs, Lisp_Object *args,
                            enum Lisp_Type target_type, bool last_special);
@@ -1773,13 +1871,12 @@ See also the function `nreverse', which is used more often.  */)
     wrong_type_argument (Qsequencep, seq);
   return new;
 }
-
-DEFUN ("sort", Fsort, Ssort, 2, 2, 0,
-       doc: /* Sort LIST, stably, comparing elements using PREDICATE.
-Returns the sorted list.  LIST is modified by side effects.
-PREDICATE is called with two elements of LIST, and should return non-nil
-if the first element should sort before the second.  */)
-  (Lisp_Object list, Lisp_Object predicate)
+
+/* Sort LIST using PREDICATE, preserving original order of elements
+   considered as equal.  */
+
+static Lisp_Object
+sort_list (Lisp_Object list, Lisp_Object predicate)
 {
   Lisp_Object front, back;
   register Lisp_Object len, tem;
@@ -1804,6 +1901,126 @@ if the first element should sort before the second.  */)
   return merge (front, back, predicate);
 }
 
+/* Using PRED to compare, return whether A and B are in order.
+   Compare stably when A appeared before B in the input.  */
+static bool
+inorder (Lisp_Object pred, Lisp_Object a, Lisp_Object b)
+{
+  return NILP (call2 (pred, b, a));
+}
+
+/* Using PRED to compare, merge from ALEN-length A and BLEN-length B
+   into DEST.  Argument arrays must be nonempty and must not overlap,
+   except that B might be the last part of DEST.  */
+static void
+merge_vectors (Lisp_Object pred,
+               ptrdiff_t alen, Lisp_Object const a[restrict VLA_ELEMS (alen)],
+               ptrdiff_t blen, Lisp_Object const b[VLA_ELEMS (blen)],
+               Lisp_Object dest[VLA_ELEMS (alen + blen)])
+{
+  eassume (0 < alen && 0 < blen);
+  Lisp_Object const *alim = a + alen;
+  Lisp_Object const *blim = b + blen;
+
+  while (true)
+    {
+      if (inorder (pred, a[0], b[0]))
+        {
+          *dest++ = *a++;
+          if (a == alim)
+            {
+              if (dest != b)
+                memcpy (dest, b, (blim - b) * sizeof *dest);
+              return;
+            }
+        }
+      else
+        {
+          *dest++ = *b++;
+          if (b == blim)
+            {
+              memcpy (dest, a, (alim - a) * sizeof *dest);
+              return;
+            }
+        }
+    }
+}
+
+/* Using PRED to compare, sort LEN-length VEC in place, using TMP for
+   temporary storage.  LEN must be at least 2.  */
+static void
+sort_vector_inplace (Lisp_Object pred, ptrdiff_t len,
+                     Lisp_Object vec[restrict VLA_ELEMS (len)],
+                     Lisp_Object tmp[restrict VLA_ELEMS (len >> 1)])
+{
+  eassume (2 <= len);
+  ptrdiff_t halflen = len >> 1;
+  sort_vector_copy (pred, halflen, vec, tmp);
+  if (1 < len - halflen)
+    sort_vector_inplace (pred, len - halflen, vec + halflen, vec);
+  merge_vectors (pred, halflen, tmp, len - halflen, vec + halflen, vec);
+}
+
+/* Using PRED to compare, sort from LEN-length SRC into DST.
+   Len must be positive.  */
+static void
+sort_vector_copy (Lisp_Object pred, ptrdiff_t len,
+                  Lisp_Object src[restrict VLA_ELEMS (len)],
+                  Lisp_Object dest[restrict VLA_ELEMS (len)])
+{
+  eassume (0 < len);
+  ptrdiff_t halflen = len >> 1;
+  if (halflen < 1)
+    dest[0] = src[0];
+  else
+    {
+      if (1 < halflen)
+        sort_vector_inplace (pred, halflen, src, dest);
+      if (1 < len - halflen)
+        sort_vector_inplace (pred, len - halflen, src + halflen, dest);
+      merge_vectors (pred, halflen, src, len - halflen, src + halflen, dest);
+    }
+}
+
+/* Sort VECTOR in place using PREDICATE, preserving original order of
+   elements considered as equal.  */
+
+static void
+sort_vector (Lisp_Object vector, Lisp_Object predicate)
+{
+  ptrdiff_t len = ASIZE (vector);
+  if (len < 2)
+    return;
+  ptrdiff_t halflen = len >> 1;
+  Lisp_Object *tmp;
+  struct gcpro gcpro1, gcpro2;
+  GCPRO2 (vector, predicate);
+  USE_SAFE_ALLOCA;
+  SAFE_ALLOCA_LISP (tmp, halflen);
+  for (ptrdiff_t i = 0; i < halflen; i++)
+    tmp[i] = make_number (0);
+  sort_vector_inplace (predicate, len, XVECTOR (vector)->contents, tmp);
+  SAFE_FREE ();
+  UNGCPRO;
+}
+
+DEFUN ("sort", Fsort, Ssort, 2, 2, 0,
+       doc: /* Sort SEQ, stably, comparing elements using PREDICATE.
+Returns the sorted sequence.  SEQ should be a list or vector.  SEQ is
+modified by side effects.  PREDICATE is called with two elements of
+SEQ, and should return non-nil if the first element should sort before
+the second.  */)
+  (Lisp_Object seq, Lisp_Object predicate)
+{
+  if (CONSP (seq))
+    seq = sort_list (seq, predicate);
+  else if (VECTORP (seq))
+    sort_vector (seq, predicate);
+  else if (!NILP (seq))
+    wrong_type_argument (Qsequencep, seq);
+  return seq;
+}
+
 Lisp_Object
 merge (Lisp_Object org_l1, Lisp_Object org_l2, Lisp_Object pred)
 {
@@ -1841,8 +2058,7 @@ merge (Lisp_Object org_l1, Lisp_Object org_l2, Lisp_Object pred)
           Fsetcdr (tail, l1);
           return value;
         }
-      tem = call2 (pred, Fcar (l2), Fcar (l1));
-      if (NILP (tem))
+      if (inorder (pred, Fcar (l1), Fcar (l2)))
         {
           tem = l1;
           l1 = Fcdr (l1);
@@ -2490,8 +2706,7 @@ If dialog boxes are supported, a dialog box will be used
 if `last-nonmenu-event' is nil, and `use-dialog-box' is non-nil.  */)
   (Lisp_Object prompt)
 {
-  register Lisp_Object ans;
-  Lisp_Object args[2];
+  Lisp_Object ans;
   struct gcpro gcpro1;
 
   CHECK_STRING (prompt);
@@ -2510,10 +2725,8 @@ if `last-nonmenu-event' is nil, and `use-dialog-box' is non-nil.  */)
       return obj;
     }
 
-  args[0] = prompt;
-  args[1] = build_string ("(yes or no) ");
-  prompt = Fconcat (2, args);
-
+  AUTO_STRING (yes_or_no, "(yes or no) ");
+  prompt = Fconcat (2, (Lisp_Object []) {prompt, yes_or_no});
   GCPRO1 (prompt);
 
   while (1)
@@ -3071,7 +3284,6 @@ into shorter lines.  */)
   if (encoded_length < 0)
     {
       /* The encoding wasn't possible. */
-      SAFE_FREE ();
       error ("Multibyte character in data for base64 encoding");
     }
 
@@ -3216,7 +3428,6 @@ If the region can't be decoded, signal an error and don't modify the buffer.  */
   if (decoded_length < 0)
     {
       /* The decoding wasn't possible. */
-      SAFE_FREE ();
       error ("Invalid base64 data");
     }
 
@@ -3784,12 +3995,9 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
 #ifdef ENABLE_CHECKING
       if (HASH_TABLE_P (Vpurify_flag)
           && XHASH_TABLE (Vpurify_flag) == h)
-        {
-          Lisp_Object args[2];
-          args[0] = build_string ("Growing hash table to: %d");
-          args[1] = make_number (new_size);
-          Fmessage (2, args);
-        }
+        Fmessage (2, ((Lisp_Object [])
+          { build_string ("Growing hash table to: %d"),
+            make_number (new_size) }));
 #endif
 
       set_hash_key_and_value (h, larger_vector (h->key_and_value,
@@ -4269,13 +4477,10 @@ sxhash (Lisp_Object obj, int depth)
       break;
 
     case Lisp_Misc:
+    case Lisp_Symbol:
       hash = XHASH (obj);
       break;
 
-    case Lisp_Symbol:
-      obj = SYMBOL_NAME (obj);
-      /* Fall through.  */
-
     case Lisp_String:
       hash = sxhash_string (SSDATA (obj), SBYTES (obj));
       break;
@@ -4363,12 +4568,12 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 {
   Lisp_Object test, size, rehash_size, rehash_threshold, weak;
   struct hash_table_test testdesc;
-  char *used;
   ptrdiff_t i;
+  USE_SAFE_ALLOCA;
 
   /* The vector `used' is used to keep track of arguments that
      have been consumed.  */
-  used = alloca (nargs * sizeof *used);
+  char *used = SAFE_ALLOCA (nargs * sizeof *used);
   memset (used, 0, nargs * sizeof *used);
 
   /* See if there's a `:test TEST' among the arguments.  */
@@ -4435,6 +4640,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
     if (!used[i])
       signal_error ("Invalid argument list", args[i]);
 
+  SAFE_FREE ();
   return make_hash_table (testdesc, size, rehash_size, rehash_threshold, weak);
 }
 
@@ -4919,6 +5125,8 @@ syms_of_fns (void)
   defsubr (&Sdefine_hash_table_test);
 
   DEFSYM (Qstring_lessp, "string-lessp");
+  DEFSYM (Qstring_collate_lessp, "string-collate-lessp");
+  DEFSYM (Qstring_collate_equalp, "string-collate-equalp");
   DEFSYM (Qprovide, "provide");
   DEFSYM (Qrequire, "require");
   DEFSYM (Qyes_or_no_p_history, "yes-or-no-p-history");
@@ -4972,6 +5180,8 @@ this variable.  */);
   defsubr (&Sstring_equal);
   defsubr (&Scompare_strings);
   defsubr (&Sstring_lessp);
+  defsubr (&Sstring_collate_lessp);
+  defsubr (&Sstring_collate_equalp);
   defsubr (&Sappend);
   defsubr (&Sconcat);
   defsubr (&Svconcat);
diff --git a/src/font.c b/src/font.c
index 054a68bfd94..08a25455cf8 100644
--- a/src/font.c
+++ b/src/font.c
@@ -273,10 +273,8 @@ static int num_font_drivers;
 Lisp_Object
 font_intern_prop (const char *str, ptrdiff_t len, bool force_symbol)
 {
-  ptrdiff_t i;
-  Lisp_Object tem;
-  Lisp_Object obarray;
-  ptrdiff_t nbytes, nchars;
+  ptrdiff_t i, nbytes, nchars;
+  Lisp_Object tem, name, obarray;
 
   if (len == 1 && *str == '*')
     return Qnil;
@@ -307,12 +305,11 @@ font_intern_prop (const char *str, ptrdiff_t len, bool force_symbol)
   parse_str_as_multibyte ((unsigned char *) str, len, &nchars, &nbytes);
   tem = oblookup (obarray, str,
                   (len == nchars || len != nbytes) ? len : nchars, len);
-
   if (SYMBOLP (tem))
     return tem;
-  tem = make_specified_string (str, nchars, len,
-                               len != nchars && len == nbytes);
-  return Fintern (tem, obarray);
+  name = make_specified_string (str, nchars, len,
+                                len != nchars && len == nbytes);
+  return intern_driver (name, obarray, XINT (tem));
 }
 
 /* Return a pixel size of font-spec SPEC on frame F.  */
@@ -366,7 +363,7 @@ font_style_to_value (enum font_property_index prop, Lisp_Object val,
     {
       int i, j;
       char *s;
-      Lisp_Object args[2], elt;
+      Lisp_Object elt;
 
       /* At first try exact match.  */
       for (i = 0; i < len; i++)
@@ -398,9 +395,9 @@ font_style_to_value (enum font_property_index prop, Lisp_Object val,
       eassert (len < 255);
       elt = Fmake_vector (make_number (2), make_number (100));
       ASET (elt, 1, val);
-      args[0] = table;
-      args[1] = Fmake_vector (make_number (1), elt);
-      ASET (font_style_table, prop - FONT_WEIGHT_INDEX, Fvconcat (2, args));
+      ASET (font_style_table, prop - FONT_WEIGHT_INDEX,
+            Fvconcat (2, ((Lisp_Object [])
+              { table, Fmake_vector (make_number (1), elt) })));
       return (100 << 8) | (i << 4);
     }
   else
@@ -1186,13 +1183,22 @@ font_parse_xlfd (char *name, ptrdiff_t len, Lisp_Object font)
         {
           val = prop[XLFD_ENCODING_INDEX];
           if (! NILP (val))
-            val = concat2 (build_string ("*-"), SYMBOL_NAME (val));
+            {
+              AUTO_STRING (star_dash, "*-");
+              val = concat2 (star_dash, SYMBOL_NAME (val));
+            }
         }
       else if (NILP (prop[XLFD_ENCODING_INDEX]))
-        val = concat2 (SYMBOL_NAME (val), build_string ("-*"));
+        {
+          AUTO_STRING (dash_star, "-*");
+          val = concat2 (SYMBOL_NAME (val), dash_star);
+        }
       else
-        val = concat3 (SYMBOL_NAME (val), build_string ("-"),
-                       SYMBOL_NAME (prop[XLFD_ENCODING_INDEX]));
+        {
+          AUTO_STRING (dash, "-");
+          val = concat3 (SYMBOL_NAME (val), dash,
+                         SYMBOL_NAME (prop[XLFD_ENCODING_INDEX]));
+        }
       if (! NILP (val))
         ASET (font, FONT_REGISTRY_INDEX, Fintern (val, Qnil));
 
@@ -1299,6 +1305,9 @@ font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
 
   val = AREF (font, FONT_SIZE_INDEX);
   eassert (NUMBERP (val) || NILP (val));
+  char font_size_index_buf[sizeof "-*"
+                           + max (INT_STRLEN_BOUND (EMACS_INT),
+                                  1 + DBL_MAX_10_EXP + 1)];
   if (INTEGERP (val))
     {
       EMACS_INT v = XINT (val);
@@ -1306,8 +1315,7 @@ font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
         v = pixel_size;
       if (v > 0)
         {
-          f[XLFD_PIXEL_INDEX] = p =
-            alloca (sizeof "-*" + INT_STRLEN_BOUND (EMACS_INT));
+          f[XLFD_PIXEL_INDEX] = p = font_size_index_buf;
           sprintf (p, "%"pI"d-*", v);
         }
       else
@@ -1316,21 +1324,22 @@ font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
   else if (FLOATP (val))
     {
       double v = XFLOAT_DATA (val) * 10;
-      f[XLFD_PIXEL_INDEX] = p = alloca (sizeof "*-" + 1 + DBL_MAX_10_EXP + 1);
+      f[XLFD_PIXEL_INDEX] = p = font_size_index_buf;
       sprintf (p, "*-%.0f", v);
     }
   else
     f[XLFD_PIXEL_INDEX] = "*-*";
 
+  char dpi_index_buf[sizeof "-" + 2 * INT_STRLEN_BOUND (EMACS_INT)];
   if (INTEGERP (AREF (font, FONT_DPI_INDEX)))
     {
       EMACS_INT v = XINT (AREF (font, FONT_DPI_INDEX));
-      f[XLFD_RESX_INDEX] = p =
-        alloca (sizeof "-" + 2 * INT_STRLEN_BOUND (EMACS_INT));
+      f[XLFD_RESX_INDEX] = p = dpi_index_buf;
       sprintf (p, "%"pI"d-%"pI"d", v, v);
     }
   else
     f[XLFD_RESX_INDEX] = "*-*";
+
   if (INTEGERP (AREF (font, FONT_SPACING_INDEX)))
     {
       EMACS_INT spacing = XINT (AREF (font, FONT_SPACING_INDEX));
@@ -1342,13 +1351,16 @@ font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
     }
   else
     f[XLFD_SPACING_INDEX] = "*";
+
+  char avgwidth_index_buf[INT_BUFSIZE_BOUND (EMACS_INT)];
   if (INTEGERP (AREF (font,  FONT_AVGWIDTH_INDEX)))
     {
-      f[XLFD_AVGWIDTH_INDEX] = p = alloca (INT_BUFSIZE_BOUND (EMACS_INT));
+      f[XLFD_AVGWIDTH_INDEX] = p = avgwidth_index_buf;
       sprintf (p, "%"pI"d", XINT (AREF (font, FONT_AVGWIDTH_INDEX)));
     }
   else
     f[XLFD_AVGWIDTH_INDEX] = "*";
+
   len = snprintf (name, nbytes, "-%s-%s-%s-%s-%s-%s-%s-%s-%s-%s-%s",
                   f[XLFD_FOUNDRY_INDEX], f[XLFD_FAMILY_INDEX],
                   f[XLFD_WEIGHT_INDEX], f[XLFD_SLANT_INDEX],
@@ -1751,7 +1763,7 @@ font_parse_name (char *name, ptrdiff_t namelen, Lisp_Object font)
 void
 font_parse_family_registry (Lisp_Object family, Lisp_Object registry, Lisp_Object font_spec)
 {
-  int len;
+  ptrdiff_t len;
   char *p0, *p1;
 
   if (! NILP (family)
@@ -1782,10 +1794,8 @@ font_parse_family_registry (Lisp_Object family, Lisp_Object registry, Lisp_Objec
       p1 = strchr (p0, '-');
       if (! p1)
         {
-          if (SDATA (registry)[len - 1] == '*')
-            registry = concat2 (registry, build_string ("-*"));
-          else
-            registry = concat2 (registry, build_string ("*-*"));
+          AUTO_STRING (extra, ("*-*" + (len && p0[len - 1] == '*')));
+          registry = concat2 (registry, extra);
         }
       registry = Fdowncase (registry);
       ASET (font_spec, FONT_REGISTRY_INDEX, Fintern (registry, Qnil));
@@ -2185,13 +2195,17 @@ font_score (Lisp_Object entity, Lisp_Object *spec_prop)
 static Lisp_Object
 font_vconcat_entity_vectors (Lisp_Object list)
 {
-  int nargs = XINT (Flength (list));
-  Lisp_Object *args = alloca (word_size * nargs);
-  int i;
+  EMACS_INT nargs = XFASTINT (Flength (list));
+  Lisp_Object *args;
+  USE_SAFE_ALLOCA;
+  SAFE_ALLOCA_LISP (args, nargs);
+  ptrdiff_t i;
 
   for (i = 0; i < nargs; i++, list = XCDR (list))
     args[i] = XCAR (list);
-  return Fvconcat (nargs, args);
+  Lisp_Object result = Fvconcat (nargs, args);
+  SAFE_FREE ();
+  return result;
 }
 
 
@@ -2674,7 +2688,7 @@ font_delete_unmatched (Lisp_Object vec, Lisp_Object spec, int size)
 {
   Lisp_Object entity, val;
   enum font_property_index prop;
-  int i;
+  ptrdiff_t i;
 
   for (val = Qnil, i = ASIZE (vec) - 1; i >= 0; i--)
     {
@@ -3219,9 +3233,10 @@ font_find_for_lface (struct frame *f, Lisp_Object *attrs, Lisp_Object spec, int
       val = attrs[LFACE_FAMILY_INDEX];
       val = font_intern_prop (SSDATA (val), SBYTES (val), 1);
     }
+  Lisp_Object familybuf[3];
   if (NILP (val))
     {
-      family = alloca ((sizeof family[0]) * 2);
+      family = familybuf;
       family[0] = Qnil;
       family[1] = zero_vector;  /* terminator.  */
     }
@@ -3242,7 +3257,7 @@ font_find_for_lface (struct frame *f, Lisp_Object *attrs, Lisp_Object spec, int
         }
       else
         {
-          family = alloca ((sizeof family[0]) * 3);
+          family = familybuf;
           i = 0;
           family[i++] = val;
           if (NILP (AREF (spec, FONT_FAMILY_INDEX)))
@@ -3529,8 +3544,9 @@ font_update_drivers (struct frame *f, Lisp_Object new_drivers)
       struct font_driver_list **list_table, **next;
       Lisp_Object tail;
       int i;
+      USE_SAFE_ALLOCA;
 
-      list_table = alloca (sizeof list_table[0] * (num_font_drivers + 1));
+      SAFE_NALLOCA (list_table, 1, num_font_drivers + 1);
       for (i = 0, tail = new_drivers; ! NILP (tail); tail = XCDR (tail))
         {
           for (list = f->font_driver_list; list; list = list->next)
@@ -3551,6 +3567,7 @@ font_update_drivers (struct frame *f, Lisp_Object new_drivers)
           next = &(*next)->next;
         }
       *next = NULL;
+      SAFE_FREE ();
 
       if (! f->font_driver_list->on)
         { /* None of the drivers is enabled: enable them all.
@@ -4252,7 +4269,7 @@ the consecutive wildcards are folded into one.  */)
         {
           if (NILP (fold_wildcards))
             return font_name;
-          strcpy (name, SSDATA (font_name));
+          lispstpcpy (name, font_name);
           namelen = SBYTES (font_name);
           goto done;
         }
@@ -4670,9 +4687,10 @@ DEFUN ("font-get-glyphs", Ffont_get_glyphs, Sfont_get_glyphs, 3, 4, 0,
        doc:
        /* Return a vector of FONT-OBJECT's glyphs for the specified characters.
 FROM and TO are positions (integers or markers) specifying a region
-of the current buffer.
-If the optional fourth arg OBJECT is not nil, it is a string or a
-vector containing the target characters.
+of the current buffer, and can be in either order.  If the optional
+fourth arg OBJECT is not nil, it is a string or a vector containing
+the target characters between indices FROM and TO, which are treated
+as in `substring'.
 
 Each element is a vector containing information of a glyph in this format:
   [FROM-IDX TO-IDX C CODE WIDTH LBEARING RBEARING ASCENT DESCENT ADJUSTMENT]
@@ -4715,45 +4733,50 @@ the corresponding element is nil.  */)
   else if (STRINGP (object))
     {
       const unsigned char *p;
+      ptrdiff_t ifrom, ito;
 
-      CHECK_NUMBER (from);
-      CHECK_NUMBER (to);
-      if (XINT (from) < 0 || XINT (from) > XINT (to)
-          || XINT (to) > SCHARS (object))
-        args_out_of_range_3 (object, from, to);
-      if (EQ (from, to))
+      validate_subarray (object, from, to, SCHARS (object), &ifrom, &ito);
+      if (ifrom == ito)
         return Qnil;
-      len = XFASTINT (to) - XFASTINT (from);
+      len = ito - ifrom;
       SAFE_ALLOCA_LISP (chars, len);
       p = SDATA (object);
       if (STRING_MULTIBYTE (object))
-        for (i = 0; i < len; i++)
+        {
+          int c;
+
+          /* Skip IFROM characters from the beginning.  */
+          for (i = 0; i < ifrom; i++)
+            c = STRING_CHAR_ADVANCE (p);
+
+          /* Now fetch an interesting characters.  */
+          for (i = 0; i < len; i++)
           {
-            int c = STRING_CHAR_ADVANCE (p);
+            c = STRING_CHAR_ADVANCE (p);
             chars[i] = make_number (c);
           }
+        }
       else
         for (i = 0; i < len; i++)
-          chars[i] = make_number (p[i]);
+          chars[i] = make_number (p[ifrom + i]);
     }
-  else
+  else if (VECTORP (object))
     {
-      CHECK_VECTOR (object);
-      CHECK_NUMBER (from);
-      CHECK_NUMBER (to);
-      if (XINT (from) < 0 || XINT (from) > XINT (to)
-          || XINT (to) > ASIZE (object))
-        args_out_of_range_3 (object, from, to);
-      if (EQ (from, to))
+      ptrdiff_t ifrom, ito;
+
+      validate_subarray (object, from, to, ASIZE (object), &ifrom, &ito);
+      if (ifrom == ito)
         return Qnil;
-      len = XFASTINT (to) - XFASTINT (from);
+      len = ito - ifrom;
       for (i = 0; i < len; i++)
         {
-          Lisp_Object elt = AREF (object, XFASTINT (from) + i);
+          Lisp_Object elt = AREF (object, ifrom + i);
           CHECK_CHARACTER (elt);
         }
-      chars = aref_addr (object, XFASTINT (from));
+      chars = aref_addr (object, ifrom);
     }
+  else
+    wrong_type_argument (Qarrayp, object);
 
   vec = make_uninit_vector (len);
   for (i = 0; i < len; i++)
@@ -5005,7 +5028,7 @@ font_add_log (const char *action, Lisp_Object arg, Lisp_Object result)
   if (FONTP (arg))
     {
       Lisp_Object tail, elt;
-      Lisp_Object equalstr = build_string ("=");
+      AUTO_STRING (equal, "=");
 
       val = Ffont_xlfd_name (arg, Qt);
       for (tail = AREF (arg, FONT_EXTRA_INDEX); CONSP (tail);
@@ -5015,16 +5038,15 @@ font_add_log (const char *action, Lisp_Object arg, Lisp_Object result)
           if (EQ (XCAR (elt), QCscript)
               && SYMBOLP (XCDR (elt)))
             val = concat3 (val, SYMBOL_NAME (QCscript),
-                           concat2 (equalstr, SYMBOL_NAME (XCDR (elt))));
+                           concat2 (equal, SYMBOL_NAME (XCDR (elt))));
           else if (EQ (XCAR (elt), QClang)
                    && SYMBOLP (XCDR (elt)))
             val = concat3 (val, SYMBOL_NAME (QClang),
-                           concat2 (equalstr, SYMBOL_NAME (XCDR (elt))));
+                           concat2 (equal, SYMBOL_NAME (XCDR (elt))));
           else if (EQ (XCAR (elt), QCotf)
                    && CONSP (XCDR (elt)) && SYMBOLP (XCAR (XCDR (elt))))
             val = concat3 (val, SYMBOL_NAME (QCotf),
-                           concat2 (equalstr,
-                                    SYMBOL_NAME (XCAR (XCDR (elt)))));
+                           concat2 (equal, SYMBOL_NAME (XCAR (XCDR (elt)))));
         }
       arg = val;
     }
@@ -5038,8 +5060,11 @@ font_add_log (const char *action, Lisp_Object arg, Lisp_Object result)
     {
       val = Ffont_xlfd_name (result, Qt);
       if (! FONT_SPEC_P (result))
-        val = concat3 (SYMBOL_NAME (AREF (result, FONT_TYPE_INDEX)),
-                       build_string (":"), val);
+        {
+          AUTO_STRING (colon, ":");
+          val = concat3 (SYMBOL_NAME (AREF (result, FONT_TYPE_INDEX)),
+                         colon, val);
+        }
       result = val;
     }
   else if (CONSP (result))
diff --git a/src/font.h b/src/font.h
index cffc035cd49..52783419ebe 100644
--- a/src/font.h
+++ b/src/font.h
@@ -570,9 +570,9 @@ struct font_driver
   /* Compute the total metrics of the NGLYPHS glyphs specified by
      the font FONT and the sequence of glyph codes CODE, and store the
      result in METRICS.  */
-  int (*text_extents) (struct font *font,
-                       unsigned *code, int nglyphs,
-                       struct font_metrics *metrics);
+  void (*text_extents) (struct font *font,
+                        unsigned *code, int nglyphs,
+                        struct font_metrics *metrics);
 
 #ifdef HAVE_WINDOW_SYSTEM
 
diff --git a/src/fontset.c b/src/fontset.c
index d99a3bcb7ef..c415fdfa8fd 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -1079,10 +1079,11 @@ fontset_pattern_regexp (Lisp_Object pattern)
       /* If PATTERN is not full XLFD we convert "*" to ".*".  Otherwise
          we convert "*" to "[^-]*" which is much faster in regular
          expression matching.  */
-      if (ndashes < 14)
-        p1 = regex = alloca (SBYTES (pattern) + 2 * nstars + 2 * nescs + 1);
-      else
-        p1 = regex = alloca (SBYTES (pattern) + 5 * nstars + 2 * nescs + 1);
+      ptrdiff_t regexsize = (SBYTES (pattern)
+                             + (ndashes < 14 ? 2 : 5) * nstars
+                             + 2 * nescs + 1);
+      USE_SAFE_ALLOCA;
+      p1 = regex = SAFE_ALLOCA (regexsize);
 
       *p1++ = '^';
       for (p0 = SDATA (pattern); *p0; p0++)
@@ -1110,6 +1111,7 @@ fontset_pattern_regexp (Lisp_Object pattern)
 
       Vcached_fontset_data = Fcons (build_string (SSDATA (pattern)),
                                     build_string ((char *) regex));
+      SAFE_FREE ();
     }
 
   return CACHED_FONTSET_REGEX;
@@ -1460,8 +1462,8 @@ appended.  By default, FONT-SPEC overrides the previous settings.  */)
       registry = AREF (font_spec, FONT_REGISTRY_INDEX);
       if (! NILP (registry))
         registry = Fdowncase (SYMBOL_NAME (registry));
-      encoding = find_font_encoding (concat3 (family, build_string ("-"),
-                                              registry));
+      AUTO_STRING (dash, "-");
+      encoding = find_font_encoding (concat3 (family, dash, registry));
       if (NILP (encoding))
         encoding = Qascii;
 
@@ -1573,7 +1575,7 @@ appended.  By default, FONT-SPEC overrides the previous settings.  */)
 
   if (ascii_changed)
     {
-      Lisp_Object tail, fr, alist;
+      Lisp_Object tail, fr;
       int fontset_id = XINT (FONTSET_ID (fontset));
 
       set_fontset_ascii (fontset, fontname);
@@ -1596,8 +1598,8 @@ appended.  By default, FONT-SPEC overrides the previous settings.  */)
           if (! NILP (font_object))
             {
               update_auto_fontset_alist (font_object, fontset);
-              alist = list1 (Fcons (Qfont, Fcons (name, font_object)));
-              Fmodify_frame_parameters (fr, alist);
+              AUTO_FRAME_ARG (arg, Qfont, Fcons (name, font_object));
+              Fmodify_frame_parameters (fr, arg);
             }
         }
     }
@@ -1892,7 +1894,9 @@ format is the same as above.  */)
 
   /* Recode fontsets realized on FRAME from the base fontset FONTSET
      in the table `realized'.  */
-  realized[0] = alloca (word_size * ASIZE (Vfontset_table));
+  USE_SAFE_ALLOCA;
+  SAFE_ALLOCA_LISP (realized[0], 2 * ASIZE (Vfontset_table));
+  realized[1] = realized[0] + ASIZE (Vfontset_table);
   for (i = j = 0; i < ASIZE (Vfontset_table); i++)
     {
       elt = FONTSET_FROM_ID (i);
@@ -1903,7 +1907,6 @@ format is the same as above.  */)
     }
   realized[0][j] = Qnil;
 
-  realized[1] = alloca (word_size * ASIZE (Vfontset_table));
   for (i = j = 0; ! NILP (realized[0][i]); i++)
     {
       elt = FONTSET_DEFAULT (realized[0][i]);
@@ -1995,6 +1998,7 @@ format is the same as above.  */)
         break;
     }
 
+  SAFE_FREE ();
   return tables[0];
 }
 
diff --git a/src/frame.c b/src/frame.c
index 501f01a3122..8fac06e2af7 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -219,21 +219,6 @@ frame_inhibit_resize (struct frame *f, bool horizontal)
           || FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f));
 }
 
-#if 0
-bool
-frame_inhibit_resize (struct frame *f, bool horizontal)
-{
-  Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
-
-  return (frame_inhibit_implied_resize
-          || EQ (fullscreen, Qfullboth)
-          || EQ (fullscreen, Qfullscreen)
-          || EQ (fullscreen, Qmaximized)
-          || (horizontal && EQ (fullscreen, Qfullwidth))
-          || (!horizontal && EQ (fullscreen, Qfullheight)));
-}
-#endif
-
 static void
 set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 {
@@ -351,7 +336,7 @@ frame_windows_min_size (Lisp_Object frame, Lisp_Object horizontal, Lisp_Object p
 
 /* Make sure windows sizes of frame F are OK.  new_width and new_height
    are in pixels.  A value of -1 means no change is requested for that
-   size (but the frame may still have to be resized to accomodate
+   size (but the frame may still have to be resized to accommodate
    windows with their minimum sizes.
 
    The argument INHIBIT can assume the following values:
@@ -979,7 +964,7 @@ affects all frames on the same terminal device.  */)
     if (CONSP (terminal))
       {
         terminal = XCDR (terminal);
-        t = get_terminal (terminal, 1);
+        t = decode_live_terminal (terminal);
       }
 #ifdef MSDOS
     if (t && t != the_only_display_info.terminal)
@@ -994,22 +979,24 @@ affects all frames on the same terminal device.  */)
     {
       char *name = 0, *type = 0;
       Lisp_Object tty, tty_type;
+      USE_SAFE_ALLOCA;
 
       tty = get_future_frame_param
         (Qtty, parms, (FRAME_TERMCAP_P (XFRAME (selected_frame))
                        ? FRAME_TTY (XFRAME (selected_frame))->name
                        : NULL));
       if (!NILP (tty))
-        name = xlispstrdupa (tty);
+        SAFE_ALLOCA_STRING (name, 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 = xlispstrdupa (tty_type);
+        SAFE_ALLOCA_STRING (type, tty_type);
 
       t = init_tty (name, type, 0); /* Errors are not fatal.  */
+      SAFE_FREE ();
     }
 
   f = make_terminal_frame (t);
@@ -1804,9 +1791,9 @@ The functions are run with one argument, the frame to be deleted.  */)
 
 DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 0, 0,
        doc: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
-The position is given in character cells, where (0, 0) is the
-upper-left corner of the frame, X is the horizontal offset, and Y is
-the vertical offset.
+The position is given in canonical character cells, where (0, 0) is the
+upper-left corner of the frame, X is the horizontal offset, and Y is the
+vertical offset, measured in units of the frame's default character size.
 If Emacs is running on a mouseless terminal or hasn't been programmed
 to read the mouse position, it returns the selected frame for FRAME
 and nil for X and Y.
@@ -1863,7 +1850,8 @@ and nil for X and Y.  */)
 {
   struct frame *f;
   Lisp_Object lispy_dummy;
-  Lisp_Object x, y;
+  Lisp_Object x, y, retval;
+  struct gcpro gcpro1;
 
   f = SELECTED_FRAME ();
   x = y = Qnil;
@@ -1880,7 +1868,11 @@ and nil for X and Y.  */)
     }
 
   XSETFRAME (lispy_dummy, f);
-  return Fcons (lispy_dummy, Fcons (x, y));
+  retval = Fcons (lispy_dummy, Fcons (x, y));
+  GCPRO1 (retval);
+  if (!NILP (Vmouse_position_function))
+    retval = call1 (Vmouse_position_function, retval);
+  RETURN_UNGCPRO (retval);
 }
 
 #ifdef HAVE_WINDOW_SYSTEM
@@ -1925,9 +1917,10 @@ Coordinates are relative to the frame, not a window,
 so the coordinates of the top left character in the frame
 may be nonzero due to left-hand scroll bars or the menu bar.
 
-The position is given in character cells, where (0, 0) is the
-upper-left corner of the frame, X is the horizontal offset, and Y is
-the vertical offset.
+The position is given in canonical character cells, where (0, 0) is
+the upper-left corner of the frame, X is the horizontal offset, and
+Y is the vertical offset, measured in units of the frame's default
+character size.
 
 This function is a no-op for an X frame that is not visible.
 If you have just created a frame, you must wait for it to become visible
@@ -3000,7 +2993,7 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
   /* If both of these parameters are present, it's more efficient to
      set them both at once.  So we wait until we've looked at the
      entire list before we set them.  */
-  int width, height;
+  int width IF_LINT (= 0), height IF_LINT (= 0);
   bool width_change = 0, height_change = 0;
 
   /* Same here.  */
@@ -3017,14 +3010,14 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
 #ifdef HAVE_X_WINDOWS
   bool icon_left_no_change = 0, icon_top_no_change = 0;
 #endif
-  struct gcpro gcpro1, gcpro2;
 
   i = 0;
   for (tail = alist; CONSP (tail); tail = XCDR (tail))
     i++;
 
-  parms = alloca (i * sizeof *parms);
-  values = alloca (i * sizeof *values);
+  USE_SAFE_ALLOCA;
+  SAFE_ALLOCA_LISP (parms, 2 * i);
+  values = parms + i;
 
   /* Extract parm names and values into those vectors.  */
 
@@ -3041,10 +3034,6 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
   /* TAIL and ALIST are not used again below here.  */
   alist = tail = Qnil;
 
-  GCPRO2 (*parms, *values);
-  gcpro1.nvars = i;
-  gcpro2.nvars = i;
-
   /* There is no need to gcpro LEFT, TOP, ICON_LEFT, or ICON_TOP,
      because their values appear in VALUES and strings are not valid.  */
   top = left = Qunbound;
@@ -3273,7 +3262,7 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
 #endif /* HAVE_X_WINDOWS */
   }
 
-  UNGCPRO;
+  SAFE_FREE ();
 }
 
 
@@ -3773,9 +3762,7 @@ x_set_vertical_scroll_bars (struct frame *f, Lisp_Object arg, Lisp_Object oldval
 void
 x_set_horizontal_scroll_bars (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
-#if (defined (HAVE_WINDOW_SYSTEM)                                       \
-     && ((defined (USE_TOOLKIT_SCROLL_BARS) && !defined (HAVE_NS))      \
-         || defined (HAVE_NTGUI)))
+#if USE_HORIZONTAL_SCROLL_BARS
   if ((NILP (arg) && FRAME_HAS_HORIZONTAL_SCROLL_BARS (f))
       || (!NILP (arg) && !FRAME_HAS_HORIZONTAL_SCROLL_BARS (f)))
     {
@@ -3825,9 +3812,7 @@ x_set_scroll_bar_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 void
 x_set_scroll_bar_height (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
-#if (defined (HAVE_WINDOW_SYSTEM)                                       \
-     && ((defined (USE_TOOLKIT_SCROLL_BARS) && !defined (HAVE_NS))      \
-         || defined (HAVE_NTGUI)))
+#if USE_HORIZONTAL_SCROLL_BARS
   int unit = FRAME_LINE_HEIGHT (f);
 
   if (NILP (arg))
@@ -4010,10 +3995,6 @@ validate_x_resource_name (void)
 static Lisp_Object
 xrdb_get_resource (XrmDatabase rdb, Lisp_Object attribute, Lisp_Object class, Lisp_Object component, Lisp_Object subclass)
 {
-  register char *value;
-  char *name_key;
-  char *class_key;
-
   CHECK_STRING (attribute);
   CHECK_STRING (class);
 
@@ -4028,22 +4009,25 @@ xrdb_get_resource (XrmDatabase rdb, Lisp_Object attribute, Lisp_Object class, Li
 
   /* Allocate space for the components, the dots which separate them,
      and the final '\0'.  Make them big enough for the worst case.  */
-  name_key = alloca (SBYTES (Vx_resource_name)
-                     + (STRINGP (component)
-                        ? SBYTES (component) : 0)
-                     + SBYTES (attribute)
-                     + 3);
-
-  class_key = alloca (SBYTES (Vx_resource_class)
-                      + SBYTES (class)
-                      + (STRINGP (subclass)
-                         ? SBYTES (subclass) : 0)
-                      + 3);
+  ptrdiff_t name_keysize = (SBYTES (Vx_resource_name)
+                            + (STRINGP (component)
+                               ? SBYTES (component) : 0)
+                            + SBYTES (attribute)
+                            + 3);
+
+  ptrdiff_t class_keysize = (SBYTES (Vx_resource_class)
+                             + SBYTES (class)
+                             + (STRINGP (subclass)
+                                ? SBYTES (subclass) : 0)
+                             + 3);
+  USE_SAFE_ALLOCA;
+  char *name_key = SAFE_ALLOCA (name_keysize + class_keysize);
+  char *class_key = name_key + name_keysize;
 
   /* Start with emacs.FRAMENAME for the name (the specific one)
      and with `Emacs' for the class key (the general one).  */
-  strcpy (name_key, SSDATA (Vx_resource_name));
-  strcpy (class_key, SSDATA (Vx_resource_class));
+  lispstpcpy (name_key, Vx_resource_name);
+  lispstpcpy (class_key, Vx_resource_class);
 
   strcat (class_key, ".");
   strcat (class_key, SSDATA (class));
@@ -4060,7 +4044,8 @@ xrdb_get_resource (XrmDatabase rdb, Lisp_Object attribute, Lisp_Object class, Li
   strcat (name_key, ".");
   strcat (name_key, SSDATA (attribute));
 
-  value = x_get_string_resource (rdb, name_key, class_key);
+  char *value = x_get_string_resource (rdb, name_key, class_key);
+  SAFE_FREE();
 
   if (value && *value)
     return build_string (value);
@@ -4112,8 +4097,10 @@ x_get_resource_string (const char *attribute, const char *class)
 
   /* Allocate space for the components, the dots which separate them,
      and the final '\0'.  */
-  char *name_key = SAFE_ALLOCA (invocation_namelen + strlen (attribute) + 2);
-  char *class_key = alloca ((sizeof (EMACS_CLASS) - 1) + strlen (class) + 2);
+  ptrdiff_t name_keysize = invocation_namelen + strlen (attribute) + 2;
+  ptrdiff_t class_keysize = sizeof (EMACS_CLASS) - 1 + strlen (class) + 2;
+  char *name_key = SAFE_ALLOCA (name_keysize + class_keysize);
+  char *class_key = name_key + name_keysize;
 
   esprintf (name_key, "%s.%s", SSDATA (Vinvocation_name), attribute);
   sprintf (class_key, "%s.%s", EMACS_CLASS, class);
@@ -4140,7 +4127,7 @@ Lisp_Object
 x_get_arg (Display_Info *dpyinfo, Lisp_Object alist, Lisp_Object param,
            const char *attribute, const char *class, enum resource_types type)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
 
   tem = Fassq (param, alist);
 
@@ -4166,10 +4153,9 @@ x_get_arg (Display_Info *dpyinfo, Lisp_Object alist, Lisp_Object param,
     {
       if (attribute && dpyinfo)
         {
-          tem = display_x_get_resource (dpyinfo,
-                                        build_string (attribute),
-                                        build_string (class),
-                                        Qnil, Qnil);
+          AUTO_STRING (at, attribute);
+          AUTO_STRING (cl, class);
+          tem = display_x_get_resource (dpyinfo, at, cl, Qnil, Qnil);
 
           if (NILP (tem))
             return Qunbound;
@@ -4279,7 +4265,8 @@ x_default_parameter (struct frame *f, Lisp_Object alist, Lisp_Object prop,
   tem = x_frame_get_arg (f, alist, prop, xprop, xclass, type);
   if (EQ (tem, Qunbound))
     tem = deflt;
-  x_set_frame_parameters (f, list1 (Fcons (prop, tem)));
+  AUTO_FRAME_ARG (arg, prop, tem);
+  x_set_frame_parameters (f, arg);
   return tem;
 }
 
@@ -4872,16 +4859,6 @@ Setting this variable does not affect existing frames, only new ones.  */);
   Vdefault_frame_scroll_bars = Qnil;
 #endif
 
-  DEFVAR_LISP ("default-frame-horizontal-scroll-bars", Vdefault_frame_horizontal_scroll_bars,
-               doc: /* Default value for horizontal scroll bars on this window-system.  */);
-#if (defined (HAVE_WINDOW_SYSTEM)                                       \
-     && ((defined (USE_TOOLKIT_SCROLL_BARS) && !defined (HAVE_NS))      \
-         || defined (HAVE_NTGUI)))
-  Vdefault_frame_horizontal_scroll_bars = Qt;
-#else
-  Vdefault_frame_horizontal_scroll_bars = Qnil;
-#endif
-
   DEFVAR_BOOL ("scroll-bar-adjust-thumb-portion",
                scroll_bar_adjust_thumb_portion_p,
                doc: /* Adjust thumb for overscrolling for Gtk+ and MOTIF.
@@ -4897,8 +4874,8 @@ is visible.  In this case you can not overscroll.  */);
 
   DEFVAR_LISP ("mouse-position-function", Vmouse_position_function,
                doc: /* If non-nil, function to transform normal value of `mouse-position'.
-`mouse-position' calls this function, passing its usual return value as
-argument, and returns whatever this function returns.
+`mouse-position' and `mouse-pixel-position' call this function, passing their
+usual return value as argument, and return whatever this function returns.
 This abnormal hook exists for the benefit of packages like `xt-mouse.el'
 which need to do mouse handling at the Lisp level.  */);
   Vmouse_position_function = Qnil;
diff --git a/src/frame.h b/src/frame.h
index 0f34770d9b4..22f2fa7a24c 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -868,9 +868,7 @@ default_pixels_per_inch_y (void)
 #endif /* HAVE_WINDOW_SYSTEM */
 
 /* Whether horizontal scroll bars are currently enabled for frame F.  */
-#if (defined (HAVE_WINDOW_SYSTEM)                                       \
-     && ((defined (USE_TOOLKIT_SCROLL_BARS) && !defined (HAVE_NS))      \
-         || defined (HAVE_NTGUI)))
+#if USE_HORIZONTAL_SCROLL_BARS
 #define FRAME_HAS_HORIZONTAL_SCROLL_BARS(f) \
   ((f)->horizontal_scroll_bars)
 #else
@@ -1062,6 +1060,11 @@ default_pixels_per_inch_y (void)
       }                                                         \
   } while (false)
 
+/* Handy macro to construct an argument to Fmodify_frame_parameters.  */
+
+#define AUTO_FRAME_ARG(name, parameter, value)  \
+  AUTO_LIST1 (name, AUTO_CONS_EXPR (parameter, value))
+
 /* False means there are no visible garbaged frames.  */
 extern bool frame_garbaged;
 
@@ -1290,7 +1293,7 @@ extern Lisp_Object Vframe_list;
    / FRAME_LINE_HEIGHT (f))
 
 /* Return the pixel width/height of frame F with a text size of
-   width/heigh.  */
+   width/height.  */
 #define FRAME_TEXT_TO_PIXEL_WIDTH(f, width)       \
   ((width)                                        \
    + FRAME_SCROLL_BAR_AREA_WIDTH (f)              \
@@ -1501,4 +1504,11 @@ extern Lisp_Object make_monitor_attribute_list (struct MonitorInfo *monitors,
 
 INLINE_HEADER_END
 
+/* Suppress -Wsuggest-attribute=const if there are no scroll bars.
+   This is for functions like x_set_horizontal_scroll_bars that have
+   no effect in this case.  */
+#if ! USE_HORIZONTAL_SCROLL_BARS && 4 < __GNUC__ + (6 <= __GNUC_MINOR__)
+# pragma GCC diagnostic ignored "-Wsuggest-attribute=const"
+#endif
+
 #endif /* not EMACS_FRAME_H */
diff --git a/src/ftfont.c b/src/ftfont.c
index 419274a30aa..4c12ef5d3af 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -24,6 +24,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <fontconfig/fontconfig.h>
 #include <fontconfig/fcfreetype.h>
 
+#include <c-strcase.h>
+
 #include "lisp.h"
 #include "dispextern.h"
 #include "frame.h"
@@ -140,6 +142,12 @@ static struct
     { NULL }
   };
 
+static bool
+matching_prefix (char const *str, ptrdiff_t len, char const *pat)
+{
+  return len == strlen (pat) && c_strncasecmp (str, pat, len) == 0;
+}
+
 /* Dirty hack for handing ADSTYLE property.
 
    Fontconfig (actually the underlying FreeType) gives such ADSTYLE
@@ -171,18 +179,10 @@ get_adstyle_property (FcPattern *p)
     return Qnil;
   str = (char *) fcstr;
   for (end = str; *end && *end != ' '; end++);
-  if (*end)
-    {
-      char *newstr = alloca (end - str + 1);
-      memcpy (newstr, str, end - str);
-      newstr[end - str] = '\0';
-      end = newstr + (end - str);
-      str = newstr;
-    }
-  if (xstrcasecmp (str, "Regular") == 0
-      || xstrcasecmp (str, "Bold") == 0
-      || xstrcasecmp (str, "Oblique") == 0
-      || xstrcasecmp (str, "Italic") == 0)
+  if (matching_prefix (str, end - str, "Regular")
+      || matching_prefix (str, end - str, "Bold")
+      || matching_prefix (str, end - str, "Oblique")
+      || matching_prefix (str, end - str, "Italic"))
     return Qnil;
   adstyle = font_intern_prop (str, end - str, 1);
   if (font_style_to_value (FONT_WIDTH_INDEX, adstyle, 0) >= 0)
@@ -499,8 +499,8 @@ static Lisp_Object ftfont_open (struct frame *, Lisp_Object, int);
 static void ftfont_close (struct font *);
 static int ftfont_has_char (Lisp_Object, int);
 static unsigned ftfont_encode_char (struct font *, int);
-static int ftfont_text_extents (struct font *, unsigned *, int,
-                                struct font_metrics *);
+static void ftfont_text_extents (struct font *, unsigned *, int,
+                                 struct font_metrics *);
 static int ftfont_get_bitmap (struct font *, unsigned,
                               struct font_bitmap *, int);
 static int ftfont_anchor_point (struct font *, unsigned, int,
@@ -573,7 +573,8 @@ static int
 ftfont_get_charset (Lisp_Object registry)
 {
   char *str = SSDATA (SYMBOL_NAME (registry));
-  char *re = alloca (SBYTES (SYMBOL_NAME (registry)) * 2 + 1);
+  USE_SAFE_ALLOCA;
+  char *re = SAFE_ALLOCA (SBYTES (SYMBOL_NAME (registry)) * 2 + 1);
   Lisp_Object regexp;
   int i, j;
 
@@ -589,6 +590,7 @@ ftfont_get_charset (Lisp_Object registry)
     }
   re[j] = '\0';
   regexp = make_unibyte_string (re, j);
+  SAFE_FREE ();
   for (i = 0; fc_charset_table[i].name; i++)
     if (fast_c_string_match_ignore_case
         (regexp, fc_charset_table[i].name,
@@ -802,7 +804,7 @@ ftfont_spec_pattern (Lisp_Object spec, char *otlayout, struct OpenTypeSpec **ots
               *otspec = ftfont_get_open_type_spec (val);
               if (! *otspec)
                 return NULL;
-              strcat (otlayout, "otlayout:");
+              strcpy (otlayout, "otlayout:");
               OTF_TAG_STR ((*otspec)->script_tag, otlayout + 9);
               script = (*otspec)->script;
             }
@@ -1371,19 +1373,18 @@ ftfont_encode_char (struct font *font, int c)
   return (code > 0 ? code : FONT_INVALID_CODE);
 }
 
-static int
-ftfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct font_metrics *metrics)
+static void
+ftfont_text_extents (struct font *font, unsigned int *code,
+                     int nglyphs, struct font_metrics *metrics)
 {
   struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
   FT_Face ft_face = ftfont_info->ft_size->face;
-  int width = 0;
-  int i;
+  int i, width = 0;
   bool first;
 
   if (ftfont_info->ft_size != ft_face->size)
     FT_Activate_Size (ftfont_info->ft_size);
-  if (metrics)
-    memset (metrics, 0, sizeof (struct font_metrics));
+
   for (i = 0, first = 1; i < nglyphs; i++)
     {
       if (FT_Load_Glyph (ft_face, code[i], FT_LOAD_DEFAULT) == 0)
@@ -1392,39 +1393,28 @@ ftfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct
 
           if (first)
             {
-              if (metrics)
-                {
-                  metrics->lbearing = m->horiBearingX >> 6;
-                  metrics->rbearing = (m->horiBearingX + m->width) >> 6;
-                  metrics->ascent = m->horiBearingY >> 6;
-                  metrics->descent = (m->height - m->horiBearingY) >> 6;
-                }
+              metrics->lbearing = m->horiBearingX >> 6;
+              metrics->rbearing = (m->horiBearingX + m->width) >> 6;
+              metrics->ascent = m->horiBearingY >> 6;
+              metrics->descent = (m->height - m->horiBearingY) >> 6;
               first = 0;
             }
-          if (metrics)
-            {
-              if (metrics->lbearing > width + (m->horiBearingX >> 6))
-                metrics->lbearing = width + (m->horiBearingX >> 6);
-              if (metrics->rbearing
-                  < width + ((m->horiBearingX + m->width) >> 6))
-                metrics->rbearing
-                  = width + ((m->horiBearingX + m->width) >> 6);
-              if (metrics->ascent < (m->horiBearingY >> 6))
-                metrics->ascent = m->horiBearingY >> 6;
-              if (metrics->descent > ((m->height - m->horiBearingY) >> 6))
-                metrics->descent = (m->height - m->horiBearingY) >> 6;
-            }
+          if (metrics->lbearing > width + (m->horiBearingX >> 6))
+            metrics->lbearing = width + (m->horiBearingX >> 6);
+          if (metrics->rbearing
+              < width + ((m->horiBearingX + m->width) >> 6))
+            metrics->rbearing
+              = width + ((m->horiBearingX + m->width) >> 6);
+          if (metrics->ascent < (m->horiBearingY >> 6))
+            metrics->ascent = m->horiBearingY >> 6;
+          if (metrics->descent > ((m->height - m->horiBearingY) >> 6))
+            metrics->descent = (m->height - m->horiBearingY) >> 6;
           width += m->horiAdvance >> 6;
         }
       else
-        {
-          width += font->space_width;
-        }
+        width += font->space_width;
     }
-  if (metrics)
-    metrics->width = width;
-
-  return width;
+  metrics->width = width;
 }
 
 static int
@@ -1700,7 +1690,8 @@ ftfont_check_otf (MFLTFont *font, MFLTOtfSpec *spec)
         else if (! otf)
           return 0;
         for (n = 1; spec->features[i][n]; n++);
-        tags = alloca (sizeof (OTF_Tag) * n);
+        USE_SAFE_ALLOCA;
+        SAFE_NALLOCA (tags, 1, n);
         for (n = 0, negative = 0; spec->features[i][n]; n++)
           {
             if (spec->features[i][n] == 0xFFFFFFFF)
@@ -1710,16 +1701,17 @@ ftfont_check_otf (MFLTFont *font, MFLTOtfSpec *spec)
             else
               tags[n] = spec->features[i][n];
           }
-#ifdef M17N_FLT_USE_NEW_FEATURE
-        if (OTF_check_features (otf, i == 0, spec->script, spec->langsys,
-                                tags, n - negative) != 1)
-          return 0;
-#else  /* not M17N_FLT_USE_NEW_FEATURE */
-        if (n - negative > 0
-            && OTF_check_features (otf, i == 0, spec->script, spec->langsys,
-                                   tags, n - negative) != 1)
+        bool passed = true;
+#ifndef M17N_FLT_USE_NEW_FEATURE
+        passed = n - negative > 0;
+#endif
+        if (passed)
+          passed = (OTF_check_features (otf, i == 0, spec->script,
+                                        spec->langsys, tags, n - negative)
+                    != 1);
+        SAFE_FREE ();
+        if (passed)
           return 0;
-#endif  /* not M17N_FLT_USE_NEW_FEATURE */
       }
   return 1;
 #undef FEATURE_NONE
@@ -1811,11 +1803,15 @@ ftfont_drive_otf (MFLTFont *font,
   if (len == 0)
     return from;
   OTF_tag_name (spec->script, script);
+
+  char langsysbuf[5];
   if (spec->langsys)
     {
-      langsys = alloca (5);
+      langsys = langsysbuf;
       OTF_tag_name (spec->langsys, langsys);
     }
+
+  USE_SAFE_ALLOCA;
   for (i = 0; i < 2; i++)
     {
       char *p;
@@ -1823,10 +1819,11 @@ ftfont_drive_otf (MFLTFont *font,
       if (spec->features[i] && spec->features[i][1] != 0xFFFFFFFF)
         {
           for (j = 0; spec->features[i][j]; j++);
+          SAFE_NALLOCA (p, 6, j);
           if (i == 0)
-            p = gsub_features = alloca (6 * j);
+            gsub_features = p;
           else
-            p = gpos_features = alloca (6 * j);
+            gpos_features = p;
           for (j = 0; spec->features[i][j]; j++)
             {
               if (spec->features[i][j] == 0xFFFFFFFF)
@@ -1858,7 +1855,10 @@ ftfont_drive_otf (MFLTFont *font,
                                    gsub_features) < 0)
         goto simple_copy;
       if (out->allocated < out->used + otf_gstring.used)
-        return -2;
+        {
+          SAFE_FREE ();
+          return -2;
+        }
       features = otf->gsub->FeatureList.Feature;
       for (i = 0, otfg = otf_gstring.glyphs; i < otf_gstring.used; )
         {
@@ -1947,7 +1947,10 @@ ftfont_drive_otf (MFLTFont *font,
   else if (out)
     {
       if (out->allocated < out->used + len)
-        return -2;
+        {
+          SAFE_FREE ();
+          return -2;
+        }
       for (i = 0; i < len; i++)
         out->glyphs[out->used++] = in->glyphs[from + i];
     }
@@ -1959,7 +1962,10 @@ ftfont_drive_otf (MFLTFont *font,
 
       if (OTF_drive_gpos_with_log (otf, &otf_gstring, script, langsys,
                                    gpos_features) < 0)
-        return to;
+        {
+          SAFE_FREE ();
+          return to;
+        }
       features = otf->gpos->FeatureList.Feature;
       x_ppem = ft_face->size->metrics.x_ppem;
       y_ppem = ft_face->size->metrics.y_ppem;
@@ -2081,7 +2087,10 @@ ftfont_drive_otf (MFLTFont *font,
     {
       if (OTF_drive_gpos_with_log (otf, &otf_gstring, script, langsys,
                                    gpos_features) < 0)
-        return to;
+        {
+          SAFE_FREE ();
+          return to;
+        }
       features = otf->gpos->FeatureList.Feature;
       for (i = 0, otfg = otf_gstring.glyphs; i < otf_gstring.used;
            i++, otfg++)
@@ -2101,9 +2110,11 @@ ftfont_drive_otf (MFLTFont *font,
               }
           }
     }
+  SAFE_FREE ();
   return to;
 
  simple_copy:
+  SAFE_FREE ();
   if (! out)
     return to;
   if (out->allocated < out->used + len)
@@ -2141,11 +2152,15 @@ ftfont_drive_otf (MFLTFont *font, MFLTOtfSpec *spec, MFLTGlyphString *in,
   if (len == 0)
     return from;
   OTF_tag_name (spec->script, script);
+
+  char langsysbuf[5];
   if (spec->langsys)
     {
-      langsys = alloca (5);
+      langsys = langsysbuf;
       OTF_tag_name (spec->langsys, langsys);
     }
+
+  USE_SAFE_ALLOCA;
   for (i = 0; i < 2; i++)
     {
       char *p;
@@ -2153,10 +2168,11 @@ ftfont_drive_otf (MFLTFont *font, MFLTOtfSpec *spec, MFLTGlyphString *in,
       if (spec->features[i] && spec->features[i][1] != 0xFFFFFFFF)
         {
           for (j = 0; spec->features[i][j]; j++);
+          SAFE_NALLOCA (p, 6, j);
           if (i == 0)
-            p = gsub_features = alloca (6 * j);
+            gsub_features = p;
           else
-            p = gpos_features = alloca (6 * j);
+            gpos_features = p;
           for (j = 0; spec->features[i][j]; j++)
             {
               if (spec->features[i][j] == 0xFFFFFFFF)
@@ -2188,7 +2204,10 @@ ftfont_drive_otf (MFLTFont *font, MFLTOtfSpec *spec, MFLTGlyphString *in,
           < 0)
         goto simple_copy;
       if (out->allocated < out->used + otf_gstring.used)
-        return -2;
+        {
+          SAFE_FREE ();
+          return -2;
+        }
       for (i = 0, otfg = otf_gstring.glyphs; i < otf_gstring.used; )
         {
           MFLTGlyph *g;
@@ -2239,7 +2258,10 @@ ftfont_drive_otf (MFLTFont *font, MFLTOtfSpec *spec, MFLTGlyphString *in,
   else
     {
       if (out->allocated < out->used + len)
-        return -2;
+        {
+          SAFE_FREE ();
+          return -2;
+        }
       for (i = 0; i < len; i++)
         out->glyphs[out->used++] = in->glyphs[from + i];
     }
@@ -2251,7 +2273,10 @@ ftfont_drive_otf (MFLTFont *font, MFLTOtfSpec *spec, MFLTGlyphString *in,
 
       if (OTF_drive_gpos (otf, &otf_gstring, script, langsys, gpos_features)
           < 0)
-        return to;
+        {
+          SAFE_FREE ();
+          return to;
+        }
 
       x_ppem = ft_face->size->metrics.x_ppem;
       y_ppem = ft_face->size->metrics.y_ppem;
@@ -2361,9 +2386,11 @@ ftfont_drive_otf (MFLTFont *font, MFLTOtfSpec *spec, MFLTGlyphString *in,
             base = g;
         }
     }
+  SAFE_FREE ();
   return to;
 
  simple_copy:
+  SAFE_FREE ();
   if (out->allocated < out->used + len)
     return -2;
   font->get_metrics (font, in, from, to);
diff --git a/src/ftxfont.c b/src/ftxfont.c
index 63e3477ebf4..7e4608b9b85 100644
--- a/src/ftxfont.c
+++ b/src/ftxfont.c
@@ -271,10 +271,11 @@ ftxfont_draw (struct glyph_string *s, int from, int to, int x, int y,
 
   n[0] = n[1] = n[2] = n[3] = n[4] = n[5] = n[6] = 0;
 
+  USE_SAFE_ALLOCA;
+  SAFE_NALLOCA (code, 1, len);
   block_input ();
   if (with_background)
     ftxfont_draw_background (f, font, s->gc, x, y, s->width);
-  code = alloca (sizeof (unsigned) * len);
   for (i = 0; i < len; i++)
     code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
                | XCHAR2B_BYTE2 (s->char2b + from + i));
@@ -322,6 +323,7 @@ ftxfont_draw (struct glyph_string *s, int from, int to, int x, int y,
     }
 
   unblock_input ();
+  SAFE_FREE ();
 
   return len;
 }
diff --git a/src/gmalloc.c b/src/gmalloc.c
index 27965e37539..3456ff0ec6f 100644
--- a/src/gmalloc.c
+++ b/src/gmalloc.c
@@ -21,13 +21,18 @@ License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <config.h>
 
-#ifdef HAVE_PTHREAD
+#if defined HAVE_PTHREAD && !defined HYBRID_MALLOC
 #define USE_PTHREAD
 #endif
 
 #include <string.h>
 #include <limits.h>
 #include <stdint.h>
+
+#ifdef HYBRID_GET_CURRENT_DIR_NAME
+#undef get_current_dir_name
+#endif
+
 #include <unistd.h>
 
 #ifdef USE_PTHREAD
@@ -42,6 +47,41 @@ License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 extern void emacs_abort (void);
 #endif
 
+/* If HYBRID_MALLOC is defined, then temacs will use malloc,
+   realloc... as defined in this file (and renamed gmalloc,
+   grealloc... via the macros that follow).  The dumped emacs,
+   however, will use the system malloc, realloc....  In other source
+   files, malloc, realloc... are renamed hybrid_malloc,
+   hybrid_realloc... via macros in conf_post.h.  hybrid_malloc and
+   friends are wrapper functions defined later in this file.
+   aligned_alloc is defined as a macro only in alloc.c.
+
+   As of this writing (August 2014), Cygwin is the only platform on
+   which HYBRID_MACRO is defined.  Any other platform that wants to
+   define it will have to define the macros DUMPED and
+   ALLOCATED_BEFORE_DUMPING, defined below for Cygwin.  */
+#ifdef HYBRID_MALLOC
+#undef malloc
+#undef realloc
+#undef calloc
+#undef free
+#define malloc gmalloc
+#define realloc grealloc
+#define calloc gcalloc
+#define aligned_alloc galigned_alloc
+#define free gfree
+#endif  /* HYBRID_MALLOC */
+
+#ifdef CYGWIN
+extern void *bss_sbrk (ptrdiff_t size);
+extern int bss_sbrk_did_unexec;
+extern char bss_sbrk_buffer[];
+extern void *bss_sbrk_buffer_end;
+#define DUMPED bss_sbrk_did_unexec
+#define ALLOCATED_BEFORE_DUMPING(P) \
+  ((P) < bss_sbrk_buffer_end && (P) >= (void *) bss_sbrk_buffer)
+#endif
+
 #ifdef  __cplusplus
 extern "C"
 {
@@ -306,22 +346,6 @@ License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <errno.h>
 
-/* On Cygwin there are two heaps.  temacs uses the static heap
-   (defined in sheap.c and managed with bss_sbrk), and the dumped
-   emacs uses the Cygwin heap (managed with sbrk).  When emacs starts
-   on Cygwin, it reinitializes malloc, and we save the old info for
-   use by free and realloc if they're called with a pointer into the
-   static heap.
-
-   Currently (2011-08-16) the Cygwin build doesn't use ralloc.c; if
-   this is changed in the future, we'll have to similarly deal with
-   reinitializing ralloc. */
-#ifdef CYGWIN
-extern void *bss_sbrk (ptrdiff_t size);
-extern int bss_sbrk_did_unexec;
-char *bss_sbrk_heapbase;        /* _heapbase for static heap */
-malloc_info *bss_sbrk_heapinfo; /* _heapinfo for static heap */
-#endif
 void *(*__morecore) (ptrdiff_t size) = __default_morecore;
 
 /* Debugging hook for `malloc'.  */
@@ -490,18 +514,8 @@ register_heapinfo (void)
 }
 
 #ifdef USE_PTHREAD
-/* On Cygwin prior to 1.7.31, pthread_mutexes were ERRORCHECK mutexes
-   by default.  When the default changed to NORMAL in Cygwin-1.7.31,
-   deadlocks occurred (bug#18222).  As a temporary workaround, we
-   explicitly set the mutexes to be of ERRORCHECK type, restoring the
-   previous behavior.  */
-#ifdef CYGWIN
-pthread_mutex_t _malloc_mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
-pthread_mutex_t _aligned_blocks_mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
-#else  /* not CYGWIN */
 pthread_mutex_t _malloc_mutex = PTHREAD_MUTEX_INITIALIZER;
 pthread_mutex_t _aligned_blocks_mutex = PTHREAD_MUTEX_INITIALIZER;
-#endif  /* not CYGWIN */
 int _malloc_thread_enabled_p;
 
 static void
@@ -536,17 +550,8 @@ malloc_enable_thread (void)
      initialized mutexes when they are used first.  To avoid such a
      situation, we initialize mutexes here while their use is
      disabled in malloc etc.  */
-#ifdef CYGWIN
-  /* Use ERRORCHECK mutexes; see comment above. */
-  pthread_mutexattr_t attr;
-  pthread_mutexattr_init (&attr);
-  pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ERRORCHECK);
-  pthread_mutex_init (&_malloc_mutex, &attr);
-  pthread_mutex_init (&_aligned_blocks_mutex, &attr);
-#else  /* not CYGWIN */
   pthread_mutex_init (&_malloc_mutex, NULL);
   pthread_mutex_init (&_aligned_blocks_mutex, NULL);
-#endif  /* not CYGWIN */
   pthread_atfork (malloc_atfork_handler_prepare,
                   malloc_atfork_handler_parent,
                   malloc_atfork_handler_child);
@@ -561,16 +566,6 @@ malloc_initialize_1 (void)
   mcheck (NULL);
 #endif
 
-#ifdef CYGWIN
-  if (bss_sbrk_did_unexec)
-    /* we're reinitializing the dumped emacs */
-    {
-      bss_sbrk_heapbase = _heapbase;
-      bss_sbrk_heapinfo = _heapinfo;
-      memset (_fraghead, 0, BLOCKLOG * sizeof (struct list));
-    }
-#endif
-
   if (__malloc_initialize_hook)
     (*__malloc_initialize_hook) ();
 
@@ -1027,12 +1022,6 @@ _free_internal_nolock (void *ptr)
   if (ptr == NULL)
     return;
 
-#ifdef CYGWIN
-  if ((char *) ptr < _heapbase)
-    /* We're being asked to free something in the static heap. */
-    return;
-#endif
-
   PROTECT_MALLOC_STATE (0);
 
   LOCK_ALIGNED_BLOCKS ();
@@ -1314,30 +1303,7 @@ License along with this library.  If not, see <http://www.gnu.org/licenses/>.
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */
 
 #ifndef min
-#define min(A, B) ((A) < (B) ? (A) : (B))
-#endif
-
-/* On Cygwin the dumped emacs may try to realloc storage allocated in
-   the static heap.  We just malloc space in the new heap and copy the
-   data.  */
-#ifdef CYGWIN
-void *
-special_realloc (void *ptr, size_t size)
-{
-  void *result;
-  int type;
-  size_t block, oldsize;
-
-  block = ((char *) ptr - bss_sbrk_heapbase) / BLOCKSIZE + 1;
-  type = bss_sbrk_heapinfo[block].busy.type;
-  oldsize =
-    type == 0 ? bss_sbrk_heapinfo[block].busy.info.size * BLOCKSIZE
-    : (size_t) 1 << type;
-  result = _malloc_internal_nolock (size);
-  if (result)
-    return memcpy (result, ptr, min (oldsize, size));
-  return result;
-}
+#define min(a, b) ((a) < (b) ? (a) : (b))
 #endif
 
 /* Debugging hook for realloc.  */
@@ -1364,12 +1330,6 @@ _realloc_internal_nolock (void *ptr, size_t size)
   else if (ptr == NULL)
     return _malloc_internal_nolock (size);
 
-#ifdef CYGWIN
-  if ((char *) ptr < _heapbase)
-    /* ptr points into the static heap */
-    return special_realloc (ptr, size);
-#endif
-
   block = BLOCK (ptr);
 
   PROTECT_MALLOC_STATE (0);
@@ -1566,7 +1526,7 @@ __default_morecore (ptrdiff_t increment)
 {
   void *result;
 #if defined (CYGWIN)
-  if (!bss_sbrk_did_unexec)
+  if (!DUMPED)
     {
       return bss_sbrk (increment);
     }
@@ -1689,6 +1649,9 @@ memalign (size_t alignment, size_t size)
   return aligned_alloc (alignment, size);
 }
 
+/* If HYBRID_MALLOC is defined, we may want to use the system
+   posix_memalign below.  */
+#ifndef HYBRID_MALLOC
 int
 posix_memalign (void **memptr, size_t alignment, size_t size)
 {
@@ -1707,6 +1670,7 @@ posix_memalign (void **memptr, size_t alignment, size_t size)
 
   return 0;
 }
+#endif
 
 /* Allocate memory on a page boundary.
    Copyright (C) 1991, 92, 93, 94, 96 Free Software Foundation, Inc.
@@ -1747,6 +1711,113 @@ valloc (size_t size)
   return aligned_alloc (pagesize, size);
 }
 
+#ifdef HYBRID_MALLOC
+#undef malloc
+#undef realloc
+#undef calloc
+#undef aligned_alloc
+#undef free
+
+/* Declare system malloc and friends.  */
+extern void *malloc (size_t size);
+extern void *realloc (void *ptr, size_t size);
+extern void *calloc (size_t nmemb, size_t size);
+extern void free (void *ptr);
+#ifdef HAVE_ALIGNED_ALLOC
+extern void *aligned_alloc (size_t alignment, size_t size);
+#elif defined HAVE_POSIX_MEMALIGN
+extern int posix_memalign (void **memptr, size_t alignment, size_t size);
+#endif
+
+/* See the comments near the beginning of this file for explanations
+   of the following functions. */
+
+void *
+hybrid_malloc (size_t size)
+{
+  if (DUMPED)
+    return malloc (size);
+  return gmalloc (size);
+}
+
+void *
+hybrid_calloc (size_t nmemb, size_t size)
+{
+  if (DUMPED)
+    return calloc (nmemb, size);
+  return gcalloc (nmemb, size);
+}
+
+void
+hybrid_free (void *ptr)
+{
+  if (!DUMPED)
+    gfree (ptr);
+  else if (!ALLOCATED_BEFORE_DUMPING (ptr))
+    free (ptr);
+  /* Otherwise the dumped emacs is trying to free something allocated
+     before dumping; do nothing.  */
+  return;
+}
+
+#if defined HAVE_ALIGNED_ALLOC || defined HAVE_POSIX_MEMALIGN
+void *
+hybrid_aligned_alloc (size_t alignment, size_t size)
+{
+  if (!DUMPED)
+    return galigned_alloc (alignment, size);
+  /* The following is copied from alloc.c */
+#ifdef HAVE_ALIGNED_ALLOC
+  return aligned_alloc (alignment, size);
+#else  /* HAVE_POSIX_MEMALIGN */
+  void *p;
+  return posix_memalign (&p, alignment, size) == 0 ? p : 0;
+#endif
+}
+#endif
+  
+void *
+hybrid_realloc (void *ptr, size_t size)
+{
+  void *result;
+  int type;
+  size_t block, oldsize;
+
+  if (!DUMPED)
+    return grealloc (ptr, size);
+  if (!ALLOCATED_BEFORE_DUMPING (ptr))
+    return realloc (ptr, size);
+
+  /* The dumped emacs is trying to realloc storage allocated before
+   dumping.  We just malloc new space and copy the data.  */
+  if (size == 0 || ptr == NULL)
+    return malloc (size);
+  block = ((char *) ptr - _heapbase) / BLOCKSIZE + 1;
+  type = _heapinfo[block].busy.type;
+  oldsize =
+    type == 0 ? _heapinfo[block].busy.info.size * BLOCKSIZE
+    : (size_t) 1 << type;
+  result = malloc (size);
+  if (result)
+    return memcpy (result, ptr, min (oldsize, size));
+  return result;
+}
+
+#ifdef HYBRID_GET_CURRENT_DIR_NAME
+/* Defined in sysdep.c.  */
+char *gget_current_dir_name (void);
+
+char *
+hybrid_get_current_dir_name (void)
+{
+  if (DUMPED)
+    return get_current_dir_name ();
+  return gget_current_dir_name ();
+}
+#endif
+
+#endif  /* HYBRID_MALLOC */
+
 #ifdef GC_MCHECK
 
 /* Standard debugging hooks for `malloc'.
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 7e7d68d80d4..445e59c335d 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -508,16 +508,16 @@ get_utf8_string (const char *str)
              && err->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE)
         {
           memcpy (up, p, bytes_written);
-          sprintf (up + bytes_written, "\\%03o", p[bytes_written]);
-          up += bytes_written+4;
-          p += bytes_written+1;
+          up += bytes_written;
+          up += sprintf (up, "\\%03o", p[bytes_written]);
+          p += bytes_written + 1;
           g_error_free (err);
           err = NULL;
         }
 
       if (cp)
         {
-          strcat (utf8_str, cp);
+          strcpy (up, cp);
           g_free (cp);
         }
       if (err)
@@ -1324,7 +1324,7 @@ x_wm_set_size_hint (struct frame *f, long int flags, bool user_position)
 
   size_hints.base_width = base_width;
   size_hints.base_height = base_height;
-  size_hints.min_width  = base_width + min_cols * FRAME_COLUMN_WIDTH (f);;
+  size_hints.min_width  = base_width + min_cols * FRAME_COLUMN_WIDTH (f);
   size_hints.min_height = base_height + min_rows * FRAME_LINE_HEIGHT (f);
 
   /* These currently have a one to one mapping with the X values, but I
@@ -2554,11 +2554,18 @@ create_menus (widget_value *data,
 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
   if (! menu_bar_p && add_tearoff_p)
     {
-      GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
-      gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), tearoff);
+      // Only add tearoff if menu is empty.
+      GList *list = gtk_container_get_children (GTK_CONTAINER (wmenu));
+      if (! list)
+        {
+          GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
+          gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), tearoff);
 
-      g_signal_connect (G_OBJECT (tearoff), "activate",
-                        G_CALLBACK (tearoff_activate), 0);
+          g_signal_connect (G_OBJECT (tearoff), "activate",
+                            G_CALLBACK (tearoff_activate), 0);
+        }
+      else
+        g_list_free (list);
     }
 #endif
 
@@ -3088,7 +3095,6 @@ xg_update_submenu (GtkWidget *submenu,
   GList *list = 0;
   GList *iter;
   widget_value *cur;
-  bool has_tearoff_p = 0;
   GList *first_radio = 0;
 
   if (submenu)
@@ -3104,7 +3110,6 @@ xg_update_submenu (GtkWidget *submenu,
   /* Skip tearoff items, they have no counterpart in val.  */
     if (GTK_IS_TEAROFF_MENU_ITEM (w))
       {
-        has_tearoff_p = 1;
         iter = g_list_next (iter);
         if (iter) w = GTK_WIDGET (iter->data);
         else break;
@@ -3198,7 +3203,7 @@ xg_update_submenu (GtkWidget *submenu,
                              highlight_cb,
                              0,
                              0,
-                             ! has_tearoff_p,
+                             1,
                              submenu,
                              cl_data,
                              0);
@@ -3993,17 +3998,18 @@ xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar *bar,
 
       block_input ();
       adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
-
-      /*      gtk_adjustment_set_lower (adj, (gdouble) lower);
+#if GTK_CHECK_VERSION (2, 3, 16)
+      gtk_adjustment_configure (adj, (gdouble) value, (gdouble) lower,
+                                (gdouble) upper, (gdouble) step_increment,
+                                (gdouble) page_increment, (gdouble) pagesize);
+#else
+      gtk_adjustment_set_lower (adj, (gdouble) lower);
       gtk_adjustment_set_upper (adj, (gdouble) upper);
       gtk_adjustment_set_page_size (adj, (gdouble) pagesize);
       gtk_adjustment_set_value (adj, (gdouble) value);
       gtk_adjustment_set_page_increment (adj, (gdouble) page_increment);
-      gtk_adjustment_set_step_increment (adj, (gdouble)
-      step_increment); */
-      gtk_adjustment_configure (adj, (gdouble) value, (gdouble) lower,
-                                (gdouble) upper, (gdouble) step_increment,
-                                (gdouble) page_increment, (gdouble) pagesize);
+      gtk_adjustment_set_step_increment (adj, (gdouble) step_increment);
+#endif
       gtk_adjustment_changed (adj);
       unblock_input ();
     }
diff --git a/src/image.c b/src/image.c
index 804da436ee9..4b73a5fe80c 100644
--- a/src/image.c
+++ b/src/image.c
@@ -3037,13 +3037,16 @@ xbm_load (struct frame *f, struct image *img)
                                      + SBYTES (data)));
       else
         {
+          USE_SAFE_ALLOCA;
+
           if (VECTORP (data))
             {
               int i;
               char *p;
               int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
 
-              p = bits = alloca (nbytes * img->height);
+              SAFE_NALLOCA (bits, nbytes, img->height);
+              p = bits;
               for (i = 0; i < img->height; ++i, p += nbytes)
                 {
                   Lisp_Object line = AREF (data, i);
@@ -3064,9 +3067,8 @@ xbm_load (struct frame *f, struct image *img)
             int nbytes, i;
             /* Windows mono bitmaps are reversed compared with X.  */
             invertedBits = bits;
-            nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR
-              * img->height;
-            bits = alloca (nbytes);
+            nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
+            SAFE_NALLOCA (bits, nbytes, img->height);
             for (i = 0; i < nbytes; i++)
               bits[i] = XBM_BIT_SHUFFLE (invertedBits[i]);
           }
@@ -3088,6 +3090,8 @@ xbm_load (struct frame *f, struct image *img)
                            img->spec, Qnil);
               x_clear_image (f, img);
             }
+
+          SAFE_FREE ();
         }
     }
 
@@ -3494,6 +3498,8 @@ xpm_load (struct frame *f, struct image *img)
   int rc;
   XpmAttributes attrs;
   Lisp_Object specified_file, color_symbols;
+  USE_SAFE_ALLOCA;
+
 #ifdef HAVE_NTGUI
   HDC hdc;
   xpm_XImage * xpm_image = NULL, * xpm_mask = NULL;
@@ -3536,7 +3542,7 @@ xpm_load (struct frame *f, struct image *img)
     {
       Lisp_Object tail;
       XpmColorSymbol *xpm_syms;
-      int i, size;
+      ptrdiff_t i, size;
 
       attrs.valuemask |= XpmColorSymbols;
 
@@ -3546,8 +3552,8 @@ xpm_load (struct frame *f, struct image *img)
         ++attrs.numsymbols;
 
       /* Allocate an XpmColorSymbol array.  */
+      SAFE_NALLOCA (xpm_syms, 1, attrs.numsymbols);
       size = attrs.numsymbols * sizeof *xpm_syms;
-      xpm_syms = alloca (size);
       memset (xpm_syms, 0, size);
       attrs.colorsymbols = xpm_syms;
 
@@ -3569,17 +3575,11 @@ xpm_load (struct frame *f, struct image *img)
           name = XCAR (XCAR (tail));
           color = XCDR (XCAR (tail));
           if (STRINGP (name))
-            {
-              xpm_syms[i].name = alloca (SCHARS (name) + 1);
-              strcpy (xpm_syms[i].name, SSDATA (name));
-            }
+            SAFE_ALLOCA_STRING (xpm_syms[i].name, name);
           else
             xpm_syms[i].name = empty_string;
           if (STRINGP (color))
-            {
-              xpm_syms[i].value = alloca (SCHARS (color) + 1);
-              strcpy (xpm_syms[i].value, SSDATA (color));
-            }
+            SAFE_ALLOCA_STRING (xpm_syms[i].value, color);
           else
             xpm_syms[i].value = empty_string;
         }
@@ -3610,6 +3610,7 @@ xpm_load (struct frame *f, struct image *img)
 #ifdef ALLOC_XPM_COLORS
           xpm_free_color_cache ();
 #endif
+          SAFE_FREE ();
           return 0;
         }
 
@@ -3640,6 +3641,7 @@ xpm_load (struct frame *f, struct image *img)
 #ifdef ALLOC_XPM_COLORS
           xpm_free_color_cache ();
 #endif
+          SAFE_FREE ();
           return 0;
         }
 #ifdef HAVE_NTGUI
@@ -3782,6 +3784,7 @@ xpm_load (struct frame *f, struct image *img)
 #ifdef ALLOC_XPM_COLORS
   xpm_free_color_cache ();
 #endif
+  SAFE_FREE ();
   return rc == XpmSuccess;
 }
 
@@ -6580,6 +6583,7 @@ jpeg_load_body (struct frame *f, struct image *img,
      colors generated, and mgr->cinfo.colormap is a two-dimensional array
      of color indices in the range 0..mgr->cinfo.actual_number_of_colors.
      No more than 255 colors will be generated.  */
+  USE_SAFE_ALLOCA;
   {
     int i, ir, ig, ib;
 
@@ -6595,7 +6599,7 @@ jpeg_load_body (struct frame *f, struct image *img,
        a default color, and we don't have to care about which colors
        can be freed safely, and which can't.  */
     init_color_table ();
-    colors = alloca (mgr->cinfo.actual_number_of_colors * sizeof *colors);
+    SAFE_NALLOCA (colors, 1, mgr->cinfo.actual_number_of_colors);
 
     for (i = 0; i < mgr->cinfo.actual_number_of_colors; ++i)
       {
@@ -6638,6 +6642,7 @@ jpeg_load_body (struct frame *f, struct image *img,
 
   /* Put ximg into the image.  */
   image_put_x_image (f, img, ximg, 0);
+  SAFE_FREE ();
   return 1;
 }
 
@@ -8226,6 +8231,12 @@ imagemagick_load_image (struct frame *f, struct image *img,
       return 0;
     }
 
+  if (MagickGetImageDelay (image_wand) > 0)
+    img->lisp_data =
+      Fcons (Qdelay,
+             Fcons (make_float (MagickGetImageDelay (image_wand) / 100.0),
+                    img->lisp_data));
+
   if (MagickGetNumberImages (image_wand) > 1)
     img->lisp_data =
       Fcons (Qcount,
diff --git a/src/indent.c b/src/indent.c
index 79af42c5f7e..e6b267a3891 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -2004,6 +2004,8 @@ whether or not it is currently displayed in some window.  */)
       int first_x;
       bool overshoot_handled = 0;
       bool disp_string_at_start_p = 0;
+      ptrdiff_t nlines = XINT (lines);
+      int vpos_init = 0;
 
       itdata = bidi_shelve_cache ();
       SET_TEXT_POS (pt, PT, PT_BYTE);
@@ -2093,18 +2095,31 @@ whether or not it is currently displayed in some window.  */)
 
           overshoot_handled = 1;
         }
-      if (XINT (lines) <= 0)
+      else if (IT_CHARPOS (it) == PT - 1
+               && FETCH_BYTE (PT - 1) == '\n'
+               && nlines < 0)
         {
-          it.vpos = 0;
+          /* The position we started from was covered by a display
+             property, so we moved to position before the string, and
+             backed up one line, because the character at PT - 1 is a
+             newline.  So we need one less line to go up.  */
+          nlines++;
+          /* But we still need to record that one line, in order to
+             return the correct value to the caller.  */
+          vpos_init = -1;
+        }
+      if (nlines <= 0)
+        {
+          it.vpos = vpos_init;
           /* Do this even if LINES is 0, so that we move back to the
              beginning of the current line as we ought.  */
-          if (XINT (lines) == 0 || IT_CHARPOS (it) > 0)
-            move_it_by_lines (&it, max (PTRDIFF_MIN, XINT (lines)));
+          if (nlines == 0 || IT_CHARPOS (it) > 0)
+            move_it_by_lines (&it, max (PTRDIFF_MIN, nlines));
         }
       else if (overshoot_handled)
         {
           it.vpos = 0;
-          move_it_by_lines (&it, min (PTRDIFF_MAX, XINT (lines)));
+          move_it_by_lines (&it, min (PTRDIFF_MAX, nlines));
         }
       else
         {
@@ -2119,13 +2134,13 @@ whether or not it is currently displayed in some window.  */)
                   it.vpos = 0;
                   move_it_by_lines (&it, 1);
                 }
-              if (XINT (lines) > 1)
-                move_it_by_lines (&it, min (PTRDIFF_MAX, XINT (lines) - 1));
+              if (nlines > 1)
+                move_it_by_lines (&it, min (PTRDIFF_MAX, nlines - 1));
             }
           else
             {
               it.vpos = 0;
-              move_it_by_lines (&it, min (PTRDIFF_MAX, XINT (lines)));
+              move_it_by_lines (&it, min (PTRDIFF_MAX, nlines));
             }
         }
 
diff --git a/src/keyboard.c b/src/keyboard.c
index 9b0b19ada2f..e8143f26681 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -133,6 +133,19 @@ static ptrdiff_t this_single_command_key_start;
 static ptrdiff_t before_command_key_count;
 static ptrdiff_t before_command_echo_length;
 
+#ifdef HAVE_STACK_OVERFLOW_HANDLING
+
+/* For longjmp to recover from C stack overflow.  */
+sigjmp_buf return_to_command_loop;
+
+/* Message displayed by Vtop_level when recovering from C stack overflow.  */
+static Lisp_Object recover_top_level_message;
+
+#endif /* HAVE_STACK_OVERFLOW_HANDLING */
+
+/* Message normally displayed by Vtop_level.  */
+static Lisp_Object regular_top_level_message;
+
 /* For longjmp to where kbd input is being done.  */
 
 static sys_jmp_buf getcjmp;
@@ -487,10 +500,12 @@ kset_system_key_syms (struct kboard *kb, Lisp_Object val)
 static void
 echo_add_key (Lisp_Object c)
 {
-  int size = KEY_DESCRIPTION_SIZE + 100;
-  char *buffer = alloca (size);
+  char initbuf[KEY_DESCRIPTION_SIZE + 100];
+  ptrdiff_t size = sizeof initbuf;
+  char *buffer = initbuf;
   char *ptr = buffer;
   Lisp_Object echo_string;
+  USE_SAFE_ALLOCA;
 
   echo_string = KVAR (current_kboard, echo_string);
 
@@ -502,13 +517,13 @@ echo_add_key (Lisp_Object c)
   else if (SYMBOLP (c))
     {
       Lisp_Object name = SYMBOL_NAME (c);
-      int nbytes = SBYTES (name);
+      ptrdiff_t nbytes = SBYTES (name);
 
       if (size - (ptr - buffer) < nbytes)
         {
-          int offset = ptr - buffer;
+          ptrdiff_t offset = ptr - buffer;
           size = max (2 * size, size + nbytes);
-          buffer = alloca (size);
+          buffer = SAFE_ALLOCA (size);
           ptr = buffer + offset;
         }
 
@@ -519,14 +534,14 @@ echo_add_key (Lisp_Object c)
   if ((NILP (echo_string) || SCHARS (echo_string) == 0)
       && help_char_p (c))
     {
-      const char *text = " (Type ? for further options)";
-      int len = strlen (text);
+      static const char text[] = " (Type ? for further options)";
+      int len = sizeof text - 1;
 
       if (size - (ptr - buffer) < len)
         {
-          int offset = ptr - buffer;
+          ptrdiff_t offset = ptr - buffer;
           size += len;
-          buffer = alloca (size);
+          buffer = SAFE_ALLOCA (size);
           ptr = buffer + offset;
         }
 
@@ -536,6 +551,7 @@ echo_add_key (Lisp_Object c)
 
   /* Replace a dash from echo_dash with a space, otherwise add a space
      at the end as a separator between keys.  */
+  AUTO_STRING (space, " ");
   if (STRINGP (echo_string) && SCHARS (echo_string) > 1)
     {
       Lisp_Object last_char, prev_char, idx;
@@ -551,14 +567,15 @@ echo_add_key (Lisp_Object c)
       if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
         Faset (echo_string, idx, make_number (' '));
       else
-        echo_string = concat2 (echo_string, build_string (" "));
+        echo_string = concat2 (echo_string, space);
     }
   else if (STRINGP (echo_string) && SCHARS (echo_string) > 0)
-    echo_string = concat2 (echo_string, build_string (" "));
+    echo_string = concat2 (echo_string, space);
 
   kset_echo_string
     (current_kboard,
      concat2 (echo_string, make_string (buffer, ptr - buffer)));
+  SAFE_FREE ();
 }
 
 /* Add C to the echo string, if echoing is going on.  C can be a
@@ -614,9 +631,9 @@ echo_dash (void)
 
   /* Put a dash at the end of the buffer temporarily,
      but make it go away when the next character is added.  */
-  kset_echo_string
-    (current_kboard,
-     concat2 (KVAR (current_kboard, echo_string), build_string ("-")));
+  AUTO_STRING (dash, "-");
+  kset_echo_string (current_kboard,
+                    concat2 (KVAR (current_kboard, echo_string), dash));
   echo_now ();
 }
 
@@ -1109,7 +1126,7 @@ Default value of `command-error-function'.  */)
     {
       print_error_message (data, Qexternal_debugging_output,
                            SSDATA (context), signal);
-      Fterpri (Qexternal_debugging_output);
+      Fterpri (Qexternal_debugging_output, Qnil);
       Fkill_emacs (make_number (-1));
     }
   else
@@ -1134,6 +1151,17 @@ static Lisp_Object top_level_1 (Lisp_Object);
 Lisp_Object
 command_loop (void)
 {
+#ifdef HAVE_STACK_OVERFLOW_HANDLING
+  /* At least on GNU/Linux, saving signal mask is important here.  */
+  if (sigsetjmp (return_to_command_loop, 1) != 0)
+    {
+      /* Comes here from handle_sigsegv, see sysdep.c.  */
+      init_eval ();
+      Vinternal__top_level_message = recover_top_level_message;
+    }
+  else
+    Vinternal__top_level_message = regular_top_level_message;
+#endif /* HAVE_STACK_OVERFLOW_HANDLING */
   if (command_loop_level > 0 || minibuf_level > 0)
     {
       Lisp_Object val;
@@ -1258,13 +1286,9 @@ tracking_off (Lisp_Object old_value)
     }
 }
 
-DEFUN ("track-mouse", Ftrack_mouse, Strack_mouse, 0, UNEVALLED, 0,
-       doc: /* Evaluate BODY with mouse movement events enabled.
-Within a `track-mouse' form, mouse motion generates input events that
-you can read with `read-event'.
-Normally, mouse motion is ignored.
-usage: (track-mouse BODY...)  */)
-  (Lisp_Object args)
+DEFUN ("internal--track-mouse", Ftrack_mouse, Strack_mouse, 1, 1, 0,
+       doc: /* Call BODYFUN with mouse movement events enabled.  */)
+  (Lisp_Object bodyfun)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
   Lisp_Object val;
@@ -1273,7 +1297,7 @@ usage: (track-mouse BODY...)  */)
 
   do_mouse_tracking = Qt;
 
-  val = Fprogn (args);
+  val = call0 (bodyfun);
   return unbind_to (count, val);
 }
 
@@ -1867,16 +1891,11 @@ safe_run_hooks_1 (ptrdiff_t nargs, Lisp_Object *args)
 static Lisp_Object
 safe_run_hooks_error (Lisp_Object error, ptrdiff_t nargs, Lisp_Object *args)
 {
-  Lisp_Object hook, fun, msgargs[4];
-
   eassert (nargs == 2);
-  hook = args[0];
-  fun = args[1];
-  msgargs[0] = build_string ("Error in %s (%S): %S");
-  msgargs[1] = hook;
-  msgargs[2] = fun;
-  msgargs[3] = error;
-  Fmessage (4, msgargs);
+  AUTO_STRING (format, "Error in %s (%S): %S");
+  Lisp_Object hook = args[0];
+  Lisp_Object fun = args[1];
+  Fmessage (4, (Lisp_Object []) {format, hook, fun, error});
 
   if (SYMBOLP (hook))
     {
@@ -2327,15 +2346,16 @@ read_decoded_event_from_main_queue (struct timespec *end_time,
             { /* An encoded byte sequence, let's try to decode it.  */
               struct coding_system *coding
                 = TERMINAL_KEYBOARD_CODING (terminal);
-              unsigned char *src = alloca (n);
+              unsigned char src[MAX_ENCODED_BYTES];
+              unsigned char dest[MAX_ENCODED_BYTES * MAX_MULTIBYTE_LENGTH];
               int i;
               for (i = 0; i < n; i++)
                 src[i] = XINT (events[i]);
               if (meta_key != 2)
                 for (i = 0; i < n; i++)
                   src[i] &= ~0x80;
-              coding->destination = alloca (n * 4);
-              coding->dst_bytes = n * 4;
+              coding->destination = dest;
+              coding->dst_bytes = sizeof dest;
               decode_coding_c_string (coding, src, n, Qnil);
               eassert (coding->produced_char <= n);
               if (coding->produced_char == 0)
@@ -3704,6 +3724,34 @@ kbd_buffer_unget_event (register struct input_event *event)
     }
 }
 
+/* Limit help event positions to this range, to avoid overflow problems.  */
+#define INPUT_EVENT_POS_MAX \
+  ((ptrdiff_t) min (PTRDIFF_MAX, min (TYPE_MAXIMUM (Time) / 2, \
+                                      MOST_POSITIVE_FIXNUM)))
+#define INPUT_EVENT_POS_MIN (-1 - INPUT_EVENT_POS_MAX)
+
+/* Return a Time that encodes position POS.  POS must be in range.  */
+
+static Time
+position_to_Time (ptrdiff_t pos)
+{
+  eassert (INPUT_EVENT_POS_MIN <= pos && pos <= INPUT_EVENT_POS_MAX);
+  return pos;
+}
+
+/* Return the position that ENCODED_POS encodes.
+   Avoid signed integer overflow.  */
+
+static ptrdiff_t
+Time_to_position (Time encoded_pos)
+{
+  if (encoded_pos <= INPUT_EVENT_POS_MAX)
+    return encoded_pos;
+  Time encoded_pos_min = INPUT_EVENT_POS_MIN;
+  eassert (encoded_pos_min <= encoded_pos);
+  ptrdiff_t notpos = -1 - encoded_pos;
+  return -1 - notpos;
+}
 
 /* Generate a HELP_EVENT input_event and store it in the keyboard
    buffer.
@@ -3722,14 +3770,12 @@ gen_help_event (Lisp_Object help, Lisp_Object frame, Lisp_Object window,
 {
   struct input_event event;
 
-  EVENT_INIT (event);
-
   event.kind = HELP_EVENT;
   event.frame_or_window = frame;
   event.arg = object;
   event.x = WINDOWP (window) ? window : frame;
   event.y = help;
-  event.code = pos;
+  event.timestamp = position_to_Time (pos);
   kbd_buffer_store_event (&event);
 }
 
@@ -3746,7 +3792,7 @@ kbd_buffer_store_help_event (Lisp_Object frame, Lisp_Object help)
   event.arg = Qnil;
   event.x = Qnil;
   event.y = help;
-  event.code = 0;
+  event.timestamp = 0;
   kbd_buffer_store_event (&event);
 }
 
@@ -4061,7 +4107,7 @@ kbd_buffer_get_event (KBOARD **kbp,
 
           frame = event->frame_or_window;
           object = event->arg;
-          position = make_number (event->code);
+          position = make_number (Time_to_position (event->timestamp));
           window = event->x;
           help = event->y;
           clear_event (event);
@@ -5171,14 +5217,15 @@ static const char *const lispy_drag_n_drop_names[] =
 static Lisp_Object Qabove_handle, Qhandle, Qbelow_handle;
 static Lisp_Object Qbefore_handle, Qhorizontal_handle, Qafter_handle;
 Lisp_Object Qup, Qdown, Qtop, Qbottom;
-Lisp_Object Qleft, Qright;
 static Lisp_Object Qleftmost, Qrightmost;
 static Lisp_Object Qend_scroll;
 static Lisp_Object Qratio;
 
-/* An array of scroll bar parts, indexed by an enum scroll_bar_part value.  */
+/* An array of scroll bar parts, indexed by an enum scroll_bar_part value.
+   Note that Qnil corresponds to scroll_bar_nowhere and should not appear
+   in Lisp events.  */
 static Lisp_Object *const scroll_bar_parts[] = {
-  &Qabove_handle, &Qhandle, &Qbelow_handle,
+  &Qnil, &Qabove_handle, &Qhandle, &Qbelow_handle,
   &Qup, &Qdown, &Qtop, &Qbottom, &Qend_scroll, &Qratio,
   &Qbefore_handle, &Qhorizontal_handle, &Qafter_handle,
   &Qleft, &Qright, &Qleftmost, &Qrightmost, &Qend_scroll, &Qratio
@@ -5425,6 +5472,16 @@ toolkit_menubar_in_use (struct frame *f)
 #endif
 }
 
+/* Build the part of Lisp event which represents scroll bar state from
+   EV.  TYPE is one of Qvertical_scroll_bar or Qhorizontal_scroll_bar.  */
+
+static Lisp_Object
+make_scroll_bar_position (struct input_event *ev, Lisp_Object type)
+{
+  return list5 (ev->frame_or_window, type, Fcons (ev->x, ev->y),
+                make_number (ev->timestamp), *scroll_bar_parts[ev->part]);
+}
+
 /* Given a struct input_event, build the lisp event which represents
    it.  If EVENT is 0, build a mouse movement event from the mouse
    movement buffer, which should have a movement event in it.
@@ -5513,30 +5570,27 @@ make_lispy_event (struct input_event *event)
                                     ARRAYELTS (iso_lispy_function_keys));
 #endif
 
-      /* Handle system-specific or unknown keysyms.  */
-      if (event->code & (1 << 28)
-          || event->code - FUNCTION_KEY_OFFSET < 0
-          || (event->code - FUNCTION_KEY_OFFSET
-              >= ARRAYELTS (lispy_function_keys))
-          || !lispy_function_keys[event->code - FUNCTION_KEY_OFFSET])
-        {
-          /* We need to use an alist rather than a vector as the cache
-             since we can't make a vector long enough.  */
-          if (NILP (KVAR (current_kboard, system_key_syms)))
-            kset_system_key_syms (current_kboard, Fcons (Qnil, Qnil));
-          return modify_event_symbol (event->code,
-                                      event->modifiers,
-                                      Qfunction_key,
-                                      KVAR (current_kboard, Vsystem_key_alist),
-                                      0, &KVAR (current_kboard, system_key_syms),
-                                      PTRDIFF_MAX);
-        }
-
-      return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET,
+      if ((FUNCTION_KEY_OFFSET <= event->code
+           && (event->code
+               < FUNCTION_KEY_OFFSET + ARRAYELTS (lispy_function_keys)))
+          && lispy_function_keys[event->code - FUNCTION_KEY_OFFSET])
+        return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET,
+                                    event->modifiers,
+                                    Qfunction_key, Qnil,
+                                    lispy_function_keys, &func_key_syms,
+                                    ARRAYELTS (lispy_function_keys));
+
+      /* Handle system-specific or unknown keysyms.
+         We need to use an alist rather than a vector as the cache
+         since we can't make a vector long enough.  */
+      if (NILP (KVAR (current_kboard, system_key_syms)))
+        kset_system_key_syms (current_kboard, Fcons (Qnil, Qnil));
+      return modify_event_symbol (event->code,
                                   event->modifiers,
-                                  Qfunction_key, Qnil,
-                                  lispy_function_keys, &func_key_syms,
-                                  ARRAYELTS (lispy_function_keys));
+                                  Qfunction_key,
+                                  KVAR (current_kboard, Vsystem_key_alist),
+                                  0, &KVAR (current_kboard, system_key_syms),
+                                  PTRDIFF_MAX);
 
 #ifdef HAVE_NTGUI
     case MULTIMEDIA_KEY_EVENT:
@@ -5642,20 +5696,8 @@ make_lispy_event (struct input_event *event)
           }
 #ifndef USE_TOOLKIT_SCROLL_BARS
         else
-          {
-            /* It's a scrollbar click.  */
-            Lisp_Object window;
-            Lisp_Object portion_whole;
-            Lisp_Object part;
-
-            window = event->frame_or_window;
-            portion_whole = Fcons (event->x, event->y);
-            part = *scroll_bar_parts[(int) event->part];
-
-            position = list5 (window, Qvertical_scroll_bar,
-                              portion_whole, make_number (event->timestamp),
-                              part);
-          }
+          /* It's a scrollbar click.  */
+          position = make_scroll_bar_position (event, Qvertical_scroll_bar);
 #endif /* not USE_TOOLKIT_SCROLL_BARS */
 
         if (button >= ASIZE (button_down_location))
@@ -5932,14 +5974,9 @@ make_lispy_event (struct input_event *event)
 
     case SCROLL_BAR_CLICK_EVENT:
       {
-        Lisp_Object position, head, window, portion_whole, part;
-
-        window = event->frame_or_window;
-        portion_whole = Fcons (event->x, event->y);
-        part = *scroll_bar_parts[(int) event->part];
+        Lisp_Object position, head;
 
-        position = list5 (window, Qvertical_scroll_bar, portion_whole,
-                          make_number (event->timestamp), part);
+        position = make_scroll_bar_position (event, Qvertical_scroll_bar);
 
         /* Always treat scroll bar events as clicks.  */
         event->modifiers |= click_modifier;
@@ -5962,14 +5999,9 @@ make_lispy_event (struct input_event *event)
 
     case HORIZONTAL_SCROLL_BAR_CLICK_EVENT:
       {
-        Lisp_Object position, head, window, portion_whole, part;
+        Lisp_Object position, head;
 
-        window = event->frame_or_window;
-        portion_whole = Fcons (event->x, event->y);
-        part = *scroll_bar_parts[(int) event->part];
-
-        position = list5 (window, Qhorizontal_scroll_bar, portion_whole,
-                          make_number (event->timestamp), part);
+        position = make_scroll_bar_position (event, Qhorizontal_scroll_bar);
 
         /* Always treat scroll bar events as clicks.  */
         event->modifiers |= click_modifier;
@@ -7410,11 +7442,14 @@ menu_bar_items (Lisp_Object old)
      in the current keymaps, or nil where it is not a prefix.  */
   Lisp_Object *maps;
 
+  Lisp_Object mapsbuf[3];
   Lisp_Object def, tail;
 
   ptrdiff_t mapno;
   Lisp_Object oquit;
 
+  USE_SAFE_ALLOCA;
+
   /* In order to build the menus, we need to call the keymap
      accessors.  They all call QUIT.  But this function is called
      during redisplay, during which a quit is fatal.  So inhibit
@@ -7443,7 +7478,7 @@ menu_bar_items (Lisp_Object old)
         && !NILP (Voverriding_local_map))
       {
         /* Yes, use them (if non-nil) as well as the global map.  */
-        maps = alloca (3 * sizeof (maps[0]));
+        maps = mapsbuf;
         nmaps = 0;
         if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
           maps[nmaps++] = KVAR (current_kboard, Voverriding_terminal_local_map);
@@ -7460,7 +7495,7 @@ menu_bar_items (Lisp_Object old)
         Lisp_Object tem;
         ptrdiff_t nminor;
         nminor = current_minor_maps (NULL, &tmaps);
-        maps = alloca ((nminor + 4) * sizeof *maps);
+        SAFE_NALLOCA (maps, 1, nminor + 4);
         nmaps = 0;
         tem = KVAR (current_kboard, Voverriding_terminal_local_map);
         if (!NILP (tem) && !NILP (Voverriding_local_map_menu_flag))
@@ -7532,6 +7567,7 @@ menu_bar_items (Lisp_Object old)
   }
 
   Vinhibit_quit = oquit;
+  SAFE_FREE ();
   return menu_bar_items_vector;
 }
 
@@ -7847,11 +7883,12 @@ parse_menu_item (Lisp_Object item, int inmenubar)
 
   { /* This is a command.  See if there is an equivalent key binding.  */
     Lisp_Object keyeq = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
+    AUTO_STRING (space_space, "  ");
 
     /* The previous code preferred :key-sequence to :keys, so we
        preserve this behavior.  */
     if (STRINGP (keyeq) && !CONSP (keyhint))
-      keyeq = concat2 (build_string ("  "), Fsubstitute_command_keys (keyeq));
+      keyeq = concat2 (space_space, Fsubstitute_command_keys (keyeq));
     else
       {
         Lisp_Object prefix = keyeq;
@@ -7894,8 +7931,7 @@ parse_menu_item (Lisp_Object item, int inmenubar)
                 if (STRINGP (XCDR (prefix)))
                   tem = concat2 (tem, XCDR (prefix));
               }
-            keyeq = concat2 (build_string ("  "), tem);
-            /* keyeq = concat3(build_string("  ("),tem,build_string(")")); */
+            keyeq = concat2 (space_space, tem);
           }
         else
           keyeq = Qnil;
@@ -7968,9 +8004,11 @@ Lisp_Object
 tool_bar_items (Lisp_Object reuse, int *nitems)
 {
   Lisp_Object *maps;
+  Lisp_Object mapsbuf[3];
   ptrdiff_t nmaps, i;
   Lisp_Object oquit;
   Lisp_Object *tmaps;
+  USE_SAFE_ALLOCA;
 
   *nitems = 0;
 
@@ -7994,7 +8032,7 @@ tool_bar_items (Lisp_Object reuse, int *nitems)
       && !NILP (Voverriding_local_map))
     {
       /* Yes, use them (if non-nil) as well as the global map.  */
-      maps = alloca (3 * sizeof *maps);
+      maps = mapsbuf;
       nmaps = 0;
       if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
         maps[nmaps++] = KVAR (current_kboard, Voverriding_terminal_local_map);
@@ -8011,7 +8049,7 @@ tool_bar_items (Lisp_Object reuse, int *nitems)
       Lisp_Object tem;
       ptrdiff_t nminor;
       nminor = current_minor_maps (NULL, &tmaps);
-      maps = alloca ((nminor + 4) * sizeof *maps);
+      SAFE_NALLOCA (maps, 1, nminor + 4);
       nmaps = 0;
       tem = KVAR (current_kboard, Voverriding_terminal_local_map);
       if (!NILP (tem) && !NILP (Voverriding_local_map_menu_flag))
@@ -8040,6 +8078,7 @@ tool_bar_items (Lisp_Object reuse, int *nitems)
 
   Vinhibit_quit = oquit;
   *nitems = ntool_bar_items / TOOL_BAR_ITEM_NSLOTS;
+  SAFE_FREE ();
   return tool_bar_items_vector;
 }
 
@@ -8478,7 +8517,7 @@ static Lisp_Object
 read_char_minibuf_menu_prompt (int commandflag,
                                Lisp_Object map)
 {
-  register Lisp_Object name;
+  Lisp_Object name;
   ptrdiff_t nlength;
   /* FIXME: Use the minibuffer's frame width.  */
   ptrdiff_t width = FRAME_COLS (SELECTED_FRAME ()) - 4;
@@ -8596,10 +8635,14 @@ read_char_minibuf_menu_prompt (int commandflag,
                       /* Insert button prefix.  */
                       Lisp_Object selected
                         = AREF (item_properties, ITEM_PROPERTY_SELECTED);
+                      AUTO_STRING (radio_yes, "(*) ");
+                      AUTO_STRING (radio_no , "( ) ");
+                      AUTO_STRING (check_yes, "[X] ");
+                      AUTO_STRING (check_no , "[ ] ");
                       if (EQ (tem, QCradio))
-                        tem = build_string (NILP (selected) ? "(*) " : "( ) ");
+                        tem = NILP (selected) ? radio_yes : radio_no;
                       else
-                        tem = build_string (NILP (selected) ? "[X] " : "[ ] ");
+                        tem = NILP (selected) ? check_yes : check_no;
                       s = concat2 (tem, s);
                     }
 
@@ -10306,7 +10349,7 @@ static void
 handle_interrupt_signal (int sig)
 {
   /* See if we have an active terminal on our controlling tty.  */
-  struct terminal *terminal = get_named_tty ("/dev/tty");
+  struct terminal *terminal = get_named_terminal ("/dev/tty");
   if (!terminal)
     {
       /* If there are no frames there, let's pretend that we are a
@@ -10360,7 +10403,7 @@ handle_interrupt (bool in_signal_handler)
   cancel_echoing ();
 
   /* XXX This code needs to be revised for multi-tty support.  */
-  if (!NILP (Vquit_flag) && get_named_tty ("/dev/tty"))
+  if (!NILP (Vquit_flag) && get_named_terminal ("/dev/tty"))
     {
       if (! in_signal_handler)
         {
@@ -10572,9 +10615,10 @@ Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
 See also `current-input-mode'.  */)
   (Lisp_Object flow, Lisp_Object terminal)
 {
-  struct terminal *t = get_terminal (terminal, 1);
+  struct terminal *t = decode_tty_terminal (terminal);
   struct tty_display_info *tty;
-  if (t == NULL || (t->type != output_termcap && t->type != output_msdos_raw))
+
+  if (!t)
     return Qnil;
   tty = t->display_info.tty;
 
@@ -10614,11 +10658,11 @@ the currently selected frame.
 See also `current-input-mode'.  */)
   (Lisp_Object meta, Lisp_Object terminal)
 {
-  struct terminal *t = get_terminal (terminal, 1);
+  struct terminal *t = decode_tty_terminal (terminal);
   struct tty_display_info *tty;
   int new_meta;
 
-  if (t == NULL || (t->type != output_termcap && t->type != output_msdos_raw))
+  if (!t)
     return Qnil;
   tty = t->display_info.tty;
 
@@ -10655,9 +10699,10 @@ process.
 See also `current-input-mode'.  */)
   (Lisp_Object quit)
 {
-  struct terminal *t = get_named_tty ("/dev/tty");
+  struct terminal *t = get_named_terminal ("/dev/tty");
   struct tty_display_info *tty;
-  if (t == NULL || (t->type != output_termcap && t->type != output_msdos_raw))
+
+  if (!t)
     return Qnil;
   tty = t->display_info.tty;
 
@@ -11000,6 +11045,15 @@ syms_of_keyboard (void)
   Vlispy_mouse_stem = build_pure_c_string ("mouse");
   staticpro (&Vlispy_mouse_stem);
 
+  regular_top_level_message = build_pure_c_string ("Back to top level");
+#ifdef HAVE_STACK_OVERFLOW_HANDLING
+  recover_top_level_message
+    = build_pure_c_string ("Re-entering top level after C stack overflow");
+#endif
+  DEFVAR_LISP ("internal--top-level-message", Vinternal__top_level_message,
+               doc: /* Message displayed by `normal-top-level'.  */);
+  Vinternal__top_level_message = regular_top_level_message;
+
   /* Tool-bars.  */
   DEFSYM (QCimage, ":image");
   DEFSYM (Qhelp_echo, "help-echo");
diff --git a/src/keymap.c b/src/keymap.c
index f4dd644aebd..c7c7d196c22 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1299,11 +1299,8 @@ define_as_prefix (Lisp_Object keymap, Lisp_Object c)
 static Lisp_Object
 append_key (Lisp_Object key_sequence, Lisp_Object key)
 {
-  Lisp_Object args[2];
-
-  args[0] = key_sequence;
-  args[1] = list1 (key);
-  return Fvconcat (2, args);
+  AUTO_LIST1 (key_list, key);
+  return Fvconcat (2, ((Lisp_Object []) { key_sequence, key_list }));
 }
 
 /* Given a event type C which is a symbol,
@@ -1342,7 +1339,8 @@ silly_event_symbol_error (Lisp_Object c)
       *p = 0;
 
       c = reorder_modifiers (c);
-      keystring = concat2 (build_string (new_mods), XCDR (assoc));
+      AUTO_STRING (new_mods_string, new_mods);
+      keystring = concat2 (new_mods_string, XCDR (assoc));
 
       error ("To bind the key %s, use [?%s], not [%s]",
              SDATA (SYMBOL_NAME (c)), SDATA (keystring),
@@ -2239,14 +2237,19 @@ Optional argument NO-ANGLES non-nil means don't put angle brackets
 around function keys and event symbols.  */)
   (Lisp_Object key, Lisp_Object no_angles)
 {
+  USE_SAFE_ALLOCA;
+
   if (CONSP (key) && lucid_event_type_list_p (key))
     key = Fevent_convert_list (key);
 
   if (CONSP (key) && INTEGERP (XCAR (key)) && INTEGERP (XCDR (key)))
     /* An interval from a map-char-table.  */
-    return concat3 (Fsingle_key_description (XCAR (key), no_angles),
-                    build_string (".."),
-                    Fsingle_key_description (XCDR (key), no_angles));
+    {
+      AUTO_STRING (dot_dot, "..");
+      return concat3 (Fsingle_key_description (XCAR (key), no_angles),
+                      dot_dot,
+                      Fsingle_key_description (XCDR (key), no_angles));
+    }
 
   key = EVENT_HEAD (key);
 
@@ -2262,7 +2265,6 @@ around function keys and event symbols.  */)
       if (NILP (no_angles))
         {
           Lisp_Object result;
-          USE_SAFE_ALLOCA;
           char *buffer = SAFE_ALLOCA (sizeof "<>"
                                       + SBYTES (SYMBOL_NAME (key)));
           esprintf (buffer, "<%s>", SDATA (SYMBOL_NAME (key)));
@@ -2883,13 +2885,14 @@ You type        Translation\n\
           if (!SYMBOLP (modes[i]))
             emacs_abort ();
 
-          p = title = alloca (42 + SCHARS (SYMBOL_NAME (modes[i])));
+          USE_SAFE_ALLOCA;
+          p = title = SAFE_ALLOCA (42 + SBYTES (SYMBOL_NAME (modes[i])));
           *p++ = '\f';
           *p++ = '\n';
           *p++ = '`';
           memcpy (p, SDATA (SYMBOL_NAME (modes[i])),
-                  SCHARS (SYMBOL_NAME (modes[i])));
-          p += SCHARS (SYMBOL_NAME (modes[i]));
+                  SBYTES (SYMBOL_NAME (modes[i])));
+          p += SBYTES (SYMBOL_NAME (modes[i]));
           *p++ = '\'';
           memcpy (p, " Minor Mode Bindings", strlen (" Minor Mode Bindings"));
           p += strlen (" Minor Mode Bindings");
@@ -2898,6 +2901,7 @@ You type        Translation\n\
           describe_map_tree (maps[i], 1, shadow, prefix,
                              title, nomenu, 0, 0, 0);
           shadow = Fcons (maps[i], shadow);
+          SAFE_FREE ();
         }
 
       start1 = get_local_map (BUF_PT (XBUFFER (buffer)),
@@ -3184,10 +3188,10 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
 
   /* These accumulate the values from sparse keymap bindings,
      so we can sort them and handle them in order.  */
-  int length_needed = 0;
+  ptrdiff_t length_needed = 0;
   struct describe_map_elt *vect;
-  int slots_used = 0;
-  int i;
+  ptrdiff_t slots_used = 0;
+  ptrdiff_t i;
 
   suppress = Qnil;
 
@@ -3207,7 +3211,8 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
   for (tail = map; CONSP (tail); tail = XCDR (tail))
     length_needed++;
 
-  vect = alloca (length_needed * sizeof *vect);
+  USE_SAFE_ALLOCA;
+  SAFE_NALLOCA (vect, 1, length_needed);
 
   for (tail = map; CONSP (tail); tail = XCDR (tail))
     {
@@ -3350,6 +3355,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
         }
     }
 
+  SAFE_FREE ();
   UNGCPRO;
 }
 
@@ -3358,7 +3364,7 @@ describe_vector_princ (Lisp_Object elt, Lisp_Object fun)
 {
   Findent_to (make_number (16), make_number (1));
   call1 (fun, elt);
-  Fterpri (Qnil);
+  Fterpri (Qnil, Qnil);
 }
 
 DEFUN ("describe-vector", Fdescribe_vector, Sdescribe_vector, 1, 2, 0,
@@ -3438,9 +3444,9 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
       /* Call Fkey_description first, to avoid GC bug for the other string.  */
       if (!NILP (prefix) && XFASTINT (Flength (prefix)) > 0)
         {
-          Lisp_Object tem;
-          tem = Fkey_description (prefix, Qnil);
-          elt_prefix = concat2 (tem, build_string (" "));
+          Lisp_Object tem = Fkey_description (prefix, Qnil);
+          AUTO_STRING (space, " ");
+          elt_prefix = concat2 (tem, space);
         }
       prefix = Qnil;
     }
diff --git a/src/lastfile.c b/src/lastfile.c
index a900e9541c8..84b28b0311b 100644
--- a/src/lastfile.c
+++ b/src/lastfile.c
@@ -36,6 +36,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 
+#include "lisp.h"
+
 char my_edata[] = "End of Emacs initialized data";
 
 /* Help unexec locate the end of the .bss area used by Emacs (which
diff --git a/src/lisp.h b/src/lisp.h
index 67299706c6b..89f29ea268b 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -36,31 +36,15 @@ INLINE_HEADER_BEGIN
 
 /* Define a TYPE constant ID as an externally visible name.  Use like this:
 
-      #define ID_val (some integer preprocessor expression)
-      #if ENUMABLE (ID_val)
-      DEFINE_GDB_SYMBOL_ENUM (ID)
-      #else
       DEFINE_GDB_SYMBOL_BEGIN (TYPE, ID)
-      # define ID ID_val
+      # define ID (some integer preprocessor expression of type TYPE)
       DEFINE_GDB_SYMBOL_END (ID)
-      #endif
 
    This hack is for the benefit of compilers that do not make macro
-   definitions visible to the debugger.  It's used for symbols that
-   .gdbinit needs, symbols whose values may not fit in 'int' (where an
-   enum would suffice).
+   definitions or enums visible to the debugger.  It's used for symbols
+   that .gdbinit needs.  */
 
-   Some GCC versions before GCC 4.2 omit enums in debugging output;
-   see GCC bug 23336.  So don't use enums with older GCC.  */
-
-#if !defined __GNUC__ || 4 < __GNUC__ + (2 <= __GNUC_MINOR__)
-# define ENUMABLE(val) (INT_MIN <= (val) && (val) <= INT_MAX)
-#else
-# define ENUMABLE(val) 0
-#endif
-
-#define DEFINE_GDB_SYMBOL_ENUM(id) enum { id = id##_val };
-#if defined MAIN_PROGRAM
+#ifdef MAIN_PROGRAM
 # define DEFINE_GDB_SYMBOL_BEGIN(type, id) type const id EXTERNALLY_VISIBLE
 # define DEFINE_GDB_SYMBOL_END(id) = id;
 #else
@@ -88,7 +72,8 @@ DEFINE_GDB_SYMBOL_END (GCTYPEBITS)
    2.  We know malloc returns a multiple of 8.  */
 #if (defined alignas \
      && (defined GNU_MALLOC || defined DOUG_LEA_MALLOC || defined __GLIBC__ \
-         || defined DARWIN_OS || defined __sun || defined __MINGW32__))
+         || defined DARWIN_OS || defined __sun || defined __MINGW32__ \
+         || defined CYGWIN))
 # define NONPOINTER_BITS 0
 #else
 # define NONPOINTER_BITS GCTYPEBITS
@@ -297,6 +282,11 @@ error !;
 # endif
 #endif
 
+#ifdef HAVE_STRUCT_ATTRIBUTE_ALIGNED
+# define GCALIGNED __attribute__ ((aligned (GCALIGNMENT)))
+#else
+# define GCALIGNED /* empty */
+#endif
 
 /* Some operations are so commonly executed that they are implemented
    as macros, not functions, because otherwise runtime performance would
@@ -590,25 +580,15 @@ LISP_MACRO_DEFUN (XIL, Lisp_Object, (EMACS_INT i), (i))
 
 /* In the size word of a vector, this bit means the vector has been marked.  */
 
-#define ARRAY_MARK_FLAG_val PTRDIFF_MIN
-#if ENUMABLE (ARRAY_MARK_FLAG_val)
-DEFINE_GDB_SYMBOL_ENUM (ARRAY_MARK_FLAG)
-#else
 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, ARRAY_MARK_FLAG)
-# define ARRAY_MARK_FLAG ARRAY_MARK_FLAG_val
+# define ARRAY_MARK_FLAG PTRDIFF_MIN
 DEFINE_GDB_SYMBOL_END (ARRAY_MARK_FLAG)
-#endif
 
 /* In the size word of a struct Lisp_Vector, this bit means it's really
    some other vector-like object.  */
-#define PSEUDOVECTOR_FLAG_val (PTRDIFF_MAX - PTRDIFF_MAX / 2)
-#if ENUMABLE (PSEUDOVECTOR_FLAG_val)
-DEFINE_GDB_SYMBOL_ENUM (PSEUDOVECTOR_FLAG)
-#else
 DEFINE_GDB_SYMBOL_BEGIN (ptrdiff_t, PSEUDOVECTOR_FLAG)
-# define PSEUDOVECTOR_FLAG PSEUDOVECTOR_FLAG_val
+# define PSEUDOVECTOR_FLAG (PTRDIFF_MAX - PTRDIFF_MAX / 2)
 DEFINE_GDB_SYMBOL_END (PSEUDOVECTOR_FLAG)
-#endif
 
 /* In a pseudovector, the size field actually contains a word with one
    PSEUDOVECTOR_FLAG bit set, and one of the following values extracted
@@ -661,14 +641,9 @@ enum More_Lisp_Bits
    that cons.  */
 
 /* Mask for the value (as opposed to the type bits) of a Lisp object.  */
-#define VALMASK_val (USE_LSB_TAG ? - (1 << GCTYPEBITS) : VAL_MAX)
-#if ENUMABLE (VALMASK_val)
-DEFINE_GDB_SYMBOL_ENUM (VALMASK)
-#else
 DEFINE_GDB_SYMBOL_BEGIN (EMACS_INT, VALMASK)
-# define VALMASK VALMASK_val
+# define VALMASK (USE_LSB_TAG ? - (1 << GCTYPEBITS) : VAL_MAX)
 DEFINE_GDB_SYMBOL_END (VALMASK)
-#endif
 
 /* Largest and smallest representable fixnum values.  These are the C
    values.  They are macros for use in static initializers.  */
@@ -1015,7 +990,7 @@ LISP_MACRO_DEFUN_VOID (CHECK_TYPE,
 
 typedef struct interval *INTERVAL;
 
-struct Lisp_Cons
+struct GCALIGNED Lisp_Cons
   {
     /* Car of this cons cell.  */
     Lisp_Object car;
@@ -1097,7 +1072,7 @@ CDR_SAFE (Lisp_Object c)
 
 /* In a string or vector, the sign bit of the `size' is the gc mark bit.  */
 
-struct Lisp_String
+struct GCALIGNED Lisp_String
   {
     ptrdiff_t size;
     ptrdiff_t size_byte;
@@ -3036,6 +3011,16 @@ struct gcpro
   ptrdiff_t nvars;
 
 #ifdef DEBUG_GCPRO
+  /* File name where this record is used.  */
+  const char *name;
+
+  /* Line number in this file.  */
+  int lineno;
+
+  /* Index in the local chain of records.  */
+  int idx;
+
+  /* Nesting level.  */
   int level;
 #endif
 };
@@ -3091,122 +3076,150 @@ struct gcpro
 
 #ifndef DEBUG_GCPRO
 
-#define GCPRO1(varname) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
-  gcprolist = &gcpro1; }
-
-#define GCPRO2(varname1, varname2) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
-  gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
-  gcprolist = &gcpro2; }
+#define GCPRO1(a)                                                       \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcprolist = &gcpro1; }
+
+#define GCPRO2(a, b)                                                    \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcprolist = &gcpro2; }
+
+#define GCPRO3(a, b, c)                                                 \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
+    gcprolist = &gcpro3; }
+
+#define GCPRO4(a, b, c, d)                                              \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
+    gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
+    gcprolist = &gcpro4; }
+
+#define GCPRO5(a, b, c, d, e)                                           \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
+    gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
+    gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
+    gcprolist = &gcpro5; }
+
+#define GCPRO6(a, b, c, d, e, f)                                        \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
+    gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
+    gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
+    gcpro6.next = &gcpro5; gcpro6.var = &(f); gcpro6.nvars = 1;         \
+    gcprolist = &gcpro6; }
 
-#define GCPRO3(varname1, varname2, varname3) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
-  gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
-  gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
-  gcprolist = &gcpro3; }
-
-#define GCPRO4(varname1, varname2, varname3, varname4) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
-  gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
-  gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
-  gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
-  gcprolist = &gcpro4; }
-
-#define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
-  gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
-  gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
-  gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
-  gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
-  gcprolist = &gcpro5; }
-
-#define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
-  gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
-  gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
-  gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
-  gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
-  gcpro6.next = &gcpro5; gcpro6.var = &varname6; gcpro6.nvars = 1; \
-  gcprolist = &gcpro6; }
-
-#define GCPRO7(a, b, c, d, e, f, g)                             \
- {gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1; \
-  gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;   \
-  gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;   \
-  gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;   \
-  gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;   \
-  gcpro6.next = &gcpro5; gcpro6.var = &(f); gcpro6.nvars = 1;   \
-  gcpro7.next = &gcpro6; gcpro7.var = &(g); gcpro7.nvars = 1;   \
-  gcprolist = &gcpro7; }
+#define GCPRO7(a, b, c, d, e, f, g)                                     \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
+    gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
+    gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
+    gcpro6.next = &gcpro5; gcpro6.var = &(f); gcpro6.nvars = 1;         \
+    gcpro7.next = &gcpro6; gcpro7.var = &(g); gcpro7.nvars = 1;         \
+    gcprolist = &gcpro7; }
 
 #define UNGCPRO (gcprolist = gcpro1.next)
 
-#else
+#else /* !DEBUG_GCPRO */
 
 extern int gcpro_level;
 
-#define GCPRO1(varname) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
-  gcpro1.level = gcpro_level++; \
-  gcprolist = &gcpro1; }
-
-#define GCPRO2(varname1, varname2) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
-  gcpro1.level = gcpro_level; \
-  gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
-  gcpro2.level = gcpro_level++; \
-  gcprolist = &gcpro2; }
-
-#define GCPRO3(varname1, varname2, varname3) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
-  gcpro1.level = gcpro_level; \
-  gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
-  gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
-  gcpro3.level = gcpro_level++; \
-  gcprolist = &gcpro3; }
-
-#define GCPRO4(varname1, varname2, varname3, varname4) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
-  gcpro1.level = gcpro_level; \
-  gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
-  gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
-  gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
-  gcpro4.level = gcpro_level++; \
-  gcprolist = &gcpro4; }
-
-#define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
-  gcpro1.level = gcpro_level; \
-  gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
-  gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
-  gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
-  gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
-  gcpro5.level = gcpro_level++; \
-  gcprolist = &gcpro5; }
-
-#define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
- {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
-  gcpro1.level = gcpro_level; \
-  gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
-  gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
-  gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
-  gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
-  gcpro6.next = &gcpro5; gcpro6.var = &varname6; gcpro6.nvars = 1; \
-  gcpro6.level = gcpro_level++; \
-  gcprolist = &gcpro6; }
+#define GCPRO1(a)                                                       \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
+    gcpro1.level = gcpro_level++;                                       \
+    gcprolist = &gcpro1; }
+
+#define GCPRO2(a, b)                                                    \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
+    gcpro1.level = gcpro_level;                                         \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
+    gcpro2.level = gcpro_level++;                                       \
+    gcprolist = &gcpro2; }
+
+#define GCPRO3(a, b, c)                                                 \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
+    gcpro1.level = gcpro_level;                                         \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
+    gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
+    gcpro3.name = __FILE__; gcpro3.lineno = __LINE__; gcpro3.idx = 3;   \
+    gcpro3.level = gcpro_level++;                                       \
+    gcprolist = &gcpro3; }
+
+#define GCPRO4(a, b, c, d)                                              \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
+    gcpro1.level = gcpro_level;                                         \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
+    gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
+    gcpro3.name = __FILE__; gcpro3.lineno = __LINE__; gcpro3.idx = 3;   \
+    gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
+    gcpro4.name = __FILE__; gcpro4.lineno = __LINE__; gcpro4.idx = 4;   \
+    gcpro4.level = gcpro_level++;                                       \
+    gcprolist = &gcpro4; }
+
+#define GCPRO5(a, b, c, d, e)                                           \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
+    gcpro1.level = gcpro_level;                                         \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
+    gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
+    gcpro3.name = __FILE__; gcpro3.lineno = __LINE__; gcpro3.idx = 3;   \
+    gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
+    gcpro4.name = __FILE__; gcpro4.lineno = __LINE__; gcpro4.idx = 4;   \
+    gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
+    gcpro5.name = __FILE__; gcpro5.lineno = __LINE__; gcpro5.idx = 5;   \
+    gcpro5.level = gcpro_level++;                                       \
+    gcprolist = &gcpro5; }
+
+#define GCPRO6(a, b, c, d, e, f)                                        \
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
+    gcpro1.level = gcpro_level;                                         \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
+    gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
+    gcpro3.name = __FILE__; gcpro3.lineno = __LINE__; gcpro3.idx = 3;   \
+    gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
+    gcpro4.name = __FILE__; gcpro4.lineno = __LINE__; gcpro4.idx = 4;   \
+    gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
+    gcpro5.name = __FILE__; gcpro5.lineno = __LINE__; gcpro5.idx = 5;   \
+    gcpro6.next = &gcpro5; gcpro6.var = &(f); gcpro6.nvars = 1;         \
+    gcpro6.name = __FILE__; gcpro6.lineno = __LINE__; gcpro6.idx = 6;   \
+    gcpro6.level = gcpro_level++;                                       \
+    gcprolist = &gcpro6; }
 
 #define GCPRO7(a, b, c, d, e, f, g)                                     \
- {gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;         \
-  gcpro1.level = gcpro_level;                                           \
-  gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;           \
-  gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;           \
-  gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;           \
-  gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;           \
-  gcpro6.next = &gcpro5; gcpro6.var = &(f); gcpro6.nvars = 1;           \
-  gcpro7.next = &gcpro6; gcpro7.var = &(g); gcpro7.nvars = 1;           \
-  gcpro7.level = gcpro_level++;                                         \
-  gcprolist = &gcpro7; }
+  { gcpro1.next = gcprolist; gcpro1.var = &(a); gcpro1.nvars = 1;       \
+    gcpro1.name = __FILE__; gcpro1.lineno = __LINE__; gcpro1.idx = 1;   \
+    gcpro1.level = gcpro_level;                                         \
+    gcpro2.next = &gcpro1; gcpro2.var = &(b); gcpro2.nvars = 1;         \
+    gcpro2.name = __FILE__; gcpro2.lineno = __LINE__; gcpro2.idx = 2;   \
+    gcpro3.next = &gcpro2; gcpro3.var = &(c); gcpro3.nvars = 1;         \
+    gcpro3.name = __FILE__; gcpro3.lineno = __LINE__; gcpro3.idx = 3;   \
+    gcpro4.next = &gcpro3; gcpro4.var = &(d); gcpro4.nvars = 1;         \
+    gcpro4.name = __FILE__; gcpro4.lineno = __LINE__; gcpro4.idx = 4;   \
+    gcpro5.next = &gcpro4; gcpro5.var = &(e); gcpro5.nvars = 1;         \
+    gcpro5.name = __FILE__; gcpro5.lineno = __LINE__; gcpro5.idx = 5;   \
+    gcpro6.next = &gcpro5; gcpro6.var = &(f); gcpro6.nvars = 1;         \
+    gcpro6.name = __FILE__; gcpro6.lineno = __LINE__; gcpro6.idx = 6;   \
+    gcpro7.next = &gcpro6; gcpro7.var = &(g); gcpro7.nvars = 1;         \
+    gcpro7.name = __FILE__; gcpro7.lineno = __LINE__; gcpro7.idx = 7;   \
+    gcpro7.level = gcpro_level++;                                       \
+    gcprolist = &gcpro7; }
 
 #define UNGCPRO                                 \
   (--gcpro_level != gcpro1.level                \
@@ -3620,6 +3633,10 @@ extern void syms_of_xsettings (void);
 /* Defined in vm-limit.c.  */
 extern void memory_warnings (void *, void (*warnfun) (const char *));
 
+/* Defined in character.c.  */
+extern void parse_str_as_multibyte (const unsigned char *, ptrdiff_t,
+                                    ptrdiff_t *, ptrdiff_t *);
+
 /* Defined in alloc.c.  */
 extern void check_pure_size (void);
 extern void free_misc (Lisp_Object);
@@ -3629,7 +3646,7 @@ extern _Noreturn void memory_full (size_t);
 extern _Noreturn void buffer_memory_full (ptrdiff_t);
 extern bool survives_gc_p (Lisp_Object);
 extern void mark_object (Lisp_Object);
-#if defined REL_ALLOC && !defined SYSTEM_MALLOC
+#if defined REL_ALLOC && !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
 extern void refill_memory_reserve (void);
 #endif
 extern const char *pending_malloc_warning;
@@ -3852,6 +3869,7 @@ extern Lisp_Object Qlexical_binding;
 extern Lisp_Object check_obarray (Lisp_Object);
 extern Lisp_Object intern_1 (const char *, ptrdiff_t);
 extern Lisp_Object intern_c_string_1 (const char *, ptrdiff_t);
+extern Lisp_Object intern_driver (Lisp_Object, Lisp_Object, ptrdiff_t);
 extern Lisp_Object oblookup (Lisp_Object, const char *, ptrdiff_t, ptrdiff_t);
 INLINE void
 LOADHIST_ATTACH (Lisp_Object x)
@@ -3882,6 +3900,7 @@ intern_c_string (const char *str)
 }
 
 /* Defined in eval.c.  */
+extern EMACS_INT lisp_eval_depth;
 extern Lisp_Object Qexit, Qinteractive, Qcommandp, Qmacro;
 extern Lisp_Object Qinhibit_quit, Qinternal_interpreter_environment, Qclosure;
 extern Lisp_Object Qand_rest;
@@ -3949,8 +3968,7 @@ extern Lisp_Object safe_call2 (Lisp_Object, Lisp_Object, Lisp_Object);
 extern void init_eval (void);
 extern void syms_of_eval (void);
 extern void unwind_body (Lisp_Object);
-extern void record_in_backtrace (Lisp_Object function,
-                                 Lisp_Object *args, ptrdiff_t nargs);
+extern ptrdiff_t record_in_backtrace (Lisp_Object, Lisp_Object *, ptrdiff_t);
 extern void mark_specpdl (void);
 extern void get_backtrace (Lisp_Object array);
 Lisp_Object backtrace_top_function (void);
@@ -3972,7 +3990,6 @@ extern Lisp_Object make_buffer_string_both (ptrdiff_t, ptrdiff_t, ptrdiff_t,
                                             ptrdiff_t, bool);
 extern void init_editfns (void);
 extern void syms_of_editfns (void);
-extern void set_time_zone_rule (const char *);
 
 /* Defined in buffer.c.  */
 extern bool mouse_face_overlay_overlaps (Lisp_Object);
@@ -4025,7 +4042,7 @@ extern _Noreturn void report_file_error (const char *, Lisp_Object);
 extern bool internal_delete_file (Lisp_Object);
 extern Lisp_Object emacs_readlinkat (int, const char *);
 extern bool file_directory_p (const char *);
-extern bool file_accessible_directory_p (const char *);
+extern bool file_accessible_directory_p (Lisp_Object);
 extern void init_fileio (void);
 extern void syms_of_fileio (void);
 extern Lisp_Object make_temp_name (Lisp_Object, bool);
@@ -4093,6 +4110,9 @@ extern Lisp_Object Qdisabled, QCfilter;
 extern Lisp_Object Qup, Qdown;
 extern Lisp_Object last_undo_boundary;
 extern bool input_pending;
+#ifdef HAVE_STACK_OVERFLOW_HANDLING
+extern sigjmp_buf return_to_command_loop;
+#endif
 extern Lisp_Object menu_bar_items (Lisp_Object);
 extern Lisp_Object tool_bar_items (Lisp_Object, int *);
 extern void discard_mouse_events (void);
@@ -4295,6 +4315,7 @@ extern void lock_file (Lisp_Object);
 extern void unlock_file (Lisp_Object);
 extern void unlock_buffer (struct buffer *);
 extern void syms_of_filelock (void);
+extern int str_collate (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
 
 /* Defined in sound.c.  */
 extern void syms_of_sound (void);
@@ -4376,6 +4397,7 @@ extern void syms_of_xsmfns (void);
 extern void syms_of_xselect (void);
 
 /* Defined in xterm.c.  */
+extern void init_xterm (void);
 extern void syms_of_xterm (void);
 #endif /* HAVE_X_WINDOWS */
 
@@ -4397,6 +4419,7 @@ extern void syms_of_decompress (void);
 
 #ifdef HAVE_DBUS
 /* Defined in dbusbind.c.  */
+void init_dbusbind (void);
 void syms_of_dbusbind (void);
 #endif
 
@@ -4412,6 +4435,11 @@ extern void syms_of_profiler (void);
 extern char *emacs_root_dir (void);
 #endif /* DOS_NT */
 
+/* Defined in lastfile.c.  */
+extern char my_edata[];
+extern char my_endbss[];
+extern char *my_endbss_static;
+
 /* True means ^G can quit instantly.  */
 extern bool immediate_quit;
 
@@ -4427,15 +4455,28 @@ extern void *xpalloc (void *, ptrdiff_t *, ptrdiff_t, ptrdiff_t, ptrdiff_t);
 extern char *xstrdup (const char *) ATTRIBUTE_MALLOC;
 extern char *xlispstrdup (Lisp_Object) ATTRIBUTE_MALLOC;
 extern void dupstring (char **, char const *);
-extern void xputenv (const char *);
 
-extern char *egetenv (const char *);
+/* Make DEST a copy of STRING's data.  Return a pointer to DEST's terminating
+   null byte.  This is like stpcpy, except the source is a Lisp string.  */
+
+INLINE char *
+lispstpcpy (char *dest, Lisp_Object string)
+{
+  ptrdiff_t len = SBYTES (string);
+  memcpy (dest, SDATA (string), len + 1);
+  return dest + len;
+}
+
+extern void xputenv (const char *);
 
-/* Copy Lisp string to temporary (allocated on stack) C string.  */
+extern char *egetenv_internal (const char *, ptrdiff_t);
 
-#define xlispstrdupa(string)                    \
-  memcpy (alloca (SBYTES (string) + 1),         \
-          SSDATA (string), SBYTES (string) + 1)
+INLINE char *
+egetenv (const char *var)
+{
+  /* When VAR is a string literal, strlen can be optimized away.  */
+  return egetenv_internal (var, strlen (var));
+}
 
 /* Set up the name of the machine we're running on.  */
 extern void init_system_name (void);
@@ -4460,12 +4501,15 @@ enum MAX_ALLOCA { MAX_ALLOCA = 16 * 1024 };
 extern void *record_xmalloc (size_t) ATTRIBUTE_ALLOC_SIZE ((1));
 
 #define USE_SAFE_ALLOCA                 \
+  ptrdiff_t sa_avail = MAX_ALLOCA;      \
   ptrdiff_t sa_count = SPECPDL_INDEX (); bool sa_must_free = false
 
+#define AVAIL_ALLOCA(size) (sa_avail -= (size), alloca (size))
+
 /* SAFE_ALLOCA allocates a simple buffer.  */
 
-#define SAFE_ALLOCA(size) ((size) < MAX_ALLOCA  \
-                           ? alloca (size)      \
+#define SAFE_ALLOCA(size) ((size) <= sa_avail                           \
+                           ? AVAIL_ALLOCA (size)                        \
                            : (sa_must_free = true, record_xmalloc (size)))
 
 /* SAFE_NALLOCA sets BUF to a newly allocated array of MULTIPLIER *
@@ -4474,8 +4518,8 @@ extern void *record_xmalloc (size_t) ATTRIBUTE_ALLOC_SIZE ((1));
 
 #define SAFE_NALLOCA(buf, multiplier, nitems)                    \
   do {                                                           \
-    if ((nitems) <= MAX_ALLOCA / sizeof *(buf) / (multiplier))   \
-      (buf) = alloca (sizeof *(buf) * (multiplier) * (nitems));  \
+    if ((nitems) <= sa_avail / sizeof *(buf) / (multiplier))     \
+      (buf) = AVAIL_ALLOCA (sizeof *(buf) * (multiplier) * (nitems)); \
     else                                                         \
       {                                                          \
         (buf) = xnmalloc (nitems, sizeof *(buf) * (multiplier)); \
@@ -4484,6 +4528,14 @@ extern void *record_xmalloc (size_t) ATTRIBUTE_ALLOC_SIZE ((1));
       }                                                          \
   } while (false)
 
+/* SAFE_ALLOCA_STRING allocates a C copy of a Lisp string.  */
+
+#define SAFE_ALLOCA_STRING(ptr, string)                 \
+  do {                                                  \
+    (ptr) = SAFE_ALLOCA (SBYTES (string) + 1);          \
+    memcpy (ptr, SDATA (string), SBYTES (string) + 1);  \
+  } while (false)
+
 /* SAFE_FREE frees xmalloced memory and enables GC as needed.  */
 
 #define SAFE_FREE()                     \
@@ -4495,13 +4547,29 @@ extern void *record_xmalloc (size_t) ATTRIBUTE_ALLOC_SIZE ((1));
   } while (false)
 
 
+/* Return floor (NBYTES / WORD_SIZE).  */
+
+INLINE ptrdiff_t
+lisp_word_count (ptrdiff_t nbytes)
+{
+  if (-1 >> 1 == -1)
+    switch (word_size)
+      {
+      case 2: return nbytes >> 1;
+      case 4: return nbytes >> 2;
+      case 8: return nbytes >> 3;
+      case 16: return nbytes >> 4;
+      }
+  return nbytes / word_size - (nbytes % word_size < 0);
+}
+
 /* SAFE_ALLOCA_LISP allocates an array of Lisp_Objects.  */
 
 #define SAFE_ALLOCA_LISP(buf, nelt)                            \
   do {                                                         \
-    if ((nelt) < MAX_ALLOCA / word_size)                       \
-      (buf) = alloca ((nelt) * word_size);                     \
-    else if ((nelt) < min (PTRDIFF_MAX, SIZE_MAX) / word_size) \
+    if ((nelt) <= lisp_word_count (sa_avail))                  \
+      (buf) = AVAIL_ALLOCA ((nelt) * word_size);               \
+    else if ((nelt) <= min (PTRDIFF_MAX, SIZE_MAX) / word_size) \
       {                                                        \
         Lisp_Object arg_;                                      \
         (buf) = xmalloc ((nelt) * word_size);                  \
@@ -4513,6 +4581,107 @@ extern void *record_xmalloc (size_t) ATTRIBUTE_ALLOC_SIZE ((1));
       memory_full (SIZE_MAX);                                  \
   } while (false)
 
+
+/* If USE_STACK_LISP_OBJECTS, define macros that and functions that allocate
+   block-scoped conses and strings.  These objects are not
+   managed by the garbage collector, so they are dangerous: passing them
+   out of their scope (e.g., to user code) results in undefined behavior.
+   Conversely, they have better performance because GC is not involved.
+
+   This feature is experimental and requires careful debugging.
+   Build with CPPFLAGS='-DUSE_STACK_LISP_OBJECTS=0' to disable it.  */
+
+#ifndef USE_STACK_LISP_OBJECTS
+# define USE_STACK_LISP_OBJECTS true
+#endif
+
+/* USE_STACK_LISP_OBJECTS requires GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS.  */
+
+#if GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS
+# undef USE_STACK_LISP_OBJECTS
+# define USE_STACK_LISP_OBJECTS false
+#endif
+
+/* Struct inside unions that are typically no larger and aligned enough.  */
+
+union Aligned_Cons
+{
+  struct Lisp_Cons s;
+  double d; intmax_t i; void *p;
+};
+
+union Aligned_String
+{
+  struct Lisp_String s;
+  double d; intmax_t i; void *p;
+};
+
+/* True for stack-based cons and string implementations, respectively.
+   Use stack-based strings only if stack-based cons also works.
+   Otherwise, STACK_CONS would create heap-based cons cells that
+   could point to stack-based strings, which is a no-no.  */
+
+enum
+  {
+    USE_STACK_CONS = (USE_STACK_LISP_OBJECTS
+                      && alignof (union Aligned_Cons) % GCALIGNMENT == 0),
+    USE_STACK_STRING = (USE_STACK_CONS
+                        && alignof (union Aligned_String) % GCALIGNMENT == 0)
+  };
+
+/* Auxiliary macros used for auto allocation of Lisp objects.  Please
+   use these only in macros like AUTO_CONS that declare a local
+   variable whose lifetime will be clear to the programmer.  */
+#define STACK_CONS(a, b) \
+  make_lisp_ptr (&(union Aligned_Cons) { { a, { b } } }.s, Lisp_Cons)
+#define AUTO_CONS_EXPR(a, b) \
+  (USE_STACK_CONS ? STACK_CONS (a, b) : Fcons (a, b))
+
+/* Declare NAME as an auto Lisp cons or short list if possible, a
+   GC-based one otherwise.  This is in the sense of the C keyword
+   'auto'; i.e., the object has the lifetime of the containing block.
+   The resulting object should not be made visible to user Lisp code.  */
+
+#define AUTO_CONS(name, a, b) Lisp_Object name = AUTO_CONS_EXPR (a, b)
+#define AUTO_LIST1(name, a)                                             \
+  Lisp_Object name = (USE_STACK_CONS ? STACK_CONS (a, Qnil) : list1 (a))
+#define AUTO_LIST2(name, a, b)                                          \
+  Lisp_Object name = (USE_STACK_CONS                                    \
+                      ? STACK_CONS (a, STACK_CONS (b, Qnil))            \
+                      : list2 (a, b))
+#define AUTO_LIST3(name, a, b, c)                                       \
+  Lisp_Object name = (USE_STACK_CONS                                    \
+                      ? STACK_CONS (a, STACK_CONS (b, STACK_CONS (c, Qnil))) \
+                      : list3 (a, b, c))
+#define AUTO_LIST4(name, a, b, c, d)                                    \
+    Lisp_Object name                                                    \
+      = (USE_STACK_CONS                                                 \
+         ? STACK_CONS (a, STACK_CONS (b, STACK_CONS (c,                 \
+                                                     STACK_CONS (d, Qnil)))) \
+         : list4 (a, b, c, d))
+
+/* Check whether stack-allocated strings are ASCII-only.  */
+
+#if defined (ENABLE_CHECKING) && USE_STACK_LISP_OBJECTS
+extern const char *verify_ascii (const char *);
+#else
+# define verify_ascii(str) (str)
+#endif
+
+/* Declare NAME as an auto Lisp string if possible, a GC-based one if not.
+   Take its value from STR.  STR is not necessarily copied and should
+   contain only ASCII characters.  The resulting Lisp string should
+   not be modified or made visible to user code.  */
+
+#define AUTO_STRING(name, str)                                          \
+  Lisp_Object name =                                                    \
+    (USE_STACK_STRING                                                   \
+     ? (make_lisp_ptr                                                   \
+        ((&(union Aligned_String)                                       \
+          {{strlen (str), -1, 0, (unsigned char *) verify_ascii (str)}}.s), \
+          Lisp_String))                                                 \
+     : build_string (verify_ascii (str)))
+
 /* Loop over all tails of a list, checking for cycles.
    FIXME: Make tortoise and n internal declarations.
    FIXME: Unroll the loop body so we don't need `n'.  */
diff --git a/src/lisp.mk b/src/lisp.mk
index 59d5b86c33a..642e9af225f 100644
--- a/src/lisp.mk
+++ b/src/lisp.mk
@@ -132,6 +132,7 @@ lisp = \
         $(lispsource)/textmodes/paragraphs.elc \
         $(lispsource)/progmodes/prog-mode.elc \
         $(lispsource)/emacs-lisp/lisp-mode.elc \
+        $(lispsource)/progmodes/elisp-mode.elc \
         $(lispsource)/textmodes/text-mode.elc \
         $(lispsource)/textmodes/fill.elc \
         $(lispsource)/newcomment.elc \
@@ -152,7 +153,6 @@ lisp = \
         $(lispsource)/term/w32-win.elc \
         $(lispsource)/ls-lisp.elc \
         $(lispsource)/disp-table.elc \
-        $(lispsource)/w32-common-fns.elc \
         $(lispsource)/dos-w32.elc \
         $(lispsource)/w32-fns.elc \
         $(lispsource)/dos-fns.elc \
diff --git a/src/lread.c b/src/lread.c
index 639d574ac6b..171a51acb3f 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -970,10 +970,8 @@ load_warn_old_style_backquotes (Lisp_Object file)
 {
   if (!NILP (Vold_style_backquotes))
     {
-      Lisp_Object args[2];
-      args[0] = build_string ("Loading `%s': old-style backquotes detected!");
-      args[1] = file;
-      Fmessage (2, args);
+      AUTO_STRING (format, "Loading `%s': old-style backquotes detected!");
+      Fmessage (2, (Lisp_Object []) {format, file});
     }
 }
 
@@ -1473,6 +1471,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
   ptrdiff_t max_suffix_len = 0;
   int last_errno = ENOENT;
   int save_fd = -1;
+  USE_SAFE_ALLOCA;
 
   /* The last-modified time of the newest matching file found.
      Initialize it to something less than all valid timestamps.  */
@@ -1513,7 +1512,10 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
          this path element/specified file name and any possible suffix.  */
       want_length = max_suffix_len + SBYTES (filename);
       if (fn_size <= want_length)
-        fn = alloca (fn_size = 100 + want_length);
+        {
+          fn_size = 100 + want_length;
+          fn = SAFE_ALLOCA (fn_size);
+        }
 
       /* Loop over suffixes.  */
       for (tail = NILP (suffixes) ? list1 (empty_unibyte_string) : suffixes;
@@ -1579,6 +1581,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
                   /* We succeeded; return this descriptor and filename.  */
                   if (storeptr)
                     *storeptr = string;
+                  SAFE_FREE ();
                   UNGCPRO;
                   return -2;
                 }
@@ -1651,6 +1654,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
                       /* We succeeded; return this descriptor and filename.  */
                       if (storeptr)
                         *storeptr = string;
+                      SAFE_FREE ();
                       UNGCPRO;
                       return fd;
                     }
@@ -1661,6 +1665,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
                 {
                   if (storeptr)
                     *storeptr = save_string;
+                  SAFE_FREE ();
                   UNGCPRO;
                   return save_fd;
                 }
@@ -1670,6 +1675,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
         break;
     }
 
+  SAFE_FREE ();
   UNGCPRO;
   errno = last_errno;
   return -1;
@@ -1774,15 +1780,17 @@ readevalloop_eager_expand_eval (Lisp_Object val, Lisp_Object macroexpand)
   val = call2 (macroexpand, val, Qnil);
   if (EQ (CAR_SAFE (val), Qprogn))
     {
+      struct gcpro gcpro1;
       Lisp_Object subforms = XCDR (val);
-      val = Qnil;
-      for (; CONSP (subforms); subforms = XCDR (subforms))
+
+      GCPRO1 (subforms);
+      for (val = Qnil; CONSP (subforms); subforms = XCDR (subforms))
           val = readevalloop_eager_expand_eval (XCAR (subforms),
                                                 macroexpand);
+      UNGCPRO;
     }
   else
       val = eval_sub (call2 (macroexpand, val, Qt));
-
   return val;
 }
 
@@ -2088,9 +2096,10 @@ DEFUN ("read-from-string", Fread_from_string, Sread_from_string, 1, 3, 0,
        doc: /* Read one Lisp expression which is represented as text by STRING.
 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).
 FINAL-STRING-INDEX is an integer giving the position of the next
- remaining character in STRING.
-START and END optionally delimit a substring of STRING from which to read;
- they default to 0 and (length STRING) respectively.  */)
+remaining character in STRING.  START and END optionally delimit
+a substring of STRING from which to read;  they default to 0 and
+(length STRING) respectively.  Negative values are counted from
+the end of STRING.  */)
   (Lisp_Object string, Lisp_Object start, Lisp_Object end)
 {
   Lisp_Object ret;
@@ -2101,10 +2110,9 @@ START and END optionally delimit a substring of STRING from which to read;
 }
 
 /* Function to set up the global context we need in toplevel read
-   calls.  */
+   calls.  START and END only used when STREAM is a string.  */
 static Lisp_Object
 read_internal_start (Lisp_Object stream, Lisp_Object start, Lisp_Object end)
-/* `start', `end' only used when stream is a string.  */
 {
   Lisp_Object retval;
 
@@ -2126,25 +2134,9 @@ read_internal_start (Lisp_Object stream, Lisp_Object start, Lisp_Object end)
       else
         string = XCAR (stream);
 
-      if (NILP (end))
-        endval = SCHARS (string);
-      else
-        {
-          CHECK_NUMBER (end);
-          if (! (0 <= XINT (end) && XINT (end) <= SCHARS (string)))
-            args_out_of_range (string, end);
-          endval = XINT (end);
-        }
+      validate_subarray (string, start, end, SCHARS (string),
+                         &startval, &endval);
 
-      if (NILP (start))
-        startval = 0;
-      else
-        {
-          CHECK_NUMBER (start);
-          if (! (0 <= XINT (start) && XINT (start) <= endval))
-            args_out_of_range (string, start);
-          startval = XINT (start);
-        }
       read_from_string_index = startval;
       read_from_string_index_byte = string_char_to_byte (string, startval);
       read_from_string_limit = endval;
@@ -2881,11 +2873,8 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
                   if (c == '=')
                     {
                       /* Make a placeholder for #n# to use temporarily.  */
-                      Lisp_Object placeholder;
-                      Lisp_Object cell;
-
-                      placeholder = Fcons (Qnil, Qnil);
-                      cell = Fcons (make_number (n), placeholder);
+                      AUTO_CONS (placeholder, Qnil, Qnil);
+                      Lisp_Object cell = Fcons (make_number (n), placeholder);
                       read_objects = Fcons (cell, read_objects);
 
                       /* Read the object itself.  */
@@ -3364,7 +3353,7 @@ substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Obj
            substitute_in_interval contains part of the logic.  */
 
         INTERVAL root_interval = string_intervals (subtree);
-        Lisp_Object arg = Fcons (object, placeholder);
+        AUTO_CONS (arg, object, placeholder);
 
         traverse_intervals_noorder (root_interval,
                                     &substitute_in_interval, arg);
@@ -3671,8 +3660,10 @@ read_list (bool flag, Lisp_Object readcharfun)
                in the installed Lisp directory.
                We don't use Fexpand_file_name because that would make
                the directory absolute now.  */
-            elt = concat2 (build_string ("../lisp/"),
-                         Ffile_name_nondirectory (elt));
+            {
+              AUTO_STRING (dot_dot_lisp, "../lisp/");
+              elt = concat2 (dot_dot_lisp, Ffile_name_nondirectory (elt));
+            }
         }
       else if (EQ (elt, Vload_file_name)
                && ! NILP (elt)
@@ -3800,6 +3791,30 @@ check_obarray (Lisp_Object obarray)
   return obarray;
 }
 
+/* Intern a symbol with name STRING in OBARRAY using bucket INDEX.  */
+
+Lisp_Object
+intern_driver (Lisp_Object string, Lisp_Object obarray, ptrdiff_t index)
+{
+  Lisp_Object *ptr, sym = Fmake_symbol (string);
+
+  XSYMBOL (sym)->interned = (EQ (obarray, initial_obarray)
+                             ? SYMBOL_INTERNED_IN_INITIAL_OBARRAY
+                             : SYMBOL_INTERNED);
+
+  if ((SREF (string, 0) == ':') && EQ (obarray, initial_obarray))
+    {
+      XSYMBOL (sym)->constant = 1;
+      XSYMBOL (sym)->redirect = SYMBOL_PLAINVAL;
+      SET_SYMBOL_VAL (XSYMBOL (sym), sym);
+    }
+
+  ptr = aref_addr (obarray, index);
+  set_symbol_next (sym, SYMBOLP (*ptr) ? XSYMBOL (*ptr) : NULL);
+  *ptr = sym;
+  return sym;
+}
+
 /* Intern the C string STR: return a symbol with that name,
    interned in the current obarray.  */
 
@@ -3809,7 +3824,8 @@ intern_1 (const char *str, ptrdiff_t len)
   Lisp_Object obarray = check_obarray (Vobarray);
   Lisp_Object tem = oblookup (obarray, str, len, len);
 
-  return SYMBOLP (tem) ? tem : Fintern (make_string (str, len), obarray);
+  return SYMBOLP (tem) ? tem : intern_driver (make_string (str, len),
+                                              obarray, XINT (tem));
 }
 
 Lisp_Object
@@ -3818,16 +3834,14 @@ intern_c_string_1 (const char *str, ptrdiff_t len)
   Lisp_Object obarray = check_obarray (Vobarray);
   Lisp_Object tem = oblookup (obarray, str, len, len);
 
-  if (SYMBOLP (tem))
-    return tem;
-
-  if (NILP (Vpurify_flag))
-    /* Creating a non-pure string from a string literal not
-       implemented yet.  We could just use make_string here and live
-       with the extra copy.  */
-    emacs_abort ();
-
-  return Fintern (make_pure_c_string (str, len), obarray);
+  if (!SYMBOLP (tem))
+    {
+      /* Creating a non-pure string from a string literal not implemented yet.
+         We could just use make_string here and live with the extra copy.  */
+      eassert (!NILP (Vpurify_flag));
+      tem = intern_driver (make_pure_c_string (str, len), obarray, XINT (tem));
+    }
+  return tem;
 }
 
 DEFUN ("intern", Fintern, Sintern, 1, 2, 0,
@@ -3837,43 +3851,16 @@ A second optional argument specifies the obarray to use;
 it defaults to the value of `obarray'.  */)
   (Lisp_Object string, Lisp_Object obarray)
 {
-  register Lisp_Object tem, sym, *ptr;
-
-  if (NILP (obarray)) obarray = Vobarray;
-  obarray = check_obarray (obarray);
+  Lisp_Object tem;
 
+  obarray = check_obarray (NILP (obarray) ? Vobarray : obarray);
   CHECK_STRING (string);
 
-  tem = oblookup (obarray, SSDATA (string),
-                  SCHARS (string),
-                  SBYTES (string));
-  if (!INTEGERP (tem))
-    return tem;
-
-  if (!NILP (Vpurify_flag))
-    string = Fpurecopy (string);
-  sym = Fmake_symbol (string);
-
-  if (EQ (obarray, initial_obarray))
-    XSYMBOL (sym)->interned = SYMBOL_INTERNED_IN_INITIAL_OBARRAY;
-  else
-    XSYMBOL (sym)->interned = SYMBOL_INTERNED;
-
-  if ((SREF (string, 0) == ':')
-      && EQ (obarray, initial_obarray))
-    {
-      XSYMBOL (sym)->constant = 1;
-      XSYMBOL (sym)->redirect = SYMBOL_PLAINVAL;
-      SET_SYMBOL_VAL (XSYMBOL (sym), sym);
-    }
-
-  ptr = aref_addr (obarray, XINT (tem));
-  if (SYMBOLP (*ptr))
-    set_symbol_next (sym, XSYMBOL (*ptr));
-  else
-    set_symbol_next (sym, NULL);
-  *ptr = sym;
-  return sym;
+  tem = oblookup (obarray, SSDATA (string), SCHARS (string), SBYTES (string));
+  if (!SYMBOLP (tem))
+    tem = intern_driver (NILP (Vpurify_flag) ? string
+                         : Fpurecopy (string), obarray, XINT (tem));
+  return tem;
 }
 
 DEFUN ("intern-soft", Fintern_soft, Sintern_soft, 1, 2, 0,
@@ -4213,7 +4200,7 @@ load_path_check (Lisp_Object lpath)
       if (STRINGP (dirfile))
         {
           dirfile = Fdirectory_file_name (dirfile);
-          if (! file_accessible_directory_p (SSDATA (dirfile)))
+          if (! file_accessible_directory_p (dirfile))
             dir_warning ("Lisp directory", XCAR (path_tail));
         }
     }
diff --git a/src/macfont.h b/src/macfont.h
index 7421cd63a79..e6e45ab152c 100644
--- a/src/macfont.h
+++ b/src/macfont.h
@@ -57,11 +57,7 @@ typedef CTCharacterCollection CharacterCollection;
 #define MAC_FONT_CASCADE_LIST_ATTRIBUTE kCTFontCascadeListAttribute
 #define MAC_FONT_CHARACTER_SET_ATTRIBUTE kCTFontCharacterSetAttribute
 #define MAC_FONT_LANGUAGES_ATTRIBUTE kCTFontLanguagesAttribute
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
 #define MAC_FONT_FORMAT_ATTRIBUTE kCTFontFormatAttribute
-#else
-#define MAC_FONT_FORMAT_ATTRIBUTE (CFSTR ("NSCTFontFormatAttribute"))
-#endif
 #define MAC_FONT_SYMBOLIC_TRAIT kCTFontSymbolicTrait
 #define MAC_FONT_WEIGHT_TRAIT kCTFontWeightTrait
 #define MAC_FONT_WIDTH_TRAIT kCTFontWidthTrait
@@ -79,11 +75,7 @@ enum {
 };
 
 enum {
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
   MAC_FONT_FORMAT_BITMAP = kCTFontFormatBitmap
-#else
-  MAC_FONT_FORMAT_BITMAP = 5
-#endif
 };
 
 enum {
@@ -112,13 +104,8 @@ enum {
 #define mac_font_get_underline_position CTFontGetUnderlinePosition
 #define mac_font_get_underline_thickness CTFontGetUnderlineThickness
 #define mac_font_copy_graphics_font(font) CTFontCopyGraphicsFont (font, NULL)
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
 #define mac_font_copy_non_synthetic_table(font, table) \
   CTFontCopyTable (font, table, kCTFontTableOptionNoOptions)
-#else
-#define mac_font_copy_non_synthetic_table(font, table) \
-  CTFontCopyTable (font, table, kCTFontTableOptionExcludeSynthetic)
-#endif
 
 #define mac_font_create_preferred_family_for_attributes \
   mac_ctfont_create_preferred_family_for_attributes
diff --git a/src/macfont.m b/src/macfont.m
index 0d702873220..366d087f8c2 100644
--- a/src/macfont.m
+++ b/src/macfont.m
@@ -36,13 +36,11 @@ Original author: YAMAMOTO Mitsuharu
 #include "macfont.h"
 #include "macuvs.h"
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
-
 #include <libkern/OSByteOrder.h>
 
 static struct font_driver macfont_driver;
 
-/* Core Text, for Mac OS X 10.5 and later.  */
+/* Core Text, for Mac OS X.  */
 static Lisp_Object Qmac_ct;
 
 static double mac_ctfont_get_advance_width_for_glyph (CTFontRef, CGGlyph);
@@ -50,25 +48,25 @@ static CGRect mac_ctfont_get_bounding_rect_for_glyph (CTFontRef, CGGlyph);
 static CFArrayRef mac_ctfont_create_available_families (void);
 static Boolean mac_ctfont_equal_in_postscript_name (CTFontRef, CTFontRef);
 static CTLineRef mac_ctfont_create_line_with_string_and_font (CFStringRef,
-                                                              CTFontRef);
+                                                              CTFontRef);
 static CFComparisonResult mac_font_family_compare (const void *,
-                                                   const void *, void *);
+                                                   const void *, void *);
 static Boolean mac_ctfont_descriptor_supports_languages (CTFontDescriptorRef,
-                                                         CFArrayRef);
+                                                         CFArrayRef);
 static CFStringRef mac_ctfont_create_preferred_family_for_attributes (CFDictionaryRef);
 static CFIndex mac_ctfont_shape (CTFontRef, CFStringRef,
-                                 struct mac_glyph_layout *, CFIndex);
+                                 struct mac_glyph_layout *, CFIndex);
 static CFArrayRef
 mac_font_copy_default_descriptors_for_language (CFStringRef language);
 
 static CFStringRef
 mac_font_copy_default_name_for_charset_and_languages (CFCharacterSetRef charset,
-                                                      CFArrayRef languages);
+                                                      CFArrayRef languages);
 
 #if USE_CT_GLYPH_INFO
 static CGGlyph mac_ctfont_get_glyph_for_cid (CTFontRef,
-                                             CTCharacterCollection,
-                                             CGFontIndex);
+                                             CTCharacterCollection,
+                                             CGFontIndex);
 #endif
 
 /* The font property key specifying the font design destination.  The
@@ -129,26 +127,26 @@ static const CGAffineTransform synthetic_italic_atfm = {1, 0, 0.25, 1, 0, 0};
 static const CGFloat synthetic_bold_factor = 0.024;
 
 static Boolean cfnumber_get_font_symbolic_traits_value (CFNumberRef,
-                                                        FontSymbolicTraits *);
+                                                        FontSymbolicTraits *);
 static void macfont_store_descriptor_attributes (FontDescriptorRef,
-                                                 Lisp_Object);
+                                                 Lisp_Object);
 static Lisp_Object macfont_descriptor_entity (FontDescriptorRef,
-                                              Lisp_Object,
-                                              FontSymbolicTraits);
+                                              Lisp_Object,
+                                              FontSymbolicTraits);
 static CFStringRef macfont_create_family_with_symbol (Lisp_Object);
 static int macfont_glyph_extents (struct font *, CGGlyph,
-                                  struct font_metrics *, CGFloat *, int);
+                                  struct font_metrics *, CGFloat *, int);
 static CFMutableDictionaryRef macfont_create_attributes_with_spec (Lisp_Object);
 static Boolean macfont_supports_charset_and_languages_p (FontDescriptorRef,
-                                                         CFCharacterSetRef,
-                                                         Lisp_Object,
-                                                         CFArrayRef);
-static CFIndex macfont_closest_traits_index (CFArrayRef,
-                                             FontSymbolicTraits);
+                                                         CFCharacterSetRef,
+                                                         Lisp_Object,
+                                                         CFArrayRef);
+static Boolean macfont_closest_traits_index_p (CFArrayRef, FontSymbolicTraits,
+                                               CFIndex);
 static CFDataRef mac_font_copy_uvs_table (FontRef);
 static void mac_font_get_glyphs_for_variants (CFDataRef, UTF32Char,
-                                              const UTF32Char [],
-                                              CGGlyph [], CFIndex);
+                                              const UTF32Char [],
+                                              CGGlyph [], CFIndex);
 
 /* From CFData to a lisp string.  Always returns a unibyte string.  */
 
@@ -180,15 +178,15 @@ cfstring_to_lisp_nodecode (CFStringRef string)
       CFIndex i, length = CFStringGetLength (string);
 
       for (i = 0; i < length; i++)
-        if (CFStringGetCharacterAtIndex (string, i) == 0)
-          break;
+        if (CFStringGetCharacterAtIndex (string, i) == 0)
+          break;
 
       if (i == length)
-        return make_unibyte_string (s, strlen (s));
+        return make_unibyte_string (s, strlen (s));
     }
 
   data = CFStringCreateExternalRepresentation (NULL, string,
-                                               kCFStringEncodingUTF8, '?');
+                                               kCFStringEncodingUTF8, '?');
   if (data)
     {
       result = cfdata_to_lisp (data);
@@ -206,12 +204,12 @@ static CFStringRef
 cfstring_create_with_string_noencode (Lisp_Object s)
 {
   CFStringRef string = CFStringCreateWithBytes (NULL, SDATA (s), SBYTES (s),
-                                                kCFStringEncodingUTF8, false);
+                                                kCFStringEncodingUTF8, false);
 
   if (string == NULL)
     /* Failed to interpret as UTF 8.  Fall back on Mac Roman.  */
     string = CFStringCreateWithBytes (NULL, SDATA (s), SBYTES (s),
-                                      kCFStringEncodingMacRoman, false);
+                                      kCFStringEncodingMacRoman, false);
 
   return string;
 }
@@ -226,7 +224,7 @@ mac_screen_font_get_advance_width_for_glyph (ScreenFontRef font, CGGlyph glyph)
 
 static CGGlyph
 mac_font_get_glyph_for_cid (FontRef font, CharacterCollection collection,
-                            CGFontIndex cid)
+                            CGFontIndex cid)
 {
 #if USE_CT_GLYPH_INFO
   return mac_ctfont_get_glyph_for_cid ((CTFontRef) font, collection, cid);
@@ -237,17 +235,17 @@ mac_font_get_glyph_for_cid (FontRef font, CharacterCollection collection,
     unichar characters[] = {0xfffd};
     NSString *string =
       [NSString stringWithCharacters:characters
-                              length:ARRAYELTS (characters)];
+                              length:ARRAYELTS (characters)];
     NSGlyphInfo *glyphInfo =
       [NSGlyphInfo glyphInfoWithCharacterIdentifier:cid
-                                         collection:collection
-                                         baseString:string];
+                                         collection:collection
+                                         baseString:string];
     NSDictionary *attributes =
       [NSDictionary dictionaryWithObjectsAndKeys:nsFont,NSFontAttributeName,
-                    glyphInfo,NSGlyphInfoAttributeName,nil];
+                    glyphInfo,NSGlyphInfoAttributeName,nil];
     NSTextStorage *textStorage =
       [[NSTextStorage alloc] initWithString:string
-                                 attributes:attributes];
+                                 attributes:attributes];
     NSLayoutManager *layoutManager = [[NSLayoutManager alloc] init];
     NSTextContainer *textContainer = [[NSTextContainer alloc] init];
     NSFont *fontInTextStorage;
@@ -261,14 +259,14 @@ mac_font_get_glyph_for_cid (FontRef font, CharacterCollection collection,
     (void) [layoutManager glyphRangeForTextContainer:textContainer];
 
     fontInTextStorage = [textStorage attribute:NSFontAttributeName atIndex:0
-                                effectiveRange:NULL];
+                                effectiveRange:NULL];
     if (fontInTextStorage == nsFont
-        || [[fontInTextStorage fontName] isEqualToString:[nsFont fontName]])
+        || [[fontInTextStorage fontName] isEqualToString:[nsFont fontName]])
       {
-        NSGlyph glyph = [layoutManager glyphAtIndex:0];
+        NSGlyph glyph = [layoutManager glyphAtIndex:0];
 
-        if (glyph < [nsFont numberOfGlyphs])
-          result = glyph;
+        if (glyph < [nsFont numberOfGlyphs])
+          result = glyph;
       }
 
     [textStorage release];
@@ -292,7 +290,7 @@ mac_screen_font_create_with_name (CFStringRef name, CGFloat size)
 
 static Boolean
 mac_screen_font_get_metrics (ScreenFontRef font, CGFloat *ascent,
-                             CGFloat *descent, CGFloat *leading)
+                             CGFloat *descent, CGFloat *leading)
 {
   NSFont *nsFont = [(NSFont *)font printerFont];
   NSTextStorage *textStorage;
@@ -323,7 +321,7 @@ mac_screen_font_get_metrics (ScreenFontRef font, CGFloat *ascent,
     }
 
   usedRect = [layoutManager lineFragmentUsedRectForGlyphAtIndex:0
-                                                 effectiveRange:NULL];
+                                                 effectiveRange:NULL];
   spaceLocation = [layoutManager locationForGlyphAtIndex:0];
   [textStorage release];
 
@@ -342,8 +340,8 @@ mac_screen_font_get_metrics (ScreenFontRef font, CGFloat *ascent,
 
 static CFIndex
 mac_font_shape_1 (NSFont *font, NSString *string,
-                  struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len,
-                  BOOL screen_font_p)
+                  struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len,
+                  BOOL screen_font_p)
 {
   NSUInteger i;
   CFIndex result = 0;
@@ -360,7 +358,7 @@ mac_font_shape_1 (NSFont *font, NSString *string,
 
   /* Append a trailing space to measure baseline position.  */
   [textStorage appendAttributedString:([[[NSAttributedString alloc]
-                                          initWithString:@" "] autorelease])];
+                                          initWithString:@" "] autorelease])];
   [textStorage setFont:font];
   [textContainer setLineFragmentPadding:0];
   [layoutManager setUsesScreenFonts:screen_font_p];
@@ -396,13 +394,13 @@ mac_font_shape_1 (NSFont *font, NSString *string,
     {
       NSRange range;
       NSFont *fontInTextStorage =
-        [textStorage attribute:NSFontAttributeName atIndex:i
-                     longestEffectiveRange:&range
-                       inRange:(NSMakeRange (0, stringLength))];
+        [textStorage attribute:NSFontAttributeName atIndex:i
+                     longestEffectiveRange:&range
+                       inRange:(NSMakeRange (0, stringLength))];
 
       if (!(fontInTextStorage == font
-            || [[fontInTextStorage fontName] isEqualToString:[font fontName]]))
-        break;
+            || [[fontInTextStorage fontName] isEqualToString:[font fontName]]))
+        break;
       i = NSMaxRange (range);
     }
   if (i < stringLength)
@@ -414,12 +412,12 @@ mac_font_shape_1 (NSFont *font, NSString *string,
       NSRange range = NSMakeRange (0, stringLength);
 
       range = [layoutManager glyphRangeForCharacterRange:range
-                                    actualCharacterRange:NULL];
+                                    actualCharacterRange:NULL];
       numberOfGlyphs = NSMaxRange (range);
       used = numberOfGlyphs;
       for (i = 0; i < numberOfGlyphs; i++)
-        if ([layoutManager notShownAttributeForGlyphAtIndex:i])
-          used--;
+        if ([layoutManager notShownAttributeForGlyphAtIndex:i])
+          used--;
     }
 
   if (0 < used && used <= glyph_len)
@@ -432,186 +430,186 @@ mac_font_shape_1 (NSFont *font, NSString *string,
 
       glyphIndex = 0;
       while ([layoutManager notShownAttributeForGlyphAtIndex:glyphIndex])
-        glyphIndex++;
+        glyphIndex++;
 
       /* For now we assume the direction is not changed within the
-         string.  */
+         string.  */
       [layoutManager getGlyphsInRange:(NSMakeRange (glyphIndex, 1))
-                               glyphs:NULL characterIndexes:NULL
-                    glyphInscriptions:NULL elasticBits:NULL
-                           bidiLevels:&bidiLevel];
+                               glyphs:NULL characterIndexes:NULL
+                    glyphInscriptions:NULL elasticBits:NULL
+                           bidiLevels:&bidiLevel];
       if (bidiLevel & 1)
-        permutation = xmalloc (sizeof (NSUInteger) * used);
+        permutation = xmalloc (sizeof (NSUInteger) * used);
       else
-        permutation = NULL;
+        permutation = NULL;
 
 #define RIGHT_TO_LEFT_P permutation
 
       /* Fill the `comp_range' member of struct mac_glyph_layout, and
-         setup a permutation for right-to-left text.  */
+         setup a permutation for right-to-left text.  */
       compRange = NSMakeRange (0, 0);
       for (range = NSMakeRange (0, 0); NSMaxRange (range) < used;
-           range.length++)
-        {
-          struct mac_glyph_layout *gl = glyph_layouts + NSMaxRange (range);
-          NSUInteger characterIndex =
-            [layoutManager characterIndexForGlyphAtIndex:glyphIndex];
-
-          gl->string_index = characterIndex;
-
-          if (characterIndex >= NSMaxRange (compRange))
-            {
-              compRange.location = NSMaxRange (compRange);
-              do
-                {
-                  NSRange characterRange =
-                    [string
-                      rangeOfComposedCharacterSequenceAtIndex:characterIndex];
-
-                  compRange.length =
-                    NSMaxRange (characterRange) - compRange.location;
-                  [layoutManager glyphRangeForCharacterRange:compRange
-                                        actualCharacterRange:&characterRange];
-                  characterIndex = NSMaxRange (characterRange) - 1;
-                }
-              while (characterIndex >= NSMaxRange (compRange));
-
-              if (RIGHT_TO_LEFT_P)
-                for (i = 0; i < range.length; i++)
-                  permutation[range.location + i] = NSMaxRange (range) - i - 1;
-
-              range = NSMakeRange (NSMaxRange (range), 0);
-            }
-
-          gl->comp_range.location = compRange.location;
-          gl->comp_range.length = compRange.length;
-
-          while (++glyphIndex < numberOfGlyphs)
-            if (![layoutManager notShownAttributeForGlyphAtIndex:glyphIndex])
-              break;
-        }
+           range.length++)
+        {
+          struct mac_glyph_layout *gl = glyph_layouts + NSMaxRange (range);
+          NSUInteger characterIndex =
+            [layoutManager characterIndexForGlyphAtIndex:glyphIndex];
+
+          gl->string_index = characterIndex;
+
+          if (characterIndex >= NSMaxRange (compRange))
+            {
+              compRange.location = NSMaxRange (compRange);
+              do
+                {
+                  NSRange characterRange =
+                    [string
+                      rangeOfComposedCharacterSequenceAtIndex:characterIndex];
+
+                  compRange.length =
+                    NSMaxRange (characterRange) - compRange.location;
+                  [layoutManager glyphRangeForCharacterRange:compRange
+                                        actualCharacterRange:&characterRange];
+                  characterIndex = NSMaxRange (characterRange) - 1;
+                }
+              while (characterIndex >= NSMaxRange (compRange));
+
+              if (RIGHT_TO_LEFT_P)
+                for (i = 0; i < range.length; i++)
+                  permutation[range.location + i] = NSMaxRange (range) - i - 1;
+
+              range = NSMakeRange (NSMaxRange (range), 0);
+            }
+
+          gl->comp_range.location = compRange.location;
+          gl->comp_range.length = compRange.length;
+
+          while (++glyphIndex < numberOfGlyphs)
+            if (![layoutManager notShownAttributeForGlyphAtIndex:glyphIndex])
+              break;
+        }
       if (RIGHT_TO_LEFT_P)
-        for (i = 0; i < range.length; i++)
-          permutation[range.location + i] = NSMaxRange (range) - i - 1;
+        for (i = 0; i < range.length; i++)
+          permutation[range.location + i] = NSMaxRange (range) - i - 1;
 
       /* Then fill the remaining members.  */
       glyphIndex = prevGlyphIndex = 0;
       while ([layoutManager notShownAttributeForGlyphAtIndex:glyphIndex])
-        glyphIndex++;
+        glyphIndex++;
 
       if (!RIGHT_TO_LEFT_P)
-        totalAdvance = 0;
+        totalAdvance = 0;
       else
-        {
-          NSUInteger nrects;
-          NSRect *glyphRects =
-            [layoutManager
-              rectArrayForGlyphRange:(NSMakeRange (0, numberOfGlyphs))
-              withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0))
-                     inTextContainer:textContainer rectCount:&nrects];
-
-          totalAdvance = NSMaxX (glyphRects[0]);
-        }
+        {
+          NSUInteger nrects;
+          NSRect *glyphRects =
+            [layoutManager
+              rectArrayForGlyphRange:(NSMakeRange (0, numberOfGlyphs))
+              withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0))
+                     inTextContainer:textContainer rectCount:&nrects];
+
+          totalAdvance = NSMaxX (glyphRects[0]);
+        }
 
       for (i = 0; i < used; i++)
-        {
-          struct mac_glyph_layout *gl;
-          NSPoint location;
-          NSUInteger nextGlyphIndex;
-          NSRange glyphRange;
-          NSRect *glyphRects;
-          NSUInteger nrects;
-
-          if (!RIGHT_TO_LEFT_P)
-            gl = glyph_layouts + i;
-          else
-            {
-              NSUInteger dest = permutation[i];
-
-              gl = glyph_layouts + dest;
-              if (i < dest)
-                {
-                  CFIndex tmp = gl->string_index;
-
-                  gl->string_index = glyph_layouts[i].string_index;
-                  glyph_layouts[i].string_index = tmp;
-                }
-            }
-          gl->glyph_id = [layoutManager glyphAtIndex:glyphIndex];
-
-          location = [layoutManager locationForGlyphAtIndex:glyphIndex];
-          gl->baseline_delta = spaceLocation.y - location.y;
-
-          for (nextGlyphIndex = glyphIndex + 1; nextGlyphIndex < numberOfGlyphs;
-               nextGlyphIndex++)
-            if (![layoutManager
-                   notShownAttributeForGlyphAtIndex:nextGlyphIndex])
-              break;
-
-          if (!RIGHT_TO_LEFT_P)
-            {
-              CGFloat maxX;
-
-              if (prevGlyphIndex == 0)
-                glyphRange = NSMakeRange (0, nextGlyphIndex);
-              else
-                glyphRange = NSMakeRange (glyphIndex,
-                                          nextGlyphIndex - glyphIndex);
-              glyphRects =
-                [layoutManager
-                  rectArrayForGlyphRange:glyphRange
-                  withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0))
-                         inTextContainer:textContainer rectCount:&nrects];
-              maxX = max (NSMaxX (glyphRects[0]), totalAdvance);
-              gl->advance_delta = location.x - totalAdvance;
-              gl->advance = maxX - totalAdvance;
-              totalAdvance = maxX;
-            }
-          else
-            {
-              CGFloat minX;
-
-              if (nextGlyphIndex == numberOfGlyphs)
-                glyphRange = NSMakeRange (prevGlyphIndex,
-                                          numberOfGlyphs - prevGlyphIndex);
-              else
-                glyphRange = NSMakeRange (prevGlyphIndex,
-                                          glyphIndex + 1 - prevGlyphIndex);
-              glyphRects =
-                [layoutManager
-                  rectArrayForGlyphRange:glyphRange
-                  withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0))
-                         inTextContainer:textContainer rectCount:&nrects];
-              minX = min (NSMinX (glyphRects[0]), totalAdvance);
-              gl->advance = totalAdvance - minX;
-              totalAdvance = minX;
-              gl->advance_delta = location.x - totalAdvance;
-            }
-
-          prevGlyphIndex = glyphIndex + 1;
-          glyphIndex = nextGlyphIndex;
-        }
+        {
+          struct mac_glyph_layout *gl;
+          NSPoint location;
+          NSUInteger nextGlyphIndex;
+          NSRange glyphRange;
+          NSRect *glyphRects;
+          NSUInteger nrects;
+
+          if (!RIGHT_TO_LEFT_P)
+            gl = glyph_layouts + i;
+          else
+            {
+              NSUInteger dest = permutation[i];
+
+              gl = glyph_layouts + dest;
+              if (i < dest)
+                {
+                  CFIndex tmp = gl->string_index;
+
+                  gl->string_index = glyph_layouts[i].string_index;
+                  glyph_layouts[i].string_index = tmp;
+                }
+            }
+          gl->glyph_id = [layoutManager glyphAtIndex:glyphIndex];
+
+          location = [layoutManager locationForGlyphAtIndex:glyphIndex];
+          gl->baseline_delta = spaceLocation.y - location.y;
+
+          for (nextGlyphIndex = glyphIndex + 1; nextGlyphIndex < numberOfGlyphs;
+               nextGlyphIndex++)
+            if (![layoutManager
+                   notShownAttributeForGlyphAtIndex:nextGlyphIndex])
+              break;
+
+          if (!RIGHT_TO_LEFT_P)
+            {
+              CGFloat maxX;
+
+              if (prevGlyphIndex == 0)
+                glyphRange = NSMakeRange (0, nextGlyphIndex);
+              else
+                glyphRange = NSMakeRange (glyphIndex,
+                                          nextGlyphIndex - glyphIndex);
+              glyphRects =
+                [layoutManager
+                  rectArrayForGlyphRange:glyphRange
+                  withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0))
+                         inTextContainer:textContainer rectCount:&nrects];
+              maxX = max (NSMaxX (glyphRects[0]), totalAdvance);
+              gl->advance_delta = location.x - totalAdvance;
+              gl->advance = maxX - totalAdvance;
+              totalAdvance = maxX;
+            }
+          else
+            {
+              CGFloat minX;
+
+              if (nextGlyphIndex == numberOfGlyphs)
+                glyphRange = NSMakeRange (prevGlyphIndex,
+                                          numberOfGlyphs - prevGlyphIndex);
+              else
+                glyphRange = NSMakeRange (prevGlyphIndex,
+                                          glyphIndex + 1 - prevGlyphIndex);
+              glyphRects =
+                [layoutManager
+                  rectArrayForGlyphRange:glyphRange
+                  withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0))
+                         inTextContainer:textContainer rectCount:&nrects];
+              minX = min (NSMinX (glyphRects[0]), totalAdvance);
+              gl->advance = totalAdvance - minX;
+              totalAdvance = minX;
+              gl->advance_delta = location.x - totalAdvance;
+            }
+
+          prevGlyphIndex = glyphIndex + 1;
+          glyphIndex = nextGlyphIndex;
+        }
 
       if (RIGHT_TO_LEFT_P)
-        xfree (permutation);
+        xfree (permutation);
 
 #undef RIGHT_TO_LEFT_P
 
       result = used;
-   }
- [textStorage release];
+    }
+  [textStorage release];
 
   return result;
 }
 
 static CFIndex
 mac_screen_font_shape (ScreenFontRef font, CFStringRef string,
-                       struct mac_glyph_layout *glyph_layouts,
-                       CFIndex glyph_len)
+                       struct mac_glyph_layout *glyph_layouts,
+                       CFIndex glyph_len)
 {
   return mac_font_shape_1 ([(NSFont *)font printerFont],
-                           (NSString *) string,
-                           glyph_layouts, glyph_len, YES);
+                           (NSString *) string,
+                           glyph_layouts, glyph_len, YES);
 }
 
 static CGColorRef
@@ -649,6 +647,7 @@ get_cgcolor(unsigned long idx, struct frame *f)
     CGColorRelease (refcol_);                                           \
   } while (0)
 
+
 
 /* Mac font driver.  */
 
@@ -711,17 +710,17 @@ static const struct
   CFStringRef font_names[3];
 } macfont_language_default_font_names[] = {
   { CFSTR ("ja"), { CFSTR ("HiraKakuProN-W3"), /* 10.5 - 10.9 */
-                    CFSTR ("HiraKakuPro-W3"),  /* 10.4 */
-                    NULL }},
+                    CFSTR ("HiraKakuPro-W3"),  /* 10.4 */
+                    NULL }},
   { CFSTR ("ko"), { CFSTR ("AppleSDGothicNeo-Regular"), /* 10.8 - 10.9 */
-                    CFSTR ("AppleGothic"), /* 10.4 - 10.7 */
-                    NULL }},
+                    CFSTR ("AppleGothic"), /* 10.4 - 10.7 */
+                    NULL }},
   { CFSTR ("zh-Hans"), { CFSTR ("STHeitiSC-Light"), /* 10.6 - 10.9 */
-                         CFSTR ("STXihei"),         /* 10.4 - 10.5 */
-                         NULL }},
+                         CFSTR ("STXihei"),         /* 10.4 - 10.5 */
+                         NULL }},
   { CFSTR ("zh-Hant"), { CFSTR ("STHeitiTC-Light"), /* 10.6 - 10.9 */
-                         CFSTR ("LiHeiPro"),        /* 10.4 - 10.5 */
-                         NULL }},
+                         CFSTR ("LiHeiPro"),        /* 10.4 - 10.5 */
+                         NULL }},
   { NULL }
 };
 #endif
@@ -736,8 +735,8 @@ macfont_update_antialias_threshold (void)
 
   threshold =
     CFPreferencesGetAppIntegerValue (CFSTR ("AppleAntiAliasingThreshold"),
-                                     kCFPreferencesCurrentApplication,
-                                     &valid_p);
+                                     kCFPreferencesCurrentApplication,
+                                     &valid_p);
   if (valid_p)
     macfont_antialias_threshold = threshold;
 }
@@ -771,7 +770,7 @@ macfont_store_utf32char_to_unichars (UTF32Char c, UniChar *unichars)
 
 static Boolean
 cfnumber_get_font_symbolic_traits_value (CFNumberRef number,
-                                         FontSymbolicTraits *sym_traits)
+                                         FontSymbolicTraits *sym_traits)
 {
   SInt64 sint64_value;
 
@@ -789,7 +788,7 @@ cfnumber_get_font_symbolic_traits_value (CFNumberRef number,
 
 static void
 macfont_store_descriptor_attributes (FontDescriptorRef desc,
-                                     Lisp_Object spec_or_entity)
+                                     Lisp_Object spec_or_entity)
 {
   CFStringRef str;
   CFDictionaryRef dict;
@@ -797,66 +796,66 @@ macfont_store_descriptor_attributes (FontDescriptorRef desc,
   CGFloat floatval;
 
   str = mac_font_descriptor_copy_attribute (desc,
-                                            MAC_FONT_FAMILY_NAME_ATTRIBUTE);
+                                            MAC_FONT_FAMILY_NAME_ATTRIBUTE);
   if (str)
     {
       ASET (spec_or_entity, FONT_FAMILY_INDEX,
-            macfont_intern_prop_cfstring (str));
+            macfont_intern_prop_cfstring (str));
       CFRelease (str);
     }
   dict = mac_font_descriptor_copy_attribute (desc, MAC_FONT_TRAITS_ATTRIBUTE);
   if (dict)
     {
       struct {
-        enum font_property_index index;
-        CFStringRef trait;
-        CGPoint points[6];
+        enum font_property_index index;
+        CFStringRef trait;
+        CGPoint points[6];
       } numeric_traits[] =
-          {{FONT_WEIGHT_INDEX, MAC_FONT_WEIGHT_TRAIT,
-            {{-0.4, 50},        /* light */
-             {-0.24, 87.5},     /* (semi-light + normal) / 2 */
-             {0, 100},          /* normal */
-             {0.24, 140},       /* (semi-bold + normal) / 2 */
-             {0.4, 200},        /* bold */
-             {CGFLOAT_MAX, CGFLOAT_MAX}}},
-           {FONT_SLANT_INDEX, MAC_FONT_SLANT_TRAIT,
-            {{0, 100}, {0.1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}},
-           {FONT_WIDTH_INDEX, MAC_FONT_WIDTH_TRAIT,
-            {{0, 100}, {1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}}};
+          {{FONT_WEIGHT_INDEX, MAC_FONT_WEIGHT_TRAIT,
+            {{-0.4, 50},        /* light */
+             {-0.24, 87.5},     /* (semi-light + normal) / 2 */
+             {0, 100},          /* normal */
+             {0.24, 140},       /* (semi-bold + normal) / 2 */
+             {0.4, 200},        /* bold */
+             {CGFLOAT_MAX, CGFLOAT_MAX}}},
+           {FONT_SLANT_INDEX, MAC_FONT_SLANT_TRAIT,
+            {{0, 100}, {0.1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}},
+           {FONT_WIDTH_INDEX, MAC_FONT_WIDTH_TRAIT,
+            {{0, 100}, {1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}}};
       int i;
 
       for (i = 0; i < ARRAYELTS (numeric_traits); i++)
-        {
-          num = CFDictionaryGetValue (dict, numeric_traits[i].trait);
-          if (num && CFNumberGetValue (num, kCFNumberCGFloatType, &floatval))
-            {
-              CGPoint *point = numeric_traits[i].points;
-
-              while (point->x < floatval)
-                point++;
-              if (point == numeric_traits[i].points)
-                point++;
-              else if (point->x == CGFLOAT_MAX)
-                point--;
-              floatval = (point - 1)->y + ((floatval - (point - 1)->x)
-                                           * ((point->y - (point - 1)->y)
-                                              / (point->x - (point - 1)->x)));
-              FONT_SET_STYLE (spec_or_entity, numeric_traits[i].index,
-                              make_number (lround (floatval)));
-            }
-        }
+        {
+          num = CFDictionaryGetValue (dict, numeric_traits[i].trait);
+          if (num && CFNumberGetValue (num, kCFNumberCGFloatType, &floatval))
+            {
+              CGPoint *point = numeric_traits[i].points;
+
+              while (point->x < floatval)
+                point++;
+              if (point == numeric_traits[i].points)
+                point++;
+              else if (point->x == CGFLOAT_MAX)
+                point--;
+              floatval = (point - 1)->y + ((floatval - (point - 1)->x)
+                                           * ((point->y - (point - 1)->y)
+                                              / (point->x - (point - 1)->x)));
+              FONT_SET_STYLE (spec_or_entity, numeric_traits[i].index,
+                              make_number (lround (floatval)));
+            }
+        }
 
       num = CFDictionaryGetValue (dict, MAC_FONT_SYMBOLIC_TRAIT);
       if (num)
-        {
-          FontSymbolicTraits sym_traits;
-          int spacing;
+        {
+          FontSymbolicTraits sym_traits;
+          int spacing;
 
-          cfnumber_get_font_symbolic_traits_value (num, &sym_traits);
-          spacing = (sym_traits & MAC_FONT_TRAIT_MONO_SPACE
-                     ? FONT_SPACING_MONO : FONT_SPACING_PROPORTIONAL);
-          ASET (spec_or_entity, FONT_SPACING_INDEX, make_number (spacing));
-        }
+          cfnumber_get_font_symbolic_traits_value (num, &sym_traits);
+          spacing = (sym_traits & MAC_FONT_TRAIT_MONO_SPACE
+                     ? FONT_SPACING_MONO : FONT_SPACING_PROPORTIONAL);
+          ASET (spec_or_entity, FONT_SPACING_INDEX, make_number (spacing));
+        }
 
       CFRelease (dict);
     }
@@ -871,7 +870,7 @@ macfont_store_descriptor_attributes (FontDescriptorRef desc,
 
 static Lisp_Object
 macfont_descriptor_entity (FontDescriptorRef desc, Lisp_Object extra,
-                           FontSymbolicTraits synth_sym_traits)
+                           FontSymbolicTraits synth_sym_traits)
 {
   Lisp_Object entity;
   CFDictionaryRef dict;
@@ -891,7 +890,7 @@ macfont_descriptor_entity (FontDescriptorRef desc, Lisp_Object extra,
       CFNumberRef num = CFDictionaryGetValue (dict, MAC_FONT_SYMBOLIC_TRAIT);
 
       if (num)
-        cfnumber_get_font_symbolic_traits_value (num, &sym_traits);
+        cfnumber_get_font_symbolic_traits_value (num, &sym_traits);
       CFRelease (dict);
     }
   if (EQ (AREF (entity, FONT_SIZE_INDEX), make_number (0)))
@@ -899,16 +898,16 @@ macfont_descriptor_entity (FontDescriptorRef desc, Lisp_Object extra,
   ASET (entity, FONT_EXTRA_INDEX, Fcopy_sequence (extra));
   name = mac_font_descriptor_copy_attribute (desc, MAC_FONT_NAME_ATTRIBUTE);
   font_put_extra (entity, QCfont_entity,
-                  make_save_ptr_int ((void *) name, sym_traits));
+                  make_save_ptr_int ((void *) name, sym_traits));
   if (synth_sym_traits & MAC_FONT_TRAIT_ITALIC)
     FONT_SET_STYLE (entity, FONT_SLANT_INDEX,
-                    make_number (FONT_SLANT_SYNTHETIC_ITALIC));
+                    make_number (FONT_SLANT_SYNTHETIC_ITALIC));
   if (synth_sym_traits & MAC_FONT_TRAIT_BOLD)
     FONT_SET_STYLE (entity, FONT_WEIGHT_INDEX,
-                    make_number (FONT_WEIGHT_SYNTHETIC_BOLD));
+                    make_number (FONT_WEIGHT_SYNTHETIC_BOLD));
   if (synth_sym_traits & MAC_FONT_TRAIT_MONO_SPACE)
     ASET (entity, FONT_SPACING_INDEX,
-          make_number (FONT_SPACING_SYNTHETIC_MONO));
+          make_number (FONT_SPACING_SYNTHETIC_MONO));
 
   return entity;
 }
@@ -925,22 +924,9 @@ macfont_create_family_with_symbol (Lisp_Object symbol)
   if (family_name == NULL)
     return NULL;
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
-  if (CTFontManagerCompareFontFamilyNames != NULL)
-#endif
     {
       family_name_comparator = CTFontManagerCompareFontFamilyNames;
     }
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
-  else               /* CTFontManagerCompareFontFamilyNames == NULL */
-#endif
-#endif  /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 */
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
-    {
-      family_name_comparator = mac_font_family_compare;
-    }
-#endif
 
   if ((*family_name_comparator) (family_name, CFSTR ("LastResort"), NULL)
       == kCFCompareEqualTo)
@@ -948,36 +934,36 @@ macfont_create_family_with_symbol (Lisp_Object symbol)
   else
     while (1)
       {
-        CFIndex i, count;
-
-        if (families == NULL)
-          {
-            families = mac_font_create_available_families ();
-            using_cache_p = 0;
-            if (families == NULL)
-              break;
-          }
-
-        count = CFArrayGetCount (families);
-        i = CFArrayBSearchValues (families, CFRangeMake (0, count),
-                                  (const void *) family_name,
-                                  family_name_comparator, NULL);
-        if (i < count)
-          {
-            CFStringRef name = CFArrayGetValueAtIndex (families, i);
-
-            if ((*family_name_comparator) (name, family_name, NULL)
-                == kCFCompareEqualTo)
-              result = CFRetain (name);
-          }
-
-        if (result || !using_cache_p)
-          break;
-        else
-          {
-            CFRelease (families);
-            families = NULL;
-          }
+        CFIndex i, count;
+
+        if (families == NULL)
+          {
+            families = mac_font_create_available_families ();
+            using_cache_p = 0;
+            if (families == NULL)
+              break;
+          }
+
+        count = CFArrayGetCount (families);
+        i = CFArrayBSearchValues (families, CFRangeMake (0, count),
+                                  (const void *) family_name,
+                                  family_name_comparator, NULL);
+        if (i < count)
+          {
+            CFStringRef name = CFArrayGetValueAtIndex (families, i);
+
+            if ((*family_name_comparator) (name, family_name, NULL)
+                == kCFCompareEqualTo)
+              result = CFRetain (name);
+          }
+
+        if (result || !using_cache_p)
+          break;
+        else
+          {
+            CFRelease (families);
+            families = NULL;
+          }
       }
 
   CFRelease (family_name);
@@ -1004,23 +990,23 @@ struct macfont_metrics
   signed width_frac : WIDTH_FRAC_BITS, width_int : 16 - WIDTH_FRAC_BITS;
 };
 
-#define METRICS_VALUE(metrics, member) \
+#define METRICS_VALUE(metrics, member)                          \
   (((metrics)->member##_high << 8) | (metrics)->member##_low)
-#define METRICS_SET_VALUE(metrics, member, value) \
-  do {short tmp = (value); (metrics)->member##_low = tmp & 0xff; \
-      (metrics)->member##_high = tmp >> 8;} while (0)
+#define METRICS_SET_VALUE(metrics, member, value)                   \
+  do {short tmp = (value); (metrics)->member##_low = tmp & 0xff;    \
+    (metrics)->member##_high = tmp >> 8;} while (0)
 
 enum metrics_status
-  {
-    METRICS_INVALID = -1,    /* metrics entry is invalid */
-    METRICS_WIDTH_VALID = -2 /* width is valid but others are invalid */
-  };
+{
+  METRICS_INVALID = -1,    /* metrics entry is invalid */
+  METRICS_WIDTH_VALID = -2 /* width is valid but others are invalid */
+};
 
-#define METRICS_STATUS(metrics) \
+#define METRICS_STATUS(metrics)                                         \
   (METRICS_VALUE (metrics, ascent) + METRICS_VALUE (metrics, descent))
-#define METRICS_SET_STATUS(metrics, status) \
-  do {METRICS_SET_VALUE (metrics, ascent, 0); \
-      METRICS_SET_VALUE (metrics, descent, status);} while (0)
+#define METRICS_SET_STATUS(metrics, status)                     \
+  do {METRICS_SET_VALUE (metrics, ascent, 0);                   \
+    METRICS_SET_VALUE (metrics, descent, status);} while (0)
 
 #define METRICS_NCOLS_PER_ROW   (128)
 #define LCD_FONT_SMOOTHING_LEFT_MARGIN  (0.396f)
@@ -1028,8 +1014,8 @@ enum metrics_status
 
 static int
 macfont_glyph_extents (struct font *font, CGGlyph glyph,
-                       struct font_metrics *metrics, CGFloat *advance_delta,
-                       int force_integral_p)
+                       struct font_metrics *metrics, CGFloat *advance_delta,
+                       int force_integral_p)
 {
   struct macfont_info *macfont_info = (struct macfont_info *) font;
   FontRef macfont = macfont_info->macfont;
@@ -1042,11 +1028,11 @@ macfont_glyph_extents (struct font *font, CGGlyph glyph,
   if (row >= macfont_info->metrics_nrows)
     {
       macfont_info->metrics =
-        xrealloc (macfont_info->metrics,
-                  sizeof (struct macfont_metrics *) * (row + 1));
+        xrealloc (macfont_info->metrics,
+                  sizeof (struct macfont_metrics *) * (row + 1));
       memset (macfont_info->metrics + macfont_info->metrics_nrows, 0,
-              (sizeof (struct macfont_metrics *)
-               * (row + 1 - macfont_info->metrics_nrows)));
+              (sizeof (struct macfont_metrics *)
+               * (row + 1 - macfont_info->metrics_nrows)));
       macfont_info->metrics_nrows = row + 1;
     }
   if (macfont_info->metrics[row] == NULL)
@@ -1056,7 +1042,7 @@ macfont_glyph_extents (struct font *font, CGGlyph glyph,
 
       new = xmalloc (sizeof (struct macfont_metrics) * METRICS_NCOLS_PER_ROW);
       for (i = 0; i < METRICS_NCOLS_PER_ROW; i++)
-        METRICS_SET_STATUS (new + i, METRICS_INVALID);
+        METRICS_SET_STATUS (new + i, METRICS_INVALID);
       macfont_info->metrics[row] = new;
     }
   cache = macfont_info->metrics[row] + col;
@@ -1066,17 +1052,17 @@ macfont_glyph_extents (struct font *font, CGGlyph glyph,
       CGFloat fwidth;
 
       if (macfont_info->screen_font)
-        fwidth = mac_screen_font_get_advance_width_for_glyph (macfont_info->screen_font, glyph);
+        fwidth = mac_screen_font_get_advance_width_for_glyph (macfont_info->screen_font, glyph);
       else
-        fwidth = mac_font_get_advance_width_for_glyph (macfont, glyph);
+        fwidth = mac_font_get_advance_width_for_glyph (macfont, glyph);
 
       /* For synthetic mono fonts, cache->width_{int,frac} holds the
-         advance delta value.  */
+         advance delta value.  */
       if (macfont_info->spacing == MACFONT_SPACING_SYNTHETIC_MONO)
-        fwidth = (font->pixel_size - fwidth) / 2;
+        fwidth = (font->pixel_size - fwidth) / 2;
       cache->width_int = lround (fwidth);
       cache->width_frac = lround ((fwidth - cache->width_int)
-                                  * WIDTH_FRAC_SCALE);
+                                  * WIDTH_FRAC_SCALE);
       METRICS_SET_STATUS (cache, METRICS_WIDTH_VALID);
     }
   if (macfont_info->spacing == MACFONT_SPACING_SYNTHETIC_MONO)
@@ -1087,52 +1073,52 @@ macfont_glyph_extents (struct font *font, CGGlyph glyph,
   if (metrics)
     {
       if (METRICS_STATUS (cache) == METRICS_WIDTH_VALID)
-        {
-          CGRect bounds = mac_font_get_bounding_rect_for_glyph (macfont, glyph);
-
-          if (macfont_info->synthetic_italic_p)
-            {
-              /* We assume the members a, b, c, and d in
-                 synthetic_italic_atfm are non-negative.  */
-              bounds.origin =
-                CGPointApplyAffineTransform (bounds.origin,
-                                             synthetic_italic_atfm);
-              bounds.size =
-                CGSizeApplyAffineTransform (bounds.size, synthetic_italic_atfm);
-            }
-          if (macfont_info->synthetic_bold_p)
-            {
-              CGFloat d =
-                - synthetic_bold_factor * mac_font_get_size (macfont) / 2;
-
-              bounds = CGRectInset (bounds, d, d);
-            }
-          switch (macfont_info->spacing)
-            {
-            case MACFONT_SPACING_PROPORTIONAL:
-              bounds.origin.x += - (cache->width_frac
-                                    / (CGFloat) (WIDTH_FRAC_SCALE * 2));
-              break;
-            case MACFONT_SPACING_MONO:
-              break;
-            case MACFONT_SPACING_SYNTHETIC_MONO:
-              bounds.origin.x += (cache->width_int
-                                  + (cache->width_frac
-                                     / (CGFloat) WIDTH_FRAC_SCALE));
-              break;
-            }
-          if (bounds.size.width > 0)
-            {
-              bounds.origin.x -= LCD_FONT_SMOOTHING_LEFT_MARGIN;
-              bounds.size.width += (LCD_FONT_SMOOTHING_LEFT_MARGIN
-                                    + LCD_FONT_SMOOTHING_RIGHT_MARGIN);
-            }
-          bounds = CGRectIntegral (bounds);
-          METRICS_SET_VALUE (cache, lbearing, CGRectGetMinX (bounds));
-          METRICS_SET_VALUE (cache, rbearing, CGRectGetMaxX (bounds));
-          METRICS_SET_VALUE (cache, ascent, CGRectGetMaxY (bounds));
-          METRICS_SET_VALUE (cache, descent, -CGRectGetMinY (bounds));
-        }
+        {
+          CGRect bounds = mac_font_get_bounding_rect_for_glyph (macfont, glyph);
+
+          if (macfont_info->synthetic_italic_p)
+            {
+              /* We assume the members a, b, c, and d in
+                 synthetic_italic_atfm are non-negative.  */
+              bounds.origin =
+                CGPointApplyAffineTransform (bounds.origin,
+                                             synthetic_italic_atfm);
+              bounds.size =
+                CGSizeApplyAffineTransform (bounds.size, synthetic_italic_atfm);
+            }
+          if (macfont_info->synthetic_bold_p)
+            {
+              CGFloat d =
+                - synthetic_bold_factor * mac_font_get_size (macfont) / 2;
+
+                bounds = CGRectInset (bounds, d, d);
+            }
+          switch (macfont_info->spacing)
+            {
+            case MACFONT_SPACING_PROPORTIONAL:
+              bounds.origin.x += - (cache->width_frac
+                                    / (CGFloat) (WIDTH_FRAC_SCALE * 2));
+              break;
+            case MACFONT_SPACING_MONO:
+              break;
+            case MACFONT_SPACING_SYNTHETIC_MONO:
+              bounds.origin.x += (cache->width_int
+                                  + (cache->width_frac
+                                     / (CGFloat) WIDTH_FRAC_SCALE));
+              break;
+            }
+          if (bounds.size.width > 0)
+            {
+              bounds.origin.x -= LCD_FONT_SMOOTHING_LEFT_MARGIN;
+              bounds.size.width += (LCD_FONT_SMOOTHING_LEFT_MARGIN
+                                    + LCD_FONT_SMOOTHING_RIGHT_MARGIN);
+            }
+          bounds = CGRectIntegral (bounds);
+          METRICS_SET_VALUE (cache, lbearing, CGRectGetMinX (bounds));
+          METRICS_SET_VALUE (cache, rbearing, CGRectGetMaxX (bounds));
+          METRICS_SET_VALUE (cache, ascent, CGRectGetMaxY (bounds));
+          METRICS_SET_VALUE (cache, descent, -CGRectGetMinY (bounds));
+        }
       metrics->lbearing = METRICS_VALUE (cache, lbearing);
       metrics->rbearing = METRICS_VALUE (cache, rbearing);
       metrics->width = width;
@@ -1143,22 +1129,22 @@ macfont_glyph_extents (struct font *font, CGGlyph glyph,
   if (advance_delta)
     {
       switch (macfont_info->spacing)
-        {
-        case MACFONT_SPACING_PROPORTIONAL:
-          *advance_delta = (force_integral_p ? 0
-                            : - (cache->width_frac
-                                 / (CGFloat) (WIDTH_FRAC_SCALE * 2)));
-          break;
-        case MACFONT_SPACING_MONO:
-          *advance_delta = 0;
-          break;
-        case MACFONT_SPACING_SYNTHETIC_MONO:
-          *advance_delta = (force_integral_p ? cache->width_int
-                            : (cache->width_int
-                               + (cache->width_frac
-                                  / (CGFloat) WIDTH_FRAC_SCALE)));
-          break;
-        }
+        {
+        case MACFONT_SPACING_PROPORTIONAL:
+          *advance_delta = (force_integral_p ? 0
+                            : - (cache->width_frac
+                                 / (CGFloat) (WIDTH_FRAC_SCALE * 2)));
+          break;
+        case MACFONT_SPACING_MONO:
+          *advance_delta = 0;
+          break;
+        case MACFONT_SPACING_SYNTHETIC_MONO:
+          *advance_delta = (force_integral_p ? cache->width_int
+                            : (cache->width_int
+                               + (cache->width_frac
+                                  / (CGFloat) WIDTH_FRAC_SCALE)));
+          break;
+        }
     }
 
   return width;
@@ -1220,7 +1206,7 @@ static CFCharacterSetRef macfont_get_cf_charset (struct font *);
 static CFCharacterSetRef macfont_get_cf_charset_for_name (CFStringRef);
 static CGGlyph macfont_get_glyph_for_character (struct font *, UTF32Char);
 static CGGlyph macfont_get_glyph_for_cid (struct font *font,
-                                          CharacterCollection, CGFontIndex);
+                                          CharacterCollection, CGFontIndex);
 static CFDataRef macfont_get_uvs_table (struct font *, CharacterCollection *);
 
 static struct macfont_cache *
@@ -1231,39 +1217,39 @@ macfont_lookup_cache (CFStringRef key)
   if (macfont_cache_dictionary == NULL)
     {
       macfont_cache_dictionary =
-        CFDictionaryCreateMutable (NULL, 0,
-                                   &kCFTypeDictionaryKeyCallBacks, NULL);
+        CFDictionaryCreateMutable (NULL, 0,
+                                   &kCFTypeDictionaryKeyCallBacks, NULL);
       cache = NULL;
     }
   else
     cache = ((struct macfont_cache *)
-             CFDictionaryGetValue (macfont_cache_dictionary, key));
+             CFDictionaryGetValue (macfont_cache_dictionary, key));
 
   if (cache == NULL)
     {
       FontRef macfont = mac_font_create_with_name (key, 0);
 
       if (macfont)
-        {
-          cache = xzalloc (sizeof (struct macfont_cache));
-          /* Treat the LastResort font as if it contained glyphs for
-             all characters.  This may look too rough, but neither
-             CTFontCopyCharacterSet nor -[NSFont coveredCharacterSet]
-             for this font is correct for non-BMP characters on Mac OS
-             X 10.5, anyway.  */
-          if (CFEqual (key, CFSTR ("LastResort")))
-            {
-              CFRange range = CFRangeMake (0, MAX_UNICODE_CHAR + 1);
-
-              cache->cf_charset =
-                CFCharacterSetCreateWithCharactersInRange (NULL, range);
-            }
-          if (cache->cf_charset == NULL)
-            cache->cf_charset = mac_font_copy_character_set (macfont);
-          CFDictionaryAddValue (macfont_cache_dictionary, key,
-                                (const void *) cache);
-          CFRelease (macfont);
-        }
+        {
+          cache = xzalloc (sizeof (struct macfont_cache));
+          /* Treat the LastResort font as if it contained glyphs for
+             all characters.  This may look too rough, but neither
+             CTFontCopyCharacterSet nor -[NSFont coveredCharacterSet]
+             for this font is correct for non-BMP characters on Mac OS
+             X 10.5, anyway.  */
+          if (CFEqual (key, CFSTR ("LastResort")))
+            {
+              CFRange range = CFRangeMake (0, MAX_UNICODE_CHAR + 1);
+
+              cache->cf_charset =
+                CFCharacterSetCreateWithCharactersInRange (NULL, range);
+            }
+          if (cache->cf_charset == NULL)
+            cache->cf_charset = mac_font_copy_character_set (macfont);
+          CFDictionaryAddValue (macfont_cache_dictionary, key,
+                                (const void *) cache);
+          CFRelease (macfont);
+        }
     }
 
   return cache;
@@ -1285,13 +1271,13 @@ macfont_release_cache (struct macfont_cache *cache)
       int i;
 
       for (i = 0; i < cache->glyph.nrows; i++)
-        xfree (cache->glyph.matrix[i]);
+        xfree (cache->glyph.matrix[i]);
       xfree (cache->glyph.matrix);
       if (cache->glyph.dictionary)
-        CFRelease (cache->glyph.dictionary);
+        CFRelease (cache->glyph.dictionary);
       memset (&cache->glyph, 0, sizeof (cache->glyph));
       if (cache->uvs.table)
-        CFRelease (cache->uvs.table);
+        CFRelease (cache->uvs.table);
       memset (&cache->uvs, 0, sizeof (cache->uvs));
     }
 }
@@ -1325,124 +1311,114 @@ macfont_get_glyph_for_character (struct font *font, UTF32Char c)
       int nkeys_or_perm = cache->glyph.row_nkeys_or_perm[row];
 
       if (nkeys_or_perm < ROW_PERM_OFFSET)
-        {
-          UniChar unichars[256], ch;
-          CGGlyph *glyphs;
-          int i, len;
-          int nrows;
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
-          dispatch_queue_t queue;
-          dispatch_group_t group = NULL;
-#else
-          int nkeys;
-#endif
-
-          if (row != 0)
-            {
-              CFMutableDictionaryRef dictionary;
-              uintptr_t key, value;
-              int nshifts;
-              CGGlyph glyph;
-
-              if (cache->glyph.dictionary == NULL)
-                cache->glyph.dictionary =
-                  CFDictionaryCreateMutable (NULL, 0, NULL, NULL);
-              dictionary = cache->glyph.dictionary;
-              key = c / NGLYPHS_IN_VALUE;
-              nshifts = ((c % NGLYPHS_IN_VALUE) * sizeof (CGGlyph) * 8);
-              value = ((uintptr_t)
-                       CFDictionaryGetValue (dictionary, (const void *) key));
-              glyph = (value >> nshifts);
-              if (glyph)
-                return glyph;
-
-              if (nkeys_or_perm + 1 != ROW_PERM_OFFSET)
-                {
-                  ch = c;
-                  if (!mac_font_get_glyphs_for_characters (macfont, &ch,
-                                                           &glyph, 1)
-                      || glyph == 0)
-                    glyph = kCGFontIndexInvalid;
-
-                  if (value == 0)
-                    cache->glyph.row_nkeys_or_perm[row] = nkeys_or_perm + 1;
-                  value |= ((uintptr_t) glyph << nshifts);
-                  CFDictionarySetValue (dictionary, (const void *) key,
-                                        (const void *) value);
-
-                  return glyph;
-                }
-
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
-              queue =
-                dispatch_get_global_queue (DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
-              group = dispatch_group_create ();
-              dispatch_group_async (group, queue, ^{
-                  int nkeys;
-                  uintptr_t key;
-#endif
-                  nkeys = nkeys_or_perm;
-                  for (key = row * (256 / NGLYPHS_IN_VALUE); ; key++)
-                    if (CFDictionaryContainsKey (dictionary,
-                                                 (const void *) key))
-                      {
-                        CFDictionaryRemoveValue (dictionary,
-                                                 (const void *) key);
-                        if (--nkeys == 0)
-                          break;
-                      }
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
-                });
-#endif
-            }
-
-          len = 0;
-          for (i = 0; i < 256; i++)
-            {
-              ch = row * 256 + i;
-              if (CFCharacterSetIsLongCharacterMember (cache->cf_charset, ch))
-                unichars[len++] = ch;
-            }
-
-          glyphs = xmalloc (sizeof (CGGlyph) * 256);
-          if (len > 0)
-            {
-              mac_font_get_glyphs_for_characters (macfont, unichars,
-                                                  glyphs, len);
-              while (i > len)
-                {
-                  int next = unichars[len - 1] % 256;
-
-                  while (--i > next)
-                    glyphs[i] = kCGFontIndexInvalid;
-
-                  len--;
-                  glyphs[i] = glyphs[len];
-                  if (len == 0)
-                    break;
-                }
-            }
-          if (i > len)
-            while (i-- > 0)
-              glyphs[i] = kCGFontIndexInvalid;
-
-          nrows = cache->glyph.nrows;
-          nkeys_or_perm = nrows + ROW_PERM_OFFSET;
-          cache->glyph.row_nkeys_or_perm[row] = nkeys_or_perm;
-          nrows++;
-          cache->glyph.matrix = xrealloc (cache->glyph.matrix,
-                                          sizeof (CGGlyph *) * nrows);
-          cache->glyph.matrix[nrows - 1] = glyphs;
-          cache->glyph.nrows = nrows;
-
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
-          if (group)
-            {
-              dispatch_group_wait (group, DISPATCH_TIME_FOREVER);
-              dispatch_release (group);
-            }
-#endif
-        }
+        {
+          UniChar unichars[256], ch;
+          CGGlyph *glyphs;
+          int i, len;
+          int nrows;
+          dispatch_queue_t queue;
+          dispatch_group_t group = NULL;
+
+          if (row != 0)
+            {
+              CFMutableDictionaryRef dictionary;
+              uintptr_t key, value;
+              int nshifts;
+              CGGlyph glyph;
+
+              if (cache->glyph.dictionary == NULL)
+                cache->glyph.dictionary =
+                  CFDictionaryCreateMutable (NULL, 0, NULL, NULL);
+              dictionary = cache->glyph.dictionary;
+              key = c / NGLYPHS_IN_VALUE;
+              nshifts = ((c % NGLYPHS_IN_VALUE) * sizeof (CGGlyph) * 8);
+              value = ((uintptr_t)
+                       CFDictionaryGetValue (dictionary, (const void *) key));
+              glyph = (value >> nshifts);
+              if (glyph)
+                return glyph;
+
+              if (nkeys_or_perm + 1 != ROW_PERM_OFFSET)
+                {
+                  ch = c;
+                  if (!mac_font_get_glyphs_for_characters (macfont, &ch,
+                                                           &glyph, 1)
+                      || glyph == 0)
+                    glyph = kCGFontIndexInvalid;
+
+                  if (value == 0)
+                    cache->glyph.row_nkeys_or_perm[row] = nkeys_or_perm + 1;
+                  value |= ((uintptr_t) glyph << nshifts);
+                  CFDictionarySetValue (dictionary, (const void *) key,
+                                        (const void *) value);
+
+                  return glyph;
+                }
+
+              queue =
+                dispatch_get_global_queue (DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+              group = dispatch_group_create ();
+              dispatch_group_async (group, queue, ^{
+                  int nkeys;
+                  uintptr_t key;
+                  nkeys = nkeys_or_perm;
+                  for (key = row * (256 / NGLYPHS_IN_VALUE); ; key++)
+                    if (CFDictionaryContainsKey (dictionary,
+                                                 (const void *) key))
+                      {
+                        CFDictionaryRemoveValue (dictionary,
+                                                 (const void *) key);
+                        if (--nkeys == 0)
+                          break;
+                      }
+                });
+            }
+
+          len = 0;
+          for (i = 0; i < 256; i++)
+            {
+              ch = row * 256 + i;
+              if (CFCharacterSetIsLongCharacterMember (cache->cf_charset, ch))
+                unichars[len++] = ch;
+            }
+
+          glyphs = xmalloc (sizeof (CGGlyph) * 256);
+          if (len > 0)
+            {
+              mac_font_get_glyphs_for_characters (macfont, unichars,
+                                                  glyphs, len);
+              while (i > len)
+                {
+                  int next = unichars[len - 1] % 256;
+
+                  while (--i > next)
+                    glyphs[i] = kCGFontIndexInvalid;
+
+                  len--;
+                  glyphs[i] = glyphs[len];
+                  if (len == 0)
+                    break;
+                }
+            }
+          if (i > len)
+            while (i-- > 0)
+              glyphs[i] = kCGFontIndexInvalid;
+
+          nrows = cache->glyph.nrows;
+          nkeys_or_perm = nrows + ROW_PERM_OFFSET;
+          cache->glyph.row_nkeys_or_perm[row] = nkeys_or_perm;
+          nrows++;
+          cache->glyph.matrix = xrealloc (cache->glyph.matrix,
+                                          sizeof (CGGlyph *) * nrows);
+          cache->glyph.matrix[nrows - 1] = glyphs;
+          cache->glyph.nrows = nrows;
+
+          if (group)
+            {
+              dispatch_group_wait (group, DISPATCH_TIME_FOREVER);
+              dispatch_release (group);
+            }
+        }
 
       return cache->glyph.matrix[nkeys_or_perm - ROW_PERM_OFFSET][c % 256];
     }
@@ -1453,29 +1429,29 @@ macfont_get_glyph_for_character (struct font *font, UTF32Char c)
       CGGlyph glyph;
 
       if (cache->glyph.dictionary == NULL)
-        cache->glyph.dictionary =
-          CFDictionaryCreateMutable (NULL, 0, NULL, NULL);
+        cache->glyph.dictionary =
+          CFDictionaryCreateMutable (NULL, 0, NULL, NULL);
       key = c / NGLYPHS_IN_VALUE;
       nshifts = ((c % NGLYPHS_IN_VALUE) * sizeof (CGGlyph) * 8);
       value = (uintptr_t) CFDictionaryGetValue (cache->glyph.dictionary,
-                                                (const void *) key);
+                                                (const void *) key);
       glyph = (value >> nshifts);
       if (glyph == 0)
-        {
-          UniChar unichars[2];
-          CGGlyph glyphs[2];
-          CFIndex count = macfont_store_utf32char_to_unichars (c, unichars);
-
-          if (mac_font_get_glyphs_for_characters (macfont, unichars, glyphs,
-                                                  count))
-            glyph = glyphs[0];
-          if (glyph == 0)
-            glyph = kCGFontIndexInvalid;
-
-          value |= ((uintptr_t) glyph << nshifts);
-          CFDictionarySetValue (cache->glyph.dictionary,
-                                (const void *) key, (const void *) value);
-        }
+        {
+          UniChar unichars[2];
+          CGGlyph glyphs[2];
+          CFIndex count = macfont_store_utf32char_to_unichars (c, unichars);
+
+          if (mac_font_get_glyphs_for_characters (macfont, unichars, glyphs,
+                                                  count))
+            glyph = glyphs[0];
+          if (glyph == 0)
+            glyph = kCGFontIndexInvalid;
+
+          value |= ((uintptr_t) glyph << nshifts);
+          CFDictionarySetValue (cache->glyph.dictionary,
+                                (const void *) key, (const void *) value);
+        }
 
       return glyph;
     }
@@ -1483,7 +1459,7 @@ macfont_get_glyph_for_character (struct font *font, UTF32Char c)
 
 static CGGlyph
 macfont_get_glyph_for_cid (struct font *font, CharacterCollection collection,
-                           CGFontIndex cid)
+                           CGFontIndex cid)
 {
   struct macfont_info *macfont_info = (struct macfont_info *) font;
   FontRef macfont = macfont_info->macfont;
@@ -1504,34 +1480,34 @@ macfont_get_uvs_table (struct font *font, CharacterCollection *collection)
     {
       CFDataRef uvs_table = mac_font_copy_uvs_table (macfont);
       CharacterCollection uvs_collection =
-        MAC_CHARACTER_COLLECTION_IDENTITY_MAPPING;
+        MAC_CHARACTER_COLLECTION_IDENTITY_MAPPING;
 
       if (uvs_table == NULL
-          && mac_font_get_glyph_for_cid (macfont,
-                                         MAC_CHARACTER_COLLECTION_ADOBE_JAPAN1,
-                                         6480) != kCGFontIndexInvalid)
-        {
-          /* If the glyph for U+4E55 is accessible via its CID 6480,
-             then we use the Adobe-Japan1 UVS table, which maps a
-             variation sequence to a CID, as a fallback.  */
-          static CFDataRef mac_uvs_table_adobe_japan1 = NULL;
-
-          if (mac_uvs_table_adobe_japan1 == NULL)
-            mac_uvs_table_adobe_japan1 =
-              CFDataCreateWithBytesNoCopy (NULL,
-                                           mac_uvs_table_adobe_japan1_bytes,
-                                           sizeof (mac_uvs_table_adobe_japan1_bytes),
-                                           kCFAllocatorNull);
-          if (mac_uvs_table_adobe_japan1)
-            {
-              uvs_table = CFRetain (mac_uvs_table_adobe_japan1);
-              uvs_collection = MAC_CHARACTER_COLLECTION_ADOBE_JAPAN1;
-            }
-        }
+          && mac_font_get_glyph_for_cid (macfont,
+                                         MAC_CHARACTER_COLLECTION_ADOBE_JAPAN1,
+                                         6480) != kCGFontIndexInvalid)
+        {
+          /* If the glyph for U+4E55 is accessible via its CID 6480,
+             then we use the Adobe-Japan1 UVS table, which maps a
+             variation sequence to a CID, as a fallback.  */
+          static CFDataRef mac_uvs_table_adobe_japan1 = NULL;
+
+          if (mac_uvs_table_adobe_japan1 == NULL)
+            mac_uvs_table_adobe_japan1 =
+              CFDataCreateWithBytesNoCopy (NULL,
+                                           mac_uvs_table_adobe_japan1_bytes,
+                                           sizeof (mac_uvs_table_adobe_japan1_bytes),
+                                           kCFAllocatorNull);
+          if (mac_uvs_table_adobe_japan1)
+            {
+              uvs_table = CFRetain (mac_uvs_table_adobe_japan1);
+              uvs_collection = MAC_CHARACTER_COLLECTION_ADOBE_JAPAN1;
+            }
+        }
       if (uvs_table == NULL)
-        cache->uvs.table = kCFNull;
+        cache->uvs.table = kCFNull;
       else
-        cache->uvs.table = uvs_table;
+        cache->uvs.table = uvs_table;
       cache->uvs.collection = uvs_collection;
     }
 
@@ -1553,12 +1529,12 @@ static Lisp_Object macfont_open (struct frame *, Lisp_Object, int);
 static void macfont_close (struct font *);
 static int macfont_has_char (Lisp_Object, int);
 static unsigned macfont_encode_char (struct font *, int);
-static int macfont_text_extents (struct font *, unsigned int *, int,
-                                 struct font_metrics *);
+static void macfont_text_extents (struct font *, unsigned int *, int,
+                                  struct font_metrics *);
 static int macfont_draw (struct glyph_string *, int, int, int, int, bool);
 static Lisp_Object macfont_shape (Lisp_Object);
 static int macfont_variation_glyphs (struct font *, int c,
-                                     unsigned variations[256]);
+                                     unsigned variations[256]);
 static void macfont_filter_properties (Lisp_Object, Lisp_Object);
 
 static struct font_driver macfont_driver =
@@ -1610,19 +1586,19 @@ macfont_get_charset (Lisp_Object registry)
   for (i = j = 0; i < SBYTES (SYMBOL_NAME (registry)); i++, j++)
     {
       if (str[i] == '.')
-        re[j++] = '\\';
+        re[j++] = '\\';
       else if (str[i] == '*')
-        re[j++] = '.';
+        re[j++] = '.';
       re[j] = str[i];
       if (re[j] == '?')
-        re[j] = '.';
+        re[j] = '.';
     }
   re[j] = '\0';
   regexp = make_unibyte_string (re, j);
   for (i = 0; cf_charset_table[i].name; i++)
     if (fast_c_string_match_ignore_case
-        (regexp, cf_charset_table[i].name,
-         strlen (cf_charset_table[i].name)) >= 0)
+        (regexp, cf_charset_table[i].name,
+         strlen (cf_charset_table[i].name)) >= 0)
       break;
   if (! cf_charset_table[i].name)
     return -1;
@@ -1635,27 +1611,27 @@ macfont_get_charset (Lisp_Object registry)
       CFMutableCharacterSetRef charset = CFCharacterSetCreateMutable (NULL);
 
       if (! charset)
-        return -1;
+        return -1;
       for (j = 0; uniquifier[j]; j++)
-        {
-          count += macfont_store_utf32char_to_unichars (uniquifier[j],
-                                                        unichars + count);
-          CFCharacterSetAddCharactersInRange (charset,
-                                              CFRangeMake (uniquifier[j], 1));
-        }
+        {
+          count += macfont_store_utf32char_to_unichars (uniquifier[j],
+                                                        unichars + count);
+          CFCharacterSetAddCharactersInRange (charset,
+                                              CFRangeMake (uniquifier[j], 1));
+        }
 
       string = CFStringCreateWithCharacters (NULL, unichars, count);
       if (! string)
-        {
-          CFRelease (charset);
-          return -1;
-        }
+        {
+          CFRelease (charset);
+          return -1;
+        }
       cf_charset_table[i].cf_charset = CFCharacterSetCreateCopy (NULL,
-                                                                 charset);
+                                                                 charset);
       CFRelease (charset);
       /* CFCharacterSetCreateWithCharactersInString does not handle
-         surrogate pairs properly as of Mac OS X 10.5.  */
-     cf_charset_table[i].cf_charset_string = string;
+         surrogate pairs properly as of Mac OS X 10.5.  */
+      cf_charset_table[i].cf_charset_string = string;
     }
   return i;
 }
@@ -1668,19 +1644,19 @@ struct OpenTypeSpec
   unsigned int *features[2];
 };
 
-#define OTF_SYM_TAG(SYM, TAG)                                   \
-  do {                                                          \
-    unsigned char *p = SDATA (SYMBOL_NAME (SYM));               \
+#define OTF_SYM_TAG(SYM, TAG)                               \
+  do {                                                      \
+    unsigned char *p = SDATA (SYMBOL_NAME (SYM));           \
     TAG = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];     \
   } while (0)
 
-#define OTF_TAG_STR(TAG, P)                     \
-  do {                                          \
-    (P)[0] = (char) (TAG >> 24);                \
-    (P)[1] = (char) ((TAG >> 16) & 0xFF);       \
-    (P)[2] = (char) ((TAG >> 8) & 0xFF);        \
-    (P)[3] = (char) (TAG & 0xFF);               \
-    (P)[4] = '\0';                              \
+#define OTF_TAG_STR(TAG, P)                     \
+  do {                                          \
+    (P)[0] = (char) (TAG >> 24);                \
+    (P)[1] = (char) ((TAG >> 16) & 0xFF);       \
+    (P)[2] = (char) ((TAG >> 8) & 0xFF);        \
+    (P)[3] = (char) (TAG & 0xFF);               \
+    (P)[4] = '\0';                              \
   } while (0)
 
 static struct OpenTypeSpec *
@@ -1699,9 +1675,9 @@ macfont_get_open_type_spec (Lisp_Object otf_spec)
       OTF_SYM_TAG (spec->script, spec->script_tag);
       val = assq_no_quit (spec->script, Votf_script_alist);
       if (CONSP (val) && SYMBOLP (XCDR (val)))
-        spec->script = XCDR (val);
+        spec->script = XCDR (val);
       else
-        spec->script = Qnil;
+        spec->script = Qnil;
     }
   else
     spec->script_tag = 0x44464C54;      /* "DFLT" */
@@ -1711,7 +1687,7 @@ macfont_get_open_type_spec (Lisp_Object otf_spec)
     {
       val = XCAR (otf_spec);
       if (! NILP (val))
-        OTF_SYM_TAG (val, spec->langsys_tag);
+        OTF_SYM_TAG (val, spec->langsys_tag);
       otf_spec = XCDR (otf_spec);
     }
   spec->nfeatures[0] = spec->nfeatures[1] = 0;
@@ -1721,31 +1697,31 @@ macfont_get_open_type_spec (Lisp_Object otf_spec)
 
       val = XCAR (otf_spec);
       if (NILP (val))
-        continue;
+        continue;
       len = Flength (val);
       spec->features[i] =
-        (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < XINT (len)
-         ? 0
-         : malloc (XINT (len) * sizeof *spec->features[i]));
+        (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < XINT (len)
+         ? 0
+         : malloc (XINT (len) * sizeof *spec->features[i]));
       if (! spec->features[i])
-        {
-          if (i > 0 && spec->features[0])
-            free (spec->features[0]);
-          free (spec);
-          return NULL;
-        }
+        {
+          if (i > 0 && spec->features[0])
+            free (spec->features[0]);
+          free (spec);
+          return NULL;
+        }
       for (j = 0, negative = 0; CONSP (val); val = XCDR (val))
-        {
-          if (NILP (XCAR (val)))
-            negative = 1;
-          else
-            {
-              unsigned int tag;
-
-              OTF_SYM_TAG (XCAR (val), tag);
-              spec->features[i][j++] = negative ? tag & 0x80000000 : tag;
-            }
-        }
+        {
+          if (NILP (XCAR (val)))
+            negative = 1;
+          else
+            {
+              unsigned int tag;
+
+              OTF_SYM_TAG (XCAR (val), tag);
+              spec->features[i][j++] = negative ? tag & 0x80000000 : tag;
+            }
+        }
       spec->nfeatures[i] = j;
     }
   return spec;
@@ -1769,16 +1745,16 @@ macfont_create_attributes_with_spec (Lisp_Object spec)
     CGPoint points[6];
   } numeric_traits[] =
       {{FONT_WEIGHT_INDEX, MAC_FONT_WEIGHT_TRAIT,
-        {{-0.4, 50},            /* light */
-         {-0.24, 87.5},         /* (semi-light + normal) / 2 */
-         {0, 100},              /* normal */
-         {0.24, 140},           /* (semi-bold + normal) / 2 */
-         {0.4, 200},            /* bold */
-         {CGFLOAT_MAX, CGFLOAT_MAX}}},
+        {{-0.4, 50},            /* light */
+         {-0.24, 87.5},         /* (semi-light + normal) / 2 */
+         {0, 100},              /* normal */
+         {0.24, 140},           /* (semi-bold + normal) / 2 */
+         {0.4, 200},            /* bold */
+         {CGFLOAT_MAX, CGFLOAT_MAX}}},
        {FONT_SLANT_INDEX, MAC_FONT_SLANT_TRAIT,
-        {{0, 100}, {0.1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}},
+        {{0, 100}, {0.1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}},
        {FONT_WIDTH_INDEX, MAC_FONT_WIDTH_TRAIT,
-        {{0, 100}, {1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}}};
+        {{0, 100}, {1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}}};
 
   registry = AREF (spec, FONT_REGISTRY_INDEX);
   if (NILP (registry)
@@ -1792,17 +1768,17 @@ macfont_create_attributes_with_spec (Lisp_Object spec)
 
       cf_charset_idx = macfont_get_charset (registry);
       if (cf_charset_idx < 0)
-        goto err;
+        goto err;
       charset = cf_charset_table[cf_charset_idx].cf_charset;
       charset_string = cf_charset_table[cf_charset_idx].cf_charset_string;
       lang = cf_charset_table[cf_charset_idx].lang;
       if (lang)
-        {
-          langarray = CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks);
-          if (! langarray)
-            goto err;
-          CFArrayAppendValue (langarray, lang);
-        }
+        {
+          langarray = CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks);
+          if (! langarray)
+            goto err;
+          CFArrayAppendValue (langarray, lang);
+        }
     }
 
   for (extra = AREF (spec, FONT_EXTRA_INDEX);
@@ -1813,35 +1789,35 @@ macfont_create_attributes_with_spec (Lisp_Object spec)
       tmp = XCAR (extra);
       key = XCAR (tmp), val = XCDR (tmp);
       if (EQ (key, QClang))
-        {
-          if (! langarray)
-            langarray = CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks);
-          if (! langarray)
-            goto err;
-          if (SYMBOLP (val))
-            val = list1 (val);
-          for (; CONSP (val); val = XCDR (val))
-            if (SYMBOLP (XCAR (val)))
-              {
-                CFStringRef lang =
-                  cfstring_create_with_string_noencode (SYMBOL_NAME
-                                                        (XCAR (val)));
-
-                if (lang == NULL)
-                  goto err;
-                CFArrayAppendValue (langarray, lang);
-                CFRelease (lang);
-              }
-        }
+        {
+          if (! langarray)
+            langarray = CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks);
+          if (! langarray)
+            goto err;
+          if (SYMBOLP (val))
+            val = list1 (val);
+          for (; CONSP (val); val = XCDR (val))
+            if (SYMBOLP (XCAR (val)))
+              {
+                CFStringRef lang =
+                  cfstring_create_with_string_noencode (SYMBOL_NAME
+                                                        (XCAR (val)));
+
+                if (lang == NULL)
+                  goto err;
+                CFArrayAppendValue (langarray, lang);
+                CFRelease (lang);
+              }
+        }
       else if (EQ (key, QCotf))
-        {
-          otspec = macfont_get_open_type_spec (val);
-          if (! otspec)
-            goto err;
-          script = otspec->script;
-        }
+        {
+          otspec = macfont_get_open_type_spec (val);
+          if (! otspec)
+            goto err;
+          script = otspec->script;
+        }
       else if (EQ (key, QCscript))
-        script = val;
+        script = val;
     }
 
   if (! NILP (script) && ! charset)
@@ -1849,40 +1825,40 @@ macfont_create_attributes_with_spec (Lisp_Object spec)
       Lisp_Object chars = assq_no_quit (script, Vscript_representative_chars);
 
       if (CONSP (chars) && CONSP (CDR (chars)))
-        {
-          CFMutableStringRef string = CFStringCreateMutable (NULL, 0);
-          CFMutableCharacterSetRef cs = CFCharacterSetCreateMutable (NULL);
-
-          if (! string || !cs)
-            {
-              if (string)
-                CFRelease (string);
-              else if (cs)
-                CFRelease (cs);
-              goto err;
-            }
-          for (chars = XCDR (chars); CONSP (chars); chars = XCDR (chars))
-            if (CHARACTERP (XCAR (chars)))
-              {
-                UniChar unichars[2];
-                CFIndex count =
-                  macfont_store_utf32char_to_unichars (XFASTINT (XCAR (chars)),
-                                                       unichars);
-                CFRange range = CFRangeMake (XFASTINT (XCAR (chars)), 1);
-
-                CFStringAppendCharacters (string, unichars, count);
-                CFCharacterSetAddCharactersInRange (cs, range);
-              }
-          charset = cs;
-          /* CFCharacterSetCreateWithCharactersInString does not
-             handle surrogate pairs properly as of Mac OS X 10.5.  */
-          charset_string = string;
-        }
+        {
+          CFMutableStringRef string = CFStringCreateMutable (NULL, 0);
+          CFMutableCharacterSetRef cs = CFCharacterSetCreateMutable (NULL);
+
+          if (! string || !cs)
+            {
+              if (string)
+                CFRelease (string);
+              else if (cs)
+                CFRelease (cs);
+              goto err;
+            }
+          for (chars = XCDR (chars); CONSP (chars); chars = XCDR (chars))
+            if (CHARACTERP (XCAR (chars)))
+              {
+                UniChar unichars[2];
+                CFIndex count =
+                  macfont_store_utf32char_to_unichars (XFASTINT (XCAR (chars)),
+                                                       unichars);
+                CFRange range = CFRangeMake (XFASTINT (XCAR (chars)), 1);
+
+                CFStringAppendCharacters (string, unichars, count);
+                CFCharacterSetAddCharactersInRange (cs, range);
+              }
+          charset = cs;
+          /* CFCharacterSetCreateWithCharactersInString does not
+             handle surrogate pairs properly as of Mac OS X 10.5.  */
+          charset_string = string;
+        }
     }
 
   attributes = CFDictionaryCreateMutable (NULL, 0,
-                                          &kCFTypeDictionaryKeyCallBacks,
-                                          &kCFTypeDictionaryValueCallBacks);
+                                          &kCFTypeDictionaryKeyCallBacks,
+                                          &kCFTypeDictionaryValueCallBacks);
   if (! attributes)
     goto err;
 
@@ -1892,15 +1868,15 @@ macfont_create_attributes_with_spec (Lisp_Object spec)
       CFStringRef family = macfont_create_family_with_symbol (tmp);
 
       if (! family)
-        goto err;
+        goto err;
       CFDictionaryAddValue (attributes, MAC_FONT_FAMILY_NAME_ATTRIBUTE,
-                            family);
+                            family);
       CFRelease (family);
     }
 
   traits = CFDictionaryCreateMutable (NULL, 4,
-                                      &kCFTypeDictionaryKeyCallBacks,
-                                      &kCFTypeDictionaryValueCallBacks);
+                                      &kCFTypeDictionaryKeyCallBacks,
+                                      &kCFTypeDictionaryValueCallBacks);
   if (! traits)
     goto err;
 
@@ -1908,40 +1884,40 @@ macfont_create_attributes_with_spec (Lisp_Object spec)
     {
       tmp = AREF (spec, numeric_traits[i].index);
       if (INTEGERP (tmp))
-        {
-          CGPoint *point = numeric_traits[i].points;
-          CGFloat floatval = (XINT (tmp) >> 8); // XXX
-          CFNumberRef num;
-
-          while (point->y < floatval)
-            point++;
-          if (point == numeric_traits[i].points)
-            point++;
-          else if (point->y == CGFLOAT_MAX)
-            point--;
-          floatval = (point - 1)->x + ((floatval - (point - 1)->y)
-                                       * ((point->x - (point - 1)->x)
-                                          / (point->y - (point - 1)->y)));
-          if (floatval > 1.0)
-            floatval = 1.0;
-          else if (floatval < -1.0)
-            floatval = -1.0;
-          num = CFNumberCreate (NULL, kCFNumberCGFloatType, &floatval);
-          if (! num)
-            goto err;
-          CFDictionaryAddValue (traits, numeric_traits[i].trait, num);
-          CFRelease (num);
-        }
+        {
+          CGPoint *point = numeric_traits[i].points;
+          CGFloat floatval = (XINT (tmp) >> 8); // XXX
+          CFNumberRef num;
+
+          while (point->y < floatval)
+            point++;
+          if (point == numeric_traits[i].points)
+            point++;
+          else if (point->y == CGFLOAT_MAX)
+            point--;
+          floatval = (point - 1)->x + ((floatval - (point - 1)->y)
+                                       * ((point->x - (point - 1)->x)
+                                          / (point->y - (point - 1)->y)));
+          if (floatval > 1.0)
+            floatval = 1.0;
+          else if (floatval < -1.0)
+            floatval = -1.0;
+          num = CFNumberCreate (NULL, kCFNumberCGFloatType, &floatval);
+          if (! num)
+            goto err;
+          CFDictionaryAddValue (traits, numeric_traits[i].trait, num);
+          CFRelease (num);
+        }
     }
   if (CFDictionaryGetCount (traits))
     CFDictionaryAddValue (attributes, MAC_FONT_TRAITS_ATTRIBUTE, traits);
 
   if (charset)
     CFDictionaryAddValue (attributes, MAC_FONT_CHARACTER_SET_ATTRIBUTE,
-                          charset);
+                          charset);
   if (charset_string)
     CFDictionaryAddValue (attributes, MAC_FONT_CHARACTER_SET_STRING_ATTRIBUTE,
-                          charset_string);
+                          charset_string);
   if (langarray)
     CFDictionaryAddValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE, langarray);
 
@@ -1962,9 +1938,9 @@ macfont_create_attributes_with_spec (Lisp_Object spec)
   if (otspec)
     {
       if (otspec->nfeatures[0] > 0)
-        free (otspec->features[0]);
+        free (otspec->features[0]);
       if (otspec->nfeatures[1] > 0)
-        free (otspec->features[1]);
+        free (otspec->features[1]);
       free (otspec);
     }
 
@@ -1973,38 +1949,38 @@ macfont_create_attributes_with_spec (Lisp_Object spec)
 
 static Boolean
 macfont_supports_charset_and_languages_p (FontDescriptorRef desc,
-                                          CFCharacterSetRef charset,
-                                          Lisp_Object chars,
-                                          CFArrayRef languages)
+                                          CFCharacterSetRef charset,
+                                          Lisp_Object chars,
+                                          CFArrayRef languages)
 {
   Boolean result = true;
 
   if (charset || VECTORP (chars))
     {
       CFCharacterSetRef desc_charset =
-        mac_font_descriptor_copy_attribute (desc,
-                                            MAC_FONT_CHARACTER_SET_ATTRIBUTE);
+        mac_font_descriptor_copy_attribute (desc,
+                                            MAC_FONT_CHARACTER_SET_ATTRIBUTE);
 
       if (desc_charset == NULL)
-        result = false;
+        result = false;
       else
-        {
-          if (charset)
-            result = CFCharacterSetIsSupersetOfSet (desc_charset, charset);
-          else                  /* VECTORP (chars) */
-            {
-              ptrdiff_t j;
-
-              for (j = 0; j < ASIZE (chars); j++)
-                if (TYPE_RANGED_INTEGERP (UTF32Char, AREF (chars, j))
-                    && CFCharacterSetIsLongCharacterMember (desc_charset,
-                                                            XFASTINT (AREF (chars, j))))
-                  break;
-              if (j == ASIZE (chars))
-                result = false;
-            }
-          CFRelease (desc_charset);
-        }
+        {
+          if (charset)
+            result = CFCharacterSetIsSupersetOfSet (desc_charset, charset);
+          else                  /* VECTORP (chars) */
+            {
+              ptrdiff_t j;
+
+              for (j = 0; j < ASIZE (chars); j++)
+                if (TYPE_RANGED_INTEGERP (UTF32Char, AREF (chars, j))
+                    && CFCharacterSetIsLongCharacterMember (desc_charset,
+                                                            XFASTINT (AREF (chars, j))))
+                  break;
+              if (j == ASIZE (chars))
+                result = false;
+            }
+          CFRelease (desc_charset);
+        }
     }
   if (result && languages)
     result = mac_font_descriptor_supports_languages (desc, languages);
@@ -2012,38 +1988,49 @@ macfont_supports_charset_and_languages_p (FontDescriptorRef desc,
   return result;
 }
 
-static CFIndex
-macfont_closest_traits_index (CFArrayRef traits_array,
-                              FontSymbolicTraits target)
+static int
+macfont_traits_distance (FontSymbolicTraits sym_traits1,
+                         FontSymbolicTraits sym_traits2)
+{
+  FontSymbolicTraits diff = (sym_traits1 ^ sym_traits2);
+  int distance = 0;
+
+  /* We prefer synthetic bold of italic to synthetic italic of bold
+     when both bold and italic are available but bold-italic is not
+     available.  */
+  if (diff & MAC_FONT_TRAIT_BOLD)
+    distance |= (1 << 0);
+  if (diff & MAC_FONT_TRAIT_ITALIC)
+    distance |= (1 << 1);
+  if (diff & MAC_FONT_TRAIT_MONO_SPACE)
+    distance |= (1 << 2);
+
+  return distance;
+}
+
+static Boolean
+macfont_closest_traits_index_p (CFArrayRef traits_array,
+                                FontSymbolicTraits target,
+                                CFIndex index)
 {
-  CFIndex i, result = -1, count = CFArrayGetCount (traits_array);
-  int min_distance = (1 << 3);
+  CFIndex i, count = CFArrayGetCount (traits_array);
+  FontSymbolicTraits traits;
+  int my_distance;
+
+  traits = ((FontSymbolicTraits) (uintptr_t)
+            CFArrayGetValueAtIndex (traits_array, index));
+  my_distance = macfont_traits_distance (target, traits);
 
   for (i = 0; i < count; i++)
-    {
-      FontSymbolicTraits traits, diff;
-      int distance = 0;
-
-      traits = ((FontSymbolicTraits) (uintptr_t)
-                CFArrayGetValueAtIndex (traits_array, i));
-      diff = (target ^ traits);
-      /* We prefer synthetic bold of italic to synthetic italic of
-         bold when both bold and italic are available but bold-italic
-         is not available.  */
-      if (diff & MAC_FONT_TRAIT_BOLD)
-        distance |= (1 << 0);
-      if (diff & MAC_FONT_TRAIT_ITALIC)
-        distance |= (1 << 1);
-      if (diff & MAC_FONT_TRAIT_MONO_SPACE)
-        distance |= (1 << 2);
-      if (distance < min_distance)
-        {
-          min_distance = distance;
-          result = i;
-        }
-    }
+    if (i != index)
+      {
+        traits = ((FontSymbolicTraits) (uintptr_t)
+                  CFArrayGetValueAtIndex (traits_array, i));
+        if (macfont_traits_distance (target, traits) < my_distance)
+          return false;
+      }
 
-  return result;
+  return true;
 }
 
 static Lisp_Object
@@ -2068,7 +2055,7 @@ macfont_list (struct frame *f, Lisp_Object spec)
     {
       family_name = macfont_create_family_with_symbol (family);
       if (family_name == NULL)
-        goto finish;
+        goto finish;
     }
 
   attributes = macfont_create_attributes_with_spec (spec);
@@ -2081,14 +2068,14 @@ macfont_list (struct frame *f, Lisp_Object spec)
     spacing = XINT (AREF (spec, FONT_SPACING_INDEX));
 
   traits = ((CFMutableDictionaryRef)
-            CFDictionaryGetValue (attributes, MAC_FONT_TRAITS_ATTRIBUTE));
+            CFDictionaryGetValue (attributes, MAC_FONT_TRAITS_ATTRIBUTE));
 
   n = FONT_SLANT_NUMERIC (spec);
   if (n < 0 || n == FONT_SLANT_SYNTHETIC_ITALIC)
     {
       synth_sym_traits |= MAC_FONT_TRAIT_ITALIC;
       if (traits)
-        CFDictionaryRemoveValue (traits, MAC_FONT_SLANT_TRAIT);
+        CFDictionaryRemoveValue (traits, MAC_FONT_SLANT_TRAIT);
     }
 
   n = FONT_WEIGHT_NUMERIC (spec);
@@ -2096,7 +2083,7 @@ macfont_list (struct frame *f, Lisp_Object spec)
     {
       synth_sym_traits |= MAC_FONT_TRAIT_BOLD;
       if (traits)
-        CFDictionaryRemoveValue (traits, MAC_FONT_WEIGHT_TRAIT);
+        CFDictionaryRemoveValue (traits, MAC_FONT_WEIGHT_TRAIT);
     }
 
   if (languages
@@ -2105,15 +2092,15 @@ macfont_list (struct frame *f, Lisp_Object spec)
       CFStringRef language = CFArrayGetValueAtIndex (languages, 0);
 
       if (CFStringHasPrefix (language, CFSTR ("ja"))
-          || CFStringHasPrefix (language, CFSTR ("ko"))
-          || CFStringHasPrefix (language, CFSTR ("zh")))
-        synth_sym_traits |= MAC_FONT_TRAIT_MONO_SPACE;
+          || CFStringHasPrefix (language, CFSTR ("ko"))
+          || CFStringHasPrefix (language, CFSTR ("zh")))
+        synth_sym_traits |= MAC_FONT_TRAIT_MONO_SPACE;
     }
 
   /* Create array of families.  */
   if (family_name)
     families = CFArrayCreate (NULL, (const void **) &family_name,
-                              1, &kCFTypeArrayCallBacks);
+                              1, &kCFTypeArrayCallBacks);
   else
     {
       CFStringRef pref_family;
@@ -2121,46 +2108,46 @@ macfont_list (struct frame *f, Lisp_Object spec)
 
       families = mac_font_create_available_families ();
       if (families == NULL)
-        goto err;
+        goto err;
 
       families_count = CFArrayGetCount (families);
 
       /* Move preferred family to the front if exists.  */
       pref_family =
-        mac_font_create_preferred_family_for_attributes (attributes);
+        mac_font_create_preferred_family_for_attributes (attributes);
       if (pref_family)
-        {
-          pref_family_index =
-            CFArrayGetFirstIndexOfValue (families,
-                                         CFRangeMake (0, families_count),
-                                         pref_family);
-          CFRelease (pref_family);
-        }
+        {
+          pref_family_index =
+            CFArrayGetFirstIndexOfValue (families,
+                                         CFRangeMake (0, families_count),
+                                         pref_family);
+          CFRelease (pref_family);
+        }
       if (pref_family_index > 0)
-        {
-          CFMutableArrayRef mutable_families =
-            CFArrayCreateMutable (NULL, families_count, &kCFTypeArrayCallBacks);
-
-          if (mutable_families)
-            {
-              CFArrayAppendValue (mutable_families,
-                                  CFArrayGetValueAtIndex (families,
-                                                          pref_family_index));
-              CFArrayAppendArray (mutable_families, families,
-                                  CFRangeMake (0, pref_family_index));
-              if (pref_family_index + 1 < families_count)
-                CFArrayAppendArray (mutable_families, families,
-                                    CFRangeMake (pref_family_index + 1,
-                                                 families_count
-                                                 - (pref_family_index + 1)));
-              CFRelease (families);
-              families = mutable_families;
-            }
-        }
+        {
+          CFMutableArrayRef mutable_families =
+            CFArrayCreateMutable (NULL, families_count, &kCFTypeArrayCallBacks);
+
+          if (mutable_families)
+            {
+              CFArrayAppendValue (mutable_families,
+                                  CFArrayGetValueAtIndex (families,
+                                                          pref_family_index));
+              CFArrayAppendArray (mutable_families, families,
+                                  CFRangeMake (0, pref_family_index));
+              if (pref_family_index + 1 < families_count)
+                CFArrayAppendArray (mutable_families, families,
+                                    CFRangeMake (pref_family_index + 1,
+                                                 families_count
+                                                 - (pref_family_index + 1)));
+              CFRelease (families);
+              families = mutable_families;
+            }
+        }
     }
 
   charset = CFDictionaryGetValue (attributes,
-                                  MAC_FONT_CHARACTER_SET_ATTRIBUTE);
+                                  MAC_FONT_CHARACTER_SET_ATTRIBUTE);
   if (charset)
     {
       CFRetain (charset);
@@ -2170,11 +2157,11 @@ macfont_list (struct frame *f, Lisp_Object spec)
     {
       val = assq_no_quit (QCscript, AREF (spec, FONT_EXTRA_INDEX));
       if (! NILP (val))
-        {
-          val = assq_no_quit (XCDR (val), Vscript_representative_chars);
-          if (CONSP (val) && VECTORP (XCDR (val)))
-            chars = XCDR (val);
-        }
+        {
+          val = assq_no_quit (XCDR (val), Vscript_representative_chars);
+          if (CONSP (val) && VECTORP (XCDR (val)))
+            chars = XCDR (val);
+        }
       val = Qnil;
     }
 
@@ -2198,151 +2185,152 @@ macfont_list (struct frame *f, Lisp_Object spec)
       int j;
 
       CFDictionarySetValue (attributes, MAC_FONT_FAMILY_NAME_ATTRIBUTE,
-                            family_name);
+                            family_name);
       pat_desc = mac_font_descriptor_create_with_attributes (attributes);
       if (! pat_desc)
-        goto err;
+        goto err;
 
       /* CTFontDescriptorCreateMatchingFontDescriptors on Mac OS X
-         10.7 returns NULL if pat_desc represents the LastResort font.
-         So we use CTFontDescriptorCreateMatchingFontDescriptor (no
-         trailing "s") for such a font.  */
+         10.7 returns NULL if pat_desc represents the LastResort font.
+         So we use CTFontDescriptorCreateMatchingFontDescriptor (no
+         trailing "s") for such a font.  */
       if (!CFEqual (family_name, CFSTR ("LastResort")))
-       descs = mac_font_descriptor_create_matching_font_descriptors (pat_desc,
-                                                                     NULL);
+        descs = mac_font_descriptor_create_matching_font_descriptors (pat_desc,
+                                                                      NULL);
       else
-       {
-         FontDescriptorRef lr_desc =
-           mac_font_descriptor_create_matching_font_descriptor (pat_desc,
-                                                                NULL);
-         if (lr_desc)
-           {
-             descs = CFArrayCreate (NULL, (const void **) &lr_desc, 1,
-                                    &kCFTypeArrayCallBacks);
-             CFRelease (lr_desc);
-           }
-         else
-           descs = NULL;
-       }
+        {
+          FontDescriptorRef lr_desc =
+            mac_font_descriptor_create_matching_font_descriptor (pat_desc,
+                                                                 NULL);
+          if (lr_desc)
+            {
+              descs = CFArrayCreate (NULL, (const void **) &lr_desc, 1,
+                                     &kCFTypeArrayCallBacks);
+              CFRelease (lr_desc);
+            }
+          else
+            descs = NULL;
+        }
       CFRelease (pat_desc);
       if (! descs)
-       goto err;
+        goto err;
 
       descs_count = CFArrayGetCount (descs);
       if (descs_count == 0
-          || !macfont_supports_charset_and_languages_p (CFArrayGetValueAtIndex (descs, 0),
-                                                        charset, chars,
-                                                        languages))
-        {
-          CFRelease (descs);
-          continue;
-        }
+          || !macfont_supports_charset_and_languages_p (CFArrayGetValueAtIndex (descs, 0),
+                                                        charset, chars,
+                                                        languages))
+        {
+          CFRelease (descs);
+          continue;
+        }
 
       filtered_descs =
-        CFArrayCreateMutable (NULL, descs_count, &kCFTypeArrayCallBacks);
+        CFArrayCreateMutable (NULL, descs_count, &kCFTypeArrayCallBacks);
       traits_array = CFArrayCreateMutable (NULL, descs_count, NULL);
       for (j = 0; j < descs_count; j++)
-        {
-          FontDescriptorRef desc = CFArrayGetValueAtIndex (descs, j);
-          CFDictionaryRef dict;
-          CFNumberRef num;
-          FontSymbolicTraits sym_traits;
-
-          dict = mac_font_descriptor_copy_attribute (desc,
-                                                     MAC_FONT_TRAITS_ATTRIBUTE);
-          if (dict == NULL)
-            continue;
-
-          num = CFDictionaryGetValue (dict, MAC_FONT_SYMBOLIC_TRAIT);
-          CFRelease (dict);
-          if (num == NULL
-              || !cfnumber_get_font_symbolic_traits_value (num, &sym_traits))
-            continue;
-
-          if (spacing >= 0
-              && !(synth_sym_traits & MAC_FONT_TRAIT_MONO_SPACE)
-              && (((sym_traits & MAC_FONT_TRAIT_MONO_SPACE) != 0)
-                  != (spacing >= FONT_SPACING_MONO)))
-            continue;
-
-          /* Don't use a color bitmap font unless its family is
-             explicitly specified.  */
-          if ((sym_traits & MAC_FONT_TRAIT_COLOR_GLYPHS) && NILP (family))
-            continue;
-
-          if (j > 0
-              && !macfont_supports_charset_and_languages_p (desc, charset,
-                                                            chars, languages))
-            continue;
-
-          CFArrayAppendValue (filtered_descs, desc);
-          CFArrayAppendValue (traits_array,
-                              (const void *) (uintptr_t) sym_traits);
-        }
+        {
+          FontDescriptorRef desc = CFArrayGetValueAtIndex (descs, j);
+          CFDictionaryRef dict;
+          CFNumberRef num;
+          FontSymbolicTraits sym_traits;
+
+          dict = mac_font_descriptor_copy_attribute (desc,
+                                                     MAC_FONT_TRAITS_ATTRIBUTE);
+          if (dict == NULL)
+            continue;
+
+          num = CFDictionaryGetValue (dict, MAC_FONT_SYMBOLIC_TRAIT);
+          CFRelease (dict);
+          if (num == NULL
+              || !cfnumber_get_font_symbolic_traits_value (num, &sym_traits))
+            continue;
+
+          if (spacing >= 0
+              && !(synth_sym_traits & MAC_FONT_TRAIT_MONO_SPACE)
+              && (((sym_traits & MAC_FONT_TRAIT_MONO_SPACE) != 0)
+                  != (spacing >= FONT_SPACING_MONO)))
+            continue;
+
+          /* Don't use a color bitmap font unless its family is
+             explicitly specified.  */
+          if ((sym_traits & MAC_FONT_TRAIT_COLOR_GLYPHS) && NILP (family))
+            continue;
+
+          if (j > 0
+              && !macfont_supports_charset_and_languages_p (desc, charset,
+                                                            chars, languages))
+            continue;
+
+          CFArrayAppendValue (filtered_descs, desc);
+          CFArrayAppendValue (traits_array,
+                              (const void *) (uintptr_t) sym_traits);
+        }
 
       CFRelease (descs);
       descs = filtered_descs;
       descs_count = CFArrayGetCount (descs);
 
       for (j = 0; j < descs_count; j++)
-        {
-          FontDescriptorRef desc = CFArrayGetValueAtIndex (descs, j);
-          FontSymbolicTraits sym_traits =
-            ((FontSymbolicTraits) (uintptr_t)
-             CFArrayGetValueAtIndex (traits_array, j));
-          FontSymbolicTraits mask_min, mask_max, imask, bmask, mmask;
-
-          mask_min = ((synth_sym_traits ^ sym_traits)
-                      & (MAC_FONT_TRAIT_ITALIC | MAC_FONT_TRAIT_BOLD));
-          if (FONT_SLANT_NUMERIC (spec) < 0)
-            mask_min &= ~MAC_FONT_TRAIT_ITALIC;
-          if (FONT_WEIGHT_NUMERIC (spec) < 0)
-            mask_min &= ~MAC_FONT_TRAIT_BOLD;
-
-          mask_max = (synth_sym_traits & ~sym_traits);
-          /* Synthetic bold does not work for bitmap-only fonts on Mac
-             OS X 10.6.  */
-          if ((mask_min ^ mask_max) & MAC_FONT_TRAIT_BOLD)
-            {
-              CFNumberRef format =
-                mac_font_descriptor_copy_attribute (desc,
-                                                    MAC_FONT_FORMAT_ATTRIBUTE);
-
-              if (format)
-                {
-                  uint32_t format_val;
-
-                  if (CFNumberGetValue (format, kCFNumberSInt32Type,
-                                        &format_val)
-                      && format_val == MAC_FONT_FORMAT_BITMAP)
-                    mask_max &= ~MAC_FONT_TRAIT_BOLD;
-                }
-            }
-          if (spacing >= 0)
-            mask_min |= (mask_max & MAC_FONT_TRAIT_MONO_SPACE);
-
-          for (mmask = (mask_min & MAC_FONT_TRAIT_MONO_SPACE);
-               mmask <= (mask_max & MAC_FONT_TRAIT_MONO_SPACE);
-               mmask += MAC_FONT_TRAIT_MONO_SPACE)
-            for (bmask = (mask_min & MAC_FONT_TRAIT_BOLD);
-                 bmask <= (mask_max & MAC_FONT_TRAIT_BOLD);
-                 bmask += MAC_FONT_TRAIT_BOLD)
-              for (imask = (mask_min & MAC_FONT_TRAIT_ITALIC);
-                   imask <= (mask_max & MAC_FONT_TRAIT_ITALIC);
-                   imask += MAC_FONT_TRAIT_ITALIC)
-                {
-                  FontSymbolicTraits synth = (imask | bmask | mmask);
-
-                  if (synth == 0
-                      || j == macfont_closest_traits_index (traits_array,
-                                                            (sym_traits | synth)))
-                    {
-                      entity = macfont_descriptor_entity (desc, extra, synth);
-                      if (! NILP (entity))
-                        val = Fcons (entity, val);
-                    }
-                }
-        }
+        {
+          FontDescriptorRef desc = CFArrayGetValueAtIndex (descs, j);
+          FontSymbolicTraits sym_traits =
+            ((FontSymbolicTraits) (uintptr_t)
+             CFArrayGetValueAtIndex (traits_array, j));
+          FontSymbolicTraits mask_min, mask_max, imask, bmask, mmask;
+
+          mask_min = ((synth_sym_traits ^ sym_traits)
+                      & (MAC_FONT_TRAIT_ITALIC | MAC_FONT_TRAIT_BOLD));
+          if (FONT_SLANT_NUMERIC (spec) < 0)
+            mask_min &= ~MAC_FONT_TRAIT_ITALIC;
+          if (FONT_WEIGHT_NUMERIC (spec) < 0)
+            mask_min &= ~MAC_FONT_TRAIT_BOLD;
+
+          mask_max = (synth_sym_traits & ~sym_traits);
+          /* Synthetic bold does not work for bitmap-only fonts on Mac
+             OS X 10.6.  */
+          if ((mask_min ^ mask_max) & MAC_FONT_TRAIT_BOLD)
+            {
+              CFNumberRef format =
+                mac_font_descriptor_copy_attribute (desc,
+                                                    MAC_FONT_FORMAT_ATTRIBUTE);
+
+              if (format)
+                {
+                  uint32_t format_val;
+
+                  if (CFNumberGetValue (format, kCFNumberSInt32Type,
+                                        &format_val)
+                      && format_val == MAC_FONT_FORMAT_BITMAP)
+                    mask_max &= ~MAC_FONT_TRAIT_BOLD;
+                }
+            }
+          if (spacing >= 0)
+            mask_min |= (mask_max & MAC_FONT_TRAIT_MONO_SPACE);
+
+          for (mmask = (mask_min & MAC_FONT_TRAIT_MONO_SPACE);
+               mmask <= (mask_max & MAC_FONT_TRAIT_MONO_SPACE);
+               mmask += MAC_FONT_TRAIT_MONO_SPACE)
+            for (bmask = (mask_min & MAC_FONT_TRAIT_BOLD);
+                 bmask <= (mask_max & MAC_FONT_TRAIT_BOLD);
+                 bmask += MAC_FONT_TRAIT_BOLD)
+              for (imask = (mask_min & MAC_FONT_TRAIT_ITALIC);
+                   imask <= (mask_max & MAC_FONT_TRAIT_ITALIC);
+                   imask += MAC_FONT_TRAIT_ITALIC)
+                {
+                  FontSymbolicTraits synth = (imask | bmask | mmask);
+
+                  if (synth == 0
+                      || macfont_closest_traits_index_p (traits_array,
+                                                         (sym_traits | synth),
+                                                         j))
+                    {
+                      entity = macfont_descriptor_entity (desc, extra, synth);
+                      if (! NILP (entity))
+                        val = Fcons (entity, val);
+                    }
+                }
+        }
 
       CFRelease (traits_array);
       CFRelease (descs);
@@ -2384,13 +2372,13 @@ macfont_match (struct frame * frame, Lisp_Object spec)
   if (pat_desc)
     {
       desc = mac_font_descriptor_create_matching_font_descriptor (pat_desc,
-                                                                  NULL);
+                                                                  NULL);
       CFRelease (pat_desc);
     }
   if (desc)
     {
       entity = macfont_descriptor_entity (desc, AREF (spec, FONT_EXTRA_INDEX),
-                                          0);
+                                          0);
       CFRelease (desc);
     }
   unblock_input ();
@@ -2413,7 +2401,7 @@ macfont_list_family (struct frame *frame)
       CFIndex i, count = CFArrayGetCount (families);
 
       for (i = 0; i < count; i++)
-        list = Fcons (macfont_intern_prop_cfstring (CFArrayGetValueAtIndex (families, i)), list);
+        list = Fcons (macfont_intern_prop_cfstring (CFArrayGetValueAtIndex (families, i)), list);
       CFRelease (families);
     }
 
@@ -2426,7 +2414,7 @@ static void
 macfont_free_entity (Lisp_Object entity)
 {
   Lisp_Object val = assq_no_quit (QCfont_entity,
-                                  AREF (entity, FONT_EXTRA_INDEX));
+                                  AREF (entity, FONT_EXTRA_INDEX));
   CFStringRef name = XSAVE_POINTER (XCDR (val), 0);
 
   block_input ();
@@ -2444,7 +2432,8 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
   int size;
   FontRef macfont;
   FontSymbolicTraits sym_traits;
-  int i, total_width;
+  char name[256];
+  int len, i, total_width;
   CGGlyph glyph;
   CGFloat ascent, descent, leading;
 
@@ -2472,7 +2461,7 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
     return Qnil;
 
   font_object = font_build_object (VECSIZE (struct macfont_info),
-                                   Qmac_ct, entity, size);
+                                   Qmac_ct, entity, size);
   font = XFONT_OBJECT (font_object);
   font->pixel_size = size;
   font->driver = &macfont_driver;
@@ -2487,7 +2476,7 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
   val = assq_no_quit (QCdestination, AREF (entity, FONT_EXTRA_INDEX));
   if (CONSP (val) && EQ (XCDR (val), make_number (1)))
     macfont_info->screen_font = mac_screen_font_create_with_name (font_name,
-                                                                  size);
+                                                                  size);
   else
     macfont_info->screen_font = NULL;
   macfont_info->cache = macfont_lookup_cache (font_name);
@@ -2507,8 +2496,8 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
   if (sym_traits & MAC_FONT_TRAIT_MONO_SPACE)
     macfont_info->spacing = MACFONT_SPACING_MONO;
   else if (INTEGERP (AREF (entity, FONT_SPACING_INDEX))
-           && (XINT (AREF (entity, FONT_SPACING_INDEX))
-               == FONT_SPACING_SYNTHETIC_MONO))
+           && (XINT (AREF (entity, FONT_SPACING_INDEX))
+               == FONT_SPACING_SYNTHETIC_MONO))
     macfont_info->spacing = MACFONT_SPACING_SYNTHETIC_MONO;
   if (macfont_info->synthetic_italic_p || macfont_info->synthetic_bold_p)
     macfont_info->antialias = MACFONT_ANTIALIAS_ON;
@@ -2516,8 +2505,8 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
     {
       val = assq_no_quit (QCantialias, AREF (entity, FONT_EXTRA_INDEX));
       if (CONSP (val))
-        macfont_info->antialias =
-          NILP (XCDR (val)) ? MACFONT_ANTIALIAS_OFF : MACFONT_ANTIALIAS_ON;
+        macfont_info->antialias =
+          NILP (XCDR (val)) ? MACFONT_ANTIALIAS_OFF : MACFONT_ANTIALIAS_ON;
     }
   macfont_info->color_bitmap_p = 0;
   if (sym_traits & MAC_FONT_TRAIT_COLOR_GLYPHS)
@@ -2535,7 +2524,7 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
     {
       glyph = macfont_get_glyph_for_character (font, ' ' + i);
       if (glyph == kCGFontIndexInvalid)
-        break;
+        break;
       total_width += macfont_glyph_extents (font, glyph, NULL, NULL, 0);
     }
   if (i == 95)
@@ -2544,8 +2533,8 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
     font->average_width = font->space_width; /* XXX */
 
   if (!(macfont_info->screen_font
-        && mac_screen_font_get_metrics (macfont_info->screen_font,
-                                        &ascent, &descent, &leading)))
+        && mac_screen_font_get_metrics (macfont_info->screen_font,
+                                        &ascent, &descent, &leading)))
     {
       CFStringRef family_name;
 
@@ -2553,21 +2542,21 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
       descent = mac_font_get_descent (macfont);
       leading = mac_font_get_leading (macfont);
       /* AppKit and WebKit do some adjustment to the heights of
-         Courier, Helvetica, and Times.  */
+         Courier, Helvetica, and Times.  */
       family_name = mac_font_copy_family_name (macfont);
       if (family_name)
-        {
-          if (CFEqual (family_name, CFSTR ("Courier"))
-              || CFEqual (family_name, CFSTR ("Helvetica"))
-              || CFEqual (family_name, CFSTR ("Times")))
-            ascent += (ascent + descent) * .15f;
-          else if (CFStringHasPrefix (family_name, CFSTR ("Hiragino")))
-            {
-              leading *= .25f;
-              ascent += leading;
-            }
-          CFRelease (family_name);
-        }
+        {
+          if (CFEqual (family_name, CFSTR ("Courier"))
+              || CFEqual (family_name, CFSTR ("Helvetica"))
+              || CFEqual (family_name, CFSTR ("Times")))
+            ascent += (ascent + descent) * .15f;
+          else if (CFStringHasPrefix (family_name, CFSTR ("Hiragino")))
+            {
+              leading *= .25f;
+              ascent += leading;
+            }
+          CFRelease (family_name);
+        }
     }
   font->ascent = ascent + 0.5f;
   val = assq_no_quit (QCminspace, AREF (entity, FONT_EXTRA_INDEX));
@@ -2598,20 +2587,25 @@ static void
 macfont_close (struct font *font)
 {
   struct macfont_info *macfont_info = (struct macfont_info *) font;
-  int i;
 
-  block_input ();
-  CFRelease (macfont_info->macfont);
-  CGFontRelease (macfont_info->cgfont);
-  if (macfont_info->screen_font)
-    CFRelease (macfont_info->screen_font);
-  macfont_release_cache (macfont_info->cache);
-  for (i = 0; i < macfont_info->metrics_nrows; i++)
-    if (macfont_info->metrics[i])
-      xfree (macfont_info->metrics[i]);
-  if (macfont_info->metrics)
-    xfree (macfont_info->metrics);
-  unblock_input ();
+  if (macfont_info->cache)
+    {
+      int i;
+
+      block_input ();
+      CFRelease (macfont_info->macfont);
+      CGFontRelease (macfont_info->cgfont);
+      if (macfont_info->screen_font)
+        CFRelease (macfont_info->screen_font);
+      macfont_release_cache (macfont_info->cache);
+      for (i = 0; i < macfont_info->metrics_nrows; i++)
+        if (macfont_info->metrics[i])
+          xfree (macfont_info->metrics[i]);
+      if (macfont_info->metrics)
+        xfree (macfont_info->metrics);
+      macfont_info->cache = NULL;
+      unblock_input ();
+    }
 }
 
 static int
@@ -2653,9 +2647,9 @@ macfont_encode_char (struct font *font, int c)
   return glyph != kCGFontIndexInvalid ? glyph : FONT_INVALID_CODE;
 }
 
-static int
+static void
 macfont_text_extents (struct font *font, unsigned int *code, int nglyphs,
-                      struct font_metrics *metrics)
+                      struct font_metrics *metrics)
 {
   int width, i;
 
@@ -2665,32 +2659,30 @@ macfont_text_extents (struct font *font, unsigned int *code, int nglyphs,
     {
       struct font_metrics m;
       int w = macfont_glyph_extents (font, code[i], metrics ? &m : NULL,
-                                     NULL, 0);
+                                     NULL, 0);
 
       if (metrics)
-        {
-          if (width + m.lbearing < metrics->lbearing)
-            metrics->lbearing = width + m.lbearing;
-          if (width + m.rbearing > metrics->rbearing)
-            metrics->rbearing = width + m.rbearing;
-          if (m.ascent > metrics->ascent)
-            metrics->ascent = m.ascent;
-          if (m.descent > metrics->descent)
-            metrics->descent = m.descent;
-        }
+        {
+          if (width + m.lbearing < metrics->lbearing)
+            metrics->lbearing = width + m.lbearing;
+          if (width + m.rbearing > metrics->rbearing)
+            metrics->rbearing = width + m.rbearing;
+          if (m.ascent > metrics->ascent)
+            metrics->ascent = m.ascent;
+          if (m.descent > metrics->descent)
+            metrics->descent = m.descent;
+        }
       width += w;
     }
   unblock_input ();
 
   if (metrics)
     metrics->width = width;
-
-  return width;
 }
 
 static int
 macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
-              bool with_background)
+              bool with_background)
 {
   struct frame * f = s->f;
   struct macfont_info *macfont_info = (struct macfont_info *) s->font;
@@ -2702,7 +2694,7 @@ macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
   bool no_antialias_p =
     (macfont_info->antialias == MACFONT_ANTIALIAS_OFF
      || (macfont_info->antialias == MACFONT_ANTIALIAS_DEFAULT
-         && font_size <= macfont_antialias_threshold));
+         && font_size <= macfont_antialias_threshold));
   int len = to - from;
   struct face *face = s->face;
   CGContextRef context;
@@ -2712,29 +2704,29 @@ macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
   if (with_background)
     background_rect = CGRectMake (x, y - FONT_BASE (s->font),
                                   s->width, FONT_HEIGHT (s->font));
- else
+  else
     background_rect = CGRectNull;
-  
+
   text_position = CGPointMake (x, -y);
   glyphs = xmalloc (sizeof (CGGlyph) * len);
   {
-    CGFloat advance_delta;
+    CGFloat advance_delta = 0;
     int i;
     CGFloat total_width = 0;
 
     positions = xmalloc (sizeof (CGPoint) * len);
     for (i = 0; i < len; i++)
       {
-        int width;
-
-        glyphs[i] = s->char2b[from + i];
-        width = (s->padding_p ? 1
-                 : macfont_glyph_extents (s->font, glyphs[i],
-                                          NULL, &advance_delta,
-                                          no_antialias_p));
-        positions[i].x = total_width + advance_delta;
-        positions[i].y = 0;
-        total_width += width;
+        int width;
+
+        glyphs[i] = s->char2b[from + i];
+        width = (s->padding_p ? 1
+                 : macfont_glyph_extents (s->font, glyphs[i],
+                                          NULL, &advance_delta,
+                                          no_antialias_p));
+        positions[i].x = total_width + advance_delta;
+        positions[i].y = 0;
+        total_width += width;
       }
   }
 
@@ -2743,7 +2735,7 @@ macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
 
   if (!CGRectIsNull (background_rect))
     {
-      if (s->hl == DRAW_MOUSE_FACE) 
+      if (s->hl == DRAW_MOUSE_FACE)
         {
           face = FACE_FROM_ID (s->f, MOUSE_HL_INFO (s->f)->mouse_face_face_id);
           if (!face)
@@ -2756,20 +2748,21 @@ macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
   if (macfont_info->cgfont)
     {
       CGAffineTransform atfm;
+
       CGContextScaleCTM (context, 1, -1);
       CG_SET_FILL_COLOR_WITH_FACE_FOREGROUND (context, face, s->f);
       if (macfont_info->synthetic_italic_p)
-        atfm = synthetic_italic_atfm;
+        atfm = synthetic_italic_atfm;
       else
-        atfm = CGAffineTransformIdentity;
+        atfm = CGAffineTransformIdentity;
       if (macfont_info->synthetic_bold_p)
-        {
-          CGContextSetTextDrawingMode (context, kCGTextFillStroke);
-          CGContextSetLineWidth (context, synthetic_bold_factor * font_size);
-          CG_SET_STROKE_COLOR_WITH_FACE_FOREGROUND (context, face, f);
-        }
+        {
+          CGContextSetTextDrawingMode (context, kCGTextFillStroke);
+          CGContextSetLineWidth (context, synthetic_bold_factor * font_size);
+          CG_SET_STROKE_COLOR_WITH_FACE_FOREGROUND (context, face, f);
+        }
       if (no_antialias_p)
-        CGContextSetShouldAntialias (context, false);
+        CGContextSetShouldAntialias (context, false);
 
       CGContextSetTextMatrix (context, atfm);
       CGContextSetTextPosition (context, text_position.x, text_position.y);
@@ -2777,23 +2770,23 @@ macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
       if (macfont_info->color_bitmap_p
 #if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
-          && CTFontDrawGlyphs != NULL
+          && CTFontDrawGlyphs != NULL
 #endif
-          )
-        {
-          if (len > 0)
-            {
-              CTFontDrawGlyphs (macfont_info->macfont, glyphs, positions, len,
+          )
+        {
+          if (len > 0)
+            {
+              CTFontDrawGlyphs (macfont_info->macfont, glyphs, positions, len,
                                 context);
-            }
-        }
+            }
+        }
       else
 #endif  /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 */
-        {
-          CGContextSetFont (context, macfont_info->cgfont);
-          CGContextSetFontSize (context, font_size);
-          CGContextShowGlyphsAtPositions (context, glyphs, positions, len);
-        }
+        {
+          CGContextSetFont (context, macfont_info->cgfont);
+          CGContextSetFontSize (context, font_size);
+          CGContextShowGlyphsAtPositions (context, glyphs, positions, len);
+        }
     }
 
 
@@ -2831,9 +2824,9 @@ macfont_shape (Lisp_Object lgstring)
       Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
 
       if (NILP (lglyph))
-        break;
+        break;
       if (LGLYPH_CHAR (lglyph) >= 0x10000)
-        nonbmp_len++;
+        nonbmp_len++;
     }
 
   len = i;
@@ -2848,25 +2841,25 @@ macfont_shape (Lisp_Object lgstring)
       UTF32Char c = LGLYPH_CHAR (LGSTRING_GLYPH (lgstring, i));
 
       if (macfont_store_utf32char_to_unichars (c, unichars + i + j) > 1)
-        {
-          nonbmp_indices[j] = i + j;
-          j++;
-        }
+        {
+          nonbmp_indices[j] = i + j;
+          j++;
+        }
     }
   nonbmp_indices[j] = len + j;  /* sentinel */
 
   block_input ();
 
   string = CFStringCreateWithCharactersNoCopy (NULL, unichars, len + nonbmp_len,
-                                               kCFAllocatorNull);
+                                               kCFAllocatorNull);
   if (string)
     {
       glyph_layouts = alloca (sizeof (struct mac_glyph_layout) * glyph_len);
       if (macfont_info->screen_font)
-        used = mac_screen_font_shape (macfont_info->screen_font, string,
-                                      glyph_layouts, glyph_len);
+        used = mac_screen_font_shape (macfont_info->screen_font, string,
+                                      glyph_layouts, glyph_len);
       else
-        used = mac_font_shape (macfont, string, glyph_layouts, glyph_len);
+        used = mac_font_shape (macfont, string, glyph_layouts, glyph_len);
       CFRelease (string);
     }
 
@@ -2886,40 +2879,40 @@ macfont_shape (Lisp_Object lgstring)
       int xoff, yoff, wadjust;
 
       if (NILP (lglyph))
-        {
-          lglyph = Fmake_vector (make_number (LGLYPH_SIZE), Qnil);
-          LGSTRING_SET_GLYPH (lgstring, i, lglyph);
-        }
+        {
+          lglyph = Fmake_vector (make_number (LGLYPH_SIZE), Qnil);
+          LGSTRING_SET_GLYPH (lgstring, i, lglyph);
+        }
 
       from = gl->comp_range.location;
       /* Convert UTF-16 index to UTF-32.  */
       j = 0;
       while (nonbmp_indices[j] < from)
-        j++;
+        j++;
       from -= j;
       LGLYPH_SET_FROM (lglyph, from);
 
       to = gl->comp_range.location + gl->comp_range.length;
       /* Convert UTF-16 index to UTF-32.  */
       while (nonbmp_indices[j] < to)
-        j++;
+        j++;
       to -= j;
       LGLYPH_SET_TO (lglyph, to - 1);
 
       /* LGLYPH_CHAR is used in `describe-char' for checking whether
-         the composition is trivial.  */
+         the composition is trivial.  */
       {
-        UTF32Char c;
-
-        if (unichars[gl->string_index] >= 0xD800
-            && unichars[gl->string_index] < 0xDC00)
-          c = (((unichars[gl->string_index] - 0xD800) << 10)
-               + (unichars[gl->string_index + 1] - 0xDC00) + 0x10000);
-        else
-          c = unichars[gl->string_index];
-        if (macfont_get_glyph_for_character (font, c) != gl->glyph_id)
-          c = 0;
-        LGLYPH_SET_CHAR (lglyph, c);
+        UTF32Char c;
+
+        if (unichars[gl->string_index] >= 0xD800
+            && unichars[gl->string_index] < 0xDC00)
+          c = (((unichars[gl->string_index] - 0xD800) << 10)
+               + (unichars[gl->string_index + 1] - 0xDC00) + 0x10000);
+        else
+          c = unichars[gl->string_index];
+        if (macfont_get_glyph_for_character (font, c) != gl->glyph_id)
+          c = 0;
+        LGLYPH_SET_CHAR (lglyph, c);
       }
 
       {
@@ -2938,15 +2931,15 @@ macfont_shape (Lisp_Object lgstring)
       yoff = lround (- gl->baseline_delta);
       wadjust = lround (gl->advance);
       if (xoff != 0 || yoff != 0 || wadjust != metrics.width)
-        {
-          Lisp_Object vec;
+        {
+          Lisp_Object vec;
 
-          vec = Fmake_vector (make_number (3), Qnil);
-          ASET (vec, 0, make_number (xoff));
-          ASET (vec, 1, make_number (yoff));
-          ASET (vec, 2, make_number (wadjust));
-          LGLYPH_SET_ADJUSTMENT (lglyph, vec);
-        }
+          vec = Fmake_vector (make_number (3), Qnil);
+          ASET (vec, 0, make_number (xoff));
+          ASET (vec, 1, make_number (yoff));
+          ASET (vec, 2, make_number (wadjust));
+          LGLYPH_SET_ADJUSTMENT (lglyph, vec);
+        }
     }
 
   unblock_input ();
@@ -2969,7 +2962,7 @@ struct uvs_table
   UInt32 length, num_var_selector_records;
   struct variation_selector_record variation_selector_records[1];
 };
-#define SIZEOF_UVS_TABLE_HEADER \
+#define SIZEOF_UVS_TABLE_HEADER                                         \
   (sizeof (struct uvs_table) - sizeof (struct variation_selector_record))
 
 struct unicode_value_range
@@ -2981,7 +2974,7 @@ struct default_uvs_table {
   UInt32 num_unicode_value_ranges;
   struct unicode_value_range unicode_value_ranges[1];
 };
-#define SIZEOF_DEFAULT_UVS_TABLE_HEADER \
+#define SIZEOF_DEFAULT_UVS_TABLE_HEADER                                 \
   (sizeof (struct default_uvs_table) - sizeof (struct unicode_value_range))
 
 struct uvs_mapping
@@ -2994,7 +2987,7 @@ struct non_default_uvs_table
   UInt32 num_uvs_mappings;
   struct uvs_mapping uvs_mappings[1];
 };
-#define SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER \
+#define SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER                             \
   (sizeof (struct non_default_uvs_table) - sizeof (struct uvs_mapping))
 #pragma pack(pop)
 
@@ -3026,98 +3019,98 @@ mac_font_copy_uvs_table (FontRef font)
 
 #if __LP64__
       if (CFDataGetLength (cmap_table) > UINT32_MAX)
-        goto finish;
+        goto finish;
 #endif
 
       cmap_len = CFDataGetLength (cmap_table);
       if (sizeof_sfntCMapHeader > cmap_len)
-        goto finish;
+        goto finish;
 
       ntables = BUINT16_VALUE (cmap->numTables);
       if (ntables > ((cmap_len - sizeof_sfntCMapHeader)
-                     / sizeof_sfntCMapEncoding))
-        goto finish;
+                     / sizeof_sfntCMapEncoding))
+        goto finish;
 
       for (i = 0; i < ntables; i++)
-        if ((BUINT16_VALUE (cmap->encoding[i].platformID)
-             == kFontUnicodePlatform)
-            && (BUINT16_VALUE (cmap->encoding[i].scriptID)
-                == 5)) /* kFontUnicodeV4_0VariationSequenceSemantics */
-          {
-            uvs_offset = BUINT32_VALUE (cmap->encoding[i].offset);
-            break;
-          }
+        if ((BUINT16_VALUE (cmap->encoding[i].platformID)
+             == kFontUnicodePlatform)
+            && (BUINT16_VALUE (cmap->encoding[i].scriptID)
+                == 5)) /* kFontUnicodeV4_0VariationSequenceSemantics */
+          {
+            uvs_offset = BUINT32_VALUE (cmap->encoding[i].offset);
+            break;
+          }
       if (i == ntables
-          || uvs_offset > cmap_len
-          || SIZEOF_UVS_TABLE_HEADER > cmap_len - uvs_offset)
-        goto finish;
+          || uvs_offset > cmap_len
+          || SIZEOF_UVS_TABLE_HEADER > cmap_len - uvs_offset)
+        goto finish;
 
       uvs = (struct uvs_table *) ((UInt8 *) cmap + uvs_offset);
       uvs_len = BUINT32_VALUE (uvs->length);
       if (uvs_len > cmap_len - uvs_offset
-          || SIZEOF_UVS_TABLE_HEADER > uvs_len)
-        goto finish;
+          || SIZEOF_UVS_TABLE_HEADER > uvs_len)
+        goto finish;
 
       if (BUINT16_VALUE (uvs->format) != 14)
-        goto finish;
+        goto finish;
 
       nrecords = BUINT32_VALUE (uvs->num_var_selector_records);
       if (nrecords > ((uvs_len - SIZEOF_UVS_TABLE_HEADER)
-                      / sizeof (struct variation_selector_record)))
-        goto finish;
+                      / sizeof (struct variation_selector_record)))
+        goto finish;
 
       records = uvs->variation_selector_records;
       for (i = 0; i < nrecords; i++)
-        {
-          UInt32 default_uvs_offset, non_default_uvs_offset;
-
-          default_uvs_offset = BUINT32_VALUE (records[i].default_uvs_offset);
-          if (default_uvs_offset)
-            {
-              struct default_uvs_table *default_uvs;
-              UInt32 nranges;
-
-              if (default_uvs_offset > uvs_len
-                  || (SIZEOF_DEFAULT_UVS_TABLE_HEADER
-                      > uvs_len - default_uvs_offset))
-                goto finish;
-
-              default_uvs = ((struct default_uvs_table *)
-                             ((UInt8 *) uvs + default_uvs_offset));
-              nranges = BUINT32_VALUE (default_uvs->num_unicode_value_ranges);
-              if (nranges > ((uvs_len - default_uvs_offset
-                              - SIZEOF_DEFAULT_UVS_TABLE_HEADER)
-                             / sizeof (struct unicode_value_range)))
-                goto finish;
-              /* Now 2 * nranges can't overflow, so we can safely use
-                 `(lo + hi) / 2' instead of `lo + (hi - lo) / 2' in
-                 mac_font_get_glyphs_for_variants.  */
-            }
-
-          non_default_uvs_offset =
-            BUINT32_VALUE (records[i].non_default_uvs_offset);
-          if (non_default_uvs_offset)
-            {
-              struct non_default_uvs_table *non_default_uvs;
-              UInt32 nmappings;
-
-              if (non_default_uvs_offset > uvs_len
-                  || (SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER
-                      > uvs_len - non_default_uvs_offset))
-                goto finish;
-
-              non_default_uvs = ((struct non_default_uvs_table *)
-                                 ((UInt8 *) uvs + non_default_uvs_offset));
-              nmappings = BUINT32_VALUE (non_default_uvs->num_uvs_mappings);
-              if (nmappings > ((uvs_len - non_default_uvs_offset
-                                - SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER)
-                               / sizeof (struct uvs_mapping)))
-                goto finish;
-              /* Now 2 * nmappings can't overflow, so we can safely
-                 use `(lo + hi) / 2' instead of `lo + (hi - lo) / 2'
-                 in mac_font_get_glyphs_for_variants.  */
-            }
-        }
+        {
+          UInt32 default_uvs_offset, non_default_uvs_offset;
+
+          default_uvs_offset = BUINT32_VALUE (records[i].default_uvs_offset);
+          if (default_uvs_offset)
+            {
+              struct default_uvs_table *default_uvs;
+              UInt32 nranges;
+
+              if (default_uvs_offset > uvs_len
+                  || (SIZEOF_DEFAULT_UVS_TABLE_HEADER
+                      > uvs_len - default_uvs_offset))
+                goto finish;
+
+              default_uvs = ((struct default_uvs_table *)
+                             ((UInt8 *) uvs + default_uvs_offset));
+              nranges = BUINT32_VALUE (default_uvs->num_unicode_value_ranges);
+              if (nranges > ((uvs_len - default_uvs_offset
+                              - SIZEOF_DEFAULT_UVS_TABLE_HEADER)
+                             / sizeof (struct unicode_value_range)))
+                goto finish;
+              /* Now 2 * nranges can't overflow, so we can safely use
+                 `(lo + hi) / 2' instead of `lo + (hi - lo) / 2' in
+                 mac_font_get_glyphs_for_variants.  */
+            }
+
+          non_default_uvs_offset =
+            BUINT32_VALUE (records[i].non_default_uvs_offset);
+          if (non_default_uvs_offset)
+            {
+              struct non_default_uvs_table *non_default_uvs;
+              UInt32 nmappings;
+
+              if (non_default_uvs_offset > uvs_len
+                  || (SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER
+                      > uvs_len - non_default_uvs_offset))
+                goto finish;
+
+              non_default_uvs = ((struct non_default_uvs_table *)
+                                 ((UInt8 *) uvs + non_default_uvs_offset));
+              nmappings = BUINT32_VALUE (non_default_uvs->num_uvs_mappings);
+              if (nmappings > ((uvs_len - non_default_uvs_offset
+                                - SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER)
+                               / sizeof (struct uvs_mapping)))
+                goto finish;
+              /* Now 2 * nmappings can't overflow, so we can safely
+                 use `(lo + hi) / 2' instead of `lo + (hi - lo) / 2'
+                 in mac_font_get_glyphs_for_variants.  */
+            }
+        }
 
       uvs_table = CFDataCreate (NULL, (UInt8 *) uvs, uvs_len);
 
@@ -3140,18 +3133,16 @@ mac_font_copy_uvs_table (FontRef font)
 
 static void
 mac_font_get_glyphs_for_variants (CFDataRef uvs_table, UTF32Char c,
-                                  const UTF32Char selectors[], CGGlyph glyphs[],
-                                  CFIndex count)
+                                  const UTF32Char selectors[], CGGlyph glyphs[],
+                                  CFIndex count)
 {
   struct uvs_table *uvs = (struct uvs_table *) CFDataGetBytePtr (uvs_table);
   struct variation_selector_record *records = uvs->variation_selector_records;
   CFIndex i;
   UInt32 ir, nrecords;
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
   dispatch_queue_t queue =
     dispatch_get_global_queue (DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
   dispatch_group_t group = dispatch_group_create ();
-#endif
 
   nrecords = BUINT32_VALUE (uvs->num_var_selector_records);
   i = 0;
@@ -3161,86 +3152,80 @@ mac_font_get_glyphs_for_variants (CFDataRef uvs_table, UTF32Char c,
       UInt32 default_uvs_offset, non_default_uvs_offset;
 
       if (selectors[i] < BUINT24_VALUE (records[ir].var_selector))
-        {
-          glyphs[i++] = kCGFontIndexInvalid;
-          continue;
-        }
+        {
+          glyphs[i++] = kCGFontIndexInvalid;
+          continue;
+        }
       else if (selectors[i] > BUINT24_VALUE (records[ir].var_selector))
-        {
-          ir++;
-          continue;
-        }
+        {
+          ir++;
+          continue;
+        }
 
       /* selectors[i] == BUINT24_VALUE (records[ir].var_selector) */
       default_uvs_offset = BUINT32_VALUE (records[ir].default_uvs_offset);
       non_default_uvs_offset =
-        BUINT32_VALUE (records[ir].non_default_uvs_offset);
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
+        BUINT32_VALUE (records[ir].non_default_uvs_offset);
       dispatch_group_async (group, queue, ^{
-#endif
-          glyphs[i] = kCGFontIndexInvalid;
-
-          if (default_uvs_offset)
-            {
-              struct default_uvs_table *default_uvs =
-                (struct default_uvs_table *) ((UInt8 *) uvs
-                                              + default_uvs_offset);
-              struct unicode_value_range *ranges =
-                default_uvs->unicode_value_ranges;
-              UInt32 lo, hi;
-
-              lo = 0;
-              hi = BUINT32_VALUE (default_uvs->num_unicode_value_ranges);
-              while (lo < hi)
-                {
-                  UInt32 mid = (lo + hi) / 2;
-
-                  if (c < BUINT24_VALUE (ranges[mid].start_unicode_value))
-                    hi = mid;
-                  else
-                    lo = mid + 1;
-                }
-              if (hi > 0
-                  && (c <= (BUINT24_VALUE (ranges[hi - 1].start_unicode_value)
-                            + BUINT8_VALUE (ranges[hi - 1].additional_count))))
-                glyphs[i] = 0;
-            }
-
-          if (glyphs[i] == kCGFontIndexInvalid && non_default_uvs_offset)
-            {
-              struct non_default_uvs_table *non_default_uvs =
-                (struct non_default_uvs_table *) ((UInt8 *) uvs
-                                                  + non_default_uvs_offset);
-              struct uvs_mapping *mappings = non_default_uvs->uvs_mappings;
-              UInt32 lo, hi;
-
-              lo = 0;
-              hi = BUINT32_VALUE (non_default_uvs->num_uvs_mappings);
-              while (lo < hi)
-                {
-                  UInt32 mid = (lo + hi) / 2;
-
-                  if (c < BUINT24_VALUE (mappings[mid].unicode_value))
-                    hi = mid;
-                  else
-                    lo = mid + 1;
-                }
-              if (hi > 0 &&
-                  BUINT24_VALUE (mappings[hi - 1].unicode_value) == c)
-                glyphs[i] = BUINT16_VALUE (mappings[hi - 1].glyph_id);
-            }
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
-        });
-#endif
+          glyphs[i] = kCGFontIndexInvalid;
+
+          if (default_uvs_offset)
+            {
+              struct default_uvs_table *default_uvs =
+                (struct default_uvs_table *) ((UInt8 *) uvs
+                                              + default_uvs_offset);
+              struct unicode_value_range *ranges =
+                default_uvs->unicode_value_ranges;
+              UInt32 lo, hi;
+
+              lo = 0;
+              hi = BUINT32_VALUE (default_uvs->num_unicode_value_ranges);
+              while (lo < hi)
+                {
+                  UInt32 mid = (lo + hi) / 2;
+
+                  if (c < BUINT24_VALUE (ranges[mid].start_unicode_value))
+                    hi = mid;
+                  else
+                    lo = mid + 1;
+                }
+              if (hi > 0
+                  && (c <= (BUINT24_VALUE (ranges[hi - 1].start_unicode_value)
+                            + BUINT8_VALUE (ranges[hi - 1].additional_count))))
+                glyphs[i] = 0;
+            }
+
+          if (glyphs[i] == kCGFontIndexInvalid && non_default_uvs_offset)
+            {
+              struct non_default_uvs_table *non_default_uvs =
+                (struct non_default_uvs_table *) ((UInt8 *) uvs
+                                                  + non_default_uvs_offset);
+              struct uvs_mapping *mappings = non_default_uvs->uvs_mappings;
+              UInt32 lo, hi;
+
+              lo = 0;
+              hi = BUINT32_VALUE (non_default_uvs->num_uvs_mappings);
+              while (lo < hi)
+                {
+                  UInt32 mid = (lo + hi) / 2;
+
+                  if (c < BUINT24_VALUE (mappings[mid].unicode_value))
+                    hi = mid;
+                  else
+                    lo = mid + 1;
+                }
+              if (hi > 0 &&
+                  BUINT24_VALUE (mappings[hi - 1].unicode_value) == c)
+                glyphs[i] = BUINT16_VALUE (mappings[hi - 1].glyph_id);
+            }
+        });
       i++;
       ir++;
     }
   while (i < count)
     glyphs[i++] = kCGFontIndexInvalid;
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
   dispatch_group_wait (group, DISPATCH_TIME_FOREVER);
   dispatch_release (group);
-#endif
 }
 
 static int
@@ -3259,26 +3244,26 @@ macfont_variation_glyphs (struct font *font, int c, unsigned variations[256])
       CGGlyph glyphs[256];
 
       for (i = 0; i < 16; i++)
-        selectors[i] = 0xFE00 + i;
+        selectors[i] = 0xFE00 + i;
       for (; i < 256; i++)
-        selectors[i] = 0xE0100 + (i - 16);
+        selectors[i] = 0xE0100 + (i - 16);
       mac_font_get_glyphs_for_variants (uvs_table, c, selectors, glyphs, 256);
       for (i = 0; i < 256; i++)
-        {
-          CGGlyph glyph = glyphs[i];
-
-          if (uvs_collection != MAC_CHARACTER_COLLECTION_IDENTITY_MAPPING
-              && glyph != kCGFontIndexInvalid)
-            glyph = macfont_get_glyph_for_cid (font, uvs_collection, glyph);
-          if (glyph == kCGFontIndexInvalid)
-            variations[i] = 0;
-          else
-            {
-              variations[i] = (glyph ? glyph
-                               : macfont_get_glyph_for_character (font, c));
-              n++;
-            }
-        }
+        {
+          CGGlyph glyph = glyphs[i];
+
+          if (uvs_collection != MAC_CHARACTER_COLLECTION_IDENTITY_MAPPING
+              && glyph != kCGFontIndexInvalid)
+            glyph = macfont_get_glyph_for_cid (font, uvs_collection, glyph);
+          if (glyph == kCGFontIndexInvalid)
+            variations[i] = 0;
+          else
+            {
+              variations[i] = (glyph ? glyph
+                               : macfont_get_glyph_for_character (font, c));
+              n++;
+            }
+        }
     }
   unblock_input ();
 
@@ -3306,7 +3291,7 @@ macfont_filter_properties (Lisp_Object font, Lisp_Object alist)
 
 static Boolean
 mac_ctfont_descriptor_supports_languages (CTFontDescriptorRef descriptor,
-                                          CFArrayRef languages)
+                                          CFArrayRef languages)
 {
   Boolean result = true;
   CFArrayRef desc_languages =
@@ -3321,13 +3306,13 @@ mac_ctfont_descriptor_supports_languages (CTFontDescriptorRef descriptor,
       desc_languages_count = CFArrayGetCount (desc_languages);
       languages_count = CFArrayGetCount (languages);
       for (i = 0; i < languages_count; i++)
-        if (!CFArrayContainsValue (desc_languages,
-                                   CFRangeMake (0, desc_languages_count),
-                                   CFArrayGetValueAtIndex (languages, i)))
-          {
-            result = false;
-            break;
-          }
+        if (!CFArrayContainsValue (desc_languages,
+                                   CFRangeMake (0, desc_languages_count),
+                                   CFArrayGetValueAtIndex (languages, i)))
+          {
+            result = false;
+            break;
+          }
       CFRelease (desc_languages);
     }
 
@@ -3345,79 +3330,79 @@ mac_ctfont_create_preferred_family_for_attributes (CFDictionaryRef attributes)
     {
       CFStringRef keys[] = {
 #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
-        kCTLanguageAttributeName
+        kCTLanguageAttributeName
 #else
-        CFSTR ("NSLanguage")
+        CFSTR ("NSLanguage")
 #endif
       };
       CFTypeRef values[] = {NULL};
       CFIndex num_values = 0;
       CFArrayRef languages
-        = CFDictionaryGetValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE);
+        = CFDictionaryGetValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE);
 
       if (languages && CFArrayGetCount (languages) > 0)
-        {
-          if (CTGetCoreTextVersion () >= kCTVersionNumber10_9)
-            values[num_values++] = CFArrayGetValueAtIndex (languages, 0);
-          else
-            {
-              CFCharacterSetRef charset =
-                CFDictionaryGetValue (attributes,
-                                      MAC_FONT_CHARACTER_SET_ATTRIBUTE);
-
-              result = mac_font_copy_default_name_for_charset_and_languages (charset, languages);
-            }
-        }
+        {
+          if (CTGetCoreTextVersion () >= kCTVersionNumber10_9)
+            values[num_values++] = CFArrayGetValueAtIndex (languages, 0);
+          else
+            {
+              CFCharacterSetRef charset =
+                CFDictionaryGetValue (attributes,
+                                      MAC_FONT_CHARACTER_SET_ATTRIBUTE);
+
+              result = mac_font_copy_default_name_for_charset_and_languages (charset, languages);
+            }
+        }
       if (result == NULL)
-        {
-          CFAttributedStringRef attr_string = NULL;
-          CTLineRef ctline = NULL;
-          CFDictionaryRef attrs
-            = CFDictionaryCreate (NULL, (const void **) keys,
-                                  (const void **) values, num_values,
-                                  &kCFTypeDictionaryKeyCallBacks,
-                                  &kCFTypeDictionaryValueCallBacks);
-
-          if (attrs)
-            {
-              attr_string = CFAttributedStringCreate (NULL, charset_string,
-                                                      attrs);
-              CFRelease (attrs);
-            }
-          if (attr_string)
-            {
-              ctline = CTLineCreateWithAttributedString (attr_string);
-              CFRelease (attr_string);
-            }
-          if (ctline)
-            {
-              CFArrayRef runs = CTLineGetGlyphRuns (ctline);
-              CFIndex i, nruns = CFArrayGetCount (runs);
-              CTFontRef font;
-
-              for (i = 0; i < nruns; i++)
-                {
-                  CTRunRef run = CFArrayGetValueAtIndex (runs, i);
-                  CFDictionaryRef attributes = CTRunGetAttributes (run);
-                  CTFontRef font_in_run;
-
-                  if (attributes == NULL)
-                    break;
-                  font_in_run =
-                    CFDictionaryGetValue (attributes, kCTFontAttributeName);
-                  if (font_in_run == NULL)
-                    break;
-                  if (i == 0)
-                    font = font_in_run;
-                  else if (!mac_ctfont_equal_in_postscript_name (font,
-                                                                 font_in_run))
-                    break;
-                }
-              if (nruns > 0 && i == nruns)
-                result = CTFontCopyAttribute (font, kCTFontFamilyNameAttribute);
-              CFRelease (ctline);
-            }
-        }
+        {
+          CFAttributedStringRef attr_string = NULL;
+          CTLineRef ctline = NULL;
+          CFDictionaryRef attrs
+            = CFDictionaryCreate (NULL, (const void **) keys,
+                                  (const void **) values, num_values,
+                                  &kCFTypeDictionaryKeyCallBacks,
+                                  &kCFTypeDictionaryValueCallBacks);
+
+          if (attrs)
+            {
+              attr_string = CFAttributedStringCreate (NULL, charset_string,
+                                                      attrs);
+              CFRelease (attrs);
+            }
+          if (attr_string)
+            {
+              ctline = CTLineCreateWithAttributedString (attr_string);
+              CFRelease (attr_string);
+            }
+          if (ctline)
+            {
+              CFArrayRef runs = CTLineGetGlyphRuns (ctline);
+              CFIndex i, nruns = CFArrayGetCount (runs);
+              CTFontRef font;
+
+              for (i = 0; i < nruns; i++)
+                {
+                  CTRunRef run = CFArrayGetValueAtIndex (runs, i);
+                  CFDictionaryRef attributes = CTRunGetAttributes (run);
+                  CTFontRef font_in_run;
+
+                  if (attributes == NULL)
+                    break;
+                  font_in_run =
+                    CFDictionaryGetValue (attributes, kCTFontAttributeName);
+                  if (font_in_run == NULL)
+                    break;
+                  if (i == 0)
+                    font = font_in_run;
+                  else if (!mac_ctfont_equal_in_postscript_name (font,
+                                                                 font_in_run))
+                    break;
+                }
+              if (nruns > 0 && i == nruns)
+                result = CTFontCopyAttribute (font, kCTFontFamilyNameAttribute);
+              CFRelease (ctline);
+            }
+        }
     }
 
   return result;
@@ -3427,14 +3412,14 @@ static inline double
 mac_ctfont_get_advance_width_for_glyph (CTFontRef font, CGGlyph glyph)
 {
   return CTFontGetAdvancesForGlyphs (font, kCTFontDefaultOrientation,
-                                     &glyph, NULL, 1);
+                                     &glyph, NULL, 1);
 }
 
 static inline CGRect
 mac_ctfont_get_bounding_rect_for_glyph (CTFontRef font, CGGlyph glyph)
 {
   return CTFontGetBoundingRectsForGlyphs (font, kCTFontDefaultOrientation,
-                                          &glyph, NULL, 1);
+                                          &glyph, NULL, 1);
 }
 
 static CFArrayRef
@@ -3442,83 +3427,31 @@ mac_ctfont_create_available_families (void)
 {
   CFMutableArrayRef families = NULL;
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
-  if (CTFontManagerCopyAvailableFontFamilyNames != NULL)
-#endif
     {
       CFArrayRef orig_families = CTFontManagerCopyAvailableFontFamilyNames ();
 
       if (orig_families)
-        {
-          CFIndex i, count = CFArrayGetCount (orig_families);
-
-          families = CFArrayCreateMutable (NULL, count, &kCFTypeArrayCallBacks);
-          if (families)
-            for (i = 0; i < count; i++)
-              {
-                CFStringRef family = CFArrayGetValueAtIndex (orig_families, i);
-
-                if (!CFStringHasPrefix (family, CFSTR ("."))
-                    && (CTFontManagerCompareFontFamilyNames (family,
-                                                             CFSTR ("LastResort"),
-                                                             NULL)
-                        != kCFCompareEqualTo))
-                  CFArrayAppendValue (families, family);
-              }
-          CFRelease (orig_families);
-        }
-    }
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
-  else         /* CTFontManagerCopyAvailableFontFamilyNames == NULL */
-#endif
-#endif  /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 */
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
-    {
-      CTFontCollectionRef collection;
-      CFArrayRef descs = NULL;
-
-      collection = CTFontCollectionCreateFromAvailableFonts (NULL);
-      if (collection)
-        {
-          descs = CTFontCollectionCreateMatchingFontDescriptors (collection);
-          CFRelease (collection);
-        }
-      if (descs)
-        {
-          CFIndex i, count = CFArrayGetCount (descs);
-
-          families = CFArrayCreateMutable (NULL, count, &kCFTypeArrayCallBacks);
-          if (families)
-            for (i = 0; i < count; i++)
-              {
-                FontDescriptorRef desc = CFArrayGetValueAtIndex (descs, i);
-                CFStringRef name =
-                  mac_font_descriptor_copy_attribute (desc,
-                                                      MAC_FONT_FAMILY_NAME_ATTRIBUTE);
-
-                if (name)
-                  {
-                    CFIndex p, limit = CFArrayGetCount (families);
-
-                    p = CFArrayBSearchValues (families, CFRangeMake (0, limit),
-                                              (const void *) name,
-                                              mac_font_family_compare, NULL);
-                    if (p >= limit)
-                      CFArrayAppendValue (families, name);
-                    else if (mac_font_family_compare
-                             (CFArrayGetValueAtIndex (families, p),
-                              name, NULL) != kCFCompareEqualTo)
-                      CFArrayInsertValueAtIndex (families, p, name);
-                    CFRelease (name);
-                  }
-              }
-          CFRelease (descs);
-        }
+        {
+          CFIndex i, count = CFArrayGetCount (orig_families);
+
+          families = CFArrayCreateMutable (NULL, count, &kCFTypeArrayCallBacks);
+          if (families)
+            for (i = 0; i < count; i++)
+              {
+                CFStringRef family = CFArrayGetValueAtIndex (orig_families, i);
+
+                if (!CFStringHasPrefix (family, CFSTR ("."))
+                    && (CTFontManagerCompareFontFamilyNames (family,
+                                                             CFSTR ("LastResort"),
+                                                             NULL)
+                        != kCFCompareEqualTo))
+                  CFArrayAppendValue (families, family);
+              }
+          CFRelease (orig_families);
+        }
     }
-#endif
 
-  return families;
+    return families;
 }
 
 static Boolean
@@ -3536,10 +3469,10 @@ mac_ctfont_equal_in_postscript_name (CTFontRef font1, CTFontRef font2)
     {
       name2 = CTFontCopyPostScriptName (font2);
       if (name2)
-        {
-          result = CFEqual (name1, name2);
-          CFRelease (name2);
-        }
+        {
+          result = CFEqual (name1, name2);
+          CFRelease (name2);
+        }
       CFRelease (name1);
     }
 
@@ -3548,7 +3481,7 @@ mac_ctfont_equal_in_postscript_name (CTFontRef font1, CTFontRef font2)
 
 static CTLineRef
 mac_ctfont_create_line_with_string_and_font (CFStringRef string,
-                                             CTFontRef macfont)
+                                             CTFontRef macfont)
 {
   CFStringRef keys[] = {kCTFontAttributeName, kCTKernAttributeName};
   CFTypeRef values[] = {NULL, NULL};
@@ -3562,10 +3495,10 @@ mac_ctfont_create_line_with_string_and_font (CFStringRef string,
   if (values[1])
     {
       attributes = CFDictionaryCreate (NULL, (const void **) keys,
-                                       (const void **) values,
+                                       (const void **) values,
                                        ARRAYELTS (keys),
-                                       &kCFTypeDictionaryKeyCallBacks,
-                                       &kCFTypeDictionaryValueCallBacks);
+                                       &kCFTypeDictionaryKeyCallBacks,
+                                       &kCFTypeDictionaryValueCallBacks);
       CFRelease (values[1]);
     }
   if (attributes)
@@ -3581,30 +3514,30 @@ mac_ctfont_create_line_with_string_and_font (CFStringRef string,
   if (ctline)
     {
       /* Abandon if ctline contains some fonts other than the
-         specified one.  */
+         specified one.  */
       CFArrayRef runs = CTLineGetGlyphRuns (ctline);
       CFIndex i, nruns = CFArrayGetCount (runs);
 
       for (i = 0; i < nruns; i++)
-        {
-          CTRunRef run = CFArrayGetValueAtIndex (runs, i);
-          CFDictionaryRef attributes = CTRunGetAttributes (run);
-          CTFontRef font_in_run;
-
-          if (attributes == NULL)
-            break;
-          font_in_run =
-            CFDictionaryGetValue (attributes, kCTFontAttributeName);
-          if (font_in_run == NULL)
-            break;
-          if (!mac_ctfont_equal_in_postscript_name (macfont, font_in_run))
-            break;
-        }
+        {
+          CTRunRef run = CFArrayGetValueAtIndex (runs, i);
+          CFDictionaryRef attributes = CTRunGetAttributes (run);
+          CTFontRef font_in_run;
+
+          if (attributes == NULL)
+            break;
+          font_in_run =
+            CFDictionaryGetValue (attributes, kCTFontAttributeName);
+          if (font_in_run == NULL)
+            break;
+          if (!mac_ctfont_equal_in_postscript_name (macfont, font_in_run))
+            break;
+        }
       if (i < nruns)
-        {
-          CFRelease (ctline);
-          ctline = NULL;
-        }
+        {
+          CFRelease (ctline);
+          ctline = NULL;
+        }
     }
 
   return ctline;
@@ -3612,7 +3545,7 @@ mac_ctfont_create_line_with_string_and_font (CFStringRef string,
 
 static CFIndex
 mac_ctfont_shape (CTFontRef font, CFStringRef string,
-                  struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len)
+                  struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len)
 {
   CFIndex used, result = 0;
   CTLineRef ctline = mac_ctfont_create_line_with_string_and_font (string, font);
@@ -3629,128 +3562,128 @@ mac_ctfont_shape (CTFontRef font, CFStringRef string,
       CFIndex total_glyph_count = 0;
 
       for (k = 0; k < ctrun_count; k++)
-        {
-          CTRunRef ctrun = CFArrayGetValueAtIndex (ctruns, k);
-          CFIndex i, min_location, glyph_count = CTRunGetGlyphCount (ctrun);
-          struct mac_glyph_layout *glbuf = glyph_layouts + total_glyph_count;
-          CFRange string_range, comp_range, range;
-          CFIndex *permutation;
-
-          if (CTRunGetStatus (ctrun) & kCTRunStatusRightToLeft)
-            permutation = xmalloc (sizeof (CFIndex) * glyph_count);
-          else
-            permutation = NULL;
+        {
+          CTRunRef ctrun = CFArrayGetValueAtIndex (ctruns, k);
+          CFIndex i, min_location, glyph_count = CTRunGetGlyphCount (ctrun);
+          struct mac_glyph_layout *glbuf = glyph_layouts + total_glyph_count;
+          CFRange string_range, comp_range, range;
+          CFIndex *permutation;
+
+          if (CTRunGetStatus (ctrun) & kCTRunStatusRightToLeft)
+            permutation = xmalloc (sizeof (CFIndex) * glyph_count);
+          else
+            permutation = NULL;
 
 #define RIGHT_TO_LEFT_P permutation
 
-          /* Now the `comp_range' member of struct mac_glyph_layout is
-             temporarily used as a work area such that:
-              glbuf[i].comp_range.location =
-                min {compRange[i + 1].location, ...,
+          /* Now the `comp_range' member of struct mac_glyph_layout is
+             temporarily used as a work area such that:
+             glbuf[i].comp_range.location =
+             min {compRange[i + 1].location, ...,
                      compRange[glyph_count - 1].location,
                      maxRange (stringRangeForCTRun)}
-              glbuf[i].comp_range.length = maxRange (compRange[i])
-             where compRange[i] is the range of composed characters
-             containing i-th glyph.  */
-          string_range = CTRunGetStringRange (ctrun);
-          min_location = string_range.location + string_range.length;
-          for (i = 0; i < glyph_count; i++)
-            {
-              struct mac_glyph_layout *gl = glbuf + glyph_count - i - 1;
-              CFIndex glyph_index;
-              CFRange rng;
-
-              if (!RIGHT_TO_LEFT_P)
-                glyph_index = glyph_count - i - 1;
-              else
-                glyph_index = i;
-              CTRunGetStringIndices (ctrun, CFRangeMake (glyph_index, 1),
-                                     &gl->string_index);
-              rng =
-                CFStringGetRangeOfComposedCharactersAtIndex (string,
-                                                             gl->string_index);
-              gl->comp_range.location = min_location;
-              gl->comp_range.length = rng.location + rng.length;
-              if (rng.location < min_location)
-                min_location = rng.location;
-            }
-
-          /* Fill the `comp_range' member of struct mac_glyph_layout,
-             and setup a permutation for right-to-left text.  */
-          comp_range = CFRangeMake (string_range.location, 0);
-          range = CFRangeMake (0, 0);
-          while (1)
-            {
-              struct mac_glyph_layout *gl =
-                glbuf + range.location + range.length;
-
-              if (gl->comp_range.length
-                  > comp_range.location + comp_range.length)
-                comp_range.length = gl->comp_range.length - comp_range.location;
-              min_location = gl->comp_range.location;
-              range.length++;
-
-              if (min_location >= comp_range.location + comp_range.length)
-                {
-                  comp_range.length = min_location - comp_range.location;
-                  for (i = 0; i < range.length; i++)
-                    {
-                      glbuf[range.location + i].comp_range = comp_range;
-                      if (RIGHT_TO_LEFT_P)
-                        permutation[range.location + i] =
-                          range.location + range.length - i - 1;
-                    }
-
-                  comp_range = CFRangeMake (min_location, 0);
-                  range.location += range.length;
-                  range.length = 0;
-                  if (range.location == glyph_count)
-                    break;
-                }
-            }
-
-          /* Then fill the remaining members.  */
-          for (range = CFRangeMake (0, 1); range.location < glyph_count;
-               range.location++)
-            {
-              struct mac_glyph_layout *gl;
-              CGPoint position;
-
-              if (!RIGHT_TO_LEFT_P)
-                gl = glbuf + range.location;
-              else
-                {
-                  CFIndex src, dest;
-
-                  src = glyph_count - 1 - range.location;
-                  dest = permutation[src];
-                  gl = glbuf + dest;
-                  if (src < dest)
-                    {
-                      CFIndex tmp = gl->string_index;
-
-                      gl->string_index = glbuf[src].string_index;
-                      glbuf[src].string_index = tmp;
-                    }
-                }
-              CTRunGetGlyphs (ctrun, range, &gl->glyph_id);
-
-              CTRunGetPositions (ctrun, range, &position);
-              gl->advance_delta = position.x - total_advance;
-              gl->baseline_delta = position.y;
-              gl->advance = (gl->advance_delta
-                             + CTRunGetTypographicBounds (ctrun, range,
-                                                          NULL, NULL, NULL));
-              total_advance += gl->advance;
-            }
-
-          if (RIGHT_TO_LEFT_P)
-            xfree (permutation);
+             glbuf[i].comp_range.length = maxRange (compRange[i])
+             where compRange[i] is the range of composed characters
+             containing i-th glyph.  */
+          string_range = CTRunGetStringRange (ctrun);
+          min_location = string_range.location + string_range.length;
+          for (i = 0; i < glyph_count; i++)
+            {
+              struct mac_glyph_layout *gl = glbuf + glyph_count - i - 1;
+              CFIndex glyph_index;
+              CFRange rng;
+
+              if (!RIGHT_TO_LEFT_P)
+                glyph_index = glyph_count - i - 1;
+              else
+                glyph_index = i;
+              CTRunGetStringIndices (ctrun, CFRangeMake (glyph_index, 1),
+                                     &gl->string_index);
+              rng =
+                CFStringGetRangeOfComposedCharactersAtIndex (string,
+                                                             gl->string_index);
+              gl->comp_range.location = min_location;
+              gl->comp_range.length = rng.location + rng.length;
+              if (rng.location < min_location)
+                min_location = rng.location;
+            }
+
+          /* Fill the `comp_range' member of struct mac_glyph_layout,
+             and setup a permutation for right-to-left text.  */
+          comp_range = CFRangeMake (string_range.location, 0);
+          range = CFRangeMake (0, 0);
+          while (1)
+            {
+              struct mac_glyph_layout *gl =
+                glbuf + range.location + range.length;
+
+              if (gl->comp_range.length
+                  > comp_range.location + comp_range.length)
+                comp_range.length = gl->comp_range.length - comp_range.location;
+              min_location = gl->comp_range.location;
+              range.length++;
+
+              if (min_location >= comp_range.location + comp_range.length)
+                {
+                  comp_range.length = min_location - comp_range.location;
+                  for (i = 0; i < range.length; i++)
+                    {
+                      glbuf[range.location + i].comp_range = comp_range;
+                      if (RIGHT_TO_LEFT_P)
+                        permutation[range.location + i] =
+                          range.location + range.length - i - 1;
+                    }
+
+                  comp_range = CFRangeMake (min_location, 0);
+                  range.location += range.length;
+                  range.length = 0;
+                  if (range.location == glyph_count)
+                    break;
+                }
+            }
+
+          /* Then fill the remaining members.  */
+          for (range = CFRangeMake (0, 1); range.location < glyph_count;
+               range.location++)
+            {
+              struct mac_glyph_layout *gl;
+              CGPoint position;
+
+              if (!RIGHT_TO_LEFT_P)
+                gl = glbuf + range.location;
+              else
+                {
+                  CFIndex src, dest;
+
+                  src = glyph_count - 1 - range.location;
+                  dest = permutation[src];
+                  gl = glbuf + dest;
+                  if (src < dest)
+                    {
+                      CFIndex tmp = gl->string_index;
+
+                      gl->string_index = glbuf[src].string_index;
+                      glbuf[src].string_index = tmp;
+                    }
+                }
+              CTRunGetGlyphs (ctrun, range, &gl->glyph_id);
+
+              CTRunGetPositions (ctrun, range, &position);
+              gl->advance_delta = position.x - total_advance;
+              gl->baseline_delta = position.y;
+              gl->advance = (gl->advance_delta
+                             + CTRunGetTypographicBounds (ctrun, range,
+                                                          NULL, NULL, NULL));
+              total_advance += gl->advance;
+            }
+
+          if (RIGHT_TO_LEFT_P)
+            xfree (permutation);
 
 #undef RIGHT_TO_LEFT_P
 
-          total_glyph_count += glyph_count;
-        }
+          total_glyph_count += glyph_count;
+        }
 
       result = used;
     }
@@ -3765,7 +3698,7 @@ mac_ctfont_shape (CTFontRef font, CFStringRef string,
 #if USE_CT_GLYPH_INFO
 static CGGlyph
 mac_ctfont_get_glyph_for_cid (CTFontRef font, CTCharacterCollection collection,
-                              CGFontIndex cid)
+                              CGFontIndex cid)
 {
   CGGlyph result = kCGFontIndexInvalid;
   UniChar characters[] = {0xfffd};
@@ -3779,27 +3712,27 @@ mac_ctfont_get_glyph_for_cid (CTFontRef font, CTCharacterCollection collection,
   if (string)
     {
       CTGlyphInfoRef glyph_info =
-        CTGlyphInfoCreateWithCharacterIdentifier (cid, collection, string);
+        CTGlyphInfoCreateWithCharacterIdentifier (cid, collection, string);
       CFDictionaryRef attributes = NULL;
 
       if (glyph_info)
-        {
-          CFStringRef keys[] = {kCTFontAttributeName,
-                                kCTGlyphInfoAttributeName};
-          CFTypeRef values[] = {font, glyph_info};
+        {
+          CFStringRef keys[] = {kCTFontAttributeName,
+                                kCTGlyphInfoAttributeName};
+          CFTypeRef values[] = {font, glyph_info};
 
-          attributes = CFDictionaryCreate (NULL, (const void **) keys,
-                                           (const void **) values,
+          attributes = CFDictionaryCreate (NULL, (const void **) keys,
+                                           (const void **) values,
                                            ARRAYELTS (keys),
-                                           &kCFTypeDictionaryKeyCallBacks,
-                                           &kCFTypeDictionaryValueCallBacks);
-          CFRelease (glyph_info);
-        }
+                                           &kCFTypeDictionaryKeyCallBacks,
+                                           &kCFTypeDictionaryValueCallBacks);
+          CFRelease (glyph_info);
+        }
       if (attributes)
-        {
-          attr_string = CFAttributedStringCreate (NULL, string, attributes);
-          CFRelease (attributes);
-        }
+        {
+          attr_string = CFAttributedStringCreate (NULL, string, attributes);
+          CFRelease (attributes);
+        }
       CFRelease (string);
     }
   if (attr_string)
@@ -3812,24 +3745,24 @@ mac_ctfont_get_glyph_for_cid (CTFontRef font, CTCharacterCollection collection,
       CFArrayRef runs = CTLineGetGlyphRuns (ctline);
 
       if (CFArrayGetCount (runs) > 0)
-        {
-          CTRunRef run = CFArrayGetValueAtIndex (runs, 0);
-          CFDictionaryRef attributes = CTRunGetAttributes (run);
-
-          if (attributes)
-            {
-              CTFontRef font_in_run =
-                CFDictionaryGetValue (attributes, kCTFontAttributeName);
-
-              if (font_in_run
-                  && mac_ctfont_equal_in_postscript_name (font_in_run, font))
-                {
-                  CTRunGetGlyphs (run, CFRangeMake (0, 1), &result);
-                  if (result >= CTFontGetGlyphCount (font))
-                    result = kCGFontIndexInvalid;
-                }
-            }
-        }
+        {
+          CTRunRef run = CFArrayGetValueAtIndex (runs, 0);
+          CFDictionaryRef attributes = CTRunGetAttributes (run);
+
+          if (attributes)
+            {
+              CTFontRef font_in_run =
+                CFDictionaryGetValue (attributes, kCTFontAttributeName);
+
+              if (font_in_run
+                  && mac_ctfont_equal_in_postscript_name (font_in_run, font))
+                {
+                  CTRunGetGlyphs (run, CFRangeMake (0, 1), &result);
+                  if (result >= CTFontGetGlyphCount (font))
+                    result = kCGFontIndexInvalid;
+                }
+            }
+        }
       CFRelease (ctline);
     }
 
@@ -3837,41 +3770,6 @@ mac_ctfont_get_glyph_for_cid (CTFontRef font, CTCharacterCollection collection,
 }
 #endif
 
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
-static inline int
-mac_font_family_group (CFStringRef family)
-{
-  if (CFStringHasPrefix (family, CFSTR ("#")))
-    return 2;
-  else
-    {
-      CFRange range;
-
-      range = CFStringFind (family, CFSTR ("Apple"),
-                            kCFCompareCaseInsensitive | kCFCompareAnchored);
-      if (range.location != kCFNotFound)
-        return 1;
-
-      return 0;
-    }
-}
-
-static CFComparisonResult
-mac_font_family_compare (const void *val1, const void *val2, void *context)
-{
-  CFStringRef family1 = (CFStringRef) val1, family2 = (CFStringRef) val2;
-  int group1, group2;
-
-  group1 = mac_font_family_group (family1);
-  group2 = mac_font_family_group (family2);
-  if (group1 < group2)
-    return kCFCompareLessThan;
-  if (group1 > group2)
-    return kCFCompareGreaterThan;
-  return CFStringCompare (family1, family2, kCFCompareCaseInsensitive);
-}
-#endif  /* MAC_OS_X_VERSION_MIN_REQUIRED < 1060 */
-
 static CFArrayRef
 mac_font_copy_default_descriptors_for_language (CFStringRef language)
 {
@@ -3883,22 +3781,22 @@ mac_font_copy_default_descriptors_for_language (CFStringRef language)
 #endif
     {
       CTFontRef user_font =
-        CTFontCreateUIFontForLanguage (kCTFontUserFontType, 0, language);
+        CTFontCreateUIFontForLanguage (kCTFontUserFontType, 0, language);
 
       if (user_font)
-        {
-          CFArrayRef languages =
-            CFArrayCreate (NULL, (const void **) &language, 1,
-                           &kCFTypeArrayCallBacks);
-
-          if (languages)
-            {
-              result = CTFontCopyDefaultCascadeListForLanguages (user_font,
-                                                                 languages);
-              CFRelease (languages);
-            }
-          CFRelease (user_font);
-        }
+        {
+          CFArrayRef languages =
+            CFArrayCreate (NULL, (const void **) &language, 1,
+                           &kCFTypeArrayCallBacks);
+
+          if (languages)
+            {
+              result = CTFontCopyDefaultCascadeListForLanguages (user_font,
+                                                                 languages);
+              CFRelease (languages);
+            }
+          CFRelease (user_font);
+        }
     }
 #if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
   else          /* CTFontCopyDefaultCascadeListForLanguages == NULL */
@@ -3909,55 +3807,55 @@ mac_font_copy_default_descriptors_for_language (CFStringRef language)
       CFIndex i;
 
       for (i = 0; macfont_language_default_font_names[i].language; i++)
-        {
-          if (CFEqual (macfont_language_default_font_names[i].language,
+        {
+          if (CFEqual (macfont_language_default_font_names[i].language,
                        language))
-            {
-              CFMutableArrayRef descriptors =
-                CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks);
-
-              if (descriptors)
-                {
-                  CFIndex j;
-
-                  for (j = 0;
-                       macfont_language_default_font_names[i].font_names[j];
-                       j++)
-                    {
-                      CFDictionaryRef attributes =
-                        CFDictionaryCreate (NULL,
-                                            ((const void **)
-                                             &MAC_FONT_NAME_ATTRIBUTE),
-                                            ((const void **)
-                                             &macfont_language_default_font_names[i].font_names[j]),
-                                            1, &kCFTypeDictionaryKeyCallBacks,
-                                            &kCFTypeDictionaryValueCallBacks);
-
-                      if (attributes)
-                        {
-                          FontDescriptorRef pat_desc =
-                            mac_font_descriptor_create_with_attributes (attributes);
-
-                          if (pat_desc)
-                            {
-                              FontDescriptorRef descriptor =
-                                mac_font_descriptor_create_matching_font_descriptor (pat_desc, NULL);
-
-                              if (descriptor)
-                                {
-                                  CFArrayAppendValue (descriptors, descriptor);
-                                  CFRelease (descriptor);
-                                }
-                              CFRelease (pat_desc);
-                            }
-                          CFRelease (attributes);
-                        }
-                    }
-                  result = descriptors;
-                }
-              break;
-            }
-        }
+            {
+              CFMutableArrayRef descriptors =
+                CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks);
+
+              if (descriptors)
+                {
+                  CFIndex j;
+
+                  for (j = 0;
+                       macfont_language_default_font_names[i].font_names[j];
+                       j++)
+                    {
+                      CFDictionaryRef attributes =
+                        CFDictionaryCreate (NULL,
+                                            ((const void **)
+                                             &MAC_FONT_NAME_ATTRIBUTE),
+                                            ((const void **)
+                                             &macfont_language_default_font_names[i].font_names[j]),
+                                            1, &kCFTypeDictionaryKeyCallBacks,
+                                            &kCFTypeDictionaryValueCallBacks);
+
+                      if (attributes)
+                        {
+                          FontDescriptorRef pat_desc =
+                            mac_font_descriptor_create_with_attributes (attributes);
+
+                          if (pat_desc)
+                            {
+                              FontDescriptorRef descriptor =
+                                mac_font_descriptor_create_matching_font_descriptor (pat_desc, NULL);
+
+                              if (descriptor)
+                                {
+                                  CFArrayAppendValue (descriptors, descriptor);
+                                  CFRelease (descriptor);
+                                }
+                              CFRelease (pat_desc);
+                            }
+                          CFRelease (attributes);
+                        }
+                    }
+                  result = descriptors;
+                }
+              break;
+            }
+        }
     }
 #endif
 
@@ -3966,7 +3864,7 @@ mac_font_copy_default_descriptors_for_language (CFStringRef language)
 
 static CFStringRef
 mac_font_copy_default_name_for_charset_and_languages (CFCharacterSetRef charset,
-                                                      CFArrayRef languages)
+                                                      CFArrayRef languages)
 {
   CFStringRef result = NULL;
   CFStringRef language = CFArrayGetValueAtIndex (languages, 0);
@@ -3978,29 +3876,29 @@ mac_font_copy_default_name_for_charset_and_languages (CFCharacterSetRef charset,
       CFIndex i, count = CFArrayGetCount (descriptors);
 
       for (i = 0; i < count; i++)
-        {
-          FontDescriptorRef descriptor =
-            CFArrayGetValueAtIndex (descriptors, i);
-
-          if (macfont_supports_charset_and_languages_p (descriptor, charset,
-                                                        Qnil, languages))
-            {
-              CFStringRef family =
-                mac_font_descriptor_copy_attribute (descriptor,
-                                                    MAC_FONT_FAMILY_NAME_ATTRIBUTE);
-              if (family)
-                {
-                  if (!CFStringHasPrefix (family, CFSTR ("."))
-                      && !CFEqual (family, CFSTR ("LastResort")))
+        {
+          FontDescriptorRef descriptor =
+            CFArrayGetValueAtIndex (descriptors, i);
+
+          if (macfont_supports_charset_and_languages_p (descriptor, charset,
+                                                        Qnil, languages))
+            {
+              CFStringRef family =
+                mac_font_descriptor_copy_attribute (descriptor,
+                                                    MAC_FONT_FAMILY_NAME_ATTRIBUTE);
+              if (family)
+                {
+                  if (!CFStringHasPrefix (family, CFSTR ("."))
+                      && !CFEqual (family, CFSTR ("LastResort")))
                     {
-                      result = family;
-                      break;
-                    }
-                  else
-                    CFRelease (family);
-                }
-            }
-        }
+                      result = family;
+                      break;
+                    }
+                  else
+                    CFRelease (family);
+                }
+            }
+        }
       CFRelease (descriptors);
     }
 
@@ -4022,13 +3920,10 @@ mac_register_font_driver (struct frame *f)
   register_font_driver (&macfont_driver, f);
 }
 
-#endif // MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
-
 
 void
 syms_of_macfont (void)
 {
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
   static struct font_driver mac_font_driver;
 
   DEFSYM (Qmac_ct, "mac-ct");
@@ -4037,5 +3932,4 @@ syms_of_macfont (void)
 
   DEFSYM (QCdestination, ":destination");
   DEFSYM (QCminspace, ":minspace");
-#endif
 }
diff --git a/src/marker.c b/src/marker.c
index 91fcea5f25f..d377efbc4fa 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -455,21 +455,8 @@ attach_marker (struct Lisp_Marker *m, struct buffer *b,
 static struct buffer *
 live_buffer (Lisp_Object buffer)
 {
-  struct buffer *b;
-
-  if (NILP (buffer))
-    {
-      b = current_buffer;
-      eassert (BUFFER_LIVE_P (b));
-    }
-  else
-    {
-      CHECK_BUFFER (buffer);
-      b = XBUFFER (buffer);
-      if (!BUFFER_LIVE_P (b))
-       b = NULL;
-    }
-  return b;
+  struct buffer *b = decode_buffer (buffer);
+  return BUFFER_LIVE_P (b) ? b : NULL;
 }
 
 /* Internal function to set MARKER in BUFFER at POSITION.  Non-zero
diff --git a/src/menu.c b/src/menu.c
index 66247c713a2..61163ae0216 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -354,7 +354,7 @@ single_menu_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy, void *sk
      front of them.  */
   if (!have_boxes ())
     {
-      Lisp_Object prefix = Qnil;
+      char const *prefix = 0;
       Lisp_Object type = AREF (item_properties, ITEM_PROPERTY_TYPE);
       if (!NILP (type))
         {
@@ -389,8 +389,11 @@ single_menu_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy, void *sk
                     {
                       if (!submenu && SREF (tem, 0) != '\0'
                           && SREF (tem, 0) != '-')
-                        ASET (menu_items, idx + MENU_ITEMS_ITEM_NAME,
-                              concat2 (build_string ("    "), tem));
+                        {
+                          AUTO_STRING (spaces, "    ");
+                          ASET (menu_items, idx + MENU_ITEMS_ITEM_NAME,
+                                concat2 (spaces, tem));
+                        }
                       idx += MENU_ITEMS_ITEM_LENGTH;
                     }
                 }
@@ -399,24 +402,30 @@ single_menu_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy, void *sk
 
           /* Calculate prefix, if any, for this item.  */
           if (EQ (type, QCtoggle))
-            prefix = build_string (NILP (selected) ? "[ ] " : "[X] ");
+            prefix = NILP (selected) ? "[ ] " : "[X] ";
           else if (EQ (type, QCradio))
-            prefix = build_string (NILP (selected) ? "( ) " : "(*) ");
+            prefix = NILP (selected) ? "( ) " : "(*) ";
         }
       /* Not a button. If we have earlier buttons, then we need a prefix.  */
       else if (!skp->notbuttons && SREF (item_string, 0) != '\0'
                && SREF (item_string, 0) != '-')
-        prefix = build_string ("    ");
+        prefix = "    ";
 
-      if (!NILP (prefix))
-        item_string = concat2 (prefix, item_string);
+      if (prefix)
+        {
+          AUTO_STRING (prefix_obj, prefix);
+          item_string = concat2 (prefix_obj, item_string);
+        }
   }
 
   if ((FRAME_TERMCAP_P (XFRAME (Vmenu_updating_frame))
        || FRAME_MSDOS_P (XFRAME (Vmenu_updating_frame)))
       && !NILP (map))
     /* Indicate visually that this is a submenu.  */
-    item_string = concat2 (item_string, build_string (" >"));
+    {
+      AUTO_STRING (space_gt, " >");
+      item_string = concat2 (item_string, space_gt);
+    }
 
   push_menu_item (item_string, enabled, key,
                   AREF (item_properties, ITEM_PROPERTY_DEF),
@@ -632,8 +641,9 @@ digest_single_submenu (int start, int end, bool top_level_items)
   widget_value **submenu_stack;
   bool panes_seen = 0;
   struct frame *f = XFRAME (Vmenu_updating_frame);
+  USE_SAFE_ALLOCA;
 
-  submenu_stack = alloca (menu_items_used * sizeof *submenu_stack);
+  SAFE_NALLOCA (submenu_stack, 1, menu_items_used);
   wv = make_widget_value ("menu", NULL, true, Qnil);
   wv->button_type = BUTTON_TYPE_NONE;
   first_wv = wv;
@@ -835,11 +845,12 @@ digest_single_submenu (int start, int end, bool top_level_items)
      that was originally a button, return it by itself.  */
   if (top_level_items && first_wv->contents && first_wv->contents->next == 0)
     {
-      wv = first_wv->contents;
-      xfree (first_wv);
-      return wv;
+      wv = first_wv;
+      first_wv = first_wv->contents;
+      xfree (wv);
     }
 
+  SAFE_FREE ();
   return first_wv;
 }
 
@@ -890,9 +901,10 @@ find_and_call_menu_selection (struct frame *f, int menu_bar_items_used,
   Lisp_Object *subprefix_stack;
   int submenu_depth = 0;
   int i;
+  USE_SAFE_ALLOCA;
 
   entry = Qnil;
-  subprefix_stack = alloca (menu_bar_items_used * sizeof *subprefix_stack);
+  SAFE_NALLOCA (subprefix_stack, 1, menu_bar_items_used);
   prefix = Qnil;
   i = 0;
 
@@ -954,11 +966,13 @@ find_and_call_menu_selection (struct frame *f, int menu_bar_items_used,
               buf.arg = entry;
               kbd_buffer_store_event (&buf);
 
-              return;
+              break;
             }
           i += MENU_ITEMS_ITEM_LENGTH;
         }
     }
+
+  SAFE_FREE ();
 }
 
 #endif /* USE_X_TOOLKIT || USE_GTK || HAVE_NS || HAVE_NTGUI */
@@ -973,10 +987,11 @@ find_and_return_menu_selection (struct frame *f, bool keymaps, void *client_data
   int i;
   Lisp_Object *subprefix_stack;
   int submenu_depth = 0;
+  USE_SAFE_ALLOCA;
 
   prefix = entry = Qnil;
   i = 0;
-  subprefix_stack = alloca (menu_items_used * word_size);
+  SAFE_ALLOCA_LISP (subprefix_stack, menu_items_used);
 
   while (i < menu_items_used)
     {
@@ -1018,11 +1033,13 @@ find_and_return_menu_selection (struct frame *f, bool keymaps, void *client_data
                     if (!NILP (subprefix_stack[j]))
                       entry = Fcons (subprefix_stack[j], entry);
                 }
+              SAFE_FREE ();
               return entry;
             }
           i += MENU_ITEMS_ITEM_LENGTH;
         }
     }
+  SAFE_FREE ();
   return Qnil;
 }
 #endif  /* HAVE_NS */
diff --git a/src/minibuf.c b/src/minibuf.c
index 93e19d5c120..0b455157d52 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1123,7 +1123,7 @@ If `read-buffer-function' is non-nil, this works by calling it as a
 function, instead of the usual behavior.  */)
   (Lisp_Object prompt, Lisp_Object def, Lisp_Object require_match)
 {
-  Lisp_Object args[4], result;
+  Lisp_Object result;
   char *s;
   ptrdiff_t len;
   ptrdiff_t count = SPECPDL_INDEX ();
@@ -1157,10 +1157,10 @@ function, instead of the usual behavior.  */)
                                               STRING_MULTIBYTE (prompt));
             }
 
-          args[0] = build_string ("%s (default %s): ");
-          args[1] = prompt;
-          args[2] = CONSP (def) ? XCAR (def) : def;
-          prompt = Fformat (3, args);
+          AUTO_STRING (format, "%s (default %s): ");
+          prompt = Fformat (3, ((Lisp_Object [])
+                                {format, prompt,
+                                 CONSP (def) ? XCAR (def) : def}));
         }
 
       result = Fcompleting_read (prompt, intern ("internal-complete-buffer"),
@@ -1168,13 +1168,8 @@ function, instead of the usual behavior.  */)
                                  Qbuffer_name_history, def, Qnil);
     }
   else
-    {
-      args[0] = Vread_buffer_function;
-      args[1] = prompt;
-      args[2] = def;
-      args[3] = require_match;
-      result = Ffuncall (4, args);
-    }
+    result = Ffuncall (4, ((Lisp_Object [])
+      { Vread_buffer_function, prompt, def, require_match }));
   return unbind_to (count, result);
 }
 
diff --git a/src/msdos.c b/src/msdos.c
index dae86b5a3b2..14c2624114d 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -1792,7 +1792,7 @@ internal_terminal_init (void)
         }
 
       Vinitial_window_system = Qpc;
-      Vwindow_system_version = make_number (24); /* RE Emacs version */
+      Vwindow_system_version = make_number (25); /* RE Emacs version */
       tty->terminal->type = output_msdos_raw;
 
       /* If Emacs was dumped on DOS/V machine, forget the stale VRAM
diff --git a/src/nsfns.m b/src/nsfns.m
index ca8f4922ccd..a93b2724403 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -46,10 +46,8 @@ GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
 
 #ifdef NS_IMPL_COCOA
 #include <IOKit/graphics/IOGraphicsLib.h>
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
 #include "macfont.h"
 #endif
-#endif
 
 #if 0
 int fns_trace_num = 1;
@@ -135,7 +133,7 @@ check_ns_display_info (Lisp_Object object)
     }
   else if (TERMINALP (object))
     {
-      struct terminal *t = get_terminal (object, 1);
+      struct terminal *t = decode_live_terminal (object);
 
       if (t->type != output_ns)
         error ("Terminal %d is not a Nextstep display", t->id);
@@ -197,7 +195,7 @@ ns_display_info_for_name (Lisp_Object name)
 static NSString *
 ns_filename_from_panel (NSSavePanel *panel)
 {
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
   NSURL *url = [panel URL];
   NSString *str = [url path];
   return str;
@@ -209,7 +207,7 @@ ns_filename_from_panel (NSSavePanel *panel)
 static NSString *
 ns_directory_from_panel (NSSavePanel *panel)
 {
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
   NSURL *url = [panel directoryURL];
   NSString *str = [url path];
   return str;
@@ -1197,13 +1195,10 @@ This function is an internal primitive--use `make-frame' instead.  */)
   block_input ();
 
 #ifdef NS_IMPL_COCOA
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
-  if (CTGetCoreTextVersion != NULL
-      && CTGetCoreTextVersion () >= kCTVersionNumber10_5)
     mac_register_font_driver (f);
+#else
+    register_font_driver (&nsfont_driver, f);
 #endif
-#endif
-  register_font_driver (&nsfont_driver, f);
 
   x_default_parameter (f, parms, Qfont_backend, Qnil,
                         "fontBackend", "FontBackend", RES_TYPE_STRING);
@@ -1244,7 +1239,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
                            "verticalScrollBars", "VerticalScrollBars",
                            RES_TYPE_SYMBOL);
   }
-  x_default_parameter (f, parms, Qhorizontal_scroll_bars, Qt,
+  x_default_parameter (f, parms, Qhorizontal_scroll_bars, Qnil,
                        "horizontalScrollBars", "HorizontalScrollBars",
                        RES_TYPE_SYMBOL);
   x_default_parameter (f, parms, Qforeground_color, build_string ("Black"),
@@ -1414,13 +1409,11 @@ DEFUN ("ns-popup-font-panel", Fns_popup_font_panel, Sns_popup_font_panel,
   id fm = [NSFontManager sharedFontManager];
   struct font *font = f->output_data.ns->font;
   NSFont *nsfont;
-  if (EQ (font->driver->type, Qns))
-    nsfont = ((struct nsfont_info *)font)->nsfont;
-#ifdef NS_IMPL_COCOA
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
-  else
-    nsfont = (NSFont *) macfont_get_nsctfont (font);
+#ifdef NS_IMPL_GNUSTEP
+  nsfont = ((struct nsfont_info *)font)->nsfont;
 #endif
+#ifdef NS_IMPL_COCOA
+  nsfont = (NSFont *) macfont_get_nsctfont (font);
 #endif
   [fm setSelectedFont: nsfont isMultiple: NO];
   [fm orderFrontFontPanel: NSApp];
@@ -1442,8 +1435,7 @@ static struct
 {
   id panel;
   BOOL ret;
-#if ! defined (NS_IMPL_COCOA) || \
-  MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_GNUSTEP
   NSString *dirS, *initS;
   BOOL no_types;
 #endif
@@ -1453,8 +1445,7 @@ void
 ns_run_file_dialog (void)
 {
   if (ns_fd_data.panel == nil) return;
-#if defined (NS_IMPL_COCOA) && \
-  MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
   ns_fd_data.ret = [ns_fd_data.panel runModal];
 #else
   if (ns_fd_data.no_types)
@@ -1534,8 +1525,7 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
   block_input ();
   ns_fd_data.panel = panel;
   ns_fd_data.ret = NO;
-#if defined (NS_IMPL_COCOA) && \
-  MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
   if (! NILP (mustmatch) || ! NILP (dir_only_p))
     [panel setAllowedFileTypes: nil];
   if (dirS) [panel setDirectoryURL: [NSURL fileURLWithPath: dirS]];
@@ -1995,7 +1985,7 @@ DEFUN ("ns-list-services", Fns_list_services, Sns_list_services, 0, 0, 0,
        doc: /* List available Nextstep services by querying NSApp.  */)
      (void)
 {
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
   /* You can't get services like this in 10.6+.  */
   return Qnil;
 #else
@@ -2551,7 +2541,7 @@ the attributes:
 Internal use only, use `display-monitor-attributes-list' instead.  */)
   (Lisp_Object terminal)
 {
-  struct terminal *term = get_terminal (terminal, 1);
+  struct terminal *term = decode_live_terminal (terminal);
   NSArray *screens;
   NSUInteger i, n_monitors;
   struct MonitorInfo *monitors;
diff --git a/src/nsfont.m b/src/nsfont.m
index 98c25fcdedd..13c7b0bce2c 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -627,8 +627,8 @@ static Lisp_Object nsfont_open (struct frame *f, Lisp_Object font_entity,
 static void nsfont_close (struct font *font);
 static int nsfont_has_char (Lisp_Object entity, int c);
 static unsigned int nsfont_encode_char (struct font *font, int c);
-static int nsfont_text_extents (struct font *font, unsigned int *code,
-                                int nglyphs, struct font_metrics *metrics);
+static void nsfont_text_extents (struct font *font, unsigned int *code,
+                                 int nglyphs, struct font_metrics *metrics);
 static int nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
                         bool with_background);
 
@@ -988,9 +988,9 @@ nsfont_encode_char (struct font *font, int c)
 /* Perform the size computation of glyphs of FONT and fill in members
    of METRICS.  The glyphs are specified by their glyph codes in
    CODE (length NGLYPHS). */
-static int
-nsfont_text_extents (struct font *font, unsigned int *code, int nglyphs,
-                     struct font_metrics *metrics)
+static void
+nsfont_text_extents (struct font *font, unsigned int *code,
+                     int nglyphs, struct font_metrics *metrics)
 {
   struct nsfont_info *font_info = (struct nsfont_info *)font;
   struct font_metrics *pcm;
@@ -1000,7 +1000,7 @@ nsfont_text_extents (struct font *font, unsigned int *code, int nglyphs,
 
   memset (metrics, 0, sizeof (struct font_metrics));
 
-  for (i =0; i<nglyphs; i++)
+  for (i = 0; i < nglyphs; i++)
     {
       /* get metrics for this glyph, filling cache if need be */
       /* TODO: get metrics for whole string from an NSLayoutManager
@@ -1024,8 +1024,6 @@ nsfont_text_extents (struct font *font, unsigned int *code, int nglyphs,
     }
 
   metrics->width = totalWidth;
-
-  return totalWidth; /* not specified in doc, but xfont.c does it */
 }
 
 
@@ -1041,8 +1039,13 @@ nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
   static unsigned char cbuf[1024];
   unsigned char *c = cbuf;
 #ifdef NS_IMPL_GNUSTEP
+#if GNUSTEP_GUI_MAJOR_VERSION > 0 || GNUSTEP_GUI_MINOR_VERSION > 22
+  static CGFloat advances[1024];
+  CGFloat *adv = advances;
+#else
   static float advances[1024];
   float *adv = advances;
+#endif
 #else
   static CGSize advances[1024];
   CGSize *adv = advances;
diff --git a/src/nsimage.m b/src/nsimage.m
index 6b68072b87a..71e5f8aa5c6 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -188,7 +188,7 @@ static EmacsImage *ImageList = nil;
   image = [[EmacsImage alloc] initByReferencingFile:
                      [NSString stringWithUTF8String: SSDATA (found)]];
 
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
   imgRep = [NSBitmapImageRep imageRepWithData:[image TIFFRepresentation]];
 #else
   imgRep = [image bestRepresentationForDevice: nil];
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 778b068ef8b..a90cb970874 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -492,11 +492,9 @@ void
 x_activate_menubar (struct frame *f)
 {
 #ifdef NS_IMPL_COCOA
-#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
 }
 
 
@@ -542,23 +540,14 @@ x_activate_menubar (struct frame *f)
 }
 
 #ifdef NS_IMPL_COCOA
-#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5
-extern NSString *NSMenuDidBeginTrackingNotification;
-#endif
-#endif
-
-#ifdef NS_IMPL_COCOA
 -(void)trackingNotification:(NSNotification *)notification
 {
   /* 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
 {
   ++trackingMenu;
@@ -579,7 +568,6 @@ extern NSString *NSMenuDidBeginTrackingNotification;
 {
   --trackingMenu;
 }
-#endif /* OSX >= 10.5 */
 
 #endif /* NS_IMPL_COCOA */
 
@@ -608,8 +596,7 @@ extern NSString *NSMenuDidBeginTrackingNotification;
   if (trackingMenu == 0)
     return;
 /*fprintf (stderr, "Updating menu '%s'\n", [[self title] UTF8String]); NSLog (@"%@\n", event); */
-#if (! defined (NS_IMPL_COCOA) \
-     || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5)
+#ifdef NS_IMPL_GNUSTEP
   /* Don't know how to do this for anything other than OSX >= 10.5
      This is wrong, as it might run Lisp code in the event loop.  */
   ns_update_menubar (frame, true, self);
@@ -706,9 +693,7 @@ extern NSString *NSMenuDidBeginTrackingNotification;
     {
       NSMenuItem *item = [self itemAtIndex: n];
       NSString *title = [item title];
-      if (([title length] == 0  /* OSX 10.5 */
-           || [ns_app_name isEqualToString: title]  /* from 10.6 on */
-           || [@"Apple" isEqualToString: title]) /* older */
+      if ([ns_app_name isEqualToString: title]
           && ![item isSeparatorItem])
         continue;
       [self removeItemAtIndex: n];
diff --git a/src/nsselect.m b/src/nsselect.m
index 038849c0aed..3712ba064e7 100644
--- a/src/nsselect.m
+++ b/src/nsselect.m
@@ -328,19 +328,14 @@ ns_string_to_pasteboard (id pb, Lisp_Object str)
    ========================================================================== */
 
 
-DEFUN ("x-own-selection-internal", Fx_own_selection_internal,
-       Sx_own_selection_internal, 2, 3, 0,
+DEFUN ("ns-own-selection-internal", Fns_own_selection_internal,
+       Sns_own_selection_internal, 2, 2, 0,
        doc: /* Assert an X selection of type SELECTION and value VALUE.
 SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.
 \(Those are literal upper-case symbol names, since that's what X expects.)
 VALUE is typically a string, or a cons of two markers, but may be
-anything that the functions on `selection-converter-alist' know about.
-
-FRAME should be a frame that should own the selection.  If omitted or
-nil, it defaults to the selected frame.
-
-On Nextstep, FRAME is unused.  */)
-     (Lisp_Object selection, Lisp_Object value, Lisp_Object frame)
+anything that the functions on `selection-converter-alist' know about.  */)
+     (Lisp_Object selection, Lisp_Object value)
 {
   id pb;
   Lisp_Object old_value, new_value;
@@ -385,21 +380,11 @@ On Nextstep, FRAME is unused.  */)
 }
 
 
-DEFUN ("x-disown-selection-internal", Fx_disown_selection_internal,
-       Sx_disown_selection_internal, 1, 3, 0,
+DEFUN ("ns-disown-selection-internal", Fns_disown_selection_internal,
+       Sns_disown_selection_internal, 1, 1, 0,
        doc: /* If we own the selection SELECTION, disown it.
-Disowning it means there is no such selection.
-
-Sets the last-change time for the selection to TIME-OBJECT (by default
-the time of the last event).
-
-TERMINAL should be a terminal object or a frame specifying the X
-server to query.  If omitted or nil, that stands for the selected
-frame's display, or the first available X display.
-
-On Nextstep, the TIME-OBJECT and TERMINAL arguments are unused.
-On MS-DOS, all this does is return non-nil if we own the selection.  */)
-  (Lisp_Object selection, Lisp_Object time_object, Lisp_Object terminal)
+Disowning it means there is no such selection.  */)
+  (Lisp_Object selection)
 {
   id pb;
   check_window_system (NULL);
@@ -443,7 +428,7 @@ On Nextstep, TERMINAL is unused.  */)
 }
 
 
-DEFUN ("x-selection-owner-p", Fx_selection_owner_p, Sx_selection_owner_p,
+DEFUN ("ns-selection-owner-p", Fns_selection_owner_p, Sns_selection_owner_p,
        0, 2, 0,
        doc: /* Whether the current Emacs process owns the given X Selection.
 The arg should be the name of the selection in question, typically one of
@@ -507,7 +492,7 @@ On Nextstep, TIME-STAMP and TERMINAL are unused.  */)
 DEFUN ("ns-get-selection-internal", Fns_get_selection_internal,
        Sns_get_selection_internal, 1, 1, 0,
        doc: /* Returns the value of SELECTION as a string.
-SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'. */)
+SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.  */)
      (Lisp_Object selection)
 {
   id pb;
@@ -520,7 +505,7 @@ SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'. */)
 DEFUN ("ns-store-selection-internal", Fns_store_selection_internal,
        Sns_store_selection_internal, 2, 2, 0,
        doc: /* Sets the string value of SELECTION.
-SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'. */)
+SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.  */)
      (Lisp_Object selection, Lisp_Object string)
 {
   id pb;
@@ -546,11 +531,11 @@ syms_of_nsselect (void)
   QTEXT      = intern_c_string ("TEXT");        staticpro (&QTEXT);
   QFILE_NAME = intern_c_string ("FILE_NAME");   staticpro (&QFILE_NAME);
 
-  defsubr (&Sx_disown_selection_internal);
+  defsubr (&Sns_disown_selection_internal);
   defsubr (&Sx_get_selection_internal);
-  defsubr (&Sx_own_selection_internal);
+  defsubr (&Sns_own_selection_internal);
   defsubr (&Sx_selection_exists_p);
-  defsubr (&Sx_selection_owner_p);
+  defsubr (&Sns_selection_owner_p);
   defsubr (&Sns_get_selection_internal);
   defsubr (&Sns_store_selection_internal);
 
diff --git a/src/nsterm.h b/src/nsterm.h
index 00a0b54add9..f59405fe9af 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -27,12 +27,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifdef HAVE_NS
 
 #ifdef NS_IMPL_COCOA
-#ifndef MAC_OS_X_VERSION_10_4
-#define MAC_OS_X_VERSION_10_4 1040
-#endif
-#ifndef MAC_OS_X_VERSION_10_5
-#define MAC_OS_X_VERSION_10_5 1050
-#endif
 #ifndef MAC_OS_X_VERSION_10_6
 #define MAC_OS_X_VERSION_10_6 1060
 #endif
@@ -58,21 +52,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    versions.
    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
@@ -139,7 +119,7 @@ typedef float EmacsCGFloat;
 
 @class EmacsToolbar;
 
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
 @interface EmacsView : NSView <NSTextInput, NSWindowDelegate>
 #else
 @interface EmacsView : NSView <NSTextInput>
@@ -217,7 +197,7 @@ typedef float EmacsCGFloat;
 
    ========================================================================== */
 
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
 @interface EmacsMenu : NSMenu  <NSMenuDelegate>
 #else
 @interface EmacsMenu : NSMenu
@@ -249,7 +229,7 @@ typedef float EmacsCGFloat;
 
 @class EmacsImage;
 
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
 @interface EmacsToolbar : NSToolbar <NSToolbarDelegate>
 #else
 @interface EmacsToolbar : NSToolbar
@@ -305,7 +285,7 @@ typedef float EmacsCGFloat;
 - (void)timeout_handler: (NSTimer *)timedEntry;
 @end
 
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
 @interface EmacsTooltip : NSObject <NSWindowDelegate>
 #else
 @interface EmacsTooltip : NSObject
@@ -401,7 +381,7 @@ typedef float EmacsCGFloat;
    CGFloat last_mouse_offset;
    float min_portion;
    int pixel_height;
-   int last_hit_part;
+   enum scroll_bar_part last_hit_part;
 
    BOOL condemned;
 
diff --git a/src/nsterm.m b/src/nsterm.m
index 47ad28aaa61..3ae4146dc20 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -65,10 +65,8 @@ GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
 #endif
 
 #ifdef NS_IMPL_COCOA
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
 #include "macfont.h"
 #endif
-#endif
 
 /* call tracing */
 #if 0
@@ -706,7 +704,6 @@ static void
 ns_update_auto_hide_menu_bar (void)
 {
 #ifdef NS_IMPL_COCOA
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
   block_input ();
 
   NSTRACE (ns_update_auto_hide_menu_bar);
@@ -739,7 +736,6 @@ ns_update_auto_hide_menu_bar (void)
 
   unblock_input ();
 #endif
-#endif
 }
 
 
@@ -1930,10 +1926,9 @@ ns_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
           position = [view convertPoint: position fromView: nil];
           remember_mouse_glyph (f, position.x, position.y,
                                 &dpyinfo->last_mouse_glyph);
-/*fprintf (stderr, "ns_mouse_position: %.0f, %.0f\n", position.x, position.y); */
 
           if (bar_window) *bar_window = Qnil;
-          if (part) *part = 0; /*scroll_bar_handle; */
+          if (part) *part = scroll_bar_above_handle;
 
           if (x) XSETINT (*x, lrint (position.x));
           if (y) XSETINT (*y, lrint (position.y));
@@ -2347,8 +2342,19 @@ ns_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
          to erase the whole background. */
       [ns_lookup_indexed_color(face->background, f) set];
       NSRectFill (r);
-      [img setXBMColor: ns_lookup_indexed_color(face->foreground, f)];
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+
+      {
+        NSColor *bm_color;
+        if (!p->cursor_p)
+          bm_color = ns_lookup_indexed_color(face->foreground, f);
+        else if (p->overlay_p)
+          bm_color = ns_lookup_indexed_color(face->background, f);
+        else
+          bm_color = f->output_data.ns->cursor_color;
+        [img setXBMColor: bm_color];
+      }
+
+#ifdef NS_IMPL_COCOA
       [img drawInRect: r
               fromRect: NSZeroRect
              operation: NSCompositeSourceOver
@@ -2431,7 +2437,10 @@ ns_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
   else if (cursor_type == HBAR_CURSOR)
     {
       cursor_height = (cursor_width < 1) ? lrint (0.25 * h) : cursor_width;
-      fy += h - cursor_height;
+      if (cursor_height > glyph_row->height)
+        cursor_height = glyph_row->height;
+      if (h > cursor_height) // Cursor smaller than line height, move down
+        fy += h - cursor_height;
       h = cursor_height;
     }
 
@@ -3024,7 +3033,7 @@ ns_dumpglyphs_image (struct glyph_string *s, NSRect r)
   /* Draw the image.. do we need to draw placeholder if img ==nil? */
   if (img != nil)
     {
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
       NSRect dr = NSMakeRect (x, y, s->slice.width, s->slice.height);
       NSRect ir = NSMakeRect (s->slice.x, s->slice.y,
                               s->slice.width, s->slice.height);
@@ -3436,9 +3445,8 @@ check_native_fs ()
 }
 #endif
 
-/* 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
+/* GNUstep does not have cancelTracking.  */
+#ifdef NS_IMPL_COCOA
 /* Check if menu open should be canceled or continued as normal.  */
 void
 ns_check_menu_open (NSMenu *menu)
@@ -3501,7 +3509,16 @@ ns_check_pending_open_menu ()
       menu_will_open_state = MENU_OPENING;
     }
 }
-#endif /* NS_IMPL_COCOA) && >= MAC_OS_X_VERSION_10_5 */
+#endif /* NS_IMPL_COCOA */
+
+static void
+unwind_apploopnr (Lisp_Object not_used)
+{
+  --apploopnr;
+  n_emacs_events_pending = 0;
+  ns_finish_events ();
+  q_event_ptr = NULL;
+}
 
 static int
 ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
@@ -3560,6 +3577,7 @@ ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
     }
   else
     {
+      ptrdiff_t specpdl_count = SPECPDL_INDEX ();
       /* Run and wait for events.  We must always send one NX_APPDEFINED event
          to ourself, otherwise [NXApp run] will never exit.  */
       send_appdefined = YES;
@@ -3569,8 +3587,9 @@ ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
         {
           emacs_abort ();
         }
+      record_unwind_protect (unwind_apploopnr, Qt);
       [NSApp run];
-      --apploopnr;
+      unbind_to (specpdl_count, Qnil);  /* calls unwind_apploopnr */
     }
 
   nevents = n_emacs_events_pending;
@@ -3677,8 +3696,14 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
     {
       emacs_abort ();
     }
-  [NSApp run];
-  --apploopnr;
+
+  {
+    ptrdiff_t specpdl_count = SPECPDL_INDEX ();
+    record_unwind_protect (unwind_apploopnr, Qt);
+    [NSApp run];
+    unbind_to (specpdl_count, Qnil);  /* calls unwind_apploopnr */
+  }
+
   ns_finish_events ();
   if (nr > 0 && readfds)
     {
@@ -4493,7 +4518,7 @@ ns_term_shutdown (int sig)
 #define NSAppKitVersionNumber10_8 1187
 #endif
 
-  if (NSAppKitVersionNumber <= NSAppKitVersionNumber10_8) 
+  if (NSAppKitVersionNumber <= NSAppKitVersionNumber10_8)
     {
       [super run];
       return;
@@ -4690,14 +4715,12 @@ ns_term_shutdown (int sig)
 
   [self antialiasThresholdDidChange:nil];
 #ifdef NS_IMPL_COCOA
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
   [[NSNotificationCenter defaultCenter]
     addObserver:self
        selector:@selector(antialiasThresholdDidChange:)
            name:NSAntialiasThresholdChangedNotification
          object:nil];
 #endif
-#endif
 
   ns_send_appdefined (-2);
 }
@@ -4705,10 +4728,8 @@ ns_term_shutdown (int sig)
 - (void)antialiasThresholdDidChange:(NSNotification *)notification
 {
 #ifdef NS_IMPL_COCOA
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
   macfont_update_antialias_threshold ();
 #endif
-#endif
 }
 
 
@@ -5048,13 +5069,11 @@ not_in_argv (NSString *arg)
   if (!emacs_event)
     return;
 
-  if (EQ (font->driver->type, Qns))
-    nsfont = ((struct nsfont_info *)font)->nsfont;
-#ifdef NS_IMPL_COCOA
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
-  else
-    nsfont = (NSFont *) macfont_get_nsctfont (font);
+#ifdef NS_IMPL_GNUSTEP
+  nsfont = ((struct nsfont_info *)font)->nsfont;
 #endif
+#ifdef NS_IMPL_COCOA
+  nsfont = (NSFont *) macfont_get_nsctfont (font);
 #endif
 
   if ((newFont = [sender convertFont: nsfont]))
@@ -5106,7 +5125,7 @@ not_in_argv (NSString *arg)
   int code;
   unsigned fnKeysym = 0;
   static NSMutableArray *nsEvArray;
-#if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_GNUSTEP
   static BOOL firstTime = YES;
 #endif
   int left_is_none;
@@ -5337,7 +5356,7 @@ not_in_argv (NSString *arg)
     }
 
 
-#if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_GNUSTEP
   /* if we get here we should send the key for input manager processing */
   /* Disable warning, there is nothing a user can do about it anyway, and
      it does not seem to matter.  */
@@ -5797,7 +5816,8 @@ not_in_argv (NSString *arg)
     {
 #ifdef NS_IMPL_GNUSTEP
       // GNUstep does not always update the tool bar height.  Force it.
-      if (toolbar) update_frame_tool_bar (emacsframe);
+      if (toolbar && [toolbar isVisible])
+          update_frame_tool_bar (emacsframe);
 #endif
 
       extra = FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
@@ -5838,10 +5858,13 @@ not_in_argv (NSString *arg)
 
       // Did resize increments change because of a font change?
       if (sz.width != FRAME_COLUMN_WIDTH (emacsframe) ||
-          sz.height != FRAME_LINE_HEIGHT (emacsframe))
+          sz.height != FRAME_LINE_HEIGHT (emacsframe) ||
+          (frame_resize_pixelwise && sz.width != 1))
         {
-          sz.width = FRAME_COLUMN_WIDTH (emacsframe);
-          sz.height = FRAME_LINE_HEIGHT (emacsframe);
+          sz.width = frame_resize_pixelwise
+            ? 1 : FRAME_COLUMN_WIDTH (emacsframe);
+          sz.height = frame_resize_pixelwise
+            ? 1 : FRAME_LINE_HEIGHT (emacsframe);
           [win setResizeIncrements: sz];
 
           NSTRACE_SIZE ("New size", NSMakeSize (neww, newh));
@@ -6111,8 +6134,8 @@ if (cols > 0 && rows > 0)
   [win setDelegate: self];
   [win useOptimizedDrawing: YES];
 
-  sz.width = FRAME_COLUMN_WIDTH (f);
-  sz.height = FRAME_LINE_HEIGHT (f);
+  sz.width = frame_resize_pixelwise ? 1 : FRAME_COLUMN_WIDTH (f);
+  sz.height = frame_resize_pixelwise ? 1 : FRAME_LINE_HEIGHT (f);
   [win setResizeIncrements: sz];
 
   [[win contentView] addSubview: self];
@@ -6459,8 +6482,8 @@ if (cols > 0 && rows > 0)
                                  (FRAME_DEFAULT_FACE (f)),
                                  f);
 
-  sz.width = FRAME_COLUMN_WIDTH (f);
-  sz.height = FRAME_LINE_HEIGHT (f);
+  sz.width = frame_resize_pixelwise ? 1 : FRAME_COLUMN_WIDTH (f);
+  sz.height = frame_resize_pixelwise ? 1 : FRAME_LINE_HEIGHT (f);
 
   if (fs_state != FULLSCREEN_BOTH)
     {
@@ -6475,8 +6498,7 @@ if (cols > 0 && rows > 0)
       /* Hide dock and menubar if we are on the primary screen.  */
       if (onFirstScreen)
         {
-#if defined (NS_IMPL_COCOA) && \
-  MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
           NSApplicationPresentationOptions options
             = NSApplicationPresentationAutoHideDock
             | NSApplicationPresentationAutoHideMenuBar;
@@ -6516,7 +6538,7 @@ if (cols > 0 && rows > 0)
       [fw makeFirstResponder:self];
       [w orderOut:self];
       r = [fw frameRectForContentRect:[screen frame]];
-      [fw setFrame: r display:YES animate:YES];
+      [fw setFrame: r display:YES animate:ns_use_fullscreen_animation];
       [self windowDidEnterFullScreen:nil];
       [fw display];
     }
@@ -6528,8 +6550,7 @@ if (cols > 0 && rows > 0)
 
       if (onFirstScreen)
         {
-#if defined (NS_IMPL_COCOA) && \
-  MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#ifdef NS_IMPL_COCOA
           [NSApp setPresentationOptions: NSApplicationPresentationDefault];
 #else
           [NSMenu setMenuBarVisible:YES];
@@ -6548,7 +6569,7 @@ if (cols > 0 && rows > 0)
         FRAME_TOOLBAR_HEIGHT (f) = tobar_height;
 
       [self windowWillExitFullScreen:nil];
-      [fw setFrame: [w frame] display:YES animate:YES];
+      [fw setFrame: [w frame] display:YES animate:ns_use_fullscreen_animation];
       [fw close];
       [w makeKeyAndOrderFront:NSApp];
       [self windowDidExitFullScreen:nil];
@@ -6854,7 +6875,7 @@ if (cols > 0 && rows > 0)
     }
   else
     {
-      error ("Invalid data type in dragging pasteboard");
+      fprintf (stderr, "Invalid data type in dragging pasteboard");
       return NO;
     }
 }
@@ -7044,7 +7065,7 @@ if (cols > 0 && rows > 0)
 #endif
 #endif
 
-  for (i = 0; i < nr_screens; ++i) 
+  for (i = 0; i < nr_screens; ++i)
     {
       NSScreen *s = [screens objectAtIndex: i];
       NSRect scrrect = [s frame];
@@ -7251,7 +7272,7 @@ if (cols > 0 && rows > 0)
 
   if (portion >= whole)
     {
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5
+#ifdef NS_IMPL_COCOA
       [self setKnobProportion: 1.0];
       [self setDoubleValue: 1.0];
 #else
@@ -7265,7 +7286,7 @@ if (cols > 0 && rows > 0)
       portion = max ((float)whole*min_portion/pixel_height, portion);
       pos = (float)position / (whole - portion);
       por = (CGFloat)portion/whole;
-#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5
+#ifdef NS_IMPL_COCOA
       [self setKnobProportion: por];
       [self setDoubleValue: pos];
 #else
@@ -7491,7 +7512,7 @@ if (cols > 0 && rows > 0)
       [scroll_repeat_entry release];
       scroll_repeat_entry = nil;
     }
-  last_hit_part = 0;
+  last_hit_part = scroll_bar_above_handle;
 }
 
 
@@ -7752,6 +7773,12 @@ Default is t for OSX >= 10.7, nil otherwise.  */);
 #endif
   ns_last_use_native_fullscreen = ns_use_native_fullscreen;
 
+  DEFVAR_BOOL ("ns-use-fullscreen-animation", ns_use_fullscreen_animation,
+     doc: /*Non-nil means use animation on non-native fullscreen.
+For native fullscreen, this does nothing.
+Default is nil.  */);
+  ns_use_fullscreen_animation = NO;
+
   DEFVAR_BOOL ("ns-use-srgb-colorspace", ns_use_srgb_colorspace,
      doc: /*Non-nil means to use sRGB colorspace on OSX >= 10.7.
 Note that this does not apply to images.
@@ -7789,14 +7816,12 @@ baseline level.  The default value is nil.  */);
   DEFSYM (Qcocoa, "cocoa");
   DEFSYM (Qgnustep, "gnustep");
 
-  syms_of_nsfont ();
 #ifdef NS_IMPL_COCOA
   Fprovide (Qcocoa, Qnil);
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
   syms_of_macfont ();
-#endif
 #else
   Fprovide (Qgnustep, Qnil);
+  syms_of_nsfont ();
 #endif
 
 }
diff --git a/src/print.c b/src/print.c
index 57fac7af378..49331ef0984 100644
--- a/src/print.c
+++ b/src/print.c
@@ -58,6 +58,9 @@ static ptrdiff_t new_backquote_output;
 #define PRINT_CIRCLE 200
 static Lisp_Object being_printed[PRINT_CIRCLE];
 
+/* Last char printed to stdout by printchar.  */
+static unsigned int printchar_stdout_last;
+
 /* When printing into a buffer, first we put the text in this
    block, then insert it all at once.  */
 static char *print_buffer;
@@ -169,11 +172,13 @@ bool print_output_debug_flag EXTERNALLY_VISIBLE = 1;
        if (print_buffer_pos != print_buffer_pos_byte                    \
            && NILP (BVAR (current_buffer, enable_multibyte_characters)))\
          {                                                              \
-           unsigned char *temp = alloca (print_buffer_pos + 1);         \
+           USE_SAFE_ALLOCA;                                             \
+           unsigned char *temp = SAFE_ALLOCA (print_buffer_pos + 1);    \
            copy_text ((unsigned char *) print_buffer, temp,             \
                       print_buffer_pos_byte, 1, 0);                     \
            insert_1_both ((char *) temp, print_buffer_pos,              \
                           print_buffer_pos, 0, 1, 0);                   \
+           SAFE_FREE ();                                                \
          }                                                              \
        else                                                             \
          insert_1_both (print_buffer, print_buffer_pos,                 \
@@ -236,6 +241,7 @@ printchar (unsigned int ch, Lisp_Object fun)
         }
       else if (noninteractive)
         {
+          printchar_stdout_last = ch;
           fwrite (str, 1, len, stdout);
           noninteractive_need_newline = 1;
         }
@@ -513,19 +519,33 @@ static void print_preprocess (Lisp_Object);
 static void print_preprocess_string (INTERVAL, Lisp_Object);
 static void print_object (Lisp_Object, Lisp_Object, bool);
 
-DEFUN ("terpri", Fterpri, Sterpri, 0, 1, 0,
+DEFUN ("terpri", Fterpri, Sterpri, 0, 2, 0,
        doc: /* Output a newline to stream PRINTCHARFUN.
+If ENSURE is non-nil only output a newline if not already at the
+beginning of a line.  Value is non-nil if a newline is printed.
 If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.  */)
-  (Lisp_Object printcharfun)
+  (Lisp_Object printcharfun, Lisp_Object ensure)
 {
-  PRINTDECLARE;
+  Lisp_Object val = Qnil;
 
+  PRINTDECLARE;
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
   PRINTPREPARE;
-  PRINTCHAR ('\n');
+
+  if (NILP (ensure))
+    val = Qt;
+  /* Difficult to check if at line beginning so abort.  */
+  else if (FUNCTIONP (printcharfun))
+    signal_error ("Unsupported function argument", printcharfun);
+  else if (noninteractive && !NILP (printcharfun))
+    val = printchar_stdout_last == 10 ? Qnil : Qt;
+  else if (NILP (Fbolp ()))
+    val = Qt;
+
+  if (!NILP (val)) PRINTCHAR ('\n');
   PRINTFINISH;
-  return Qt;
+  return val;
 }
 
 DEFUN ("prin1", Fprin1, Sprin1, 1, 2, 0,
@@ -581,7 +601,6 @@ A printed representation of an object is text which describes that object.  */)
 {
   Lisp_Object printcharfun;
   bool prev_abort_on_gc;
-  /* struct gcpro gcpro1, gcpro2; */
   Lisp_Object save_deactivate_mark;
   ptrdiff_t count = SPECPDL_INDEX ();
   struct buffer *previous;
@@ -595,7 +614,6 @@ A printed representation of an object is text which describes that object.  */)
        but we don't want to deactivate the mark just for that.
        No need for specbind, since errors deactivate the mark.  */
     save_deactivate_mark = Vdeactivate_mark;
-    /* GCPRO2 (object, save_deactivate_mark); */
     prev_abort_on_gc = abort_on_gc;
     abort_on_gc = 1;
 
@@ -619,7 +637,6 @@ A printed representation of an object is text which describes that object.  */)
   set_buffer_internal (previous);
 
   Vdeactivate_mark = save_deactivate_mark;
-  /* UNGCPRO; */
 
   abort_on_gc = prev_abort_on_gc;
   return unbind_to (count, object);
diff --git a/src/process.c b/src/process.c
index 0d6994bdab1..06fc918cf54 100644
--- a/src/process.c
+++ b/src/process.c
@@ -173,6 +173,9 @@ close_on_exec (int fd)
   return fd;
 }
 
+# undef accept4
+# define accept4(sockfd, addr, addrlen, flags) \
+    process_accept4 (sockfd, addr, addrlen, flags)
 static int
 accept4 (int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags)
 {
@@ -596,7 +599,7 @@ status_message (struct Lisp_Process *p)
   Lisp_Object symbol;
   int code;
   bool coredump;
-  Lisp_Object string, string2;
+  Lisp_Object string;
 
   decode_status (status, &symbol, &code, &coredump);
 
@@ -620,8 +623,8 @@ status_message (struct Lisp_Process *p)
           if (c1 != c2)
             Faset (string, make_number (0), make_number (c2));
         }
-      string2 = build_string (coredump ? " (core dumped)\n" : "\n");
-      return concat2 (string, string2);
+      AUTO_STRING (suffix, coredump ? " (core dumped)\n" : "\n");
+      return concat2 (string, suffix);
     }
   else if (EQ (symbol, Qexit))
     {
@@ -629,17 +632,17 @@ status_message (struct Lisp_Process *p)
         return build_string (code == 0 ? "deleted\n" : "connection broken by remote peer\n");
       if (code == 0)
         return build_string ("finished\n");
+      AUTO_STRING (prefix, "exited abnormally with code ");
       string = Fnumber_to_string (make_number (code));
-      string2 = build_string (coredump ? " (core dumped)\n" : "\n");
-      return concat3 (build_string ("exited abnormally with code "),
-                      string, string2);
+      AUTO_STRING (suffix, coredump ? " (core dumped)\n" : "\n");
+      return concat3 (prefix, string, suffix);
     }
   else if (EQ (symbol, Qfailed))
     {
+      AUTO_STRING (prefix, "failed with code ");
       string = Fnumber_to_string (make_number (code));
-      string2 = build_string ("\n");
-      return concat3 (build_string ("failed with code "),
-                      string, string2);
+      AUTO_STRING (suffix, "\n");
+      return concat3 (prefix, string, suffix);
     }
   else
     return Fcopy_sequence (Fsymbol_name (symbol));
@@ -1302,30 +1305,34 @@ Returns nil if format of ADDRESS is invalid.  */)
       ptrdiff_t size = p->header.size;
       Lisp_Object args[10];
       int nargs, i;
+      char const *format;
 
       if (size == 4 || (size == 5 && !NILP (omit_port)))
         {
-          args[0] = build_string ("%d.%d.%d.%d");
+          format = "%d.%d.%d.%d";
           nargs = 4;
         }
       else if (size == 5)
         {
-          args[0] = build_string ("%d.%d.%d.%d:%d");
+          format = "%d.%d.%d.%d:%d";
           nargs = 5;
         }
       else if (size == 8 || (size == 9 && !NILP (omit_port)))
         {
-          args[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
+          format = "%x:%x:%x:%x:%x:%x:%x:%x";
           nargs = 8;
         }
       else if (size == 9)
         {
-          args[0] = build_string ("[%x:%x:%x:%x:%x:%x:%x:%x]:%d");
+          format = "[%x:%x:%x:%x:%x:%x:%x:%x]:%d";
           nargs = 9;
         }
       else
         return Qnil;
 
+      AUTO_STRING (format_obj, format);
+      args[0] = format_obj;
+
       for (i = 0; i < nargs; i++)
         {
           if (! RANGED_INTEGERP (0, p->contents[i], 65535))
@@ -1339,15 +1346,13 @@ Returns nil if format of ADDRESS is invalid.  */)
           args[i+1] = p->contents[i];
         }
 
-      return Fformat (nargs+1, args);
+      return Fformat (nargs + 1, args);
     }
 
   if (CONSP (address))
     {
-      Lisp_Object args[2];
-      args[0] = build_string ("<Family %d>");
-      args[1] = Fcar (address);
-      return Fformat (2, args);
+      AUTO_STRING (format, "<Family %d>");
+      return Fformat (2, (Lisp_Object []) {format, Fcar (address)});
     }
 
   return Qnil;
@@ -1386,9 +1391,10 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object buffer, name, program, proc, current_dir, tem;
-  register unsigned char **new_argv;
+  unsigned char **new_argv;
   ptrdiff_t i;
   ptrdiff_t count = SPECPDL_INDEX ();
+  USE_SAFE_ALLOCA;
 
   buffer = args[1];
   if (!NILP (buffer))
@@ -1464,7 +1470,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
     val = Vcoding_system_for_read;
     if (NILP (val))
       {
-        args2 = alloca ((nargs + 1) * sizeof *args2);
+        SAFE_ALLOCA_LISP (args2, nargs + 1);
         args2[0] = Qstart_process;
         for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
         GCPRO2 (proc, current_dir);
@@ -1483,7 +1489,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
       {
         if (EQ (coding_systems, Qt))
           {
-            args2 = alloca ((nargs + 1) * sizeof *args2);
+            SAFE_ALLOCA_LISP (args2, nargs + 1);
             args2[0] = Qstart_process;
             for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
             GCPRO2 (proc, current_dir);
@@ -1578,7 +1584,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
 
       /* Now that everything is encoded we can collect the strings into
          NEW_ARGV.  */
-      new_argv = alloca ((nargs - 1) * sizeof *new_argv);
+      SAFE_NALLOCA (new_argv, 1, nargs - 1);
       new_argv[nargs - 2] = 0;
 
       for (i = nargs - 2; i-- != 0; )
@@ -1592,6 +1598,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
   else
     create_pty (proc);
 
+  SAFE_FREE ();
   return unbind_to (count, proc);
 }
 
@@ -2071,8 +2078,10 @@ get_lisp_to_sockaddr_size (Lisp_Object address, int *familyp)
            && VECTORP (XCDR (address)))
     {
       struct sockaddr *sa;
-      *familyp = XINT (XCAR (address));
       p = XVECTOR (XCDR (address));
+      if (MAX_ALLOCA - sizeof sa->sa_family < p->header.size)
+        return 0;
+      *familyp = XINT (XCAR (address));
       return p->header.size + sizeof (sa->sa_family);
     }
   return 0;
@@ -2989,7 +2998,7 @@ usage: (make-network-process &rest ARGS)  */)
       address_un.sun_family = AF_LOCAL;
       if (sizeof address_un.sun_path <= SBYTES (service))
         error ("Service name too long");
-      strcpy (address_un.sun_path, SSDATA (service));
+      lispstpcpy (address_un.sun_path, service);
       ai.ai_addr = (struct sockaddr *) &address_un;
       ai.ai_addrlen = sizeof address_un;
       goto open_socket;
@@ -3680,7 +3689,7 @@ network_interface_info (Lisp_Object ifname)
 
   if (sizeof rq.ifr_name <= SBYTES (ifname))
     error ("interface name too long");
-  strcpy (rq.ifr_name, SSDATA (ifname));
+  lispstpcpy (rq.ifr_name, ifname);
 
   s = socket (AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
   if (s < 0)
@@ -4057,20 +4066,15 @@ server_accept_connection (Lisp_Object server, int channel)
     {
     case AF_INET:
       {
-        Lisp_Object args[5];
         unsigned char *ip = (unsigned char *)&saddr.in.sin_addr.s_addr;
-        args[0] = build_string ("%d.%d.%d.%d");
-        args[1] = make_number (*ip++);
-        args[2] = make_number (*ip++);
-        args[3] = make_number (*ip++);
-        args[4] = make_number (*ip++);
-        host = Fformat (5, args);
-        service = make_number (ntohs (saddr.in.sin_port));
 
-        args[0] = build_string (" <%s:%d>");
-        args[1] = host;
-        args[2] = service;
-        caller = Fformat (3, args);
+        AUTO_STRING (ipv4_format, "%d.%d.%d.%d");
+        host = Fformat (5, ((Lisp_Object [])
+          { ipv4_format, make_number (ip[0]),
+            make_number (ip[1]), make_number (ip[2]), make_number (ip[3]) }));
+        service = make_number (ntohs (saddr.in.sin_port));
+        AUTO_STRING (caller_format, " <%s:%d>");
+        caller = Fformat (3, (Lisp_Object []) {caller_format, host, service});
       }
       break;
 
@@ -4080,16 +4084,15 @@ server_accept_connection (Lisp_Object server, int channel)
         Lisp_Object args[9];
         uint16_t *ip6 = (uint16_t *)&saddr.in6.sin6_addr;
         int i;
-        args[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
+
+        AUTO_STRING (ipv6_format, "%x:%x:%x:%x:%x:%x:%x:%x");
+        args[0] = ipv6_format;
         for (i = 0; i < 8; i++)
-          args[i+1] = make_number (ntohs (ip6[i]));
+          args[i + 1] = make_number (ntohs (ip6[i]));
         host = Fformat (9, args);
         service = make_number (ntohs (saddr.in.sin_port));
-
-        args[0] = build_string (" <[%s]:%d>");
-        args[1] = host;
-        args[2] = service;
-        caller = Fformat (3, args);
+        AUTO_STRING (caller_format, " <[%s]:%d>");
+        caller = Fformat (3, (Lisp_Object []) {caller_format, host, service});
       }
       break;
 #endif
@@ -4099,7 +4102,9 @@ server_accept_connection (Lisp_Object server, int channel)
 #endif
     default:
       caller = Fnumber_to_string (make_number (connect_counter));
-      caller = concat3 (build_string (" <"), caller, build_string (">"));
+      AUTO_STRING (space_less_than, " <");
+      AUTO_STRING (greater_than, ">");
+      caller = concat3 (space_less_than, caller, greater_than);
       break;
     }
 
@@ -4196,16 +4201,18 @@ server_accept_connection (Lisp_Object server, int channel)
   p->inherit_coding_system_flag
     = (NILP (buffer) ? 0 : ps->inherit_coding_system_flag);
 
+  AUTO_STRING (dash, "-");
+  AUTO_STRING (nl, "\n");
+  Lisp_Object host_string = STRINGP (host) ? host : dash;
+
   if (!NILP (ps->log))
-      call3 (ps->log, server, proc,
-             concat3 (build_string ("accept from "),
-                      (STRINGP (host) ? host : build_string ("-")),
-                      build_string ("\n")));
+    {
+      AUTO_STRING (accept_from, "accept from ");
+      call3 (ps->log, server, proc, concat3 (accept_from, host_string, nl));
+    }
 
-  exec_sentinel (proc,
-                 concat3 (build_string ("open from "),
-                          (STRINGP (host) ? host : build_string ("-")),
-                          build_string ("\n")));
+  AUTO_STRING (open_from, "open from ");
+  exec_sentinel (proc, concat3 (open_from, host_string, nl));
 }
 
 /* This variable is different from waiting_for_input in keyboard.c.
@@ -4973,18 +4980,17 @@ read_and_dispose_of_process_output (struct Lisp_Process *p, char *chars,
    for decoding.  */
 
 static int
-read_process_output (Lisp_Object proc, register int channel)
+read_process_output (Lisp_Object proc, int channel)
 {
-  register ssize_t nbytes;
-  char *chars;
-  register struct Lisp_Process *p = XPROCESS (proc);
+  ssize_t nbytes;
+  struct Lisp_Process *p = XPROCESS (proc);
   struct coding_system *coding = proc_decode_coding_system[channel];
   int carryover = p->decoding_carryover;
-  int readmax = 4096;
+  enum { readmax = 4096 };
   ptrdiff_t count = SPECPDL_INDEX ();
   Lisp_Object odeactivate;
+  char chars[sizeof coding->carryover + readmax];
 
-  chars = alloca (carryover + readmax);
   if (carryover)
     /* See the comment above.  */
     memcpy (chars, SDATA (p->decoding_buf), carryover);
@@ -6837,7 +6843,7 @@ add_timer_wait_descriptor (int fd)
 {
   FD_SET (fd, &input_wait_mask);
   FD_SET (fd, &non_keyboard_wait_mask);
-  FD_SET (fd, &non_process_wait_mask);  
+  FD_SET (fd, &non_process_wait_mask);
   fd_callback_info[fd].func = timerfd_callback;
   fd_callback_info[fd].data = NULL;
   fd_callback_info[fd].condition |= FOR_READ;
diff --git a/src/ralloc.c b/src/ralloc.c
index c82cd4548d2..e63ed34c89b 100644
--- a/src/ralloc.c
+++ b/src/ralloc.c
@@ -35,9 +35,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define M_TOP_PAD           -2
 extern int mallopt (int, int);
 #else /* not DOUG_LEA_MALLOC */
-#ifndef SYSTEM_MALLOC
+#if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
 extern size_t __malloc_extra_blocks;
-#endif /* SYSTEM_MALLOC */
+#endif /* not SYSTEM_MALLOC and not HYBRID_MALLOC */
 #endif /* not DOUG_LEA_MALLOC */
 
 #else /* not emacs */
@@ -95,7 +95,7 @@ static int extra_bytes;
 /* The hook `malloc' uses for the function which gets more space
    from the system.  */
 
-#ifndef SYSTEM_MALLOC
+#if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
 extern void *(*__morecore) (ptrdiff_t);
 #endif
 
@@ -1179,7 +1179,7 @@ r_alloc_init (void)
   r_alloc_initialized = 1;
 
   page_size = PAGE;
-#ifndef SYSTEM_MALLOC
+#if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
   real_morecore = __morecore;
   __morecore = r_alloc_sbrk;
 
@@ -1198,7 +1198,7 @@ r_alloc_init (void)
   mallopt (M_TOP_PAD, 64 * 4096);
   unblock_input ();
 #else
-#ifndef SYSTEM_MALLOC
+#if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
   /* Give GNU malloc's morecore some hysteresis so that we move all
      the relocatable blocks much less often.  The number used to be
      64, but alloc.c would override that with 32 in code that was
@@ -1211,7 +1211,7 @@ r_alloc_init (void)
 #endif
 #endif
 
-#ifndef SYSTEM_MALLOC
+#if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
   first_heap->end = (void *) PAGE_ROUNDUP (first_heap->start);
 
   /* The extra call to real_morecore guarantees that the end of the
diff --git a/src/regex.c b/src/regex.c
index 1c1164da57d..766ad26e709 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -457,11 +457,17 @@ init_syntax_once (void)
 
 # endif /* not alloca */
 
-# define REGEX_ALLOCATE alloca
+# ifdef emacs
+#  define REGEX_USE_SAFE_ALLOCA USE_SAFE_ALLOCA
+#  define REGEX_SAFE_FREE() SAFE_FREE ()
+#  define REGEX_ALLOCATE SAFE_ALLOCA
+# else
+#  define REGEX_ALLOCATE alloca
+# endif
 
 /* Assumes a `char *destination' variable.  */
 # define REGEX_REALLOCATE(source, osize, nsize)                         \
-  (destination = alloca (nsize),                                        \
+  (destination = REGEX_ALLOCATE (nsize),                                \
    memcpy (destination, source, osize))
 
 /* No need to do anything to free, after alloca.  */
@@ -469,6 +475,11 @@ init_syntax_once (void)
 
 #endif /* not REGEX_MALLOC */
 
+#ifndef REGEX_USE_SAFE_ALLOCA
+# define REGEX_USE_SAFE_ALLOCA ((void) 0)
+# define REGEX_SAFE_FREE() ((void) 0)
+#endif
+
 /* Define how to allocate the failure stack.  */
 
 #if defined REL_ALLOC && defined REGEX_MALLOC
@@ -482,22 +493,10 @@ init_syntax_once (void)
 
 #else /* not using relocating allocator */
 
-# ifdef REGEX_MALLOC
-
-#  define REGEX_ALLOCATE_STACK malloc
-#  define REGEX_REALLOCATE_STACK(source, osize, nsize) realloc (source, nsize)
-#  define REGEX_FREE_STACK free
+# define REGEX_ALLOCATE_STACK(size) REGEX_ALLOCATE (size)
+# define REGEX_REALLOCATE_STACK(source, o, n) REGEX_REALLOCATE (source, o, n)
+# define REGEX_FREE_STACK(ptr) REGEX_FREE (ptr)
 
-# else /* not REGEX_MALLOC */
-
-#  define REGEX_ALLOCATE_STACK alloca
-
-#  define REGEX_REALLOCATE_STACK(source, osize, nsize)                  \
-   REGEX_REALLOCATE (source, osize, nsize)
-/* No need to explicitly free anything.  */
-#  define REGEX_FREE_STACK(arg) ((void)0)
-
-# endif /* not REGEX_MALLOC */
 #endif /* not using relocating allocator */
 
 
@@ -516,10 +515,12 @@ init_syntax_once (void)
 
 #define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
 
-#undef MAX
-#undef MIN
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#ifndef emacs  
+# undef max
+# undef min
+# define max(a, b) ((a) > (b) ? (a) : (b))
+# define min(a, b) ((a) < (b) ? (a) : (b))
+#endif
 
 /* Type of source-pattern and string chars.  */
 #ifdef _MSC_VER
@@ -1395,14 +1396,14 @@ typedef struct
    : ((fail_stack).stack                                                \
       = REGEX_REALLOCATE_STACK ((fail_stack).stack,                     \
           (fail_stack).size * sizeof (fail_stack_elt_t),                \
-          MIN (re_max_failures * TYPICAL_FAILURE_SIZE,                  \
+          min (re_max_failures * TYPICAL_FAILURE_SIZE,                  \
                ((fail_stack).size * sizeof (fail_stack_elt_t)           \
                 * FAIL_STACK_GROWTH_FACTOR))),                          \
                                                                         \
       (fail_stack).stack == NULL                                        \
       ? 0                                                               \
       : ((fail_stack).size                                              \
-         = (MIN (re_max_failures * TYPICAL_FAILURE_SIZE,                \
+         = (min (re_max_failures * TYPICAL_FAILURE_SIZE,                \
                  ((fail_stack).size * sizeof (fail_stack_elt_t)         \
                   * FAIL_STACK_GROWTH_FACTOR))                          \
             / sizeof (fail_stack_elt_t)),                               \
@@ -2310,8 +2311,8 @@ set_image_of_range (struct range_table_work_area *work_area,
                 cmin = c, cmax = c;
               else
                 {
-                  cmin = MIN (cmin, c);
-                  cmax = MAX (cmax, c);
+                  cmin = min (cmin, c);
+                  cmax = max (cmax, c);
                 }
             }
         }
@@ -2990,7 +2991,7 @@ regex_compile (const_re_char *pattern, size_t size, reg_syntax_t syntax,
 #else  /* emacs */
                     if (c < 128)
                       {
-                        ch = MIN (127, c1);
+                        ch = min (127, c1);
                         SETUP_ASCII_RANGE (range_table_work, c, ch);
                         c = ch + 1;
                         if (CHAR_BYTE8_P (c1))
@@ -4579,6 +4580,7 @@ static int bcmp_translate (re_char *s1, re_char *s2,
     FREE_VAR (regend);                                                  \
     FREE_VAR (best_regstart);                                           \
     FREE_VAR (best_regend);                                             \
+    REGEX_SAFE_FREE ();                                                 \
   } while (0)
 #else
 # define FREE_VARIABLES() ((void)0) /* Do nothing!  But inhibit gcc warning.  */
@@ -5018,6 +5020,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const_re_char *string1,
 
   DEBUG_PRINT ("\n\nEntering re_match_2.\n");
 
+  REGEX_USE_SAFE_ALLOCA;
+
   INIT_FAIL_STACK ();
 
 #ifdef MATCH_MAY_ALLOCATE
@@ -5208,7 +5212,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const_re_char *string1,
                 { /* No.  So allocate them with malloc.  We need one
                      extra element beyond `num_regs' for the `-1' marker
                      GNU code uses.  */
-                  regs->num_regs = MAX (RE_NREGS, num_regs + 1);
+                  regs->num_regs = max (RE_NREGS, num_regs + 1);
                   regs->start = TALLOC (regs->num_regs, regoff_t);
                   regs->end = TALLOC (regs->num_regs, regoff_t);
                   if (regs->start == NULL || regs->end == NULL)
@@ -5252,7 +5256,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const_re_char *string1,
 
               /* Go through the first `min (num_regs, regs->num_regs)'
                  registers, since that is all we initialized.  */
-              for (reg = 1; reg < MIN (num_regs, regs->num_regs); reg++)
+              for (reg = 1; reg < min (num_regs, regs->num_regs); reg++)
                 {
                   if (REG_UNSET (regstart[reg]) || REG_UNSET (regend[reg]))
                     regs->start[reg] = regs->end[reg] = -1;
diff --git a/src/regex.h b/src/regex.h
index 1b064987eb7..0e25723a85e 100644
--- a/src/regex.h
+++ b/src/regex.h
@@ -172,6 +172,9 @@ extern reg_syntax_t re_syntax_options;
 extern Lisp_Object re_match_object;
 #endif
 
+/* Roughly the maximum number of failure points on the stack.  */
+extern size_t re_max_failures;
+
 
 /* Define combinations of the above bits for the standard possibilities.
    (The [[[ comments delimit what gets put into the Texinfo file, so
diff --git a/src/scroll.c b/src/scroll.c
index 6c559663f80..7cb683c4577 100644
--- a/src/scroll.c
+++ b/src/scroll.c
@@ -245,18 +245,20 @@ do_scrolling (struct frame *frame, struct glyph_matrix *current_matrix,
 {
   struct matrix_elt *p;
   int i, j, k;
+  USE_SAFE_ALLOCA;
 
   /* True if we have set a terminal window with set_terminal_window.  */
   bool terminal_window_p = 0;
 
   /* A queue for line insertions to be done.  */
   struct queue { int count, pos; };
-  struct queue *queue_start
-    = alloca (current_matrix->nrows * sizeof *queue_start);
+  struct queue *queue_start;
+  SAFE_NALLOCA (queue_start, 1, current_matrix->nrows);
   struct queue *queue = queue_start;
 
-  char *retained_p = alloca (window_size * sizeof *retained_p);
-  int *copy_from = alloca (window_size * sizeof *copy_from);
+  char *retained_p = SAFE_ALLOCA (window_size);
+  int *copy_from;
+  SAFE_NALLOCA (copy_from, 1, window_size);
 
   /* Zero means line is empty.  */
   memset (retained_p, 0, window_size * sizeof (char));
@@ -378,6 +380,7 @@ do_scrolling (struct frame *frame, struct glyph_matrix *current_matrix,
 
   if (terminal_window_p)
     set_terminal_window (frame, 0);
+  SAFE_FREE ();
 }
 
 
@@ -649,10 +652,12 @@ do_direct_scrolling (struct frame *frame, struct glyph_matrix *current_matrix,
 {
   struct matrix_elt *p;
   int i, j;
+  USE_SAFE_ALLOCA;
 
   /* A queue of deletions and insertions to be performed.  */
   struct alt_queue { int count, pos, window; };
-  struct alt_queue *queue_start = alloca (window_size * sizeof *queue_start);
+  struct alt_queue *queue_start;
+  SAFE_NALLOCA (queue_start, 1, window_size);
   struct alt_queue *queue = queue_start;
 
   /* True if a terminal window has been set with set_terminal_window.  */
@@ -667,11 +672,12 @@ do_direct_scrolling (struct frame *frame, struct glyph_matrix *current_matrix,
   bool write_follows_p = 1;
 
   /* For each row in the new matrix what row of the old matrix it is.  */
-  int *copy_from = alloca (window_size * sizeof *copy_from);
+  int *copy_from;
+  SAFE_NALLOCA (copy_from, 1, window_size);
 
   /* Non-zero for each row in the new matrix that is retained from the
      old matrix.  Lines not retained are empty.  */
-  char *retained_p = alloca (window_size * sizeof *retained_p);
+  char *retained_p = SAFE_ALLOCA (window_size);
 
   memset (retained_p, 0, window_size * sizeof (char));
 
@@ -787,6 +793,7 @@ do_direct_scrolling (struct frame *frame, struct glyph_matrix *current_matrix,
 
   if (terminal_window_p)
     set_terminal_window (frame, 0);
+  SAFE_FREE ();
 }
 
 
@@ -796,8 +803,9 @@ scrolling_1 (struct frame *frame, int window_size, int unchanged_at_top,
              int unchanged_at_bottom, int *draw_cost, int *old_draw_cost,
              unsigned *old_hash, unsigned *new_hash, int free_at_end)
 {
-  struct matrix_elt *matrix
-    = alloca ((window_size + 1) * (window_size + 1) * sizeof *matrix);
+  USE_SAFE_ALLOCA;
+  struct matrix_elt *matrix;
+  SAFE_NALLOCA (matrix, window_size + 1, window_size + 1);
 
   if (FRAME_SCROLL_REGION_OK (frame))
     {
@@ -817,6 +825,8 @@ scrolling_1 (struct frame *frame, int window_size, int unchanged_at_top,
                     frame->current_matrix, matrix, window_size,
                     unchanged_at_top);
     }
+
+  SAFE_FREE ();
 }
 
 
diff --git a/src/search.c b/src/search.c
index ecfb2352144..9eed390244f 100644
--- a/src/search.c
+++ b/src/search.c
@@ -1318,6 +1318,7 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
          translation.  Otherwise set to zero later.  */
       int char_base = -1;
       bool boyer_moore_ok = 1;
+      USE_SAFE_ALLOCA;
 
       /* MULTIBYTE says whether the text to be searched is multibyte.
          We must convert PATTERN to match that, or we will not really
@@ -1335,7 +1336,7 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
           raw_pattern_size_byte
             = count_size_as_multibyte (SDATA (string),
                                        raw_pattern_size);
-          raw_pattern = alloca (raw_pattern_size_byte + 1);
+          raw_pattern = SAFE_ALLOCA (raw_pattern_size_byte + 1);
           copy_text (SDATA (string), raw_pattern,
                      SCHARS (string), 0, 1);
         }
@@ -1349,7 +1350,7 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
              the chosen single-byte character set can possibly match.  */
           raw_pattern_size = SCHARS (string);
           raw_pattern_size_byte = SCHARS (string);
-          raw_pattern = alloca (raw_pattern_size + 1);
+          raw_pattern = SAFE_ALLOCA (raw_pattern_size + 1);
           copy_text (SDATA (string), raw_pattern,
                      SBYTES (string), 1, 0);
         }
@@ -1357,7 +1358,7 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
       /* Copy and optionally translate the pattern.  */
       len = raw_pattern_size;
       len_byte = raw_pattern_size_byte;
-      patbuf = alloca (len * MAX_MULTIBYTE_LENGTH);
+      SAFE_NALLOCA (patbuf, MAX_MULTIBYTE_LENGTH, len);
       pat = patbuf;
       base_pat = raw_pattern;
       if (multibyte)
@@ -1497,13 +1498,15 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
       len_byte = pat - patbuf;
       pat = base_pat = patbuf;
 
-      if (boyer_moore_ok)
-        return boyer_moore (n, pat, len_byte, trt, inverse_trt,
-                            pos_byte, lim_byte,
-                            char_base);
-      else
-        return simple_search (n, pat, raw_pattern_size, len_byte, trt,
-                              pos, pos_byte, lim, lim_byte);
+      EMACS_INT result
+        = (boyer_moore_ok
+           ? boyer_moore (n, pat, len_byte, trt, inverse_trt,
+                          pos_byte, lim_byte,
+                          char_base)
+           : simple_search (n, pat, raw_pattern_size, len_byte, trt,
+                            pos, pos_byte, lim, lim_byte));
+      SAFE_FREE ();
+      return result;
     }
 }
 
@@ -2809,7 +2812,8 @@ Return value is undefined if the last search failed.  */)
 
   prev = Qnil;
 
-  data = alloca ((2 * search_regs.num_regs + 1) * sizeof *data);
+  USE_SAFE_ALLOCA;
+  SAFE_NALLOCA (data, 1, 2 * search_regs.num_regs + 1);
 
   len = 0;
   for (i = 0; i < search_regs.num_regs; i++)
@@ -2852,25 +2856,28 @@ Return value is undefined if the last search failed.  */)
 
   /* If REUSE is not usable, cons up the values and return them.  */
   if (! CONSP (reuse))
-    return Flist (len, data);
-
-  /* If REUSE is a list, store as many value elements as will fit
-     into the elements of REUSE.  */
-  for (i = 0, tail = reuse; CONSP (tail);
-       i++, tail = XCDR (tail))
+    reuse = Flist (len, data);
+  else
     {
+      /* If REUSE is a list, store as many value elements as will fit
+         into the elements of REUSE.  */
+      for (i = 0, tail = reuse; CONSP (tail);
+           i++, tail = XCDR (tail))
+        {
+          if (i < len)
+            XSETCAR (tail, data[i]);
+          else
+            XSETCAR (tail, Qnil);
+          prev = tail;
+        }
+
+      /* If we couldn't fit all value elements into REUSE,
+         cons up the rest of them and add them to the end of REUSE.  */
       if (i < len)
-        XSETCAR (tail, data[i]);
-      else
-        XSETCAR (tail, Qnil);
-      prev = tail;
+        XSETCDR (prev, Flist (len - i, data + i));
     }
 
-  /* If we couldn't fit all value elements into REUSE,
-     cons up the rest of them and add them to the end of REUSE.  */
-  if (i < len)
-    XSETCDR (prev, Flist (len - i, data + i));
-
+  SAFE_FREE ();
   return reuse;
 }
 
@@ -3075,7 +3082,8 @@ DEFUN ("regexp-quote", Fregexp_quote, Sregexp_quote, 1, 1, 0,
 
   CHECK_STRING (string);
 
-  temp = alloca (SBYTES (string) * 2);
+  USE_SAFE_ALLOCA;
+  SAFE_NALLOCA (temp, 2, SBYTES (string));
 
   /* Now copy the data into the new string, inserting escapes. */
 
@@ -3093,10 +3101,13 @@ DEFUN ("regexp-quote", Fregexp_quote, Sregexp_quote, 1, 1, 0,
       *out++ = *in;
     }
 
-  return make_specified_string (temp,
-                                SCHARS (string) + backslashes_added,
-                                out - temp,
-                                STRING_MULTIBYTE (string));
+  Lisp_Object result
+    = make_specified_string (temp,
+                             SCHARS (string) + backslashes_added,
+                             out - temp,
+                             STRING_MULTIBYTE (string));
+  SAFE_FREE ();
+  return result;
 }
 
 /* Like find_newline, but doesn't use the cache, and only searches forward.  */
diff --git a/src/sheap.c b/src/sheap.c
index 5069744435b..956faa36aa1 100644
--- a/src/sheap.c
+++ b/src/sheap.c
@@ -44,6 +44,8 @@ int debug_sheap = 0;
 #define BLOCKSIZE 4096
 
 char bss_sbrk_buffer[STATIC_HEAP_SIZE];
+/* The following is needed in gmalloc.c */
+void *bss_sbrk_buffer_end = bss_sbrk_buffer + STATIC_HEAP_SIZE;
 char *bss_sbrk_ptr;
 char *max_bss_sbrk_ptr;
 int bss_sbrk_did_unexec;
diff --git a/src/sound.c b/src/sound.c
index 7046f4e8e32..b49348f1256 100644
--- a/src/sound.c
+++ b/src/sound.c
@@ -86,8 +86,13 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* BEGIN: Windows Specific Includes */
 #include <stdio.h>
 #include <limits.h>
+#include <mbstring.h>
 #include <windows.h>
 #include <mmsystem.h>
+
+#include "coding.h"
+#include "w32common.h"
+#include "w32.h"
 /* END: Windows Specific Includes */
 
 #endif /* WINDOWSNT */
@@ -564,12 +569,11 @@ wav_play (struct sound *s, struct sound_device *sd)
                SBYTES (s->data) - sizeof *header);
   else
     {
-      char *buffer;
       ptrdiff_t nbytes = 0;
       ptrdiff_t blksize = sd->period_size ? sd->period_size (sd) : 2048;
       ptrdiff_t data_left = header->data_length;
-
-      buffer = alloca (blksize);
+      USE_SAFE_ALLOCA;
+      char *buffer = SAFE_ALLOCA (blksize);
       lseek (s->fd, sizeof *header, SEEK_SET);
       while (data_left > 0
              && (nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
@@ -582,6 +586,7 @@ wav_play (struct sound *s, struct sound_device *sd)
 
       if (nbytes < 0)
         sound_perror ("Error reading sound file");
+      SAFE_FREE ();
     }
 }
 
@@ -656,19 +661,20 @@ au_play (struct sound *s, struct sound_device *sd)
   else
     {
       ptrdiff_t blksize = sd->period_size ? sd->period_size (sd) : 2048;
-      char *buffer;
       ptrdiff_t nbytes;
 
       /* Seek */
       lseek (s->fd, header->data_offset, SEEK_SET);
 
       /* Copy sound data to the device.  */
-      buffer = alloca (blksize);
+      USE_SAFE_ALLOCA;
+      char *buffer = SAFE_ALLOCA (blksize);
       while ((nbytes = emacs_read (s->fd, buffer, blksize)) > 0)
         sd->write (sd, buffer, nbytes);
 
       if (nbytes < 0)
         sound_perror ("Error reading sound file");
+      SAFE_FREE ();
     }
 }
 
@@ -1203,38 +1209,83 @@ alsa_init (struct sound_device *sd)
 
 /* BEGIN: Windows specific functions */
 
-#define SOUND_WARNING(fun, error, text)            \
-  {                                                \
-    char buf[1024];                                \
-    char err_string[MAXERRORLENGTH];               \
-    fun (error, err_string, sizeof (err_string));  \
-    _snprintf (buf, sizeof (buf), "%s\nError: %s", \
-               text, err_string);                  \
-    sound_warning (buf);                           \
-  }
+#define SOUND_WARNING(func, error, text)                \
+  do {                                                  \
+    char buf[1024];                                     \
+    char err_string[MAXERRORLENGTH];                    \
+    func (error, err_string, sizeof (err_string));      \
+    _snprintf (buf, sizeof (buf), "%s\nMCI Error: %s",  \
+               text, err_string);                       \
+    message_with_string ("%s", build_string (buf), 1);  \
+  } while (0)
 
 static int
 do_play_sound (const char *psz_file, unsigned long ui_volume)
 {
   int i_result = 0;
   MCIERROR mci_error = 0;
-  char sz_cmd_buf[520] = {0};
-  char sz_ret_buf[520] = {0};
+  char sz_cmd_buf_a[520];
+  char sz_ret_buf_a[520];
   MMRESULT mm_result = MMSYSERR_NOERROR;
   unsigned long ui_volume_org = 0;
   BOOL b_reset_volume = FALSE;
+  char warn_text[560];
+
+  /* Since UNICOWS.DLL includes only a stub for mciSendStringW, we
+     need to encode the file in the ANSI codepage on Windows 9X even
+     if w32_unicode_filenames is non-zero.  */
+  if (w32_major_version <= 4 || !w32_unicode_filenames)
+    {
+      char fname_a[MAX_PATH], shortname[MAX_PATH], *fname_to_use;
+
+      filename_to_ansi (psz_file, fname_a);
+      fname_to_use = fname_a;
+      /* If the file name is not encodable in ANSI, try its short 8+3
+         alias.  This will only work if w32_unicode_filenames is
+         non-zero.  */
+      if (_mbspbrk ((const unsigned char *)fname_a,
+                    (const unsigned char *)"?"))
+        {
+          if (w32_get_short_filename (psz_file, shortname, MAX_PATH))
+            fname_to_use = shortname;
+          else
+            mci_error = MCIERR_FILE_NOT_FOUND;
+        }
 
-  memset (sz_cmd_buf, 0, sizeof (sz_cmd_buf));
-  memset (sz_ret_buf, 0, sizeof (sz_ret_buf));
-  sprintf (sz_cmd_buf,
-           "open \"%s\" alias GNUEmacs_PlaySound_Device wait",
-           psz_file);
-  mci_error = mciSendString (sz_cmd_buf, sz_ret_buf, sizeof (sz_ret_buf), NULL);
+      if (!mci_error)
+        {
+          memset (sz_cmd_buf_a, 0, sizeof (sz_cmd_buf_a));
+          memset (sz_ret_buf_a, 0, sizeof (sz_ret_buf_a));
+          sprintf (sz_cmd_buf_a,
+                   "open \"%s\" alias GNUEmacs_PlaySound_Device wait",
+                   fname_to_use);
+          mci_error = mciSendStringA (sz_cmd_buf_a,
+                                      sz_ret_buf_a, sizeof (sz_ret_buf_a), NULL);
+        }
+    }
+  else
+    {
+      wchar_t sz_cmd_buf_w[520];
+      wchar_t sz_ret_buf_w[520];
+      wchar_t fname_w[MAX_PATH];
+
+      filename_to_utf16 (psz_file, fname_w);
+      memset (sz_cmd_buf_w, 0, sizeof (sz_cmd_buf_w));
+      memset (sz_ret_buf_w, 0, sizeof (sz_ret_buf_w));
+      /* _swprintf is not available on Windows 9X, so we construct the
+         UTF-16 command string by hand.  */
+      wcscpy (sz_cmd_buf_w, L"open \"");
+      wcscat (sz_cmd_buf_w, fname_w);
+      wcscat (sz_cmd_buf_w, L"\" alias GNUEmacs_PlaySound_Device wait");
+      mci_error = mciSendStringW (sz_cmd_buf_w,
+                                  sz_ret_buf_w, ARRAYELTS (sz_ret_buf_w) , NULL);
+    }
   if (mci_error != 0)
     {
-      SOUND_WARNING (mciGetErrorString, mci_error,
-                     "The open mciSendString command failed to open "
-                     "the specified sound file.");
+      strcpy (warn_text,
+              "mciSendString: 'open' command failed to open sound file ");
+      strcat (warn_text, psz_file);
+      SOUND_WARNING (mciGetErrorString, mci_error, warn_text);
       i_result = (int) mci_error;
       return i_result;
     }
@@ -1248,44 +1299,47 @@ do_play_sound (const char *psz_file, unsigned long ui_volume)
           if (mm_result != MMSYSERR_NOERROR)
             {
               SOUND_WARNING (waveOutGetErrorText, mm_result,
-                             "waveOutSetVolume failed to set the volume level "
-                             "of the WAVE_MAPPER device.\n"
-                             "As a result, the user selected volume level will "
-                             "not be used.");
+                             "waveOutSetVolume: failed to set the volume level"
+                             " of the WAVE_MAPPER device.\n"
+                             "As a result, the user selected volume level will"
+                             " not be used.");
             }
         }
       else
         {
           SOUND_WARNING (waveOutGetErrorText, mm_result,
-                         "waveOutGetVolume failed to obtain the original "
-                         "volume level of the WAVE_MAPPER device.\n"
-                         "As a result, the user selected volume level will "
-                         "not be used.");
+                         "waveOutGetVolume: failed to obtain the original"
+                         " volume level of the WAVE_MAPPER device.\n"
+                         "As a result, the user selected volume level will"
+                         " not be used.");
         }
     }
-  memset (sz_cmd_buf, 0, sizeof (sz_cmd_buf));
-  memset (sz_ret_buf, 0, sizeof (sz_ret_buf));
-  strcpy (sz_cmd_buf, "play GNUEmacs_PlaySound_Device wait");
-  mci_error = mciSendString (sz_cmd_buf, sz_ret_buf, sizeof (sz_ret_buf), NULL);
+  memset (sz_cmd_buf_a, 0, sizeof (sz_cmd_buf_a));
+  memset (sz_ret_buf_a, 0, sizeof (sz_ret_buf_a));
+  strcpy (sz_cmd_buf_a, "play GNUEmacs_PlaySound_Device wait");
+  mci_error = mciSendStringA (sz_cmd_buf_a, sz_ret_buf_a, sizeof (sz_ret_buf_a),
+                              NULL);
   if (mci_error != 0)
     {
-      SOUND_WARNING (mciGetErrorString, mci_error,
-                     "The play mciSendString command failed to play the "
-                     "opened sound file.");
+      strcpy (warn_text,
+              "mciSendString: 'play' command failed to play sound file ");
+      strcat (warn_text, psz_file);
+      SOUND_WARNING (mciGetErrorString, mci_error, warn_text);
       i_result = (int) mci_error;
     }
-  memset (sz_cmd_buf, 0, sizeof (sz_cmd_buf));
-  memset (sz_ret_buf, 0, sizeof (sz_ret_buf));
-  strcpy (sz_cmd_buf, "close GNUEmacs_PlaySound_Device wait");
-  mci_error = mciSendString (sz_cmd_buf, sz_ret_buf, sizeof (sz_ret_buf), NULL);
+  memset (sz_cmd_buf_a, 0, sizeof (sz_cmd_buf_a));
+  memset (sz_ret_buf_a, 0, sizeof (sz_ret_buf_a));
+  strcpy (sz_cmd_buf_a, "close GNUEmacs_PlaySound_Device wait");
+  mci_error = mciSendStringA (sz_cmd_buf_a, sz_ret_buf_a, sizeof (sz_ret_buf_a),
+                              NULL);
   if (b_reset_volume == TRUE)
     {
       mm_result = waveOutSetVolume ((HWAVEOUT) WAVE_MAPPER, ui_volume_org);
       if (mm_result != MMSYSERR_NOERROR)
         {
           SOUND_WARNING (waveOutGetErrorText, mm_result,
-                         "waveOutSetVolume failed to reset the original volume "
-                         "level of the WAVE_MAPPER device.");
+                         "waveOutSetVolume: failed to reset the original"
+                         " volume level of the WAVE_MAPPER device.");
         }
     }
   return i_result;
@@ -1303,15 +1357,11 @@ Internal use only, use `play-sound' instead.  */)
 {
   Lisp_Object attrs[SOUND_ATTR_SENTINEL];
   ptrdiff_t count = SPECPDL_INDEX ();
-
-#ifndef WINDOWSNT
   Lisp_Object file;
-  struct gcpro gcpro1, gcpro2;
   Lisp_Object args[2];
-#else /* WINDOWSNT */
-  int len = 0;
-  Lisp_Object lo_file = {0};
-  char * psz_file = NULL;
+  struct gcpro gcpro1, gcpro2;
+
+#ifdef WINDOWSNT
   unsigned long ui_volume_tmp = UINT_MAX;
   unsigned long ui_volume = UINT_MAX;
 #endif /* WINDOWSNT */
@@ -1326,7 +1376,8 @@ Internal use only, use `play-sound' instead.  */)
   current_sound_device = xzalloc (sizeof *current_sound_device);
   current_sound = xzalloc (sizeof *current_sound);
   record_unwind_protect_void (sound_cleanup);
-  current_sound->header = alloca (MAX_SOUND_HEADER_BYTES);
+  char headerbuf[MAX_SOUND_HEADER_BYTES];
+  current_sound->header = headerbuf;
 
   if (STRINGP (attrs[SOUND_FILE]))
     {
@@ -1383,10 +1434,8 @@ Internal use only, use `play-sound' instead.  */)
 
 #else /* WINDOWSNT */
 
-  lo_file = Fexpand_file_name (attrs[SOUND_FILE], Qnil);
-  len = XSTRING (lo_file)->size;
-  psz_file = alloca (len + 1);
-  strcpy (psz_file, XSTRING (lo_file)->data);
+  file = Fexpand_file_name (attrs[SOUND_FILE], Vdata_directory);
+  file = ENCODE_FILE (file);
   if (INTEGERP (attrs[SOUND_VOLUME]))
     {
       ui_volume_tmp = XFASTINT (attrs[SOUND_VOLUME]);
@@ -1395,6 +1444,13 @@ Internal use only, use `play-sound' instead.  */)
     {
       ui_volume_tmp = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
     }
+
+  GCPRO2 (sound, file);
+
+  args[0] = Qplay_sound_functions;
+  args[1] = sound;
+  Frun_hook_with_args (2, args);
+
   /*
     Based on some experiments I have conducted, a value of 100 or less
     for the sound volume is much too low.  You cannot even hear it.
@@ -1408,7 +1464,9 @@ Internal use only, use `play-sound' instead.  */)
     {
       ui_volume = ui_volume_tmp * (UINT_MAX / 100);
     }
-  do_play_sound (psz_file, ui_volume);
+  (void)do_play_sound (SSDATA (file), ui_volume);
+
+  UNGCPRO;
 
 #endif /* WINDOWSNT */
 
diff --git a/src/syntax.c b/src/syntax.c
index 4166ee211c7..9f5ef754e2a 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -1231,7 +1231,7 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
   syntax_code = XINT (first) & INT_MAX;
   code = syntax_code & 0377;
   start1 = SYNTAX_FLAGS_COMSTART_FIRST (syntax_code);
-  start2 = SYNTAX_FLAGS_COMSTART_SECOND (syntax_code);;
+  start2 = SYNTAX_FLAGS_COMSTART_SECOND (syntax_code);
   end1 = SYNTAX_FLAGS_COMEND_FIRST (syntax_code);
   end2 = SYNTAX_FLAGS_COMEND_SECOND (syntax_code);
   prefix = SYNTAX_FLAGS_PREFIX (syntax_code);
@@ -1567,6 +1567,7 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
   const unsigned char *str;
   int len;
   Lisp_Object iso_classes;
+  USE_SAFE_ALLOCA;
 
   CHECK_STRING (string);
   iso_classes = Qnil;
@@ -1699,7 +1700,7 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
           memcpy (himap, fastmap + 0200, 0200);
           himap[0200] = 0;
           memset (fastmap + 0200, 0, 0200);
-          char_ranges = alloca (sizeof *char_ranges * 128 * 2);
+          SAFE_NALLOCA (char_ranges, 2, 128);
           i = 0;
 
           while ((p1 = memchr (himap + i, 1, 0200 - i)))
@@ -1723,7 +1724,7 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
     }
   else                          /* STRING is multibyte */
     {
-      char_ranges = alloca (sizeof *char_ranges * SCHARS (string) * 2);
+      SAFE_NALLOCA (char_ranges, 2, SCHARS (string));
 
       while (i_byte < size_byte)
         {
@@ -2032,6 +2033,7 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
     SET_PT_BOTH (pos, pos_byte);
     immediate_quit = 0;
 
+    SAFE_FREE ();
     return make_number (PT - start_point);
   }
 }
@@ -2857,10 +2859,13 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
             case Smath:
               if (!sexpflag)
                 break;
-              temp_pos = dec_bytepos (from_byte);
-              UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
-              if (from != stop && c == FETCH_CHAR_AS_MULTIBYTE (temp_pos))
-                DEC_BOTH (from, from_byte);
+              if (from > BEGV)
+                {
+                  temp_pos = dec_bytepos (from_byte);
+                  UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
+                  if (from != stop && c == FETCH_CHAR_AS_MULTIBYTE (temp_pos))
+                    DEC_BOTH (from, from_byte);
+                }
               if (mathexit)
                 {
                   mathexit = 0;
diff --git a/src/sysdep.c b/src/sysdep.c
index d5cfd5b88cf..24cc5cb0b40 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -19,6 +19,14 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 
+/* If HYBRID_GET_CURRENT_DIR_NAME is defined in conf_post.h, then we
+   need the following before including unistd.h, in order to pick up
+   the right prototype for gget_current_dir_name.  */
+#ifdef HYBRID_GET_CURRENT_DIR_NAME
+#undef get_current_dir_name
+#define get_current_dir_name gget_current_dir_name
+#endif
+
 #include <execinfo.h>
 #include "sysstdio.h"
 #ifdef HAVE_PWD_H
@@ -46,7 +54,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 # include <sys/user.h>
 # undef frame
 
-# include <sys/resource.h>
 # include <math.h>
 #endif
 
@@ -72,6 +79,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "msdos.h"
 #endif
 
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
 #include <sys/param.h>
 #include <sys/file.h>
 #include <fcntl.h>
@@ -119,9 +129,8 @@ static const int baud_convert[] =
     1800, 2400, 4800, 9600, 19200, 38400
   };
 
-
-#if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
-
+#if !defined HAVE_GET_CURRENT_DIR_NAME || defined BROKEN_GET_CURRENT_DIR_NAME \
+  || (defined HYBRID_GET_CURRENT_DIR_NAME)
 /* Return the current working directory.  Returns NULL on errors.
    Any other returned value must be freed with free. This is used
    only when get_current_dir_name is not defined on the system.  */
@@ -1716,6 +1725,83 @@ handle_arith_signal (int sig)
   xsignal0 (Qarith_error);
 }
 
+#ifdef HAVE_STACK_OVERFLOW_HANDLING
+
+/* -1 if stack grows down as expected on most OS/ABI variants, 1 otherwise.  */
+
+static int stack_direction;
+
+/* Alternate stack used by SIGSEGV handler below.  */
+
+static unsigned char sigsegv_stack[SIGSTKSZ];
+
+/* Attempt to recover from SIGSEGV caused by C stack overflow.  */
+
+static void
+handle_sigsegv (int sig, siginfo_t *siginfo, void *arg)
+{
+  /* Hard GC error may lead to stack overflow caused by
+     too nested calls to mark_object.  No way to survive.  */
+  if (!gc_in_progress)
+    {
+      struct rlimit rlim;
+
+      if (!getrlimit (RLIMIT_STACK, &rlim))
+        {
+          enum { STACK_DANGER_ZONE = 16 * 1024 };
+          char *beg, *end, *addr;
+
+          beg = stack_bottom;
+          end = stack_bottom + stack_direction * rlim.rlim_cur;
+          if (beg > end)
+            addr = beg, beg = end, end = addr;
+          addr = (char *) siginfo->si_addr;
+          /* If we're somewhere on stack and too close to
+             one of its boundaries, most likely this is it.  */
+          if (beg < addr && addr < end
+              && (addr - beg < STACK_DANGER_ZONE
+                  || end - addr < STACK_DANGER_ZONE))
+            siglongjmp (return_to_command_loop, 1);
+        }
+    }
+
+  /* Otherwise we can't do anything with this.  */
+  deliver_fatal_thread_signal (sig);
+}
+
+/* Return true if we have successfully set up SIGSEGV handler on alternate
+   stack.  Otherwise we just treat SIGSEGV among the rest of fatal signals.  */
+
+static bool
+init_sigsegv (void)
+{
+  struct sigaction sa;
+  stack_t ss;
+
+  stack_direction = ((char *) &ss < stack_bottom) ? -1 : 1;
+
+  ss.ss_sp = sigsegv_stack;
+  ss.ss_size = sizeof (sigsegv_stack);
+  ss.ss_flags = 0;
+  if (sigaltstack (&ss, NULL) < 0)
+    return 0;
+
+  sigfillset (&sa.sa_mask);
+  sa.sa_sigaction = handle_sigsegv;
+  sa.sa_flags = SA_SIGINFO | SA_ONSTACK | emacs_sigaction_flags ();
+  return sigaction (SIGSEGV, &sa, NULL) < 0 ? 0 : 1;
+}
+
+#else /* not HAVE_STACK_OVERFLOW_HANDLING */
+
+static bool
+init_sigsegv (void)
+{
+  return 0;
+}
+
+#endif /* HAVE_STACK_OVERFLOW_HANDLING */
+
 static void
 deliver_arith_signal (int sig)
 {
@@ -1982,7 +2068,8 @@ init_signals (bool dumping)
 #ifdef SIGBUS
   sigaction (SIGBUS, &thread_fatal_action, 0);
 #endif
-  sigaction (SIGSEGV, &thread_fatal_action, 0);
+  if (!init_sigsegv ())
+    sigaction (SIGSEGV, &thread_fatal_action, 0);
 #ifdef SIGSYS
   sigaction (SIGSYS, &thread_fatal_action, 0);
 #endif
@@ -2370,7 +2457,7 @@ emacs_full_write (int fildes, char const *buf, ptrdiff_t nbyte,
         {
           if (errno == EINTR)
             {
-              /* I originally used `QUIT' but that might causes files to
+              /* I originally used `QUIT' but that might cause files to
                  be truncated if you hit C-g in the middle of it.  --Stef  */
               if (process_signals && pending_signals)
                 process_pending_signals ();
@@ -3513,3 +3600,208 @@ system_process_attributes (Lisp_Object pid)
 }
 
 #endif  /* !defined (WINDOWSNT) */
+
+/* Wide character string collation.  */
+
+#ifdef __STDC_ISO_10646__
+# include <wchar.h>
+# include <wctype.h>
+
+# if defined HAVE_NEWLOCALE || defined HAVE_SETLOCALE
+#  include <locale.h>
+# endif
+# ifndef LC_COLLATE
+#  define LC_COLLATE 0
+# endif
+# ifndef LC_COLLATE_MASK
+#  define LC_COLLATE_MASK 0
+# endif
+# ifndef LC_CTYPE
+#  define LC_CTYPE 0
+# endif
+# ifndef LC_CTYPE_MASK
+#  define LC_CTYPE_MASK 0
+# endif
+
+# ifndef HAVE_NEWLOCALE
+#  undef freelocale
+#  undef locale_t
+#  undef newlocale
+#  undef wcscoll_l
+#  undef towlower_l
+#  define freelocale emacs_freelocale
+#  define locale_t emacs_locale_t
+#  define newlocale emacs_newlocale
+#  define wcscoll_l emacs_wcscoll_l
+#  define towlower_l emacs_towlower_l
+
+typedef char const *locale_t;
+
+static locale_t
+newlocale (int category_mask, char const *locale, locale_t loc)
+{
+  return locale;
+}
+
+static void
+freelocale (locale_t loc)
+{
+}
+
+static char *
+emacs_setlocale (int category, char const *locale)
+{
+#  ifdef HAVE_SETLOCALE
+  errno = 0;
+  char *loc = setlocale (category, locale);
+  if (loc || errno)
+    return loc;
+  errno = EINVAL;
+#  else
+  errno = ENOTSUP;
+#  endif
+  return 0;
+}
+
+static int
+wcscoll_l (wchar_t const *a, wchar_t const *b, locale_t loc)
+{
+  int result = 0;
+  char *oldloc = emacs_setlocale (LC_COLLATE, NULL);
+  int err;
+
+  if (! oldloc)
+    err = errno;
+  else
+    {
+      USE_SAFE_ALLOCA;
+      char *oldcopy = SAFE_ALLOCA (strlen (oldloc) + 1);
+      strcpy (oldcopy, oldloc);
+      if (! emacs_setlocale (LC_COLLATE, loc))
+        err = errno;
+      else
+        {
+          errno = 0;
+          result = wcscoll (a, b);
+          err = errno;
+          if (! emacs_setlocale (LC_COLLATE, oldcopy))
+            err = errno;
+        }
+      SAFE_FREE ();
+    }
+
+  errno = err;
+  return result;
+}
+
+static wint_t
+towlower_l (wint_t wc, locale_t loc)
+{
+  wint_t result = wc;
+  char *oldloc = emacs_setlocale (LC_CTYPE, NULL);
+
+  if (oldloc)
+    {
+      USE_SAFE_ALLOCA;
+      char *oldcopy = SAFE_ALLOCA (strlen (oldloc) + 1);
+      strcpy (oldcopy, oldloc);
+      if (emacs_setlocale (LC_CTYPE, loc))
+        {
+          result = towlower (wc);
+          emacs_setlocale (LC_COLLATE, oldcopy);
+        }
+      SAFE_FREE ();
+    }
+
+  return result;
+}
+# endif
+
+int
+str_collate (Lisp_Object s1, Lisp_Object s2,
+             Lisp_Object locale, Lisp_Object ignore_case)
+{
+  int res, err;
+  ptrdiff_t len, i, i_byte;
+  wchar_t *p1, *p2;
+
+  USE_SAFE_ALLOCA;
+
+  /* Convert byte stream to code points.  */
+  len = SCHARS (s1); i = i_byte = 0;
+  SAFE_NALLOCA (p1, 1, len + 1);
+  while (i < len)
+    FETCH_STRING_CHAR_ADVANCE (*(p1+i-1), s1, i, i_byte);
+  *(p1+len) = 0;
+
+  len = SCHARS (s2); i = i_byte = 0;
+  SAFE_NALLOCA (p2, 1, len + 1);
+  while (i < len)
+    FETCH_STRING_CHAR_ADVANCE (*(p2+i-1), s2, i, i_byte);
+  *(p2+len) = 0;
+
+  if (STRINGP (locale))
+    {
+      locale_t loc = newlocale (LC_COLLATE_MASK | LC_CTYPE_MASK,
+                                SSDATA (locale), 0);
+      if (!loc)
+        error ("Invalid locale %s: %s", SSDATA (locale), strerror (errno));
+
+      if (! NILP (ignore_case))
+        for (int i = 1; i < 3; i++)
+          {
+            wchar_t *p = (i == 1) ? p1 : p2;
+            for (; *p; p++)
+              *p = towlower_l (*p, loc);
+          }
+
+      errno = 0;
+      res = wcscoll_l (p1, p2, loc);
+      err = errno;
+      freelocale (loc);
+    }
+  else
+    {
+      if (! NILP (ignore_case))
+        for (int i = 1; i < 3; i++)
+          {
+            wchar_t *p = (i == 1) ? p1 : p2;
+            for (; *p; p++)
+              *p = towlower (*p);
+          }
+
+      errno = 0;
+      res = wcscoll (p1, p2);
+      err = errno;
+    }
+#  ifndef HAVE_NEWLOCALE
+  if (err)
+    error ("Invalid locale or string for collation: %s", strerror (err));
+#  else
+  if (err)
+    error ("Invalid string for collation: %s", strerror (err));
+#  endif
+
+  SAFE_FREE ();
+  return res;
+}
+#endif  /* __STDC_ISO_10646__ */
+
+#ifdef WINDOWSNT
+int
+str_collate (Lisp_Object s1, Lisp_Object s2,
+             Lisp_Object locale, Lisp_Object ignore_case)
+{
+
+  char *loc = STRINGP (locale) ? SSDATA (locale) : NULL;
+  int res, err = errno;
+
+  errno = 0;
+  res = w32_compare_strings (SDATA (s1), SDATA (s2), loc, !NILP (ignore_case));
+  if (errno)
+    error ("Invalid string for collation: %s", strerror (errno));
+
+  errno = err;
+  return res;
+}
+#endif  /* WINDOWSNT */
diff --git a/src/systime.h b/src/systime.h
index a834bce76dc..8f018044660 100644
--- a/src/systime.h
+++ b/src/systime.h
@@ -93,6 +93,22 @@ extern bool decode_time_components (Lisp_Object, Lisp_Object, Lisp_Object,
 extern struct timespec lisp_time_argument (Lisp_Object);
 #endif
 
+#ifndef HAVE_TZALLOC
+# undef mktime_z
+# undef timezone_t
+# undef tzalloc
+# undef tzfree
+# define mktime_z emacs_mktime_z
+# define timezone_t emacs_timezone_t
+# define tzalloc emacs_tzalloc
+# define tzfree emacs_tzfree
+typedef char const *timezone_t;
+INLINE timezone_t tzalloc (char const *name) { return name; }
+INLINE void tzfree (timezone_t tz) { }
+/* Defined in editfns.c.  */
+extern time_t mktime_z (timezone_t, struct tm *);
+#endif
+
 INLINE_HEADER_END
 
 #endif /* EMACS_SYSTIME_H */
diff --git a/src/term.c b/src/term.c
index c8ff6f31575..04f6e3318a0 100644
--- a/src/term.c
+++ b/src/term.c
@@ -77,7 +77,6 @@ static void tty_turn_off_highlight (struct tty_display_info *);
 static void tty_show_cursor (struct tty_display_info *);
 static void tty_hide_cursor (struct tty_display_info *);
 static void tty_background_highlight (struct tty_display_info *tty);
-static struct terminal *get_tty_terminal (Lisp_Object, bool);
 static void clear_tty_hooks (struct terminal *terminal);
 static void set_tty_hooks (struct terminal *terminal);
 static void dissociate_if_controlling_tty (int fd);
@@ -2029,11 +2028,9 @@ selected frame's terminal).  This function always returns nil if
 TERMINAL does not refer to a text terminal.  */)
   (Lisp_Object terminal)
 {
-  struct terminal *t = get_tty_terminal (terminal, 0);
-  if (!t)
-    return Qnil;
-  else
-    return t->display_info.tty->TN_max_colors > 0 ? Qt : Qnil;
+  struct terminal *t = decode_tty_terminal (terminal);
+
+  return (t && t->display_info.tty->TN_max_colors > 0) ? Qt : Qnil;
 }
 
 /* Return the number of supported colors.  */
@@ -2046,11 +2043,9 @@ selected frame's terminal).  This function always returns 0 if
 TERMINAL does not refer to a text terminal.  */)
   (Lisp_Object terminal)
 {
-  struct terminal *t = get_tty_terminal (terminal, 0);
-  if (!t)
-    return make_number (0);
-  else
-    return make_number (t->display_info.tty->TN_max_colors);
+  struct terminal *t = decode_tty_terminal (terminal);
+
+  return make_number (t ? t->display_info.tty->TN_max_colors : 0);
 }
 
 #ifndef DOS_NT
@@ -2165,52 +2160,6 @@ set_tty_color_mode (struct tty_display_info *tty, struct frame *f)
 
 #endif /* !DOS_NT */
 
-
-
-/* Return the tty display object specified by TERMINAL. */
-
-static struct terminal *
-get_tty_terminal (Lisp_Object terminal, bool throw)
-{
-  struct terminal *t = get_terminal (terminal, throw);
-
-  if (t && t->type != output_termcap && t->type != output_msdos_raw)
-    {
-      if (throw)
-        error ("Device %d is not a termcap terminal device", t->id);
-      else
-        return NULL;
-    }
-
-  return t;
-}
-
-/* Return an active termcap device that uses the tty device with the
-   given name.
-
-   This function ignores suspended devices.
-
-   Returns NULL if the named terminal device is not opened.  */
-
-struct terminal *
-get_named_tty (const char *name)
-{
-  struct terminal *t;
-
-  eassert (name);
-
-  for (t = terminal_list; t; t = t->next_terminal)
-    {
-      if ((t->type == output_termcap || t->type == output_msdos_raw)
-          && !strcmp (t->display_info.tty->name, name)
-          && TERMINAL_ACTIVE_P (t))
-        return t;
-    }
-
-  return 0;
-}
-
-
 DEFUN ("tty-type", Ftty_type, Stty_type, 0, 1, 0,
        doc: /* Return the type of the tty device that TERMINAL uses.
 Returns nil if TERMINAL is not on a tty device.
@@ -2219,15 +2168,10 @@ TERMINAL can be a terminal object, a frame, or nil (meaning the
 selected frame's terminal).  */)
   (Lisp_Object terminal)
 {
-  struct terminal *t = get_terminal (terminal, 1);
-
-  if (t->type != output_termcap && t->type != output_msdos_raw)
-    return Qnil;
+  struct terminal *t = decode_tty_terminal (terminal);
 
-  if (t->display_info.tty->type)
-    return build_string (t->display_info.tty->type);
-  else
-    return Qnil;
+  return (t && t->display_info.tty->type
+          ? build_string (t->display_info.tty->type) : Qnil);
 }
 
 DEFUN ("controlling-tty-p", Fcontrolling_tty_p, Scontrolling_tty_p, 0, 1, 0,
@@ -2238,13 +2182,9 @@ selected frame's terminal).  This function always returns nil if
 TERMINAL is not on a tty device.  */)
   (Lisp_Object terminal)
 {
-  struct terminal *t = get_terminal (terminal, 1);
+  struct terminal *t = decode_tty_terminal (terminal);
 
-  if ((t->type != output_termcap && t->type != output_msdos_raw)
-      || strcmp (t->display_info.tty->name, DEV_TTY) != 0)
-    return Qnil;
-  else
-    return Qt;
+  return (t && !strcmp (t->display_info.tty->name, DEV_TTY) ? Qt : Qnil);
 }
 
 DEFUN ("tty-no-underline", Ftty_no_underline, Stty_no_underline, 0, 1, 0,
@@ -2258,7 +2198,7 @@ selected frame's terminal).  This function always returns nil if
 TERMINAL does not refer to a text terminal.  */)
   (Lisp_Object terminal)
 {
-  struct terminal *t = get_terminal (terminal, 1);
+  struct terminal *t = decode_live_terminal (terminal);
 
   if (t->type == output_termcap)
     t->display_info.tty->TS_enter_underline_mode = 0;
@@ -2273,7 +2213,7 @@ does not refer to a text terminal.  Otherwise, it returns the
 top-most frame on the text terminal.  */)
   (Lisp_Object terminal)
 {
-  struct terminal *t = get_terminal (terminal, 1);
+  struct terminal *t = decode_live_terminal (terminal);
 
   if (t->type == output_termcap)
     return t->display_info.tty->top_frame;
@@ -2303,11 +2243,11 @@ suspended.
 A suspended tty may be resumed by calling `resume-tty' on it.  */)
   (Lisp_Object tty)
 {
-  struct terminal *t = get_tty_terminal (tty, 1);
+  struct terminal *t = decode_tty_terminal (tty);
   FILE *f;
 
   if (!t)
-    error ("Unknown tty device");
+    error ("Attempt to suspend a non-text terminal device");
 
   f = t->display_info.tty->input;
 
@@ -2363,15 +2303,15 @@ TTY may be a terminal object, a frame, or nil (meaning the selected
 frame's terminal). */)
   (Lisp_Object tty)
 {
-  struct terminal *t = get_tty_terminal (tty, 1);
+  struct terminal *t = decode_tty_terminal (tty);
   int fd;
 
   if (!t)
-    error ("Unknown tty device");
+    error ("Attempt to resume a non-text terminal device");
 
   if (!t->display_info.tty->input)
     {
-      if (get_named_tty (t->display_info.tty->name))
+      if (get_named_terminal (t->display_info.tty->name))
         error ("Cannot resume display while another display is active on the same device");
 
 #ifdef MSDOS
@@ -2537,7 +2477,7 @@ term_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
   (*fp)->mouse_moved = 0;
 
   *bar_window = Qnil;
-  *part = 0;
+  *part = scroll_bar_above_handle;
 
   XSETINT (*x, last_mouse_x);
   XSETINT (*y, last_mouse_y);
@@ -3188,6 +3128,7 @@ tty_menu_activate (tty_menu *menu, int *pane, int *selidx,
   Lisp_Object selectface;
   int first_item = 0;
   int col, row;
+  USE_SAFE_ALLOCA;
 
   /* Don't allow non-positive x0 and y0, lest the menu will wrap
      around the display.  */
@@ -3196,7 +3137,7 @@ tty_menu_activate (tty_menu *menu, int *pane, int *selidx,
   if (y0 <= 0)
     y0 = 1;
 
-  state = alloca (menu->panecount * sizeof (struct tty_menu_state));
+  SAFE_NALLOCA (state, 1, menu->panecount);
   memset (state, 0, sizeof (*state));
   faces[0]
     = lookup_derived_face (sf, intern ("tty-menu-disabled-face"),
@@ -3418,6 +3359,7 @@ tty_menu_activate (tty_menu *menu, int *pane, int *selidx,
   discard_mouse_events ();
   if (!kbd_buffer_events_waiting ())
     clear_input_pending ();
+  SAFE_FREE ();
   return result;
 }
 
@@ -3603,6 +3545,7 @@ tty_menu_show (struct frame *f, int x, int y, int menuflags,
   item_y = y += f->top_pos;
 
   /* Create all the necessary panes and their items.  */
+  USE_SAFE_ALLOCA;
   maxwidth = maxlines = lines = i = 0;
   lpane = TTYM_FAILURE;
   while (i < menu_items_used)
@@ -3671,9 +3614,7 @@ tty_menu_show (struct frame *f, int x, int y, int menuflags,
 
           if (!NILP (descrip))
             {
-              /* If alloca is fast, use that to make the space,
-                 to reduce gc needs.  */
-              item_data = (char *) alloca (maxwidth + SBYTES (descrip) + 1);
+              item_data = SAFE_ALLOCA (maxwidth + SBYTES (descrip) + 1);
               memcpy (item_data, SSDATA (item_name), SBYTES (item_name));
               for (j = SCHARS (item_name); j < maxwidth; j++)
                 item_data[j] = ' ';
@@ -3826,6 +3767,7 @@ tty_menu_show (struct frame *f, int x, int y, int menuflags,
 
  tty_menu_end:
 
+  SAFE_FREE ();
   unbind_to (specpdl_count, Qnil);
   return entry;
 }
@@ -4002,7 +3944,7 @@ init_tty (const char *name, const char *terminal_type, bool must_succeed)
   /* XXX Perhaps this should be made explicit by having init_tty
      always create a new terminal and separating terminal and frame
      creation on Lisp level.  */
-  terminal = get_named_tty (name);
+  terminal = get_named_terminal (name);
   if (terminal)
     return terminal;
 
diff --git a/src/termhooks.h b/src/termhooks.h
index 04104eb41e9..9cab853ed3d 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -28,7 +28,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 INLINE_HEADER_BEGIN
 
 enum scroll_bar_part {
-  scroll_bar_nowhere = -1,
+  scroll_bar_nowhere,
   scroll_bar_above_handle,
   scroll_bar_handle,
   scroll_bar_below_handle,
@@ -255,28 +255,36 @@ enum event_kind
 struct input_event
 {
   /* What kind of event was this?  */
-  enum event_kind kind;
+  ENUM_BF (event_kind) kind : 16;
+
+  /* Used in scroll back click events.  */
+  ENUM_BF (scroll_bar_part) part : 16;
 
   /* For an ASCII_KEYSTROKE_EVENT and MULTIBYTE_CHAR_KEYSTROKE_EVENT,
      this is the character.
      For a NON_ASCII_KEYSTROKE_EVENT, this is the keysym code.
-     For a mouse event, this is the button number.
-     For a HELP_EVENT, this is the position within the object
-      (stored in ARG below) where the help was found.  */
-  ptrdiff_t code;
-  enum scroll_bar_part part;
+     For a mouse event, this is the button number.  */
+  unsigned code;
 
-  int modifiers;                /* See enum below for interpretation.  */
+  /* See enum below for interpretation.  */
+  unsigned modifiers;
 
+  /* One would prefer C integers, but HELP_EVENT uses these to
+     record frame or window object and a help form, respectively.  */
   Lisp_Object x, y;
+
+  /* Usually a time as reported by window system-specific event loop.
+     For a HELP_EVENT, this is the position within the object (stored
+     in ARG below) where the help was found.  */
   Time timestamp;
 
   /* This field is copied into a vector while the event is in
      the queue, so that garbage collections won't kill it.  */
   Lisp_Object frame_or_window;
 
-  /* Additional event argument.  This is used for TOOL_BAR_EVENTs and
-     HELP_EVENTs and avoids calling Fcons during signal handling.  */
+  /* This additional argument is used in attempt to avoid extra consing
+     when building events.  Unfortunately some events have to pass much
+     more data than it's reasonable to pack directly into this structure.  */
   Lisp_Object arg;
 };
 
@@ -673,7 +681,9 @@ extern struct terminal *terminal_list;
   (t->type == output_ns ? t->display_info.ns->name_list_element : Qnil)
 #endif
 
-extern struct terminal *get_terminal (Lisp_Object terminal, bool);
+extern struct terminal *decode_live_terminal (Lisp_Object);
+extern struct terminal *decode_tty_terminal (Lisp_Object);
+extern struct terminal *get_named_terminal (const char *);
 extern struct terminal *create_terminal (enum output_method,
                                          struct redisplay_interface *);
 extern void delete_terminal (struct terminal *);
diff --git a/src/terminal.c b/src/terminal.c
index a827677a58d..0cd6a0bf602 100644
--- a/src/terminal.c
+++ b/src/terminal.c
@@ -37,7 +37,9 @@ static int next_terminal_id;
 /* The initial terminal device, created by initial_term_init.  */
 struct terminal *initial_terminal;
 
+Lisp_Object Qrun_hook_with_args;
 static Lisp_Object Qterminal_live_p;
+static Lisp_Object Qdelete_terminal_functions;
 
 static void delete_initial_terminal (struct terminal *);
 
@@ -194,34 +196,66 @@ ins_del_lines (struct frame *f, int vpos, int n)
     (*FRAME_TERMINAL (f)->ins_del_lines_hook) (f, vpos, n);
 }
 
+/* Return the terminal object specified by TERMINAL.  TERMINAL may
+   be a terminal object, a frame, or nil for the terminal device of
+   the current frame.  If TERMINAL is neither from the above or the
+   resulting terminal object is deleted, return NULL.  */
 
-
-
-/* Return the terminal object specified by TERMINAL.  TERMINAL may be
-   a terminal object, a frame, or nil for the terminal device of the
-   current frame.  If THROW is false, return NULL for failure,
-   otherwise throw an error.  */
-
-struct terminal *
-get_terminal (Lisp_Object terminal, bool throw)
+static struct terminal *
+decode_terminal (Lisp_Object terminal)
 {
-  struct terminal *result = NULL;
+  struct terminal *t;
 
   if (NILP (terminal))
     terminal = selected_frame;
+  t = (TERMINALP (terminal)
+       ? XTERMINAL (terminal)
+       : FRAMEP (terminal) ? FRAME_TERMINAL (XFRAME (terminal)) : NULL);
+  return t && t->name ? t : NULL;
+}
 
-  if (TERMINALP (terminal))
-    result = XTERMINAL (terminal);
-  else if (FRAMEP (terminal))
-    result = FRAME_TERMINAL (XFRAME (terminal));
+/* Like above, but throw an error if TERMINAL is not valid or deleted.  */
 
-  if (result && !result->name)
-    result = NULL;
+struct terminal *
+decode_live_terminal (Lisp_Object terminal)
+{
+  struct terminal *t = decode_terminal (terminal);
 
-  if (result == NULL && throw)
+  if (!t)
     wrong_type_argument (Qterminal_live_p, terminal);
+  return t;
+}
+
+/* Like decode_terminal, but ensure that the resulting terminal object refers
+   to a text-based terminal device.  */
+
+struct terminal *
+decode_tty_terminal (Lisp_Object terminal)
+{
+  struct terminal *t = decode_live_terminal (terminal);
 
-  return result;
+  return (t->type == output_termcap || t->type == output_msdos_raw) ? t : NULL;
+}
+
+/* Return an active (not suspended) text-based terminal device that uses
+   the tty device with the given NAME, or NULL if the named terminal device
+   is not opened.  */
+
+struct terminal *
+get_named_terminal (const char *name)
+{
+  struct terminal *t;
+
+  eassert (name);
+
+  for (t = terminal_list; t; t = t->next_terminal)
+    {
+      if ((t->type == output_termcap || t->type == output_msdos_raw)
+          && !strcmp (t->display_info.tty->name, name)
+          && TERMINAL_ACTIVE_P (t))
+        return t;
+    }
+  return NULL;
 }
 
 /* Create a new terminal object of TYPE and add it to the terminal list.  RIF
@@ -308,8 +342,6 @@ delete_terminal (struct terminal *terminal)
     }
 }
 
-Lisp_Object Qrun_hook_with_args;
-static Lisp_Object Qdelete_terminal_functions;
 DEFUN ("delete-terminal", Fdelete_terminal, Sdelete_terminal, 0, 2, 0,
        doc: /* Delete TERMINAL by deleting all frames on it and closing the terminal.
 TERMINAL may be a terminal object, a frame, or nil (meaning the
@@ -319,7 +351,7 @@ Normally, you may not delete a display if all other displays are suspended,
 but if the second argument FORCE is non-nil, you may do so. */)
   (Lisp_Object terminal, Lisp_Object force)
 {
-  struct terminal *t = get_terminal (terminal, 0);
+  struct terminal *t = decode_terminal (terminal);
 
   if (!t)
     return Qnil;
@@ -380,9 +412,7 @@ sort of output terminal it uses.  See the documentation of `framep' for
 possible return values.  */)
   (Lisp_Object object)
 {
-  struct terminal *t;
-
-  t = get_terminal (object, 0);
+  struct terminal *t = decode_terminal (object);
 
   if (!t)
     return Qnil;
@@ -429,8 +459,7 @@ TERMINAL may be a terminal object, a frame, or nil (meaning the
 selected frame's terminal). */)
   (Lisp_Object terminal)
 {
-  struct terminal *t
-    = TERMINALP (terminal) ? XTERMINAL (terminal) : get_terminal (terminal, 1);
+  struct terminal *t = decode_live_terminal (terminal);
 
   return t->name ? build_string (t->name) : Qnil;
 }
@@ -467,9 +496,7 @@ TERMINAL can be a terminal object, a frame, or nil (meaning the
 selected frame's terminal).  */)
   (Lisp_Object terminal)
 {
-  struct terminal *t
-    = TERMINALP (terminal) ? XTERMINAL (terminal) : get_terminal (terminal, 1);
-  return Fcopy_alist (t->param_alist);
+  return Fcopy_alist (decode_live_terminal (terminal)->param_alist);
 }
 
 DEFUN ("terminal-parameter", Fterminal_parameter, Sterminal_parameter, 2, 2, 0,
@@ -478,12 +505,8 @@ TERMINAL can be a terminal object, a frame, or nil (meaning the
 selected frame's terminal).  */)
   (Lisp_Object terminal, Lisp_Object parameter)
 {
-  Lisp_Object value;
-  struct terminal *t
-    = TERMINALP (terminal) ? XTERMINAL (terminal) : get_terminal (terminal, 1);
   CHECK_SYMBOL (parameter);
-  value = Fcdr (Fassq (parameter, t->param_alist));
-  return value;
+  return Fcdr (Fassq (parameter, decode_live_terminal (terminal)->param_alist));
 }
 
 DEFUN ("set-terminal-parameter", Fset_terminal_parameter,
@@ -495,9 +518,7 @@ TERMINAL can be a terminal object, a frame or nil (meaning the
 selected frame's terminal).  */)
   (Lisp_Object terminal, Lisp_Object parameter, Lisp_Object value)
 {
-  struct terminal *t
-    = TERMINALP (terminal) ? XTERMINAL (terminal) : get_terminal (terminal, 1);
-  return store_terminal_param (t, parameter, value);
+  return store_terminal_param (decode_live_terminal (terminal), parameter, value);
 }
 
 /* Initial frame has no device-dependent output data, but has
diff --git a/src/textprop.c b/src/textprop.c
index bd09304ba3b..91ade8ae298 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -660,6 +660,7 @@ get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop,
 
       set_buffer_temp (XBUFFER (object));
 
+      USE_SAFE_ALLOCA;
       GET_OVERLAYS_AT (XINT (position), overlay_vec, noverlays, NULL, 0);
       noverlays = sort_overlays (overlay_vec, noverlays, w);
 
@@ -674,9 +675,11 @@ get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop,
               if (overlay)
                 /* Return the overlay we got the property from.  */
                 *overlay = overlay_vec[noverlays];
+              SAFE_FREE ();
               return tem;
             }
         }
+      SAFE_FREE ();
     }
 
   if (overlay)
@@ -1314,9 +1317,11 @@ specify the property to add.
 If the optional fifth argument OBJECT is a buffer (or nil, which means
 the current buffer), START and END are buffer positions (integers or
 markers).  If OBJECT is a string, START and END are 0-based indices into it.  */)
-  (Lisp_Object start, Lisp_Object end, Lisp_Object property, Lisp_Object value, Lisp_Object object)
+  (Lisp_Object start, Lisp_Object end, Lisp_Object property,
+   Lisp_Object value, Lisp_Object object)
 {
-  Fadd_text_properties (start, end, list2 (property, value), object);
+  AUTO_LIST2 (properties, property, value);
+  Fadd_text_properties (start, end, properties, object);
   return Qnil;
 }
 
@@ -1357,7 +1362,8 @@ into it.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object face,
    Lisp_Object append, Lisp_Object object)
 {
-  add_text_properties_1 (start, end, list2 (Qface, face), object,
+  AUTO_LIST2 (properties, Qface, face);
+  add_text_properties_1 (start, end, properties, object,
                          (NILP (append)
                           ? TEXT_PROPERTY_PREPEND
                           : TEXT_PROPERTY_APPEND));
@@ -1906,7 +1912,8 @@ text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
 /* Note this can GC when DEST is a buffer.  */
 
 Lisp_Object
-copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src, Lisp_Object pos, Lisp_Object dest, Lisp_Object prop)
+copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src,
+                      Lisp_Object pos, Lisp_Object dest, Lisp_Object prop)
 {
   INTERVAL i;
   Lisp_Object res;
@@ -1959,12 +1966,10 @@ copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src, Lisp_
             plist = Fcdr (Fcdr (plist));
           }
       if (! NILP (plist))
-        {
-          /* Must defer modifications to the interval tree in case src
-             and dest refer to the same string or buffer.  */
-          stuff = Fcons (list3 (make_number (p), make_number (p + len), plist),
-                         stuff);
-        }
+        /* Must defer modifications to the interval tree in case
+           src and dest refer to the same string or buffer.  */
+        stuff = Fcons (list3 (make_number (p), make_number (p + len), plist),
+                       stuff);
 
       i = next_interval (i);
       if (!i)
diff --git a/src/unexcw.c b/src/unexcw.c
index 7636b05a12e..cdeb899fd30 100644
--- a/src/unexcw.c
+++ b/src/unexcw.c
@@ -34,12 +34,6 @@ extern void report_sheap_usage (int);
 
 extern int bss_sbrk_did_unexec;
 
-extern int __malloc_initialized;
-
-/* emacs symbols that indicate where bss and data end for emacs internals */
-extern char my_endbss[];
-extern char my_edata[];
-
 /*
 ** header for Windows executable files
 */
@@ -233,12 +227,9 @@ fixup_executable (int fd)
             lseek (fd, (long) (exe_header->section_header[i].s_scnptr),
                    SEEK_SET);
           assert (ret != -1);
-          /* force the dumped emacs to reinitialize malloc */
-          __malloc_initialized = 0;
           ret =
             write (fd, (char *) start_address,
                    my_endbss - (char *) start_address);
-          __malloc_initialized = 1;
           assert (ret == (my_endbss - (char *) start_address));
           if (debug_unexcw)
             printf ("         .bss, mem start %#lx mem length %d\n",
diff --git a/src/unexhp9k800.c b/src/unexhp9k800.c
index 55db8071b76..cbf1835b9ee 100644
--- a/src/unexhp9k800.c
+++ b/src/unexhp9k800.c
@@ -72,7 +72,6 @@ run_time_remap (char *ignored)
 
 #undef roundup
 #define roundup(x,n) (((x) + ((n) - 1)) & ~((n) - 1))  /* n is power of 2 */
-#define min(x,y)  (((x) < (y)) ? (x) : (y))
 
 /* Report a fatal error and exit.  */
 static _Noreturn void
diff --git a/src/unexmacosx.c b/src/unexmacosx.c
index 8cd80a7a544..2e1ac880d2a 100644
--- a/src/unexmacosx.c
+++ b/src/unexmacosx.c
@@ -107,9 +107,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <mach/mach.h>
 #include <mach-o/loader.h>
 #include <mach-o/reloc.h>
-#if defined (__ppc__)
-#include <mach-o/ppc/reloc.h>
-#endif
 #ifdef HAVE_MALLOC_MALLOC_H
 #include <malloc/malloc.h>
 #else
@@ -826,7 +823,6 @@ copy_data_segment (struct load_command *lc)
          file.  */
       if (strncmp (sectp->sectname, SECT_DATA, 16) == 0)
         {
-          extern char my_edata[];
           unsigned long my_size;
 
           /* The __data section is basically dumped from memory.  But
@@ -857,7 +853,6 @@ copy_data_segment (struct load_command *lc)
         }
       else if (strncmp (sectp->sectname, SECT_BSS, 16) == 0)
         {
-          extern char *my_endbss_static;
           unsigned long my_size;
 
           sectp->flags = S_REGULAR;
@@ -881,6 +876,27 @@ copy_data_segment (struct load_command *lc)
           if (!unexec_write (header_offset, sectp, sizeof (struct section)))
             unexec_error ("cannot write section %.16s's header", sectp->sectname);
         }
+      else if (strncmp (sectp->sectname, "__bss", 5) == 0
+               || strncmp (sectp->sectname, "__pu_bss", 8) == 0)
+        {
+          sectp->flags = S_REGULAR;
+
+          /* These sections are produced by GCC 4.6+.
+
+             FIXME: We possibly ought to clear uninitialized local
+             variables in statically linked libraries like for
+             SECT_BSS (__bss) above, but setting up the markers we
+             need in lastfile.c would be rather messy. See
+             darwin_output_aligned_bss () in gcc/config/darwin.c for
+             the root of the problem, keeping in mind that the
+             sections are numbered by their alignment in GCC 4.6, but
+             by log2(alignment) in GCC 4.7. */
+
+          if (!unexec_write (sectp->offset, (void *) sectp->addr, sectp->size))
+            unexec_error ("cannot copy section %.16s", sectp->sectname);
+          if (!unexec_write (header_offset, sectp, sizeof (struct section)))
+            unexec_error ("cannot write section %.16s's header", sectp->sectname);
+        }
       else if (strncmp (sectp->sectname, "__la_symbol_ptr", 16) == 0
                || strncmp (sectp->sectname, "__nl_symbol_ptr", 16) == 0
                || strncmp (sectp->sectname, "__got", 16) == 0
@@ -892,6 +908,7 @@ copy_data_segment (struct load_command *lc)
                || strncmp (sectp->sectname, "__program_vars", 16) == 0
                || strncmp (sectp->sectname, "__mod_init_func", 16) == 0
                || strncmp (sectp->sectname, "__mod_term_func", 16) == 0
+               || strncmp (sectp->sectname, "__static_data", 16) == 0
                || strncmp (sectp->sectname, "__objc_", 7) == 0)
         {
           if (!unexec_copy (sectp->offset, old_file_offset, sectp->size))
@@ -1013,17 +1030,8 @@ unrelocate (const char *name, off_t reloff, int nrel, vm_address_t base)
                           name, i, reloc_info.r_type);
           }
       else
-        switch (sc_reloc_info->r_type)
-          {
-#if defined (__ppc__)
-          case PPC_RELOC_PB_LA_PTR:
-            /* nothing to do for prebound lazy pointer */
-            break;
-#endif
-          default:
-            unexec_error ("unrelocate: %s:%d cannot handle scattered type = %d",
-                          name, i, sc_reloc_info->r_type);
-          }
+        unexec_error ("unrelocate: %s:%d cannot handle scattered type = %d",
+                      name, i, sc_reloc_info->r_type);
     }
 
   if (nrel > 0)
@@ -1031,35 +1039,6 @@ unrelocate (const char *name, off_t reloff, int nrel, vm_address_t base)
             unreloc_count, nrel, name);
 }
 
-#if __ppc64__
-/* Rebase r_address in the relocation table.  */
-static void
-rebase_reloc_address (off_t reloff, int nrel, long linkedit_delta, long diff)
-{
-  int i;
-  struct relocation_info reloc_info;
-  struct scattered_relocation_info *sc_reloc_info
-    = (struct scattered_relocation_info *) &reloc_info;
-
-  for (i = 0; i < nrel; i++, reloff += sizeof (reloc_info))
-    {
-      if (lseek (infd, reloff - linkedit_delta, L_SET)
-          != reloff - linkedit_delta)
-        unexec_error ("rebase_reloc_table: cannot seek to reloc_info");
-      if (!unexec_read (&reloc_info, sizeof (reloc_info)))
-        unexec_error ("rebase_reloc_table: cannot read reloc_info");
-
-      if (sc_reloc_info->r_scattered == 0
-          && reloc_info.r_type == GENERIC_RELOC_VANILLA)
-        {
-          reloc_info.r_address -= diff;
-          if (!unexec_write (reloff, &reloc_info, sizeof (reloc_info)))
-            unexec_error ("rebase_reloc_table: cannot write reloc_info");
-        }
-    }
-}
-#endif
-
 /* Copy a LC_DYSYMTAB load command from the input file to the output
    file, adjusting the file offset fields.  */
 static void
@@ -1069,28 +1048,8 @@ copy_dysymtab (struct load_command *lc, long delta)
   vm_address_t base;
 
 #ifdef _LP64
-#if __ppc64__
-  {
-    int i;
-
-    base = 0;
-    for (i = 0; i < nlc; i++)
-      if (lca[i]->cmd == LC_SEGMENT)
-        {
-          struct segment_command *scp = (struct segment_command *) lca[i];
-
-          if (scp->vmaddr + scp->vmsize > 0x100000000
-              && (scp->initprot & VM_PROT_WRITE) != 0)
-            {
-              base = data_segment_scp->vmaddr;
-              break;
-            }
-        }
-  }
-#else
   /* First writable segment address.  */
   base = data_segment_scp->vmaddr;
-#endif
 #else
   /* First segment address in the file (unless MH_SPLIT_SEGS set). */
   base = 0;
@@ -1116,29 +1075,6 @@ copy_dysymtab (struct load_command *lc, long delta)
     unexec_error ("cannot write symtab command to header");
 
   curr_header_offset += lc->cmdsize;
-
-#if __ppc64__
-  /* Check if the relocation base needs to be changed.  */
-  if (base == 0)
-    {
-      vm_address_t newbase = 0;
-      int i;
-
-      for (i = 0; i < num_unexec_regions; i++)
-        if (unexec_regions[i].range.address + unexec_regions[i].range.size
-            > 0x100000000)
-          {
-            newbase = data_segment_scp->vmaddr;
-            break;
-          }
-
-      if (newbase)
-        {
-          rebase_reloc_address (dstp->locreloff, dstp->nlocrel, delta, newbase);
-          rebase_reloc_address (dstp->extreloff, dstp->nextrel, delta, newbase);
-        }
-    }
-#endif
 }
 
 /* Copy a LC_TWOLEVEL_HINTS load command from the input file to the output
@@ -1302,7 +1238,9 @@ dump_it (void)
       }
 
   if (curr_header_offset > text_seg_lowest_offset)
-    unexec_error ("not enough room for load commands for new __DATA segments");
+    unexec_error ("not enough room for load commands for new __DATA segments"
+                  " (increase headerpad_extra in configure.in to at least %lX)",
+                  num_unexec_regions * sizeof (struct segment_command));
 
   printf ("%ld unused bytes follow Mach-O header\n",
           text_seg_lowest_offset - curr_header_offset);
diff --git a/src/unexw32.c b/src/unexw32.c
index 7cbd95a46fe..5c1c1f3f391 100644
--- a/src/unexw32.c
+++ b/src/unexw32.c
@@ -43,19 +43,11 @@ PIMAGE_NT_HEADERS
 extern BOOL ctrl_c_handler (unsigned long type);
 
 extern char my_begdata[];
-extern char my_edata[];
 extern char my_begbss[];
-extern char my_endbss[];
 extern char *my_begbss_static;
-extern char *my_endbss_static;
 
 #include "w32heap.h"
 
-#undef min
-#undef max
-#define min(x, y) (((x) < (y)) ? (x) : (y))
-#define max(x, y) (((x) > (y)) ? (x) : (y))
-
 /* Basically, our "initialized" flag.  */
 BOOL using_dynamic_heap = FALSE;
 
diff --git a/src/vm-limit.c b/src/vm-limit.c
index 308613f7eb4..015f3ee2111 100644
--- a/src/vm-limit.c
+++ b/src/vm-limit.c
@@ -51,6 +51,15 @@ char data_start[1] = { 1 };
 # endif
 #endif
 
+/* From gmalloc.c.  */
+extern void (* __after_morecore_hook) (void);
+extern void *(*__morecore) (ptrdiff_t);
+
+/* From ralloc.c.  */
+#ifdef REL_ALLOC
+extern void *(*real_morecore) (ptrdiff_t);
+#endif
+
 /*
   Level number of warnings already issued.
   0 -- no warnings issued.
@@ -130,12 +139,9 @@ ret_lim_data (void)
 static void
 check_memory_limits (void)
 {
-#ifdef REL_ALLOC
-  extern void *(*real_morecore) (ptrdiff_t);
-#else
+#ifndef REL_ALLOC
   void *(*real_morecore) (ptrdiff_t) = 0;
 #endif
-  extern void *(*__morecore) (ptrdiff_t);
 
   char *cp;
   size_t five_percent;
@@ -203,8 +209,6 @@ check_memory_limits (void)
 void
 memory_warnings (void *start, void (*warnfun) (const char *))
 {
-  extern void (* __after_morecore_hook) (void);     /* From gmalloc.c */
-
   data_space_start = start ? start : data_start;
 
   warn_function = warnfun;
diff --git a/src/w32.c b/src/w32.c
index 7cb9d8960c5..f014cd73a76 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -309,6 +309,8 @@ static BOOL g_b_init_set_named_security_info_w;
 static BOOL g_b_init_set_named_security_info_a;
 static BOOL g_b_init_get_adapters_info;
 
+BOOL g_b_init_compare_string_w;
+
 /*
   BEGIN: Wrapper functions around OpenProcessToken
   and other functions in advapi32.dll that are only
@@ -2292,7 +2294,7 @@ get_long_basename (char * name, char * buf, int size)
 
 /* Get long name for file, if possible (assumed to be absolute).  */
 BOOL
-w32_get_long_filename (char * name, char * buf, int size)
+w32_get_long_filename (const char * name, char * buf, int size)
 {
   char * o = buf;
   char * p;
@@ -2343,7 +2345,7 @@ w32_get_long_filename (char * name, char * buf, int size)
 }
 
 unsigned int
-w32_get_short_filename (char * name, char * buf, int size)
+w32_get_short_filename (const char * name, char * buf, int size)
 {
   if (w32_unicode_filenames)
     {
@@ -2389,6 +2391,8 @@ ansi_encode_filename (Lisp_Object filename)
           dostounix_filename (shortname);
           encoded_filename = build_string (shortname);
         }
+      else
+        encoded_filename = build_unibyte_string (fname);
     }
   else
     encoded_filename = build_unibyte_string (fname);
@@ -7718,15 +7722,15 @@ fcntl (int s, int cmd, int options)
   if (cmd == F_DUPFD_CLOEXEC)
     return sys_dup (s);
 
-  if (winsock_lib == NULL)
-    {
-      errno = ENETDOWN;
-      return -1;
-    }
-
   check_errno ();
   if (fd_info[s].flags & FILE_SOCKET)
     {
+      if (winsock_lib == NULL)
+        {
+          errno = ENETDOWN;
+          return -1;
+        }
+
       if (cmd == F_SETFL && options == O_NONBLOCK)
         {
           unsigned long nblock = 1;
@@ -7743,13 +7747,36 @@ fcntl (int s, int cmd, int options)
           return SOCKET_ERROR;
         }
     }
+  else if ((fd_info[s].flags & (FILE_PIPE | FILE_WRITE))
+           == (FILE_PIPE | FILE_WRITE))
+    {
+      /* Force our writes to pipes be non-blocking.  */
+      if (cmd == F_SETFL && options == O_NONBLOCK)
+        {
+          HANDLE h = (HANDLE)_get_osfhandle (s);
+          DWORD pipe_mode = PIPE_NOWAIT;
+
+          if (!SetNamedPipeHandleState (h, &pipe_mode, NULL, NULL))
+            {
+              DebPrint (("SetNamedPipeHandleState: %lu\n", GetLastError ()));
+              return SOCKET_ERROR;
+            }
+          fd_info[s].flags |= FILE_NDELAY;
+          return 0;
+        }
+      else
+        {
+          errno = EINVAL;
+          return SOCKET_ERROR;
+        }
+    }
   errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
 
 /* Shadow main io functions: we need to handle pipes and sockets more
-   intelligently, and implement non-blocking mode as well. */
+   intelligently.  */
 
 int
 sys_close (int fd)
@@ -8234,11 +8261,11 @@ sys_read (int fd, char * buffer, unsigned int count)
 /* From w32xfns.c */
 extern HANDLE interrupt_handle;
 
-/* For now, don't bother with a non-blocking mode */
 int
 sys_write (int fd, const void * buffer, unsigned int count)
 {
   int nchars;
+  USE_SAFE_ALLOCA;
 
   if (fd < 0)
     {
@@ -8257,30 +8284,33 @@ sys_write (int fd, const void * buffer, unsigned int count)
       /* Perform text mode translation if required.  */
       if ((fd_info[fd].flags & FILE_BINARY) == 0)
         {
-          char * tmpbuf = alloca (count * 2);
-          unsigned char * src = (void *)buffer;
-          unsigned char * dst = tmpbuf;
+          char * tmpbuf;
+          const unsigned char * src = buffer;
+          unsigned char * dst;
           int nbytes = count;
 
+          SAFE_NALLOCA (tmpbuf, 2, count);
+          dst = tmpbuf;
+
           while (1)
             {
               unsigned char *next;
-              /* copy next line or remaining bytes */
+              /* Copy next line or remaining bytes.  */
               next = _memccpy (dst, src, '\n', nbytes);
               if (next)
                 {
-                  /* copied one line ending with '\n' */
+                  /* Copied one line ending with '\n'.  */
                   int copied = next - dst;
                   nbytes -= copied;
                   src += copied;
-                  /* insert '\r' before '\n' */
+                  /* Insert '\r' before '\n'.  */
                   next[-1] = '\r';
                   next[0] = '\n';
                   dst = next + 1;
                   count++;
                 }
               else
-                /* copied remaining partial line -> now finished */
+                /* Copied remaining partial line -> now finished.  */
                 break;
             }
           buffer = tmpbuf;
@@ -8294,31 +8324,44 @@ sys_write (int fd, const void * buffer, unsigned int count)
       HANDLE wait_hnd[2] = { interrupt_handle, ovl->hEvent };
       DWORD active = 0;
 
+      /* This is async (a.k.a. "overlapped") I/O, so the return value
+         of FALSE from WriteFile means either an error or the output
+         will be completed asynchronously (ERROR_IO_PENDING).  */
       if (!WriteFile (hnd, buffer, count, (DWORD*) &nchars, ovl))
         {
           if (GetLastError () != ERROR_IO_PENDING)
             {
               errno = EIO;
-              return -1;
+              nchars = -1;
             }
-          if (detect_input_pending ())
-            active = MsgWaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE,
-                                                QS_ALLINPUT);
           else
-            active = WaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE);
-          if (active == WAIT_OBJECT_0)
-            { /* User pressed C-g, cancel write, then leave.  Don't bother
-                 cleaning up as we may only get stuck in buggy drivers.  */
-              PurgeComm (hnd, PURGE_TXABORT | PURGE_TXCLEAR);
-              CancelIo (hnd);
-              errno = EIO;
-              return -1;
-            }
-          if (active == WAIT_OBJECT_0 + 1
-              && !GetOverlappedResult (hnd, ovl, (DWORD*) &nchars, TRUE))
             {
-              errno = EIO;
-              return -1;
+              /* Wait for the write to complete, and watch C-g while
+                 at that.  */
+              if (detect_input_pending ())
+                active = MsgWaitForMultipleObjects (2, wait_hnd, FALSE,
+                                                    INFINITE, QS_ALLINPUT);
+              else
+                active = WaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE);
+              switch (active)
+                {
+                case WAIT_OBJECT_0:
+                  /* User pressed C-g, cancel write, then leave.
+                     Don't bother cleaning up as we may only get stuck
+                     in buggy drivers.  */
+                  PurgeComm (hnd, PURGE_TXABORT | PURGE_TXCLEAR);
+                  CancelIo (hnd);
+                  errno = EIO;  /* Why not EINTR? */
+                  nchars = -1;
+                  break;
+                case WAIT_OBJECT_0 + 1:
+                  if (!GetOverlappedResult (hnd, ovl, (DWORD*) &nchars, TRUE))
+                    {
+                      errno = EIO;
+                      nchars = -1;
+                    }
+                  break;
+                }
             }
         }
     }
@@ -8369,6 +8412,22 @@ sys_write (int fd, const void * buffer, unsigned int count)
           nchars += n;
           if (n < 0)
             {
+              /* When there's no buffer space in a pipe that is in the
+                 non-blocking mode, _write returns ENOSPC.  We return
+                 EAGAIN instead, which should trigger the logic in
+                 send_process that enters waiting loop and calls
+                 wait_reading_process_output to allow process input to
+                 be accepted during the wait.  Those calls to
+                 wait_reading_process_output allow sys_select to
+                 notice when process input becomes available, thus
+                 avoiding deadlock whereby each side of the pipe is
+                 blocked on write, waiting for the other party to read
+                 its end of the pipe.  */
+              if (errno == ENOSPC
+                  && fd < MAXDESC
+                  && ((fd_info[fd].flags & (FILE_PIPE | FILE_NDELAY))
+                      == (FILE_PIPE | FILE_NDELAY)))
+                errno = EAGAIN;
               nchars = n;
               break;
             }
@@ -8379,6 +8438,7 @@ sys_write (int fd, const void * buffer, unsigned int count)
         }
     }
 
+  SAFE_FREE ();
   return nchars;
 }
 
@@ -9068,6 +9128,7 @@ globals_of_w32 (void)
   g_b_init_set_named_security_info_w = 0;
   g_b_init_set_named_security_info_a = 0;
   g_b_init_get_adapters_info = 0;
+  g_b_init_compare_string_w = 0;
   num_of_processors = 0;
   /* The following sets a handler for shutdown notifications for
      console apps. This actually applies to Emacs in both console and
diff --git a/src/w32.h b/src/w32.h
index 94f7a962833..e0aedcbffa2 100644
--- a/src/w32.h
+++ b/src/w32.h
@@ -144,10 +144,10 @@ extern char * w32_strerror (int error_no);
 extern int w32_valid_pointer_p (void *, int);
 
 /* Get long (aka "true") form of file name, if it exists.  */
-extern BOOL w32_get_long_filename (char * name, char * buf, int size);
+extern BOOL w32_get_long_filename (const char * name, char * buf, int size);
 
 /* Get the short (a.k.a. "8+3") form of a file name.  */
-extern unsigned int w32_get_short_filename (char *, char *, int);
+extern unsigned int w32_get_short_filename (const char *, char *, int);
 
 /* Prepare our standard handles for proper inheritance by child processes.  */
 extern void prepare_standard_handles (int in, int out,
@@ -210,6 +210,9 @@ extern int sys_link (const char *, const char *);
 extern int w32_memory_info (unsigned long long *, unsigned long long *,
                             unsigned long long *, unsigned long long *);
 
+/* Compare 2 UTF-8 strings in locale-dependent fashion.  */
+extern int w32_compare_strings (const char *, const char *, char *, int);
+
 #ifdef HAVE_GNUTLS
 #include <gnutls/gnutls.h>
 
diff --git a/src/w32fns.c b/src/w32fns.c
index ac0e693e1c0..05da2a5c1d1 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -263,9 +263,9 @@ static unsigned int sound_type = 0xFFFFFFFF;
    the first display on the list.  */
 
 struct w32_display_info *
-check_x_display_info (Lisp_Object frame)
+check_x_display_info (Lisp_Object object)
 {
-  if (NILP (frame))
+  if (NILP (object))
     {
       struct frame *sf = XFRAME (selected_frame);
 
@@ -274,14 +274,23 @@ check_x_display_info (Lisp_Object frame)
       else
         return &one_w32_display_info;
     }
-  else if (STRINGP (frame))
-    return x_display_info_for_name (frame);
+  else if (TERMINALP (object))
+    {
+      struct terminal *t = decode_live_terminal (object);
+
+      if (t->type != output_w32)
+        error ("Terminal %d is not a W32 display", t->id);
+
+      return t->display_info.w32;
+    }
+  else if (STRINGP (object))
+    return x_display_info_for_name (object);
   else
     {
       struct frame *f;
 
-      CHECK_LIVE_FRAME (frame);
-      f = XFRAME (frame);
+      CHECK_LIVE_FRAME (object);
+      f = XFRAME (object);
       if (! FRAME_W32_P (f))
         error ("Non-W32 frame used");
       return FRAME_DISPLAY_INFO (f);
@@ -1956,13 +1965,12 @@ w32_createhscrollbar (struct frame *f, struct scroll_bar * bar)
 }
 
 static void
-w32_createwindow (struct frame *f)
+w32_createwindow (struct frame *f, int *coords)
 {
   HWND hwnd;
   RECT rect;
-  Lisp_Object top = Qunbound;
-  Lisp_Object left = Qunbound;
-  struct w32_display_info *dpyinfo = &one_w32_display_info;
+  int top;
+  int left;
 
   rect.left = rect.top = 0;
   rect.right = FRAME_PIXEL_WIDTH (f);
@@ -1977,25 +1985,21 @@ w32_createwindow (struct frame *f)
 
   if (f->size_hint_flags & USPosition || f->size_hint_flags & PPosition)
     {
-      XSETINT (left, f->left_pos);
-      XSETINT (top, f->top_pos);
+      left = f->left_pos;
+      top = f->top_pos;
     }
-  else if (EQ (left, Qunbound) && EQ (top, Qunbound))
+  else
     {
-      /* When called with RES_TYPE_NUMBER, w32_get_arg will return zero
-         for anything that is not a number and is not Qunbound.  */
-      left = x_get_arg (dpyinfo, Qnil, Qleft, "left", "Left", RES_TYPE_NUMBER);
-      top = x_get_arg (dpyinfo, Qnil, Qtop, "top", "Top", RES_TYPE_NUMBER);
+      left = coords[0];
+      top = coords[1];
     }
 
   FRAME_W32_WINDOW (f) = hwnd
     = CreateWindow (EMACS_CLASS,
                     f->namebuf,
                     f->output_data.w32->dwStyle | WS_CLIPCHILDREN,
-                    EQ (left, Qunbound) ? CW_USEDEFAULT : XINT (left),
-                    EQ (top, Qunbound) ? CW_USEDEFAULT : XINT (top),
-                    rect.right - rect.left,
-                    rect.bottom - rect.top,
+                    left, top,
+                    rect.right - rect.left, rect.bottom - rect.top,
                     NULL,
                     NULL,
                     hinst,
@@ -2516,7 +2520,8 @@ w32_msg_pump (deferred_msg * msg_buf)
                  the patch for XP is not publicly available until XP SP3,
                  and older versions will never be patched.  */
               CoInitialize (NULL);
-              w32_createwindow ((struct frame *) msg.wParam);
+              w32_createwindow ((struct frame *) msg.wParam,
+                                (int *) msg.lParam);
               if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
                 emacs_abort ();
               break;
@@ -4136,8 +4141,25 @@ static void
 my_create_window (struct frame * f)
 {
   MSG msg;
+  static int coords[2];
+  Lisp_Object left, top;
+  struct w32_display_info *dpyinfo = &one_w32_display_info;
+
+  /* When called with RES_TYPE_NUMBER, x_get_arg will return zero for
+     anything that is not a number and is not Qunbound.  */
+  left = x_get_arg (dpyinfo, Qnil, Qleft, "left", "Left", RES_TYPE_NUMBER);
+  top = x_get_arg (dpyinfo, Qnil, Qtop, "top", "Top", RES_TYPE_NUMBER);
+  if (EQ (left, Qunbound))
+    coords[0] = CW_USEDEFAULT;
+  else
+    coords[0] = XINT (left);
+  if (EQ (top, Qunbound))
+    coords[1] = CW_USEDEFAULT;
+  else
+    coords[1] = XINT (top);
 
-  if (!PostThreadMessage (dwWindowsThreadId, WM_EMACS_CREATEWINDOW, (WPARAM)f, 0))
+  if (!PostThreadMessage (dwWindowsThreadId, WM_EMACS_CREATEWINDOW,
+                          (WPARAM)f, (LPARAM)coords))
     emacs_abort ();
   GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
 }
@@ -4569,7 +4591,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
                        NULL, NULL, RES_TYPE_NUMBER);
   x_default_parameter (f, parameters, Qvertical_scroll_bars, Qright,
                        "verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL);
-  x_default_parameter (f, parameters, Qhorizontal_scroll_bars, Qbottom,
+  x_default_parameter (f, parameters, Qhorizontal_scroll_bars, Qnil,
                        "horizontalScrollBars", "ScrollBars", RES_TYPE_SYMBOL);
 
   /* Also do the stuff which must be set before the window exists.  */
@@ -5012,7 +5034,7 @@ If omitted or nil, that stands for the selected frame's display.  */)
   return Qnil;
 }
 
-static BOOL CALLBACK
+static BOOL CALLBACK ALIGN_STACK
 w32_monitor_enum (HMONITOR monitor, HDC hdc, RECT *rcMonitor, LPARAM dwData)
 {
   Lisp_Object *monitor_list = (Lisp_Object *) dwData;
@@ -5339,7 +5361,7 @@ terminate Emacs if we can't open the connection.
   {
     char basename[ MAX_PATH ], *str;
 
-    strcpy (basename, SDATA (Vinvocation_name));
+    lispstpcpy (basename, Vinvocation_name);
     str = strrchr (basename, '.');
     if (str) *str = 0;
     Vinvocation_name = build_string (basename);
@@ -5640,7 +5662,8 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
   f->wants_modeline = 0;
   XSETFRAME (frame, f);
 
-  buffer = Fget_buffer_create (build_string (" *tip*"));
+  AUTO_STRING (tip, " *tip*");
+  buffer = Fget_buffer_create (tip);
   /* Use set_window_buffer instead of Fset_window_buffer (see
      discussion of bug#11984, bug#12025, bug#12026).  */
   set_window_buffer (FRAME_ROOT_WINDOW (f), buffer, 0, 0);
diff --git a/src/w32font.c b/src/w32font.c
index 81e25eb0856..895931843ba 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -115,15 +115,15 @@ static void compute_metrics (HDC, struct w32font_info *, unsigned int,
 static Lisp_Object w32_registry (LONG, DWORD);
 
 /* EnumFontFamiliesEx callbacks.  */
-static int CALLBACK add_font_entity_to_list (ENUMLOGFONTEX *,
-                                             NEWTEXTMETRICEX *,
-                                             DWORD, LPARAM);
-static int CALLBACK add_one_font_entity_to_list (ENUMLOGFONTEX *,
-                                                 NEWTEXTMETRICEX *,
-                                                 DWORD, LPARAM);
-static int CALLBACK add_font_name_to_list (ENUMLOGFONTEX *,
-                                           NEWTEXTMETRICEX *,
-                                           DWORD, LPARAM);
+static int CALLBACK ALIGN_STACK add_font_entity_to_list (ENUMLOGFONTEX *,
+                                                         NEWTEXTMETRICEX *,
+                                                         DWORD, LPARAM);
+static int CALLBACK ALIGN_STACK add_one_font_entity_to_list (ENUMLOGFONTEX *,
+                                                             NEWTEXTMETRICEX *,
+                                                             DWORD, LPARAM);
+static int CALLBACK ALIGN_STACK add_font_name_to_list (ENUMLOGFONTEX *,
+                                                       NEWTEXTMETRICEX *,
+                                                       DWORD, LPARAM);
 
 /* struct passed in as LPARAM arg to EnumFontFamiliesEx, for keeping track
    of what we really want.  */
@@ -287,11 +287,11 @@ Lisp_Object
 intern_font_name (char * string)
 {
   Lisp_Object str = DECODE_SYSTEM (build_string (string));
-  int len = SCHARS (str);
+  ptrdiff_t len = SCHARS (str);
   Lisp_Object obarray = check_obarray (Vobarray);
   Lisp_Object tem = oblookup (obarray, SDATA (str), len, len);
   /* This code is similar to intern function from lread.c.  */
-  return SYMBOLP (tem) ? tem : Fintern (str, obarray);
+  return SYMBOLP (tem) ? tem : intern_driver (str, obarray, XINT (tem));
 }
 
 /* w32 implementation of get_cache for font backend.
@@ -473,7 +473,7 @@ w32font_encode_char (struct font *font, int c)
    of METRICS.  The glyphs are specified by their glyph codes in
    CODE (length NGLYPHS).  Apparently metrics can be NULL, in this
    case just return the overall width.  */
-int
+void
 w32font_text_extents (struct font *font, unsigned *code,
                       int nglyphs, struct font_metrics *metrics)
 {
@@ -487,84 +487,80 @@ w32font_text_extents (struct font *font, unsigned *code,
 
   struct w32font_info *w32_font = (struct w32font_info *) font;
 
-  if (metrics)
-    {
-      memset (metrics, 0, sizeof (struct font_metrics));
-      metrics->ascent = font->ascent;
-      metrics->descent = font->descent;
-
-      for (i = 0; i < nglyphs; i++)
-        {
-          struct w32_metric_cache *char_metric;
-          int block = *(code + i) / CACHE_BLOCKSIZE;
-          int pos_in_block = *(code + i) % CACHE_BLOCKSIZE;
+  memset (metrics, 0, sizeof (struct font_metrics));
+  metrics->ascent = font->ascent;
+  metrics->descent = font->descent;
 
-          if (block >= w32_font->n_cache_blocks)
-            {
-              if (!w32_font->cached_metrics)
-                w32_font->cached_metrics
-                  = xmalloc ((block + 1)
-                             * sizeof (struct w32_metric_cache *));
-              else
-                w32_font->cached_metrics
-                  = xrealloc (w32_font->cached_metrics,
-                              (block + 1)
-                              * sizeof (struct w32_metric_cache *));
-              memset (w32_font->cached_metrics + w32_font->n_cache_blocks, 0,
-                      ((block + 1 - w32_font->n_cache_blocks)
-                       * sizeof (struct w32_metric_cache *)));
-              w32_font->n_cache_blocks = block + 1;
-            }
+  for (i = 0; i < nglyphs; i++)
+    {
+      struct w32_metric_cache *char_metric;
+      int block = *(code + i) / CACHE_BLOCKSIZE;
+      int pos_in_block = *(code + i) % CACHE_BLOCKSIZE;
 
-          if (!w32_font->cached_metrics[block])
-            {
-              w32_font->cached_metrics[block]
-                = xzalloc (CACHE_BLOCKSIZE * sizeof (struct w32_metric_cache));
-            }
+      if (block >= w32_font->n_cache_blocks)
+        {
+          if (!w32_font->cached_metrics)
+            w32_font->cached_metrics
+              = xmalloc ((block + 1)
+                         * sizeof (struct w32_metric_cache *));
+          else
+            w32_font->cached_metrics
+              = xrealloc (w32_font->cached_metrics,
+                          (block + 1)
+                          * sizeof (struct w32_metric_cache *));
+          memset (w32_font->cached_metrics + w32_font->n_cache_blocks, 0,
+                  ((block + 1 - w32_font->n_cache_blocks)
+                   * sizeof (struct w32_metric_cache *)));
+          w32_font->n_cache_blocks = block + 1;
+        }
 
-          char_metric = w32_font->cached_metrics[block] + pos_in_block;
+      if (!w32_font->cached_metrics[block])
+        {
+          w32_font->cached_metrics[block]
+            = xzalloc (CACHE_BLOCKSIZE * sizeof (struct w32_metric_cache));
+        }
 
-          if (char_metric->status == W32METRIC_NO_ATTEMPT)
-            {
-              if (dc == NULL)
-                {
-                  /* TODO: Frames can come and go, and their fonts
-                     outlive them. So we can't cache the frame in the
-                     font structure.  Use selected_frame until the API
-                     is updated to pass in a frame.  */
-                  f = XFRAME (selected_frame);
-
-                  dc = get_frame_dc (f);
-                  old_font = SelectObject (dc, w32_font->hfont);
-                }
-              compute_metrics (dc, w32_font, *(code + i), char_metric);
-            }
+      char_metric = w32_font->cached_metrics[block] + pos_in_block;
 
-          if (char_metric->status == W32METRIC_SUCCESS)
+      if (char_metric->status == W32METRIC_NO_ATTEMPT)
+        {
+          if (dc == NULL)
             {
-              metrics->lbearing = min (metrics->lbearing,
-                                       metrics->width + char_metric->lbearing);
-              metrics->rbearing = max (metrics->rbearing,
-                                       metrics->width + char_metric->rbearing);
-              metrics->width += char_metric->width;
+              /* TODO: Frames can come and go, and their fonts
+                 outlive them. So we can't cache the frame in the
+                 font structure.  Use selected_frame until the API
+                 is updated to pass in a frame.  */
+              f = XFRAME (selected_frame);
+
+              dc = get_frame_dc (f);
+              old_font = SelectObject (dc, w32_font->hfont);
             }
-          else
-            /* If we couldn't get metrics for a char,
-               use alternative method.  */
-            break;
+          compute_metrics (dc, w32_font, *(code + i), char_metric);
         }
-      /* If we got through everything, return.  */
-      if (i == nglyphs)
-        {
-          if (dc != NULL)
-            {
-              /* Restore state and release DC.  */
-              SelectObject (dc, old_font);
-              release_frame_dc (f, dc);
-            }
 
-          return metrics->width;
-        }
+      if (char_metric->status == W32METRIC_SUCCESS)
+        {
+          metrics->lbearing = min (metrics->lbearing,
+                                   metrics->width + char_metric->lbearing);
+          metrics->rbearing = max (metrics->rbearing,
+                                   metrics->width + char_metric->rbearing);
+          metrics->width += char_metric->width;
+        }
+      else
+        /* If we couldn't get metrics for a char,
+           use alternative method.  */
+        break;
+    }
+  /* If we got through everything, return.  */
+  if (i == nglyphs)
+    {
+      if (dc != NULL)
+        {
+          /* Restore state and release DC.  */
+          SelectObject (dc, old_font);
+          release_frame_dc (f, dc);
+        }
+      return;
     }
 
   /* For non-truetype fonts, GetGlyphOutlineW is not supported, so
@@ -620,18 +616,13 @@ w32font_text_extents (struct font *font, unsigned *code,
     }
 
   /* Give our best estimate of the metrics, based on what we know.  */
-  if (metrics)
-    {
-      metrics->width = total_width - w32_font->metrics.tmOverhang;
-      metrics->lbearing = 0;
-      metrics->rbearing = total_width;
-    }
+  metrics->width = total_width - w32_font->metrics.tmOverhang;
+  metrics->lbearing = 0;
+  metrics->rbearing = total_width;
 
   /* Restore state and release DC.  */
   SelectObject (dc, old_font);
   release_frame_dc (f, dc);
-
-  return total_width;
 }
 
 /* w32 implementation of draw for font backend.
@@ -1009,7 +1000,7 @@ w32font_open_internal (struct frame *f, Lisp_Object font_entity,
 
 /* Callback function for EnumFontFamiliesEx.
  * Adds the name of a font to a Lisp list (passed in as the lParam arg).  */
-static int CALLBACK
+static int CALLBACK ALIGN_STACK
 add_font_name_to_list (ENUMLOGFONTEX *logical_font,
                        NEWTEXTMETRICEX *physical_font,
                        DWORD font_type, LPARAM list_object)
@@ -1455,7 +1446,7 @@ check_face_name (LOGFONT *font, char *full_name)
  * and if so, adds it to a list. Both the data we are checking against
  * and the list to which the fonts are added are passed in via the
  * lparam argument, in the form of a font_callback_data struct. */
-static int CALLBACK
+static int CALLBACK ALIGN_STACK
 add_font_entity_to_list (ENUMLOGFONTEX *logical_font,
                          NEWTEXTMETRICEX *physical_font,
                          DWORD font_type, LPARAM lParam)
@@ -1574,7 +1565,7 @@ add_font_entity_to_list (ENUMLOGFONTEX *logical_font,
 
 /* Callback function for EnumFontFamiliesEx.
  * Terminates the search once we have a match. */
-static int CALLBACK
+static int CALLBACK ALIGN_STACK
 add_one_font_entity_to_list (ENUMLOGFONTEX *logical_font,
                              NEWTEXTMETRICEX *physical_font,
                              DWORD font_type, LPARAM lParam)
diff --git a/src/w32font.h b/src/w32font.h
index 1be49bb91c2..5ce3ac7a5f9 100644
--- a/src/w32font.h
+++ b/src/w32font.h
@@ -74,8 +74,8 @@ int w32font_open_internal (struct frame *f, Lisp_Object font_entity,
                            int pixel_size, Lisp_Object font_object);
 void w32font_close (struct font *font);
 int w32font_has_char (Lisp_Object entity, int c);
-int w32font_text_extents (struct font *font, unsigned *code, int nglyphs,
-                          struct font_metrics *metrics);
+void w32font_text_extents (struct font *font, unsigned *code, int nglyphs,
+                           struct font_metrics *metrics);
 int w32font_draw (struct glyph_string *s, int from, int to,
                   int x, int y, bool with_background);
 
diff --git a/src/w32inevt.c b/src/w32inevt.c
index ccb5a900a16..7d10d88155c 100644
--- a/src/w32inevt.c
+++ b/src/w32inevt.c
@@ -411,7 +411,7 @@ w32_console_mouse_position (struct frame **f,
 
   *f = get_frame ();
   *bar_window = Qnil;
-  *part = 0;
+  *part = scroll_bar_above_handle;
   SELECTED_FRAME ()->mouse_moved = 0;
 
   XSETINT (*x, movement_pos.X);
@@ -605,7 +605,7 @@ maybe_generate_resize_event (void)
   change_frame_size (f,
                      1 + info.srWindow.Right - info.srWindow.Left,
                      1 + info.srWindow.Bottom - info.srWindow.Top
-                     - FRAME_MENU_BAR_LINES (f), 0, 0, 0, 0);
+                     - FRAME_MENU_BAR_LINES (f), 0, 1, 0, 0);
 }
 
 #if HAVE_W32NOTIFY
diff --git a/src/w32inevt.h b/src/w32inevt.h
index 9117453e721..c4836211bc9 100644
--- a/src/w32inevt.h
+++ b/src/w32inevt.h
@@ -27,6 +27,6 @@ extern void w32_console_mouse_position (struct frame **f, int insist,
                                         Lisp_Object *bar_window,
                                         enum scroll_bar_part *part,
                                         Lisp_Object *x, Lisp_Object *y,
-                                        unsigned long *time);
+                                        Time *time);
 
 #endif /* EMACS_W32INEVT_H */
diff --git a/src/w32proc.c b/src/w32proc.c
index 426a656f566..38452917add 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -32,6 +32,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <signal.h>
 #include <sys/file.h>
 #include <mbstring.h>
+#include <locale.h>
 
 /* must include CRT headers *before* config.h */
 #include <config.h>
@@ -1604,6 +1605,15 @@ sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
       program = ENCODE_FILE (full);
       cmdname = SDATA (program);
     }
+  else
+    {
+      char *p = alloca (strlen (cmdname) + 1);
+
+      /* Don't change the command name we were passed by our caller
+         (unixtodos_filename below will destructively mirror forward
+         slashes).  */
+      cmdname = strcpy (p, cmdname);
+    }
 
   /* make sure argv[0] and cmdname are both in DOS format */
   unixtodos_filename (cmdname);
@@ -1646,7 +1656,7 @@ sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
         strcpy (cmdname, egetenv ("CMDPROXY"));
       else
         {
-          strcpy (cmdname, SDATA (Vinvocation_directory));
+          lispstpcpy (cmdname, Vinvocation_directory);
           strcat (cmdname, "cmdproxy.exe");
         }
 
@@ -2908,7 +2918,7 @@ int_from_hex (char * s)
    function isn't given a context pointer.  */
 Lisp_Object Vw32_valid_locale_ids;
 
-static BOOL CALLBACK
+static BOOL CALLBACK ALIGN_STACK
 enum_locale_fn (LPTSTR localeNum)
 {
   DWORD id = int_from_hex (localeNum);
@@ -2972,7 +2982,7 @@ If successful, the new locale id is returned, otherwise nil.  */)
    function isn't given a context pointer.  */
 Lisp_Object Vw32_valid_codepages;
 
-static BOOL CALLBACK
+static BOOL CALLBACK ALIGN_STACK
 enum_codepage_fn (LPTSTR codepageNum)
 {
   DWORD id = atoi (codepageNum);
@@ -3144,6 +3154,190 @@ If successful, the new layout id is returned, otherwise nil.  */)
   return Fw32_get_keyboard_layout ();
 }
 
+/* Two variables to interface between get_lcid and the EnumLocales
+   callback function below.  */
+#ifndef LOCALE_NAME_MAX_LENGTH
+# define LOCALE_NAME_MAX_LENGTH 85
+#endif
+static LCID found_lcid;
+static char lname[3 * LOCALE_NAME_MAX_LENGTH + 1 + 1];
+
+/* Callback function for EnumLocales.  */
+static BOOL CALLBACK
+get_lcid_callback (LPTSTR locale_num_str)
+{
+  char *endp;
+  char locval[2 * LOCALE_NAME_MAX_LENGTH + 1 + 1];
+  LCID try_lcid = strtoul (locale_num_str, &endp, 16);
+
+  if (GetLocaleInfo (try_lcid, LOCALE_SABBREVLANGNAME,
+                     locval, LOCALE_NAME_MAX_LENGTH))
+    {
+      /* This is for when they only specify the language, as in "ENU".  */
+      if (stricmp (locval, lname) == 0)
+        {
+          found_lcid = try_lcid;
+          return FALSE;
+        }
+      strcat (locval, "_");
+      if (GetLocaleInfo (try_lcid, LOCALE_SABBREVCTRYNAME,
+                         locval + strlen (locval), LOCALE_NAME_MAX_LENGTH))
+        {
+          size_t locval_len = strlen (locval);
+
+          if (strnicmp (locval, lname, locval_len) == 0
+              && (lname[locval_len] == '.'
+                  || lname[locval_len] == '\0'))
+            {
+              found_lcid = try_lcid;
+              return FALSE;
+            }
+        }
+    }
+  return TRUE;
+}
+
+/* Return the Locale ID (LCID) number given the locale's name, a
+   string, in LOCALE_NAME.  This works by enumerating all the locales
+   supported by the system, until we find one whose name matches
+   LOCALE_NAME.  */
+static LCID
+get_lcid (const char *locale_name)
+{
+  /* A simple cache.  */
+  static LCID last_lcid;
+  static char last_locale[1000];
+
+  /* The code below is not thread-safe, as it uses static variables.
+     But this function is called only from the Lisp thread.  */
+  if (last_lcid > 0 && strcmp (locale_name, last_locale) == 0)
+    return last_lcid;
+
+  strncpy (lname, locale_name, sizeof (lname) - 1);
+  lname[sizeof (lname) - 1] = '\0';
+  found_lcid = 0;
+  EnumSystemLocales (get_lcid_callback, LCID_SUPPORTED);
+  if (found_lcid > 0)
+    {
+      last_lcid = found_lcid;
+      strcpy (last_locale, locale_name);
+    }
+  return found_lcid;
+}
+
+#ifndef _NSLCMPERROR
+# define _NSLCMPERROR INT_MAX
+#endif
+#ifndef LINGUISTIC_IGNORECASE
+# define LINGUISTIC_IGNORECASE  0x00000010
+#endif
+
+int
+w32_compare_strings (const char *s1, const char *s2, char *locname,
+                     int ignore_case)
+{
+  LCID lcid = GetThreadLocale ();
+  wchar_t *string1_w, *string2_w;
+  int val, needed;
+  extern BOOL g_b_init_compare_string_w;
+  static int (WINAPI *pCompareStringW)(LCID, DWORD, LPCWSTR, int, LPCWSTR, int);
+  DWORD flags = 0;
+
+  USE_SAFE_ALLOCA;
+
+  /* The LCID machinery doesn't seem to support the "C" locale, so we
+     need to do that by hand.  */
+  if (locname
+      && ((locname[0] == 'C' && (locname[1] == '\0' || locname[1] == '.'))
+          || strcmp (locname, "POSIX") == 0))
+    return (ignore_case ? stricmp (s1, s2) : strcmp (s1, s2));
+
+  if (!g_b_init_compare_string_w)
+    {
+      if (os_subtype == OS_9X)
+        {
+          pCompareStringW = GetProcAddress (LoadLibrary ("Unicows.dll"),
+                                            "CompareStringW");
+          if (!pCompareStringW)
+            {
+              errno = EINVAL;
+              /* This return value is compatible with wcscoll and
+                 other MS CRT functions.  */
+              return _NSLCMPERROR;
+            }
+        }
+      else
+        pCompareStringW = CompareStringW;
+
+      g_b_init_compare_string_w = 1;
+    }
+
+  needed = pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s1, -1, NULL, 0);
+  if (needed > 0)
+    {
+      SAFE_NALLOCA (string1_w, 1, needed + 1);
+      pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s1, -1,
+                            string1_w, needed);
+    }
+  else
+    {
+      errno = EINVAL;
+      return _NSLCMPERROR;
+    }
+
+  needed = pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s2, -1, NULL, 0);
+  if (needed > 0)
+    {
+      SAFE_NALLOCA (string2_w, 1, needed + 1);
+      pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s2, -1,
+                            string2_w, needed);
+    }
+  else
+    {
+      SAFE_FREE ();
+      errno = EINVAL;
+      return _NSLCMPERROR;
+    }
+
+  if (locname)
+    {
+      /* Convert locale name string to LCID.  We don't want to use
+         LocaleNameToLCID because (a) it is only available since
+         Vista, and (b) it doesn't accept locale names returned by
+         'setlocale' and 'GetLocaleInfo'.  */
+      LCID new_lcid = get_lcid (locname);
+
+      if (new_lcid > 0)
+        lcid = new_lcid;
+      else
+        error ("Invalid locale %s: Invalid argument", locname);
+    }
+
+  if (ignore_case)
+    {
+      /* NORM_IGNORECASE ignores any tertiary distinction, not just
+         case variants.  LINGUISTIC_IGNORECASE is more selective, and
+         is sensitive to the locale's language, but it is not
+         available before Vista.  */
+      if (w32_major_version >= 6)
+        flags |= LINGUISTIC_IGNORECASE;
+      else
+        flags |= NORM_IGNORECASE;
+    }
+  /* This approximates what glibc collation functions do when the
+     locale's codeset is UTF-8.  */
+  if (!NILP (Vw32_collate_ignore_punctuation))
+    flags |= NORM_IGNORESYMBOLS;
+  val = pCompareStringW (lcid, flags, string1_w, -1, string2_w, -1);
+  SAFE_FREE ();
+  if (!val)
+    {
+      errno = EINVAL;
+      return _NSLCMPERROR;
+    }
+  return val - 2;
+}
+
 
 void
 syms_of_ntproc (void)
@@ -3254,6 +3448,20 @@ Any other non-nil value means do this even on remote and removable drives
 where the performance impact may be noticeable even on modern hardware.  */);
   Vw32_get_true_file_attributes = Qlocal;
 
+  DEFVAR_LISP ("w32-collate-ignore-punctuation",
+               Vw32_collate_ignore_punctuation,
+               doc: /* Non-nil causes string collation functions ignore punctuation on MS-Windows.
+On Posix platforms, `string-collate-lessp' and `string-collate-equalp'
+ignore punctuation characters when they compare strings, if the
+locale's codeset is UTF-8, as in \"en_US.UTF-8\".  Binding this option
+to a non-nil value will achieve a similar effect on MS-Windows, where
+locales with UTF-8 codeset are not supported.
+
+Note that setting this to non-nil will also ignore blanks and symbols
+in the strings.  So do NOT use this option when comparing file names
+for equality, only when you need to sort them.  */);
+  Vw32_collate_ignore_punctuation = Qnil;
+
   staticpro (&Vw32_valid_locale_ids);
   staticpro (&Vw32_valid_codepages);
 }
diff --git a/src/w32term.c b/src/w32term.c
index d9e051be870..e8bcf3ef639 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -2228,7 +2228,7 @@ x_draw_stretch_glyph_string (struct glyph_string *s)
         {
           /* In R2L rows, draw the cursor on the right edge of the
              stretch glyph.  */
-          int right_x = window_box_right_offset (s->w, TEXT_AREA);
+          int right_x = window_box_right (s->w, TEXT_AREA);
 
           if (x + background_width > right_x)
             background_width -= x - right_x;
@@ -3344,11 +3344,11 @@ static struct scroll_bar *x_window_to_scroll_bar (Window, int);
 static void x_scroll_bar_report_motion (struct frame **, Lisp_Object *,
                                         enum scroll_bar_part *,
                                         Lisp_Object *, Lisp_Object *,
-                                        unsigned long *);
+                                        Time *);
 static void x_horizontal_scroll_bar_report_motion (struct frame **, Lisp_Object *,
                                                    enum scroll_bar_part *,
                                                    Lisp_Object *, Lisp_Object *,
-                                                   unsigned long *);
+                                                   Time *);
 static void x_check_fullscreen (struct frame *);
 
 static void
@@ -3380,7 +3380,7 @@ w32_define_cursor (Window window, Cursor cursor)
 static void
 w32_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
                     enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
-                    unsigned long *time)
+                    Time *time)
 {
   struct frame *f1;
   struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
@@ -3448,7 +3448,7 @@ w32_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
             dpyinfo->last_mouse_glyph_frame = f1;
 
             *bar_window = Qnil;
-            *part = 0;
+            *part = scroll_bar_above_handle;
             *fp = f1;
             XSETINT (*x, pt.x);
             XSETINT (*y, pt.y);
@@ -4293,7 +4293,7 @@ w32_horizontal_scroll_bar_handle_click (struct scroll_bar *bar, W32Msg *msg,
       x = si.nTrackPos;
     else
       x = si.nPos;
-    y = si.nMax - x - si.nPage;
+    y = si.nMax - si.nPage;
 
     bar->dragging = 0;
     FRAME_DISPLAY_INFO (f)->last_mouse_scroll_bar_pos = msg->msg.wParam;
@@ -4350,12 +4350,9 @@ w32_horizontal_scroll_bar_handle_click (struct scroll_bar *bar, W32Msg *msg,
             int end = bar->end;
 
             si.cbSize = sizeof (si);
-/**         si.fMask = SIF_PAGE | SIF_POS; **/
             si.fMask = SIF_POS;
-/**         si.nPage = end - start + HORIZONTAL_SCROLL_BAR_MIN_HANDLE; **/
             si.nPos = min (last_scroll_bar_drag_pos,
                            XWINDOW (bar->window)->hscroll_whole - 1);
-/**         si.nPos = last_scroll_bar_drag_pos; **/
             SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE);
           }
         /* fall through */
@@ -4377,7 +4374,7 @@ static void
 x_scroll_bar_report_motion (struct frame **fp, Lisp_Object *bar_window,
                             enum scroll_bar_part *part,
                             Lisp_Object *x, Lisp_Object *y,
-                            unsigned long *time)
+                            Time *time)
 {
   struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
   struct scroll_bar *bar = dpyinfo->last_mouse_scroll_bar;
@@ -4427,7 +4424,7 @@ static void
 x_horizontal_scroll_bar_report_motion (struct frame **fp, Lisp_Object *bar_window,
                                        enum scroll_bar_part *part,
                                        Lisp_Object *x, Lisp_Object *y,
-                                       unsigned long *time)
+                                       Time *time)
 {
   struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
   struct scroll_bar *bar = dpyinfo->last_mouse_scroll_bar;
@@ -5147,30 +5144,38 @@ w32_read_socket (struct terminal *terminal,
               RECT rect;
               int rows, columns, width, height, text_width, text_height;
 
-              GetClientRect (msg.msg.hwnd, &rect);
-
-              height = rect.bottom - rect.top;
-              width = rect.right - rect.left;
-              text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, width);
-              text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, height);
-              /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
-              /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
-
-              /* TODO: Clip size to the screen dimensions.  */
-
-              /* Even if the number of character rows and columns has
-                 not changed, the font size may have changed, so we need
-                 to check the pixel dimensions as well.  */
-
-              if (width != FRAME_PIXEL_WIDTH (f)
-                  || height != FRAME_PIXEL_HEIGHT (f)
-                  || text_width != FRAME_TEXT_WIDTH (f)
-                  || text_height != FRAME_TEXT_HEIGHT (f))
+              if (GetClientRect (msg.msg.hwnd, &rect)
+                  /* GetClientRect evidently returns (0, 0, 0, 0) if
+                     called on a minimized frame.  Such "dimensions"
+                     aren't useful anyway.  */
+                  && !(rect.bottom == 0
+                       && rect.top == 0
+                       && rect.left == 0
+                       && rect.right == 0))
                 {
-                  change_frame_size (f, text_width, text_height, 0, 1, 0, 1);
-                  SET_FRAME_GARBAGED (f);
-                  cancel_mouse_face (f);
-                  f->win_gravity = NorthWestGravity;
+                  height = rect.bottom - rect.top;
+                  width = rect.right - rect.left;
+                  text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, width);
+                  text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, height);
+                  /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
+                  /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
+
+                  /* TODO: Clip size to the screen dimensions.  */
+
+                  /* Even if the number of character rows and columns
+                     has not changed, the font size may have changed,
+                     so we need to check the pixel dimensions as well.  */
+
+                  if (width != FRAME_PIXEL_WIDTH (f)
+                      || height != FRAME_PIXEL_HEIGHT (f)
+                      || text_width != FRAME_TEXT_WIDTH (f)
+                      || text_height != FRAME_TEXT_HEIGHT (f))
+                    {
+                      change_frame_size (f, text_width, text_height, 0, 1, 0, 1);
+                      SET_FRAME_GARBAGED (f);
+                      cancel_mouse_face (f);
+                      f->win_gravity = NorthWestGravity;
+                    }
                 }
             }
 
@@ -5475,6 +5480,12 @@ x_draw_hollow_cursor (struct window *w, struct glyph_row *row)
   /* Compute frame-relative coordinates for phys cursor.  */
   get_phys_cursor_geometry (w, row, cursor_glyph, &left, &top, &h);
   rect.left = left;
+  /* When on R2L character, show cursor at the right edge of the
+     glyph, unless the cursor box is as wide as the glyph or wider
+     (the latter happens when x-stretch-cursor is non-nil).  */
+  if ((cursor_glyph->resolved_level & 1) != 0
+      && cursor_glyph->pixel_width > w->phys_cursor_width)
+    rect.left += cursor_glyph->pixel_width - w->phys_cursor_width;
   rect.top = top;
   rect.bottom = rect.top + h;
   rect.right = rect.left + w->phys_cursor_width;
@@ -5556,7 +5567,7 @@ x_draw_bar_cursor (struct window *w, struct glyph_row *row,
                          WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
                          width, row->height);
         }
-      else
+      else      /* HBAR_CURSOR */
         {
           int dummy_x, dummy_y, dummy_h;
 
@@ -5567,6 +5578,9 @@ x_draw_bar_cursor (struct window *w, struct glyph_row *row,
 
           get_phys_cursor_geometry (w, row, cursor_glyph, &dummy_x,
                                     &dummy_y, &dummy_h);
+          if ((cursor_glyph->resolved_level & 1) != 0
+              && cursor_glyph->pixel_width > w->phys_cursor_width)
+            x += cursor_glyph->pixel_width - w->phys_cursor_width;
           w32_fill_area (f, hdc, cursor_color, x,
                          WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
                                                   row->height - width),
@@ -6333,7 +6347,7 @@ x_make_frame_visible (struct frame *f)
           RECT window_rect;
 
           /* Adjust vertical window position in order to avoid being
-             covered by a task bar placed at the bottom of the desktop. */
+             covered by a taskbar placed at the bottom of the desktop. */
           SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0);
           GetWindowRect (FRAME_W32_WINDOW (f), &window_rect);
           if (window_rect.bottom > workarea_rect.bottom
diff --git a/src/w32term.h b/src/w32term.h
index 0fabe12819c..fb37550100e 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -22,6 +22,22 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "frame.h"
 #include "atimer.h"
 
+/* Stack alignment stuff.  Every CALLBACK function should have the
+   ALIGN_STACK attribute if it manipulates Lisp objects, because
+   Windows x86 32-bit ABI only guarantees 4-byte stack alignment, and
+   that is what we will get when a Windows function calls us.  The
+   ALIGN_STACK attribute forces GCC to emit a preamble code to
+   re-align the stack at function entry.  Further details about this
+   can be found in http://www.peterstock.co.uk/games/mingw_sse/.  */
+#ifdef __GNUC__
+# if USE_STACK_LISP_OBJECTS && !defined _WIN64 && !defined __x86_64__   \
+  && __GNUC__ + (__GNUC_MINOR__ > 1) >= 5
+#  define ALIGN_STACK __attribute__((force_align_arg_pointer))
+# else
+#  define ALIGN_STACK
+# endif  /* USE_STACK_LISP_OBJECTS */
+#endif
+
 
 #define BLACK_PIX_DEFAULT(f) PALETTERGB(0,0,0)
 #define WHITE_PIX_DEFAULT(f) PALETTERGB(255,255,255)
diff --git a/src/w32uniscribe.c b/src/w32uniscribe.c
index d06586f973a..1c7b256988c 100644
--- a/src/w32uniscribe.c
+++ b/src/w32uniscribe.c
@@ -52,9 +52,9 @@ extern Lisp_Object Quniscribe;
 extern Lisp_Object Qopentype;
 
 /* EnumFontFamiliesEx callback.  */
-static int CALLBACK add_opentype_font_name_to_list (ENUMLOGFONTEX *,
-                                                    NEWTEXTMETRICEX *,
-                                                    DWORD, LPARAM);
+static int CALLBACK ALIGN_STACK add_opentype_font_name_to_list (ENUMLOGFONTEX *,
+                                                                NEWTEXTMETRICEX *,
+                                                                DWORD, LPARAM);
 /* Used by uniscribe_otf_capability.  */
 static Lisp_Object otf_features (HDC context, char *table);
 
@@ -591,8 +591,8 @@ uniscribe_encode_char (struct font *font, int c)
    Lisp_Object uniscribe_get_cache (Lisp_Object frame);
    void uniscribe_free_entity (Lisp_Object font_entity);
    int uniscribe_has_char (Lisp_Object entity, int c);
-   int uniscribe_text_extents (struct font *font, unsigned *code,
-                               int nglyphs, struct font_metrics *metrics);
+   void uniscribe_text_extents (struct font *font, unsigned *code,
+                                int nglyphs, struct font_metrics *metrics);
    int uniscribe_draw (struct glyph_string *s, int from, int to,
                        int x, int y, int with_background);
 
@@ -613,7 +613,7 @@ uniscribe_encode_char (struct font *font, int c)
 /* Callback function for EnumFontFamiliesEx.
    Adds the name of opentype fonts to a Lisp list (passed in as the
    lParam arg). */
-static int CALLBACK
+static int CALLBACK ALIGN_STACK
 add_opentype_font_name_to_list (ENUMLOGFONTEX *logical_font,
                                 NEWTEXTMETRICEX *physical_font,
                                 DWORD font_type, LPARAM list_object)
diff --git a/src/widget.c b/src/widget.c
index b5b76bb306b..baa6a2ab917 100644
--- a/src/widget.c
+++ b/src/widget.c
@@ -579,15 +579,6 @@ EmacsFrameResize (Widget widget)
   if (true || frame_resize_pixelwise)
     {
       int width, height;
-/**       int width = (ew->core.width **/
-/**                - FRAME_SCROLL_BAR_AREA_WIDTH (f) **/
-/**                - FRAME_TOTAL_FRINGE_WIDTH (f) **/
-/**                - 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
-
-/**       int height  = (ew->core.height **/
-/**                  - FRAME_TOOLBAR_HEIGHT (f) **/
-/**                  - FRAME_SCROLL_BAR_AREA_HEIGHT (f) **/
-/**                  - 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
 
       pixel_to_text_size (ew, ew->core.width, ew->core.height, &width, &height);
       change_frame_size (f, width, height, 0, 1, 0, 1);
diff --git a/src/window.c b/src/window.c
index ac685f6867f..0b0f2140a58 100644
--- a/src/window.c
+++ b/src/window.c
@@ -4163,7 +4163,6 @@ resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
       new_pixel_size = max (horflag
                             ? size
                             : (size
-/**                            - FRAME_TOP_MARGIN_HEIGHT (f) **/
                                - ((FRAME_HAS_MINIBUF_P (f)
                                    && !FRAME_MINIBUF_ONLY_P (f))
                                   ? FRAME_LINE_HEIGHT (f) : 0)),
@@ -4175,7 +4174,6 @@ resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
       new_size = max (horflag
                       ? size
                       : (size
-/**                      - FRAME_TOP_MARGIN (f) **/
                          - ((FRAME_HAS_MINIBUF_P (f)
                              && !FRAME_MINIBUF_ONLY_P (f))
                             ? 1 : 0)),
@@ -4796,10 +4794,10 @@ DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini
       block_input ();
       window_resize_apply (r, 0);
 
-      w->total_lines = XFASTINT (w->new_total);
-      w->top_line = r->top_line + r->total_lines;
       w->pixel_height = XFASTINT (w->new_pixel);
+      w->total_lines = w->pixel_height / FRAME_LINE_HEIGHT (f);
       w->pixel_top = r->pixel_top + r->pixel_height;
+      w->top_line = r->top_line + r->total_lines;
 
       fset_redisplay (f);
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
@@ -5916,6 +5914,8 @@ and redisplay normally--don't erase and redraw the frame.  */)
   w->start_at_line_beg = (bytepos == BEGV_BYTE
                           || FETCH_BYTE (bytepos - 1) == '\n');
 
+  wset_redisplay (w);
+
   return Qnil;
 }
 
@@ -6124,6 +6124,7 @@ the return value is nil.  Otherwise the value is t.  */)
   Lisp_Object frame;
   struct frame *f;
   ptrdiff_t old_point = -1;
+  USE_SAFE_ALLOCA;
 
   CHECK_WINDOW_CONFIGURATION (configuration);
 
@@ -6231,8 +6232,8 @@ the return value is nil.  Otherwise the value is t.  */)
          really like to do is to free only those matrices not reused
          below.  */
       root_window = XWINDOW (FRAME_ROOT_WINDOW (f));
-      leaf_windows = alloca (count_windows (root_window)
-                             * sizeof *leaf_windows);
+      int nwindows = count_windows (root_window);
+      SAFE_NALLOCA (leaf_windows, 1, nwindows);
       n_leaf_windows = get_leaf_windows (root_window, leaf_windows, 0);
 
       /* Kludge Alert!
@@ -6456,424 +6457,11 @@ the return value is nil.  Otherwise the value is t.  */)
   Vminibuf_scroll_window = data->minibuf_scroll_window;
   minibuf_selected_window = data->minibuf_selected_window;
 
+  SAFE_FREE ();
   return (FRAME_LIVE_P (f) ? Qt : Qnil);
 }
 
 
-#if 0
-DEFUN ("set-window-configuration", Fset_window_configuration,
-       Sset_window_configuration, 1, 1, 0,
-       doc: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
-CONFIGURATION must be a value previously returned
-by `current-window-configuration' (which see).
-If CONFIGURATION was made from a frame that is now deleted,
-only frame-independent values can be restored.  In this case,
-the return value is nil.  Otherwise the value is t.  */)
-  (Lisp_Object configuration)
-{
-  register struct save_window_data *data;
-  struct Lisp_Vector *saved_windows;
-  Lisp_Object new_current_buffer;
-  Lisp_Object frame;
-  struct frame *f;
-  ptrdiff_t old_point = -1;
-
-  CHECK_WINDOW_CONFIGURATION (configuration);
-
-  data = (struct save_window_data *) XVECTOR (configuration);
-  saved_windows = XVECTOR (data->saved_windows);
-
-  new_current_buffer = data->current_buffer;
-  if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer)))
-    new_current_buffer = Qnil;
-  else
-    {
-      if (XBUFFER (new_current_buffer) == current_buffer)
-        /* The code further down "preserves point" by saving here PT in
-           old_point and then setting it later back into PT.  When the
-           current-selected-window and the final-selected-window both show
-           the current buffer, this suffers from the problem that the
-           current PT is the window-point of the current-selected-window,
-           while the final PT is the point of the final-selected-window, so
-           this copy from one PT to the other would end up moving the
-           window-point of the final-selected-window to the window-point of
-           the current-selected-window.  So we have to be careful which
-           point of the current-buffer we copy into old_point.  */
-        if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer)
-            && WINDOWP (selected_window)
-            && EQ (XWINDOW (selected_window)->contents, new_current_buffer)
-            && !EQ (selected_window, data->current_window))
-          old_point = marker_position (XWINDOW (data->current_window)->pointm);
-        else
-          old_point = PT;
-      else
-        /* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
-           point in new_current_buffer as of the last time this buffer was
-           used.  This can be non-deterministic since it can be changed by
-           things like jit-lock by mere temporary selection of some random
-           window that happens to show this buffer.
-           So if possible we want this arbitrary choice of "which point" to
-           be the one from the to-be-selected-window so as to prevent this
-           window's cursor from being copied from another window.  */
-        if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer)
-            /* If current_window = selected_window, its point is in BUF_PT.  */
-            && !EQ (selected_window, data->current_window))
-          old_point = marker_position (XWINDOW (data->current_window)->pointm);
-        else
-          old_point = BUF_PT (XBUFFER (new_current_buffer));
-    }
-
-  frame = XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;
-  f = XFRAME (frame);
-
-  /* If f is a dead frame, don't bother rebuilding its window tree.
-     However, there is other stuff we should still try to do below.  */
-  if (FRAME_LIVE_P (f))
-    {
-      Lisp_Object window;
-      Lisp_Object dead_windows = Qnil;
-      register Lisp_Object tem, par, pers;
-      register struct window *w;
-      register struct saved_window *p;
-      struct window *root_window;
-      struct window **leaf_windows;
-      int n_leaf_windows;
-      ptrdiff_t k;
-      int i, n;
-      ptrdiff_t count = SPECPDL_INDEX ();
-      /* If the frame has been resized since this window configuration was
-         made, we change the frame to the size specified in the
-         configuration, restore the configuration, and then resize it
-         back.  We keep track of the prevailing height in these variables.  */
-      int previous_frame_text_height = FRAME_TEXT_HEIGHT (f);
-      int previous_frame_text_width =  FRAME_TEXT_WIDTH  (f);
-      /* int previous_frame_menu_bar_height = FRAME_MENU_BAR_HEIGHT (f); */
-      /* int previous_frame_tool_bar_height = FRAME_TOOL_BAR_HEIGHT (f); */
-      /* int previous_frame_lines = FRAME_LINES (f); */
-      /* int previous_frame_cols =  FRAME_COLS  (f); */
-      int previous_frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
-      int previous_frame_tool_bar_lines = FRAME_TOOL_BAR_LINES (f);
-
-      /* Don't do this within the main loop below: This may call Lisp
-         code and is thus potentially unsafe while input is blocked.  */
-      for (k = 0; k < saved_windows->header.size; k++)
-        {
-          p = SAVED_WINDOW_N (saved_windows, k);
-          window = p->window;
-          w = XWINDOW (window);
-          if (BUFFERP (w->contents)
-              && !EQ (w->contents, p->buffer)
-              && BUFFER_LIVE_P (XBUFFER (p->buffer)))
-            /* If a window we restore gets another buffer, record the
-               window's old buffer.  */
-            call1 (Qrecord_window_buffer, window);
-        }
-
-      /* Consider frame unofficial, temporarily.  */
-      f->official = false;
-      /* The mouse highlighting code could get screwed up
-         if it runs during this.  */
-      block_input ();
-
-      if (data->frame_text_width != previous_frame_text_width
-          || data->frame_text_height != previous_frame_text_height)
-        /* Make frame size fit the one in data, so window sizes restored
-           from data match those of the frame.  */
-        adjust_frame_size (f, data->frame_text_width,
-                           data->frame_text_height, 5, 0);
-
-      if (data->frame_menu_bar_lines != previous_frame_menu_bar_lines)
-        {
-#ifdef HAVE_WINDOW_SYSTEM
-          if (FRAME_WINDOW_P (f))
-            x_set_menu_bar_lines (f, make_number (data->frame_menu_bar_lines),
-                                  make_number (0));
-          else  /* TTY or MSDOS */
-#endif
-            set_menu_bar_lines (f, make_number (data->frame_menu_bar_lines),
-                                make_number (0));
-        }
-#ifdef HAVE_WINDOW_SYSTEM
-      if (data->frame_tool_bar_lines != previous_frame_tool_bar_lines)
-        x_set_tool_bar_lines (f, make_number (data->frame_tool_bar_lines),
-                              make_number (0));
-#endif
-
-      /* "Swap out" point from the selected window's buffer
-         into the window itself.  (Normally the pointm of the selected
-         window holds garbage.)  We do this now, before
-         restoring the window contents, and prevent it from
-         being done later on when we select a new window.  */
-      if (! NILP (XWINDOW (selected_window)->contents))
-        {
-          w = XWINDOW (selected_window);
-          set_marker_both (w->pointm,
-                           w->contents,
-                           BUF_PT (XBUFFER (w->contents)),
-                           BUF_PT_BYTE (XBUFFER (w->contents)));
-        }
-
-      fset_redisplay (f);
-      FRAME_WINDOW_SIZES_CHANGED (f) = 1;
-
-      /* Problem: Freeing all matrices and later allocating them again
-         is a serious redisplay flickering problem.  What we would
-         really like to do is to free only those matrices not reused
-         below.  */
-      root_window = XWINDOW (FRAME_ROOT_WINDOW (f));
-      leaf_windows = alloca (count_windows (root_window)
-                             * sizeof *leaf_windows);
-      n_leaf_windows = get_leaf_windows (root_window, leaf_windows, 0);
-
-      /* Kludge Alert!
-         Mark all windows now on frame as "deleted".
-         Restoring the new configuration "undeletes" any that are in it.
-
-         Save their current buffers in their height fields, since we may
-         need it later, if a buffer saved in the configuration is now
-         dead.  */
-      delete_all_child_windows (FRAME_ROOT_WINDOW (f));
-
-      for (k = 0; k < saved_windows->header.size; k++)
-        {
-          p = SAVED_WINDOW_N (saved_windows, k);
-          window = p->window;
-          w = XWINDOW (window);
-          wset_next (w, Qnil);
-
-          if (!NILP (p->parent))
-            wset_parent
-              (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->parent))->window);
-          else
-            wset_parent (w, Qnil);
-
-          if (!NILP (p->prev))
-            {
-              wset_prev
-                (w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->prev))->window);
-              wset_next (XWINDOW (w->prev), p->window);
-            }
-          else
-            {
-              wset_prev (w, Qnil);
-              if (!NILP (w->parent))
-                wset_combination (XWINDOW (w->parent),
-                                  (XINT (p->total_cols)
-                                   != XWINDOW (w->parent)->total_cols),
-                                  p->window);
-            }
-
-          /* If we squirreled away the buffer, restore it now.  */
-          if (BUFFERP (w->combination_limit))
-            wset_buffer (w, w->combination_limit);
-          w->pixel_left = XFASTINT (p->pixel_left);
-          w->pixel_top = XFASTINT (p->pixel_top);
-          w->pixel_width = XFASTINT (p->pixel_width);
-          w->pixel_height = XFASTINT (p->pixel_height);
-          w->left_col = XFASTINT (p->left_col);
-          w->top_line = XFASTINT (p->top_line);
-          w->total_cols = XFASTINT (p->total_cols);
-          w->total_lines = XFASTINT (p->total_lines);
-          wset_normal_cols (w, p->normal_cols);
-          wset_normal_lines (w, p->normal_lines);
-          w->hscroll = XFASTINT (p->hscroll);
-          w->suspend_auto_hscroll = !NILP (p->suspend_auto_hscroll);
-          w->min_hscroll = XFASTINT (p->min_hscroll);
-          w->hscroll_whole = XFASTINT (p->hscroll_whole);
-          wset_display_table (w, p->display_table);
-          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);
-          w->scroll_bar_width = XINT (p->scroll_bar_width);
-          w->scroll_bar_height = XINT (p->scroll_bar_height);
-          wset_vertical_scroll_bar_type (w, p->vertical_scroll_bar_type);
-          wset_horizontal_scroll_bar_type (w, p->horizontal_scroll_bar_type);
-          wset_dedicated (w, p->dedicated);
-          wset_combination_limit (w, p->combination_limit);
-          /* Restore any window parameters that have been saved.
-             Parameters that have not been saved are left alone.  */
-          for (tem = p->window_parameters; CONSP (tem); tem = XCDR (tem))
-            {
-              pers = XCAR (tem);
-              if (CONSP (pers))
-                {
-                  if (NILP (XCDR (pers)))
-                    {
-                      par = Fassq (XCAR (pers), w->window_parameters);
-                      if (CONSP (par) && !NILP (XCDR (par)))
-                        /* Reset a parameter to nil if and only if it
-                           has a non-nil association.  Don't make new
-                           associations.  */
-                        Fsetcdr (par, Qnil);
-                    }
-                  else
-                    /* Always restore a non-nil value.  */
-                    Fset_window_parameter (window, XCAR (pers), XCDR (pers));
-                }
-            }
-
-          if (BUFFERP (p->buffer) && BUFFER_LIVE_P (XBUFFER (p->buffer)))
-            /* If saved buffer is alive, install it.  */
-            {
-              wset_buffer (w, p->buffer);
-              w->start_at_line_beg = !NILP (p->start_at_line_beg);
-              set_marker_restricted (w->start, p->start, w->contents);
-              set_marker_restricted (w->pointm, p->pointm, w->contents);
-              set_marker_restricted (w->old_pointm, p->old_pointm, w->contents);
-              /* As documented in Fcurrent_window_configuration, don't
-                 restore the location of point in the buffer which was
-                 current when the window configuration was recorded.  */
-              if (!EQ (p->buffer, new_current_buffer)
-                  && XBUFFER (p->buffer) == current_buffer)
-                Fgoto_char (w->pointm);
-            }
-          else if (BUFFERP (w->contents) && BUFFER_LIVE_P (XBUFFER (w->contents)))
-            /* Keep window's old buffer; make sure the markers are real.  */
-            {
-              /* Set window markers at start of visible range.  */
-              if (XMARKER (w->start)->buffer == 0)
-                set_marker_restricted_both (w->start, w->contents, 0, 0);
-              if (XMARKER (w->pointm)->buffer == 0)
-                set_marker_restricted_both
-                  (w->pointm, w->contents,
-                   BUF_PT (XBUFFER (w->contents)),
-                   BUF_PT_BYTE (XBUFFER (w->contents)));
-              if (XMARKER (w->old_pointm)->buffer == 0)
-                set_marker_restricted_both
-                  (w->old_pointm, w->contents,
-                   BUF_PT (XBUFFER (w->contents)),
-                   BUF_PT_BYTE (XBUFFER (w->contents)));
-              w->start_at_line_beg = 1;
-            }
-          else if (!NILP (w->start))
-            /* Leaf window has no live buffer, get one.  */
-            {
-              /* Get the buffer via other_buffer_safely in order to
-                 avoid showing an unimportant buffer and, if necessary, to
-                 recreate *scratch* in the course (part of Juanma's bs-show
-                 scenario from March 2011).  */
-              wset_buffer (w, other_buffer_safely (Fcurrent_buffer ()));
-              /* This will set the markers to beginning of visible
-                 range.  */
-              set_marker_restricted_both (w->start, w->contents, 0, 0);
-              set_marker_restricted_both (w->pointm, w->contents, 0, 0);
-              set_marker_restricted_both (w->old_pointm, w->contents, 0, 0);
-              w->start_at_line_beg = 1;
-              if (!NILP (w->dedicated))
-                /* Record this window as dead.  */
-                dead_windows = Fcons (window, dead_windows);
-              /* Make sure window is no more dedicated.  */
-              wset_dedicated (w, Qnil);
-            }
-        }
-
-      fset_root_window (f, data->root_window);
-      /* Arrange *not* to restore point in the buffer that was
-         current when the window configuration was saved.  */
-      if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer))
-        set_marker_restricted (XWINDOW (data->current_window)->pointm,
-                               make_number (old_point),
-                               XWINDOW (data->current_window)->contents);
-
-      /* In the following call to `select-window', prevent "swapping out
-         point" in the old selected window using the buffer that has
-         been restored into it.  We already swapped out that point from
-         that window's old buffer.
-
-         Do not record the buffer here.  We do that in a separate call
-         to select_window below.  See also Bug#16207.  */
-      select_window (data->current_window, Qt, 1);
-      BVAR (XBUFFER (XWINDOW (selected_window)->contents),
-            last_selected_window)
-        = selected_window;
-
-      if (NILP (data->focus_frame)
-          || (FRAMEP (data->focus_frame)
-              && FRAME_LIVE_P (XFRAME (data->focus_frame))))
-        Fredirect_frame_focus (frame, data->focus_frame);
-
-      /* Set the frame size to the value it had before this function.  */
-      if (previous_frame_text_width != FRAME_TEXT_WIDTH (f)
-          || previous_frame_text_height != FRAME_TEXT_HEIGHT (f))
-        adjust_frame_size (f, previous_frame_text_width,
-                           previous_frame_text_height, 5, 0);
-
-      if (previous_frame_menu_bar_lines != FRAME_MENU_BAR_LINES (f))
-        {
-#ifdef HAVE_WINDOW_SYSTEM
-          if (FRAME_WINDOW_P (f))
-            x_set_menu_bar_lines (f,
-                                  make_number (previous_frame_menu_bar_lines),
-                                  make_number (0));
-          else  /* TTY or MSDOS */
-#endif
-            set_menu_bar_lines (f, make_number (previous_frame_menu_bar_lines),
-                                make_number (0));
-        }
-#ifdef HAVE_WINDOW_SYSTEM
-      if (previous_frame_tool_bar_lines != FRAME_TOOL_BAR_LINES (f))
-        x_set_tool_bar_lines (f, make_number (previous_frame_tool_bar_lines),
-                              make_number (0));
-#endif
-
-      /* Now, free glyph matrices in windows that were not reused.  */
-      for (i = n = 0; i < n_leaf_windows; ++i)
-        {
-          if (NILP (leaf_windows[i]->contents))
-            free_window_matrices (leaf_windows[i]);
-          else if (EQ (leaf_windows[i]->contents, new_current_buffer))
-            ++n;
-        }
-
-      /* Make frame official again and apply frame size changes if
-         needed.  */
-      f->official = true;
-      adjust_frame_size (f, -1, -1, 1, 0);
-
-      adjust_frame_glyphs (f);
-      unblock_input ();
-
-      /* Scan dead buffer windows.  */
-      for (; CONSP (dead_windows); dead_windows = XCDR (dead_windows))
-        {
-          window = XCAR (dead_windows);
-          if (WINDOW_LIVE_P (window) && !EQ (window, FRAME_ROOT_WINDOW (f)))
-            delete_deletable_window (window);
-        }
-
-      /* Record the selected window's buffer here.  The window should
-         already be the selected one from the call above.  */
-      select_window (data->current_window, Qnil, 0);
-
-      /* Fselect_window will have made f the selected frame, so we
-         reselect the proper frame here.  Fhandle_switch_frame will change the
-         selected window too, but that doesn't make the call to
-         Fselect_window above totally superfluous; it still sets f's
-         selected window.  */
-      if (FRAME_LIVE_P (XFRAME (data->selected_frame)))
-        do_switch_frame (data->selected_frame, 0, 0, Qnil);
-
-      run_window_configuration_change_hook (f);
-    }
-
-  if (!NILP (new_current_buffer))
-    {
-      Fset_buffer (new_current_buffer);
-      /* If the new current buffer doesn't appear in the selected
-         window, go to its old point (see bug#12208).  */
-      if (!EQ (XWINDOW (data->current_window)->contents, new_current_buffer))
-        Fgoto_char (make_number (old_point));
-    }
-
-  Vminibuf_scroll_window = data->minibuf_scroll_window;
-  minibuf_selected_window = data->minibuf_selected_window;
-
-  return (FRAME_LIVE_P (f) ? Qt : Qnil);
-}
-#endif
-
 void
 restore_window_configuration (Lisp_Object configuration)
 {
@@ -7374,9 +6962,7 @@ set_window_scroll_bars (struct window *w, Lisp_Object width,
         }
     }
 
-#if (defined (HAVE_WINDOW_SYSTEM)                                       \
-     && ((defined (USE_TOOLKIT_SCROLL_BARS) && !defined (HAVE_NS))      \
-         || defined (HAVE_NTGUI)))
+#if USE_HORIZONTAL_SCROLL_BARS
   {
     int iheight = (NILP (height) ? -1 : (CHECK_NATNUM (height), XINT (height)));
 
@@ -7416,16 +7002,17 @@ DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars,
        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.
+Second parameter WIDTH specifies the pixel width for the vertical scroll
+bar.  If WIDTH is nil, use the scroll-bar width of WINDOW's frame.
 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.
+bar: left, right, or nil.  If VERTICAL-TYPE is t, this means use the
+frame's scroll-bar type.
 
-Fourth parameter HEIGHT specifies the pixel height for the scroll bar.
-Fifth parameter HORIZONTAL-TYPE specifies the type of the vertical
-scroll bar: nil, bottom, or t.  If HEIGHT is nil, use the frame's
-scroll-bar height.  If HORIZONTAL-TYPE is t, use the frame's scroll-bar
-type.
+Fourth parameter HEIGHT specifies the pixel height for the horizontal
+scroll bar.  If HEIGHT is nil, use the scroll-bar height of WINDOW's
+frame.  Fifth parameter HORIZONTAL-TYPE specifies the type of the
+horizontal scroll bar: nil, bottom, or t.  If HORIZONTAL-TYPE is t, this
+means to use the frame's horizontal scroll-bar type.
 
 Return t if scroll bars were actually changed and nil otherwise.  */)
   (Lisp_Object window, Lisp_Object width, Lisp_Object vertical_type,
@@ -7443,17 +7030,22 @@ DEFUN ("window-scroll-bars", Fwindow_scroll_bars, Swindow_scroll_bars,
        doc: /* Get width and type of scroll bars of window WINDOW.
 WINDOW must be a live window and defaults to the selected one.
 
-Value is a list of the form (WIDTH COLS VERTICAL-TYPE HEIGHT LINES
-HORIZONTAL-TYPE).  If WIDTH or HEIGHT is nil or TYPE is t, the window is
-using the frame's corresponding value.  */)
+Value is a list of the form (WIDTH COLUMNS VERTICAL-TYPE HEIGHT LINES
+HORIZONTAL-TYPE).  If WIDTH or HEIGHT is nil or VERTICAL-TYPE or
+HORIZONTAL-TYPE is t, the window is using the frame's corresponding
+value.  */)
   (Lisp_Object window)
 {
   struct window *w = decode_live_window (window);
 
-  return Fcons (make_number (WINDOW_SCROLL_BAR_AREA_WIDTH (w)),
+  return Fcons (((w->scroll_bar_width >= 0)
+                 ? make_number (w->scroll_bar_width)
+                 : Qnil),
                 list5 (make_number (WINDOW_SCROLL_BAR_COLS (w)),
                        w->vertical_scroll_bar_type,
-                       make_number (WINDOW_SCROLL_BAR_AREA_HEIGHT (w)),
+                       ((w->scroll_bar_height >= 0)
+                        ? make_number (w->scroll_bar_height)
+                        : Qnil),
                        make_number (WINDOW_SCROLL_BAR_LINES (w)),
                        w->horizontal_scroll_bar_type));
 }
diff --git a/src/window.h b/src/window.h
index 7e1c7d619b9..ea5dddc9fc8 100644
--- a/src/window.h
+++ b/src/window.h
@@ -785,11 +785,17 @@ wset_next_buffers (struct window *w, Lisp_Object val)
   (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (W)           \
    || WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (W))
 
-/* Say whether horizontal scroll bars are currently enabled for window
-   W.  Horizontal scrollbars exist for toolkit versions only.  */
 #if (defined (HAVE_WINDOW_SYSTEM)                                       \
      && ((defined (USE_TOOLKIT_SCROLL_BARS) && !defined (HAVE_NS))      \
          || defined (HAVE_NTGUI)))
+# define USE_HORIZONTAL_SCROLL_BARS true
+#else
+# define USE_HORIZONTAL_SCROLL_BARS false
+#endif
+
+/* Say whether horizontal scroll bars are currently enabled for window
+   W.  Horizontal scrollbars exist for toolkit versions only.  */
+#if USE_HORIZONTAL_SCROLL_BARS
 #define WINDOW_HAS_HORIZONTAL_SCROLL_BAR(W)                     \
   ((WINDOW_PSEUDO_P (W) || MINI_NON_ONLY_WINDOW_P (W))          \
    ? false                                                      \
diff --git a/src/xdisp.c b/src/xdisp.c
index a1e78f1129a..7c3aaa2042e 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -1144,7 +1144,7 @@ window_box_left_offset (struct window *w, enum glyph_row_area area)
    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
+static int
 window_box_right_offset (struct window *w, enum glyph_row_area area)
 {
   /* Don't return more than the window's pixel width.  */
@@ -1455,15 +1455,19 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
          glyph.  */
       int top_x = it.current_x;
       int top_y = it.current_y;
-      /* Calling line_bottom_y may change it.method, it.position, etc.  */
-      enum it_method it_method = it.method;
-      int bottom_y = (last_height = 0, line_bottom_y (&it));
       int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w);
+      int bottom_y;
+      struct it save_it;
+      void *save_it_data = NULL;
 
+      /* Calling line_bottom_y may change it.method, it.position, etc.  */
+      SAVE_IT (save_it, it, save_it_data);
+      last_height = 0;
+      bottom_y = line_bottom_y (&it);
       if (top_y < window_top_y)
         visible_p = bottom_y > window_top_y;
       else if (top_y < it.last_visible_y)
-        visible_p = true;
+        visible_p = 1;
       if (bottom_y >= it.last_visible_y
           && it.bidi_p && it.bidi_it.scan_dir == -1
           && IT_CHARPOS (it) < charpos)
@@ -1476,7 +1480,6 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
              move_it_to again with a slightly larger vertical limit,
              and see if it actually moved vertically; if it did, we
              didn't really reach CHARPOS, which is beyond window end.  */
-          struct it save_it = it;
           /* Why 10? because we don't know how many canonical lines
              will the height of the next line(s) be.  So we guess.  */
           int ten_more_lines = 10 * default_line_pixel_height (w);
@@ -1486,11 +1489,11 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
           if (it.current_y > top_y)
             visible_p = 0;
 
-          it = save_it;
         }
+      RESTORE_IT (&it, &save_it, save_it_data);
       if (visible_p)
         {
-          if (it_method == GET_FROM_DISPLAY_VECTOR)
+          if (it.method == GET_FROM_DISPLAY_VECTOR)
             {
               /* We stopped on the last glyph of a display vector.
                  Try and recompute.  Hack alert!  */
@@ -2174,7 +2177,10 @@ get_glyph_string_clip_rects (struct glyph_string *s, NativeRectangle *rects, int
 
       if (s->x > r.x)
         {
-          r.width -= s->x - r.x;
+          if (r.width >= s->x - r.x)
+            r.width -= s->x - r.x;
+          else  /* R2L hscrolled row with cursor outside text area */
+            r.width = 0;
           r.x = s->x;
         }
       r.width = min (r.width, glyph->pixel_width);
@@ -2535,7 +2541,7 @@ remember_mouse_glyph (struct frame *f, int gx, int gy, NativeRectangle *rect)
       gy = 0;
       /* The bottom divider prevails. */
       height = WINDOW_PIXEL_HEIGHT (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
-      goto add_edge;;
+      goto add_edge;
 
     case ON_BOTTOM_DIVIDER:
       gx = 0;
@@ -2623,15 +2629,14 @@ safe__call (bool inhibit_quit, ptrdiff_t nargs, Lisp_Object func, va_list ap)
     {
       ptrdiff_t i;
       ptrdiff_t count = SPECPDL_INDEX ();
-      struct gcpro gcpro1;
-      Lisp_Object *args = alloca (nargs * word_size);
+      Lisp_Object *args;
+      USE_SAFE_ALLOCA;
+      SAFE_ALLOCA_LISP (args, nargs);
 
       args[0] = func;
       for (i = 1; i < nargs; i++)
         args[i] = va_arg (ap, Lisp_Object);
 
-      GCPRO1 (args[0]);
-      gcpro1.nvars = nargs;
       specbind (Qinhibit_redisplay, Qt);
       if (inhibit_quit)
         specbind (Qinhibit_quit, Qt);
@@ -2639,7 +2644,7 @@ safe__call (bool inhibit_quit, ptrdiff_t nargs, Lisp_Object func, va_list ap)
          so there is no possibility of wanting to redisplay.  */
       val = internal_condition_case_n (Ffuncall, nargs, args, Qt,
                                        safe_eval_handler);
-      UNGCPRO;
+      SAFE_FREE ();
       val = unbind_to (count, val);
     }
 
@@ -2990,12 +2995,8 @@ init_iterator (struct it *it, struct window *w,
 
       /* If we truncate lines, leave room for the truncation glyph(s) at
          the right margin.  Otherwise, leave room for the continuation
-         glyph(s).  Done only if the window has no fringes.  Since we
-         don't know at this point whether there will be any R2L lines in
-         the window, we reserve space for truncation/continuation glyphs
-         even if only one of the fringes is absent.  */
-      if (WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0
-          || (it->bidi_p && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0))
+         glyph(s).  Done only if the window has no right fringe.  */
+      if (WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0)
         {
           if (it->line_wrap == TRUNCATE)
             it->last_visible_x -= it->truncation_pixel_width;
@@ -3060,6 +3061,19 @@ init_iterator (struct it *it, struct window *w,
          iterator.  */
       if (it->bidi_p)
         {
+          /*  Since we don't know at this point whether there will be
+              any R2L lines in the window, we reserve space for
+              truncation/continuation glyphs even if only the left
+              fringe is absent.  */
+          if (base_face_id == DEFAULT_FACE_ID
+              && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0
+              && WINDOW_RIGHT_FRINGE_WIDTH (it->w) != 0)
+            {
+              if (it->line_wrap == TRUNCATE)
+                it->last_visible_x -= it->truncation_pixel_width;
+              else
+                it->last_visible_x -= it->continuation_pixel_width;
+            }
           /* Note the paragraph direction that this buffer wants to
              use.  */
           if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
@@ -3413,6 +3427,48 @@ handle_stop (struct it *it)
   if (it->selective_display_ellipsis_p)
     it->saved_face_id = it->face_id;
 
+  /* Here's the description of the semantics of, and the logic behind,
+     the various HANDLED_* statuses:
+
+     HANDLED_NORMALLY means the handler did its job, and the loop
+     should proceed to calling the next handler in order.
+
+     HANDLED_RECOMPUTE_PROPS means the handler caused a significant
+     change in the properties and overlays at current position, so the
+     loop should be restarted, to re-invoke the handlers that were
+     already called.  This happens when fontification-functions were
+     called by handle_fontified_prop, and actually fontified
+     something.  Another case where HANDLED_RECOMPUTE_PROPS is
+     returned is when we discover overlay strings that need to be
+     displayed right away.  The loop below will continue for as long
+     as the status is HANDLED_RECOMPUTE_PROPS.
+
+     HANDLED_RETURN means return immediately to the caller, to
+     continue iteration without calling any further handlers.  This is
+     used when we need to act on some property right away, for example
+     when we need to display the ellipsis or a replacing display
+     property, such as display string or image.
+
+     HANDLED_OVERLAY_STRING_CONSUMED means an overlay string was just
+     consumed, and the handler switched to the next overlay string.
+     This signals the loop below to refrain from looking for more
+     overlays before all the overlay strings of the current overlay
+     are processed.
+
+     Some of the handlers called by the loop push the iterator state
+     onto the stack (see 'push_it'), and arrange for the iteration to
+     continue with another object, such as an image, a display string,
+     or an overlay string.  In most such cases, it->stop_charpos is
+     set to the first character of the string, so that when the
+     iteration resumes, this function will immediately be called
+     again, to examine the properties at the beginning of the string.
+
+     When a display or overlay string is exhausted, the iterator state
+     is popped (see 'pop_it'), and iteration continues with the
+     previous object.  Again, in many such cases this function is
+     called again to find the next position where properties might
+     change.  */
+
   do
     {
       handled = HANDLED_NORMALLY;
@@ -3614,6 +3670,7 @@ next_overlay_change (ptrdiff_t pos)
   ptrdiff_t i, noverlays;
   ptrdiff_t endpos;
   Lisp_Object *overlays;
+  USE_SAFE_ALLOCA;
 
   /* Get all overlays at the given position.  */
   GET_OVERLAYS_AT (pos, overlays, noverlays, &endpos, 1);
@@ -3630,6 +3687,7 @@ next_overlay_change (ptrdiff_t pos)
       endpos = min (endpos, oendpos);
     }
 
+  SAFE_FREE ();
   return endpos;
 }
 
@@ -5075,7 +5133,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
 
       if (it)
         {
-          int face_id = lookup_basic_face (it->f, DEFAULT_FACE_ID);;
+          int face_id = lookup_basic_face (it->f, DEFAULT_FACE_ID);
 
           if (CONSP (XCDR (XCDR (spec))))
             {
@@ -5690,10 +5748,11 @@ load_overlay_strings (struct it *it, ptrdiff_t charpos)
   Lisp_Object overlay, window, str, invisible;
   struct Lisp_Overlay *ov;
   ptrdiff_t start, end;
-  ptrdiff_t size = 20;
   ptrdiff_t n = 0, i, j;
   int invis_p;
-  struct overlay_entry *entries = alloca (size * sizeof *entries);
+  struct overlay_entry entriesbuf[20];
+  ptrdiff_t size = ARRAYELTS (entriesbuf);
+  struct overlay_entry *entries = entriesbuf;
   USE_SAFE_ALLOCA;
 
   if (charpos <= 0)
@@ -9694,6 +9753,7 @@ move_it_by_lines (struct it *it, ptrdiff_t dvpos)
               back_to_previous_visible_line_start (it);
               it->vpos--;
             }
+          reseat_1 (it, it->current.pos, 1);
         }
       else
         RESTORE_IT (it, it, it2data);
@@ -10147,9 +10207,9 @@ message3 (Lisp_Object m)
     {
       ptrdiff_t nbytes = SBYTES (m);
       bool multibyte = STRING_MULTIBYTE (m);
+      char *buffer;
       USE_SAFE_ALLOCA;
-      char *buffer = SAFE_ALLOCA (nbytes);
-      memcpy (buffer, SDATA (m), nbytes);
+      SAFE_ALLOCA_STRING (buffer, m);
       message_dolog (buffer, nbytes, 1, multibyte);
       SAFE_FREE ();
     }
@@ -10351,11 +10411,13 @@ vmessage (const char *m, va_list ap)
             {
               ptrdiff_t len;
               ptrdiff_t maxsize = FRAME_MESSAGE_BUF_SIZE (f);
-              char *message_buf = alloca (maxsize + 1);
+              USE_SAFE_ALLOCA;
+              char *message_buf = SAFE_ALLOCA (maxsize + 1);
 
               len = doprnt (message_buf, maxsize, m, 0, ap);
 
               message3 (make_string (message_buf, len));
+              SAFE_FREE ();
             }
           else
             message1 (0);
@@ -11987,11 +12049,11 @@ static void
 build_desired_tool_bar_string (struct frame *f)
 {
   int i, size, size_needed;
-  struct gcpro gcpro1, gcpro2, gcpro3;
-  Lisp_Object image, plist, props;
+  struct gcpro gcpro1, gcpro2;
+  Lisp_Object image, plist;
 
-  image = plist = props = Qnil;
-  GCPRO3 (image, plist, props);
+  image = plist = Qnil;
+  GCPRO2 (image, plist);
 
   /* Prepare F->desired_tool_bar_string.  If we can reuse it, do so.
      Otherwise, make a new string.  */
@@ -12010,9 +12072,12 @@ build_desired_tool_bar_string (struct frame *f)
       (f, Fmake_string (make_number (size_needed), make_number (' ')));
   else
     {
-      props = list4 (Qdisplay, Qnil, Qmenu_item, Qnil);
+      AUTO_LIST4 (props, Qdisplay, Qnil, Qmenu_item, Qnil);
+      struct gcpro gcpro1;
+      GCPRO1 (props);
       Fremove_text_properties (make_number (0), make_number (size),
                                props, f->desired_tool_bar_string);
+      UNGCPRO;
     }
 
   /* Put a `display' property on the string for the images to display,
@@ -12123,8 +12188,10 @@ build_desired_tool_bar_string (struct frame *f)
          the start of this item's properties in the tool-bar items
          vector.  */
       image = Fcons (Qimage, plist);
-      props = list4 (Qdisplay, image,
-                     Qmenu_item, make_number (i * TOOL_BAR_ITEM_NSLOTS));
+      AUTO_LIST4 (props, Qdisplay, image, Qmenu_item,
+                  make_number (i * TOOL_BAR_ITEM_NSLOTS));
+      struct gcpro gcpro1;
+      GCPRO1 (props);
 
       /* Let the last image hide all remaining spaces in the tool bar
          string.  The string can be longer than needed when we reuse a
@@ -12135,6 +12202,7 @@ build_desired_tool_bar_string (struct frame *f)
         end = i + 1;
       Fadd_text_properties (make_number (i), make_number (end),
                             props, f->desired_tool_bar_string);
+      UNGCPRO;
 #undef PROP
     }
 
@@ -13506,6 +13574,12 @@ redisplay_internal (void)
 
       if (mode_line_update_needed (w))
         w->update_mode_line = 1;
+
+      /* If reconsider_clip_changes above decided that the narrowing
+         in the current buffer changed, make sure all other windows
+         showing that buffer will be redisplayed.  */
+      if (current_buffer->clip_changed)
+        bset_update_mode_line (current_buffer);
     }
 
   /* Normally the message* functions will have already displayed and
@@ -14929,6 +15003,10 @@ run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
    If FORCE_P is non-zero, return 0 even if partial visible cursor row
    is higher than window.
 
+   If CURRENT_MATRIX_P is non-zero, use the information from the
+   window's current glyph matrix; otherwise use the desired glyph
+   matrix.
+
    A value of 0 means the caller should do scrolling
    as if point had gone off the screen.  */
 
@@ -16102,26 +16180,48 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
 
   /* If someone specified a new starting point but did not insist,
      check whether it can be used.  */
-  if (w->optional_new_start
+  if ((w->optional_new_start || window_frozen_p (w))
       && CHARPOS (startp) >= BEGV
       && CHARPOS (startp) <= ZV)
     {
+      ptrdiff_t it_charpos;
+
       w->optional_new_start = 0;
       start_display (&it, w, startp);
       move_it_to (&it, PT, 0, it.last_visible_y, -1,
                   MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
-      if (IT_CHARPOS (it) == PT)
-        w->force_start = 1;
-      /* IT may overshoot PT if text at PT is invisible.  */
-      else if (IT_CHARPOS (it) > PT && CHARPOS (startp) <= PT)
-        w->force_start = 1;
+      /* Record IT's position now, since line_bottom_y might change
+         that.  */
+      it_charpos = IT_CHARPOS (it);
+      /* Make sure we set the force_start flag only if the cursor row
+         will be fully visible.  Otherwise, the code under force_start
+         label below will try to move point back into view, which is
+         not what the code which sets optional_new_start wants.  */
+      if ((it.current_y == 0 || line_bottom_y (&it) < it.last_visible_y)
+          && !w->force_start)
+        {
+          if (it_charpos == PT)
+            w->force_start = 1;
+          /* IT may overshoot PT if text at PT is invisible.  */
+          else if (it_charpos > PT && CHARPOS (startp) <= PT)
+            w->force_start = 1;
+#ifdef GLYPH_DEBUG
+          if (w->force_start)
+            {
+              if (window_frozen_p (w))
+                debug_method_add (w, "set force_start from frozen window start");
+              else
+                debug_method_add (w, "set force_start from optional_new_start");
+            }
+#endif
+        }
     }
 
  force_start:
 
   /* Handle case where place to start displaying has been specified,
      unless the specified location is outside the accessible range.  */
-  if (w->force_start || window_frozen_p (w))
+  if (w->force_start)
     {
       /* We set this later on if we have to adjust point.  */
       int new_vpos = -1;
@@ -16166,7 +16266,7 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
           goto need_larger_matrices;
         }
 
-      if (w->cursor.vpos < 0 && !window_frozen_p (w))
+      if (w->cursor.vpos < 0)
         {
           /* If point does not appear, try to move point so it does
              appear. The desired matrix has been built above, so we
@@ -16259,6 +16359,11 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
             }
           */
         }
+      if (w->cursor.vpos < 0 || !cursor_row_fully_visible_p (w, 0, 0))
+        {
+          clear_glyph_matrix (w->desired_matrix);
+          goto try_to_scroll;
+        }
 
 #ifdef GLYPH_DEBUG
       debug_method_add (w, "forced window start");
@@ -16323,7 +16428,8 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
                || CHARPOS (startp) == BEGV
                || !window_outdated (w)))
     {
-      int d1, d2, d3, d4, d5, d6;
+      int d1, d2, d5, d6;
+      int rtop, rbot;
 
       /* If first window line is a continuation line, and window start
          is inside the modified region, but the first change is before
@@ -16348,14 +16454,20 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
           && compute_window_start_on_continuation_line (w)
           /* It doesn't make sense to force the window start like we
              do at label force_start if it is already known that point
-             will not be visible in the resulting window, because
+             will not be fully visible in the resulting window, because
              doing so will move point from its correct position
              instead of scrolling the window to bring point into view.
              See bug#9324.  */
-          && pos_visible_p (w, PT, &d1, &d2, &d3, &d4, &d5, &d6))
+          && pos_visible_p (w, PT, &d1, &d2, &rtop, &rbot, &d5, &d6)
+          /* A very tall row could need more than the window height,
+             in which case we accept that it is partially visible.  */
+          && (rtop != 0) == (rbot != 0))
         {
           w->force_start = 1;
           SET_TEXT_POS_FROM_MARKER (startp, w->start);
+#ifdef GLYPH_DEBUG
+          debug_method_add (w, "recomputed window start in continuation line");
+#endif
           goto force_start;
         }
 
@@ -18651,10 +18763,10 @@ dump_glyph_row (struct glyph_row *row, int vpos, int glyphs)
   else if (glyphs == 1)
     {
       int area;
+      char s[SHRT_MAX + 4];
 
       for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
         {
-          char *s = alloca (row->used[area] + 4);
           int i;
 
           for (i = 0; i < row->used[area]; ++i)
@@ -18807,7 +18919,7 @@ get_overlay_arrow_glyph_row (struct window *w, Lisp_Object overlay_arrow_string)
   struct buffer *buffer = XBUFFER (w->contents);
   struct buffer *old = current_buffer;
   const unsigned char *arrow_string = SDATA (overlay_arrow_string);
-  int arrow_len = SCHARS (overlay_arrow_string);
+  ptrdiff_t arrow_len = SCHARS (overlay_arrow_string);
   const unsigned char *arrow_end = arrow_string + arrow_len;
   const unsigned char *p;
   struct it it;
@@ -19328,7 +19440,18 @@ extend_face_to_end_of_line (struct it *it)
 
           for (row_width = 0, g = row_start; g < row_end; g++)
             row_width += g->pixel_width;
-          stretch_width = window_box_width (it->w, TEXT_AREA) - row_width;
+
+          /* FIXME: There are various minor display glitches in R2L
+             rows when only one of the fringes is missing.  The
+             strange condition below produces the least bad effect.  */
+          if ((WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0)
+              == (WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0)
+              || WINDOW_RIGHT_FRINGE_WIDTH (it->w) != 0)
+            stretch_width = window_box_width (it->w, TEXT_AREA);
+          else
+            stretch_width = it->last_visible_x - it->first_visible_x;
+          stretch_width -= row_width;
+
           if (stretch_width > 0)
             {
               stretch_ascent =
@@ -20469,9 +20592,17 @@ display_line (struct it *it)
                   /* When the last glyph of an R2L row only fits
                      partially on the line, we need to set row->x to a
                      negative offset, so that the leftmost glyph is
-                     the one that is partially visible.  */
-                  if (row->reversed_p && new_x > it->last_visible_x)
-                    row->x = it->last_visible_x - new_x;
+                     the one that is partially visible.  But if we are
+                     going to produce the truncation glyph, this will
+                     be taken care of in produce_special_glyphs.  */
+                  if (row->reversed_p
+                      && new_x > it->last_visible_x
+                      && !(it->line_wrap == TRUNCATE
+                           && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0))
+                    {
+                      eassert (FRAME_WINDOW_P (it->f));
+                      row->x = it->last_visible_x - new_x;
+                    }
                 }
               else
                 {
@@ -20545,7 +20676,10 @@ display_line (struct it *it)
                   that they are cropped at the right edge of the
                   window, so an image glyph will always end exactly at
                   last_visible_x, even if there's no right fringe.  */
-               && (WINDOW_RIGHT_FRINGE_WIDTH (it->w) || it->what == IT_IMAGE))
+               && ((row->reversed_p
+                    ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
+                    : WINDOW_RIGHT_FRINGE_WIDTH (it->w))
+                   || it->what == IT_IMAGE))
               ? (it->current_x >= it->last_visible_x)
               : (it->current_x > it->last_visible_x)))
         {
@@ -20622,10 +20756,15 @@ display_line (struct it *it)
           row->truncated_on_right_p = 1;
           it->continuation_lines_width = 0;
           reseat_at_next_visible_line_start (it, 0);
-          if (IT_BYTEPOS (*it) <= BEG_BYTE)
-            row->ends_at_zv_p = true;
+          /* We insist below that IT's position be at ZV because in
+             bidi-reordered lines the character at visible line start
+             might not be the character that follows the newline in
+             the logical order.  */
+          if (IT_BYTEPOS (*it) > BEG_BYTE)
+            row->ends_at_zv_p =
+              IT_BYTEPOS (*it) >= ZV_BYTE && FETCH_BYTE (ZV_BYTE - 1) != '\n';
           else
-            row->ends_at_zv_p = FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n';
+            row->ends_at_zv_p = false;
           break;
         }
     }
@@ -20828,7 +20967,8 @@ See also `bidi-paragraph-direction'.  */)
          the previous non-empty line.  */
       if (pos >= ZV && pos > BEGV)
         DEC_BOTH (pos, bytepos);
-      if (fast_looking_at (build_string ("[\f\t ]*\n"),
+      AUTO_STRING (trailing_white_space, "[\f\t ]*\n");
+      if (fast_looking_at (trailing_white_space,
                            pos, bytepos, ZV, ZV_BYTE, Qnil) > 0)
         {
           while ((c = FETCH_BYTE (bytepos)) == '\n'
@@ -20939,7 +21079,7 @@ Value is the new character position of point.  */)
                   if ((gpt->resolved_level - row->reversed_p) % 2 == 0)
                     new_pos += (row->reversed_p ? -dir : dir);
                   else
-                    new_pos -= (row->reversed_p ? -dir : dir);;
+                    new_pos -= (row->reversed_p ? -dir : dir);
                 }
               else if (BUFFERP (g->object))
                 new_pos = g->charpos;
@@ -22749,10 +22889,8 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_
         }
       else if (CHARACTERP (eoltype))
         {
-          unsigned char *tmp = alloca (MAX_MULTIBYTE_LENGTH);
           int c = XFASTINT (eoltype);
-          eol_str_len = CHAR_STRING (c, tmp);
-          eol_str = tmp;
+          return buf + CHAR_STRING (c, (unsigned char *) buf);
         }
       else
         {
@@ -22888,7 +23026,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
         }
 
     case 'e':
-#ifndef SYSTEM_MALLOC
+#if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
       {
         if (NILP (Vmemory_full))
           return "";
@@ -24668,7 +24806,7 @@ compute_overhangs_and_x (struct glyph_string *s, int x, int backward_p)
          face_id = (row)->glyphs[area][START].face_id;                     \
                                                                            \
          s = alloca (sizeof *s);                                           \
-         char2b = alloca ((END - START) * sizeof *char2b);                 \
+         SAFE_NALLOCA (char2b, 1, (END) - (START));                        \
          INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);           \
          append_glyph_string (&HEAD, &TAIL, s);                            \
          s->x = (X);                                                       \
@@ -24696,7 +24834,7 @@ compute_overhangs_and_x (struct glyph_string *s, int x, int backward_p)
     struct glyph_string *first_s = NULL;                                    \
     int n;                                                                  \
                                                                             \
-    char2b = alloca (cmp->glyph_len * sizeof *char2b);                      \
+    SAFE_NALLOCA (char2b, 1, cmp->glyph_len);                               \
                                                                             \
     /* Make glyph_strings for each glyph sequence that is drawable by       \
        the same face, and append them to HEAD/TAIL.  */                     \
@@ -24731,7 +24869,7 @@ compute_overhangs_and_x (struct glyph_string *s, int x, int backward_p)
     gstring = (composition_gstring_from_id                                \
                ((row)->glyphs[area][START].u.cmp.id));                    \
     s = alloca (sizeof *s);                                               \
-    char2b = alloca (LGSTRING_GLYPH_LEN (gstring) * sizeof *char2b);      \
+    SAFE_NALLOCA (char2b, 1, LGSTRING_GLYPH_LEN (gstring));               \
     INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);               \
     append_glyph_string (&(HEAD), &(TAIL), s);                            \
     s->x = (X);                                                           \
@@ -24883,6 +25021,7 @@ draw_glyphs (struct window *w, int x, struct glyph_row *row,
      BUILD_GLYPH_STRINGS will modify its start parameter.  That's
      the reason we use a separate variable `i'.  */
   i = start;
+  USE_SAFE_ALLOCA;
   BUILD_GLYPH_STRINGS (i, end, head, tail, hl, x, last_x);
   if (tail)
     x_reached = tail->x + tail->background_width;
@@ -25082,6 +25221,7 @@ draw_glyphs (struct window *w, int x, struct glyph_row *row,
 
   RELEASE_HDC (hdc, f);
 
+  SAFE_FREE ();
   return x_reached;
 }
 
@@ -25821,14 +25961,13 @@ produce_special_glyphs (struct it *it, enum display_element_type what)
 
   temp_it.dp = NULL;
   temp_it.what = IT_CHARACTER;
-  temp_it.len = 1;
   temp_it.c = temp_it.char_to_display = GLYPH_CHAR (glyph);
   temp_it.face_id = GLYPH_FACE (glyph);
   temp_it.len = CHAR_BYTES (temp_it.c);
 
   PRODUCE_GLYPHS (&temp_it);
   it->pixel_width = temp_it.pixel_width;
-  it->nglyphs = temp_it.pixel_width;
+  it->nglyphs = temp_it.nglyphs;
 }
 
 #ifdef HAVE_WINDOW_SYSTEM
@@ -27567,6 +27706,10 @@ display_and_set_cursor (struct window *w, bool on,
       && (!on
           || w->phys_cursor.x != x
           || w->phys_cursor.y != y
+          /* HPOS can be negative in R2L rows whose
+             exact_window_width_line_p flag is set (i.e. their newline
+             would "overflow into the fringe").  */
+          || hpos < 0
           || new_cursor_type != w->phys_cursor_type
           || ((new_cursor_type == BAR_CURSOR || new_cursor_type == HBAR_CURSOR)
               && new_cursor_width != w->phys_cursor_width)))
@@ -29341,6 +29484,8 @@ note_mouse_highlight (struct frame *f, int x, int y)
       /* Is this char mouse-active or does it have help-echo?  */
       position = make_number (pos);
 
+      USE_SAFE_ALLOCA;
+
       if (BUFFERP (object))
         {
           /* Put all the overlays we want in a vector in overlay_vec.  */
@@ -29622,6 +29767,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
       BEGV = obegv;
       ZV = ozv;
       current_buffer = obuf;
+      SAFE_FREE ();
     }
 
  set_cursor:
@@ -30141,8 +30287,6 @@ expose_frame (struct frame *f, int x, int y, int w, int h)
       r.x = r.y = 0;
       r.width = FRAME_TEXT_WIDTH (f);
       r.height = FRAME_TEXT_HEIGHT (f);
-/**       r.width = FRAME_COLUMN_WIDTH (f) * FRAME_COLS (f); **/
-/**       r.height = FRAME_LINE_HEIGHT (f) * FRAME_LINES (f); **/
     }
   else
     {
diff --git a/src/xfaces.c b/src/xfaces.c
index 047f75ffb19..6afa0a2953d 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -3112,17 +3112,26 @@ FRAME 0 means change the face on all frames, and change the default
                 f = XFRAME (selected_frame);
               else
                 f = XFRAME (frame);
-              if (! FONT_OBJECT_P (value))
-                {
-                  Lisp_Object *attrs = XVECTOR (lface)->contents;
-                  Lisp_Object font_object;
 
-                  font_object = font_load_for_lface (f, attrs, value);
-                  if (NILP (font_object))
-                    signal_error ("Font not available", value);
-                  value = font_object;
-                }
-              set_lface_from_font (f, lface, value, 1);
+              /* FIXME:
+                 If frame is t, and selected frame is a tty frame, the font
+                 can't be realized.  An improvement would be to loop over frames
+                 for a non-tty frame and use that.  See discussion in
+                 bug#18573.  */
+              if (f->terminal->type != output_termcap)
+                {
+                  if (! FONT_OBJECT_P (value))
+                    {
+                      Lisp_Object *attrs = XVECTOR (lface)->contents;
+                      Lisp_Object font_object;
+
+                      font_object = font_load_for_lface (f, attrs, value);
+                      if (NILP (font_object))
+                        signal_error ("Font not available", value);
+                      value = font_object;
+                    }
+                  set_lface_from_font (f, lface, value, 1);
+                }
             }
           else
             ASET (lface, LFACE_FONT_INDEX, value);
@@ -3398,7 +3407,8 @@ set_font_frame_param (Lisp_Object frame, Lisp_Object lface)
           ASET (lface, LFACE_FONT_INDEX, font);
         }
       f->default_face_done_p = 0;
-      Fmodify_frame_parameters (frame, list1 (Fcons (Qfont, font)));
+      AUTO_FRAME_ARG (arg, Qfont, font);
+      Fmodify_frame_parameters (frame, arg);
     }
 }
 
@@ -3787,18 +3797,23 @@ Default face attributes override any local face attributes.  */)
               && newface->font)
             {
               Lisp_Object name = newface->font->props[FONT_NAME_INDEX];
-              Fmodify_frame_parameters (frame, list1 (Fcons (Qfont, name)));
+              AUTO_FRAME_ARG (arg, Qfont, name);
+              Fmodify_frame_parameters (frame, arg);
             }
 
           if (STRINGP (gvec[LFACE_FOREGROUND_INDEX]))
-            Fmodify_frame_parameters (frame,
-                                      list1 (Fcons (Qforeground_color,
-                                                    gvec[LFACE_FOREGROUND_INDEX])));
+            {
+              AUTO_FRAME_ARG (arg, Qforeground_color,
+                              gvec[LFACE_FOREGROUND_INDEX]);
+              Fmodify_frame_parameters (frame, arg);
+            }
 
           if (STRINGP (gvec[LFACE_BACKGROUND_INDEX]))
-            Fmodify_frame_parameters (frame,
-                                      list1 (Fcons (Qbackground_color,
-                                                    gvec[LFACE_BACKGROUND_INDEX])));
+            {
+              AUTO_FRAME_ARG (arg, Qbackground_color,
+                              gvec[LFACE_BACKGROUND_INDEX]);
+              Fmodify_frame_parameters (frame, arg);
+            }
         }
     }
 
@@ -5980,6 +5995,7 @@ face_at_buffer_position (struct window *w, ptrdiff_t pos,
     endpos = XINT (end);
 
   /* Look at properties from overlays.  */
+  USE_SAFE_ALLOCA;
   {
     ptrdiff_t next_overlay;
 
@@ -6006,7 +6022,10 @@ face_at_buffer_position (struct window *w, ptrdiff_t pos,
   /* Optimize common cases where we can use the default face.  */
   if (noverlays == 0
       && NILP (prop))
-    return default_face->id;
+    {
+      SAFE_FREE ();
+      return default_face->id;
+    }
 
   /* Begin with attributes from the default face.  */
   memcpy (attrs, default_face->lface, sizeof attrs);
@@ -6034,6 +6053,8 @@ face_at_buffer_position (struct window *w, ptrdiff_t pos,
 
   *endptr = endpos;
 
+  SAFE_FREE ();
+
   /* Look up a realized face with the given face attributes,
      or realize a new one for ASCII characters.  */
   return lookup_face (f, attrs);
diff --git a/src/xfns.c b/src/xfns.c
index 0c07d6cb03d..5edb635b182 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -159,7 +159,7 @@ check_x_display_info (Lisp_Object object)
     }
   else if (TERMINALP (object))
     {
-      struct terminal *t = get_terminal (object, 1);
+      struct terminal *t = decode_live_terminal (object);
 
       if (t->type != output_x_window)
         error ("Terminal %d is not an X display", t->id);
@@ -1140,10 +1140,8 @@ x_change_tool_bar_height (struct frame *f, int height)
 
   adjust_frame_size (f, -1, -1, 4, 0);
 
-/** #if !defined USE_X_TOOLKIT **/
   if (FRAME_X_WINDOW (f))
     x_clear_under_internal_border (f);
-/** #endif **/
 
 #endif /* USE_GTK */
 }
@@ -1571,13 +1569,14 @@ x_default_scroll_bar_color_parameter (struct frame *f,
 
       /* See if an X resource for the scroll bar color has been
          specified.  */
-      tem = display_x_get_resource (dpyinfo,
-                                    build_string (foreground_p
-                                                  ? "foreground"
-                                                  : "background"),
-                                    empty_unibyte_string,
-                                    build_string ("verticalScrollBar"),
-                                    empty_unibyte_string);
+      AUTO_STRING (foreground, "foreground");
+      AUTO_STRING (background, "foreground");
+      AUTO_STRING (verticalScrollBar, "verticalScrollBar");
+      tem = (display_x_get_resource
+             (dpyinfo, foreground_p ? foreground : background,
+              empty_unibyte_string,
+              verticalScrollBar,
+              empty_unibyte_string));
       if (!STRINGP (tem))
         {
           /* If nothing has been specified, scroll bars will use a
@@ -1595,7 +1594,8 @@ x_default_scroll_bar_color_parameter (struct frame *f,
 #endif /* not USE_TOOLKIT_SCROLL_BARS */
     }
 
-  x_set_frame_parameters (f, list1 (Fcons (prop, tem)));
+  AUTO_FRAME_ARG (arg, prop, tem);
+  x_set_frame_parameters (f, arg);
   return tem;
 }
 
@@ -1786,7 +1786,7 @@ xic_create_fontsetname (const char *base_fontname, int motif)
           len = p - base_fontname + strlen (allcs) + 1;
           font_allcs = alloca (len);
           memcpy (font_allcs, base_fontname, p - base_fontname);
-          strcat (font_allcs, allcs);
+          strcpy (font_allcs + (p - base_fontname), allcs);
 
           /* Build the font spec that matches all families and
              add-styles.  */
@@ -1794,7 +1794,7 @@ xic_create_fontsetname (const char *base_fontname, int motif)
           font_allfamilies = alloca (len);
           strcpy (font_allfamilies, allfamilies);
           memcpy (font_allfamilies + strlen (allfamilies), p1, p - p1);
-          strcat (font_allfamilies, allcs);
+          strcpy (font_allfamilies + strlen (allfamilies) + (p - p1), allcs);
 
           /* Build the font spec that matches all.  */
           len = p - p2 + strlen (allcs) + strlen (all) + strlen (allfamilies) + 1;
@@ -1802,7 +1802,8 @@ xic_create_fontsetname (const char *base_fontname, int motif)
           strcpy (font_all, allfamilies);
           strcat (font_all, all);
           memcpy (font_all + strlen (all) + strlen (allfamilies), p2, p - p2);
-          strcat (font_all, allcs);
+          strcpy (font_all + strlen (all) + strlen (allfamilies) + (p - p2),
+                  allcs);
 
           /* Build the actual font set name.  */
           len = strlen (base_fontname) + strlen (font_allcs)
@@ -2846,7 +2847,8 @@ x_default_font_parameter (struct frame *f, Lisp_Object parms)
     {
       /* Remember the explicit font parameter, so we can re-apply it after
          we've applied the `default' face settings.  */
-      x_set_frame_parameters (f, list1 (Fcons (Qfont_param, font_param)));
+      AUTO_FRAME_ARG (arg, Qfont_param, font_param);
+      x_set_frame_parameters (f, arg);
     }
 
   /* This call will make X resources override any system font setting.  */
@@ -3112,15 +3114,9 @@ This function is an internal primitive--use `make-frame' instead.  */)
 #endif
                        "verticalScrollBars", "ScrollBars",
                        RES_TYPE_SYMBOL);
-  x_default_parameter (f, parms, Qhorizontal_scroll_bars,
-#if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
-                       Qt,
-#else
-                       Qnil,
-#endif
+  x_default_parameter (f, parms, Qhorizontal_scroll_bars, Qnil,
                        "horizontalScrollBars", "ScrollBars",
                        RES_TYPE_SYMBOL);
-
   /* Also do the stuff which must be set before the window exists.  */
   x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
                        "foreground", "Foreground", RES_TYPE_STRING);
@@ -4279,13 +4275,13 @@ select_visual (struct x_display_info *dpyinfo)
 {
   Display *dpy = dpyinfo->display;
   Screen *screen = dpyinfo->screen;
-  Lisp_Object value;
 
   /* See if a visual is specified.  */
-  value = display_x_get_resource (dpyinfo,
-                                  build_string ("visualClass"),
-                                  build_string ("VisualClass"),
-                                  Qnil, Qnil);
+  AUTO_STRING (visualClass, "visualClass");
+  AUTO_STRING (VisualClass, "VisualClass");
+  Lisp_Object value = display_x_get_resource (dpyinfo, visualClass,
+                                              VisualClass, Qnil, Qnil);
+
   if (STRINGP (value))
     {
       /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
@@ -4296,7 +4292,7 @@ select_visual (struct x_display_info *dpyinfo)
       int i, class = -1;
       XVisualInfo vinfo;
 
-      strcpy (s, SSDATA (value));
+      lispstpcpy (s, value);
       dash = strchr (s, '-');
       if (dash)
         {
@@ -4833,7 +4829,8 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
   f = make_frame (1);
   XSETFRAME (frame, f);
 
-  buffer = Fget_buffer_create (build_string (" *tip*"));
+  AUTO_STRING (tip, " *tip*");
+  buffer = Fget_buffer_create (tip);
   /* Use set_window_buffer instead of Fset_window_buffer (see
      discussion of bug#11984, bug#12025, bug#12026).  */
   set_window_buffer (FRAME_ROOT_WINDOW (f), buffer, 0, 0);
@@ -5043,7 +5040,10 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
 
   /* Add `tooltip' frame parameter's default value. */
   if (NILP (Fframe_parameter (frame, Qtooltip)))
-    Fmodify_frame_parameters (frame, list1 (Fcons (Qtooltip, Qt)));
+    {
+      AUTO_FRAME_ARG (arg, Qtooltip, Qt);
+      Fmodify_frame_parameters (frame, arg);
+    }
 
   /* FIXME - can this be done in a similar way to normal frames?
      http://lists.gnu.org/archive/html/emacs-devel/2007-10/msg00641.html */
@@ -5061,7 +5061,10 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
       disptype = intern ("color");
 
     if (NILP (Fframe_parameter (frame, Qdisplay_type)))
-      Fmodify_frame_parameters (frame, list1 (Fcons (Qdisplay_type, disptype)));
+      {
+        AUTO_FRAME_ARG (arg, Qdisplay_type, disptype);
+        Fmodify_frame_parameters (frame, arg);
+      }
   }
 
   /* Set up faces after all frame parameters are known.  This call
@@ -5080,7 +5083,10 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
     call2 (Qface_set_after_frame_default, frame, Qnil);
 
     if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
-      Fmodify_frame_parameters (frame, list1 (Fcons (Qbackground_color, bg)));
+      {
+        AUTO_FRAME_ARG (arg, Qbackground_color, bg);
+        Fmodify_frame_parameters (frame, arg);
+      }
   }
 
   f->no_split = 1;
diff --git a/src/xfont.c b/src/xfont.c
index 8996783541b..5e8dd370120 100644
--- a/src/xfont.c
+++ b/src/xfont.c
@@ -124,8 +124,8 @@ static void xfont_close (struct font *);
 static void xfont_prepare_face (struct frame *, struct face *);
 static int xfont_has_char (Lisp_Object, int);
 static unsigned xfont_encode_char (struct font *, int);
-static int xfont_text_extents (struct font *, unsigned *, int,
-                               struct font_metrics *);
+static void xfont_text_extents (struct font *, unsigned *, int,
+                                struct font_metrics *);
 static int xfont_draw (struct glyph_string *, int, int, int, int, bool);
 static int xfont_check (struct frame *, struct font *);
 
@@ -541,7 +541,7 @@ xfont_list (struct frame *f, Lisp_Object spec)
             if (STRINGP (XCAR (alter))
                 && ((r - name) + SBYTES (XCAR (alter))) < 256)
               {
-                strcpy (r, SSDATA (XCAR (alter)));
+                lispstpcpy (r, XCAR (alter));
                 list = xfont_list_pattern (display, name, registry, script);
                 if (! NILP (list))
                   break;
@@ -975,15 +975,14 @@ xfont_encode_char (struct font *font, int c)
   return (xfont_get_pcm (xfont, &char2b) ? code : FONT_INVALID_CODE);
 }
 
-static int
-xfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct font_metrics *metrics)
+static void
+xfont_text_extents (struct font *font, unsigned int *code,
+                    int nglyphs, struct font_metrics *metrics)
 {
   XFontStruct *xfont = ((struct xfont_info *) font)->xfont;
-  int width = 0;
-  int i, first;
+  int i, width = 0;
+  bool first;
 
-  if (metrics)
-    memset (metrics, 0, sizeof (struct font_metrics));
   for (i = 0, first = 1; i < nglyphs; i++)
     {
       XChar2b char2b;
@@ -997,34 +996,27 @@ xfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct f
         continue;
       if (first)
         {
-          if (metrics)
-            {
-              metrics->lbearing = pcm->lbearing;
-              metrics->rbearing = pcm->rbearing;
-              metrics->ascent = pcm->ascent;
-              metrics->descent = pcm->descent;
-            }
+          metrics->lbearing = pcm->lbearing;
+          metrics->rbearing = pcm->rbearing;
+          metrics->ascent = pcm->ascent;
+          metrics->descent = pcm->descent;
           first = 0;
         }
       else
         {
-          if (metrics)
-            {
-              if (metrics->lbearing > width + pcm->lbearing)
-                metrics->lbearing = width + pcm->lbearing;
-              if (metrics->rbearing < width + pcm->rbearing)
-                metrics->rbearing = width + pcm->rbearing;
-              if (metrics->ascent < pcm->ascent)
-                metrics->ascent = pcm->ascent;
-              if (metrics->descent < pcm->descent)
-                metrics->descent = pcm->descent;
-            }
+          if (metrics->lbearing > width + pcm->lbearing)
+            metrics->lbearing = width + pcm->lbearing;
+          if (metrics->rbearing < width + pcm->rbearing)
+            metrics->rbearing = width + pcm->rbearing;
+          if (metrics->ascent < pcm->ascent)
+            metrics->ascent = pcm->ascent;
+          if (metrics->descent < pcm->descent)
+            metrics->descent = pcm->descent;
         }
       width += pcm->width;
     }
-  if (metrics)
-    metrics->width = width;
-  return width;
+
+  metrics->width = width;
 }
 
 static int
diff --git a/src/xftfont.c b/src/xftfont.c
index 9726a3b9911..0a883a7b87b 100644
--- a/src/xftfont.c
+++ b/src/xftfont.c
@@ -557,8 +557,9 @@ xftfont_encode_char (struct font *font, int c)
   return (code ? code : FONT_INVALID_CODE);
 }
 
-static int
-xftfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct font_metrics *metrics)
+static void
+xftfont_text_extents (struct font *font, unsigned int *code,
+                      int nglyphs, struct font_metrics *metrics)
 {
   struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
   XGlyphInfo extents;
@@ -567,15 +568,12 @@ xftfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct
   XftGlyphExtents (xftfont_info->display, xftfont_info->xftfont, code, nglyphs,
                    &extents);
   unblock_input ();
-  if (metrics)
-    {
-      metrics->lbearing = - extents.x;
-      metrics->rbearing = - extents.x + extents.width;
-      metrics->width = extents.xOff;
-      metrics->ascent = extents.y;
-      metrics->descent = extents.height - extents.y;
-    }
-  return extents.xOff;
+
+  metrics->lbearing = - extents.x;
+  metrics->rbearing = - extents.x + extents.width;
+  metrics->width = extents.xOff;
+  metrics->ascent = extents.y;
+  metrics->descent = extents.height - extents.y;
 }
 
 static XftDraw *
diff --git a/src/xmenu.c b/src/xmenu.c
index a7d47188ef5..e3f1a17fbce 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -627,7 +627,6 @@ update_frame_menubar (struct frame *f)
   xg_update_frame_menubar (f);
 #else
   struct x_output *x;
-/**   int columns, rows; **/
 
   eassert (FRAME_X_P (f));
 
@@ -637,10 +636,6 @@ update_frame_menubar (struct frame *f)
     return;
 
   block_input ();
-  /* Save the size of the frame because the pane widget doesn't accept
-     to resize itself. So force it.  */
-/**   columns = FRAME_COLS (f); **/
-/**   rows = FRAME_LINES (f); **/
 
   /* Do the voodoo which means "I'm changing lots of things, don't try
      to refigure sizes until I'm done."  */
@@ -661,8 +656,7 @@ update_frame_menubar (struct frame *f)
   XtManageChild (x->edit_widget);
   lw_refigure_widget (x->column_widget, True);
 
-  /* Force the pane widget to resize itself with the right values.  */
-/**   EmacsFrameSetCharSize (x->edit_widget, columns, rows); **/
+  /* Force the pane widget to resize itself.  */
   adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 2, 0);
   unblock_input ();
 #endif
@@ -2023,7 +2017,8 @@ x_menu_show (struct frame *f, int x, int y, int menuflags,
   Window root;
   XMenu *menu;
   int pane, selidx, lpane, status;
-  Lisp_Object entry, pane_prefix;
+  Lisp_Object entry = Qnil;
+  Lisp_Object pane_prefix;
   char *datap;
   int ulx, uly, width, height;
   int dispwidth, dispheight;
@@ -2045,6 +2040,7 @@ x_menu_show (struct frame *f, int x, int y, int menuflags,
       return Qnil;
     }
 
+  USE_SAFE_ALLOCA;
   block_input ();
 
   /* Figure out which root window F is on.  */
@@ -2057,8 +2053,7 @@ x_menu_show (struct frame *f, int x, int y, int menuflags,
   if (menu == NULL)
     {
       *error_name = "Can't create menu";
-      unblock_input ();
-      return Qnil;
+      goto return_entry;
     }
 
   /* Don't GC while we prepare and show the menu,
@@ -2101,8 +2096,7 @@ x_menu_show (struct frame *f, int x, int y, int menuflags,
             {
               XMenuDestroy (FRAME_X_DISPLAY (f), menu);
               *error_name = "Can't create pane";
-              unblock_input ();
-              return Qnil;
+              goto return_entry;
             }
           i += MENU_ITEMS_PANE_LENGTH;
 
@@ -2146,9 +2140,7 @@ x_menu_show (struct frame *f, int x, int y, int menuflags,
 
           if (!NILP (descrip))
             {
-              /* if alloca is fast, use that to make the space,
-                 to reduce gc needs.  */
-              item_data = alloca (maxwidth + SBYTES (descrip) + 1);
+              item_data = SAFE_ALLOCA (maxwidth + SBYTES (descrip) + 1);
               memcpy (item_data, SSDATA (item_name), SBYTES (item_name));
               for (j = SCHARS (item_name); j < maxwidth; j++)
                 item_data[j] = ' ';
@@ -2166,8 +2158,7 @@ x_menu_show (struct frame *f, int x, int y, int menuflags,
             {
               XMenuDestroy (FRAME_X_DISPLAY (f), menu);
               *error_name = "Can't add selection to menu";
-              unblock_input ();
-              return Qnil;
+              goto return_entry;
             }
           i += MENU_ITEMS_ITEM_LENGTH;
           lines++;
@@ -2241,7 +2232,7 @@ x_menu_show (struct frame *f, int x, int y, int menuflags,
   status = XMenuActivate (FRAME_X_DISPLAY (f), menu, &pane, &selidx,
                           x, y, ButtonReleaseMask, &datap,
                           menu_help_callback);
-  entry = pane_prefix = Qnil;
+  pane_prefix = Qnil;
 
   switch (status)
     {
@@ -2300,10 +2291,10 @@ x_menu_show (struct frame *f, int x, int y, int menuflags,
       break;
     }
 
+ return_entry:
   unblock_input ();
-  unbind_to (specpdl_count, Qnil);
-
-  return entry;
+  SAFE_FREE ();
+  return unbind_to (specpdl_count, entry);
 }
 
 #endif /* not USE_X_TOOLKIT */
diff --git a/src/xselect.c b/src/xselect.c
index 23310b0f867..92e89822293 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -96,13 +96,6 @@ static Lisp_Object Qx_lost_selection_functions, Qx_sent_selection_functions;
    is not necessarily sizeof (long).  */
 #define X_LONG_SIZE 4
 
-/* Extreme 'short' and 'long' values suitable for libX11.  */
-#define X_SHRT_MAX 0x7fff
-#define X_SHRT_MIN (-1 - X_SHRT_MAX)
-#define X_LONG_MAX 0x7fffffff
-#define X_LONG_MIN (-1 - X_LONG_MAX)
-#define X_ULONG_MAX 0xffffffffUL
-
 /* If this is a smaller number than the max-request-size of the display,
    emacs will use INCR selection transfer when the selection is larger
    than this.  The max-request-size is usually around 64k, so if you want
@@ -1908,7 +1901,7 @@ frame_for_x_selection (Lisp_Object object)
     }
   else if (TERMINALP (object))
     {
-      struct terminal *t = get_terminal (object, 1);
+      struct terminal *t = decode_live_terminal (object);
 
       if (t->type == output_x_window)
         FOR_EACH_FRAME (tail, frame)
@@ -2159,11 +2152,9 @@ x_clipboard_manager_save (Lisp_Object frame)
 static Lisp_Object
 x_clipboard_manager_error_1 (Lisp_Object err)
 {
-  Lisp_Object args[2];
-  args[0] = build_string ("X clipboard manager error: %s\n\
+  AUTO_STRING (format, "X clipboard manager error: %s\n\
 If the problem persists, set `x-select-enable-clipboard-manager' to nil.");
-  args[1] = CAR (CDR (err));
-  Fmessage (2, args);
+  Fmessage (2, (Lisp_Object []) {format, CAR (CDR (err))});
   return Qnil;
 }
 
@@ -2230,10 +2221,8 @@ x_clipboard_manager_save_all (void)
       local_frame = XCAR (XCDR (XCDR (XCDR (local_selection))));
       if (FRAME_LIVE_P (XFRAME (local_frame)))
         {
-          Lisp_Object args[1];
-          args[0] = build_string ("Saving clipboard to X clipboard manager...");
-          Fmessage (1, args);
-
+          AUTO_STRING (saving, "Saving clipboard to X clipboard manager...");
+          Fmessage (1, &saving);
           internal_condition_case_1 (x_clipboard_manager_save, local_frame,
                                      Qt, x_clipboard_manager_error_2);
         }
@@ -2288,10 +2277,10 @@ x_check_property_data (Lisp_Object data)
 void
 x_fill_property_data (Display *dpy, Lisp_Object data, void *ret, int format)
 {
-  long val;
-  long  *d32 = (long  *) ret;
-  short *d16 = (short *) ret;
-  char  *d08 = (char  *) ret;
+  unsigned long val;
+  unsigned long  *d32 = (unsigned long  *) ret;
+  unsigned short *d16 = (unsigned short *) ret;
+  unsigned char  *d08 = (unsigned char  *) ret;
   Lisp_Object iter;
 
   for (iter = data; CONSP (iter); iter = XCDR (iter))
@@ -2299,7 +2288,22 @@ x_fill_property_data (Display *dpy, Lisp_Object data, void *ret, int format)
       Lisp_Object o = XCAR (iter);
 
       if (INTEGERP (o) || FLOATP (o) || CONSP (o))
-        val = cons_to_signed (o, LONG_MIN, LONG_MAX);
+        {
+          if (CONSP (o)
+              && RANGED_INTEGERP (X_LONG_MIN >> 16, XCAR (o), X_LONG_MAX >> 16)
+              && RANGED_INTEGERP (- (1 << 15), XCDR (o), -1))
+            {
+              /* cons_to_x_long does not handle negative values for v2.
+                 For XDnd, v2 might be y of a window, and can be negative.
+                 The XDnd spec. is not explicit about negative values,
+                 but let's assume negative v2 is sent modulo 2**16.  */
+              unsigned long v1 = XINT (XCAR (o)) & 0xffff;
+              unsigned long v2 = XINT (XCDR (o)) & 0xffff;
+              val = (v1 << 16) | v2;
+            }
+          else
+            val = cons_to_x_long (o);
+        }
       else if (STRINGP (o))
         {
           block_input ();
@@ -2311,17 +2315,15 @@ x_fill_property_data (Display *dpy, Lisp_Object data, void *ret, int format)
 
       if (format == 8)
         {
-          if (CHAR_MIN <= val && val <= CHAR_MAX)
-            *d08++ = val;
-          else
+          if ((1 << 8) < val && val <= X_ULONG_MAX - (1 << 7))
             error ("Out of 'char' range");
+          *d08++ = val;
         }
       else if (format == 16)
         {
-          if (SHRT_MIN <= val && val <= SHRT_MAX)
-            *d16++ = val;
-          else
+          if ((1 << 16) < val && val <= X_ULONG_MAX - (1 << 15))
             error ("Out of 'short' range");
+          *d16++ = val;
         }
       else
         *d32++ = val;
@@ -2627,12 +2629,14 @@ syms_of_xselect (void)
   converted_selections = NULL;
   conversion_fail_tag = None;
 
+  /* FIXME: Duplicate definition in nsselect.c.  */
   DEFVAR_LISP ("selection-converter-alist", Vselection_converter_alist,
                doc: /* An alist associating X Windows selection-types with functions.
 These functions are called to convert the selection, with three args:
 the name of the selection (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');
 a desired type to which the selection should be converted;
-and the local selection value (whatever was given to `x-own-selection').
+and the local selection value (whatever was given to
+`x-own-selection-internal').
 
 The function should return the value to send to the X server
 \(typically a string).  A return value of nil
diff --git a/src/xsmfns.c b/src/xsmfns.c
index 81b012690f9..cd4f9ce57fa 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -49,7 +49,7 @@ static struct input_event emacs_event;
 
 /* The descriptor that we use to check for data from the session manager.  */
 
-static int ice_fd;
+static int ice_fd = -1;
 
 /* A flag that says if we are in shutdown interactions or not.  */
 
@@ -415,11 +415,11 @@ x_session_initialize (struct x_display_info *dpyinfo)
   /* This malloc will not be freed, but it is only done once, and hopefully
      not very large   */
   emacs_program = xmalloc (name_len + 1);
-  emacs_program[0] = '\0';
+  char *z = emacs_program;
 
   if (! EQ (Vinvocation_directory, Qnil))
-    strcpy (emacs_program, SSDATA (Vinvocation_directory));
-  strcat (emacs_program, SSDATA (Vinvocation_name));
+    z = lispstpcpy (z, Vinvocation_directory);
+  lispstpcpy (z, Vinvocation_name);
 
   /* The SM protocol says all callbacks are mandatory, so set up all
      here and in the mask passed to SmcOpenConnection.  */
diff --git a/src/xterm.c b/src/xterm.c
index 7b8d32a4516..f32aea031f9 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -2474,7 +2474,7 @@ x_draw_stretch_glyph_string (struct glyph_string *s)
         {
           /* In R2L rows, draw the cursor on the right edge of the
              stretch glyph.  */
-          int right_x = window_box_right_offset (s->w, TEXT_AREA);
+          int right_x = window_box_right (s->w, TEXT_AREA);
 
           if (x + background_width > right_x)
             background_width -= x - right_x;
@@ -4157,7 +4157,7 @@ XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
             dpyinfo->last_mouse_glyph_frame = f1;
 
             *bar_window = Qnil;
-            *part = 0;
+            *part = scroll_bar_above_handle;
             *fp = f1;
             XSETINT (*x, win_x);
             XSETINT (*y, win_y);
@@ -4250,7 +4250,8 @@ x_window_to_menu_bar (Window window)
 
 #ifdef USE_TOOLKIT_SCROLL_BARS
 
-static void x_send_scroll_bar_event (Lisp_Object, int, int, int, bool);
+static void x_send_scroll_bar_event (Lisp_Object, enum scroll_bar_part,
+                                     int, int, bool);
 
 /* Lisp window being scrolled.  Set when starting to interact with
    a toolkit scroll bar, reset to nil when ending the interaction.  */
@@ -4371,7 +4372,8 @@ xt_horizontal_action_hook (Widget widget, XtPointer client_data, String action_n
    amount to scroll of a whole of WHOLE.  */
 
 static void
-x_send_scroll_bar_event (Lisp_Object window, int part, int portion, int whole, bool horizontal)
+x_send_scroll_bar_event (Lisp_Object window, enum scroll_bar_part part,
+                         int portion, int whole, bool horizontal)
 {
   XEvent event;
   XClientMessageEvent *ev = &event.xclient;
@@ -4504,8 +4506,8 @@ xm_scroll_callback (Widget widget, XtPointer client_data, XtPointer call_data)
 {
   struct scroll_bar *bar = client_data;
   XmScrollBarCallbackStruct *cs = call_data;
-  int part = -1, whole = 0, portion = 0;
-  int horizontal = bar->horizontal;
+  enum scroll_bar_part part = scroll_bar_nowhere;
+  int horizontal = bar->horizontal, whole = 0, portion = 0;
 
   switch (cs->reason)
     {
@@ -4549,12 +4551,9 @@ xm_scroll_callback (Widget widget, XtPointer client_data, XtPointer call_data)
 
         if (horizontal)
           {
-            whole = bar->whole;
-            portion = (((float) cs->value
-                        / (XM_SB_MAX - slider_size))
-                       * (whole
-                          - ((float) slider_size / XM_SB_MAX) * whole));
-            portion = max (0, portion);
+            portion = bar->whole * ((float)cs->value / XM_SB_MAX);
+            whole = bar->whole * ((float)(XM_SB_MAX - slider_size) / XM_SB_MAX);
+            portion = min (portion, whole);
             part = scroll_bar_horizontal_handle;
           }
         else
@@ -4572,7 +4571,7 @@ xm_scroll_callback (Widget widget, XtPointer client_data, XtPointer call_data)
       break;
     };
 
-  if (part >= 0)
+  if (part != scroll_bar_nowhere)
     {
       window_being_scrolled = bar->window;
       x_send_scroll_bar_event (bar->window, part, portion, whole, bar->horizontal);
@@ -4590,8 +4589,9 @@ xg_scroll_callback (GtkRange     *range,
                     gdouble       value,
                     gpointer      user_data)
 {
+  int whole = 0, portion = 0;
   struct scroll_bar *bar = user_data;
-  int part = -1, whole = 0, portion = 0;
+  enum scroll_bar_part part = scroll_bar_nowhere;
   GtkAdjustment *adj = GTK_ADJUSTMENT (gtk_range_get_adjustment (range));
   struct frame *f = g_object_get_data (G_OBJECT (range), XG_FRAME_DATA);
 
@@ -4644,7 +4644,7 @@ xg_scroll_callback (GtkRange     *range,
       break;
     }
 
-  if (part >= 0)
+  if (part != scroll_bar_nowhere)
     {
       window_being_scrolled = bar->window;
       x_send_scroll_bar_event (bar->window, part, portion, whole, bar->horizontal);
@@ -4687,24 +4687,51 @@ xaw_jump_callback (Widget widget, XtPointer client_data, XtPointer call_data)
   float *top_addr = call_data;
   float top = *top_addr;
   float shown;
-  int whole, portion, height;
+  int whole, portion, height, width;
   enum scroll_bar_part part;
   int horizontal = bar->horizontal;
 
-  /* Get the size of the thumb, a value between 0 and 1.  */
-  block_input ();
-  XtVaGetValues (widget, XtNshown, &shown, XtNheight, &height, NULL);
-  unblock_input ();
 
   if (horizontal)
     {
-      whole = bar->whole;
-      portion = (top * (whole - (shown * whole))) / (1 - shown);
-      portion = max (0, portion);
+      /* Get the size of the thumb, a value between 0 and 1.  */
+      block_input ();
+      XtVaGetValues (widget, XtNshown, &shown, XtNwidth, &width, NULL);
+      unblock_input ();
+
+      if (shown < 1)
+        {
+          whole = bar->whole - (shown * bar->whole);
+          portion = min (top * bar->whole, whole);
+        }
+      else
+        {
+          whole = bar->whole;
+          portion = 0;
+        }
+
       part = scroll_bar_horizontal_handle;
     }
   else
-    part = scroll_bar_handle;
+    {
+      /* Get the size of the thumb, a value between 0 and 1.  */
+      block_input ();
+      XtVaGetValues (widget, XtNshown, &shown, XtNheight, &height, NULL);
+      unblock_input ();
+
+      whole = 10000000;
+      portion = shown < 1 ? top * whole : 0;
+
+      if (shown < 1 && (eabs (top + shown - 1) < 1.0f / height))
+        /* Some derivatives of Xaw refuse to shrink the thumb when you reach
+           the bottom, so we force the scrolling whenever we see that we're
+           too close to the bottom (in x_set_toolkit_scroll_bar_thumb
+           we try to ensure that we always stay two pixels away from the
+           bottom).  */
+        part = scroll_bar_down_arrow;
+      else
+        part = scroll_bar_handle;
+    }
 
   window_being_scrolled = bar->window;
   bar->dragging = portion;
@@ -4727,28 +4754,54 @@ xaw_scroll_callback (Widget widget, XtPointer client_data, XtPointer call_data)
   struct scroll_bar *bar = client_data;
   /* The position really is stored cast to a pointer.  */
   int position = (intptr_t) call_data;
-  Dimension height;
+  Dimension height, width;
   enum scroll_bar_part part;
 
-  /* Get the height of the scroll bar.  */
-  block_input ();
-  XtVaGetValues (widget, XtNheight, &height, NULL);
-  unblock_input ();
+  if (bar->horizontal)
+    {
+      /* Get the width of the scroll bar.  */
+      block_input ();
+      XtVaGetValues (widget, XtNwidth, &width, NULL);
+      unblock_input ();
 
-  if (eabs (position) >= height)
-    part = (position < 0) ? scroll_bar_above_handle : scroll_bar_below_handle;
+      if (eabs (position) >= width)
+        part = (position < 0) ? scroll_bar_before_handle : scroll_bar_after_handle;
+
+      /* If Xaw3d was compiled with ARROW_SCROLLBAR,
+         it maps line-movement to call_data = max(5, height/20).  */
+      else if (xaw3d_arrow_scroll && eabs (position) <= max (5, width / 20))
+        part = (position < 0) ? scroll_bar_left_arrow : scroll_bar_right_arrow;
+      else
+        part = scroll_bar_move_ratio;
 
-  /* If Xaw3d was compiled with ARROW_SCROLLBAR,
-     it maps line-movement to call_data = max(5, height/20).  */
-  else if (xaw3d_arrow_scroll && eabs (position) <= max (5, height / 20))
-    part = (position < 0) ? scroll_bar_up_arrow : scroll_bar_down_arrow;
+      window_being_scrolled = bar->window;
+      bar->dragging = -1;
+      bar->last_seen_part = part;
+      x_send_scroll_bar_event (bar->window, part, position, width, bar->horizontal);
+    }
   else
-    part = scroll_bar_move_ratio;
+    {
 
-  window_being_scrolled = bar->window;
-  bar->dragging = -1;
-  bar->last_seen_part = part;
-  x_send_scroll_bar_event (bar->window, part, position, height, bar->horizontal);
+      /* Get the height of the scroll bar.  */
+      block_input ();
+      XtVaGetValues (widget, XtNheight, &height, NULL);
+      unblock_input ();
+
+      if (eabs (position) >= height)
+        part = (position < 0) ? scroll_bar_above_handle : scroll_bar_below_handle;
+
+      /* If Xaw3d was compiled with ARROW_SCROLLBAR,
+         it maps line-movement to call_data = max(5, height/20).  */
+      else if (xaw3d_arrow_scroll && eabs (position) <= max (5, height / 20))
+        part = (position < 0) ? scroll_bar_up_arrow : scroll_bar_down_arrow;
+      else
+        part = scroll_bar_move_ratio;
+
+      window_being_scrolled = bar->window;
+      bar->dragging = -1;
+      bar->last_seen_part = part;
+      x_send_scroll_bar_event (bar->window, part, position, height, bar->horizontal);
+    }
 }
 
 #endif /* not USE_GTK and not USE_MOTIF */
@@ -6134,7 +6187,7 @@ x_scroll_bar_handle_click (struct scroll_bar *bar,
       /* If the user has released the handle, set it to its final position.  */
       if (event->type == ButtonRelease && bar->dragging != -1)
         {
-          int new_start =  - bar->dragging;
+          int new_start = - bar->dragging;
           int new_end = new_start + bar->end - bar->start;
 
           x_scroll_bar_set_handle (bar, new_start, new_end, 0);
@@ -6749,7 +6802,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       break;
 
     case SelectionNotify:
-      dpyinfo->last_user_time = event->xselection.time;
+      x_display_set_last_user_time (dpyinfo, event->xselection.time);
 #ifdef USE_X_TOOLKIT
       if (! x_window_to_frame (dpyinfo, event->xselection.requestor))
         goto OTHER;
@@ -6758,7 +6811,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       break;
 
     case SelectionClear:        /* Someone has grabbed ownership.  */
-      dpyinfo->last_user_time = event->xselectionclear.time;
+      x_display_set_last_user_time (dpyinfo, event->xselectionclear.time);
 #ifdef USE_X_TOOLKIT
       if (! x_window_to_frame (dpyinfo, event->xselectionclear.window))
         goto OTHER;
@@ -6774,7 +6827,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       break;
 
     case SelectionRequest:      /* Someone wants our selection.  */
-      dpyinfo->last_user_time = event->xselectionrequest.time;
+      x_display_set_last_user_time (dpyinfo, event->xselectionrequest.time);
 #ifdef USE_X_TOOLKIT
       if (!x_window_to_frame (dpyinfo, event->xselectionrequest.owner))
         goto OTHER;
@@ -6793,23 +6846,33 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       break;
 
     case PropertyNotify:
-      dpyinfo->last_user_time = event->xproperty.time;
+      x_display_set_last_user_time (dpyinfo, event->xproperty.time);
       f = x_top_window_to_frame (dpyinfo, event->xproperty.window);
       if (f && event->xproperty.atom == dpyinfo->Xatom_net_wm_state)
-        if (x_handle_net_wm_state (f, &event->xproperty)
-            && FRAME_ICONIFIED_P (f)
-            && f->output_data.x->net_wm_state_hidden_seen)
-          {
-            /* Gnome shell does not iconify us when C-z is pressed.
-               It hides the frame.  So if our state says we aren't
-               hidden anymore, treat it as deiconified.  */
-            SET_FRAME_VISIBLE (f, 1);
-            SET_FRAME_ICONIFIED (f, 0);
-            f->output_data.x->has_been_visible = 1;
-            f->output_data.x->net_wm_state_hidden_seen = 0;
-            inev.ie.kind = DEICONIFY_EVENT;
-            XSETFRAME (inev.ie.frame_or_window, f);
-          }
+        {
+          if (x_handle_net_wm_state (f, &event->xproperty)
+              && FRAME_ICONIFIED_P (f)
+              && f->output_data.x->net_wm_state_hidden_seen)
+            {
+              /* Gnome shell does not iconify us when C-z is pressed.
+                 It hides the frame.  So if our state says we aren't
+                 hidden anymore, treat it as deiconified.  */
+              SET_FRAME_VISIBLE (f, 1);
+              SET_FRAME_ICONIFIED (f, 0);
+              f->output_data.x->has_been_visible = 1;
+              f->output_data.x->net_wm_state_hidden_seen = 0;
+              inev.ie.kind = DEICONIFY_EVENT;
+              XSETFRAME (inev.ie.frame_or_window, f);
+            }
+          else if (! FRAME_ICONIFIED_P (f)
+                   && f->output_data.x->net_wm_state_hidden_seen)
+            {
+              SET_FRAME_VISIBLE (f, 0);
+              SET_FRAME_ICONIFIED (f, 1);
+              inev.ie.kind = ICONIFY_EVENT;
+              XSETFRAME (inev.ie.frame_or_window, f);
+            }
+        }
 
       x_handle_property_notify (&event->xproperty);
       xft_settings_event (dpyinfo, event);
@@ -6981,7 +7044,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 
     case KeyPress:
 
-      dpyinfo->last_user_time = event->xkey.time;
+      x_display_set_last_user_time (dpyinfo, event->xkey.time);
       ignore_next_mouse_click_timeout = 0;
 
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
@@ -7315,7 +7378,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 #endif
 
     case KeyRelease:
-      dpyinfo->last_user_time = event->xkey.time;
+      x_display_set_last_user_time (dpyinfo, event->xkey.time);
 #ifdef HAVE_X_I18N
       /* Don't dispatch this event since XtDispatchEvent calls
          XFilterEvent, and two calls in a row may freeze the
@@ -7326,7 +7389,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 #endif
 
     case EnterNotify:
-      dpyinfo->last_user_time = event->xcrossing.time;
+      x_display_set_last_user_time (dpyinfo, event->xcrossing.time);
       x_detect_focus_change (dpyinfo, any, event, &inev.ie);
 
       f = any;
@@ -7351,7 +7414,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       goto OTHER;
 
     case LeaveNotify:
-      dpyinfo->last_user_time = event->xcrossing.time;
+      x_display_set_last_user_time (dpyinfo, event->xcrossing.time);
       x_detect_focus_change (dpyinfo, any, event, &inev.ie);
 
       f = x_top_window_to_frame (dpyinfo, event->xcrossing.window);
@@ -7385,7 +7448,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 
     case MotionNotify:
       {
-        dpyinfo->last_user_time = event->xmotion.time;
+        x_display_set_last_user_time (dpyinfo, event->xmotion.time);
         previous_help_echo_string = help_echo_string;
         help_echo_string = Qnil;
 
@@ -7497,9 +7560,6 @@ handle_one_xevent (struct x_display_info *dpyinfo,
               SET_FRAME_GARBAGED (f);
               cancel_mouse_face (f);
             }
-
-/**           FRAME_PIXEL_WIDTH (f) = event->xconfigure.width; **/
-/**           FRAME_PIXEL_HEIGHT (f) = event->xconfigure.height; **/
 #endif /* not USE_GTK */
 #endif
 
@@ -7528,7 +7588,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 
         memset (&compose_status, 0, sizeof (compose_status));
         dpyinfo->last_mouse_glyph_frame = NULL;
-        dpyinfo->last_user_time = event->xbutton.time;
+        x_display_set_last_user_time (dpyinfo, event->xbutton.time);
 
         f = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
              : x_window_to_frame (dpyinfo, event->xbutton.window));
@@ -7917,6 +7977,15 @@ x_draw_hollow_cursor (struct window *w, struct glyph_row *row)
                                             GCForeground, &xgcv);
   gc = dpyinfo->scratch_cursor_gc;
 
+  /* When on R2L character, show cursor at the right edge of the
+     glyph, unless the cursor box is as wide as the glyph or wider
+     (the latter happens when x-stretch-cursor is non-nil).  */
+  if ((cursor_glyph->resolved_level & 1) != 0
+      && cursor_glyph->pixel_width > w->phys_cursor_width)
+    {
+      x += cursor_glyph->pixel_width - w->phys_cursor_width;
+      wd -= 1;
+    }
   /* Set clipping, draw the rectangle, and reset clipping again.  */
   x_clip_to_row (w, row, TEXT_AREA, gc);
   XDrawRectangle (dpy, FRAME_X_WINDOW (f), gc, x, y, wd, h - 1);
@@ -8002,9 +8071,10 @@ x_draw_bar_cursor (struct window *w, struct glyph_row *row, int width, enum text
                           WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
                           width, row->height);
         }
-      else
+      else /* HBAR_CURSOR */
         {
           int dummy_x, dummy_y, dummy_h;
+          int x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
 
           if (width < 0)
             width = row->height;
@@ -8014,8 +8084,10 @@ x_draw_bar_cursor (struct window *w, struct glyph_row *row, int width, enum text
           get_phys_cursor_geometry (w, row, cursor_glyph, &dummy_x,
                                     &dummy_y, &dummy_h);
 
-          XFillRectangle (dpy, window, gc,
-                          WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
+          if ((cursor_glyph->resolved_level & 1) != 0
+              && cursor_glyph->pixel_width > w->phys_cursor_width)
+            x += cursor_glyph->pixel_width - w->phys_cursor_width;
+          XFillRectangle (dpy, window, gc, x,
                           WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
                                                    row->height - width),
                           w->phys_cursor_width, width);
@@ -8571,8 +8643,7 @@ x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
   FRAME_COLUMN_WIDTH (f) = font->average_width;
   FRAME_LINE_HEIGHT (f) = FONT_HEIGHT (font);
 
-#ifndef USE_X_TOOLKIT                                                   \
-/**   FRAME_TOOL_BAR_HEIGHT (f) = FRAME_TOOL_BAR_LINES (f) * FRAME_LINE_HEIGHT (f); **/
+#ifndef USE_X_TOOLKIT
   FRAME_MENU_BAR_HEIGHT (f) = FRAME_MENU_BAR_LINES (f) * FRAME_LINE_HEIGHT (f);
 #endif
 
@@ -9415,18 +9486,6 @@ x_set_window_size_1 (struct frame *f, int change_gravity, int width, int height,
 {
   int pixelwidth, pixelheight;
 
-/**   if (pixelwise) **/
-/**     { **/
-/**       pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width); **/
-/**       pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height); **/
-/**     } **/
-/**   else **/
-/**     { **/
-/**       pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width); **/
-/**       pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height); **/
-/**     } **/
-
-/**   FRAME_TOOL_BAR_HEIGHT (f) = FRAME_TOOLBAR_HEIGHT (f); **/
   pixelwidth = (pixelwise
                 ? FRAME_TEXT_TO_PIXEL_WIDTH (f, width)
                 : FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width));
@@ -9434,16 +9493,6 @@ x_set_window_size_1 (struct frame *f, int change_gravity, int width, int height,
                   ? FRAME_TEXT_TO_PIXEL_HEIGHT (f, height)
                   : FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height)));
 
-/**   pixelwidth = ((pixelwise ? width : (width * FRAME_COLUMN_WIDTH (f))) **/
-/**             + FRAME_SCROLL_BAR_AREA_WIDTH (f) **/
-/**             + FRAME_TOTAL_FRINGE_WIDTH (f) **/
-/**             + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
-
-/**   pixelheight = ((pixelwise ? height : (height * FRAME_LINE_HEIGHT (f))) **/
-/**              + FRAME_TOOLBAR_HEIGHT (f) **/
-/**              + FRAME_SCROLL_BAR_AREA_HEIGHT (f) **/
-/**              + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
-
   if (change_gravity) f->win_gravity = NorthWestGravity;
   x_wm_set_size_hint (f, 0, 0);
   XResizeWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
@@ -10617,7 +10666,6 @@ static unsigned x_display_id;
 struct x_display_info *
 x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 {
-  int connection;
   Display *dpy;
   struct terminal *terminal;
   struct x_display_info *dpyinfo;
@@ -10669,10 +10717,6 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 
         XSetLocaleModifiers ("");
 
-        /* Emacs can only handle core input events, so make sure
-           Gtk doesn't use Xinput or Xinput2 extensions.  */
-        xputenv ("GDK_CORE_DEVICE_EVENTS=1");
-
         /* Work around GLib bug that outputs a faulty warning. See
            https://bugzilla.gnome.org/show_bug.cgi?id=563627.  */
         id = g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL
@@ -10831,8 +10875,9 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   dpyinfo->x_id = ++x_display_id;
   dpyinfo->x_id_name = xmalloc (SBYTES (Vinvocation_name)
                                 + SBYTES (Vsystem_name) + 2);
-  strcat (strcat (strcpy (dpyinfo->x_id_name, SSDATA (Vinvocation_name)), "@"),
-          SSDATA (Vsystem_name));
+  char *nametail = lispstpcpy (dpyinfo->x_id_name, Vinvocation_name);
+  *nametail++ = '@';
+  lispstpcpy (nametail, Vsystem_name);
 
   /* Figure out which modifier bits mean what.  */
   x_find_modifier_meanings (dpyinfo);
@@ -10886,11 +10931,11 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
     {
       if (dpyinfo->visual->class == PseudoColor)
         {
-          Lisp_Object value;
-          value = display_x_get_resource (dpyinfo,
-                                          build_string ("privateColormap"),
-                                          build_string ("PrivateColormap"),
-                                          Qnil, Qnil);
+          AUTO_STRING (privateColormap, "privateColormap");
+          AUTO_STRING (PrivateColormap, "PrivateColormap");
+          Lisp_Object value
+            = display_x_get_resource (dpyinfo, privateColormap,
+                                      PrivateColormap, Qnil, Qnil);
           if (STRINGP (value)
               && (!strcmp (SSDATA (value), "true")
                   || !strcmp (SSDATA (value), "on")))
@@ -11014,11 +11059,11 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
     };
 
     int i;
-    const int atom_count = ARRAYELTS (atom_refs);
-    /* 1 for _XSETTINGS_SN  */
-    const int total_atom_count = 1 + atom_count;
-    Atom *atoms_return = xmalloc (total_atom_count * sizeof *atoms_return);
-    char **atom_names = xmalloc (total_atom_count * sizeof *atom_names);
+    enum { atom_count = ARRAYELTS (atom_refs) };
+    /* 1 for _XSETTINGS_SN.  */
+    enum { total_atom_count = 1 + atom_count };
+    Atom atoms_return[total_atom_count];
+    char *atom_names[total_atom_count];
     static char const xsettings_fmt[] = "_XSETTINGS_S%d";
     char xsettings_atom_name[sizeof xsettings_fmt - 2
                              + INT_STRLEN_BOUND (int)];
@@ -11026,7 +11071,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
     for (i = 0; i < atom_count; i++)
       atom_names[i] = (char *) atom_refs[i].name;
 
-    /* Build _XSETTINGS_SN atom name */
+    /* Build _XSETTINGS_SN atom name.  */
     sprintf (xsettings_atom_name, xsettings_fmt,
              XScreenNumberOfScreen (dpyinfo->screen));
     atom_names[i] = xsettings_atom_name;
@@ -11037,11 +11082,8 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
     for (i = 0; i < atom_count; i++)
       *(Atom *) ((char *) dpyinfo + atom_refs[i].offset) = atoms_return[i];
 
-    /* Manual copy of last atom */
+    /* Manually copy last atom.  */
     dpyinfo->Xatom_xsettings_sel = atoms_return[i];
-
-    xfree (atom_names);
-    xfree (atoms_return);
   }
 
   dpyinfo->x_dnd_atoms_size = 8;
@@ -11060,22 +11102,19 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 
   xsettings_initialize (dpyinfo);
 
-  connection = ConnectionNumber (dpyinfo->display);
-
   /* This is only needed for distinguishing keyboard and process input.  */
-  if (connection != 0)
-    add_keyboard_wait_descriptor (connection);
+  if (dpyinfo->connection != 0)
+    add_keyboard_wait_descriptor (dpyinfo->connection);
 
 #ifdef F_SETOWN
-  fcntl (connection, F_SETOWN, getpid ());
+  fcntl (dpyinfo->connection, F_SETOWN, getpid ());
 #endif /* ! defined (F_SETOWN) */
 
   if (interrupt_input)
-    init_sigio (connection);
+    init_sigio (dpyinfo->connection);
 
 #ifdef USE_LUCID
   {
-    XFontStruct *xfont = NULL;
     XrmValue d, fr, to;
     Font font;
 
@@ -11089,10 +11128,10 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
     x_catch_errors (dpy);
     if (!XtCallConverter (dpy, XtCvtStringToFont, &d, 1, &fr, &to, NULL))
       emacs_abort ();
-    if (x_had_errors_p (dpy) || !((xfont = XQueryFont (dpy, font))))
+    if (x_had_errors_p (dpy) || !XQueryFont (dpy, font))
       XrmPutLineResource (&xrdb, "Emacs.dialog.*.font: 9x15");
-    if (xfont)
-      XFreeFont (dpy, xfont);
+    /* Do not free XFontStruct returned by the above call to XQueryFont.
+       This leads to X protocol errors at XtCloseDisplay (Bug#18403).  */
     x_uncatch_errors ();
   }
 #endif
@@ -11100,11 +11139,10 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   /* See if we should run in synchronous mode.  This is useful
      for debugging X code.  */
   {
-    Lisp_Object value;
-    value = display_x_get_resource (dpyinfo,
-                                    build_string ("synchronous"),
-                                    build_string ("Synchronous"),
-                                    Qnil, Qnil);
+    AUTO_STRING (synchronous, "synchronous");
+    AUTO_STRING (Synchronous, "Synchronous");
+    Lisp_Object value = display_x_get_resource (dpyinfo, synchronous,
+                                                Synchronous, Qnil, Qnil);
     if (STRINGP (value)
         && (!strcmp (SSDATA (value), "true")
             || !strcmp (SSDATA (value), "on")))
@@ -11112,11 +11150,10 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   }
 
   {
-    Lisp_Object value;
-    value = display_x_get_resource (dpyinfo,
-                                    build_string ("useXIM"),
-                                    build_string ("UseXIM"),
-                                    Qnil, Qnil);
+    AUTO_STRING (useXIM, "useXIM");
+    AUTO_STRING (UseXIM, "UseXIM");
+    Lisp_Object value = display_x_get_resource (dpyinfo, useXIM, UseXIM,
+                                                Qnil, Qnil);
 #ifdef USE_XIM
     if (STRINGP (value)
         && (!strcmp (SSDATA (value), "false")
@@ -11133,8 +11170,8 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 #ifdef HAVE_X_SM
   /* Only do this for the very first display in the Emacs session.
      Ignore X session management when Emacs was first started on a
-     tty.  */
-  if (terminal->id == 1)
+     tty or started as a daemon.  */
+  if (terminal->id == 1 && ! IS_DAEMON)
     x_session_initialize (dpyinfo);
 #endif
 
@@ -11325,18 +11362,17 @@ x_delete_terminal (struct terminal *terminal)
       XCloseDisplay (dpyinfo->display);
 #endif
 #endif /* ! USE_GTK */
-    }
 
-  /* No more input on this descriptor.  */
-  if (0 <= dpyinfo->connection)
-    {
+      /* No more input on this descriptor.  Do not close it because
+         it's already closed by X(t)CloseDisplay (Bug#18403).  */
+      eassert (0 <= dpyinfo->connection);
       delete_keyboard_wait_descriptor (dpyinfo->connection);
-      emacs_close (dpyinfo->connection);
+
+      /* Mark as dead. */
+      dpyinfo->display = NULL;
+      dpyinfo->connection = -1;
     }
 
-  /* Mark as dead. */
-  dpyinfo->display = NULL;
-  dpyinfo->connection = -1;
   x_delete_display (dpyinfo);
   unblock_input ();
 }
@@ -11430,6 +11466,15 @@ x_initialize (void)
   XSetIOErrorHandler (x_io_error_quitter);
 }
 
+#ifdef USE_GTK
+void
+init_xterm (void)
+{
+  /* Emacs can handle only core input events, so make sure
+     Gtk doesn't use Xinput or Xinput2 extensions.  */
+  xputenv ("GDK_CORE_DEVICE_EVENTS=1");
+}
+#endif
 
 void
 syms_of_xterm (void)
diff --git a/src/xterm.h b/src/xterm.h
index c8673123611..ed611f1d19f 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -434,7 +434,7 @@ extern void select_visual (struct x_display_info *);
 
 struct x_output
 {
-#if defined (USE_X_TOOLKIT) || defined (USE_GTK)  
+#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
   /* Height of menu bar widget, in pixels.  This value
      is not meaningful if the menubar is turned off.  */
   int menubar_height;
@@ -654,6 +654,13 @@ struct x_output
   int move_offset_left;
 };
 
+/* Extreme 'short' and 'long' values suitable for libX11.  */
+#define X_SHRT_MAX 0x7fff
+#define X_SHRT_MIN (-1 - X_SHRT_MAX)
+#define X_LONG_MAX 0x7fffffff
+#define X_LONG_MIN (-1 - X_LONG_MAX)
+#define X_ULONG_MAX 0xffffffffUL
+
 #define No_Cursor (None)
 
 enum
@@ -1022,6 +1029,15 @@ x_display_pixel_width (struct x_display_info *dpyinfo)
   return WidthOfScreen (dpyinfo->screen);
 }
 
+INLINE void
+x_display_set_last_user_time (struct x_display_info *dpyinfo, Time t)
+{
+#ifdef ENABLE_CHECKING
+  eassert (t <= X_ULONG_MAX);
+#endif
+  dpyinfo->last_user_time = t;
+}
+
 extern void x_set_sticky (struct frame *, Lisp_Object, Lisp_Object);
 extern void x_wait_for_event (struct frame *, int);
 extern void x_clear_under_internal_border (struct frame *f);