Merge from mainline.

86 files changed, 2790 insertions, 1543 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index b973b5b8d04..a2dfa5bf613 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,706 @@
+2013-11-18  Eli Zaretskii  <eliz@gnu.org>
+
+        * insdel.c (invalidate_buffer_caches): New function, consolidated
+        from part of prepare_to_modify_buffer.
+        (insert_from_gap, prepare_to_modify_buffer):
+        * coding.c (code_convert_region, code_convert_string): Call
+        invalidate_buffer_caches.  (Bug#15841)
+
+        * lisp.h (invalidate_buffer_caches): Add prototype.
+
+2013-11-17  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32term.c (x_update_window_end): Don't invalidate the entire
+        mouse-highlight info, just signal frame_up_to_date_hook that mouse
+        highlight needs to be redisplayed.  (Bug#15913)
+
+2013-11-17  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * lisp.h (DEBUGGER_SEES_C_MACROS): Remove.
+
+2013-11-16  Eli Zaretskii  <eliz@gnu.org>
+
+        * doc.c (Fsubstitute_command_keys): Inhibit modification hooks
+        while we are using Vprin1_to_string_buffer.
+
+        * keymap.c (describe_map): Don't crash if PT is 1 both before and
+        after inserting the description string.  (Bug#15907)
+
+2013-11-15  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * data.c: Work around bogus GCC diagnostic about shift count.
+        Reported by Eli Zaretskii in
+        <http://lists.gnu.org/archive/html/emacs-devel/2013-11/msg00489.html>.
+        (pre_value): New function.
+        (count_trailing_zero_bits): Use it.
+
+2013-11-15  Eli Zaretskii  <eliz@gnu.org>
+
+        * lisp.h (DEBUGGER_SEES_C_MACROS) [GCC < v3.5]: Pessimistically
+        assume C macros are not supported even under -g3 in these old GCC
+        versions.
+
+2013-11-15  Leo Liu  <sdl.web@gmail.com>
+
+        * minibuf.c (Ftry_completion, Fall_completions)
+        (Ftest_completion): Use FUNCTIONP.  (Bug#15889)
+
+2013-11-15  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * lisp.h (DEFINE_GDB_SYMBOL_BEGIN, DEFINE_GDB_SYMBOL_END):
+        Define to empty if DEBUGGER_SEES_C_MACROS is defined.
+        This avoids placing unnecessary constants into the Emacs code.
+
+2013-11-14  Kazuhiro Ito  <kzhr@d1.dion.ne.jp>  (tiny change)
+
+        * keyboard.c (make_ctrl_char) [HAVE_NTGUI]: Now externally visible
+        for Cygwin w32 build.
+
+        * xdisp.c (erase_phys_cursor) [HAVE_NTGUI]: Now externally visible
+        for Cygwin w32 build.  (Bug#15892)
+
+2013-11-14  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Simplify, port and tune bool vector implementation.
+        * alloc.c (bool_vector_exact_payload_bytes)
+        (bool_vector_payload_bytes): Remove.
+        (bool_vector_fill): Return its argument.
+        * alloc.c (bool_vector_fill):
+        * lread.c (read1):
+        * print.c (print_object):
+        Simplify by using bool_vector_bytes.
+        * alloc.c (make_uninit_bool_vector):
+        New function, broken out from Fmake_bool_vector.
+        (Fmake_bool_vector): Use it.  Use tail call.
+        (make_uninit_bool_vector, vector_nbytes): Simplify size calculations.
+        * data.c (BITS_PER_ULL): New constant.
+        (ULLONG_MAX, count_one_bits_ll): Fall back on long counterparts
+        if long long versions don't exist.
+        (shift_right_ull): New function.
+        (count_one_bits_word): New function, replacing popcount_bits_word
+        macro.  Don't assume that bits_word is no wider than long long.
+        (count_one_bits_word, count_trailing_zero_bits):
+        Don't assume that bits_word is no wider than long long.
+        * data.c (bool_vector_binop_driver, bool_vector_not):
+        * fns.c (Fcopy_sequence):
+        * lread.c (read1):
+        Create an uninitialized destination, to avoid needless work.
+        (internal_equal): Simplify.
+        (Ffillarray): Prefer tail call.
+        * data.c (bool_vector_binop_driver): Don't assume bit vectors always
+        contain at least one word.
+        (bits_word_to_host_endian): Prefer if to #if.  Don't assume
+        chars are narrower than ints.
+        * data.c (Fbool_vector_count_matches, Fbool_vector_count_matches_at):
+        * fns.c (Fcopy_sequence):
+        Simplify and tune.
+        * lisp.h (bits_word, BITS_WORD_MAX, BITS_PER_BITS_WORD):
+        Don't try to port to hosts where bits_word values have holes; the
+        code wouldn't work there anyway.  Verify this assumption, though.
+        (bool_vector_bytes): New function.
+        (make_uninit_bool_vector): New decl.
+        (bool_vector_fill): Now returns Lisp_Object.
+
+        * xfns.c (xic_create_fontsetname):
+        * xrdb.c (gethomedir): Prefer tail calls.
+
+2013-11-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xterm.c (syms_of_xterm): staticpro Qmodifier_value, Qalt, Qhyper,
+        Qmeta, and Qsuper.  This is safer, and it's what w32fns.c does.
+
+        * buffer.c (Fforce_mode_line_update): Don't fall off end of function
+        that requires a return value.
+        (Fset_buffer_modified_p): Take advantage of this change to do
+        a tail call.
+
+2013-11-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * buffer.c (Frestore_buffer_modified_p): Sync it with
+        Fset_buffer_modified_p.
+        (Fforce_mode_line_update): New function, moved from subr.el.
+        (Fset_buffer_modified_p): Use them.
+        (syms_of_buffer): Defsubr Fforce_mode_line_update.
+
+2013-11-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * search.c (find_newline): Rewrite to prefer offsets to pointers.
+        This avoids undefined behavior when subtracting pointers into
+        different aways.  On my platform it also makes the code a tad
+        smaller and presumably faster.
+
+2013-11-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (command_loop_1): Use region-extract-function.
+        * insdel.c (Qregion_extract_function): Not static any more (can we
+        stop pretending that these vars can benefit from being marked static?).
+
+2013-11-09  Eli Zaretskii  <eliz@gnu.org>
+
+        * search.c (find_newline): If buffer text is relocated during the
+        "dumb loop", adjust C pointers into buffer text to follow suit.
+        (Bug#15841)
+
+2013-11-09  Łukasz Stelmach <stlman@poczta.fm> (tiny change)
+
+        * gtkutil.c (xg_check_special_colors): Use rgb: instead of rgbi:
+        for conversion (Bug#15837).
+
+2013-11-09  Eli Zaretskii  <eliz@gnu.org>
+
+        * fileio.c (Finsert_file_contents): Invalidate the newline cache
+        for the entire range of inserted characters.  (Bug#15841)
+
+2013-11-08  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xfaces.c (lface_fully_specified_p): Let distant-foreground be
+        unspecified.
+        (realize_default_face): Remove assignment to distant-foreground if
+        unspecified (Bug#15815).
+
+2013-11-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (message_dolog): Make sure the *Messages* buffer has its
+        cache-long-scans disabled, since we don't want to call
+        prepare_to_modify_buffer (in insert_1_both) for each message we
+        display.
+
+        * buffer.h (bset_cache_long_scans): New INLINE function, moved
+        from buffer.c.  Improve commentary to the buffer field setter
+        functions.
+
+        * buffer.c (bset_cache_long_scans): Static function deleted.
+        Improve commentary to the buffer field setter functions.
+        (init_buffer_once): Default for cache-long-scans changed to t.
+        (Bug#15797)
+
+2013-11-08  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * gmalloc.c (special_realloc, calloc, mallochook): Use tail calls.
+
+        * chartab.c (make_sub_char_table): Fix size typo (Bug#15825).
+        This bug was introduced in my 2013-06-21 change, and caused
+        struct Lisp_Sub_Char_Table objects to be given too many slots,
+        which broke 'make -C admin/unidata'.
+
+2013-11-07  Jan Djärv  <jan.h.d@swipnet.se>
+
+        Import changes from mac-port 4.5.
+        * macfont.m (mac_font_copy_default_descriptors_for_language)
+        (mac_font_copy_default_name_for_charset_and_languages): Declare.
+        (cf_charset_table): big-5-0 has uniquifier 0x4EDC.
+        (macfont_language_default_font_names): New.
+        (macfont_list): Rearrange language/charset code.
+        (macfont_close): Don't check for macfont_info->cache.
+        (mac_ctfont_create_preferred_family_for_attributes): New font
+        selection code, call
+        mac_font_copy_default_name_for_charset_and_languages.
+        (mac_font_copy_default_descriptors_for_language)
+        (mac_font_copy_default_name_for_charset_and_languages): New functions.
+
+        * macfont.h (kCTVersionNumber10_9): Define if not defined.
+
+2013-11-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Port to C11 aligned_alloc, and fix some integer overflows.
+        * alloc.c (USE_ALIGNED_ALLOC): New symbol.
+        (USE_POSIX_MEMALIGN): Remove.  All uses replaced with USE_ALIGNED_ALLOC,
+        and use of posix_memalign replaced with aligned_alloc.
+        (aligned_alloc): New function, defined or declared as needed.
+        * conf_post.h (HAVE_POSIX_MEMALIGN) [DARWIN_OS]:
+        Don't undef; configure.ac now does this.
+        * gmalloc.c (aligned_alloc) [MSDOS]: New decl.
+        (calloc, aligned_alloc): Check for integer overflow.
+        (aligned_alloc): Rename from memalign.  All uses changed.
+        (memalign): New function, an alias for aligned_alloc.
+
+2013-11-06  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (redisplay_internal): Fix typo in last change.
+
+2013-11-06  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * regex.c: Fix --enable-gcc-warning glitch with GCC 4.5.2.
+
+2013-11-06  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (syms_of_xdisp): New vars redisplay--all-windows-cause and
+        redisplay--mode-lines-cause.
+        (redisplay_internal): Keep them uptodate.  Remove redundant check of
+        buffer_shared_and_changed.
+        * *.[chm]: Number every assignment to update_mode_lines so we
+        can track why it is set.
+
+2013-11-06  Eli Zaretskii  <eliz@gnu.org>
+
+        * editfns.c (Fformat_time_string): Doc fix.  (Bug#15816)
+
+2013-11-06  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * *.[chm]: Number every assignment to windows_or_buffers_changed so we
+        can track why it is set.
+
+2013-11-06  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Integer-related fixes for term.c etc.
+        * dispextern.h (face_tty_specified_color): New function.
+        * term.c (turn_on_face): Don't rely on undefined behavior when
+        assigning an out-of-range value to 'long'.
+        Simplify test for toggling highlight.
+        (tty_capable_p): Omit last two (unused) args.  All callers changed.
+        * term.c (tty_capable_p, tty_menu_display, tty_menu_add_selection)
+        (read_menu_input, tty_menu_activate, tty_menu_show):
+        * xfaces.c (x_supports_face_attributes_p)
+        (tty_supports_face_attributes_p):
+        Use bool for boolean.  All callers changed.
+        (tty_supports_face_attributes_p): Omit defaults for color indices;
+        no longer needed.  Simplify tail call.
+
+2013-11-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (prepare_menu_bars): Mark static.
+        * lisp.h (prepare_menu_bars): Don't declare.
+        * xselect.c (x_handle_selection_clear):
+        * callproc.c (call_process): Remove redundant call to prepare_menu_bars.
+
+2013-11-05  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * keyboard.c (Fcommand_error_default_function): Fix pointer signedness
+        glitch.  Eliminate 'sz' prefix; Hungarian notation is not helpful here.
+
+2013-11-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (Fcommand_error_default_function): Rename from
+        Fdefault_error_output.
+
+2013-11-05  Jarek Czekalski  <jarekczek@poczta.onet.pl>  (tiny change)
+
+        * keyboard.c (Fdefault_error_output): New function, extracted from
+        cmd_error_internal.
+        (syms_of_keyboard): Use it for Vcommand_error_function.
+
+2013-11-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (handlerlist_sentinel): New variable (bug#15802).
+        (init_eval): Use it to ensure handlerlist is non-NULL.
+        (unwind_to_catch): Make sure we never set handlerlist to NULL.
+        (Fsignal): Adjust NULLness test of handlerlist.
+        * lisp.h (PUSH_HANDLER): Assume handlerlist is non-NULL.
+
+2013-11-05  Eli Zaretskii  <eliz@gnu.org>
+
+        * callproc.c (call_process): Call prepare_to_modify_buffer before
+        decoding text read from the sub-process, as the decoded stuff will
+        be inserted into the buffer.  This will invalidate the various
+        caches maintained for the buffer.  (Bug#15148)
+
+2013-11-05  Xue Fuqiao  <xfq.free@gmail.com>
+
+        * xdisp.c (syms_of_xdisp): Mention the active display table in doc
+        string of glyphless-char-display.
+
+2013-11-05  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfns.m (ns_get_name_from_ioreg): New function.
+        (ns_screen_name): Don't use deprecated CGDisplayIOServicePort on
+        OSX >= 10.9.  Use ns_get_name_from_ioreg.
+
+2013-11-05  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Simplify and port recent bool vector changes.
+        * alloc.c (ROUNDUP): Move here from lisp.h, since it's now used
+        only in this file.  Use a more-efficient implementation if the
+        second argument is a power of 2.
+        (ALIGN): Rewrite in terms of ROUNDUP.  Make it a function.
+        Remove no-longer-necessary compile-time checks.
+        (bool_vector_exact_payload_bytes): New function.
+        (bool_vector_payload_bytes): Remove 2nd arg; callers that need
+        exact payload changed to call the new function.  Do not assume
+        that the arg or result fits in ptrdiff_t.
+        (bool_vector_fill): New function.
+        (Fmake_bool_vector): Use it.  Don't assume bit counts fit
+        in ptrdiff_t.
+        (vroundup_ct): Don't assume arg fits in size_t.
+        * category.c (SET_CATEGORY_SET): Remove.  All callers now just
+        invoke set_category_set.
+        (set_category_set): 2nd arg is now EMACS_INT and 3rd is now bool.
+        All callers changed.  Use bool_vector_set.
+        * category.h (XCATEGORY_SET): Remove; no longer needed.
+        (CATEGORY_MEMBER): Now a function.  Rewrite in terms of
+        bool_vector_bitref.
+        * data.c (Faref): Use bool_vector_ref.
+        (Faset): Use bool_vector_set.
+        (bits_word_to_host_endian): Don't assume you can shift by CHAR_BIT.
+        (Fbool_vector_not, Fbool_vector_count_matches)
+        (Fbool_vector_count_matches_at): Don't assume CHAR_BIT == 8.
+        * fns.c (concat): Use bool_vector_ref.
+        (Ffillarray): Use bool_vector_fill.
+        (mapcar1): Use bool_vector_ref.
+        (sxhash_bool_vector): Hash words, not bytes.
+        * lisp.h (BOOL_VECTOR_BITS_PER_CHAR): Now a macro as well as
+        a constant, since it's now used in #if.
+        (bits_word, BITS_WORD_MAX, BITS_PER_BITS_WORD): Fall back on
+        unsigned char on unusual architectures, so that we no longer
+        assume that the number of bits per bits_word is a power of two or
+        is a multiple of 8 or of CHAR_BIT.
+        (Qt): Add forward decl.
+        (struct Lisp_Bool_Vector): Don't assume EMACS_INT is aligned
+        at least as strictly as bits_word.
+        (bool_vector_data, bool_vector_uchar_data): New accessors.
+        All data structure accesses changed to use them.
+        (bool_vector_words, bool_vector_bitref, bool_vector_ref)
+        (bool_vector_set): New functions.
+        (bool_vector_fill): New decl.
+        (ROUNDUP): Move to alloc.c as described above.
+
+        Fix recent gnutls changes.
+        * gnutls.c (Fgnutls_boot): Don't assume C99.
+        * process.c (wait_reading_process_output): Fix typo in recent change.
+
+2013-11-05  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * process.c (wait_reading_process_output, read_process_output)
+        (send_process): Check gnutls_state is not NULL.
+
+        * gnutls.c (emacs_gnutls_handle_error): Adjust log level for EAGAIN.
+        (Fgnutls_boot): Set process gnutls_p later, after initialization.
+
+2013-11-04  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (init, run, stop:): New methods in EmacsApp for
+        OSX >= 10.9 to prevent memory leak of GCD dispatch source.
+
+        * nsterm.h (EmacsApp): Add shouldKeepRunning and isFirst for
+        OSX >= 10.9.
+
+        * nsfns.m (Fx_create_frame): Fix memory leak.
+
+        * macfont.m (CG_SET_FILL_COLOR_WITH_GC_FOREGROUND)
+        (CG_SET_FILL_COLOR_WITH_GC_BACKGROUND)
+        (CG_SET_STROKE_COLOR_WITH_GC_FOREGROUND): Fix memory leak.
+
+2013-11-04  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (message3_nolog, message_with_string): Encode the string
+        before writing it to the terminal in a non-interactive session.
+
+        * lread.c (openp): If both FILENAME and SUFFIX are unibyte, make
+        sure we concatenate them into a unibyte string.
+
+        * fileio.c (make_temp_name): Encode PREFIX, and decode the
+        resulting temporary name before returning it to the caller.
+        (Fexpand_file_name): If NAME is pure-ASCII and DEFAULT_DIRECTORY
+        is a unibyte string, convert NAME to a unibyte string to ensure
+        that the result is also a unibyte string.
+
+        * emacs.c (init_cmdargs): Use build_unibyte_string to make sure we
+        create unibyte strings from default paths and directory/file
+        names.
+
+        * coding.h (ENCODE_FILE): Do not attempt to encode a unibyte
+        string.
+
+        * callproc.c (init_callproc): Use build_unibyte_string to make
+        sure we create unibyte strings from default paths and
+        directory/file names.
+
+        * buffer.c (init_buffer): Don't store default-directory of
+        *scratch* in multibyte form.  The original problem which led to
+        that is described in
+        http://lists.gnu.org/archive/html/emacs-pretest-bug/2004-11/msg00532.html,
+        but it was solved long ago.  (Bug#15260)
+
+2013-11-04  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Port to stricter C99 platforms.
+        Especially, C99 prohibits nesting a struct X inside struct Y if
+        struct X has a flexible array member.
+        * alloc.c (struct sdata): New type.
+        (sdata): Implement in terms of struct sdata.
+        Remove u member; all uses replaced by next_vector, set_next_vector.
+        (SDATA_SELECTOR, SDATA_DATA, SDATA_DATA_OFFSET): Adjust to sdata change.
+        (SDATA_DATA_OFFSET): Now a constant, not a macro.
+        (struct sblock): Rename first_data member to data, which is now
+        a flexible array member.  All uses changed.
+        (next_vector, set_next_vector, large_vector_vec): New functions.
+        (vector_alignment): New constant.
+        (roundup_size): Make it a multiple of ALIGNOF_STRUCT_LISP_VECTOR, too.
+        (struct large-vector): Now merely a NEXT member, since the old approach
+        ran afoul of stricter C99.  All uses changed to use
+        large_vector_vec or large_vector_offset.
+        (large_vector_offset): New constant.
+        * dispnew.c: Include tparam.h, for tgetent.
+        Do not include term.h; no longer needed.
+        * gnutls.c (Fgnutls_boot): Don't continue after calling a _Noreturn.
+        * lisp.h (ENUM_BF) [__SUNPRO_C && __STDC__]: Use unsigned int.
+        (struct Lisp_Vector): Use a flexible array member for contents,
+        instead of a union with a member that is an array of size 1.
+        All uses changed.
+        (ALIGNOF_STRUCT_LISP_VECTOR): New constant, to make up for the
+        fact that the struct no longer contains a union.
+        (struct Lisp_Misc_Any, struct Lisp_Marker, struct Lisp_Overlay)
+        (struct Lisp_Save_Value, struct Lisp_Free):
+        Use unsigned, not int, for spacers, to avoid c99 warning.
+        (union specbinding): Use unsigned, not bool, for bitfield, as
+        bool is not portable to pre-C99 hosts.
+
+2013-11-04  Glenn Morris  <rgm@gnu.org>
+
+        * emacs.c (usage_message): Mention that `-L :...' appends.
+
+2013-11-02  Glenn Morris  <rgm@gnu.org>
+
+        * Makefile.in (abs_builddir): Remove.
+        (bootstrap_exe): Use relative filename.
+
+        Use relative filenames in TAGS files.
+        * Makefile.in (abs_srcdir): Remove it again.
+        (.PHONY): Remove frc.
+        (maintainer-clean): No more TAGS-LISP file.
+        (TAGS): Pass relative file names to etags.
+        (../lisp/TAGS): Rename from TAGS-LISP.  Work in ../lisp.
+
+        * Makefile.in (abs_srcdir): New, set by configure.
+        (lispdir): Remove.
+        (maintainer-clean): Remove pointless echo.  That should be in the
+        top-level Makefile, if anywhere.  Delete TAGS-LISP.
+        (extraclean): No s/ and m/ directories for some time.
+        (TAGS): Also depend on ctagsfiles3.
+        Remove no-longer-defined S_FILE.
+        Pass absolute filenames to etags once more.
+        (TAGS-LISP): Replace lispdir with its expansion.
+        (TAGS-LISP, $(lwlibdir)/TAGS): Correctly pass ETAGS to sub-makes.
+        ($(lwlibdir)/TAGS): Remove useless subshell, check cd return value.
+
+2013-11-02  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xfaces.c (check_lface_attrs, realize_default_face):
+        Add LFACE_DISTANT_FOREGROUND_INDEX (Bug#15788).
+        (realize_default_face): Set DISTANT_FOREGROUND to unspecified_fg.
+
+2013-11-02  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * emacs.c (original_pwd): Remove global var by making it local.
+        (init_cmdargs): New arg ORIGINAL_PWD; caller changed.
+
+2013-11-01  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xfaces.c: Declare color_distance.
+        (QCdistant_foreground): New variable.
+        (NEAR_SAME_COLOR_THRESHOLD): New define.
+        (load_color2): New function.
+        (load_color): Call load_color2.
+        (load_face_colors): Call load_color2 and if distant-color is specified
+        calculate distant and use distant-color if colors are near.
+        (LFACE_DISTANT_FOREGROUND): New define.
+        (merge_face_ref, Finternal_set_lisp_face_attribute)
+        (Finternal_get_lisp_face_attribute)
+        (x_supports_face_attributes_p): Handle distant-foreground similar to
+        foreground.
+        (syms_of_xfaces): DEFSYM QCdistant_foreground.
+
+        * dispextern.h (lface_attribute_index):
+        Add LFACE_DISTANT_FOREGROUND_INDEX.
+
+2013-11-01  Claudio Bley  <claudio.bley@googlemail.com>
+
+        * image.c (pbm_next_char): New function.
+        See http://netpbm.sourceforge.net/doc/pbm.html for the details.
+        (pbm_scan_number): Use it.
+        (Qlibjpeg_version): New variable.
+        (syms_of_image): DEFSYM and initialize it.
+
+2013-10-31  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * emacs.c (main): Skip -psn args on OSX even if ! isatty (0).
+
+2013-10-31  Glenn Morris  <rgm@gnu.org>
+
+        * emacs.c (original_pwd): New char.
+        (main): If using --chdir, store original_pwd.
+        (init_cmdargs): When setting Vinvocation_directory based on a
+        relative argv[0], use original_pwd if set.  (Bug#15768)
+
+2013-10-29  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (command_loop_1): If command is nil, call `undefined'.
+
+2013-10-29  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * insdel.c: Fix minor problems found by static checking.
+        (Qregion_extract_function): Now static.
+        (prepare_to_modify_buffer_1): Remove unused locals.
+
+2013-10-29  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (prepare_menu_bars): Call Vpre_redisplay_function.
+        (syms_of_xdisp): Declare pre-redisplay-function.
+        (markpos_of_region): Remove function.
+        (init_iterator, compute_stop_pos, handle_face_prop)
+        (face_before_or_after_it_pos, reseat_to_string)
+        (get_next_display_element, window_buffer_changed)
+        (redisplay_internal, try_cursor_movement, redisplay_window)
+        (try_window_reusing_current_matrix, try_window_id, display_line)
+        (note_mode_line_or_margin_highlight, note_mouse_highlight)
+        (display_string, mouse_face_from_buffer_pos): Remove region handling.
+        * window.h (struct window): Remove field `region_showing'.
+        * dispextern.h (struct it): Remove region_beg/end_charpos.
+        (face_at_buffer_position, face_for_overlay_string)
+        (face_at_string_position): Update prototypes.
+        * xfaces.c (face_at_buffer_position, face_for_overlay_string)
+        (face_at_string_position): Remove `region_beg' and `region_end' args.
+        * fontset.c (Finternal_char_font):
+        * font.c (font_at, font_range): Adjust calls accordingly.
+        * insdel.c (Qregion_extract_function): New var.
+        (syms_of_insdel): Initialize it.
+        (prepare_to_modify_buffer_1): Use it.
+
+2013-10-29  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Prefer 'unsigned long' to 'long unsigned int' and 'unsigned long int'.
+        * ftxfont.c (ftxfont_get_gcs):
+        * gtkutil.c (xg_set_widget_bg, xg_set_background_color):
+        * xfaces.c (x_free_colors, x_free_dpy_colors)
+        (x_create_gc, unload_color):
+        * xselect.c (x_property_data_to_lisp):
+        * xsettings.c (parse_settings):
+        * xterm.c (x_copy_color, x_alloc_lighter_color, x_setup_relief_color)
+        (get_bits_and_offset): Adjust definition.
+        * frame.c (XParseGeometry): Adjust locals.
+        * lisp.h (toplevel): Adjust EMACS_UINT type definition.
+        * regex.h (toplevel): Likewise for reg_syntax_t.
+
+2013-10-29  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (run_hook_with_args): Use FUNCTIONP.
+
+2013-10-29  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xterm.h (struct x_output): For 'black_relief' and 'white_relief'
+        fields, drop 'allocated_p' member and use -1 for uninitialized value.
+        * w32term.h (struct w32_output): Similarly but do not use -1 because...
+        * xfaces.c (unload_color) [HAVE_X_WINDOWS]: ...this function is a no-op
+        on MS-Windows anyway.
+        (free_face_colors): Define only if HAVE_X_WINDOWS and...
+        (free_realized_face): ...adjust user.
+        * xfns.c (Fx_create_frame, x_create_tip_frame): Initialize black and
+        white relief pixels to -1.
+        * xterm.c (x_setup_relief_color, x_free_frame_resources): Adjust users.
+        * w32term.c (w32_setup_relief_color, x_free_frame_resources): Likewise.
+        * dispextern.h (unload_color): Move prototype under HAVE_X_WINDOWS.
+
+2013-10-28  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * dispextern.h, image.c (x_bitmap_height, x_bitmap_width): Now static.
+        * xfaces.c (load_pixmap): Omit last two args, which are always NULL
+        in practice now.  All callers changed.
+
+2013-10-28  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * dispextern.h (struct face): Use bitfields for 'underline_type'
+        and 'box' members.  Remove set-but-unused members 'pixmap_w' and
+        'pixmap_h'.  If not HAVE_WINDOW_SYSTEM, also remove dummy
+        'stipple' member.  Move 'lface' member up to help...
+        * xfaces.c (make_realized_face): ...this function to find and
+        clear just the members that need clearing.
+        (load_face_colors, realize_x_face):
+        * xdisp.c (extend_face_to_end_of_line): Adjust user.
+
+2013-10-27  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xftfont.c (struct xftfont_info): Remove set-but-unused
+        'screen' member.
+        (xftfont_open): Adjust user.
+        (xftfont_get_colors): Remove useless prototype.
+
+2013-10-26  Eli Zaretskii  <eliz@gnu.org>
+
+        * emacs.c (Fdump_emacs): Encode FILENAME and SYMFILE arguments
+        before passing them to 'unexec'.  (Bug#15260)
+
+2013-10-26  Xue Fuqiao  <xfq.free@gmail.com>
+
+        * fringe.c (set_fringe_bitmap_face): Add usage note from lispref.
+
+2013-10-25  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32uniscribe.c (uniscribe_close): Adjust the argument list to
+        the changed signature of the font driver's 'close' method.
+
+        * w32font.h (w32font_close): Adjust the prototype to the change in
+        function definition.
+
+        * w32font.c (w32font_close): Reintroduce deleted declaration of i.
+
+        * w32uniscribe.c (uniscribe_close): Adapt the call to
+        w32font_close to its new prototype.
+
+2013-10-25  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Omit unused frame argument of font API's close function.
+        * font.h (struct font): Drop frame argument.  Adjust comment.
+        * font.c (font_clear_cache, font_close_object): Adjust users.
+        * ftfont.c (ftfont_close):
+        * ftxfont.c (ftxfont_close):
+        * macfont.m (macfont_close):
+        * nsfont.m (nsfont_close):
+        * w32font.c (w32font_close):
+        * xfont.c (xfont_close):
+        * xftfont.c (xftfont_close): Adjust driver-specific close functions,
+        tweak comments and make functions safe if called more than once for
+        the same font object.
+
+        Perform font-specific cleanup when font object is swept by GC.  See
+        http://lists.gnu.org/archive/html/emacs-devel/2013-10/msg00740.html.
+        * alloc.c (cleanup_vector): New function.
+        (sweep_vector): Call it for each reclaimed vector object.
+        * font.h (struct font): Adjust comment.
+
+2013-10-24  Glenn Morris  <rgm@gnu.org>
+
+        * Makefile.in (abs_top_srcdir): New, set by configure.
+
+2013-10-23  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Adjust recent font-related changes to fix bug#15686.
+        * alloc.c (mark_object) [HAVE_WINDOW_SYSTEM]: If marked frame
+        is a live window system frame, mark its default font too.
+
+2013-10-23  Glenn Morris  <rgm@gnu.org>
+
+        * Makefile.in (RUN_TEMACS): Make relative (again).
+        ($(leimdir)/leim-list.el, .el.elc, $(lispsource)/loaddefs.el)
+        (bootstrap-emacs$(EXEEXT)):
+        Quote entities that might contain whitespace.
+
+2013-10-23  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Port to Solaris 10 and its bundled GCC.
+        Problem reported by Timothy C. Burt.
+        * floatfns.c (isfinite, isnan): Redefine unconditionally.
+
+2013-10-21  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Do not allow font caches to grow too large.
+        * alloc.c (compact_font_cache_entry, compact_font_caches):
+        New functions or stub if not HAVE_WINDOW_SYSTEM.
+        (compact_undo_list): Factor out from Fgarbage_collect.
+        Add comment.
+        (mark_face_cache): Mark face font.  Move down to avoid
+        extra prototypes.
+        (mark_terminals): Do not mark font cache here.
+        (Fgarbage_collect): Call compaction functions described
+        above.  Adjust comment.
+
+2013-10-20  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * emacs.c (main): On Cocoa, if GUI session and 0 is not a tty,
+        chdir to HOME (bug#15607).
+
+        * nsterm.m (Qcocoa, Qgnustep): New variables.
+        (syms_of_nsterm): Defsym Qcocoa, Qgnustep.  Fprovide appropriate one.
+        (ns_get_color): Make selection color work for GNUStep also.
+
 2013-10-18  Eli Zaretskii  <eliz@gnu.org>
 
         * keyboard.c (make_lispy_event): Remove GPM-specific code that
@@ -100,8 +803,8 @@
         (get_adapters_info): New wrapper function.
         (globals_of_w32): Initialize g_b_init_get_adapters_info.
 
-        * process.h (network_interface_list, network_interface_info): New
-        prototypes.
+        * process.h (network_interface_list, network_interface_info):
+        New prototypes.
 
         * process.c (conv_sockaddr_to_lisp): Now externally-visible.
         (Fnetwork_interface_list, Fnetwork_interface_info): Define for
@@ -432,8 +1135,8 @@
         (xw_popup_dialog): New function, with X-specific bits of popup
         dialogs.
 
-        * xdisp.c (deep_copy_glyph_row, display_tty_menu_item): New
-        functions.
+        * xdisp.c (deep_copy_glyph_row, display_tty_menu_item):
+        New functions.
 
         * window.c (Fset_window_configuration): Use run-time tests of the
         frame type instead of compile-time conditionals, when menu-bar
@@ -498,11 +1201,11 @@
         of, or in addition to, compile-time conditionals.
         (menu_item_width, Fmenu_bar_menu_at_x_y): New functions.
         (Fx_popup_menu): Detect when the function is called from keyboard
-        on a TTY.  Don't barf when invoked on a text-mode frame.  Check
-        frame type at run time, instead of compile-time conditionals for
-        invoking terminal-specific menu-show functions.  Call
-        tty_menu_show on text-mode frames.
-        (Fx_popup_dialog): Moved here from xmenu.c.  Test frame types at
+        on a TTY.  Don't barf when invoked on a text-mode frame.
+        Check frame type at run time, instead of compile-time conditionals for
+        invoking terminal-specific menu-show functions.
+        Call tty_menu_show on text-mode frames.
+        (Fx_popup_dialog): Move here from xmenu.c.  Test frame types at
         run time to determine which alternative to invoke; support dialogs
         on TTYs.
 
@@ -5384,7 +6087,7 @@
 
         * keyboard.c (read_decoded_char): Don't decode under w32 (bug#14403).
 
-2013-05-22  Barry OReilly  <gundaetiapo@gmail.com>  (tiny change)
+2013-05-22  Barry O'Reilly  <gundaetiapo@gmail.com>
 
         * casetab.c (init_casetab_once): Fix last change (bug#14424).
 
@@ -5409,7 +6112,7 @@
         character numbers counted by detect_coding_utf_8.  Fix detection
         of BOM for utf-8.
 
-2013-05-21  Barry OReilly  <gundaetiapo@gmail.com>  (tiny change)
+2013-05-21  Barry O'Reilly  <gundaetiapo@gmail.com>
 
         * search.c (looking_at_1): Only set last_thing_searched if the match
         changed the match-data (bug#14281).
diff --git a/src/ChangeLog.12 b/src/ChangeLog.12
index 053baa3d487..b14ce20ede3 100644
--- a/src/ChangeLog.12
+++ b/src/ChangeLog.12
@@ -6862,7 +6862,7 @@
         is undefined.  See Stefan Monnier in
         <http://lists.gnu.org/archive/html/emacs-devel/2012-08/msg00762.html>.
 
-2012-08-26  Barry OReilly  <gundaetiapo@gmail.com>  (tiny change)
+2012-08-26  Barry O'Reilly  <gundaetiapo@gmail.com>
 
         * lisp.h (functionp): New function (extracted from Ffunctionp).
         (FUNCTIONP): Use it.
@@ -7567,7 +7567,7 @@
         * editfns.c (Fformat): Doc fix (Bug#12059).
         (Fsave_current_buffer): Doc fix (Bug#11542).
 
-2012-08-14  Barry OReilly  <gundaetiapo@gmail.com>  (tiny change)
+2012-08-14  Barry O'Reilly  <gundaetiapo@gmail.com>
 
         * keyboard.c (access_keymap_keyremap): Accept anonymous functions
         (bug#12022).
diff --git a/src/Makefile.in b/src/Makefile.in
index 254aa175d49..ca0b25a2f69 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -1,7 +1,7 @@
 ### @configure_input@
 
-# Copyright (C) 1985, 1987-1988, 1993-1995, 1999-2013 Free Software
-# Foundation, Inc.
+# Copyright (C) 1985, 1987-1988, 1993-1995, 1999-2013
+#   Free Software Foundation, Inc.
 
 # This file is part of GNU Emacs.
 
@@ -28,8 +28,9 @@ SHELL = @SHELL@
 # Here are the things that we expect ../configure to edit.
 # We use $(srcdir) explicitly in dependencies so as not to depend on VPATH.
 srcdir = @srcdir@
+# MinGW CPPFLAGS may use this.
+abs_top_srcdir=@abs_top_srcdir@
 ntsource = $(srcdir)/../nt
-abs_builddir = @abs_builddir@
 VPATH = $(srcdir)
 CC = @CC@
 WINDRES = @WINDRES@
@@ -54,12 +55,11 @@ etc = ../etc
 leimdir = ../leim
 oldXMenudir = ../oldXMenu
 lwlibdir = ../lwlib
-lispdir = ../lisp
 
 # Configuration files for .o files to depend on.
 config_h = config.h $(srcdir)/conf_post.h
 
-bootstrap_exe = $(abs_builddir)/bootstrap-emacs$(EXEEXT)
+bootstrap_exe = ../src/bootstrap-emacs$(EXEEXT)
 
 ## ns-app if HAVE_NS, else empty.
 OTHER_FILES = @OTHER_FILES@
@@ -313,7 +313,7 @@ INTERVALS_H = dispextern.h intervals.h composite.h
 
 GETLOADAVG_LIBS = @GETLOADAVG_LIBS@
 
-RUN_TEMACS = `/bin/pwd`/temacs
+RUN_TEMACS = ./temacs
 
 ## Invoke ../nt/addsection for MinGW, ":" elsewhere.
 TEMACS_POST_LINK = @TEMACS_POST_LINK@
@@ -437,7 +437,7 @@ all: emacs$(EXEEXT) $(OTHER_FILES)
 .PHONY: all
 
 $(leimdir)/leim-list.el: bootstrap-emacs$(EXEEXT)
-        cd $(leimdir) && $(MAKE) $(MFLAGS) leim-list.el EMACS=$(bootstrap_exe)
+        cd $(leimdir) && $(MAKE) $(MFLAGS) leim-list.el EMACS="$(bootstrap_exe)"
 
 ## The dumped Emacs is as functional and more efficient than
 ## bootstrap-emacs, so we replace the latter with the former.
@@ -555,7 +555,7 @@ ns-app: emacs$(EXEEXT)
         cd ../nextstep && $(MAKE) $(MFLAGS) all
 
 .PHONY: mostlyclean clean bootstrap-clean distclean maintainer-clean
-.PHONY: versionclean extraclean frc
+.PHONY: versionclean extraclean
 
 mostlyclean:
         rm -f temacs$(EXEEXT) core *.core \#* *.o libXMenu11.a liblw.a
@@ -578,40 +578,45 @@ bootstrap-clean: clean
           if test -f "$(srcdir)/.gdbinit"; then rm -f ./.gdbinit.save; \
           else mv ./.gdbinit.save ./.gdbinit; fi; \
         fi
-## This is used in making a distribution.
-## Do not use it on development directories!
+
 distclean: bootstrap-clean
         rm -f Makefile
+
 maintainer-clean: distclean
-        @echo "This command is intended for maintainers to use;"
-        @echo "it deletes files that may require special tools to rebuild."
         rm -f TAGS
 versionclean:
         -rm -f emacs$(EXEEXT) emacs-*.*.*$(EXEEXT) ../etc/DOC*
 extraclean: distclean
-        -rm -f *~ \#* m/?*~ s/?*~
+        -rm -f *~ \#*
+
 
-## Arrange to make a tags table TAGS-LISP for ../lisp,
-## plus TAGS for the C files, which includes ../lisp/TAGS by reference.
+ETAGS = ../lib-src/etags
 
 ctagsfiles1 = [xyzXYZ]*.[hc]
 ctagsfiles2 = [a-wA-W]*.[hc]
 ctagsfiles3 = [a-zA-Z]*.m
 
-TAGS: $(srcdir)/$(ctagsfiles1) $(srcdir)/$(ctagsfiles2) $(S_FILE)
-        ../lib-src/etags --include=TAGS-LISP --include=$(lwlibdir)/TAGS \
+## FIXME? In out-of-tree builds, should TAGS be generated in srcdir?
+
+## This does not need to depend on ../lisp and ../lwlib TAGS files,
+## because etags "--include" only includes a pointer to the file,
+## rather than the file contents.
+TAGS: $(srcdir)/$(ctagsfiles1) $(srcdir)/$(ctagsfiles2) $(srcdir)/$(ctagsfiles3)
+        "$(ETAGS)" --include=../lisp/TAGS --include=$(lwlibdir)/TAGS \
           --regex='{c}/[        ]*DEFVAR_[A-Z_  (]+"\([^"]+\)"/' \
-          $(srcdir)/$(ctagsfiles1) $(srcdir)/$(ctagsfiles2) $(S_FILE) \
+          $(srcdir)/$(ctagsfiles1) $(srcdir)/$(ctagsfiles2) \
           --regex='{objc}/[     ]*DEFVAR_[A-Z_  (]+"\([^"]+\)"/' \
           $(srcdir)/$(ctagsfiles3)
-frc:
-TAGS-LISP: frc
-        $(MAKE) -f $(lispdir)/Makefile TAGS-LISP ETAGS=../lib-src/etags
+
+## Arrange to make tags tables for ../lisp and ../lwlib,
+## which the above TAGS file for the C files includes by reference.
+../lisp/TAGS:
+        cd ../lisp && $(MAKE) TAGS ETAGS="$(ETAGS)"
 
 $(lwlibdir)/TAGS:
-        (cd $(lwlibdir); $(MAKE) -f $(lwlibdir)/Makefile tags ETAGS=../lib-src/etags)
+        cd $(lwlibdir) && $(MAKE) TAGS ETAGS="$(ETAGS)"
 
-tags: TAGS TAGS-LISP $(lwlibdir)/TAGS
+tags: TAGS ../lisp/TAGS $(lwlibdir)/TAGS
 .PHONY: tags
 
 
@@ -646,7 +651,7 @@ tags: TAGS TAGS-LISP $(lwlibdir)/TAGS
 ## With GNU Make, we would just say "%.el : %.elc $(BOOTSTRAPEMACS)"
 .el.elc:
         @cd ../lisp; $(MAKE) $(MFLAGS) compile-onefile \
-                             THEFILE=$< EMACS=$(bootstrap_exe)
+                             THEFILE=$< EMACS="$(bootstrap_exe)"
 
 ## Since the .el.elc rule cannot specify an extra dependency, we do it here.
 $(lisp): $(BOOTSTRAPEMACS)
@@ -657,7 +662,7 @@ $(lisp): $(BOOTSTRAPEMACS)
 VCSWITNESS =
 
 $(lispsource)/loaddefs.el: $(BOOTSTRAPEMACS) $(VCSWITNESS)
-        cd ../lisp; $(MAKE) $(MFLAGS) autoloads EMACS=$(bootstrap_exe)
+        cd ../lisp; $(MAKE) $(MFLAGS) autoloads EMACS="$(bootstrap_exe)"
 
 ## Dump an Emacs executable named bootstrap-emacs containing the
 ## files from loadup.el in source form.
@@ -672,7 +677,7 @@ bootstrap-emacs$(EXEEXT): temacs$(EXEEXT)
           mv -f emacs$(EXEEXT) bootstrap-emacs$(EXEEXT); \
         fi
         @: Compile some files earlier to speed up further compilation.
-        cd ../lisp; $(MAKE) $(MFLAGS) compile-first EMACS=$(bootstrap_exe)
+        cd ../lisp; $(MAKE) $(MFLAGS) compile-first EMACS="$(bootstrap_exe)"
 
 ## Insert either autodeps.mk (if AUTO_DEPEND), else deps.mk.
 @deps_frag@
diff --git a/src/alloc.c b/src/alloc.c
index 02deaa94af1..f12fdc5c861 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -361,13 +361,21 @@ static int staticidx;
 
 static void *pure_alloc (size_t, int);
 
+/* Return X rounded to the next multiple of Y.  Arguments should not
+   have side effects, as they are evaluated more than once.  Assume X
+   + Y - 1 does not overflow.  Tune for Y being a power of 2.  */
 
-/* Value is SZ rounded up to the next multiple of ALIGNMENT.
-   ALIGNMENT must be a power of 2.  */
+#define ROUNDUP(x, y) ((y) & ((y) - 1)                                  \
+                       ? ((x) + (y) - 1) - ((x) + (y) - 1) % (y)        \
+                       : ((x) + (y) - 1) & ~ ((y) - 1))
 
-#define ALIGN(ptr, ALIGNMENT) \
-  ((void *) (((uintptr_t) (ptr) + (ALIGNMENT) - 1) \
-             & ~ ((ALIGNMENT) - 1)))
+/* Return PTR rounded up to the next multiple of ALIGNMENT.  */
+
+static void *
+ALIGN (void *ptr, int alignment)
+{
+  return (void *) ROUNDUP ((uintptr_t) ptr, alignment);
+}
 
 static void
 XFLOAT_INIT (Lisp_Object f, double n)
@@ -912,8 +920,20 @@ lisp_free (void *block)
 /* The entry point is lisp_align_malloc which returns blocks of at most
    BLOCK_BYTES and guarantees they are aligned on a BLOCK_ALIGN boundary.  */
 
-#if defined (HAVE_POSIX_MEMALIGN) && defined (SYSTEM_MALLOC)
-#define USE_POSIX_MEMALIGN 1
+#if !defined SYSTEM_MALLOC && !defined DOUG_LEA_MALLOC
+# define USE_ALIGNED_ALLOC 1
+/* Defined in gmalloc.c.  */
+void *aligned_alloc (size_t, size_t);
+#elif defined HAVE_ALIGNED_ALLOC
+# define USE_ALIGNED_ALLOC 1
+#elif defined HAVE_POSIX_MEMALIGN
+# define USE_ALIGNED_ALLOC 1
+static void *
+aligned_alloc (size_t alignment, size_t size)
+{
+  void *p;
+  return posix_memalign (&p, alignment, size) == 0 ? p : 0;
+}
 #endif
 
 /* BLOCK_ALIGN has to be a power of 2.  */
@@ -923,7 +943,7 @@ lisp_free (void *block)
    malloc a chance to minimize the amount of memory wasted to alignment.
    It should be tuned to the particular malloc library used.
    On glibc-2.3.2, malloc never tries to align, so a padding of 0 is best.
-   posix_memalign on the other hand would ideally prefer a value of 4
+   aligned_alloc on the other hand would ideally prefer a value of 4
    because otherwise, there's 1020 bytes wasted between each ablocks.
    In Emacs, testing shows that those 1020 can most of the time be
    efficiently used by malloc to place other objects, so a value of 0 can
@@ -968,7 +988,7 @@ struct ablocks
   struct ablock blocks[ABLOCKS_SIZE];
 };
 
-/* Size of the block requested from malloc or posix_memalign.  */
+/* Size of the block requested from malloc or aligned_alloc.  */
 #define ABLOCKS_BYTES (sizeof (struct ablocks) - BLOCK_PADDING)
 
 #define ABLOCK_ABASE(block) \
@@ -980,7 +1000,7 @@ struct ablocks
 #define ABLOCKS_BUSY(abase) ((abase)->blocks[0].abase)
 
 /* Pointer to the (not necessarily aligned) malloc block.  */
-#ifdef USE_POSIX_MEMALIGN
+#ifdef USE_ALIGNED_ALLOC
 #define ABLOCKS_BASE(abase) (abase)
 #else
 #define ABLOCKS_BASE(abase) \
@@ -1019,13 +1039,8 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
       mallopt (M_MMAP_MAX, 0);
 #endif
 
-#ifdef USE_POSIX_MEMALIGN
-      {
-        int err = posix_memalign (&base, BLOCK_ALIGN, ABLOCKS_BYTES);
-        if (err)
-          base = NULL;
-        abase = base;
-      }
+#ifdef USE_ALIGNED_ALLOC
+      abase = base = aligned_alloc (BLOCK_ALIGN, ABLOCKS_BYTES);
 #else
       base = malloc (ABLOCKS_BYTES);
       abase = ALIGN (base, BLOCK_ALIGN);
@@ -1280,28 +1295,32 @@ mark_interval (register INTERVAL i, Lisp_Object dummy)
 
 #define LARGE_STRING_BYTES 1024
 
-/* Struct or union describing string memory sub-allocated from an sblock.
-   This is where the contents of Lisp strings are stored.  */
-
-#ifdef GC_CHECK_STRING_BYTES
+/* The SDATA typedef is a struct or union describing string memory
+   sub-allocated from an sblock.  This is where the contents of Lisp
+   strings are stored.  */
 
-typedef struct
+struct sdata
 {
   /* Back-pointer to the string this sdata belongs to.  If null, this
-     structure is free, and the NBYTES member of the union below
+     structure is free, and NBYTES (in this structure or in the union below)
      contains the string's byte size (the same value that STRING_BYTES
      would return if STRING were non-null).  If non-null, STRING_BYTES
      (STRING) is the size of the data, and DATA contains the string's
      contents.  */
   struct Lisp_String *string;
 
+#ifdef GC_CHECK_STRING_BYTES
   ptrdiff_t nbytes;
+#endif
+
   unsigned char data[FLEXIBLE_ARRAY_MEMBER];
-} sdata;
+};
 
+#ifdef GC_CHECK_STRING_BYTES
+
+typedef struct sdata sdata;
 #define SDATA_NBYTES(S) (S)->nbytes
 #define SDATA_DATA(S)   (S)->data
-#define SDATA_SELECTOR(member) member
 
 #else
 
@@ -1309,12 +1328,16 @@ typedef union
 {
   struct Lisp_String *string;
 
-  /* When STRING is non-null.  */
-  struct
-  {
-    struct Lisp_String *string;
-    unsigned char data[FLEXIBLE_ARRAY_MEMBER];
-  } u;
+  /* When STRING is nonnull, this union is actually of type 'struct sdata',
+     which has a flexible array member.  However, if implemented by
+     giving this union a member of type 'struct sdata', the union
+     could not be the last (flexible) member of 'struct sblock',
+     because C99 prohibits a flexible array member from having a type
+     that is itself a flexible array.  So, comment this member out here,
+     but remember that the option's there when using this union.  */
+#if 0
+  struct sdata u;
+#endif
 
   /* When STRING is null.  */
   struct
@@ -1325,13 +1348,11 @@ typedef union
 } sdata;
 
 #define SDATA_NBYTES(S) (S)->n.nbytes
-#define SDATA_DATA(S)   (S)->u.data
-#define SDATA_SELECTOR(member) u.member
+#define SDATA_DATA(S)   ((struct sdata *) (S))->data
 
 #endif /* not GC_CHECK_STRING_BYTES */
 
-#define SDATA_DATA_OFFSET offsetof (sdata, SDATA_SELECTOR (data))
-
+enum { SDATA_DATA_OFFSET = offsetof (struct sdata, data) };
 
 /* Structure describing a block of memory which is sub-allocated to
    obtain string data memory for strings.  Blocks for small strings
@@ -1347,8 +1368,8 @@ struct sblock
      of the sblock if there isn't any space left in this block.  */
   sdata *next_free;
 
-  /* Start of data.  */
-  sdata first_data;
+  /* String data.  */
+  sdata data[FLEXIBLE_ARRAY_MEMBER];
 };
 
 /* Number of Lisp strings in a string_block structure.  The 1020 is
@@ -1464,7 +1485,7 @@ static ptrdiff_t const STRING_BYTES_MAX =
   min (STRING_BYTES_BOUND,
        ((SIZE_MAX - XMALLOC_OVERRUN_CHECK_OVERHEAD
          - GC_STRING_EXTRA
-         - offsetof (struct sblock, first_data)
+         - offsetof (struct sblock, data)
          - SDATA_DATA_OFFSET)
         & ~(sizeof (EMACS_INT) - 1)));
 
@@ -1507,7 +1528,7 @@ check_sblock (struct sblock *b)
 
   end = b->next_free;
 
-  for (from = &b->first_data; from < end; from = from_end)
+  for (from = b->data; from < end; from = from_end)
     {
       /* Compute the next FROM here because copying below may
          overwrite data we need to compute it.  */
@@ -1535,7 +1556,7 @@ check_string_bytes (bool all_p)
 
       for (b = large_sblocks; b; b = b->next)
         {
-          struct Lisp_String *s = b->first_data.string;
+          struct Lisp_String *s = b->data[0].string;
           if (s)
             string_bytes (s);
         }
@@ -1669,7 +1690,7 @@ allocate_string_data (struct Lisp_String *s,
 
   if (nbytes > LARGE_STRING_BYTES)
     {
-      size_t size = offsetof (struct sblock, first_data) + needed;
+      size_t size = offsetof (struct sblock, data) + needed;
 
 #ifdef DOUG_LEA_MALLOC
       /* Prevent mmap'ing the chunk.  Lisp data may not be mmap'ed
@@ -1691,8 +1712,8 @@ allocate_string_data (struct Lisp_String *s,
       mallopt (M_MMAP_MAX, MMAP_MAX_AREAS);
 #endif
 
-      b->next_free = &b->first_data;
-      b->first_data.string = NULL;
+      b->next_free = b->data;
+      b->data[0].string = NULL;
       b->next = large_sblocks;
       large_sblocks = b;
     }
@@ -1703,8 +1724,8 @@ allocate_string_data (struct Lisp_String *s,
     {
       /* Not enough room in the current sblock.  */
       b = lisp_malloc (SBLOCK_SIZE, MEM_TYPE_NON_LISP);
-      b->next_free = &b->first_data;
-      b->first_data.string = NULL;
+      b->next_free = b->data;
+      b->data[0].string = NULL;
       b->next = NULL;
 
       if (current_sblock)
@@ -1858,7 +1879,7 @@ free_large_strings (void)
     {
       next = b->next;
 
-      if (b->first_data.string == NULL)
+      if (b->data[0].string == NULL)
         lisp_free (b);
       else
         {
@@ -1885,7 +1906,7 @@ compact_small_strings (void)
      to, and TB_END is the end of TB.  */
   tb = oldest_sblock;
   tb_end = (sdata *) ((char *) tb + SBLOCK_SIZE);
-  to = &tb->first_data;
+  to = tb->data;
 
   /* Step through the blocks from the oldest to the youngest.  We
      expect that old blocks will stabilize over time, so that less
@@ -1895,7 +1916,7 @@ compact_small_strings (void)
       end = b->next_free;
       eassert ((char *) end <= (char *) b + SBLOCK_SIZE);
 
-      for (from = &b->first_data; from < end; from = from_end)
+      for (from = b->data; from < end; from = from_end)
         {
           /* Compute the next FROM here because copying below may
              overwrite data we need to compute it.  */
@@ -1932,7 +1953,7 @@ compact_small_strings (void)
                   tb->next_free = to;
                   tb = tb->next;
                   tb_end = (sdata *) ((char *) tb + SBLOCK_SIZE);
-                  to = &tb->first_data;
+                  to = tb->data;
                   to_end = (sdata *) ((char *) to + nbytes + GC_STRING_EXTRA);
                 }
 
@@ -2020,82 +2041,61 @@ INIT must be an integer that represents a character.  */)
   return val;
 }
 
-verify (sizeof (size_t) * CHAR_BIT == BITS_PER_BITS_WORD);
-verify ((BITS_PER_BITS_WORD & (BITS_PER_BITS_WORD - 1)) == 0);
+/* Fill A with 1 bits if INIT is non-nil, and with 0 bits otherwise.
+   Return A.  */
 
-static ptrdiff_t
-bool_vector_payload_bytes (ptrdiff_t nr_bits,
-                           ptrdiff_t *exact_needed_bytes_out)
+Lisp_Object
+bool_vector_fill (Lisp_Object a, Lisp_Object init)
 {
-  ptrdiff_t exact_needed_bytes;
-  ptrdiff_t needed_bytes;
-
-  eassume (nr_bits >= 0);
-
-  exact_needed_bytes = ROUNDUP ((size_t) nr_bits, CHAR_BIT) / CHAR_BIT;
-  needed_bytes = ROUNDUP ((size_t) nr_bits, BITS_PER_BITS_WORD) / CHAR_BIT;
-
-  if (needed_bytes == 0)
+  EMACS_INT nbits = bool_vector_size (a);
+  if (0 < nbits)
     {
-      /* Always allocate at least one machine word of payload so that
-         bool-vector operations in data.c don't need a special case
-         for empty vectors.  */
-      needed_bytes = sizeof (bits_word);
+      unsigned char *data = bool_vector_uchar_data (a);
+      int pattern = NILP (init) ? 0 : (1 << BOOL_VECTOR_BITS_PER_CHAR) - 1;
+      ptrdiff_t nbytes = bool_vector_bytes (nbits);
+      int last_mask = ~ (~0 << ((nbits - 1) % BOOL_VECTOR_BITS_PER_CHAR + 1));
+      memset (data, pattern, nbytes - 1);
+      data[nbytes - 1] = pattern & last_mask;
     }
-
-  if (exact_needed_bytes_out != NULL)
-    *exact_needed_bytes_out = exact_needed_bytes;
-
-  return needed_bytes;
+  return a;
 }
 
-DEFUN ("make-bool-vector", Fmake_bool_vector, Smake_bool_vector, 2, 2, 0,
-       doc: /* Return a new bool-vector of length LENGTH, using INIT for each element.
-LENGTH must be a number.  INIT matters only in whether it is t or nil.  */)
-  (Lisp_Object length, Lisp_Object init)
+/* Return a newly allocated, uninitialized bool vector of size NBITS.  */
+
+Lisp_Object
+make_uninit_bool_vector (EMACS_INT nbits)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   struct Lisp_Bool_Vector *p;
-  ptrdiff_t exact_payload_bytes;
-  ptrdiff_t total_payload_bytes;
-  ptrdiff_t needed_elements;
-
-  CHECK_NATNUM (length);
-  if (PTRDIFF_MAX < XFASTINT (length))
-    memory_full (SIZE_MAX);
-
-  total_payload_bytes = bool_vector_payload_bytes
-    (XFASTINT (length), &exact_payload_bytes);
-
-  eassume (exact_payload_bytes <= total_payload_bytes);
-  eassume (0 <= exact_payload_bytes);
-
-  needed_elements = ROUNDUP ((size_t) ((bool_header_size - header_size)
-                                       + total_payload_bytes),
-                             word_size) / word_size;
-
+  EMACS_INT word_bytes, needed_elements;
+  word_bytes = bool_vector_words (nbits) * sizeof (bits_word);
+  needed_elements = ((bool_header_size - header_size + word_bytes
+                      + word_size - 1)
+                     / word_size);
   p = (struct Lisp_Bool_Vector *) allocate_vector (needed_elements);
   XSETVECTOR (val, p);
   XSETPVECTYPESIZE (XVECTOR (val), PVEC_BOOL_VECTOR, 0, 0);
-
-  p->size = XFASTINT (length);
-  if (exact_payload_bytes)
-    {
-      memset (p->data, ! NILP (init) ? -1 : 0, exact_payload_bytes);
-
-      /* Clear any extraneous bits in the last byte.  */
-      p->data[exact_payload_bytes - 1]
-        &= (1 << ((XFASTINT (length) - 1) % BOOL_VECTOR_BITS_PER_CHAR + 1)) - 1;
-    }
+  p->size = nbits;
 
   /* Clear padding at the end.  */
-  memset (p->data + exact_payload_bytes,
-          0,
-          total_payload_bytes - exact_payload_bytes);
+  if (nbits)
+    p->data[bool_vector_words (nbits) - 1] = 0;
 
   return val;
 }
 
+DEFUN ("make-bool-vector", Fmake_bool_vector, Smake_bool_vector, 2, 2, 0,
+       doc: /* Return a new bool-vector of length LENGTH, using INIT for each element.
+LENGTH must be a number.  INIT matters only in whether it is t or nil.  */)
+  (Lisp_Object length, Lisp_Object init)
+{
+  Lisp_Object val;
+
+  CHECK_NATNUM (length);
+  val = make_uninit_bool_vector (XFASTINT (length));
+  return bool_vector_fill (val, init);
+}
+
 
 /* Make a string from NBYTES bytes at CONTENTS, and compute the number
    of characters from the contents.  This string may be unibyte or
@@ -2606,16 +2606,35 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
                            Vector Allocation
  ***********************************************************************/
 
+/* Sometimes a vector's contents are merely a pointer internally used
+   in vector allocation code.  Usually you don't want to touch this.  */
+
+static struct Lisp_Vector *
+next_vector (struct Lisp_Vector *v)
+{
+  return XUNTAG (v->contents[0], 0);
+}
+
+static void
+set_next_vector (struct Lisp_Vector *v, struct Lisp_Vector *p)
+{
+  v->contents[0] = make_lisp_ptr (p, 0);
+}
+
 /* This value is balanced well enough to avoid too much internal overhead
    for the most common cases; it's not required to be a power of two, but
    it's expected to be a mult-of-ROUNDUP_SIZE (see below).  */
 
 #define VECTOR_BLOCK_SIZE 4096
 
-/* Align allocation request sizes to be a multiple of ROUNDUP_SIZE.  */
 enum
   {
-    roundup_size = COMMON_MULTIPLE (word_size, USE_LSB_TAG ? GCALIGNMENT : 1)
+    /* Alignment of struct Lisp_Vector objects.  */
+    vector_alignment = COMMON_MULTIPLE (ALIGNOF_STRUCT_LISP_VECTOR,
+                                        USE_LSB_TAG ? GCALIGNMENT : 1),
+
+    /* Vector size requests are a multiple of this.  */
+    roundup_size = COMMON_MULTIPLE (vector_alignment, word_size)
   };
 
 /* Verify assumptions described above.  */
@@ -2623,7 +2642,7 @@ verify ((VECTOR_BLOCK_SIZE % roundup_size) == 0);
 verify (VECTOR_BLOCK_SIZE <= (1 << PSEUDOVECTOR_SIZE_BITS));
 
 /* Round up X to nearest mult-of-ROUNDUP_SIZE --- use at compile time.  */
-#define vroundup_ct(x) ROUNDUP ((size_t) (x), roundup_size)
+#define vroundup_ct(x) ROUNDUP (x, roundup_size)
 /* Round up X to nearest mult-of-ROUNDUP_SIZE --- use at runtime.  */
 #define vroundup(x) (eassume ((x) >= 0), vroundup_ct (x))
 
@@ -2663,26 +2682,37 @@ verify (VECTOR_BLOCK_SIZE <= (1 << PSEUDOVECTOR_SIZE_BITS));
     eassert ((nbytes) % roundup_size == 0);             \
     (tmp) = VINDEX (nbytes);                            \
     eassert ((tmp) < VECTOR_MAX_FREE_LIST_INDEX);       \
-    v->u.next = vector_free_lists[tmp];                 \
+    set_next_vector (v, vector_free_lists[tmp]);        \
     vector_free_lists[tmp] = (v);                       \
     total_free_vector_slots += (nbytes) / word_size;    \
   } while (0)
 
 /* This internal type is used to maintain the list of large vectors
-   which are allocated at their own, e.g. outside of vector blocks.  */
+   which are allocated at their own, e.g. outside of vector blocks.
+
+   struct large_vector itself cannot contain a struct Lisp_Vector, as
+   the latter contains a flexible array member and C99 does not allow
+   such structs to be nested.  Instead, each struct large_vector
+   object LV is followed by a struct Lisp_Vector, which is at offset
+   large_vector_offset from LV, and whose address is therefore
+   large_vector_vec (&LV).  */
 
 struct large_vector
 {
-  union {
-    struct large_vector *vector;
-#if USE_LSB_TAG
-    /* We need to maintain ROUNDUP_SIZE alignment for the vector member.  */
-    unsigned char c[vroundup_ct (sizeof (struct large_vector *))];
-#endif
-  } next;
-  struct Lisp_Vector v;
+  struct large_vector *next;
 };
 
+enum
+{
+  large_vector_offset = ROUNDUP (sizeof (struct large_vector), vector_alignment)
+};
+
+static struct Lisp_Vector *
+large_vector_vec (struct large_vector *p)
+{
+  return (struct Lisp_Vector *) ((char *) p + large_vector_offset);
+}
+
 /* This internal type is used to maintain an underlying storage
    for small vectors.  */
 
@@ -2760,7 +2790,7 @@ allocate_vector_from_block (size_t nbytes)
   if (vector_free_lists[index])
     {
       vector = vector_free_lists[index];
-      vector_free_lists[index] = vector->u.next;
+      vector_free_lists[index] = next_vector (vector);
       total_free_vector_slots -= nbytes / word_size;
       return vector;
     }
@@ -2774,7 +2804,7 @@ allocate_vector_from_block (size_t nbytes)
       {
         /* This vector is larger than requested.  */
         vector = vector_free_lists[index];
-        vector_free_lists[index] = vector->u.next;
+        vector_free_lists[index] = next_vector (vector);
         total_free_vector_slots -= nbytes / word_size;
 
         /* Excess bytes are used for the smaller vector,
@@ -2814,27 +2844,40 @@ static ptrdiff_t
 vector_nbytes (struct Lisp_Vector *v)
 {
   ptrdiff_t size = v->header.size & ~ARRAY_MARK_FLAG;
+  ptrdiff_t nwords;
 
   if (size & PSEUDOVECTOR_FLAG)
     {
       if (PSEUDOVECTOR_TYPEP (&v->header, PVEC_BOOL_VECTOR))
         {
           struct Lisp_Bool_Vector *bv = (struct Lisp_Bool_Vector *) v;
-          ptrdiff_t payload_bytes =
-              bool_vector_payload_bytes (bv->size, NULL);
-
-          eassume (payload_bytes >= 0);
-          size = bool_header_size + ROUNDUP (payload_bytes, word_size);
+          ptrdiff_t word_bytes = (bool_vector_words (bv->size)
+                                  * sizeof (bits_word));
+          ptrdiff_t boolvec_bytes = bool_header_size + word_bytes;
+          verify (header_size <= bool_header_size);
+          nwords = (boolvec_bytes - header_size + word_size - 1) / word_size;
         }
       else
-        size = (header_size
-                + ((size & PSEUDOVECTOR_SIZE_MASK)
-                   + ((size & PSEUDOVECTOR_REST_MASK)
-                      >> PSEUDOVECTOR_SIZE_BITS)) * word_size);
+        nwords = ((size & PSEUDOVECTOR_SIZE_MASK)
+                  + ((size & PSEUDOVECTOR_REST_MASK)
+                     >> PSEUDOVECTOR_SIZE_BITS));
     }
   else
-    size = header_size + size * word_size;
-  return vroundup (size);
+    nwords = size;
+  return vroundup (header_size + word_size * nwords);
+}
+
+/* Release extra resources still in use by VECTOR, which may be any
+   vector-like object.  For now, this is used just to free data in
+   font objects.  */
+
+static void
+cleanup_vector (struct Lisp_Vector *vector)
+{
+  if (PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FONT)
+      && ((vector->header.size & PSEUDOVECTOR_SIZE_MASK)
+          == FONT_OBJECT_MAX))
+    ((struct font *) vector)->driver->close ((struct font *) vector);
 }
 
 /* Reclaim space used by unmarked vectors.  */
@@ -2871,6 +2914,7 @@ sweep_vectors (void)
             {
               ptrdiff_t total_bytes;
 
+              cleanup_vector (vector);
               nbytes = vector_nbytes (vector);
               total_bytes = nbytes;
               next = ADVANCE (vector, nbytes);
@@ -2882,6 +2926,7 @@ sweep_vectors (void)
                 {
                   if (VECTOR_MARKED_P (next))
                     break;
+                  cleanup_vector (next);
                   nbytes = vector_nbytes (next);
                   total_bytes += nbytes;
                   next = ADVANCE (next, nbytes);
@@ -2918,7 +2963,7 @@ sweep_vectors (void)
 
   for (lv = large_vectors; lv; lv = *lvprev)
     {
-      vector = &lv->v;
+      vector = large_vector_vec (lv);
       if (VECTOR_MARKED_P (vector))
         {
           VECTOR_UNMARK (vector);
@@ -2934,11 +2979,11 @@ sweep_vectors (void)
           else
             total_vector_slots
               += header_size / word_size + vector->header.size;
-          lvprev = &lv->next.vector;
+          lvprev = &lv->next;
         }
       else
         {
-          *lvprev = lv->next.vector;
+          *lvprev = lv->next;
           lisp_free (lv);
         }
     }
@@ -2972,12 +3017,12 @@ allocate_vectorlike (ptrdiff_t len)
       else
         {
           struct large_vector *lv
-            = lisp_malloc ((offsetof (struct large_vector, v.u.contents)
+            = lisp_malloc ((large_vector_offset + header_size
                             + len * word_size),
                            MEM_TYPE_VECTORLIKE);
-          lv->next.vector = large_vectors;
+          lv->next = large_vectors;
           large_vectors = lv;
-          p = &lv->v;
+          p = large_vector_vec (lv);
         }
 
 #ifdef DOUG_LEA_MALLOC
@@ -3026,7 +3071,7 @@ allocate_pseudovector (int memlen, int lisplen, enum pvec_type tag)
 
   /* Only the first lisplen slots will be traced normally by the GC.  */
   for (i = 0; i < lisplen; ++i)
-    v->u.contents[i] = Qnil;
+    v->contents[i] = Qnil;
 
   XSETPVECTYPESIZE (v, tag, lisplen, memlen - lisplen);
   return v;
@@ -3114,7 +3159,7 @@ See also the function `vector'.  */)
   p = allocate_vector (XFASTINT (length));
   sizei = XFASTINT (length);
   for (i = 0; i < sizei; i++)
-    p->u.contents[i] = init;
+    p->contents[i] = init;
 
   XSETVECTOR (vector, p);
   return vector;
@@ -3132,7 +3177,7 @@ usage: (vector &rest OBJECTS)  */)
   register struct Lisp_Vector *p = XVECTOR (val);
 
   for (i = 0; i < nargs; i++)
-    p->u.contents[i] = args[i];
+    p->contents[i] = args[i];
   return val;
 }
 
@@ -3141,14 +3186,14 @@ make_byte_code (struct Lisp_Vector *v)
 {
   /* Don't allow the global zero_vector to become a byte code object. */
   eassert(0 < v->header.size);
-  if (v->header.size > 1 && STRINGP (v->u.contents[1])
-      && STRING_MULTIBYTE (v->u.contents[1]))
+  if (v->header.size > 1 && STRINGP (v->contents[1])
+      && STRING_MULTIBYTE (v->contents[1]))
     /* BYTECODE-STRING must have been produced by Emacs 20.2 or the
        earlier because they produced a raw 8-bit string for byte-code
        and now such a byte-code string is loaded as multibyte while
        raw 8-bit characters converted to multibyte form.  Thus, now we
        must convert them back to the original unibyte form.  */
-    v->u.contents[1] = Fstring_as_unibyte (v->u.contents[1]);
+    v->contents[1] = Fstring_as_unibyte (v->contents[1]);
   XSETPVECTYPE (v, PVEC_COMPILED);
 }
 
@@ -3183,7 +3228,7 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
      to be setcar'd).  */
 
   for (i = 0; i < nargs; i++)
-    p->u.contents[i] = args[i];
+    p->contents[i] = args[i];
   make_byte_code (p);
   XSETCOMPILED (val, p);
   return val;
@@ -4241,9 +4286,7 @@ live_vector_p (struct mem_node *m, void *p)
             vector = ADVANCE (vector, vector_nbytes (vector));
         }
     }
-  else if (m->type == MEM_TYPE_VECTORLIKE
-           && (char *) p == ((char *) m->start
-                             + offsetof (struct large_vector, v)))
+  else if (m->type == MEM_TYPE_VECTORLIKE && p == large_vector_vec (m->start))
     /* This memory node corresponds to a large vector.  */
     return 1;
   return 0;
@@ -5174,7 +5217,7 @@ Does not copy symbols.  Copies strings without text properties.  */)
         size &= PSEUDOVECTOR_SIZE_MASK;
       vec = XVECTOR (make_pure_vector (size));
       for (i = 0; i < size; i++)
-        vec->u.contents[i] = Fpurecopy (AREF (obj, i));
+        vec->contents[i] = Fpurecopy (AREF (obj, i));
       if (COMPILEDP (obj))
         {
           XSETPVECTYPE (vec, PVEC_COMPILED);
@@ -5254,6 +5297,95 @@ total_bytes_of_live_objects (void)
   return tot;
 }
 
+#ifdef HAVE_WINDOW_SYSTEM
+
+/* Remove unmarked font-spec and font-entity objects from ENTRY, which is
+   (DRIVER-TYPE NUM-FRAMES FONT-CACHE-DATA ...), and return changed entry.  */
+
+static Lisp_Object
+compact_font_cache_entry (Lisp_Object entry)
+{
+  Lisp_Object tail, *prev = &entry;
+
+  for (tail = entry; CONSP (tail); tail = XCDR (tail))
+    {
+      bool drop = 0;
+      Lisp_Object obj = XCAR (tail);
+
+      /* Consider OBJ if it is (font-spec . [font-entity font-entity ...]).  */
+      if (CONSP (obj) && FONT_SPEC_P (XCAR (obj))
+          && !VECTOR_MARKED_P (XFONT_SPEC (XCAR (obj)))
+          && VECTORP (XCDR (obj)))
+        {
+          ptrdiff_t i, size = ASIZE (XCDR (obj)) & ~ARRAY_MARK_FLAG;
+
+          /* If font-spec is not marked, most likely all font-entities
+             are not marked too.  But we must be sure that nothing is
+             marked within OBJ before we really drop it.  */
+          for (i = 0; i < size; i++)
+            if (VECTOR_MARKED_P (XFONT_ENTITY (AREF (XCDR (obj), i))))
+              break;
+
+          if (i == size)
+            drop = 1;
+        }
+      if (drop)
+        *prev = XCDR (tail);
+      else
+        prev = xcdr_addr (tail);
+    }
+  return entry;
+}
+
+/* Compact font caches on all terminals and mark
+   everything which is still here after compaction.  */
+
+static void
+compact_font_caches (void)
+{
+  struct terminal *t;
+
+  for (t = terminal_list; t; t = t->next_terminal)
+    {
+      Lisp_Object cache = TERMINAL_FONT_CACHE (t);
+
+      if (CONSP (cache))
+        {
+          Lisp_Object entry;
+
+          for (entry = XCDR (cache); CONSP (entry); entry = XCDR (entry))
+            XSETCAR (entry, compact_font_cache_entry (XCAR (entry)));
+        }
+      mark_object (cache);
+    }
+}
+
+#else /* not HAVE_WINDOW_SYSTEM */
+
+#define compact_font_caches() (void)(0)
+
+#endif /* HAVE_WINDOW_SYSTEM */
+
+/* Remove (MARKER . DATA) entries with unmarked MARKER
+   from buffer undo LIST and return changed list.  */
+
+static Lisp_Object
+compact_undo_list (Lisp_Object list)
+{
+  Lisp_Object tail, *prev = &list;
+
+  for (tail = list; CONSP (tail); tail = XCDR (tail))
+    {
+      if (CONSP (XCAR (tail))
+          && MARKERP (XCAR (XCAR (tail)))
+          && !XMARKER (XCAR (XCAR (tail)))->gcmarkbit)
+        *prev = XCDR (tail);
+      else
+        prev = xcdr_addr (tail);
+    }
+  return list;
+}
+
 DEFUN ("garbage-collect", Fgarbage_collect, Sgarbage_collect, 0, 0, "",
        doc: /* Reclaim storage for Lisp objects no longer needed.
 Garbage collection happens automatically if you cons more than
@@ -5392,46 +5524,19 @@ See Info node `(elisp)Garbage Collection'.  */)
   mark_stack ();
 #endif
 
-  /* Everything is now marked, except for the things that require special
-     finalization, i.e. the undo_list.
-     Look thru every buffer's undo list
-     for elements that update markers that were not marked,
-     and delete them.  */
+  /* Everything is now marked, except for the data in font caches
+     and undo lists.  They're compacted by removing an items which
+     aren't reachable otherwise.  */
+
+  compact_font_caches ();
+
   FOR_EACH_BUFFER (nextb)
     {
-      /* If a buffer's undo list is Qt, that means that undo is
-         turned off in that buffer.  Calling truncate_undo_list on
-         Qt tends to return NULL, which effectively turns undo back on.
-         So don't call truncate_undo_list if undo_list is Qt.  */
-      if (! EQ (nextb->INTERNAL_FIELD (undo_list), Qt))
-        {
-          Lisp_Object tail, prev;
-          tail = nextb->INTERNAL_FIELD (undo_list);
-          prev = Qnil;
-          while (CONSP (tail))
-            {
-              if (CONSP (XCAR (tail))
-                  && MARKERP (XCAR (XCAR (tail)))
-                  && !XMARKER (XCAR (XCAR (tail)))->gcmarkbit)
-                {
-                  if (NILP (prev))
-                    nextb->INTERNAL_FIELD (undo_list) = tail = XCDR (tail);
-                  else
-                    {
-                      tail = XCDR (tail);
-                      XSETCDR (prev, tail);
-                    }
-                }
-              else
-                {
-                  prev = tail;
-                  tail = XCDR (tail);
-                }
-            }
-        }
-      /* Now that we have stripped the elements that need not be in the
-         undo_list any more, we can finally mark the list.  */
-      mark_object (nextb->INTERNAL_FIELD (undo_list));
+      if (!EQ (BVAR (nextb, undo_list), Qt))
+        bset_undo_list (nextb, compact_undo_list (BVAR (nextb, undo_list)));
+      /* Now that we have stripped the elements that need not be
+         in the undo_list any more, we can finally mark the list.  */
+      mark_object (BVAR (nextb, undo_list));
     }
 
   gc_sweep ();
@@ -5603,30 +5708,6 @@ mark_glyph_matrix (struct glyph_matrix *matrix)
       }
 }
 
-
-/* Mark Lisp faces in the face cache C.  */
-
-static void
-mark_face_cache (struct face_cache *c)
-{
-  if (c)
-    {
-      int i, j;
-      for (i = 0; i < c->used; ++i)
-        {
-          struct face *face = FACE_FROM_ID (c->f, i);
-
-          if (face)
-            {
-              for (j = 0; j < LFACE_VECTOR_SIZE; ++j)
-                mark_object (face->lface[j]);
-            }
-        }
-    }
-}
-
-
-
 /* Mark reference to a Lisp_Object.
    If the object referred to has not been seen yet, recursively mark
    all the references contained in it.  */
@@ -5657,7 +5738,7 @@ mark_vectorlike (struct Lisp_Vector *ptr)
      The distinction is used e.g. by Lisp_Process which places extra
      non-Lisp_Object fields at the end of the structure...  */
   for (i = 0; i < size; i++) /* ...and then mark its elements.  */
-    mark_object (ptr->u.contents[i]);
+    mark_object (ptr->contents[i]);
 }
 
 /* Like mark_vectorlike but optimized for char-tables (and
@@ -5674,7 +5755,7 @@ mark_char_table (struct Lisp_Vector *ptr)
   VECTOR_MARK (ptr);
   for (i = 0; i < size; i++)
     {
-      Lisp_Object val = ptr->u.contents[i];
+      Lisp_Object val = ptr->contents[i];
 
       if (INTEGERP (val) || (SYMBOLP (val) && XSYMBOL (val)->gcmarkbit))
         continue;
@@ -5726,6 +5807,30 @@ mark_buffer (struct buffer *buffer)
     mark_buffer (buffer->base_buffer);
 }
 
+/* Mark Lisp faces in the face cache C.  */
+
+static void
+mark_face_cache (struct face_cache *c)
+{
+  if (c)
+    {
+      int i, j;
+      for (i = 0; i < c->used; ++i)
+        {
+          struct face *face = FACE_FROM_ID (c->f, i);
+
+          if (face)
+            {
+              if (face->font && !VECTOR_MARKED_P (face->font))
+                mark_vectorlike ((struct Lisp_Vector *) face->font);
+
+              for (j = 0; j < LFACE_VECTOR_SIZE; ++j)
+                mark_object (face->lface[j]);
+            }
+        }
+    }
+}
+
 /* Remove killed buffers or items whose car is a killed buffer from
    LIST, and mark other items.  Return changed LIST, which is marked.  */
 
@@ -5879,18 +5984,31 @@ mark_object (Lisp_Object arg)
               VECTOR_MARK (ptr);
               for (i = 0; i < size; i++)
                 if (i != COMPILED_CONSTANTS)
-                  mark_object (ptr->u.contents[i]);
+                  mark_object (ptr->contents[i]);
               if (size > COMPILED_CONSTANTS)
                 {
-                  obj = ptr->u.contents[COMPILED_CONSTANTS];
+                  obj = ptr->contents[COMPILED_CONSTANTS];
                   goto loop;
                 }
             }
             break;
 
           case PVEC_FRAME:
-            mark_vectorlike (ptr);
-            mark_face_cache (((struct frame *) ptr)->face_cache);
+            {
+              struct frame *f = (struct frame *) ptr;
+
+              mark_vectorlike (ptr);
+              mark_face_cache (f->face_cache);
+#ifdef HAVE_WINDOW_SYSTEM
+              if (FRAME_WINDOW_P (f) && FRAME_X_OUTPUT (f))
+                {
+                  struct font *font = FRAME_FONT (f);
+
+                  if (font && !VECTOR_MARKED_P (font))
+                    mark_vectorlike ((struct Lisp_Vector *) font);
+                }
+#endif
+            }
             break;
 
           case PVEC_WINDOW:
@@ -6118,9 +6236,6 @@ mark_terminals (void)
          it might have been marked already.  Make sure the image cache
          gets marked.  */
       mark_image_cache (t->image_cache);
-      /* FIXME: currently font cache may grow too large
-         and probably needs special finalization.  */
-      mark_object (TERMINAL_FONT_CACHE (t));
 #endif /* HAVE_WINDOW_SYSTEM */
       if (!VECTOR_MARKED_P (t))
         mark_vectorlike ((struct Lisp_Vector *)t);
diff --git a/src/buffer.c b/src/buffer.c
index ef04ca7018d..61b685ea5c5 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -154,7 +154,8 @@ CHECK_OVERLAY (Lisp_Object x)
   CHECK_TYPE (OVERLAYP (x), Qoverlayp, x);
 }
 
-/* These setters are used only in this file, so they can be private.  */
+/* These setters are used only in this file, so they can be private.
+   The public setters are inline functions defined in buffer.h.  */
 static void
 bset_abbrev_mode (struct buffer *b, Lisp_Object val)
 {
@@ -201,11 +202,6 @@ bset_buffer_file_coding_system (struct buffer *b, Lisp_Object val)
   b->INTERNAL_FIELD (buffer_file_coding_system) = val;
 }
 static void
-bset_cache_long_scans (struct buffer *b, Lisp_Object val)
-{
-  b->INTERNAL_FIELD (cache_long_scans) = val;
-}
-static void
 bset_case_fold_search (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (case_fold_search) = val;
@@ -1332,15 +1328,54 @@ No argument or nil as argument means use current buffer as BUFFER.  */)
   return BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf) ? Qt : Qnil;
 }
 
+DEFUN ("force-mode-line-update", Fforce_mode_line_update,
+       Sforce_mode_line_update, 0, 1, 0,
+       doc: /* Force redisplay of the current buffer's mode line and header line.
+With optional non-nil ALL, force redisplay of all mode lines and
+header lines.  This function also forces recomputation of the
+menu bar menus and the frame title.  */)
+     (Lisp_Object all)
+{
+  if (!NILP (all) || buffer_window_count (current_buffer))
+    {
+      update_mode_lines = 10;
+      current_buffer->prevent_redisplay_optimizations_p = 1;
+    }
+  return all;
+}
+
 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, Sset_buffer_modified_p,
        1, 1, 0,
        doc: /* Mark current buffer as modified or unmodified according to FLAG.
 A non-nil FLAG means mark the buffer modified.  */)
   (Lisp_Object flag)
 {
-  Lisp_Object fn;
+  Frestore_buffer_modified_p (flag);
+
+  /* Set update_mode_lines only if buffer is displayed in some window.
+     Packages like jit-lock or lazy-lock preserve a buffer's modified
+     state by recording/restoring the state around blocks of code.
+     Setting update_mode_lines makes redisplay consider all windows
+     (on all frames).  Stealth fontification of buffers not displayed
+     would incur additional redisplay costs if we'd set
+     update_modes_lines unconditionally.
+
+     Ideally, I think there should be another mechanism for fontifying
+     buffers without "modifying" buffers, or redisplay should be
+     smarter about updating the `*' in mode lines.  --gerd  */
+  return Fforce_mode_line_update (Qnil);
+}
 
+DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p,
+       Srestore_buffer_modified_p, 1, 1, 0,
+       doc: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
+It is not ensured that mode lines will be updated to show the modified
+state of the current buffer.  Use with care.  */)
+  (Lisp_Object flag)
+{
 #ifdef CLASH_DETECTION
+  Lisp_Object fn;
+
   /* If buffer becoming modified, lock the file.
      If buffer becoming unmodified, unlock the file.  */
 
@@ -1380,52 +1415,6 @@ A non-nil FLAG means mark the buffer modified.  */)
                     or increase MODIFF.  */
                  : MODIFF++);
 
-  /* Set update_mode_lines only if buffer is displayed in some window.
-     Packages like jit-lock or lazy-lock preserve a buffer's modified
-     state by recording/restoring the state around blocks of code.
-     Setting update_mode_lines makes redisplay consider all windows
-     (on all frames).  Stealth fontification of buffers not displayed
-     would incur additional redisplay costs if we'd set
-     update_modes_lines unconditionally.
-
-     Ideally, I think there should be another mechanism for fontifying
-     buffers without "modifying" buffers, or redisplay should be
-     smarter about updating the `*' in mode lines.  --gerd  */
-  if (buffer_window_count (current_buffer))
-    {
-      ++update_mode_lines;
-      current_buffer->prevent_redisplay_optimizations_p = 1;
-    }
-
-  return flag;
-}
-
-DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p,
-       Srestore_buffer_modified_p, 1, 1, 0,
-       doc: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
-It is not ensured that mode lines will be updated to show the modified
-state of the current buffer.  Use with care.  */)
-  (Lisp_Object flag)
-{
-#ifdef CLASH_DETECTION
-  Lisp_Object fn;
-
-  /* If buffer becoming modified, lock the file.
-     If buffer becoming unmodified, unlock the file.  */
-
-  fn = BVAR (current_buffer, file_truename);
-  /* Test buffer-file-name so that binding it to nil is effective.  */
-  if (!NILP (fn) && ! NILP (BVAR (current_buffer, filename)))
-    {
-      bool already = SAVE_MODIFF < MODIFF;
-      if (!already && !NILP (flag))
-        lock_file (fn);
-      else if (already && NILP (flag))
-        unlock_file (fn);
-    }
-#endif /* CLASH_DETECTION */
-
-  SAVE_MODIFF = NILP (flag) ? MODIFF : 0;
   return flag;
 }
 
@@ -1513,7 +1502,7 @@ This does not change the name of the visited file (if any).  */)
 
   /* Catch redisplay's attention.  Unless we do this, the mode lines for
      any windows displaying current_buffer will stay unchanged.  */
-  update_mode_lines++;
+  update_mode_lines = 11;
 
   XSETBUFFER (buf, current_buffer);
   Fsetcar (Frassq (buf, Vbuffer_alist), newname);
@@ -1798,7 +1787,7 @@ cleaning up all windows currently displaying the buffer to be killed. */)
   /* Run replace_buffer_in_windows before making another buffer current
      since set-window-buffer-start-and-point will refuse to make another
      buffer current if the selected window does not show the current
-     buffer.  (Bug#10114) */
+     buffer (bug#10114).  */
   replace_buffer_in_windows (buffer);
 
   /* Exit if replacing the buffer in windows has killed our buffer.  */
@@ -2074,7 +2063,7 @@ the current buffer's major mode.  */)
   count = SPECPDL_INDEX ();
 
   /* To select a nonfundamental mode,
-     select the buffer temporarily and then call the mode function. */
+     select the buffer temporarily and then call the mode function.  */
 
   record_unwind_protect (save_excursion_restore, save_excursion_save ());
 
@@ -2114,7 +2103,7 @@ set_buffer_internal_1 (register struct buffer *b)
 
   old_buf = current_buffer;
   current_buffer = b;
-  last_known_column_point = -1;   /* invalidate indentation cache */
+  last_known_column_point = -1;   /* Invalidate indentation cache.  */
 
   if (old_buf)
     {
@@ -2138,7 +2127,7 @@ set_buffer_internal_1 (register struct buffer *b)
   fetch_buffer_markers (b);
 
   /* Look down buffer's list of local Lisp variables
-     to find and update any that forward into C variables. */
+     to find and update any that forward into C variables.  */
 
   do
     {
@@ -2705,7 +2694,7 @@ current buffer is cleared.  */)
 
   /* If buffer is shown in a window, let redisplay consider other windows.  */
   if (buffer_window_count (current_buffer))
-    ++windows_or_buffers_changed;
+    windows_or_buffers_changed = 10;
 
   /* Copy this buffer's new multibyte status
      into all of its indirect buffers.  */
@@ -2765,7 +2754,7 @@ the normal hook `change-major-mode-hook'.  */)
 
   /* Force mode-line redisplay.  Useful here because all major mode
      commands call this function.  */
-  update_mode_lines++;
+  update_mode_lines = 12;
 
   return Qnil;
 }
@@ -3911,11 +3900,11 @@ modify_overlay (struct buffer *buf, ptrdiff_t start, ptrdiff_t end)
     {
       /* ... it's visible in other window than selected,  */
       if (buf != XBUFFER (XWINDOW (selected_window)->contents))
-        windows_or_buffers_changed = 1;
+        windows_or_buffers_changed = 11;
       /* ... or if we modify an overlay at the end of the buffer
          and so we cannot be sure that window end is still valid.  */
       else if (end >= ZV && start <= ZV)
-        windows_or_buffers_changed = 1;
+        windows_or_buffers_changed = 12;
     }
 
   ++BUF_OVERLAY_MODIFF (buf);
@@ -4534,7 +4523,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
     Lisp_Object *copy = alloca (size * sizeof *copy);
     ptrdiff_t i;
 
-    memcpy (copy, XVECTOR (last_overlay_modification_hooks)->u.contents,
+    memcpy (copy, XVECTOR (last_overlay_modification_hooks)->contents,
             size * word_size);
     gcpro1.var = copy;
     gcpro1.nvars = size;
@@ -5185,7 +5174,7 @@ init_buffer_once (void)
   bset_buffer_file_coding_system (&buffer_defaults, Qnil);
   XSETFASTINT (BVAR (&buffer_defaults, fill_column), 70);
   XSETFASTINT (BVAR (&buffer_defaults, left_margin), 0);
-  bset_cache_long_scans (&buffer_defaults, Qnil);
+  bset_cache_long_scans (&buffer_defaults, Qt);
   bset_file_truename (&buffer_defaults, Qnil);
   XSETFASTINT (BVAR (&buffer_defaults, display_count), 0);
   XSETFASTINT (BVAR (&buffer_defaults, left_margin_cols), 0);
@@ -5349,13 +5338,10 @@ init_buffer (void)
       len++;
     }
 
+  /* At this moment, we still don't know how to decode the directory
+     name.  So, we keep the bytes in unibyte form so that file I/O
+     routines correctly get the original bytes.  */
   bset_directory (current_buffer, make_unibyte_string (pwd, len));
-  if (! NILP (BVAR (&buffer_defaults, enable_multibyte_characters)))
-    /* At this moment, we still don't know how to decode the
-       directory name.  So, we keep the bytes in multibyte form so
-       that ENCODE_FILE correctly gets the original bytes.  */
-    bset_directory
-      (current_buffer, string_to_multibyte (BVAR (current_buffer, directory)));
 
   /* Add /: to the front of the name
      if it would otherwise be treated as magic.  */
@@ -5410,12 +5396,12 @@ defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
 
   if (PER_BUFFER_IDX (offset) == 0)
     /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
-       slot of buffer_local_flags */
+       slot of buffer_local_flags.  */
     emacs_abort ();
 }
 
 
-/* initialize the buffer routines */
+/* Initialize the buffer routines.  */
 void
 syms_of_buffer (void)
 {
@@ -5805,7 +5791,8 @@ its value may not be a list of functions.  */);
 
   DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer, filename),
                      Qstringp,
-                     doc: /* Name of file visited in current buffer, or nil if not visiting a file.  */);
+                     doc: /* Name of file visited in current buffer, or nil if not visiting a file.
+This should be an absolute file name.  */);
 
   DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer, file_truename),
                      Qstringp,
@@ -6305,6 +6292,7 @@ and `bury-buffer-internal'.  */);
   defsubr (&Sbuffer_local_value);
   defsubr (&Sbuffer_local_variables);
   defsubr (&Sbuffer_modified_p);
+  defsubr (&Sforce_mode_line_update);
   defsubr (&Sset_buffer_modified_p);
   defsubr (&Sbuffer_modified_tick);
   defsubr (&Sbuffer_chars_modified_tick);
diff --git a/src/buffer.h b/src/buffer.h
index a36c0d13c9e..d1a3e50d7cf 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -871,13 +871,19 @@ struct buffer
 };
 
 /* Most code should use these functions to set Lisp fields in struct
-   buffer.  */
+   buffer.  (Some setters that are private to a single .c file are
+   defined as static in those files.)  */
 INLINE void
 bset_bidi_paragraph_direction (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (bidi_paragraph_direction) = val;
 }
 INLINE void
+bset_cache_long_scans (struct buffer *b, Lisp_Object val)
+{
+  b->INTERNAL_FIELD (cache_long_scans) = val;
+}
+INLINE void
 bset_case_canon_table (struct buffer *b, Lisp_Object val)
 {
   b->INTERNAL_FIELD (case_canon_table) = val;
diff --git a/src/bytecode.c b/src/bytecode.c
index b9cb36c871f..f34e702c71d 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -550,7 +550,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 #ifdef BYTE_CODE_SAFE
   bytestr_length = SBYTES (bytestr);
 #endif
-  vectorp = XVECTOR (vector)->u.contents;
+  vectorp = XVECTOR (vector)->contents;
 
   stack.byte_string = bytestr;
   stack.pc = stack.byte_string_start = SDATA (bytestr);
diff --git a/src/callproc.c b/src/callproc.c
index d4b4a26ec3a..3317c1203bc 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -777,7 +777,6 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
       char buf[CALLPROC_BUFFER_SIZE_MAX];
       int bufsize = CALLPROC_BUFFER_SIZE_MIN;
       int nread;
-      bool first = 1;
       EMACS_INT total_read = 0;
       int carryover = 0;
       bool display_on_the_fly = display_p;
@@ -822,6 +821,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
               ptrdiff_t count1 = SPECPDL_INDEX ();
 
               XSETBUFFER (curbuf, current_buffer);
+              prepare_to_modify_buffer (PT, PT, NULL);
               /* We cannot allow after-change-functions be run
                  during decoding, because that might modify the
                  buffer, while we rely on process_coding.produced to
@@ -874,9 +874,6 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
 
           if (display_p)
             {
-              if (first)
-                prepare_menu_bars ();
-              first = 0;
               redisplay_preserve_echo_area (1);
               /* This variable might have been set to 0 for code
                  detection.  In that case, set it back to 1 because
@@ -1612,14 +1609,14 @@ init_callproc (void)
       Lisp_Object tem, tem1, srcdir;
 
       srcdir = Fexpand_file_name (build_string ("../src/"),
-                                  build_string (PATH_DUMPLOADSEARCH));
+                                  build_unibyte_string (PATH_DUMPLOADSEARCH));
       tem = Fexpand_file_name (build_string ("GNU"), Vdata_directory);
       tem1 = Ffile_exists_p (tem);
       if (!NILP (Fequal (srcdir, Vinvocation_directory)) || NILP (tem1))
         {
           Lisp_Object newdir;
           newdir = Fexpand_file_name (build_string ("../etc/"),
-                                      build_string (PATH_DUMPLOADSEARCH));
+                                      build_unibyte_string (PATH_DUMPLOADSEARCH));
           tem = Fexpand_file_name (build_string ("GNU"), newdir);
           tem1 = Ffile_exists_p (tem);
           if (!NILP (tem1))
@@ -1646,7 +1643,7 @@ init_callproc (void)
 #ifdef DOS_NT
   Vshared_game_score_directory = Qnil;
 #else
-  Vshared_game_score_directory = build_string (PATH_GAME);
+  Vshared_game_score_directory = build_unibyte_string (PATH_GAME);
   if (NILP (Ffile_accessible_directory_p (Vshared_game_score_directory)))
     Vshared_game_score_directory = Qnil;
 #endif
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 5a40790f87f..9b213bb3cf2 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -102,7 +102,7 @@ casify_object (enum case_action flag, Lisp_Object obj)
             inword = (SYNTAX (c) == Sword);
           if (c != c1)
             {
-                  MAKE_CHAR_UNIBYTE (c);
+              MAKE_CHAR_UNIBYTE (c);
               /* If the char can't be converted to a valid byte, just don't
                  change it.  */
               if (c >= 0 && c < 256)
diff --git a/src/category.c b/src/category.c
index da5e81e4709..80d8b1ca1a2 100644
--- a/src/category.c
+++ b/src/category.c
@@ -55,17 +55,9 @@ bset_category_table (struct buffer *b, Lisp_Object val)
 static int category_table_version;
 
 static Lisp_Object Qcategory_table, Qcategoryp, Qcategorysetp, Qcategory_table_p;
-
-/* Make CATEGORY_SET includes (if VAL is t) or excludes (if VAL is
-   nil) CATEGORY.  */
-#define SET_CATEGORY_SET(category_set, category, val) \
-  set_category_set (category_set, category, val)
-static void set_category_set (Lisp_Object, Lisp_Object, Lisp_Object);
 
 /* Category set staff.  */
 
-static Lisp_Object hash_get_category_set (Lisp_Object, Lisp_Object);
-
 static Lisp_Object
 hash_get_category_set (Lisp_Object table, Lisp_Object category_set)
 {
@@ -88,6 +80,13 @@ hash_get_category_set (Lisp_Object table, Lisp_Object category_set)
   return category_set;
 }
 
+/* Make CATEGORY_SET include (if VAL) or exclude (if !VAL) CATEGORY.  */
+
+static void
+set_category_set (Lisp_Object category_set, EMACS_INT category, bool val)
+{
+  bool_vector_set (category_set, category, val);
+}
 
 DEFUN ("make-category-set", Fmake_category_set, Smake_category_set, 1, 1, 0,
        doc: /* Return a newly created category-set which contains CATEGORIES.
@@ -108,11 +107,11 @@ those categories.  */)
   len = SCHARS (categories);
   while (--len >= 0)
     {
-      Lisp_Object category;
+      unsigned char cat = SREF (categories, len);
+      Lisp_Object category = make_number (cat);
 
-      XSETFASTINT (category, SREF (categories, len));
       CHECK_CATEGORY (category);
-      SET_CATEGORY_SET (val, category, Qt);
+      set_category_set (val, cat, 1);
     }
   return val;
 }
@@ -334,20 +333,6 @@ The return value is a string containing those same categories.  */)
   return build_string (str);
 }
 
-static void
-set_category_set (Lisp_Object category_set, Lisp_Object category, Lisp_Object val)
-{
-  do {
-    int idx = XINT (category) / 8;
-    unsigned char bits = 1 << (XINT (category) % 8);
-
-    if (NILP (val))
-      XCATEGORY_SET (category_set)->data[idx] &= ~bits;
-    else
-      XCATEGORY_SET (category_set)->data[idx] |= bits;
-  } while (0);
-}
-
 DEFUN ("modify-category-entry", Fmodify_category_entry,
        Smodify_category_entry, 2, 4, 0,
        doc: /* Modify the category set of CHARACTER by adding CATEGORY to it.
@@ -359,7 +344,7 @@ If optional fourth argument RESET is non-nil,
 then delete CATEGORY from the category set instead of adding it.  */)
   (Lisp_Object character, Lisp_Object category, Lisp_Object table, Lisp_Object reset)
 {
-  Lisp_Object set_value;        /* Actual value to be set in category sets.  */
+  bool set_value;       /* Actual value to be set in category sets.  */
   Lisp_Object category_set;
   int start, end;
   int from, to;
@@ -384,7 +369,7 @@ then delete CATEGORY from the category set instead of adding it.  */)
   if (NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
     error ("Undefined category: %c", (int) XFASTINT (category));
 
-  set_value = NILP (reset) ? Qt : Qnil;
+  set_value = NILP (reset);
 
   while (start <= end)
     {
@@ -393,7 +378,7 @@ then delete CATEGORY from the category set instead of adding it.  */)
       if (CATEGORY_MEMBER (XFASTINT (category), category_set) != NILP (reset))
         {
           category_set = Fcopy_sequence (category_set);
-          SET_CATEGORY_SET (category_set, category, set_value);
+          set_category_set (category_set, XFASTINT (category), set_value);
           category_set = hash_get_category_set (table, category_set);
           char_table_set_range (table, start, to, category_set);
         }
diff --git a/src/category.h b/src/category.h
index a2eaf010132..ef784c8cbf5 100644
--- a/src/category.h
+++ b/src/category.h
@@ -60,8 +60,6 @@ INLINE_HEADER_BEGIN
 #define CHECK_CATEGORY(x) \
   CHECK_TYPE (CATEGORYP (x), Qcategoryp, x)
 
-#define XCATEGORY_SET XBOOL_VECTOR
-
 #define CATEGORY_SET_P(x) \
   (BOOL_VECTOR_P (x) && bool_vector_size (x) == 128)
 
@@ -75,10 +73,12 @@ INLINE_HEADER_BEGIN
 #define CATEGORY_SET(c) char_category_set (c)
 
 /* Return true if CATEGORY_SET contains CATEGORY.
-   The faster version of `!NILP (Faref (category_set, category))'.  */
-#define CATEGORY_MEMBER(category, category_set)                         \
-  ((XCATEGORY_SET (category_set)->data[(category) / 8]                  \
-    >> ((category) % 8)) & 1)
+   Faster than '!NILP (Faref (category_set, make_number (category)))'.  */
+INLINE bool
+CATEGORY_MEMBER (EMACS_INT category, Lisp_Object category_set)
+{
+  return bool_vector_bitref (category_set, category);
+}
 
 /* Return true if category set of CH contains CATEGORY.  */
 INLINE bool
diff --git a/src/ccl.c b/src/ccl.c
index d1783c25718..8fec18296a6 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -1094,7 +1094,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
             ccl_prog_stack_struct[stack_idx].ic = ic;
             ccl_prog_stack_struct[stack_idx].eof_ic = eof_ic;
             stack_idx++;
-            ccl_prog = XVECTOR (AREF (slot, 1))->u.contents;
+            ccl_prog = XVECTOR (AREF (slot, 1))->contents;
             ic = CCL_HEADER_MAIN;
             eof_ic = XFASTINT (ccl_prog[CCL_HEADER_EOF]);
           }
@@ -1936,9 +1936,9 @@ setup_ccl_program (struct ccl_program *ccl, Lisp_Object ccl_prog)
         return -1;
       vp = XVECTOR (ccl_prog);
       ccl->size = vp->header.size;
-      ccl->prog = vp->u.contents;
-      ccl->eof_ic = XINT (vp->u.contents[CCL_HEADER_EOF]);
-      ccl->buf_magnification = XINT (vp->u.contents[CCL_HEADER_BUF_MAG]);
+      ccl->prog = vp->contents;
+      ccl->eof_ic = XINT (vp->contents[CCL_HEADER_EOF]);
+      ccl->buf_magnification = XINT (vp->contents[CCL_HEADER_BUF_MAG]);
       if (ccl->idx >= 0)
         {
           Lisp_Object slot;
diff --git a/src/character.h b/src/character.h
index d1b781caa53..e944b5775ed 100644
--- a/src/character.h
+++ b/src/character.h
@@ -677,7 +677,7 @@ extern Lisp_Object string_escape_byte8 (Lisp_Object);
 
 /* Return a translation table of id number ID.  */
 #define GET_TRANSLATION_TABLE(id) \
-  (XCDR (XVECTOR (Vtranslation_table_vector)->u.contents[(id)]))
+  (XCDR (XVECTOR (Vtranslation_table_vector)->contents[(id)]))
 
 INLINE_HEADER_END
 
diff --git a/src/chartab.c b/src/chartab.c
index 089c4254da6..16dd85c12c0 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -141,7 +141,8 @@ static Lisp_Object
 make_sub_char_table (int depth, int min_char, Lisp_Object defalt)
 {
   Lisp_Object table;
-  int size = CHAR_TABLE_STANDARD_SLOTS + chartab_size[depth];
+  int size = (PSEUDOVECSIZE (struct Lisp_Sub_Char_Table, contents)
+              + chartab_size[depth]);
 
   table = Fmake_vector (make_number (size), defalt);
   XSETPVECTYPE (XVECTOR (table), PVEC_SUB_CHAR_TABLE);
@@ -1258,7 +1259,7 @@ uniprop_encode_value_character (Lisp_Object table, Lisp_Object value)
 static Lisp_Object
 uniprop_encode_value_run_length (Lisp_Object table, Lisp_Object value)
 {
-  Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->u.contents;
+  Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->contents;
   int i, size = ASIZE (XCHAR_TABLE (table)->extras[4]);
 
   for (i = 0; i < size; i++)
@@ -1276,7 +1277,7 @@ uniprop_encode_value_run_length (Lisp_Object table, Lisp_Object value)
 static Lisp_Object
 uniprop_encode_value_numeric (Lisp_Object table, Lisp_Object value)
 {
-  Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->u.contents;
+  Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->contents;
   int i, size = ASIZE (XCHAR_TABLE (table)->extras[4]);
 
   CHECK_NUMBER (value);
diff --git a/src/coding.c b/src/coding.c
index 69b01553e7f..4ee55f7c8e6 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -9358,6 +9358,14 @@ code_convert_region (Lisp_Object start, Lisp_Object end,
   setup_coding_system (coding_system, &coding);
   coding.mode |= CODING_MODE_LAST_BLOCK;
 
+  if (BUFFERP (dst_object) && !EQ (dst_object, src_object))
+    {
+      struct buffer *buf = XBUFFER (dst_object);
+      ptrdiff_t buf_pt = BUF_PT (buf);
+
+      invalidate_buffer_caches (buf, buf_pt, buf_pt);
+    }
+
   if (encodep)
     encode_coding_object (&coding, src_object, from, from_byte, to, to_byte,
                           dst_object);
@@ -9447,6 +9455,15 @@ code_convert_string (Lisp_Object string, Lisp_Object coding_system,
   coding.mode |= CODING_MODE_LAST_BLOCK;
   chars = SCHARS (string);
   bytes = SBYTES (string);
+
+  if (BUFFERP (dst_object))
+    {
+      struct buffer *buf = XBUFFER (dst_object);
+      ptrdiff_t buf_pt = BUF_PT (buf);
+
+      invalidate_buffer_caches (buf, buf_pt, buf_pt);
+    }
+
   if (encodep)
     encode_coding_object (&coding, string, 0, 0, chars, bytes, dst_object);
   else
@@ -9499,6 +9516,12 @@ decode_file_name (Lisp_Object fname)
 Lisp_Object
 encode_file_name (Lisp_Object fname)
 {
+  /* This is especially important during bootstrap and dumping, when
+     file-name encoding is not yet known, and therefore any non-ASCII
+     file names are unibyte strings, and could only be thrashed if we
+     try to encode them.  */
+  if (!STRING_MULTIBYTE (fname))
+    return fname;
 #ifdef WINDOWSNT
   /* The w32 build pretends to use UTF-8 for file-name encoding, and
      converts the file names either to UTF-16LE or to the system ANSI
diff --git a/src/commands.h b/src/commands.h
index 35c2c05fe72..b7f0049515d 100644
--- a/src/commands.h
+++ b/src/commands.h
@@ -36,10 +36,10 @@ extern Lisp_Object control_x_map;
    events until a non-ASCII event is acceptable as input.  */
 extern Lisp_Object unread_switch_frame;
 
-/* Nonzero if input is coming from the keyboard */
+/* Nonzero if input is coming from the keyboard.  */
 
 #define INTERACTIVE (NILP (Vexecuting_kbd_macro) && !noninteractive)
 
-/* Set this nonzero to force reconsideration of mode line. */
+/* Set this nonzero to force reconsideration of mode line.  */
 
 extern int update_mode_lines;
diff --git a/src/composite.c b/src/composite.c
index 689ae95fa17..2ab5dbc9133 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -266,7 +266,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
     composition_table = xpalloc (composition_table, &composition_table_size,
                                  1, -1, sizeof *composition_table);
 
-  key_contents = XVECTOR (key)->u.contents;
+  key_contents = XVECTOR (key)->contents;
 
   /* Check if the contents of COMPONENTS are valid if COMPONENTS is a
      vector or a list.  It should be a sequence of:
diff --git a/src/composite.h b/src/composite.h
index b3ea5cd1ed8..9026d03f7b6 100644
--- a/src/composite.h
+++ b/src/composite.h
@@ -88,8 +88,8 @@ composition_registered_p (Lisp_Object prop)
 #define COMPOSITION_GLYPH(cmp, n)                                       \
   XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)          \
                           ->key_and_value)                              \
-                 ->u.contents[cmp->hash_index * 2])                     \
-        ->u.contents[cmp->method == COMPOSITION_WITH_RULE_ALTCHARS      \
+                 ->contents[cmp->hash_index * 2])                       \
+        ->contents[cmp->method == COMPOSITION_WITH_RULE_ALTCHARS        \
                   ? (n) * 2 : (n)])
 
 /* Return the encoded composition rule to compose the Nth glyph of
@@ -98,8 +98,8 @@ composition_registered_p (Lisp_Object prop)
 #define COMPOSITION_RULE(cmp, n)                                \
   XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)  \
                           ->key_and_value)                      \
-                 ->u.contents[cmp->hash_index * 2])             \
-        ->u.contents[(n) * 2 - 1])
+                 ->contents[cmp->hash_index * 2])               \
+        ->contents[(n) * 2 - 1])
 
 /* Decode encoded composition rule RULE_CODE into GREF (global
    reference point code), NREF (new ref. point code).  Don't check RULE_CODE;
diff --git a/src/conf_post.h b/src/conf_post.h
index 786105864f2..2d967c0fefc 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -49,8 +49,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define malloc unexec_malloc
 #define realloc unexec_realloc
 #define free unexec_free
-/* Don't use posix_memalign because it is not compatible with unexmacosx.c.  */
-#undef HAVE_POSIX_MEMALIGN
 #endif
 /* The following solves the problem that Emacs hangs when evaluating
    (make-comint "test0" "/nodir/nofile" nil "") when /nodir/nofile
diff --git a/src/data.c b/src/data.c
index 22d051ef932..d0171b5d758 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2141,13 +2141,9 @@ or a byte-code object.  IDX starts at 0.  */)
     }
   else if (BOOL_VECTOR_P (array))
     {
-      int val;
-
       if (idxval < 0 || idxval >= bool_vector_size (array))
         args_out_of_range (array, idx);
-
-      val = (unsigned char) XBOOL_VECTOR (array)->data[idxval / BOOL_VECTOR_BITS_PER_CHAR];
-      return (val & (1 << (idxval % BOOL_VECTOR_BITS_PER_CHAR)) ? Qt : Qnil);
+      return bool_vector_ref (array, idxval);
     }
   else if (CHAR_TABLE_P (array))
     {
@@ -2191,18 +2187,9 @@ bool-vector.  IDX starts at 0.  */)
     }
   else if (BOOL_VECTOR_P (array))
     {
-      int val;
-
       if (idxval < 0 || idxval >= bool_vector_size (array))
         args_out_of_range (array, idx);
-
-      val = (unsigned char) XBOOL_VECTOR (array)->data[idxval / BOOL_VECTOR_BITS_PER_CHAR];
-
-      if (! NILP (newelt))
-        val |= 1 << (idxval % BOOL_VECTOR_BITS_PER_CHAR);
-      else
-        val &= ~(1 << (idxval % BOOL_VECTOR_BITS_PER_CHAR));
-      XBOOL_VECTOR (array)->data[idxval / BOOL_VECTOR_BITS_PER_CHAR] = val;
+      bool_vector_set (array, idxval, !NILP (newelt));
     }
   else if (CHAR_TABLE_P (array))
     {
@@ -2975,9 +2962,7 @@ lowercase l) for small endian machines.  */)
 
 /* Because we round up the bool vector allocate size to word_size
    units, we can safely read past the "end" of the vector in the
-   operations below.  These extra bits are always zero.  Also, we
-   always allocate bool vectors with at least one bits_word of storage so
-   that we don't have to special-case empty bit vectors.  */
+   operations below.  These extra bits are always zero.  */
 
 static bits_word
 bool_vector_spare_mask (EMACS_INT nr_bits)
@@ -2985,16 +2970,47 @@ bool_vector_spare_mask (EMACS_INT nr_bits)
   return (((bits_word) 1) << (nr_bits % BITS_PER_BITS_WORD)) - 1;
 }
 
-#if BITS_WORD_MAX <= UINT_MAX
-# define popcount_bits_word count_one_bits
-#elif BITS_WORD_MAX <= ULONG_MAX
-# define popcount_bits_word count_one_bits_l
-#elif BITS_WORD_MAX <= ULLONG_MAX
-# define popcount_bits_word count_one_bits_ll
+/* Info about unsigned long long, falling back on unsigned long
+   if unsigned long long is not available.  */
+
+#if HAVE_UNSIGNED_LONG_LONG_INT
+enum { BITS_PER_ULL = CHAR_BIT * sizeof (unsigned long long) };
 #else
-# error "bits_word wider than long long? Please file a bug report."
+enum { BITS_PER_ULL = CHAR_BIT * sizeof (unsigned long) };
+# define ULLONG_MAX ULONG_MAX
+# define count_one_bits_ll count_one_bits_l
 #endif
 
+/* Shift VAL right by the width of an unsigned long long.
+   BITS_PER_ULL must be less than BITS_PER_BITS_WORD.  */
+
+static bits_word
+shift_right_ull (bits_word w)
+{
+  /* Pacify bogus GCC warning about shift count exceeding type width.  */
+  int shift = BITS_PER_ULL - BITS_PER_BITS_WORD < 0 ? BITS_PER_ULL : 0;
+  return w >> shift;
+}
+
+/* Return the number of 1 bits in W.  */
+
+static int
+count_one_bits_word (bits_word w)
+{
+  if (BITS_WORD_MAX <= UINT_MAX)
+    return count_one_bits (w);
+  else if (BITS_WORD_MAX <= ULONG_MAX)
+    return count_one_bits_l (w);
+  else
+    {
+      int i = 0, count = 0;
+      while (count += count_one_bits_ll (w),
+             BITS_PER_BITS_WORD <= (i += BITS_PER_ULL))
+        w = shift_right_ull (w);
+      return count;
+    }
+}
+
 enum bool_vector_op { bool_vector_exclusive_or,
                       bool_vector_union,
                       bool_vector_intersection,
@@ -3010,7 +3026,7 @@ bool_vector_binop_driver (Lisp_Object op1,
   EMACS_INT nr_bits;
   bits_word *adata, *bdata, *cdata;
   ptrdiff_t i;
-  bits_word changed = 0;
+  bool changed = 0;
   bits_word mword;
   ptrdiff_t nr_words;
 
@@ -3023,7 +3039,7 @@ bool_vector_binop_driver (Lisp_Object op1,
 
   if (NILP (dest))
     {
-      dest = Fmake_bool_vector (make_number (nr_bits), Qnil);
+      dest = make_uninit_bool_vector (nr_bits);
       changed = 1;
     }
   else
@@ -3033,13 +3049,13 @@ bool_vector_binop_driver (Lisp_Object op1,
         wrong_length_argument (op1, op2, dest);
     }
 
-  nr_words = ROUNDUP (nr_bits, BITS_PER_BITS_WORD) / BITS_PER_BITS_WORD;
+  nr_words = bool_vector_words (nr_bits);
+
+  adata = bool_vector_data (dest);
+  bdata = bool_vector_data (op1);
+  cdata = bool_vector_data (op2);
 
-  adata = (bits_word *) XBOOL_VECTOR (dest)->data;
-  bdata = (bits_word *) XBOOL_VECTOR (op1)->data;
-  cdata = (bits_word *) XBOOL_VECTOR (op2)->data;
-  i = 0;
-  do
+  for (i = 0; i < nr_words; i++)
     {
       if (op == bool_vector_exclusive_or)
         mword = bdata[i] ^ cdata[i];
@@ -3052,18 +3068,26 @@ bool_vector_binop_driver (Lisp_Object op1,
       else
         abort ();
 
-      changed |= adata[i] ^ mword;
+      if (! changed)
+        changed = adata[i] != mword;
 
       if (op != bool_vector_subsetp)
         adata[i] = mword;
-
-      i++;
     }
-  while (i < nr_words);
 
   return changed ? dest : Qnil;
 }
 
+/* PRECONDITION must be true.  Return VALUE.  This odd construction
+   works around a bogus GCC diagnostic "shift count >= width of type".  */
+
+static int
+pre_value (bool precondition, int value)
+{
+  eassume (precondition);
+  return precondition ? value : 0;
+}
+
 /* Compute the number of trailing zero bits in val.  If val is zero,
    return the number of bits in val.  */
 static int
@@ -3073,27 +3097,34 @@ count_trailing_zero_bits (bits_word val)
     return count_trailing_zeros (val);
   if (BITS_WORD_MAX == ULONG_MAX)
     return count_trailing_zeros_l (val);
-# if HAVE_UNSIGNED_LONG_LONG_INT
   if (BITS_WORD_MAX == ULLONG_MAX)
     return count_trailing_zeros_ll (val);
-# endif
 
   /* The rest of this code is for the unlikely platform where bits_word differs
      in width from unsigned int, unsigned long, and unsigned long long.  */
-  if (val == 0)
-    return CHAR_BIT * sizeof (val);
+  val |= ~ BITS_WORD_MAX;
   if (BITS_WORD_MAX <= UINT_MAX)
     return count_trailing_zeros (val);
   if (BITS_WORD_MAX <= ULONG_MAX)
     return count_trailing_zeros_l (val);
-  {
-# if HAVE_UNSIGNED_LONG_LONG_INT
-    verify (BITS_WORD_MAX <= ULLONG_MAX);
-    return count_trailing_zeros_ll (val);
-# else
-    verify (BITS_WORD_MAX <= ULONG_MAX);
-# endif
-  }
+  else
+    {
+      int count;
+      for (count = 0;
+           count < BITS_PER_BITS_WORD - BITS_PER_ULL;
+           count += BITS_PER_ULL)
+        {
+          if (val & ULLONG_MAX)
+            return count + count_trailing_zeros_ll (val);
+          val = shift_right_ull (val);
+        }
+
+      if (BITS_PER_BITS_WORD % BITS_PER_ULL != 0
+          && BITS_WORD_MAX == (bits_word) -1)
+        val |= (bits_word) 1 << pre_value (ULONG_MAX < BITS_WORD_MAX,
+                                           BITS_PER_BITS_WORD % BITS_PER_ULL);
+      return count + count_trailing_zeros_ll (val);
+    }
 }
 
 static bits_word
@@ -3101,19 +3132,24 @@ bits_word_to_host_endian (bits_word val)
 {
 #ifndef WORDS_BIGENDIAN
   return val;
-#elif BITS_WORD_MAX >> 31 == 1
-  return bswap_32 (val);
-#elif BITS_WORD_MAX >> 31 >> 31 >> 1 == 1
-  return bswap_64 (val);
 #else
-  int i;
-  bits_word r = 0;
-  for (i = 0; i < sizeof val; i++)
-    {
-      r = (r << CHAR_BIT) | (val & ((1u << CHAR_BIT) - 1));
-      val >>= CHAR_BIT;
-    }
-  return r;
+  if (BITS_WORD_MAX >> 31 == 1)
+    return bswap_32 (val);
+# if HAVE_UNSIGNED_LONG_LONG
+  if (BITS_WORD_MAX >> 31 >> 31 >> 1 == 1)
+    return bswap_64 (val);
+# endif
+  {
+    int i;
+    bits_word r = 0;
+    for (i = 0; i < sizeof val; i++)
+      {
+        r = ((r << 1 << (CHAR_BIT - 1))
+             | (val & ((1u << 1 << (CHAR_BIT - 1)) - 1)));
+        val = val >> 1 >> (CHAR_BIT - 1);
+      }
+    return r;
+  }
 #endif
 }
 
@@ -3181,13 +3217,12 @@ Return the destination vector.  */)
   EMACS_INT nr_bits;
   bits_word *bdata, *adata;
   ptrdiff_t i;
-  bits_word mword;
 
   CHECK_BOOL_VECTOR (a);
   nr_bits = bool_vector_size (a);
 
   if (NILP (b))
-    b = Fmake_bool_vector (make_number (nr_bits), Qnil);
+    b = make_uninit_bool_vector (nr_bits);
   else
     {
       CHECK_BOOL_VECTOR (b);
@@ -3195,15 +3230,15 @@ Return the destination vector.  */)
         wrong_length_argument (a, b, Qnil);
     }
 
-  bdata = (bits_word *) XBOOL_VECTOR (b)->data;
-  adata = (bits_word *) XBOOL_VECTOR (a)->data;
+  bdata = bool_vector_data (b);
+  adata = bool_vector_data (a);
 
   for (i = 0; i < nr_bits / BITS_PER_BITS_WORD; i++)
-    bdata[i] = ~adata[i];
+    bdata[i] = BITS_WORD_MAX & ~adata[i];
 
   if (nr_bits % BITS_PER_BITS_WORD)
     {
-      mword = bits_word_to_host_endian (adata[i]);
+      bits_word mword = bits_word_to_host_endian (adata[i]);
       mword = ~mword;
       mword &= bool_vector_spare_mask (nr_bits);
       bdata[i] = bits_word_to_host_endian (mword);
@@ -3221,27 +3256,20 @@ A must be a bool vector.  B is a generalized bool.  */)
   EMACS_INT count;
   EMACS_INT nr_bits;
   bits_word *adata;
-  bits_word match;
-  ptrdiff_t i;
+  ptrdiff_t i, nwords;
 
   CHECK_BOOL_VECTOR (a);
 
   nr_bits = bool_vector_size (a);
+  nwords = bool_vector_words (nr_bits);
   count = 0;
-  match = NILP (b) ? -1 : 0;
-  adata = (bits_word *) XBOOL_VECTOR (a)->data;
-
-  for (i = 0; i < nr_bits / BITS_PER_BITS_WORD; ++i)
-    count += popcount_bits_word (adata[i] ^ match);
+  adata = bool_vector_data (a);
 
-  /* Mask out trailing parts of final mword.  */
-  if (nr_bits % BITS_PER_BITS_WORD)
-    {
-      bits_word mword = adata[i] ^ match;
-      mword = bits_word_to_host_endian (mword);
-      count += popcount_bits_word (mword & bool_vector_spare_mask (nr_bits));
-    }
+  for (i = 0; i < nwords; i++)
+    count += count_one_bits_word (adata[i]);
 
+  if (NILP (b))
+    count = nr_bits - count;
   return make_number (count);
 }
 
@@ -3259,7 +3287,7 @@ index into the vector.  */)
   bits_word *adata;
   bits_word twiddle;
   bits_word mword; /* Machine word.  */
-  ptrdiff_t pos;
+  ptrdiff_t pos, pos0;
   ptrdiff_t nr_words;
 
   CHECK_BOOL_VECTOR (a);
@@ -3269,10 +3297,8 @@ index into the vector.  */)
   if (XFASTINT (i) > nr_bits) /* Allow one past the end for convenience */
     args_out_of_range (a, i);
 
-  adata = (bits_word *) XBOOL_VECTOR (a)->data;
-
-  nr_words = ROUNDUP (nr_bits, BITS_PER_BITS_WORD) / BITS_PER_BITS_WORD;
-
+  adata = bool_vector_data (a);
+  nr_words = bool_vector_words (nr_bits);
   pos = XFASTINT (i) / BITS_PER_BITS_WORD;
   offset = XFASTINT (i) % BITS_PER_BITS_WORD;
   count = 0;
@@ -3280,7 +3306,7 @@ index into the vector.  */)
   /* By XORing with twiddle, we transform the problem of "count
      consecutive equal values" into "count the zero bits".  The latter
      operation usually has hardware support.  */
-  twiddle = NILP (b) ? 0 : -1;
+  twiddle = NILP (b) ? 0 : BITS_WORD_MAX;
 
   /* Scan the remainder of the mword at the current offset.  */
   if (pos < nr_words && offset != 0)
@@ -3288,8 +3314,8 @@ index into the vector.  */)
       mword = bits_word_to_host_endian (adata[pos]);
       mword ^= twiddle;
       mword >>= offset;
+      mword |= (bits_word) 1 << (BITS_PER_BITS_WORD - offset);
       count = count_trailing_zero_bits (mword);
-      count = min (count, BITS_PER_BITS_WORD - offset);
       pos++;
       if (count + offset < BITS_PER_BITS_WORD)
         return make_number (count);
@@ -3298,11 +3324,10 @@ index into the vector.  */)
   /* Scan whole words until we either reach the end of the vector or
      find an mword that doesn't completely match.  twiddle is
      endian-independent.  */
+  pos0 = pos;
   while (pos < nr_words && adata[pos] == twiddle)
-    {
-      count += BITS_PER_BITS_WORD;
-      ++pos;
-    }
+    pos++;
+  count += (pos - pos0) * BITS_PER_BITS_WORD;
 
   if (pos < nr_words)
     {
diff --git a/src/dispextern.h b/src/dispextern.h
index 681eba25cb3..d40febd207a 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -33,7 +33,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #else /* !HAVE_X_WINDOWS */
 
-/* X-related stuff used by non-X gui code. */
+/* X-related stuff used by non-X gui code.  */
 
 typedef struct {
   unsigned long pixel;
@@ -1543,6 +1543,7 @@ enum lface_attribute_index
   LFACE_FONT_INDEX,
   LFACE_INHERIT_INDEX,
   LFACE_FONTSET_INDEX,
+  LFACE_DISTANT_FOREGROUND_INDEX,
   LFACE_VECTOR_SIZE
 };
 
@@ -1581,6 +1582,10 @@ enum face_underline_type
 
 struct face
 {
+  /* The Lisp face attributes this face realizes.  All attributes
+     in this vector are non-nil.  */
+  Lisp_Object lface[LFACE_VECTOR_SIZE];
+
   /* The id of this face.  The id equals the index of this face in the
      vector faces_by_id of its face cache.  */
   int id;
@@ -1595,11 +1600,6 @@ struct face
      an id as returned from load_pixmap.  */
   ptrdiff_t stipple;
 
-#else /* not HAVE_WINDOW_SYSTEM */
-
-  /* Dummy.  */
-  ptrdiff_t stipple;
-
 #endif /* not HAVE_WINDOW_SYSTEM */
 
   /* Pixel value of foreground color for X frames.  Color index
@@ -1624,9 +1624,6 @@ struct face
      from the same ASCII face have the same fontset.  */
   int fontset;
 
-  /* Pixmap width and height.  */
-  unsigned int pixmap_w, pixmap_h;
-
   /* Non-zero means characters in this face have a box of that
      thickness around them.  If this value is negative, its absolute
      value indicates the thickness, and the horizontal (top and
@@ -1640,10 +1637,10 @@ struct face
      of width box_line_width is drawn in color box_color.  A value of
      FACE_RAISED_BOX or FACE_SUNKEN_BOX means a 3D box is drawn with
      shadow colors derived from the background color of the face.  */
-  enum face_box_type box;
+  ENUM_BF (face_box_type) box : 2;
 
   /* Style of underlining. */
-  enum face_underline_type underline_type;
+  ENUM_BF (face_underline_type) underline_type : 1;
 
   /* If `box' above specifies a 3D type, 1 means use box_color for
      drawing shadows.  */
@@ -1695,10 +1692,6 @@ struct face
   unsigned synth_ital : 1;
 #endif
 
-  /* The Lisp face attributes this face realizes.  All attributes
-     in this vector are non-nil.  */
-  Lisp_Object lface[LFACE_VECTOR_SIZE];
-
   /* The hash value of this face.  */
   unsigned hash;
 
@@ -1727,6 +1720,15 @@ struct face
 
 #define FACE_TTY_DEFAULT_BG_COLOR ((unsigned long) -3)
 
+/* True if COLOR is a specified (i.e., nondefault) foreground or
+   background color for a tty face.  */
+
+INLINE bool
+face_tty_specified_color (unsigned long color)
+{
+  return color < FACE_TTY_DEFAULT_BG_COLOR;
+}
+
 /* Non-zero if FACE was realized for unibyte use.  */
 
 #define FACE_UNIBYTE_P(FACE) ((FACE)->charset < 0)
@@ -2222,10 +2224,6 @@ struct it
      used for overlay strings and strings from display properties.  */
   ptrdiff_t string_nchars;
 
-  /* Start and end of a visible region; -1 if the region is not
-     visible in the window.  */
-  ptrdiff_t region_beg_charpos, region_end_charpos;
-
   /* Position at which redisplay end trigger functions should be run.  */
   ptrdiff_t redisplay_end_trigger_charpos;
 
@@ -2359,7 +2357,7 @@ struct it
       } stretch;
     } u;
 
-    /* current text and display positions.  */
+    /* Current text and display positions.  */
     struct text_pos position;
     struct display_pos current;
     Lisp_Object from_overlay;
@@ -2371,11 +2369,12 @@ struct it
     unsigned string_from_prefix_prop_p : 1;
     unsigned display_ellipsis_p : 1;
     unsigned avoid_cursor_p : 1;
-    unsigned bidi_p:1;
+    unsigned bidi_p : 1;
     unsigned from_disp_prop_p : 1;
     enum line_wrap_method line_wrap;
 
-    /* properties from display property that are reset by another display property. */
+    /* Properties from display property that are reset by another display
+       property.  */
     short voffset;
     Lisp_Object space_width;
     Lisp_Object font_height;
@@ -3282,8 +3281,6 @@ extern unsigned row_hash (struct glyph_row *);
 
 #ifdef HAVE_WINDOW_SYSTEM
 
-extern int x_bitmap_height (struct frame *, ptrdiff_t);
-extern int x_bitmap_width (struct frame *, ptrdiff_t);
 extern ptrdiff_t x_bitmap_pixmap (struct frame *, ptrdiff_t);
 extern void x_reference_bitmap (struct frame *, ptrdiff_t);
 extern ptrdiff_t x_create_bitmap_from_data (struct frame *, char *,
@@ -3335,9 +3332,10 @@ void init_baud_rate (int);
 void init_sigio (int);
 void ignore_sigio (void);
 
-/* Defined in xfaces.c */
+/* Defined in xfaces.c.  */
 
 #ifdef HAVE_X_WINDOWS
+void unload_color (struct frame *, unsigned long);
 void x_free_colors (struct frame *, unsigned long *, int);
 #endif
 
@@ -3349,7 +3347,6 @@ void clear_face_cache (int);
 unsigned long load_color (struct frame *, struct face *, Lisp_Object,
                           enum lface_attribute_index);
 #endif
-void unload_color (struct frame *, unsigned long);
 char *choose_face_font (struct frame *, Lisp_Object *, Lisp_Object,
                         int *);
 void prepare_face_for_display (struct frame *, struct face *);
@@ -3362,16 +3359,13 @@ void init_frame_faces (struct frame *);
 void free_frame_faces (struct frame *);
 void recompute_basic_faces (struct frame *);
 int face_at_buffer_position (struct window *w, ptrdiff_t pos,
-                             ptrdiff_t region_beg, ptrdiff_t region_end,
                              ptrdiff_t *endptr, ptrdiff_t limit,
                              int mouse, int base_face_id);
 int face_for_overlay_string (struct window *w, ptrdiff_t pos,
-                             ptrdiff_t region_beg, ptrdiff_t region_end,
                              ptrdiff_t *endptr, ptrdiff_t limit,
                              int mouse, Lisp_Object overlay);
 int face_at_string_position (struct window *w, Lisp_Object string,
                              ptrdiff_t pos, ptrdiff_t bufpos,
-                             ptrdiff_t region_beg, ptrdiff_t region_end,
                              ptrdiff_t *endptr, enum face_id, int mouse);
 int merge_faces (struct frame *, Lisp_Object, int, int);
 int compute_char_face (struct frame *, int, Lisp_Object);
@@ -3379,7 +3373,7 @@ void free_all_realized_faces (Lisp_Object);
 extern Lisp_Object Qforeground_color, Qbackground_color;
 extern char unspecified_fg[], unspecified_bg[];
 
-/* Defined in xfns.c  */
+/* Defined in xfns.c.  */
 
 #ifdef HAVE_X_WINDOWS
 void gamma_correct (struct frame *, XColor *);
@@ -3504,8 +3498,7 @@ extern int string_cost (const char *);
 extern int per_line_cost (const char *);
 extern void calculate_costs (struct frame *);
 extern void produce_glyphs (struct it *);
-extern bool tty_capable_p (struct tty_display_info *, unsigned,
-                           unsigned long, unsigned long);
+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 *);
diff --git a/src/dispnew.c b/src/dispnew.c
index 25acdd725dd..3207f4a0018 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -42,6 +42,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "process.h"
 
 #include "syssignal.h"
+#include "tparam.h"
 
 #ifdef HAVE_WINDOW_SYSTEM
 #include TERM_HEADER
@@ -52,10 +53,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <fpending.h>
 #include <timespec.h>
 
-#if defined (HAVE_TERM_H) && defined (GNU_LINUX)
-#include <term.h>               /* for tgetent */
-#endif
-
 #ifdef WINDOWSNT
 #include "w32.h"
 #endif
@@ -2943,7 +2940,7 @@ redraw_frame (struct frame *f)
   clear_frame (f);
   clear_current_matrices (f);
   update_end (f);
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 13;
   /* Mark all windows as inaccurate, so that every window will have
      its redisplay done.  */
   mark_window_display_accurate (FRAME_ROOT_WINDOW (f), 0);
diff --git a/src/disptab.h b/src/disptab.h
index 87dc5a22a68..e02bab04bbc 100644
--- a/src/disptab.h
+++ b/src/disptab.h
@@ -59,7 +59,7 @@ extern Lisp_Object Qdisplay_table;
 /* Return the current base (for indexing) of the GLYPH table,
    or 0 if the table isn't currently valid.  */
 #define GLYPH_TABLE_BASE  \
-  ((VECTORP (Vglyph_table)) ? XVECTOR (Vglyph_table)->u.contents : 0)
+  ((VECTORP (Vglyph_table)) ? XVECTOR (Vglyph_table)->contents : 0)
 
 /* Given BASE and LEN returned by the two previous macros,
    return nonzero if the GLYPH code G should be output as a single
diff --git a/src/doc.c b/src/doc.c
index d3f8fde08f6..b6f1569c2d8 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -850,6 +850,7 @@ Otherwise, return a new string, without any text properties.  */)
           /* This is for computing the SHADOWS arg for describe_map_tree.  */
           Lisp_Object active_maps = Fcurrent_active_maps (Qnil, Qnil);
           Lisp_Object earlier_maps;
+          ptrdiff_t count = SPECPDL_INDEX ();
 
           changed = 1;
           strp += 2;            /* skip \{ or \< */
@@ -886,6 +887,10 @@ Otherwise, return a new string, without any text properties.  */)
           /* Now switch to a temp buffer.  */
           oldbuf = current_buffer;
           set_buffer_internal (XBUFFER (Vprin1_to_string_buffer));
+          /* This is for an unusual case where some after-change
+             function uses 'format' or 'prin1' or something else that
+             will thrash Vprin1_to_string_buffer we are using.  */
+          specbind (Qinhibit_modification_hooks, Qt);
 
           if (NILP (tem))
             {
@@ -910,6 +915,7 @@ Otherwise, return a new string, without any text properties.  */)
           tem = Fbuffer_string ();
           Ferase_buffer ();
           set_buffer_internal (oldbuf);
+          unbind_to (count, Qnil);
 
         subst_string:
           start = SDATA (tem);
diff --git a/src/dosfns.c b/src/dosfns.c
index 37d3998b5ee..426da1fb41a 100644
--- a/src/dosfns.c
+++ b/src/dosfns.c
@@ -472,7 +472,7 @@ x_set_title (struct frame *f, Lisp_Object name)
   if (EQ (name, f->title))
     return;
 
-  update_mode_lines = 1;
+  update_mode_lines = 13;
 
   fset_title (f, name);
 
diff --git a/src/editfns.c b/src/editfns.c
index d4c1f995d61..277e5b60704 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -1702,6 +1702,7 @@ by text that describes the specified date and time in TIME:
 %G is the year corresponding to the ISO week, %g within the century.
 %m is the numeric month.
 %b and %h are the locale's abbreviated month name, %B the full name.
+ (%h is not supported on MS-Windows.)
 %d is the day of the month, zero-padded, %e is blank-padded.
 %u is the numeric day of week from 1 (Monday) to 7, %w from 0 (Sunday) to 6.
 %a is the locale's abbreviated name of the day of week, %A the full name.
diff --git a/src/emacs.c b/src/emacs.c
index a58829e8918..3e9635fd229 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -254,7 +254,7 @@ Action options:\n\
 FILE                    visit FILE using find-file\n\
 +LINE                   go to line LINE in next FILE\n\
 +LINE:COLUMN            go to line LINE, column COLUMN, in next FILE\n\
---directory, -L DIR     add DIR to variable load-path\n\
+--directory, -L DIR     prepend DIR to load-path (with :DIR, append DIR)\n\
 --eval EXPR             evaluate Emacs Lisp expression EXPR\n\
 --execute EXPR          evaluate Emacs Lisp expression EXPR\n\
 ",
@@ -383,7 +383,7 @@ terminate_due_to_signal (int sig, int backtrace_limit)
 /* Code for dealing with Lisp access to the Unix command line.  */
 
 static void
-init_cmdargs (int argc, char **argv, int skip_args)
+init_cmdargs (int argc, char **argv, int skip_args, char *original_pwd)
 {
   register int i;
   Lisp_Object name, dir, handler;
@@ -393,7 +393,7 @@ init_cmdargs (int argc, char **argv, int skip_args)
   initial_argv = argv;
   initial_argc = argc;
 
-  raw_name = build_string (argv[0]);
+  raw_name = build_unibyte_string (argv[0]);
 
   /* Add /: to the front of the name
      if it would otherwise be treated as magic.  */
@@ -426,7 +426,12 @@ init_cmdargs (int argc, char **argv, int skip_args)
       && NILP (Ffile_name_absolute_p (Vinvocation_directory)))
     /* Emacs was started with relative path, like ./emacs.
        Make it absolute.  */
-    Vinvocation_directory = Fexpand_file_name (Vinvocation_directory, Qnil);
+    {
+      Lisp_Object odir =
+        original_pwd ? build_unibyte_string (original_pwd) : Qnil;
+
+      Vinvocation_directory = Fexpand_file_name (Vinvocation_directory, odir);
+    }
 
   Vinstallation_directory = Qnil;
 
@@ -699,6 +704,9 @@ main (int argc, char **argv)
 #endif
   char *ch_to_dir;
 
+  /* If we use --chdir, this records the original directory.  */
+  char *original_pwd = 0;
+
 #if GC_MARK_STACK
   stack_base = &dummy;
 #endif
@@ -786,12 +794,15 @@ main (int argc, char **argv)
     }
 
   if (argmatch (argv, argc, "-chdir", "--chdir", 4, &ch_to_dir, &skip_args))
-    if (chdir (ch_to_dir) == -1)
-      {
-        fprintf (stderr, "%s: Can't chdir to %s: %s\n",
-                 argv[0], ch_to_dir, strerror (errno));
-        exit (1);
-      }
+    {
+      original_pwd = get_current_dir_name ();
+      if (chdir (ch_to_dir) != 0)
+        {
+          fprintf (stderr, "%s: Can't chdir to %s: %s\n",
+                   argv[0], ch_to_dir, strerror (errno));
+          exit (1);
+        }
+    }
 
   dumping = !initialized && (strcmp (argv[argc - 1], "dump") == 0
                              || strcmp (argv[argc - 1], "bootstrap") == 0);
@@ -1187,10 +1198,13 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
   if (!noninteractive)
     {
 #ifdef NS_IMPL_COCOA
+      /* Started from GUI? */
+      /* FIXME: Do the right thing if getenv returns NULL, or if
+         chdir fails.  */
+      if (! inhibit_window_system && ! isatty (0))
+        chdir (getenv ("HOME"));
       if (skip_args < argc)
         {
-          /* FIXME: Do the right thing if getenv returns NULL, or if
-             chdir fails.  */
           if (!strncmp (argv[skip_args], "-psn", 4))
             {
               skip_args += 1;
@@ -1318,7 +1332,9 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
   init_buffer ();       /* Init default directory of main buffer.  */
 
   init_callproc_1 ();   /* Must precede init_cmdargs and init_sys_modes.  */
-  init_cmdargs (argc, argv, skip_args); /* Must precede init_lread.  */
+
+  /* Must precede init_lread.  */
+  init_cmdargs (argc, argv, skip_args, original_pwd);
 
   if (initialized)
     {
@@ -2041,11 +2057,15 @@ You must run Emacs in batch mode in order to dump it.  */)
 
   CHECK_STRING (filename);
   filename = Fexpand_file_name (filename, Qnil);
+  filename = ENCODE_FILE (filename);
   if (!NILP (symfile))
     {
       CHECK_STRING (symfile);
       if (SCHARS (symfile))
-        symfile = Fexpand_file_name (symfile, Qnil);
+        {
+          symfile = Fexpand_file_name (symfile, Qnil);
+          symfile = ENCODE_FILE (symfile);
+        }
     }
 
   tem = Vpurify_flag;
@@ -2201,7 +2221,7 @@ decode_env_path (const char *evarname, const char *defalt)
       p = strchr (path, SEPCHAR);
       if (!p)
         p = path + strlen (path);
-      element = (p - path ? make_string (path, p - path)
+      element = (p - path ? make_unibyte_string (path, p - path)
                  : build_string ("."));
 #ifdef WINDOWSNT
       /* Relative file names in the default path are interpreted as
@@ -2211,7 +2231,7 @@ decode_env_path (const char *evarname, const char *defalt)
         element = Fexpand_file_name (Fsubstring (element,
                                                  make_number (emacs_dir_len),
                                                  Qnil),
-                                     build_string (emacs_dir));
+                                     build_unibyte_string (emacs_dir));
 #endif
 
       /* Add /: to the front of the name
diff --git a/src/eval.c b/src/eval.c
index 1e0a63a0ece..d3fcec5aef4 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -237,11 +237,22 @@ init_eval_once (void)
   Vrun_hooks = Qnil;
 }
 
+static struct handler handlerlist_sentinel;
+
 void
 init_eval (void)
 {
   specpdl_ptr = specpdl;
-  handlerlist = NULL;
+  { /* Put a dummy catcher at top-level so that handlerlist is never NULL.
+       This is important since handlerlist->nextfree holds the freelist
+       which would otherwise leak every time we unwind back to top-level.   */
+    struct handler *c;
+    handlerlist = handlerlist_sentinel.nextfree = &handlerlist_sentinel;
+    PUSH_HANDLER (c, Qunbound, CATCHER);
+    eassert (c == &handlerlist_sentinel);
+    handlerlist_sentinel.nextfree = NULL;
+    handlerlist_sentinel.next = NULL;
+  }
   Vquit_flag = Qnil;
   debug_on_next_call = 0;
   lisp_eval_depth = 0;
@@ -1129,6 +1140,8 @@ unwind_to_catch (struct handler *catch, Lisp_Object value)
 {
   bool last_time;
 
+  eassert (catch->next);
+
   /* Save the value in the tag.  */
   catch->val = value;
 
@@ -1542,7 +1555,10 @@ See also the function `condition-case'.  */)
     }
   else
     {
-      if (handlerlist != 0)
+      if (handlerlist != &handlerlist_sentinel)
+        /* FIXME: This will come right back here if there's no `top-level'
+           catcher.  A better solution would be to abort here, and instead
+           add a catch-all condition handler so we never come here.  */
         Fthrow (Qtop_level, Qt);
     }
 
@@ -2479,7 +2495,7 @@ run_hook_with_args (ptrdiff_t nargs, Lisp_Object *args,
 
   if (EQ (val, Qunbound) || NILP (val))
     return ret;
-  else if (!CONSP (val) || EQ (XCAR (val), Qlambda))
+  else if (!CONSP (val) || FUNCTIONP (val))
     {
       args[0] = val;
       return funcall (nargs, args);
diff --git a/src/fileio.c b/src/fileio.c
index eeaa736290c..fbf896e91c3 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -49,6 +49,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "coding.h"
 #include "window.h"
 #include "blockinput.h"
+#include "region-cache.h"
 #include "frame.h"
 #include "dispextern.h"
 
@@ -733,8 +734,8 @@ static unsigned make_temp_name_count, make_temp_name_count_initialized_p;
 Lisp_Object
 make_temp_name (Lisp_Object prefix, bool base64_p)
 {
-  Lisp_Object val;
-  int len, clen;
+  Lisp_Object val, encoded_prefix;
+  int len;
   printmax_t pid;
   char *p, *data;
   char pidbuf[INT_BUFSIZE_BOUND (printmax_t)];
@@ -768,12 +769,11 @@ make_temp_name (Lisp_Object prefix, bool base64_p)
 #endif
     }
 
-  len = SBYTES (prefix); clen = SCHARS (prefix);
-  val = make_uninit_multibyte_string (clen + 3 + pidlen, len + 3 + pidlen);
-  if (!STRING_MULTIBYTE (prefix))
-    STRING_SET_UNIBYTE (val);
+  encoded_prefix = ENCODE_FILE (prefix);
+  len = SBYTES (encoded_prefix);
+  val = make_uninit_string (len + 3 + pidlen);
   data = SSDATA (val);
-  memcpy (data, SSDATA (prefix), len);
+  memcpy (data, SSDATA (encoded_prefix), len);
   p = data + len;
 
   memcpy (p, pidbuf, pidlen);
@@ -811,7 +811,7 @@ make_temp_name (Lisp_Object prefix, bool base64_p)
         {
           /* We want to return only if errno is ENOENT.  */
           if (errno == ENOENT)
-            return val;
+            return DECODE_FILE (val);
           else
             /* The error here is dubious, but there is little else we
                can do.  The alternatives are to return nil, which is
@@ -988,7 +988,26 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
   if (multibyte != STRING_MULTIBYTE (default_directory))
     {
       if (multibyte)
-        default_directory = string_to_multibyte (default_directory);
+        {
+          unsigned char *p = SDATA (name);
+
+          while (*p && ASCII_BYTE_P (*p))
+            p++;
+          if (*p == '\0')
+            {
+              /* NAME is a pure ASCII string, and DEFAULT_DIRECTORY is
+                 unibyte.  Do not convert DEFAULT_DIRECTORY to
+                 multibyte; instead, convert NAME to a unibyte string,
+                 so that the result of this function is also a unibyte
+                 string.  This is needed during bootstrapping and
+                 dumping, when Emacs cannot decode file names, because
+                 the locale environment is not set up.  */
+              name = make_unibyte_string (SSDATA (name), SBYTES (name));
+              multibyte = 0;
+            }
+          else
+            default_directory = string_to_multibyte (default_directory);
+        }
       else
         {
           name = string_to_multibyte (name);
@@ -4467,6 +4486,14 @@ by calling `format-decode', which see.  */)
       report_file_errno ("Opening input file", orig_filename, save_errno);
     }
 
+  /* We made a lot of deletions and insertions above, so invalidate
+     the newline cache for the entire region of the inserted
+     characters.  */
+  if (current_buffer->newline_cache)
+    invalidate_region_cache (current_buffer,
+                             current_buffer->newline_cache,
+                             PT - BEG, Z - PT - inserted);
+
   if (read_quit)
     Fsignal (Qquit, Qnil);
 
@@ -4988,7 +5015,7 @@ write_region (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
       SAVE_MODIFF = MODIFF;
       XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
       bset_filename (current_buffer, visit_file);
-      update_mode_lines++;
+      update_mode_lines = 14;
     }
   else if (quietly)
     {
diff --git a/src/floatfns.c b/src/floatfns.c
index f3d0936f888..9f0bab2a452 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -46,12 +46,13 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <math.h>
 
-#ifndef isfinite
-# define isfinite(x) ((x) - (x) == 0)
-#endif
-#ifndef isnan
-# define isnan(x) ((x) != (x))
-#endif
+/* 'isfinite' and 'isnan' cause build failures on Solaris 10 with the
+   bundled GCC in c99 mode.  Work around the bugs with simple
+   implementations that are good enough.  */
+#undef isfinite
+#define isfinite(x) ((x) - (x) == 0)
+#undef isnan
+#define isnan(x) ((x) != (x))
 
 /* Check that X is a floating point number.  */
 
diff --git a/src/fns.c b/src/fns.c
index 7a7ddc8b89c..93829fb1d62 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -435,14 +435,10 @@ with the original.  */)
 
   if (BOOL_VECTOR_P (arg))
     {
-      Lisp_Object val;
-      ptrdiff_t size_in_chars
-        = ((bool_vector_size (arg) + BOOL_VECTOR_BITS_PER_CHAR - 1)
-           / BOOL_VECTOR_BITS_PER_CHAR);
-
-      val = Fmake_bool_vector (Flength (arg), Qnil);
-      memcpy (XBOOL_VECTOR (val)->data, XBOOL_VECTOR (arg)->data,
-              size_in_chars);
+      EMACS_INT nbits = bool_vector_size (arg);
+      ptrdiff_t nbytes = bool_vector_bytes (nbits);
+      Lisp_Object val = make_uninit_bool_vector (nbits);
+      memcpy (bool_vector_data (val), bool_vector_data (arg), nbytes);
       return val;
     }
 
@@ -674,12 +670,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
               }
             else if (BOOL_VECTOR_P (this))
               {
-                int byte;
-                byte = XBOOL_VECTOR (this)->data[thisindex / BOOL_VECTOR_BITS_PER_CHAR];
-                if (byte & (1 << (thisindex % BOOL_VECTOR_BITS_PER_CHAR)))
-                  elt = Qt;
-                else
-                  elt = Qnil;
+                elt = bool_vector_ref (this, thisindex);
                 thisindex++;
               }
             else
@@ -1602,7 +1593,7 @@ changing the value of a sequence `foo'.  */)
 
           for (i = n = 0; i < ASIZE (seq); ++i)
             if (NILP (Fequal (AREF (seq, i), elt)))
-              p->u.contents[n++] = AREF (seq, i);
+              p->contents[n++] = AREF (seq, i);
 
           XSETVECTOR (seq, p);
         }
@@ -2071,9 +2062,8 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props)
             EMACS_INT size = bool_vector_size (o1);
             if (size != bool_vector_size (o2))
               return 0;
-            if (memcmp (XBOOL_VECTOR (o1)->data, XBOOL_VECTOR (o2)->data,
-                        ((size + BOOL_VECTOR_BITS_PER_CHAR - 1)
-                         / BOOL_VECTOR_BITS_PER_CHAR)))
+            if (memcmp (bool_vector_data (o1), bool_vector_data (o2),
+                        bool_vector_bytes (size)))
               return 0;
             return 1;
           }
@@ -2163,19 +2153,7 @@ ARRAY is a vector, string, char-table, or bool-vector.  */)
           p[idx] = charval;
     }
   else if (BOOL_VECTOR_P (array))
-    {
-      unsigned char *p = XBOOL_VECTOR (array)->data;
-      size = ((bool_vector_size (array) + BOOL_VECTOR_BITS_PER_CHAR - 1)
-              / BOOL_VECTOR_BITS_PER_CHAR);
-
-      if (size)
-        {
-          memset (p, ! NILP (item) ? -1 : 0, size);
-
-          /* Clear any extraneous bits in the last byte.  */
-          p[size - 1] &= (1 << (size % BOOL_VECTOR_BITS_PER_CHAR)) - 1;
-        }
-    }
+    return bool_vector_fill (array, item);
   else
     wrong_type_argument (Qarrayp, array);
   return array;
@@ -2287,10 +2265,7 @@ mapcar1 (EMACS_INT leni, Lisp_Object *vals, Lisp_Object fn, Lisp_Object seq)
     {
       for (i = 0; i < leni; i++)
         {
-          unsigned char byte;
-          byte = XBOOL_VECTOR (seq)->data[i / BOOL_VECTOR_BITS_PER_CHAR];
-          dummy = (byte & (1 << (i % BOOL_VECTOR_BITS_PER_CHAR))) ? Qt : Qnil;
-          dummy = call1 (fn, dummy);
+          dummy = call1 (fn, bool_vector_ref (seq, i));
           if (vals)
             vals[i] = dummy;
         }
@@ -3446,7 +3421,7 @@ larger_vector (Lisp_Object vec, ptrdiff_t incr_min, ptrdiff_t nitems_max)
 {
   struct Lisp_Vector *v;
   ptrdiff_t i, incr, incr_max, old_size, new_size;
-  ptrdiff_t C_language_max = min (PTRDIFF_MAX, SIZE_MAX) / sizeof *v->u.contents;
+  ptrdiff_t C_language_max = min (PTRDIFF_MAX, SIZE_MAX) / sizeof *v->contents;
   ptrdiff_t n_max = (0 <= nitems_max && nitems_max < C_language_max
                      ? nitems_max : C_language_max);
   eassert (VECTORP (vec));
@@ -3458,9 +3433,9 @@ larger_vector (Lisp_Object vec, ptrdiff_t incr_min, ptrdiff_t nitems_max)
     memory_full (SIZE_MAX);
   new_size = old_size + incr;
   v = allocate_vector (new_size);
-  memcpy (v->u.contents, XVECTOR (vec)->u.contents, old_size * sizeof *v->u.contents);
+  memcpy (v->contents, XVECTOR (vec)->contents, old_size * sizeof *v->contents);
   for (i = old_size; i < new_size; ++i)
-    v->u.contents[i] = Qnil;
+    v->contents[i] = Qnil;
   XSETVECTOR (vec, v);
   return vec;
 }
@@ -4189,11 +4164,9 @@ sxhash_bool_vector (Lisp_Object vec)
   EMACS_UINT hash = size;
   int i, n;
 
-  n = min (SXHASH_MAX_LEN,
-           ((size + BOOL_VECTOR_BITS_PER_CHAR - 1)
-            / BOOL_VECTOR_BITS_PER_CHAR));
+  n = min (SXHASH_MAX_LEN, bool_vector_words (size));
   for (i = 0; i < n; ++i)
-    hash = sxhash_combine (hash, XBOOL_VECTOR (vec)->data[i]);
+    hash = sxhash_combine (hash, bool_vector_data (vec)[i]);
 
   return SXHASH_REDUCE (hash);
 }
diff --git a/src/font.c b/src/font.c
index 68db9f2ef2d..1e1670b21af 100644
--- a/src/font.c
+++ b/src/font.c
@@ -2591,7 +2591,7 @@ font_clear_cache (struct frame *f, Lisp_Object cache, struct font_driver *driver
                       if (! NILP (AREF (val, FONT_TYPE_INDEX)))
                         {
                           eassert (font && driver == font->driver);
-                          driver->close (f, font);
+                          driver->close (font);
                         }
                     }
                   if (driver->free_entity)
@@ -2892,7 +2892,7 @@ font_close_object (struct frame *f, Lisp_Object font_object)
     /* Already closed.  */
     return;
   FONT_ADD_LOG ("close", font_object, Qnil);
-  font->driver->close (f, font);
+  font->driver->close (font);
 #ifdef HAVE_WINDOW_SYSTEM
   eassert (FRAME_DISPLAY_INFO (f)->n_fonts);
   FRAME_DISPLAY_INFO (f)->n_fonts--;
@@ -3669,10 +3669,10 @@ font_at (int c, ptrdiff_t pos, struct face *face, struct window *w,
       ptrdiff_t endptr;
 
       if (STRINGP (string))
-        face_id = face_at_string_position (w, string, pos, 0, -1, -1, &endptr,
+        face_id = face_at_string_position (w, string, pos, 0, &endptr,
                                            DEFAULT_FACE_ID, 0);
       else
-        face_id = face_at_buffer_position (w, pos, -1, -1, &endptr,
+        face_id = face_at_buffer_position (w, pos, &endptr,
                                            pos + 100, 0, -1);
       face = FACE_FROM_ID (f, face_id);
     }
@@ -3716,7 +3716,7 @@ font_range (ptrdiff_t pos, ptrdiff_t pos_byte, ptrdiff_t *limit,
         {
           int face_id;
 
-          face_id = face_at_buffer_position (w, pos, 0, 0, &ignore,
+          face_id = face_at_buffer_position (w, pos, &ignore,
                                              *limit, 0, -1);
           face = FACE_FROM_ID (XFRAME (w->frame), face_id);
         }
diff --git a/src/font.h b/src/font.h
index 0ec56590916..2db8d35af48 100644
--- a/src/font.h
+++ b/src/font.h
@@ -545,8 +545,8 @@ struct font_driver
   Lisp_Object (*open) (struct frame *f, Lisp_Object font_entity,
                        int pixel_size);
 
-  /* Close FONT on frame F.  */
-  void (*close) (struct frame *f, struct font *font);
+  /* Close FONT.  NOTE: this can be called by GC.  */
+  void (*close) (struct font *font);
 
   /* Optional (if FACE->extra is not used).
      Prepare FACE for displaying characters by FONT on frame F by
diff --git a/src/fontset.c b/src/fontset.c
index 15fdf9f41a0..a3634f0b08d 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -453,7 +453,7 @@ reorder_font_vector (Lisp_Object font_group, struct font *font)
     }
 
   if (score_changed)
-    qsort (XVECTOR (vec)->u.contents, size, word_size,
+    qsort (XVECTOR (vec)->contents, size, word_size,
            fontset_compare_rfontdef);
   XSETCAR (font_group, make_number (charset_ordered_list_tick));
 }
@@ -1875,7 +1875,7 @@ DEFUN ("internal-char-font", Finternal_char_font, Sinternal_char_font, 1, 2, 0,
         return Qnil;
       w = XWINDOW (window);
       f = XFRAME (w->frame);
-      face_id = face_at_buffer_position (w, pos, -1, -1, &dummy,
+      face_id = face_at_buffer_position (w, pos, &dummy,
                                          pos + 100, 0, -1);
     }
   if (! CHAR_VALID_P (c))
diff --git a/src/frame.c b/src/frame.c
index f2218b7bcb7..4494edda5d7 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -231,7 +231,7 @@ set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 
   if (nlines != olines)
     {
-      windows_or_buffers_changed++;
+      windows_or_buffers_changed = 14;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
       FRAME_MENU_BAR_LINES (f) = nlines;
       set_menu_bar_lines_1 (f->root_window, nlines - olines);
@@ -1489,7 +1489,7 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
 
   /* Cause frame titles to update--necessary if we now have just one frame.  */
   if (!is_tooltip_frame)
-    update_mode_lines = 1;
+    update_mode_lines = 15;
 
   return Qnil;
 }
@@ -1699,7 +1699,7 @@ If omitted, FRAME defaults to the currently selected frame.  */)
   make_frame_visible_1 (f->root_window);
 
   /* Make menu bar update for the Buffers and Frames menus.  */
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 15;
 
   XSETFRAME (frame, f);
   return frame;
@@ -1753,7 +1753,7 @@ displayed in the terminal.  */)
 #endif
 
   /* Make menu bar update for the Buffers and Frames menus.  */
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 16;
 
   return Qnil;
 }
@@ -1776,7 +1776,7 @@ If omitted, FRAME defaults to the currently selected frame.  */)
 #endif
 
   /* Make menu bar update for the Buffers and Frames menus.  */
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 17;
 
   return Qnil;
 }
@@ -2025,7 +2025,7 @@ set_term_frame_name (struct frame *f, Lisp_Object name)
     }
 
   fset_name (f, name);
-  update_mode_lines = 1;
+  update_mode_lines = 16;
 }
 
 void
@@ -3245,7 +3245,7 @@ x_set_font_backend (struct frame *f, Lisp_Object new_value, Lisp_Object old_valu
       XSETFRAME (frame, f);
       x_set_font (f, Fframe_parameter (frame, Qfont), Qnil);
       ++face_change_count;
-      ++windows_or_buffers_changed;
+      windows_or_buffers_changed = 18;
     }
 }
 
@@ -3844,7 +3844,7 @@ XParseGeometry (char *string,
 {
   int mask = NoValue;
   char *strind;
-  unsigned long int tempWidth, tempHeight;
+  unsigned long tempWidth, tempHeight;
   long int tempX, tempY;
   char *nextCharacter;
 
diff --git a/src/fringe.c b/src/fringe.c
index 3537027f1dd..9c77e6557f4 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -1690,6 +1690,8 @@ If BITMAP already exists, the existing definition is replaced.  */)
 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face, Sset_fringe_bitmap_face,
        1, 2, 0,
        doc: /* Set face for fringe bitmap BITMAP to FACE.
+FACE is merged with the `fringe' face, so normally FACE should specify
+only the foreground color.
 If FACE is nil, reset face to default fringe face.  */)
   (Lisp_Object bitmap, Lisp_Object face)
 {
diff --git a/src/ftfont.c b/src/ftfont.c
index eeee56891ec..224b8e82500 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -498,7 +498,7 @@ static Lisp_Object ftfont_list (struct frame *, Lisp_Object);
 static Lisp_Object ftfont_match (struct frame *, Lisp_Object);
 static Lisp_Object ftfont_list_family (struct frame *);
 static Lisp_Object ftfont_open (struct frame *, Lisp_Object, int);
-static void ftfont_close (struct frame *, struct font *);
+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,
@@ -1317,7 +1317,7 @@ ftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
 }
 
 static void
-ftfont_close (struct frame *f, struct font *font)
+ftfont_close (struct font *font)
 {
   struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
   Lisp_Object val, cache;
diff --git a/src/ftxfont.c b/src/ftxfont.c
index 63d03b0e244..d1aa3e40403 100644
--- a/src/ftxfont.c
+++ b/src/ftxfont.c
@@ -57,7 +57,7 @@ struct ftxfont_frame_data
 /* Return an array of 6 GCs for antialiasing.  */
 
 static GC *
-ftxfont_get_gcs (struct frame *f, long unsigned int foreground, long unsigned int background)
+ftxfont_get_gcs (struct frame *f, unsigned long foreground, unsigned long background)
 {
   XColor color;
   XGCValues xgcv;
@@ -260,9 +260,9 @@ ftxfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
 }
 
 static void
-ftxfont_close (struct frame *f, struct font *font)
+ftxfont_close (struct font *font)
 {
-  ftfont_driver.close (f, font);
+  ftfont_driver.close (font);
 }
 
 static int
diff --git a/src/gmalloc.c b/src/gmalloc.c
index bc1d85ac5fb..c50df25cd41 100644
--- a/src/gmalloc.c
+++ b/src/gmalloc.c
@@ -58,6 +58,7 @@ extern void free (void *ptr);
 
 /* Allocate SIZE bytes allocated to ALIGNMENT bytes.  */
 #ifdef MSDOS
+extern void *aligned_alloc (size_t, size_t);
 extern void *memalign (size_t, size_t);
 extern int posix_memalign (void **, size_t, size_t);
 #endif
@@ -143,11 +144,11 @@ struct list
 /* Free list headers for each fragment size.  */
 extern struct list _fraghead[];
 
-/* List of blocks allocated with `memalign' (or `valloc').  */
+/* List of blocks allocated with aligned_alloc and friends.  */
 struct alignlist
   {
     struct alignlist *next;
-    void *aligned;              /* The address that memaligned returned.  */
+    void *aligned;              /* The address that aligned_alloc returned.  */
     void *exact;                /* The address that malloc returned.  */
   };
 extern struct alignlist *_aligned_blocks;
@@ -977,7 +978,7 @@ License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 /* Debugging hook for free.  */
 void (*__free_hook) (void *__ptr);
 
-/* List of blocks allocated by memalign.  */
+/* List of blocks allocated by aligned_alloc.  */
 struct alignlist *_aligned_blocks = NULL;
 
 /* Return memory to the heap.
@@ -1306,8 +1307,8 @@ special_realloc (void *ptr, size_t size)
     type == 0 ? bss_sbrk_heapinfo[block].busy.info.size * BLOCKSIZE
     : (size_t) 1 << type;
   result = _malloc_internal_nolock (size);
-  if (result != NULL)
-    memcpy (result, ptr, min (oldsize, size));
+  if (result)
+    return memcpy (result, ptr, min (oldsize, size));
   return result;
 }
 #endif
@@ -1487,13 +1488,20 @@ License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 /* Allocate an array of NMEMB elements each SIZE bytes long.
    The entire array is initialized to zeros.  */
 void *
-calloc (register size_t nmemb, register size_t size)
+calloc (size_t nmemb, size_t size)
 {
-  register void *result = malloc (nmemb * size);
+  void *result;
+  size_t bytes = nmemb * size;
 
-  if (result != NULL)
-    (void) memset (result, 0, nmemb * size);
+  if (size != 0 && bytes / size != nmemb)
+    {
+      errno = ENOMEM;
+      return NULL;
+    }
 
+  result = malloc (bytes);
+  if (result)
+    return memset (result, 0, bytes);
   return result;
 }
 /* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
@@ -1559,7 +1567,7 @@ License along with this library.  If not, see <http://www.gnu.org/licenses/>.  *
 void *(*__memalign_hook) (size_t size, size_t alignment);
 
 void *
-memalign (size_t alignment, size_t size)
+aligned_alloc (size_t alignment, size_t size)
 {
   void *result;
   size_t adj, lastadj;
@@ -1570,6 +1578,11 @@ memalign (size_t alignment, size_t size)
 
   /* Allocate a block with enough extra space to pad the block with up to
      (ALIGNMENT - 1) bytes if necessary.  */
+  if (- size < alignment)
+    {
+      errno = ENOMEM;
+      return NULL;
+    }
   result = malloc (size + alignment - 1);
   if (result == NULL)
     return NULL;
@@ -1631,6 +1644,15 @@ memalign (size_t alignment, size_t size)
   return result;
 }
 
+/* An obsolete alias for aligned_alloc, for any old libraries that use
+   this alias.  */
+
+void *
+memalign (size_t alignment, size_t size)
+{
+  return aligned_alloc (alignment, size);
+}
+
 int
 posix_memalign (void **memptr, size_t alignment, size_t size)
 {
@@ -1641,7 +1663,7 @@ posix_memalign (void **memptr, size_t alignment, size_t size)
       || (alignment & (alignment - 1)) != 0)
     return EINVAL;
 
-  mem = memalign (alignment, size);
+  mem = aligned_alloc (alignment, size);
   if (mem == NULL)
     return ENOMEM;
 
@@ -1686,7 +1708,7 @@ valloc (size_t size)
   if (pagesize == 0)
     pagesize = getpagesize ();
 
-  return memalign (pagesize, size);
+  return aligned_alloc (pagesize, size);
 }
 
 #ifdef GC_MCHECK
@@ -1792,8 +1814,7 @@ mallochook (size_t size)
   hdr->size = size;
   hdr->magic = MAGICWORD;
   ((char *) &hdr[1])[size] = MAGICBYTE;
-  memset (hdr + 1, MALLOCFLOOD, size);
-  return hdr + 1;
+  return memset (hdr + 1, MALLOCFLOOD, size);
 }
 
 static void *
diff --git a/src/gnutls.c b/src/gnutls.c
index f9e86d1a697..82b2fc8baa4 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -488,8 +488,20 @@ emacs_gnutls_handle_error (gnutls_session_t session, int err)
   else
     {
       ret = 1;
-      GNUTLS_LOG2 (1, max_log_level, "non-fatal error:", str);
-      /* TODO: EAGAIN AKA Qgnutls_e_again should be level 2.  */
+
+      switch (err)
+        {
+        case GNUTLS_E_AGAIN:
+          GNUTLS_LOG2 (3,
+                       max_log_level,
+                       "retry:",
+                       str);
+        default:
+          GNUTLS_LOG2 (1,
+                       max_log_level,
+                       "non-fatal error:",
+                       str);
+        }
     }
 
   if (err == GNUTLS_E_WARNING_ALERT_RECEIVED
@@ -791,16 +803,10 @@ one trustfile (usually a CA bundle).  */)
   CHECK_LIST (proplist);
 
   if (NILP (Fgnutls_available_p ()))
-    {
-      error ("GnuTLS not available");
-      return gnutls_make_error (GNUTLS_EMACS_ERROR_NOT_LOADED);
-    }
+    error ("GnuTLS not available");
 
   if (!EQ (type, Qgnutls_x509pki) && !EQ (type, Qgnutls_anon))
-    {
-      error ("Invalid GnuTLS credential type");
-      return gnutls_make_error (GNUTLS_EMACS_ERROR_INVALID_TYPE);
-    }
+    error ("Invalid GnuTLS credential type");
 
   hostname              = Fplist_get (proplist, QCgnutls_bootprop_hostname);
   priority_string       = Fplist_get (proplist, QCgnutls_bootprop_priority);
@@ -816,7 +822,6 @@ one trustfile (usually a CA bundle).  */)
   c_hostname = SSDATA (hostname);
 
   state = XPROCESS (proc)->gnutls_state;
-  XPROCESS (proc)->gnutls_p = 1;
 
   if (TYPE_RANGED_INTEGERP (int, loglevel))
     {
@@ -839,7 +844,6 @@ one trustfile (usually a CA bundle).  */)
   emacs_gnutls_deinit (proc);
 
   /* Mark PROC as a GnuTLS process.  */
-  XPROCESS (proc)->gnutls_p = 1;
   XPROCESS (proc)->gnutls_state = NULL;
   XPROCESS (proc)->gnutls_x509_cred = NULL;
   XPROCESS (proc)->gnutls_anon_cred = NULL;
@@ -1099,6 +1103,9 @@ one trustfile (usually a CA bundle).  */)
       fn_gnutls_x509_crt_deinit (gnutls_verify_cert);
     }
 
+  /* Set this flag only if the whole initialization succeeded.  */
+  XPROCESS (proc)->gnutls_p = 1;
+
   return gnutls_make_error (ret);
 }
 
diff --git a/src/gtkutil.c b/src/gtkutil.c
index e20d01521f0..192b64a7e62 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -598,14 +598,17 @@ xg_check_special_colors (struct frame *f,
     GtkStyleContext *gsty
       = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f));
     GdkRGBA col;
-    char buf[sizeof "rgbi://" + 3 * (DBL_MAX_10_EXP + sizeof "-1.000000" - 1)];
+    char buf[sizeof "rgb://rrrr/gggg/bbbb"];
     int state = GTK_STATE_FLAG_SELECTED|GTK_STATE_FLAG_FOCUSED;
     if (get_fg)
       gtk_style_context_get_color (gsty, state, &col);
     else
       gtk_style_context_get_background_color (gsty, state, &col);
 
-    sprintf (buf, "rgbi:%lf/%lf/%lf", col.red, col.green, col.blue);
+    sprintf (buf, "rgb:%04x/%04x/%04x",
+             (int)(col.red * 65535),
+             (int)(col.green * 65535),
+             (int)(col.blue * 65535));
     success_p = (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
                               buf, color)
                  != 0);
@@ -1038,7 +1041,7 @@ xg_win_to_widget (Display *dpy, Window wdesc)
 /* Set the background of widget W to PIXEL.  */
 
 static void
-xg_set_widget_bg (struct frame *f, GtkWidget *w, long unsigned int pixel)
+xg_set_widget_bg (struct frame *f, GtkWidget *w, unsigned long pixel)
 {
 #ifdef HAVE_GTK3
   GdkRGBA bg;
@@ -1439,7 +1442,7 @@ x_wm_set_size_hint (struct frame *f, long int flags, bool user_position)
    BG is the pixel value to change to.  */
 
 void
-xg_set_background_color (struct frame *f, long unsigned int bg)
+xg_set_background_color (struct frame *f, unsigned long bg)
 {
   if (FRAME_GTK_WIDGET (f))
     {
diff --git a/src/image.c b/src/image.c
index 2b07b83b816..37a19e4f5a5 100644
--- a/src/image.c
+++ b/src/image.c
@@ -87,11 +87,12 @@ typedef struct w32_bitmap_record Bitmap_Record;
 #define x_defined_color w32_defined_color
 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
 
-/* Versions of libpng and libgif that we were compiled with, or -1 if
-   no PNG/GIF support was compiled in.  This is tested by w32-win.el
-   to correctly set up the alist used to search for the respective
-   image libraries.  */
-Lisp_Object Qlibpng_version, Qlibgif_version;
+/* Versions of libpng, libgif, and libjpeg that we were compiled with,
+   or -1 if no PNG/GIF support was compiled in.  This is tested by
+   w32-win.el to correctly set up the alist used to search for the
+   respective image libraries.  */
+Lisp_Object Qlibpng_version, Qlibgif_version, Qlibjpeg_version;
+
 #endif /* HAVE_NTGUI */
 
 #ifdef HAVE_NS
@@ -159,13 +160,13 @@ XPutPixel (XImagePtr ximage, int x, int y, unsigned long pixel)
 
 /* Functions to access the contents of a bitmap, given an id.  */
 
-int
+static int
 x_bitmap_height (struct frame *f, ptrdiff_t id)
 {
   return FRAME_DISPLAY_INFO (f)->bitmaps[id - 1].height;
 }
 
-int
+static int
 x_bitmap_width (struct frame *f, ptrdiff_t id)
 {
   return FRAME_DISPLAY_INFO (f)->bitmaps[id - 1].width;
@@ -1520,7 +1521,7 @@ clear_image_cache (struct frame *f, Lisp_Object filter)
                 clear_current_matrices (fr);
             }
 
-          ++windows_or_buffers_changed;
+          windows_or_buffers_changed = 19;
         }
 
       unblock_input ();
@@ -3025,13 +3026,13 @@ xbm_load (struct frame *f, struct image *img)
                   if (STRINGP (line))
                     memcpy (p, SDATA (line), nbytes);
                   else
-                    memcpy (p, XBOOL_VECTOR (line)->data, nbytes);
+                    memcpy (p, bool_vector_data (line), nbytes);
                 }
             }
           else if (STRINGP (data))
             bits = SSDATA (data);
           else
-            bits = (char *) XBOOL_VECTOR (data)->data;
+            bits = (char *) bool_vector_data (data);
 
 #ifdef HAVE_NTGUI
           {
@@ -5105,6 +5106,27 @@ pbm_image_p (Lisp_Object object)
 }
 
 
+/* Get next char skipping comments in Netpbm header.  Returns -1 at
+   end of input.  */
+
+static int
+pbm_next_char (unsigned char **s, unsigned char *end)
+{
+  int c = -1;
+
+  while (*s < end && (c = *(*s)++, c == '#'))
+    {
+      /* Skip to the next line break.  */
+      while (*s < end && (c = *(*s)++, c != '\n' && c != '\r'))
+        ;
+
+      c = -1;
+    }
+
+  return c;
+}
+
+
 /* Scan a decimal number from *S and return it.  Advance *S while
    reading the number.  END is the end of the string.  Value is -1 at
    end of input.  */
@@ -5114,28 +5136,16 @@ pbm_scan_number (unsigned char **s, unsigned char *end)
 {
   int c = 0, val = -1;
 
-  while (*s < end)
-    {
-      /* Skip white-space.  */
-      while (*s < end && (c = *(*s)++, c_isspace (c)))
-        ;
+  /* Skip white-space.  */
+  while ((c = pbm_next_char (s, end)) != -1 && c_isspace (c))
+    ;
 
-      if (c == '#')
-        {
-          /* Skip comment to end of line.  */
-          while (*s < end && (c = *(*s)++, c != '\n'))
-            ;
-        }
-      else if (c_isdigit (c))
-        {
-          /* Read decimal number.  */
-          val = c - '0';
-          while (*s < end && (c = *(*s)++, c_isdigit (c)))
-            val = 10 * val + c - '0';
-          break;
-        }
-      else
-        break;
+  if (c_isdigit (c))
+    {
+      /* Read decimal number.  */
+      val = c - '0';
+      while ((c = pbm_next_char (s, end)) != -1 && c_isdigit (c))
+        val = 10 * val + c - '0';
     }
 
   return val;
@@ -9411,6 +9421,14 @@ non-numeric, there is no explicit limit on the size of images.  */);
 #else
         make_number (-1)
 #endif
+        );
+  DEFSYM (Qlibjpeg_version, "libjpeg-version");
+  Fset (Qlibjpeg_version,
+#if HAVE_JPEG
+        make_number (JPEG_LIB_VERSION)
+#else
+        make_number (-1)
+#endif
         );
 #endif
 
diff --git a/src/indent.c b/src/indent.c
index d956e627ba9..891b42788ed 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -118,7 +118,7 @@ disptab_matches_widthtab (struct Lisp_Char_Table *disptab, struct Lisp_Vector *w
 
   for (i = 0; i < 256; i++)
     if (character_width (i, disptab)
-        != XFASTINT (widthtab->u.contents[i]))
+        != XFASTINT (widthtab->contents[i]))
       return 0;
 
   return 1;
@@ -138,7 +138,7 @@ recompute_width_table (struct buffer *buf, struct Lisp_Char_Table *disptab)
   eassert (widthtab->header.size == 256);
 
   for (i = 0; i < 256; i++)
-    XSETFASTINT (widthtab->u.contents[i], character_width (i, disptab));
+    XSETFASTINT (widthtab->contents[i], character_width (i, disptab));
 }
 
 /* Allocate or free the width run cache, as requested by the
@@ -1136,7 +1136,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
   width_run_cache_on_off ();
   if (dp == buffer_display_table ())
     width_table = (VECTORP (BVAR (current_buffer, width_table))
-                   ? XVECTOR (BVAR (current_buffer, width_table))->u.contents
+                   ? XVECTOR (BVAR (current_buffer, width_table))->contents
                    : 0);
   else
     /* If the window has its own display table, we can't use the width
diff --git a/src/insdel.c b/src/insdel.c
index 0eb80c04d99..8de4f095396 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -827,7 +827,7 @@ insert_1_both (const char *string,
 
   eassert (GPT <= GPT_BYTE);
 
-  /* The insert may have been in the unchanged region, so check again. */
+  /* The insert may have been in the unchanged region, so check again.  */
   if (Z - GPT < END_UNCHANGED)
     END_UNCHANGED = Z - GPT;
 
@@ -956,7 +956,7 @@ insert_from_string_1 (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
 
   eassert (GPT <= GPT_BYTE);
 
-  /* The insert may have been in the unchanged region, so check again. */
+  /* The insert may have been in the unchanged region, so check again.  */
   if (Z - GPT < END_UNCHANGED)
     END_UNCHANGED = Z - GPT;
 
@@ -993,6 +993,11 @@ insert_from_gap (ptrdiff_t nchars, ptrdiff_t nbytes, bool text_at_gap_tail)
   if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
     nchars = nbytes;
 
+  /* No need to call prepare_to_modify_buffer, since this is called
+     from places that replace some region with a different text, so
+     prepare_to_modify_buffer was already called by the deletion part
+     of this dance.  */
+  invalidate_buffer_caches (current_buffer, GPT, GPT);
   record_insert (GPT, nchars);
   MODIFF++;
 
@@ -1148,7 +1153,7 @@ insert_from_buffer_1 (struct buffer *buf,
 
   eassert (GPT <= GPT_BYTE);
 
-  /* The insert may have been in the unchanged region, so check again. */
+  /* The insert may have been in the unchanged region, so check again.  */
   if (Z - GPT < END_UNCHANGED)
     END_UNCHANGED = Z - GPT;
 
@@ -1778,6 +1783,8 @@ modify_text (ptrdiff_t start, ptrdiff_t end)
   bset_point_before_scroll (current_buffer, Qnil);
 }
 
+Lisp_Object Qregion_extract_function;
+
 /* Check that it is okay to modify the buffer between START and END,
    which are char positions.
 
@@ -1801,7 +1808,7 @@ prepare_to_modify_buffer_1 (ptrdiff_t start, ptrdiff_t end,
      let redisplay consider other windows if this buffer is visible.  */
   if (XBUFFER (XWINDOW (selected_window)->contents) != current_buffer
       && buffer_window_count (current_buffer))
-    ++windows_or_buffers_changed;
+    windows_or_buffers_changed = 20;
 
   if (buffer_intervals (current_buffer))
     {
@@ -1843,6 +1850,7 @@ prepare_to_modify_buffer_1 (ptrdiff_t start, ptrdiff_t end,
 #endif /* not CLASH_DETECTION */
 
   /* If `select-active-regions' is non-nil, save the region text.  */
+  /* FIXME: Move this to Elisp (via before-change-functions).  */
   if (!NILP (BVAR (current_buffer, mark_active))
       && !inhibit_modification_hooks
       && XMARKER (BVAR (current_buffer, mark))->buffer
@@ -1851,14 +1859,8 @@ prepare_to_modify_buffer_1 (ptrdiff_t start, ptrdiff_t end,
           ? EQ (CAR_SAFE (Vtransient_mark_mode), Qonly)
           : (!NILP (Vselect_active_regions)
              && !NILP (Vtransient_mark_mode))))
-    {
-      ptrdiff_t b = marker_position (BVAR (current_buffer, mark));
-      ptrdiff_t e = PT;
-      if (b < e)
-        Vsaved_region_selection = make_buffer_string (b, e, 0);
-      else if (b > e)
-        Vsaved_region_selection = make_buffer_string (e, b, 0);
-    }
+    Vsaved_region_selection
+      = call1 (Fsymbol_value (Qregion_extract_function), Qnil);
 
   signal_before_change (start, end, preserve_ptr);
   Vdeactivate_mark = Qt;
@@ -1872,19 +1874,26 @@ prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
                           ptrdiff_t *preserve_ptr)
 {
   prepare_to_modify_buffer_1 (start, end, preserve_ptr);
+  invalidate_buffer_caches (current_buffer, start, end);
+}
 
-  if (current_buffer->newline_cache)
-    invalidate_region_cache (current_buffer,
-                             current_buffer->newline_cache,
-                             start - BEG, Z - end);
-  if (current_buffer->width_run_cache)
-    invalidate_region_cache (current_buffer,
-                             current_buffer->width_run_cache,
-                             start - BEG, Z - end);
-  if (current_buffer->bidi_paragraph_cache)
-    invalidate_region_cache (current_buffer,
-                             current_buffer->bidi_paragraph_cache,
-                             start - BEG, Z - end);
+/* Invalidate the caches maintained by the buffer BUF, if any, for the
+   region between buffer positions START and END.  */
+void
+invalidate_buffer_caches (struct buffer *buf, ptrdiff_t start, ptrdiff_t end)
+{
+  if (buf->newline_cache)
+    invalidate_region_cache (buf,
+                             buf->newline_cache,
+                             start - BUF_BEG (buf), BUF_Z (buf) - end);
+  if (buf->width_run_cache)
+    invalidate_region_cache (buf,
+                             buf->width_run_cache,
+                             start - BUF_BEG (buf), BUF_Z (buf) - end);
+  if (buf->bidi_paragraph_cache)
+    invalidate_region_cache (buf,
+                             buf->bidi_paragraph_cache,
+                             start - BUF_BEG (buf), BUF_Z (buf) - end);
 }
 
 /* These macros work with an argument named `preserve_ptr'
@@ -2202,5 +2211,7 @@ as well as hooks attached to text properties and overlays.  */);
   inhibit_modification_hooks = 0;
   DEFSYM (Qinhibit_modification_hooks, "inhibit-modification-hooks");
 
+  DEFSYM (Qregion_extract_function, "region-extract-function");
+
   defsubr (&Scombine_after_change_execute);
 }
diff --git a/src/keyboard.c b/src/keyboard.c
index 0ff4cda034a..450592a07b6 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -821,7 +821,7 @@ This function is called by the editor initialization to begin editing.  */)
     return Qnil;
 
   command_loop_level++;
-  update_mode_lines = 1;
+  update_mode_lines = 17;
 
   if (command_loop_level
       && current_buffer != XBUFFER (XWINDOW (selected_window)->contents))
@@ -848,7 +848,7 @@ recursive_edit_unwind (Lisp_Object buffer)
     Fset_buffer (buffer);
 
   command_loop_level--;
-  update_mode_lines = 1;
+  update_mode_lines = 18;
 }
 
 
@@ -1064,8 +1064,6 @@ cmd_error (Lisp_Object data)
 void
 cmd_error_internal (Lisp_Object data, const char *context)
 {
-  struct frame *sf = SELECTED_FRAME ();
-
   /* The immediate context is not interesting for Quits,
      since they are asynchronous.  */
   if (EQ (XCAR (data), Qquit))
@@ -1079,9 +1077,23 @@ cmd_error_internal (Lisp_Object data, const char *context)
     call3 (Vcommand_error_function, data,
            context ? build_string (context) : empty_unibyte_string,
            Vsignaling_function);
+
+  Vsignaling_function = Qnil;
+}
+
+DEFUN ("command-error-default-function", Fcommand_error_default_function,
+       Scommand_error_default_function, 3, 3, 0,
+       doc: /* Produce default output for unhandled error message.
+Default value of `command-error-function'.  */)
+  (Lisp_Object data, Lisp_Object context, Lisp_Object signal)
+{
+  struct frame *sf = SELECTED_FRAME ();
+
+  CHECK_STRING (context);
+
   /* If the window system or terminal frame hasn't been initialized
      yet, or we're not interactive, write the message to stderr and exit.  */
-  else if (!sf->glyphs_initialized_p
+  if (!sf->glyphs_initialized_p
            /* The initial frame is a special non-displaying frame. It
               will be current in daemon mode when there are no frames
               to display, and in non-daemon mode before the real frame
@@ -1096,7 +1108,7 @@ cmd_error_internal (Lisp_Object data, const char *context)
            || noninteractive)
     {
       print_error_message (data, Qexternal_debugging_output,
-                           context, Vsignaling_function);
+                           SSDATA (context), signal);
       Fterpri (Qexternal_debugging_output);
       Fkill_emacs (make_number (-1));
     }
@@ -1107,10 +1119,9 @@ cmd_error_internal (Lisp_Object data, const char *context)
       message_log_maybe_newline ();
       bitch_at_user ();
 
-      print_error_message (data, Qt, context, Vsignaling_function);
+      print_error_message (data, Qt, SSDATA (context), signal);
     }
-
-  Vsignaling_function = Qnil;
+  return Qnil;
 }
 
 static Lisp_Object command_loop_2 (Lisp_Object);
@@ -1310,6 +1321,8 @@ static void adjust_point_for_property (ptrdiff_t, bool);
 /* The last boundary auto-added to buffer-undo-list.  */
 Lisp_Object last_undo_boundary;
 
+extern Lisp_Object Qregion_extract_function;
+
 /* FIXME: This is wrong rather than test window-system, we should call
    a new set-selection, which will then dispatch to x-set-selection, or
    tty-set-selection, or w32-set-selection, ...  */
@@ -1510,27 +1523,8 @@ command_loop_1 (void)
       already_adjusted = 0;
 
       if (NILP (Vthis_command))
-        {
-          /* nil means key is undefined.  */
-          Lisp_Object keys = Fvector (i, keybuf);
-          keys = Fkey_description (keys, Qnil);
-          bitch_at_user ();
-          message_with_string ("%s is undefined", keys, 0);
-          kset_defining_kbd_macro (current_kboard, Qnil);
-          update_mode_lines = 1;
-          /* If this is a down-mouse event, don't reset prefix-arg;
-             pass it to the command run by the up event.  */
-          if (EVENT_HAS_PARAMETERS (last_command_event))
-            {
-              Lisp_Object breakdown
-                = parse_modifiers (EVENT_HEAD (last_command_event));
-              int modifiers = XINT (XCAR (XCDR (breakdown)));
-              if (!(modifiers & down_modifier))
-                kset_prefix_arg (current_kboard, Qnil);
-            }
-          else
-            kset_prefix_arg (current_kboard, Qnil);
-        }
+        /* nil means key is undefined.  */
+        call0 (Qundefined);
       else
         {
           /* Here for a command that isn't executed directly.  */
@@ -1637,16 +1631,11 @@ command_loop_1 (void)
                   && NILP (Fmemq (Vthis_command,
                                   Vselection_inhibit_update_commands)))
                 {
-                  ptrdiff_t beg =
-                    XINT (Fmarker_position (BVAR (current_buffer, mark)));
-                  ptrdiff_t end = PT;
-                  if (beg < end)
-                    call2 (Qx_set_selection, QPRIMARY,
-                           make_buffer_string (beg, end, 0));
-                  else if (beg > end)
-                    call2 (Qx_set_selection, QPRIMARY,
-                           make_buffer_string (end, beg, 0));
-                  /* Don't set empty selections.  */
+                  Lisp_Object txt
+                    = call1 (Fsymbol_value (Qregion_extract_function), Qnil);
+                  if (XINT (Flength (txt)) > 0)
+                    /* Don't set empty selections.  */
+                    call2 (Qx_set_selection, QPRIMARY, txt);
                 }
 
               if (current_buffer != prev_buffer || MODIFF != prev_modiff)
@@ -1675,7 +1664,7 @@ command_loop_1 (void)
                cluster to prevent automatic composition.  To recover
                the automatic composition, we must update the
                display.  */
-            windows_or_buffers_changed++;
+            windows_or_buffers_changed = 21;
           if (!already_adjusted)
             adjust_point_for_property (last_point_position,
                                        MODIFF != prev_modiff);
@@ -2097,7 +2086,7 @@ bind_polling_period (int n)
 
 /* Apply the control modifier to CHARACTER.  */
 
-#ifndef WINDOWSNT
+#ifndef HAVE_NTGUI
 static
 #endif
 int
@@ -4376,7 +4365,7 @@ decode_timer (Lisp_Object timer, struct timespec *result)
 
   if (! (VECTORP (timer) && ASIZE (timer) == 9))
     return 0;
-  vector = XVECTOR (timer)->u.contents;
+  vector = XVECTOR (timer)->contents;
   if (! NILP (vector[0]))
     return 0;
 
@@ -8006,7 +7995,7 @@ process_tool_bar_item (Lisp_Object key, Lisp_Object def, Lisp_Object data, void
          discard any previously made item.  */
       for (i = 0; i < ntool_bar_items; i += TOOL_BAR_ITEM_NSLOTS)
         {
-          Lisp_Object *v = XVECTOR (tool_bar_items_vector)->u.contents + i;
+          Lisp_Object *v = XVECTOR (tool_bar_items_vector)->contents + i;
 
           if (EQ (key, v[TOOL_BAR_ITEM_KEY]))
             {
@@ -8330,7 +8319,7 @@ append_tool_bar_item (void)
   /* Append entries from tool_bar_item_properties to the end of
      tool_bar_items_vector.  */
   vcopy (tool_bar_items_vector, ntool_bar_items,
-         XVECTOR (tool_bar_item_properties)->u.contents, TOOL_BAR_ITEM_NSLOTS);
+         XVECTOR (tool_bar_item_properties)->contents, TOOL_BAR_ITEM_NSLOTS);
   ntool_bar_items += TOOL_BAR_ITEM_NSLOTS;
 }
 
@@ -9934,7 +9923,7 @@ DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
        doc: /* Return vector of last 300 events, not counting those from keyboard macros.  */)
   (void)
 {
-  Lisp_Object *keys = XVECTOR (recent_keys)->u.contents;
+  Lisp_Object *keys = XVECTOR (recent_keys)->contents;
   Lisp_Object val;
 
   if (total_keys < NUM_RECENT_KEYS)
@@ -9960,7 +9949,7 @@ See also `this-command-keys-vector'.  */)
   (void)
 {
   return make_event_array (this_command_key_count,
-                           XVECTOR (this_command_keys)->u.contents);
+                           XVECTOR (this_command_keys)->contents);
 }
 
 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector, Sthis_command_keys_vector, 0, 0, 0,
@@ -9972,7 +9961,7 @@ See also `this-command-keys'.  */)
   (void)
 {
   return Fvector (this_command_key_count,
-                  XVECTOR (this_command_keys)->u.contents);
+                  XVECTOR (this_command_keys)->contents);
 }
 
 DEFUN ("this-single-command-keys", Fthis_single_command_keys,
@@ -9987,7 +9976,7 @@ The value is always a vector.  */)
 {
   return Fvector (this_command_key_count
                   - this_single_command_key_start,
-                  (XVECTOR (this_command_keys)->u.contents
+                  (XVECTOR (this_command_keys)->contents
                    + this_single_command_key_start));
 }
 
@@ -10001,7 +9990,7 @@ shows the events before all translations (except for input methods).
 The value is always a vector.  */)
   (void)
 {
-  return Fvector (raw_keybuf_count, XVECTOR (raw_keybuf)->u.contents);
+  return Fvector (raw_keybuf_count, XVECTOR (raw_keybuf)->contents);
 }
 
 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths,
@@ -11127,6 +11116,7 @@ syms_of_keyboard (void)
   defsubr (&Sabort_recursive_edit);
   defsubr (&Sexit_recursive_edit);
   defsubr (&Srecursion_depth);
+  defsubr (&Scommand_error_default_function);
   defsubr (&Stop_level);
   defsubr (&Sdiscard_input);
   defsubr (&Sopen_dribble_file);
@@ -11606,13 +11596,13 @@ peculiar kind of quitting.  */);
   Vthrow_on_input = Qnil;
 
   DEFVAR_LISP ("command-error-function", Vcommand_error_function,
-               doc: /* If non-nil, function to output error messages.
-The arguments are the error data, a list of the form
- (SIGNALED-CONDITIONS . SIGNAL-DATA)
-such as just as `condition-case' would bind its variable to,
-the context (a string which normally goes at the start of the message),
-and the Lisp function within which the error was signaled.  */);
-  Vcommand_error_function = Qnil;
+               doc: /* Function to output error messages.
+Called with three arguments:
+- the error data, a list of the form (SIGNALED-CONDITION . SIGNAL-DATA)
+  such as what `condition-case' would bind its variable to,
+- the context (a string which normally goes at the start of the message),
+- the Lisp function within which the error was signaled.  */);
+  Vcommand_error_function = intern ("command-error-default-function");
 
   DEFVAR_LISP ("enable-disabled-menus-and-buttons",
                Venable_disabled_menus_and_buttons,
diff --git a/src/keymap.c b/src/keymap.c
index 7a18cd5d983..562787ee8a5 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -3383,9 +3383,12 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
 
       if (vect[i].shadowed)
         {
-          SET_PT (PT - 1);
+          ptrdiff_t pt = max (PT - 1, BEG);
+
+          SET_PT (pt);
           insert_string ("\n  (that binding is currently shadowed by another mode)");
-          SET_PT (PT + 1);
+          pt = min (PT + 1, Z);
+          SET_PT (pt);
         }
     }
 
diff --git a/src/lisp.h b/src/lisp.h
index e1a6fc7c91a..a5aec41be38 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -45,7 +45,7 @@ INLINE_HEADER_BEGIN
    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).  */
-#ifdef MAIN_PROGRAM
+#if defined MAIN_PROGRAM
 # define DEFINE_GDB_SYMBOL_BEGIN(type, id) type const id EXTERNALLY_VISIBLE
 # define DEFINE_GDB_SYMBOL_END(id) = id;
 #else
@@ -71,7 +71,7 @@ typedef unsigned long long int EMACS_UINT;
 #  define pI "ll"
 # elif INT_MAX < LONG_MAX
 typedef long int EMACS_INT;
-typedef unsigned long int EMACS_UINT;
+typedef unsigned long EMACS_UINT;
 #  define EMACS_INT_MAX LONG_MAX
 #  define pI "l"
 # else
@@ -82,10 +82,26 @@ typedef unsigned int EMACS_UINT;
 # endif
 #endif
 
+/* Number of bits to put in each character in the internal representation
+   of bool vectors.  This should not vary across implementations.  */
+enum {  BOOL_VECTOR_BITS_PER_CHAR =
+#define BOOL_VECTOR_BITS_PER_CHAR 8
+        BOOL_VECTOR_BITS_PER_CHAR
+};
+
 /* An unsigned integer type representing a fixed-length bit sequence,
-   suitable for words in a Lisp bool vector.  */
+   suitable for words in a Lisp bool vector.  Normally it is size_t
+   for speed, but it is unsigned char on weird platforms.  */
+#if BOOL_VECTOR_BITS_PER_CHAR == CHAR_BIT
 typedef size_t bits_word;
-#define BITS_WORD_MAX SIZE_MAX
+# define BITS_WORD_MAX SIZE_MAX
+enum { BITS_PER_BITS_WORD = CHAR_BIT * sizeof (bits_word) };
+#else
+typedef unsigned char bits_word;
+# define BITS_WORD_MAX ((1u << BOOL_VECTOR_BITS_PER_CHAR) - 1)
+enum { BITS_PER_BITS_WORD = BOOL_VECTOR_BITS_PER_CHAR };
+#endif
+verify (BITS_WORD_MAX >> (BITS_PER_BITS_WORD - 1) == 1);
 
 /* Number of bits in some machine integer types.  */
 enum
@@ -94,7 +110,6 @@ enum
     BITS_PER_SHORT     = CHAR_BIT * sizeof (short),
     BITS_PER_INT       = CHAR_BIT * sizeof (int),
     BITS_PER_LONG      = CHAR_BIT * sizeof (long int),
-    BITS_PER_BITS_WORD = CHAR_BIT * sizeof (bits_word),
     BITS_PER_EMACS_INT = CHAR_BIT * sizeof (EMACS_INT)
   };
 
@@ -406,8 +421,10 @@ enum enum_USE_LSB_TAG { USE_LSB_TAG = 0 };
 #define case_Lisp_Int case Lisp_Int0: case Lisp_Int1
 
 /* Idea stolen from GDB.  Pedantic GCC complains about enum bitfields,
-   MSVC doesn't support them, and xlc complains vociferously about them.  */
-#if defined __STRICT_ANSI__ || defined _MSC_VER || defined __IBMC__
+   MSVC doesn't support them, and xlc and Oracle Studio c99 complain
+   vociferously about them.  */
+#if (defined __STRICT_ANSI__ || defined _MSC_VER || defined __IBMC__ \
+     || (defined __SUNPRO_C && __STDC__))
 #define ENUM_BF(TYPE) unsigned int
 #else
 #define ENUM_BF(TYPE) enum TYPE
@@ -614,10 +631,6 @@ enum More_Lisp_Bits
     /* Used to extract pseudovector subtype information.  */
     PSEUDOVECTOR_AREA_BITS = PSEUDOVECTOR_SIZE_BITS + PSEUDOVECTOR_REST_BITS,
     PVEC_TYPE_MASK = 0x3f << PSEUDOVECTOR_AREA_BITS,
-
-    /* Number of bits to put in each character in the internal representation
-       of bool vectors.  This should not vary across implementations.  */
-    BOOL_VECTOR_BITS_PER_CHAR = 8
   };
 
 /* These functions extract various sorts of values from a Lisp_Object.
@@ -775,7 +788,7 @@ extern int char_table_translate (Lisp_Object, int);
 /* Defined in data.c.  */
 extern Lisp_Object Qarrayp, Qbufferp, Qbuffer_or_string_p, Qchar_table_p;
 extern Lisp_Object Qconsp, Qfloatp, Qintegerp, Qlambda, Qlistp, Qmarkerp, Qnil;
-extern Lisp_Object Qnumberp, Qstringp, Qsymbolp, Qvectorp;
+extern Lisp_Object Qnumberp, Qstringp, Qsymbolp, Qt, Qvectorp;
 extern Lisp_Object Qbool_vector_p;
 extern Lisp_Object Qvector_or_char_table_p, Qwholenump;
 extern Lisp_Object Qwindow;
@@ -1150,7 +1163,7 @@ STRING_COPYIN (Lisp_Object string, ptrdiff_t index, char const *new,
    and PSEUDOVECTORP cast their pointers to struct vectorlike_header *,
    because when two such pointers potentially alias, a compiler won't
    incorrectly reorder loads and stores to their size fields.  See
-   <http://debbugs.gnu.org/cgi/bugreport.cgi?bug=8546>.  */
+   Bug#8546.  */
 struct vectorlike_header
   {
     /* The only field contains various pieces of information:
@@ -1175,22 +1188,22 @@ struct vectorlike_header
     ptrdiff_t size;
   };
 
-/* Regular vector is just a header plus array of Lisp_Objects...  */
+/* A regular vector is just a header plus an array of Lisp_Objects.  */
 
 struct Lisp_Vector
   {
     struct vectorlike_header header;
-    union {
-      /* ...but sometimes there is also a pointer internally used in
-         vector allocation code.  Usually you don't want to touch this.  */
-      struct Lisp_Vector *next;
+    Lisp_Object contents[FLEXIBLE_ARRAY_MEMBER];
+  };
 
-      /* We can't use FLEXIBLE_ARRAY_MEMBER here.  */
-      Lisp_Object contents[1];
-    } u;
+/* C11 prohibits alignof (struct Lisp_Vector), so compute it manually.  */
+enum
+  {
+    ALIGNOF_STRUCT_LISP_VECTOR
+      = alignof (union { struct vectorlike_header a; Lisp_Object b; })
   };
 
-/* A boolvector is a kind of vectorlike, with contents are like a string.  */
+/* A boolvector is a kind of vectorlike, with contents like a string.  */
 
 struct Lisp_Bool_Vector
   {
@@ -1199,8 +1212,10 @@ struct Lisp_Bool_Vector
     struct vectorlike_header header;
     /* This is the size in bits.  */
     EMACS_INT size;
-    /* This contains the actual bits, packed into bytes.  */
-    unsigned char data[FLEXIBLE_ARRAY_MEMBER];
+    /* The actual bits, packed into bytes.
+       The bits are in little-endian order in the bytes, and
+       the bytes are in little-endian order in the words.  */
+    bits_word data[FLEXIBLE_ARRAY_MEMBER];
   };
 
 INLINE EMACS_INT
@@ -1211,12 +1226,72 @@ bool_vector_size (Lisp_Object a)
   return size;
 }
 
+INLINE bits_word *
+bool_vector_data (Lisp_Object a)
+{
+  return XBOOL_VECTOR (a)->data;
+}
+
+INLINE unsigned char *
+bool_vector_uchar_data (Lisp_Object a)
+{
+  return (unsigned char *) bool_vector_data (a);
+}
+
+/* The number of data words and bytes in a bool vector with SIZE bits.  */
+
+INLINE EMACS_INT
+bool_vector_words (EMACS_INT size)
+{
+  eassume (0 <= size && size <= EMACS_INT_MAX - (BITS_PER_BITS_WORD - 1));
+  return (size + BITS_PER_BITS_WORD - 1) / BITS_PER_BITS_WORD;
+}
+
+INLINE EMACS_INT
+bool_vector_bytes (EMACS_INT size)
+{
+  eassume (0 <= size && size <= EMACS_INT_MAX - (BITS_PER_BITS_WORD - 1));
+  return (size + BOOL_VECTOR_BITS_PER_CHAR - 1) / BOOL_VECTOR_BITS_PER_CHAR;
+}
+
+/* True if A's Ith bit is set.  */
+
+INLINE bool
+bool_vector_bitref (Lisp_Object a, EMACS_INT i)
+{
+  eassume (0 <= i && i < bool_vector_size (a));
+  return !! (bool_vector_uchar_data (a)[i / BOOL_VECTOR_BITS_PER_CHAR]
+             & (1 << (i % BOOL_VECTOR_BITS_PER_CHAR)));
+}
+
+INLINE Lisp_Object
+bool_vector_ref (Lisp_Object a, EMACS_INT i)
+{
+  return bool_vector_bitref (a, i) ? Qt : Qnil;
+}
+
+/* Set A's Ith bit to B.  */
+
+INLINE void
+bool_vector_set (Lisp_Object a, EMACS_INT i, bool b)
+{
+  unsigned char *addr;
+
+  eassume (0 <= i && i < bool_vector_size (a));
+  addr = &bool_vector_uchar_data (a)[i / BOOL_VECTOR_BITS_PER_CHAR];
+
+  if (b)
+    *addr |= 1 << (i % BOOL_VECTOR_BITS_PER_CHAR);
+  else
+    *addr &= ~ (1 << (i % BOOL_VECTOR_BITS_PER_CHAR));
+}
+
 /* Some handy constants for calculating sizes
    and offsets, mostly of vectorlike objects.   */
 
 enum
   {
-    header_size = offsetof (struct Lisp_Vector, u.contents),
+    header_size = offsetof (struct Lisp_Vector, contents),
     bool_header_size = offsetof (struct Lisp_Bool_Vector, data),
     word_size = sizeof (Lisp_Object)
   };
@@ -1226,13 +1301,13 @@ enum
 INLINE Lisp_Object
 AREF (Lisp_Object array, ptrdiff_t idx)
 {
-  return XVECTOR (array)->u.contents[idx];
+  return XVECTOR (array)->contents[idx];
 }
 
 INLINE Lisp_Object *
 aref_addr (Lisp_Object array, ptrdiff_t idx)
 {
-  return & XVECTOR (array)->u.contents[idx];
+  return & XVECTOR (array)->contents[idx];
 }
 
 INLINE ptrdiff_t
@@ -1245,7 +1320,7 @@ INLINE void
 ASET (Lisp_Object array, ptrdiff_t idx, Lisp_Object val)
 {
   eassert (0 <= idx && idx < ASIZE (array));
-  XVECTOR (array)->u.contents[idx] = val;
+  XVECTOR (array)->contents[idx] = val;
 }
 
 INLINE void
@@ -1254,7 +1329,7 @@ gc_aset (Lisp_Object array, ptrdiff_t idx, Lisp_Object val)
   /* Like ASET, but also can be used in the garbage collector:
      sweep_weak_table calls set_hash_key etc. while the table is marked.  */
   eassert (0 <= idx && idx < (ASIZE (array) & ~ARRAY_MARK_FLAG));
-  XVECTOR (array)->u.contents[idx] = val;
+  XVECTOR (array)->contents[idx] = val;
 }
 
 /* If a struct is made to look like a vector, this macro returns the length
@@ -1758,14 +1833,14 @@ struct Lisp_Misc_Any		/* Supertype of all Misc types.  */
 {
   ENUM_BF (Lisp_Misc_Type) type : 16;           /* = Lisp_Misc_??? */
   unsigned gcmarkbit : 1;
-  int spacer : 15;
+  unsigned spacer : 15;
 };
 
 struct Lisp_Marker
 {
   ENUM_BF (Lisp_Misc_Type) type : 16;           /* = Lisp_Misc_Marker */
   unsigned gcmarkbit : 1;
-  int spacer : 13;
+  unsigned spacer : 13;
   /* This flag is temporarily used in the functions
      decode/encode_coding_object to record that the marker position
      must be adjusted after the conversion.  */
@@ -1819,7 +1894,7 @@ struct Lisp_Overlay
   {
     ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Overlay */
     unsigned gcmarkbit : 1;
-    int spacer : 15;
+    unsigned spacer : 15;
     struct Lisp_Overlay *next;
     Lisp_Object start;
     Lisp_Object end;
@@ -1897,7 +1972,7 @@ struct Lisp_Save_Value
   {
     ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Save_Value */
     unsigned gcmarkbit : 1;
-    int spacer : 32 - (16 + 1 + SAVE_TYPE_BITS);
+    unsigned spacer : 32 - (16 + 1 + SAVE_TYPE_BITS);
 
     /* V->data may hold up to SAVE_VALUE_SLOTS entries.  The type of
        V's data entries are determined by V->save_type.  E.g., if
@@ -1973,7 +2048,7 @@ struct Lisp_Free
   {
     ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Free */
     unsigned gcmarkbit : 1;
-    int spacer : 15;
+    unsigned spacer : 15;
     union Lisp_Misc *chain;
   };
 
@@ -2737,7 +2812,7 @@ union specbinding
     } let;
     struct {
       ENUM_BF (specbind_tag) kind : CHAR_BIT;
-      bool debug_on_exit : 1;
+      unsigned debug_on_exit : 1;
       Lisp_Object function;
       Lisp_Object *args;
       ptrdiff_t nargs;
@@ -2807,14 +2882,13 @@ struct handler
 
 /* Fill in the components of c, and put it on the list.  */
 #define PUSH_HANDLER(c, tag_ch_val, handlertype)        \
-  if (handlerlist && handlerlist->nextfree)             \
+  if (handlerlist->nextfree)                            \
     (c) = handlerlist->nextfree;                        \
   else                                                  \
     {                                                   \
       (c) = xmalloc (sizeof (struct handler));          \
       (c)->nextfree = NULL;                             \
-      if (handlerlist)                                  \
-        handlerlist->nextfree = (c);                    \
+      handlerlist->nextfree = (c);                      \
     }                                                   \
   (c)->type = (handlertype);                            \
   (c)->tag_or_ch = (tag_ch_val);                        \
@@ -3089,7 +3163,7 @@ INLINE void
 vcopy (Lisp_Object v, ptrdiff_t offset, Lisp_Object *args, ptrdiff_t count)
 {
   eassert (0 <= offset && 0 <= count && offset + count <= ASIZE (v));
-  memcpy (XVECTOR (v)->u.contents + offset, args, count * sizeof *args);
+  memcpy (XVECTOR (v)->contents + offset, args, count * sizeof *args);
 }
 
 /* Functions to modify hash tables.  */
@@ -3405,6 +3479,7 @@ extern Lisp_Object del_range_2 (ptrdiff_t, ptrdiff_t,
 extern void modify_text (ptrdiff_t, ptrdiff_t);
 extern void prepare_to_modify_buffer (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
 extern void prepare_to_modify_buffer_1 (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
+extern void invalidate_buffer_caches (struct buffer *, ptrdiff_t, ptrdiff_t);
 extern void signal_after_change (ptrdiff_t, ptrdiff_t, ptrdiff_t);
 extern void adjust_after_insert (ptrdiff_t, ptrdiff_t, ptrdiff_t,
                                  ptrdiff_t, ptrdiff_t);
@@ -3461,7 +3536,6 @@ extern void update_echo_area (void);
 extern void truncate_echo_area (ptrdiff_t);
 extern void redisplay (void);
 extern void redisplay_preserve_echo_area (int);
-extern void prepare_menu_bars (void);
 
 void set_frame_cursor_types (struct frame *, Lisp_Object);
 extern void syms_of_xdisp (void);
@@ -3524,6 +3598,8 @@ list4i (EMACS_INT x, EMACS_INT y, EMACS_INT w, EMACS_INT h)
                 make_number (w), make_number (h));
 }
 
+extern Lisp_Object make_uninit_bool_vector (EMACS_INT);
+extern Lisp_Object bool_vector_fill (Lisp_Object, Lisp_Object);
 extern _Noreturn void string_overflow (void);
 extern Lisp_Object make_string (const char *, ptrdiff_t);
 extern Lisp_Object make_formatted_string (char *, const char *, ...)
@@ -4417,10 +4493,6 @@ functionp (Lisp_Object object)
     return 0;
 }
 
-/* Round x to the next multiple of y.  Does not overflow.  Evaluates
-   arguments repeatedly.  */
-#define ROUNDUP(x,y) ((y)*((x)/(y) + ((x)%(y)!=0)))
-
 INLINE_HEADER_END
 
 #endif /* EMACS_LISP_H */
diff --git a/src/lread.c b/src/lread.c
index fe2b92a34b3..6c1b17f62b7 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1500,7 +1500,8 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
       for (tail = NILP (suffixes) ? list1 (empty_unibyte_string) : suffixes;
            CONSP (tail); tail = XCDR (tail))
         {
-          ptrdiff_t fnlen, lsuffix = SBYTES (XCAR (tail));
+          Lisp_Object suffix = XCAR (tail);
+          ptrdiff_t fnlen, lsuffix = SBYTES (suffix);
           Lisp_Object handler;
 
           /* Concatenate path element/specified name with the suffix.
@@ -1511,7 +1512,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
                            ? 2 : 0);
           fnlen = SBYTES (filename) - prefixlen;
           memcpy (fn, SDATA (filename) + prefixlen, fnlen);
-          memcpy (fn + fnlen, SDATA (XCAR (tail)), lsuffix + 1);
+          memcpy (fn + fnlen, SDATA (suffix), lsuffix + 1);
           fnlen += lsuffix;
           /* Check that the file exists and is not a directory.  */
           /* We used to only check for handlers on non-absolute file names:
@@ -1521,7 +1522,18 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
                   handler = Ffind_file_name_handler (filename, Qfile_exists_p);
              It's not clear why that was the case and it breaks things like
              (load "/bar.el") where the file is actually "/bar.el.gz".  */
-          string = make_string (fn, fnlen);
+          /* make_string has its own ideas on when to return a unibyte
+             string and when a multibyte string, but we know better.
+             We must have a unibyte string when dumping, since
+             file-name encoding is shaky at best at that time, and in
+             particular default-file-name-coding-system is reset
+             several times during loadup.  We therefore don't want to
+             encode the file before passing it to file I/O library
+             functions.  */
+          if (!STRING_MULTIBYTE (filename) && !STRING_MULTIBYTE (suffix))
+            string = make_unibyte_string (fn, fnlen);
+          else
+            string = make_string (fn, fnlen);
           handler = Ffind_file_name_handler (string, Qfile_exists_p);
           if ((!NILP (handler) || !NILP (predicate)) && !NATNUMP (predicate))
             {
@@ -2565,9 +2577,8 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
           if (c == '"')
             {
               Lisp_Object tmp, val;
-              EMACS_INT size_in_chars
-                = ((XFASTINT (length) + BOOL_VECTOR_BITS_PER_CHAR - 1)
-                   / BOOL_VECTOR_BITS_PER_CHAR);
+              EMACS_INT size_in_chars = bool_vector_bytes (XFASTINT (length));
+              unsigned char *data;
 
               UNREAD (c);
               tmp = read1 (readcharfun, pch, first_in_list);
@@ -2581,11 +2592,12 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
                             == (SCHARS (tmp) - 1) * BOOL_VECTOR_BITS_PER_CHAR)))
                 invalid_syntax ("#&...");
 
-              val = Fmake_bool_vector (length, Qnil);
-              memcpy (XBOOL_VECTOR (val)->data, SDATA (tmp), size_in_chars);
+              val = make_uninit_bool_vector (XFASTINT (length));
+              data = bool_vector_uchar_data (val);
+              memcpy (data, SDATA (tmp), size_in_chars);
               /* Clear the extraneous bits in the last byte.  */
               if (XINT (length) != size_in_chars * BOOL_VECTOR_BITS_PER_CHAR)
-                XBOOL_VECTOR (val)->data[size_in_chars - 1]
+                data[size_in_chars - 1]
                   &= (1 << (XINT (length) % BOOL_VECTOR_BITS_PER_CHAR)) - 1;
               return val;
             }
@@ -3462,7 +3474,7 @@ read_vector (Lisp_Object readcharfun, bool bytecodeflag)
   vector = Fmake_vector (len, Qnil);
 
   size = ASIZE (vector);
-  ptr = XVECTOR (vector)->u.contents;
+  ptr = XVECTOR (vector)->contents;
   for (i = 0; i < size; i++)
     {
       item = Fcar (tem);
diff --git a/src/macfont.h b/src/macfont.h
index 141d60bfb0a..4b57c18692e 100644
--- a/src/macfont.h
+++ b/src/macfont.h
@@ -134,6 +134,9 @@ enum {
 
 #define mac_nsctfont_copy_font_descriptor CTFontCopyFontDescriptor
 
+#ifndef kCTVersionNumber10_9
+#define kCTVersionNumber10_9 0x00060000
+#endif
 #define MAC_FONT_CHARACTER_SET_STRING_ATTRIBUTE \
   (CFSTR ("MAC_FONT_CHARACTER_SET_STRING_ATTRIBUTE"))
 
diff --git a/src/macfont.m b/src/macfont.m
index b3bf96d8c4e..10623eb12fe 100644
--- a/src/macfont.m
+++ b/src/macfont.m
@@ -57,6 +57,13 @@ static Boolean mac_ctfont_descriptor_supports_languages (CTFontDescriptorRef,
 static CFStringRef mac_ctfont_create_preferred_family_for_attributes (CFDictionaryRef);
 static CFIndex mac_ctfont_shape (CTFontRef, CFStringRef,
                                  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);
+
 #if USE_CT_GLYPH_INFO
 static CGGlyph mac_ctfont_get_glyph_for_cid (CTFontRef,
                                              CTCharacterCollection,
@@ -64,7 +71,7 @@ static CGGlyph mac_ctfont_get_glyph_for_cid (CTFontRef,
 #endif
 
 /* The font property key specifying the font design destination.  The
-   value is an unsigned integer code: 0 for WYSIWIG, and 1 for Video
+   value is an unsigned integer code: 0 for WYSIWYG, and 1 for Video
    text.  (See the documentation of X Logical Font Description
    Conventions.)  In the Mac font driver, 1 means the screen font is
    used for calculating some glyph metrics.  You can see the
@@ -366,7 +373,7 @@ mac_font_shape_1 (NSFont *font, NSString *string,
   if (!(textStorage && layoutManager && textContainer))
     {
       [textStorage release];
-      
+
       return 0;
     }
 
@@ -624,19 +631,26 @@ get_cgcolor(unsigned long idx, struct frame *f)
 }
 
 #define CG_SET_FILL_COLOR_WITH_GC_FOREGROUND(context, s)                \
-  CGContextSetFillColorWithColor (context,                              \
-                                  get_cgcolor (NS_FACE_FOREGROUND (s->face), \
-                                               s->f))
-
+  do {                                                                  \
+    CGColorRef refcol_ = get_cgcolor (NS_FACE_FOREGROUND (s->face),     \
+                                      s->f);                            \
+    CGContextSetFillColorWithColor (context, refcol_) ;                 \
+    CGColorRelease (refcol_);                                           \
+  } while (0)
 #define CG_SET_FILL_COLOR_WITH_GC_BACKGROUND(context, s)                \
-  CGContextSetFillColorWithColor (context,                              \
-                                  get_cgcolor (NS_FACE_BACKGROUND (s->face), \
-                                               s->f))
-
+  do {                                                                  \
+    CGColorRef refcol_ = get_cgcolor (NS_FACE_BACKGROUND (s->face),\
+                                      s->f);                            \
+    CGContextSetFillColorWithColor (context, refcol_);                  \
+    CGColorRelease (refcol_);                                           \
+  } while (0)
 #define CG_SET_STROKE_COLOR_WITH_GC_FOREGROUND(context, s)              \
-  CGContextSetStrokeColorWithColor (context,                            \
-                                    get_cgcolor (NS_FACE_FOREGROUND (s->face),\
-                                                 s->f))
+  do {                                                                  \
+    CGColorRef refcol_ = get_cgcolor (NS_FACE_FOREGROUND (s->face),\
+                                      s->f);                            \
+    CGContextSetStrokeColorWithColor (context, refcol_);                \
+    CGColorRelease (refcol_);                                           \
+  } while (0)
 
 
 /* Mac font driver.  */
@@ -669,7 +683,7 @@ static struct
     { "iso8859-15", { 0x00A0, 0x00A1, 0x00D0, 0x0152 }},
     { "iso8859-16", { 0x00A0, 0x0218}},
     { "gb2312.1980-0", { 0x4E13 }, CFSTR ("zh-Hans")},
-    { "big5-0", { /* 0xF6B1 in ftfont.c */ 0xF7E5 }, CFSTR ("zh-Hant") },
+    { "big5-0", { /* 0xF6B1 in ftfont.c */ 0x4EDC }, CFSTR ("zh-Hant") },
     { "jisx0208.1983-0", { 0x4E55 }, CFSTR ("ja")},
     { "ksc5601.1987-0", { 0xAC00 }, CFSTR ("ko")},
     { "cns11643.1992-1", { 0xFE32 }, CFSTR ("zh-Hant")},
@@ -693,9 +707,31 @@ static struct
     { NULL }
   };
 
+#if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
+static const struct
+{
+  CFStringRef language;
+  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 ("ko"), { CFSTR ("AppleSDGothicNeo-Regular"), /* 10.8 - 10.9 */
+                    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 ("zh-Hant"), { CFSTR ("STHeitiTC-Light"), /* 10.6 - 10.9 */
+                         CFSTR ("LiHeiPro"),        /* 10.4 - 10.5 */
+                         NULL }},
+  { NULL }
+};
+#endif
+
 static CGFloat macfont_antialias_threshold;
 
-void
+static void
 macfont_update_antialias_threshold (void)
 {
   int threshold;
@@ -1159,7 +1195,7 @@ struct macfont_cache
 
     /* The cached glyph for a character c is stored as the (c %
        NGLYPHS_IN_VALUE)-th CGGlyph block of a value for the key (c /
-       NGLYPHS_IN_VALUE).  However, the glyph for a BMP characrer c is
+       NGLYPHS_IN_VALUE).  However, the glyph for a BMP character c is
        not stored here if row_nkeys_or_perm[c / 256] >=
        ROW_PERM_OFFSET.  */
     CFMutableDictionaryRef dictionary;
@@ -1518,7 +1554,7 @@ static Lisp_Object macfont_match (struct frame *, Lisp_Object);
 static Lisp_Object macfont_list_family (struct frame *);
 static void macfont_free_entity (Lisp_Object);
 static Lisp_Object macfont_open (struct frame *, Lisp_Object, int);
-static void macfont_close (struct frame *, struct font *);
+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,
@@ -2045,33 +2081,7 @@ macfont_list (struct frame *f, Lisp_Object spec)
   if (! attributes)
     goto finish;
 
-  charset = ((CFCharacterSetRef)
-             CFDictionaryGetValue (attributes,
-                                   MAC_FONT_CHARACTER_SET_ATTRIBUTE));
-  if (charset)
-    {
-      CFRetain (charset);
-      CFDictionaryRemoveValue (attributes, MAC_FONT_CHARACTER_SET_ATTRIBUTE);
-    }
-  else
-    {
-      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 = Qnil;
-    }
-
-  languages = ((CFArrayRef)
-               CFDictionaryGetValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE));
-  if (languages)
-    {
-      CFRetain (languages);
-      CFDictionaryRemoveValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE);
-    }
+  languages = CFDictionaryGetValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE);
 
   if (INTEGERP (AREF (spec, FONT_SPACING_INDEX)))
     spacing = XINT (AREF (spec, FONT_SPACING_INDEX));
@@ -2155,6 +2165,31 @@ macfont_list (struct frame *f, Lisp_Object spec)
         }
     }
 
+  charset = CFDictionaryGetValue (attributes,
+                                  MAC_FONT_CHARACTER_SET_ATTRIBUTE);
+  if (charset)
+    {
+      CFRetain (charset);
+      CFDictionaryRemoveValue (attributes, MAC_FONT_CHARACTER_SET_ATTRIBUTE);
+    }
+  else
+    {
+      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 = Qnil;
+    }
+
+  if (languages)
+    {
+      CFRetain (languages);
+      CFDictionaryRemoveValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE);
+    }
+
   val = Qnil;
   extra = AREF (spec, FONT_EXTRA_INDEX);
   families_count = CFArrayGetCount (families);
@@ -2465,7 +2500,7 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
   macfont_info = (struct macfont_info *) font;
   macfont_info->macfont = macfont;
   macfont_info->cgfont = mac_font_copy_graphics_font (macfont);
-  
+
   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,
@@ -2580,7 +2615,7 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
 }
 
 static void
-macfont_close (struct frame * f, struct font *font)
+macfont_close (struct font *font)
 {
   struct macfont_info *macfont_info = (struct macfont_info *) font;
   int i;
@@ -2667,7 +2702,7 @@ macfont_text_extents (struct font *font, unsigned int *code, int nglyphs,
     }
   unblock_input ();
 
-  if (metrics) 
+  if (metrics)
     metrics->width = width;
 
   return width;
@@ -2729,7 +2764,7 @@ macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
       for (i = 0; i < len; i++)
         {
           int width;
- 
+
           glyphs[i] = *(s->char2b + s->cmp_from + i);
           width = (s->padding_p ? 1
                    : macfont_glyph_extents (s->font, glyphs[i],
@@ -2786,7 +2821,7 @@ macfont_draw (struct glyph_string *s, int from, int to, int x, int y,
   return len;
 }
 
-Lisp_Object
+static Lisp_Object
 macfont_shape (Lisp_Object lgstring)
 {
   struct font *font;
@@ -2989,7 +3024,7 @@ struct non_default_uvs_table
 #define BUINT32_VALUE(lval)     OSReadBigInt32 (&(lval), 0)
 
 /* Return UVS subtable for the specified FONT.  If the subtable is not
-   found or ill-formated, then return NULL.  */
+   found or ill-formatted, then return NULL.  */
 
 static CFDataRef
 mac_font_copy_uvs_table (FontRef font)
@@ -3323,49 +3358,80 @@ mac_ctfont_create_preferred_family_for_attributes (CFDictionaryRef attributes)
 
   if (charset_string && CFStringGetLength (charset_string) > 0)
     {
-      CFAttributedStringRef attr_string = NULL;
-      CTLineRef ctline = NULL;
-      CFDictionaryRef attrs =
-        CFDictionaryCreate (NULL, NULL, NULL, 0,
-                            &kCFTypeDictionaryKeyCallBacks,
-                            &kCFTypeDictionaryValueCallBacks);
+      CFStringRef keys[] = {
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
+        kCTLanguageAttributeName
+#else
+        CFSTR ("NSLanguage")
+#endif
+      };
+      CFTypeRef values[] = {NULL};
+      CFIndex num_values = 0;
+      CFArrayRef languages
+        = CFDictionaryGetValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE);
 
-      if (attrs)
-        {
-          attr_string = CFAttributedStringCreate (NULL, charset_string, attrs);
-          CFRelease (attrs);
-        }
-      if (attr_string)
+      if (languages && CFArrayGetCount (languages) > 0)
         {
-          ctline = CTLineCreateWithAttributedString (attr_string);
-          CFRelease (attr_string);
+          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 (ctline)
+      if (result == NULL)
         {
-          CFArrayRef runs = CTLineGetGlyphRuns (ctline);
-          CFIndex i, nruns = CFArrayGetCount (runs);
-          CTFontRef font;
-
-          for (i = 0; i < nruns; i++)
+          CFAttributedStringRef attr_string = NULL;
+          CTLineRef ctline = NULL;
+          CFDictionaryRef attrs
+            = CFDictionaryCreate (NULL, (const void **) keys,
+                                  (const void **) values, num_values,
+                                  &kCFTypeDictionaryKeyCallBacks,
+                                  &kCFTypeDictionaryValueCallBacks);
+
+          if (attrs)
             {
-              CTRunRef run = CFArrayGetValueAtIndex (runs, i);
-              CFDictionaryRef attributes = CTRunGetAttributes (run);
-              CTFontRef font_in_run;
+              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;
 
-              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;
+              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);
             }
-          if (nruns > 0 && i == nruns)
-            result = CTFontCopyAttribute (font, kCTFontFamilyNameAttribute);
-          CFRelease (ctline);
         }
     }
 
@@ -3559,7 +3625,7 @@ mac_ctfont_create_line_with_string_and_font (CFStringRef string,
   return ctline;
 }
 
-CFIndex
+static CFIndex
 mac_ctfont_shape (CTFontRef font, CFStringRef string,
                   struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len)
 {
@@ -3712,7 +3778,7 @@ mac_ctfont_shape (CTFontRef font, CFStringRef string,
    created by CFStringCreateWithCharacters as of Mac OS X 10.5.8 and
    10.6.3.  For now, we use the NSGlyphInfo version instead.  */
 #if USE_CT_GLYPH_INFO
-CGGlyph
+static CGGlyph
 mac_ctfont_get_glyph_for_cid (CTFontRef font, CTCharacterCollection collection,
                               CGFontIndex cid)
 {
@@ -3805,7 +3871,7 @@ mac_font_family_group (CFStringRef family)
     }
 }
 
-CFComparisonResult
+static CFComparisonResult
 mac_font_family_compare (const void *val1, const void *val2, void *context)
 {
   CFStringRef family1 = (CFStringRef) val1, family2 = (CFStringRef) val2;
@@ -3821,6 +3887,142 @@ mac_font_family_compare (const void *val1, const void *val2, void *context)
 }
 #endif  /* MAC_OS_X_VERSION_MIN_REQUIRED < 1060 */
 
+static CFArrayRef
+mac_font_copy_default_descriptors_for_language (CFStringRef language)
+{
+  CFArrayRef result = NULL;
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
+#if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
+  if (CTFontCopyDefaultCascadeListForLanguages != NULL)
+#endif
+    {
+      CTFontRef user_font =
+        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);
+        }
+    }
+#if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
+  else          /* CTFontCopyDefaultCascadeListForLanguages == NULL */
+#endif
+#endif  /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1080 */
+#if MAC_OS_X_VERSION_MIN_REQUIRED < 1080
+    {
+      CFIndex i;
+
+      for (i = 0; macfont_language_default_font_names[i].language; i++)
+        {
+          if (CFStringCompare (macfont_language_default_font_names[i].language,
+                               language, 0) == kCFCompareEqualTo)
+            {
+              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
+
+  return result;
+}
+
+static CFStringRef
+mac_font_copy_default_name_for_charset_and_languages (CFCharacterSetRef charset,
+                                                      CFArrayRef languages)
+{
+  CFStringRef result = NULL;
+  CFStringRef language = CFArrayGetValueAtIndex (languages, 0);
+  CFArrayRef descriptors =
+    mac_font_copy_default_descriptors_for_language (language);
+
+  if (descriptors)
+    {
+      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 ("."))
+                      && (CFStringCompare (family, CFSTR ("LastResort"), 0)
+                          != kCFCompareEqualTo))
+                    {
+                      result = family;
+                      break;
+                    }
+                  else
+                    CFRelease (family);
+                }
+            }
+        }
+      CFRelease (descriptors);
+    }
+
+  return result;
+}
+
 void *
 macfont_get_nsctfont (struct font *font)
 {
diff --git a/src/macros.c b/src/macros.c
index 0c11efcdc9a..232188a408b 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -55,7 +55,7 @@ Use \\[name-last-kbd-macro] to give it a permanent name.
 Non-nil arg (prefix arg) means append to last macro defined;
 this begins by re-executing that macro as if you typed it again.
 If optional second arg, NO-EXEC, is non-nil, do not re-execute last
-macro before appending to it. */)
+macro before appending to it.  */)
   (Lisp_Object append, Lisp_Object no_exec)
 {
   if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
@@ -66,7 +66,7 @@ macro before appending to it. */)
       current_kboard->kbd_macro_buffer = xmalloc (30 * word_size);
       current_kboard->kbd_macro_bufsize = 30;
     }
-  update_mode_lines++;
+  update_mode_lines = 19;
   if (NILP (append))
     {
       if (current_kboard->kbd_macro_bufsize > 200)
@@ -138,7 +138,7 @@ void
 end_kbd_macro (void)
 {
   kset_defining_kbd_macro (current_kboard, Qnil);
-  update_mode_lines++;
+  update_mode_lines = 20;
   kset_last_kbd_macro
     (current_kboard,
      make_event_array ((current_kboard->kbd_macro_end
diff --git a/src/menu.h b/src/menu.h
index 17d66290647..cd89f5eecea 100644
--- a/src/menu.h
+++ b/src/menu.h
@@ -51,7 +51,7 @@ extern Lisp_Object ns_menu_show (struct frame *, int, int, bool, bool,
                                  Lisp_Object, const char **);
 extern Lisp_Object xmenu_show (struct frame *, int, int, bool, bool,
                                Lisp_Object, const char **);
-extern Lisp_Object tty_menu_show (struct frame *, int, int, int, int,
-                                  Lisp_Object, int, const char **);
+extern Lisp_Object tty_menu_show (struct frame *, int, int, bool, bool,
+                                  Lisp_Object, bool, const char **);
 extern ptrdiff_t menu_item_width (const unsigned char *);
 #endif /* MENU_H */
diff --git a/src/minibuf.c b/src/minibuf.c
index cc6f234f7da..8eb1a2890e0 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -866,7 +866,7 @@ read_minibuf_unwind (void)
     resize_mini_window (XWINDOW (window), 0);
 
   /* Enforce full redisplay.  FIXME: make it more selective.  */
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 22;
 
   /* In case the previous minibuffer displayed in this miniwindow is
      dead, we may keep displaying this buffer (tho it's inactive), so reset it,
@@ -1199,9 +1199,7 @@ is used to further constrain the set of candidates.  */)
     type = (HASH_TABLE_P (collection) ? hash_table
             : VECTORP (collection) ? obarray_table
             : ((NILP (collection)
-                || (CONSP (collection)
-                    && (!SYMBOLP (XCAR (collection))
-                        || NILP (XCAR (collection)))))
+                || (CONSP (collection) && !FUNCTIONP (collection)))
                ? list_table : function_table));
   ptrdiff_t idx = 0, obsize = 0;
   int matchcount = 0;
@@ -1460,9 +1458,7 @@ with a space are ignored unless STRING itself starts with a space.  */)
   Lisp_Object allmatches;
   int type = HASH_TABLE_P (collection) ? 3
     : VECTORP (collection) ? 2
-    : NILP (collection) || (CONSP (collection)
-                            && (!SYMBOLP (XCAR (collection))
-                                || NILP (XCAR (collection))));
+    : NILP (collection) || (CONSP (collection) && !FUNCTIONP (collection));
   ptrdiff_t idx = 0, obsize = 0;
   ptrdiff_t bindcount = -1;
   Lisp_Object bucket, tem, zero;
@@ -1691,9 +1687,7 @@ the values STRING, PREDICATE and `lambda'.  */)
 
   CHECK_STRING (string);
 
-  if ((CONSP (collection)
-       && (!SYMBOLP (XCAR (collection)) || NILP (XCAR (collection))))
-      || NILP (collection))
+  if (NILP (collection) || (CONSP (collection) && !FUNCTIONP (collection)))
     {
       tem = Fassoc_string (string, collection, completion_ignore_case ? Qt : Qnil);
       if (NILP (tem))
diff --git a/src/msdos.c b/src/msdos.c
index cb4f8c3df89..b778245a7be 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -2387,7 +2387,7 @@ Each input key receives two values in this vector: first the ASCII code,
 and then the scan code.  */)
   (void)
 {
-  Lisp_Object val, *keys = XVECTOR (recent_doskeys)->u.contents;
+  Lisp_Object val, *keys = XVECTOR (recent_doskeys)->contents;
 
   if (total_doskeys < NUM_RECENT_DOSKEYS)
     return Fvector (total_doskeys, keys);
diff --git a/src/nsfns.m b/src/nsfns.m
index 011edf38cef..ee6020f2b43 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -403,23 +403,23 @@ x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
       if (!NILP (f->title))
         arg = f->title;
       else
-        /* explicit name and no icon-name -> explicit_name */
+        /* Explicit name and no icon-name -> explicit_name.  */
         if (f->explicit_name)
           arg = f->name;
         else
           {
-            /* no explicit name and no icon-name ->
-               name has to be rebuild from icon_title_format */
-            windows_or_buffers_changed++;
+            /* No explicit name and no icon-name ->
+               name has to be rebuild from icon_title_format.  */
+            windows_or_buffers_changed = 62;
             return;
           }
     }
 
   /* Don't change the name if it's already NAME.  */
-  if ([[view window] miniwindowTitle] &&
-      ([[[view window] miniwindowTitle]
+  if ([[view window] miniwindowTitle]
+      && ([[[view window] miniwindowTitle]
              isEqualToString: [NSString stringWithUTF8String:
-                                           SSDATA (arg)]]))
+                                          SSDATA (arg)]]))
     return;
 
   [[view window] setMiniwindowTitle:
@@ -451,8 +451,8 @@ ns_set_name_internal (struct frame *f, Lisp_Object name)
 
   str = [NSString stringWithUTF8String: SSDATA (encoded_icon_name)];
 
-  if ([[view window] miniwindowTitle] &&
-      ! [[[view window] miniwindowTitle] isEqualToString: str])
+  if ([[view window] miniwindowTitle]
+      && ! [[[view window] miniwindowTitle] isEqualToString: str])
     [[view window] setMiniwindowTitle: str];
 
 }
@@ -469,7 +469,7 @@ ns_set_name (struct frame *f, Lisp_Object name, int explicit)
       /* If we're switching from explicit to implicit, we had better
          update the mode lines and thereby update the title.  */
       if (f->explicit_name && NILP (name))
-        update_mode_lines = 1;
+        update_mode_lines = 21;
 
       f->explicit_name = ! NILP (name);
     }
@@ -477,7 +477,7 @@ ns_set_name (struct frame *f, Lisp_Object name, int explicit)
     return;
 
   if (NILP (name))
-    name = build_string([ns_app_name UTF8String]);
+    name = build_string ([ns_app_name UTF8String]);
   else
     CHECK_STRING (name);
 
@@ -487,7 +487,7 @@ ns_set_name (struct frame *f, Lisp_Object name, int explicit)
 
   fset_name (f, name);
 
-  /* title overrides explicit name */
+  /* Title overrides explicit name.  */
   if (! NILP (f->title))
     name = f->title;
 
@@ -534,7 +534,7 @@ x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
   if (EQ (name, f->title))
     return;
 
-  update_mode_lines = 1;
+  update_mode_lines = 22;
 
   fset_title (f, name);
 
@@ -1194,6 +1194,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
     x_default_parameter (f, parms, Qfont,
                                  build_string (fontname),
                                  "font", "Font", RES_TYPE_STRING);
+    xfree (fontname);
   }
   unblock_input ();
 
@@ -2357,28 +2358,86 @@ each physical monitor, use `display-monitor-attributes-list'.  */)
 }
 
 #ifdef NS_IMPL_COCOA
-/* Returns the name for the screen that DICT came from, or NULL.
+
+/* Returns the name for the screen that OBJ represents, or NULL.
    Caller must free return value.
 */
 
 static char *
-ns_screen_name (CGDirectDisplayID did)
+ns_get_name_from_ioreg (io_object_t obj)
 {
   char *name = NULL;
+
   NSDictionary *info = (NSDictionary *)
-    IODisplayCreateInfoDictionary (CGDisplayIOServicePort (did),
-                                   kIODisplayOnlyPreferredName);
-  NSDictionary *names
-    = [info objectForKey:
-              [NSString stringWithUTF8String:kDisplayProductName]];
-
-  if ([names count] > 0) {
-    NSString *n = [names objectForKey: [[names allKeys] objectAtIndex:0]];
-    if (n != nil)
-      name = xstrdup ([n UTF8String]);
-  }
+    IODisplayCreateInfoDictionary (obj, kIODisplayOnlyPreferredName);
+  NSDictionary *names = [info objectForKey:
+                                [NSString stringWithUTF8String:
+                                            kDisplayProductName]];
+
+  if ([names count] > 0)
+    {
+      NSString *n = [names objectForKey: [[names allKeys]
+                                                 objectAtIndex:0]];
+      if (n != nil) name = xstrdup ([n UTF8String]);
+    }
 
   [info release];
+
+  return name;
+}
+
+/* Returns the name for the screen that DID came from, or NULL.
+   Caller must free return value.
+*/
+
+static char *
+ns_screen_name (CGDirectDisplayID did)
+{
+  char *name = NULL;
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_9
+  mach_port_t masterPort;
+  io_iterator_t it;
+  io_object_t obj;
+
+  // CGDisplayIOServicePort is deprecated.  Do it another (harder) way.
+
+  if (IOMasterPort (MACH_PORT_NULL, &masterPort) != kIOReturnSuccess
+      || IOServiceGetMatchingServices (masterPort,
+                                       IOServiceMatching ("IONDRVDevice"),
+                                       &it) != kIOReturnSuccess)
+    return name;
+
+  /* Must loop until we find a name.  Many devices can have the same unit
+     number (represents different GPU parts), but only one has a name.  */
+  while (! name && (obj = IOIteratorNext (it)))
+    {
+      CFMutableDictionaryRef props;
+      const void *val;
+
+      if (IORegistryEntryCreateCFProperties (obj,
+                                             &props,
+                                             kCFAllocatorDefault,
+                                             kNilOptions) == kIOReturnSuccess
+          && props != nil
+          && (val = CFDictionaryGetValue(props, @"IOFBDependentIndex")))
+        {
+          unsigned nr = [(NSNumber *)val unsignedIntegerValue];
+          if (nr == CGDisplayUnitNumber (did))
+            name = ns_get_name_from_ioreg (obj);
+        }
+
+      CFRelease (props);
+      IOObjectRelease (obj);
+    }
+
+  IOObjectRelease (it);
+
+#else
+
+  name = ns_get_name_from_ioreg (CGDisplayIOServicePort (did));
+
+#endif
   return name;
 }
 #endif
diff --git a/src/nsfont.m b/src/nsfont.m
index bd9a2acc983..58663804a2f 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -624,7 +624,7 @@ static Lisp_Object nsfont_match (struct frame *, Lisp_Object);
 static Lisp_Object nsfont_list_family (struct frame *);
 static Lisp_Object nsfont_open (struct frame *f, Lisp_Object font_entity,
                                  int pixel_size);
-static void nsfont_close (struct frame *f, struct font *font);
+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,
@@ -929,29 +929,30 @@ nsfont_open (struct frame *f, Lisp_Object font_entity, int pixel_size)
 }
 
 
-/* Close FONT on frame F. */
+/* Close FONT. */
 static void
-nsfont_close (struct frame *f, struct font *font)
+nsfont_close (struct font *font)
 {
-  struct nsfont_info *font_info = (struct nsfont_info *)font;
-  int i;
-
-  /* FIXME: this occurs apparently due to same failure to detect same font
-            that causes need for cache in nsfont_open () */
-  if (!font_info)
-      return;
+  struct nsfont_info *font_info = (struct nsfont_info *) font;
 
-  for (i =0; i<0x100; i++)
+  /* FIXME: font_info may be NULL due to same failure to detect
+     same font that causes need for cache in nsfont_open.  */
+  if (font_info && font_info->name)
     {
-      xfree (font_info->glyphs[i]);
-      xfree (font_info->metrics[i]);
-    }
-  [font_info->nsfont release];
+      int i;
+
+      for (i = 0; i < 0x100; i++)
+        {
+          xfree (font_info->glyphs[i]);
+          xfree (font_info->metrics[i]);
+        }
+      [font_info->nsfont release];
 #ifdef NS_IMPL_COCOA
-  CGFontRelease (font_info->cgfont);
+      CGFontRelease (font_info->cgfont);
 #endif
-  xfree (font_info->name);
-  xfree (font_info);
+      xfree (font_info->name);
+      font_info->name = NULL;
+    }
 }
 
 
diff --git a/src/nsterm.h b/src/nsterm.h
index 71faa075f32..22a8aec9436 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -85,6 +85,10 @@ typedef float EmacsCGFloat;
 /* We override sendEvent: as a means to stop/start the event loop */
 @interface EmacsApp : NSApplication
 {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_9
+  BOOL shouldKeepRunning;
+  BOOL isFirst;
+#endif
 #ifdef NS_IMPL_GNUSTEP
 @public
   int nextappdefined;
diff --git a/src/nsterm.m b/src/nsterm.m
index 5b2c6a3f686..0e7667b6dc6 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -173,6 +173,7 @@ Lisp_Object Qalt, Qcontrol, Qhyper, Qmeta, Qsuper;
 extern Lisp_Object Qcursor_color, Qcursor_type, Qns, Qleft;
 
 static Lisp_Object QUTF8_STRING;
+static Lisp_Object Qcocoa, Qgnustep;
 
 /* On OS X picks up the default NSGlobalDomain AppleAntiAliasingThreshold,
    the maximum font size to NOT antialias.  On GNUstep there is currently
@@ -1460,15 +1461,16 @@ ns_get_color (const char *name, NSColor **col)
 /*fprintf (stderr, "ns_get_color: '%s'\n", name); */
   block_input ();
 
-#ifdef NS_IMPL_COCOA
   if ([nsname isEqualToString: @"ns_selection_bg_color"])
     {
+#ifdef NS_IMPL_COCOA
       NSString *defname = [[NSUserDefaults standardUserDefaults]
                             stringForKey: @"AppleHighlightColor"];
-
       if (defname != nil)
         nsname = defname;
-      else if ((new = [NSColor selectedTextBackgroundColor]) != nil)
+      else
+#endif
+      if ((new = [NSColor selectedTextBackgroundColor]) != nil)
         {
           *col = [new colorUsingColorSpaceName: NSCalibratedRGBColorSpace];
           unblock_input ();
@@ -1494,7 +1496,6 @@ ns_get_color (const char *name, NSColor **col)
       nsname = NS_SELECTION_FG_COLOR_DEFAULT;
       name = [nsname UTF8String];
     }
-#endif // NS_IMPL_COCOA
 
   /* First, check for some sort of numeric specification. */
   hex[0] = '\0';
@@ -4366,6 +4367,46 @@ ns_term_shutdown (int sig)
 
 @implementation EmacsApp
 
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_9
+- (id)init
+{
+  if (self = [super init])
+    self->isFirst = YES;
+
+  return self;
+}
+
+- (void)run
+{
+    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+
+    if (isFirst) [self finishLaunching];
+    isFirst = NO;
+
+    shouldKeepRunning = YES;
+    do
+    {
+        [pool release];
+        pool = [[NSAutoreleasePool alloc] init];
+
+        NSEvent *event =
+          [self nextEventMatchingMask:NSAnyEventMask
+                            untilDate:[NSDate distantFuture]
+                               inMode:NSDefaultRunLoopMode
+                              dequeue:YES];
+        [self sendEvent:event];
+        [self updateWindows];
+    } while (shouldKeepRunning);
+
+    [pool release];
+}
+
+- (void)stop: (id)sender
+{
+    shouldKeepRunning = NO;
+}
+#endif
+
 - (void)logNotification: (NSNotification *)notification
 {
   const char *name = [[notification name] UTF8String];
@@ -6048,7 +6089,7 @@ if (cols > 0 && rows > 0)
 
   SET_FRAME_ICONIFIED (emacsframe, 0);
   SET_FRAME_VISIBLE (emacsframe, 1);
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 63;
 
   if (emacs_event)
     {
@@ -7501,11 +7542,17 @@ baseline level.  The default value is nil.  */);
   /* Tell Emacs about this window system.  */
   Fprovide (Qns, Qnil);
 
+  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);
 #endif
   
 }
diff --git a/src/print.c b/src/print.c
index 965d719f852..e3c56a6de62 100644
--- a/src/print.c
+++ b/src/print.c
@@ -1705,8 +1705,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
           unsigned char c;
           struct gcpro gcpro1;
           EMACS_INT size = bool_vector_size (obj);
-          ptrdiff_t size_in_chars = ((size + BOOL_VECTOR_BITS_PER_CHAR - 1)
-                                     / BOOL_VECTOR_BITS_PER_CHAR);
+          ptrdiff_t size_in_chars = bool_vector_bytes (size);
           ptrdiff_t real_size_in_chars = size_in_chars;
           GCPRO1 (obj);
 
@@ -1726,7 +1725,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
           for (i = 0; i < size_in_chars; i++)
             {
               QUIT;
-              c = XBOOL_VECTOR (obj)->data[i];
+              c = bool_vector_uchar_data (obj)[i];
               if (c == '\n' && print_escape_newlines)
                 {
                   PRINTCHAR ('\\');
diff --git a/src/process.c b/src/process.c
index 91bc090e76e..307eab3ab30 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1333,15 +1333,15 @@ Returns nil if format of ADDRESS is invalid.  */)
 
       for (i = 0; i < nargs; i++)
         {
-          if (! RANGED_INTEGERP (0, p->u.contents[i], 65535))
+          if (! RANGED_INTEGERP (0, p->contents[i], 65535))
             return Qnil;
 
           if (nargs <= 5         /* IPv4 */
               && i < 4           /* host, not port */
-              && XINT (p->u.contents[i]) > 255)
+              && XINT (p->contents[i]) > 255)
             return Qnil;
 
-          args[i+1] = p->u.contents[i];
+          args[i+1] = p->contents[i];
         }
 
       return Fformat (nargs+1, args);
@@ -1983,7 +1983,7 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, int len)
         len = sizeof (sin->sin_addr) + 1;
         address = Fmake_vector (make_number (len), Qnil);
         p = XVECTOR (address);
-        p->u.contents[--len] = make_number (ntohs (sin->sin_port));
+        p->contents[--len] = make_number (ntohs (sin->sin_port));
         cp = (unsigned char *) &sin->sin_addr;
         break;
       }
@@ -1995,9 +1995,9 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, int len)
         len = sizeof (sin6->sin6_addr)/2 + 1;
         address = Fmake_vector (make_number (len), Qnil);
         p = XVECTOR (address);
-        p->u.contents[--len] = make_number (ntohs (sin6->sin6_port));
+        p->contents[--len] = make_number (ntohs (sin6->sin6_port));
         for (i = 0; i < len; i++)
-          p->u.contents[i] = make_number (ntohs (ip6[i]));
+          p->contents[i] = make_number (ntohs (ip6[i]));
         return address;
       }
 #endif
@@ -2022,7 +2022,7 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, int len)
 
   i = 0;
   while (i < len)
-    p->u.contents[i++] = make_number (*cp++);
+    p->contents[i++] = make_number (*cp++);
 
   return address;
 }
@@ -2093,7 +2093,7 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
         {
           struct sockaddr_in *sin = (struct sockaddr_in *) sa;
           len = sizeof (sin->sin_addr) + 1;
-          hostport = XINT (p->u.contents[--len]);
+          hostport = XINT (p->contents[--len]);
           sin->sin_port = htons (hostport);
           cp = (unsigned char *)&sin->sin_addr;
           sa->sa_family = family;
@@ -2104,12 +2104,12 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
           struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa;
           uint16_t *ip6 = (uint16_t *)&sin6->sin6_addr;
           len = sizeof (sin6->sin6_addr) + 1;
-          hostport = XINT (p->u.contents[--len]);
+          hostport = XINT (p->contents[--len]);
           sin6->sin6_port = htons (hostport);
           for (i = 0; i < len; i++)
-            if (INTEGERP (p->u.contents[i]))
+            if (INTEGERP (p->contents[i]))
               {
-                int j = XFASTINT (p->u.contents[i]) & 0xffff;
+                int j = XFASTINT (p->contents[i]) & 0xffff;
                 ip6[i] = ntohs (j);
               }
           sa->sa_family = family;
@@ -2140,8 +2140,8 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
     }
 
   for (i = 0; i < len; i++)
-    if (INTEGERP (p->u.contents[i]))
-      *cp++ = XFASTINT (p->u.contents[i]) & 0xff;
+    if (INTEGERP (p->contents[i]))
+      *cp++ = XFASTINT (p->contents[i]) & 0xff;
 }
 
 #ifdef DATAGRAM_SOCKETS
@@ -3723,7 +3723,9 @@ network_interface_info (Lisp_Object ifname)
 
       any = 1;
       for (n = 0; n < 6; n++)
-        p->u.contents[n] = make_number (((unsigned char *)&rq.ifr_hwaddr.sa_data[0])[n]);
+        p->contents[n] = make_number (((unsigned char *)
+                                       &rq.ifr_hwaddr.sa_data[0])
+                                      [n]);
       elt = Fcons (make_number (rq.ifr_hwaddr.sa_family), hwaddr);
     }
 #elif defined (HAVE_GETIFADDRS) && defined (LLADDR)
@@ -3746,7 +3748,7 @@ network_interface_info (Lisp_Object ifname)
 
           memcpy (linkaddr, LLADDR (sdl), sdl->sdl_alen);
           for (n = 0; n < 6; n++)
-            p->u.contents[n] = make_number (linkaddr[n]);
+            p->contents[n] = make_number (linkaddr[n]);
 
           elt = Fcons (make_number (it->ifa_addr->sa_family), hwaddr);
           break;
@@ -4607,7 +4609,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                       {
                         struct Lisp_Process *p =
                           XPROCESS (chan_process[channel]);
-                        if (p && p->gnutls_p && p->infd
+                        if (p && p->gnutls_p && p->gnutls_state && p->infd
                             && ((emacs_gnutls_record_check_pending
                                  (p->gnutls_state))
                                 > 0))
@@ -4621,6 +4623,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                 {
                   /* Check this specific channel. */
                   if (wait_proc->gnutls_p /* Check for valid process.  */
+                      && wait_proc->gnutls_state
                       /* Do we have pending data?  */
                       && ((emacs_gnutls_record_check_pending
                            (wait_proc->gnutls_state))
@@ -5002,7 +5005,7 @@ read_process_output (Lisp_Object proc, register int channel)
           proc_buffered_char[channel] = -1;
         }
 #ifdef HAVE_GNUTLS
-      if (p->gnutls_p)
+      if (p->gnutls_p && p->gnutls_state)
         nbytes = emacs_gnutls_read (p, chars + carryover + buffered,
                                     readmax - buffered);
       else
@@ -5243,7 +5246,7 @@ DEFUN ("internal-default-process-filter", Finternal_default_process_filter,
       else
         set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
 
-      update_mode_lines++;
+      update_mode_lines = 23;
 
       /* Make sure opoint and the old restrictions
          float ahead of any new text just as point would.  */
@@ -5496,7 +5499,7 @@ send_process (Lisp_Object proc, const char *buf, ptrdiff_t len,
 #endif
             {
 #ifdef HAVE_GNUTLS
-              if (p->gnutls_p)
+              if (p->gnutls_p && p->gnutls_state)
                 written = emacs_gnutls_write (p, cur_buf, cur_len);
               else
 #endif
@@ -6387,7 +6390,7 @@ status_notify (struct Lisp_Process *deleting_process)
         }
     } /* end for */
 
-  update_mode_lines++;  /* In case buffers use %s in mode-line-format.  */
+  update_mode_lines = 24;  /* In case buffers use %s in mode-line-format.  */
   UNGCPRO;
 }
 
diff --git a/src/regex.c b/src/regex.c
index 4ab98bbf098..615fb3fdf34 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -43,7 +43,7 @@
 # endif
 #endif
 
-#if 4 < __GNUC__ + (5 <= __GNUC_MINOR__) && ! defined __clang__
+#if 4 < __GNUC__ + (6 <= __GNUC_MINOR__) && ! defined __clang__
 # pragma GCC diagnostic ignored "-Wunused-but-set-variable"
 #endif
 
diff --git a/src/regex.h b/src/regex.h
index bb737df5239..8f5bb56fbd1 100644
--- a/src/regex.h
+++ b/src/regex.h
@@ -40,7 +40,7 @@ extern "C" {
    The bits are given in alphabetical order, and
    the definitions shifted by one from the previous bit; thus, when we
    add or remove a bit, only one other definition need change.  */
-typedef unsigned long int reg_syntax_t;
+typedef unsigned long reg_syntax_t;
 
 /* If this bit is not set, then \ inside a bracket expression is literal.
    If set, then such a \ quotes the following character.  */
diff --git a/src/search.c b/src/search.c
index 99e8d2501fe..c9e27627cd1 100644
--- a/src/search.c
+++ b/src/search.c
@@ -720,42 +720,45 @@ find_newline (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
 
         {
           /* The termination address of the dumb loop.  */
-          register unsigned char *ceiling_addr
-            = BYTE_POS_ADDR (ceiling_byte) + 1;
-          register unsigned char *cursor
-            = BYTE_POS_ADDR (start_byte);
-          unsigned char *base = cursor;
+          unsigned char *lim_addr = BYTE_POS_ADDR (ceiling_byte) + 1;
+          ptrdiff_t lim_byte = ceiling_byte + 1;
 
-          while (cursor < ceiling_addr)
-            {
+          /* Nonpositive offsets (relative to LIM_ADDR and LIM_BYTE)
+             of the base, the cursor, and the next line.  */
+          ptrdiff_t base = start_byte - lim_byte;
+          ptrdiff_t cursor, next;
+
+          for (cursor = base; cursor < 0; cursor = next)
+            {
               /* The dumb loop.  */
-              unsigned char *nl = memchr (cursor, '\n', ceiling_addr - cursor);
+              unsigned char *nl = memchr (lim_addr + cursor, '\n', - cursor);
+              next = nl ? nl - lim_addr : 0;
 
               /* If we're looking for newlines, cache the fact that
-                 the region from start to cursor is free of them. */
+                 this line's region is free of them. */
               if (newline_cache)
                 {
-                  unsigned char *low = cursor;
-                  unsigned char *lim = nl ? nl : ceiling_addr;
                   know_region_cache (current_buffer, newline_cache,
-                                     BYTE_TO_CHAR (low - base + start_byte),
-                                     BYTE_TO_CHAR (lim - base + start_byte));
+                                     BYTE_TO_CHAR (lim_byte + cursor),
+                                     BYTE_TO_CHAR (lim_byte + next));
+                  /* know_region_cache can relocate buffer text.  */
+                  lim_addr = BYTE_POS_ADDR (ceiling_byte) + 1;
                 }
 
               if (! nl)
                 break;
+              next++;
 
               if (--count == 0)
                 {
                   immediate_quit = 0;
                   if (bytepos)
-                    *bytepos = nl + 1 - base + start_byte;
-                  return BYTE_TO_CHAR (nl + 1 - base + start_byte);
+                    *bytepos = lim_byte + next;
+                  return BYTE_TO_CHAR (lim_byte + next);
                 }
-              cursor = nl + 1;
             }
 
-          start_byte += ceiling_addr - base;
+          start_byte = lim_byte;
           start = BYTE_TO_CHAR (start_byte);
         }
       }
@@ -794,24 +797,28 @@ find_newline (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
 
         {
           /* The termination address of the dumb loop.  */
-          register unsigned char *ceiling_addr = BYTE_POS_ADDR (ceiling_byte);
-          register unsigned char *cursor = BYTE_POS_ADDR (start_byte - 1);
-          unsigned char *base = cursor;
+          unsigned char *ceiling_addr = BYTE_POS_ADDR (ceiling_byte);
+
+          /* Offsets (relative to CEILING_ADDR and CEILING_BYTE) of
+             the base, the cursor, and the previous line.  These
+             offsets are at least -1.  */
+          ptrdiff_t base = start_byte - ceiling_byte;
+          ptrdiff_t cursor, prev;
 
-          while (cursor >= ceiling_addr)
+          for (cursor = base; 0 < cursor; cursor = prev)
             {
-              unsigned char *nl = memrchr (ceiling_addr, '\n',
-                                           cursor + 1 - ceiling_addr);
+              unsigned char *nl = memrchr (ceiling_addr, '\n', cursor);
+              prev = nl ? nl - ceiling_addr : -1;
 
               /* If we're looking for newlines, cache the fact that
-                 the region from after the cursor to start is free of them.  */
+                 this line's region is free of them. */
               if (newline_cache)
                 {
-                  unsigned char *low = nl ? nl : ceiling_addr - 1;
-                  unsigned char *lim = cursor;
                   know_region_cache (current_buffer, newline_cache,
-                                     BYTE_TO_CHAR (low - base + start_byte),
-                                     BYTE_TO_CHAR (lim - base + start_byte));
+                                     BYTE_TO_CHAR (ceiling_byte + prev + 1),
+                                     BYTE_TO_CHAR (ceiling_byte + cursor));
+                  /* know_region_cache can relocate buffer text.  */
+                  ceiling_addr = BYTE_POS_ADDR (ceiling_byte);
                 }
 
               if (! nl)
@@ -821,13 +828,12 @@ find_newline (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
                 {
                   immediate_quit = 0;
                   if (bytepos)
-                    *bytepos = nl - base + start_byte;
-                  return BYTE_TO_CHAR (nl - base + start_byte);
+                    *bytepos = ceiling_byte + prev + 1;
+                  return BYTE_TO_CHAR (ceiling_byte + prev + 1);
                 }
-              cursor = nl - 1;
             }
 
-          start_byte += ceiling_addr - 1 - base;
+          start_byte = ceiling_byte;
           start = BYTE_TO_CHAR (start_byte);
         }
       }
diff --git a/src/term.c b/src/term.c
index b4c2e2560cc..f86d71ac2f4 100644
--- a/src/term.c
+++ b/src/term.c
@@ -1892,55 +1892,18 @@ static void
 turn_on_face (struct frame *f, int face_id)
 {
   struct face *face = FACE_FROM_ID (f, face_id);
-  long fg = face->foreground;
-  long bg = face->background;
+  unsigned long fg = face->foreground;
+  unsigned long bg = face->background;
   struct tty_display_info *tty = FRAME_TTY (f);
 
-  /* Do this first because TS_end_standout_mode may be the same
+  /* Use reverse video if the face specifies that.
+     Do this first because TS_end_standout_mode may be the same
      as TS_exit_attribute_mode, which turns all appearances off. */
-  if (MAY_USE_WITH_COLORS_P (tty, NC_REVERSE))
-    {
-      if (tty->TN_max_colors > 0)
-        {
-          if (fg >= 0 && bg >= 0)
-            {
-              /* If the terminal supports colors, we can set them
-                 below without using reverse video.  The face's fg
-                 and bg colors are set as they should appear on
-                 the screen, i.e. they take the inverse-video'ness
-                 of the face already into account.  */
-            }
-          else if (inverse_video)
-            {
-              if (fg == FACE_TTY_DEFAULT_FG_COLOR
-                  || bg == FACE_TTY_DEFAULT_BG_COLOR)
-                tty_toggle_highlight (tty);
-            }
-          else
-            {
-              if (fg == FACE_TTY_DEFAULT_BG_COLOR
-                  || bg == FACE_TTY_DEFAULT_FG_COLOR)
-                tty_toggle_highlight (tty);
-            }
-        }
-      else
-        {
-          /* If we can't display colors, use reverse video
-             if the face specifies that.  */
-          if (inverse_video)
-            {
-              if (fg == FACE_TTY_DEFAULT_FG_COLOR
-                  || bg == FACE_TTY_DEFAULT_BG_COLOR)
-                tty_toggle_highlight (tty);
-            }
-          else
-            {
-              if (fg == FACE_TTY_DEFAULT_BG_COLOR
-                  || bg == FACE_TTY_DEFAULT_FG_COLOR)
-                tty_toggle_highlight (tty);
-            }
-        }
-    }
+  if (MAY_USE_WITH_COLORS_P (tty, NC_REVERSE)
+      && (inverse_video
+          ? fg == FACE_TTY_DEFAULT_FG_COLOR || bg == FACE_TTY_DEFAULT_BG_COLOR
+          : fg == FACE_TTY_DEFAULT_BG_COLOR || bg == FACE_TTY_DEFAULT_FG_COLOR))
+    tty_toggle_highlight (tty);
 
   if (face->tty_bold_p && MAY_USE_WITH_COLORS_P (tty, NC_BOLD))
     OUTPUT1_IF (tty, tty->TS_enter_bold_mode);
@@ -1965,7 +1928,7 @@ turn_on_face (struct frame *f, int face_id)
       char *p;
 
       ts = tty->standout_mode ? tty->TS_set_background : tty->TS_set_foreground;
-      if (fg >= 0 && ts)
+      if (face_tty_specified_color (fg) && ts)
         {
           p = tparam (ts, NULL, 0, fg, 0, 0, 0);
           OUTPUT (tty, p);
@@ -1973,7 +1936,7 @@ turn_on_face (struct frame *f, int face_id)
         }
 
       ts = tty->standout_mode ? tty->TS_set_foreground : tty->TS_set_background;
-      if (bg >= 0 && ts)
+      if (face_tty_specified_color (bg) && ts)
         {
           p = tparam (ts, NULL, 0, bg, 0, 0, 0);
           OUTPUT (tty, p);
@@ -2027,12 +1990,10 @@ turn_off_face (struct frame *f, int face_id)
 
 
 /* Return true if the terminal on frame F supports all of the
-   capabilities in CAPS simultaneously, with foreground and background
-   colors FG and BG.  */
+   capabilities in CAPS simultaneously.  */
 
 bool
-tty_capable_p (struct tty_display_info *tty, unsigned int caps,
-               unsigned long fg, unsigned long bg)
+tty_capable_p (struct tty_display_info *tty, unsigned int caps)
 {
 #define TTY_CAPABLE_P_TRY(tty, cap, TS, NC_bit)                         \
   if ((caps & (cap)) && (!(TS) || !MAY_USE_WITH_COLORS_P(tty, NC_bit))) \
@@ -2867,7 +2828,8 @@ tty_menu_search_pane (tty_menu *menu, int pane)
       {
         if (pane == menu->panenumber[i])
           return menu->submenu[i];
-        if ((try = tty_menu_search_pane (menu->submenu[i], pane)))
+        try = tty_menu_search_pane (menu->submenu[i], pane);
+        if (try)
           return try;
       }
   return (tty_menu *) 0;
@@ -2920,7 +2882,7 @@ mouse_get_xy (int *x, int *y)
 
 static void
 tty_menu_display (tty_menu *menu, int x, int y, int pn, int *faces,
-                  int mx, int my, int first_item, int disp_help)
+                  int mx, int my, int first_item, bool disp_help)
 {
   int i, face, width, enabled, mousehere, row, col;
   struct frame *sf = SELECTED_FRAME ();
@@ -2997,16 +2959,19 @@ tty_menu_add_pane (tty_menu *menu, const char *txt)
 
 /* Create a new item in a menu pane.  */
 
-static int
+static bool
 tty_menu_add_selection (tty_menu *menu, int pane,
-                        char *txt, int enable, char const *help_text)
+                        char *txt, bool enable, char const *help_text)
 {
   int len;
   unsigned char *p;
 
   if (pane)
-    if (!(menu = tty_menu_search_pane (menu, pane)))
-      return TTYM_FAILURE;
+    {
+      menu = tty_menu_search_pane (menu, pane);
+      if (! menu)
+        return 0;
+    }
   tty_menu_make_room (menu);
   menu->submenu[menu->count] = (tty_menu *) 0;
   menu->text[menu->count] = txt;
@@ -3027,7 +2992,7 @@ tty_menu_add_selection (tty_menu *menu, int pane,
   if (len > menu->width)
     menu->width = len;
 
-  return TTYM_SUCCESS;
+  return 1;
 }
 
 /* Decide where the menu would be placed if requested at (X,Y).  */
@@ -3155,7 +3120,7 @@ read_menu_input (struct frame *sf, int *x, int *y, int min_y, int max_y,
   else
     {
       Lisp_Object cmd;
-      int usable_input = 1;
+      bool usable_input = 1;
       mi_result st = MI_CONTINUE;
       struct tty_display_info *tty = FRAME_TTY (sf);
       Lisp_Object saved_mouse_tracking = do_mouse_tracking;
@@ -3215,10 +3180,11 @@ static int
 tty_menu_activate (tty_menu *menu, int *pane, int *selidx,
                    int x0, int y0, char **txt,
                    void (*help_callback)(char const *, int, int),
-                   int kbd_navigation)
+                   bool kbd_navigation)
 {
   struct tty_menu_state *state;
-  int statecount, x, y, i, leave, onepane;
+  int statecount, x, y, i;
+  bool leave, onepane;
   int result IF_LINT (= 0);
   int title_faces[4];           /* face to display the menu title */
   int faces[4], buffers_num_deleted = 0;
@@ -3285,7 +3251,8 @@ tty_menu_activate (tty_menu *menu, int *pane, int *selidx,
   tty_hide_cursor (tty);
   if (buffers_num_deleted)
     menu->text[0][7] = ' ';
-  if ((onepane = menu->count == 1 && menu->submenu[0]))
+  onepane = menu->count == 1 && menu->submenu[0];
+  if (onepane)
     {
       menu->width = menu->submenu[0]->width;
       state[0].menu = menu->submenu[0];
@@ -3478,7 +3445,7 @@ tty_menu_help_callback (char const *help_string, int pane, int item)
   Lisp_Object pane_name;
   Lisp_Object menu_object;
 
-  first_item = XVECTOR (menu_items)->u.contents;
+  first_item = XVECTOR (menu_items)->contents;
   if (EQ (first_item[0], Qt))
     pane_name = first_item[MENU_ITEMS_PANE_NAME];
   else if (EQ (first_item[0], Qquote))
@@ -3585,8 +3552,8 @@ tty_menu_new_item_coords (struct frame *f, int which, int *x, int *y)
 }
 
 Lisp_Object
-tty_menu_show (struct frame *f, int x, int y, int for_click, int keymaps,
-               Lisp_Object title, int kbd_navigation, const char **error_name)
+tty_menu_show (struct frame *f, int x, int y, bool for_click, bool keymaps,
+               Lisp_Object title, bool kbd_navigation, const char **error_name)
 {
   tty_menu *menu;
   int pane, selidx, lpane, status;
@@ -3709,9 +3676,8 @@ tty_menu_show (struct frame *f, int x, int y, int for_click, int keymaps,
             item_data = SSDATA (item_name);
 
           if (lpane == TTYM_FAILURE
-              || (tty_menu_add_selection (menu, lpane, item_data,
-                                          !NILP (enable), help_string)
-                  == TTYM_FAILURE))
+              || (! tty_menu_add_selection (menu, lpane, item_data,
+                                            !NILP (enable), help_string)))
             {
               tty_menu_destroy (menu);
               *error_name = "Can't add selection to menu";
diff --git a/src/w32.c b/src/w32.c
index 8968147ac06..64fdd47a86a 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -8049,7 +8049,7 @@ network_interface_get_info (Lisp_Object ifname)
 
               /* Hardware address and its family.  */
               for (n = 0; n < adapter->AddressLength; n++)
-                p->u.contents[n] = make_number ((int) adapter->Address[n]);
+                p->contents[n] = make_number ((int) adapter->Address[n]);
               /* Windows does not support AF_LINK or AF_PACKET family
                  of addresses.  Use an arbitrary family number that is
                  identical to what GNU/Linux returns.  */
diff --git a/src/w32fns.c b/src/w32fns.c
index 3e60d68023b..eb77980af79 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -1664,7 +1664,7 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
     nlines = 0;
 
   /* Make sure we redisplay all windows in this frame.  */
-  ++windows_or_buffers_changed;
+  windows_or_buffers_changed = 23;
 
   delta = nlines - FRAME_TOOL_BAR_LINES (f);
 
@@ -1740,7 +1740,7 @@ x_set_name (struct frame *f, Lisp_Object name, int explicit)
       /* If we're switching from explicit to implicit, we had better
          update the mode lines and thereby update the title.  */
       if (f->explicit_name && NILP (name))
-        update_mode_lines = 1;
+        update_mode_lines = 25;
 
       f->explicit_name = ! NILP (name);
     }
@@ -1808,7 +1808,7 @@ x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
   if (EQ (name, f->title))
     return;
 
-  update_mode_lines = 1;
+  update_mode_lines = 26;
 
   fset_title (f, name);
 
diff --git a/src/w32font.c b/src/w32font.c
index 845df68f09d..effedfc04e1 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -376,26 +376,28 @@ w32font_open (struct frame *f, Lisp_Object font_entity, int pixel_size)
   return font_object;
 }
 
-/* w32 implementation of close for font_backend.
-   Close FONT on frame F.  */
+/* w32 implementation of close for font_backend.  */
 void
-w32font_close (struct frame *f, struct font *font)
+w32font_close (struct font *font)
 {
-  int i;
   struct w32font_info *w32_font = (struct w32font_info *) font;
 
-  /* Delete the GDI font object.  */
-  DeleteObject (w32_font->hfont);
-
-  /* Free all the cached metrics.  */
-  if (w32_font->cached_metrics)
+  if (w32_font->hfont)
     {
-      for (i = 0; i < w32_font->n_cache_blocks; i++)
-        {
-          xfree (w32_font->cached_metrics[i]);
-        }
-      xfree (w32_font->cached_metrics);
-      w32_font->cached_metrics = NULL;
+      /* Delete the GDI font object.  */
+      DeleteObject (w32_font->hfont);
+      w32_font->hfont = NULL;
+
+      /* Free all the cached metrics.  */
+      if (w32_font->cached_metrics)
+        {
+          int i;
+
+          for (i = 0; i < w32_font->n_cache_blocks; i++)
+              xfree (w32_font->cached_metrics[i]);
+          xfree (w32_font->cached_metrics);
+          w32_font->cached_metrics = NULL;
+        }
     }
 }
 
diff --git a/src/w32font.h b/src/w32font.h
index 56220860863..1991492628c 100644
--- a/src/w32font.h
+++ b/src/w32font.h
@@ -72,7 +72,7 @@ Lisp_Object w32font_match_internal (struct frame *f,
                                     int opentype_only);
 int w32font_open_internal (struct frame *f, Lisp_Object font_entity,
                            int pixel_size, Lisp_Object font_object);
-void w32font_close (struct frame *f, struct font *font);
+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);
diff --git a/src/w32inevt.c b/src/w32inevt.c
index c5d3fa3ad7d..dc587de1183 100644
--- a/src/w32inevt.c
+++ b/src/w32inevt.c
@@ -518,7 +518,7 @@ do_mouse_event (MOUSE_EVENT_RECORD *event,
                               help_echo_window, help_echo_object,
                               help_echo_pos);
           }
-        /* We alread called kbd_buffer_store_event, so indicate the
+        /* We already called kbd_buffer_store_event, so indicate the
            the caller it shouldn't.  */
         return 0;
       }
diff --git a/src/w32menu.c b/src/w32menu.c
index 6ac02d95a63..b25652017cd 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -326,7 +326,7 @@ set_frame_menubar (struct frame *f, bool first_time, bool deep_p)
 
       /* Save the frame's previous menu bar contents data.  */
       if (previous_menu_items_used)
-        memcpy (previous_items, XVECTOR (f->menu_bar_vector)->u.contents,
+        memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
                 previous_menu_items_used * word_size);
 
       /* Fill in menu_items with the current menu bar contents.
diff --git a/src/w32term.c b/src/w32term.c
index 6c94090f3b7..0741761febe 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -656,7 +656,13 @@ x_update_window_end (struct window *w, bool cursor_on_p,
   /* If a row with mouse-face was overwritten, arrange for
      XTframe_up_to_date to redisplay the mouse highlight.  */
   if (mouse_face_overwritten_p)
-    reset_mouse_highlight (MOUSE_HL_INFO (XFRAME (w->frame)));
+    {
+      Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
+
+      hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
+      hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
+      hlinfo->mouse_face_window = Qnil;
+    }
 
   /* Unhide the caret.  This won't actually show the cursor, unless it
      was visible before the corresponding call to HideCaret in
@@ -1596,10 +1602,7 @@ w32_setup_relief_color (struct frame *f, struct relief *relief, double factor,
   xgcv.foreground = default_pixel;
   pixel = background;
   if (w32_alloc_lighter_color (f, &pixel, factor, delta))
-    {
-      relief->allocated_p = 1;
-      xgcv.foreground = relief->pixel = pixel;
-    }
+    xgcv.foreground = relief->pixel = pixel;
 
   if (relief->gc == 0)
     {
@@ -6001,17 +6004,6 @@ x_free_frame_resources (struct frame *f)
 
   free_frame_menubar (f);
 
-  unload_color (f, FRAME_FOREGROUND_PIXEL (f));
-  unload_color (f, FRAME_BACKGROUND_PIXEL (f));
-  unload_color (f, f->output_data.w32->cursor_pixel);
-  unload_color (f, f->output_data.w32->cursor_foreground_pixel);
-  unload_color (f, f->output_data.w32->border_pixel);
-  unload_color (f, f->output_data.w32->mouse_pixel);
-  if (f->output_data.w32->white_relief.allocated_p)
-    unload_color (f, f->output_data.w32->white_relief.pixel);
-  if (f->output_data.w32->black_relief.allocated_p)
-    unload_color (f, f->output_data.w32->black_relief.pixel);
-
   if (FRAME_FACE_CACHE (f))
     free_frame_faces (f);
 
diff --git a/src/w32term.h b/src/w32term.h
index 956e03d336c..b3c0cf56c7b 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -376,7 +376,6 @@ struct w32_output
   {
     XGCValues *gc;
     unsigned long pixel;
-    int allocated_p;
   }
   black_relief, white_relief;
 
diff --git a/src/w32uniscribe.c b/src/w32uniscribe.c
index b31baa0e65c..fb3fbd0d607 100644
--- a/src/w32uniscribe.c
+++ b/src/w32uniscribe.c
@@ -135,7 +135,7 @@ uniscribe_open (struct frame *f, Lisp_Object font_entity, int pixel_size)
 }
 
 static void
-uniscribe_close (struct frame *f, struct font *font)
+uniscribe_close (struct font *font)
 {
   struct uniscribe_font_info *uniscribe_font
     = (struct uniscribe_font_info *) font;
@@ -143,7 +143,7 @@ uniscribe_close (struct frame *f, struct font *font)
   if (uniscribe_font->cache)
     ScriptFreeCache (&(uniscribe_font->cache));
 
-  w32font_close (f, font);
+  w32font_close (font);
 }
 
 /* Return a list describing which scripts/languages FONT supports by
diff --git a/src/window.c b/src/window.c
index ecbe5fa5365..bc0adaf459f 100644
--- a/src/window.c
+++ b/src/window.c
@@ -500,7 +500,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
 
   select_window_1 (window, inhibit_point_swap);
   bset_last_selected_window (XBUFFER (w->contents), window);
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 24;
 
  record_and_return:
   /* record_buffer can run QUIT, so make sure it is run only after we have
@@ -1553,7 +1553,7 @@ Return POS.  */)
       set_marker_restricted (w->pointm, pos, w->contents);
       /* We have to make sure that redisplay updates the window to show
          the new value of point.  */
-      ++windows_or_buffers_changed;
+      windows_or_buffers_changed = 25;
     }
 
   return pos;
@@ -1576,7 +1576,7 @@ overriding motion of point in order to display at this exact start.  */)
   w->update_mode_line = 1;
   if (w != XWINDOW (selected_window))
     /* Enforce full redisplay.  FIXME: make it more selective.  */
-    windows_or_buffers_changed++;
+    windows_or_buffers_changed = 26;
 
   return pos;
 }
@@ -2639,7 +2639,7 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
                 mark_window_display_accurate (window, 0);
                 w->update_mode_line = 1;
                 XBUFFER (obj)->prevent_redisplay_optimizations_p = 1;
-                ++update_mode_lines;
+                update_mode_lines = 27;
                 best_window = window;
               }
             break;
@@ -2837,7 +2837,7 @@ window-start value is reasonable when this function is called.  */)
     }
   free_window_matrices (r);
 
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 27;
   Vwindow_list = Qnil;
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
   resize_failed = 0;
@@ -3171,7 +3171,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
     }
   /* Maybe we could move this into the `if' but it's not obviously safe and
      I doubt it's worth the trouble.  */
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 28;
 
   /* We must select BUFFER for running the window-scroll-functions.  */
   /* We can't check ! NILP (Vwindow_scroll_functions) here
@@ -3278,8 +3278,8 @@ displaying that buffer.  */)
 {
   if (NILP (object))
     {
-      windows_or_buffers_changed++;
-      update_mode_lines++;
+      windows_or_buffers_changed = 29;
+      update_mode_lines = 28;
       return Qt;
     }
 
@@ -3290,7 +3290,7 @@ displaying that buffer.  */)
       w->update_mode_line = 1;
       if (BUFFERP (w->contents))
         XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
-      ++update_mode_lines;
+      update_mode_lines = 29;
       return Qt;
     }
 
@@ -3646,7 +3646,7 @@ be applied on the Elisp level.  */)
   block_input ();
   window_resize_apply (r, horflag);
 
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 30;
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
   adjust_frame_glyphs (f);
@@ -3741,7 +3741,7 @@ resize_frame_windows (struct frame *f, int size, bool horflag)
         }
     }
 
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 31;
 }
 
 
@@ -3862,7 +3862,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
   else
     p = XWINDOW (o->parent);
 
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 32;
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
   new = make_window ();
   n = XWINDOW (new);
@@ -4012,7 +4012,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
             hlinfo->mouse_face_window = Qnil;
         }
 
-      windows_or_buffers_changed++;
+      windows_or_buffers_changed = 33;
       Vwindow_list = Qnil;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
@@ -4134,7 +4134,7 @@ grow_mini_window (struct window *w, int delta)
       w->top_line = r->top_line + r->total_lines;
       w->total_lines -= XINT (value);
       /* Enforce full redisplay.  FIXME: make it more selective.  */
-      windows_or_buffers_changed++;
+      windows_or_buffers_changed = 34;
       adjust_frame_glyphs (f);
       unblock_input ();
     }
@@ -4168,7 +4168,7 @@ shrink_mini_window (struct window *w)
           w->top_line = r->top_line + r->total_lines;
           w->total_lines = 1;
           /* Enforce full redisplay.  FIXME: make it more selective.  */
-          windows_or_buffers_changed++;
+          windows_or_buffers_changed = 35;
           adjust_frame_glyphs (f);
           unblock_input ();
         }
@@ -4208,7 +4208,7 @@ DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini
       w->total_lines = XFASTINT (w->new_total);
       w->top_line = r->top_line + r->total_lines;
 
-      windows_or_buffers_changed++;
+      windows_or_buffers_changed = 36;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
       adjust_frame_glyphs (f);
       unblock_input ();
@@ -4830,7 +4830,7 @@ scroll_command (Lisp_Object n, int direction)
       Fset_buffer (XWINDOW (selected_window)->contents);
 
       /* Make redisplay consider other windows than just selected_window.  */
-      ++windows_or_buffers_changed;
+      windows_or_buffers_changed = 37;
     }
 
   if (NILP (n))
@@ -4940,7 +4940,7 @@ specifies the window to scroll.  This takes precedence over
 
   /* Don't screw up if window_scroll gets an error.  */
   record_unwind_protect (save_excursion_restore, save_excursion_save ());
-  ++windows_or_buffers_changed;
+  windows_or_buffers_changed = 38;
 
   Fset_buffer (w->contents);
   SET_PT_BOTH (marker_position (w->pointm), marker_byte_position (w->pointm));
@@ -5405,7 +5405,7 @@ struct saved_window
 };
 
 #define SAVED_WINDOW_N(swv,n) \
-  ((struct saved_window *) (XVECTOR ((swv)->u.contents[(n)])))
+  ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
 
 DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a window-configuration object.  */)
@@ -5575,7 +5575,7 @@ the return value is nil.  Otherwise the value is t.  */)
                            BUF_PT_BYTE (XBUFFER (w->contents)));
         }
 
-      windows_or_buffers_changed++;
+      windows_or_buffers_changed = 39;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
       /* Problem: Freeing all matrices and later allocating them again
@@ -6103,7 +6103,7 @@ apply_window_adjustment (struct window *w)
   adjust_window_margins (w);
   clear_glyph_matrix (w->current_matrix);
   w->window_end_valid = 0;
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 40;
   adjust_frame_glyphs (XFRAME (WINDOW_FRAME (w)));
 }
 
diff --git a/src/window.h b/src/window.h
index cc4332ccf7f..f619b82e8a3 100644
--- a/src/window.h
+++ b/src/window.h
@@ -341,10 +341,6 @@ struct window
        y-direction (smooth scrolling).  */
     int vscroll;
 
-    /* If we have highlighted the region (or any part of it), the mark
-       (region start) position; otherwise zero.  */
-    ptrdiff_t region_showing;
-
     /* Z_BYTE - buffer position of the last glyph in the current matrix of W.
        Should be nonnegative, and only valid if window_end_valid is nonzero.  */
     ptrdiff_t window_end_bytepos;
diff --git a/src/xdisp.c b/src/xdisp.c
index 395a74e4122..47855a1de3c 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -737,7 +737,7 @@ ptrdiff_t help_echo_pos;
 
 Lisp_Object previous_help_echo_string;
 
-/* Platform-independent portion of hourglass implementation. */
+/* Platform-independent portion of hourglass implementation.  */
 
 #ifdef HAVE_WINDOW_SYSTEM
 
@@ -2601,24 +2601,6 @@ check_window_end (struct window *w)
 
 #endif /* GLYPH_DEBUG and ENABLE_CHECKING */
 
-/* Return mark position if current buffer has the region of non-zero length,
-   or -1 otherwise.  */
-
-static ptrdiff_t
-markpos_of_region (void)
-{
-  if (!NILP (Vtransient_mark_mode)
-      && !NILP (BVAR (current_buffer, mark_active))
-      && XMARKER (BVAR (current_buffer, mark))->buffer != NULL)
-    {
-      ptrdiff_t markpos = XMARKER (BVAR (current_buffer, mark))->charpos;
-
-      if (markpos != PT)
-        return markpos;
-    }
-  return -1;
-}
-
 /***********************************************************************
                        Iterator initialization
  ***********************************************************************/
@@ -2647,7 +2629,6 @@ init_iterator (struct it *it, struct window *w,
                ptrdiff_t charpos, ptrdiff_t bytepos,
                struct glyph_row *row, enum face_id base_face_id)
 {
-  ptrdiff_t markpos;
   enum face_id remapped_base_face_id = base_face_id;
 
   /* Some precondition checks.  */
@@ -2751,28 +2732,6 @@ init_iterator (struct it *it, struct window *w,
   /* Are multibyte characters enabled in current_buffer?  */
   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
 
-  /* If visible region is of non-zero length, set IT->region_beg_charpos
-     and IT->region_end_charpos to the start and end of a visible region
-     in window IT->w.  Set both to -1 to indicate no region.  */
-  markpos = markpos_of_region ();
-  if (markpos >= 0
-      /* Maybe highlight only in selected window.  */
-      && (/* Either show region everywhere.  */
-          highlight_nonselected_windows
-          /* Or show region in the selected window.  */
-          || w == XWINDOW (selected_window)
-          /* Or show the region if we are in the mini-buffer and W is
-             the window the mini-buffer refers to.  */
-          || (MINI_WINDOW_P (XWINDOW (selected_window))
-              && WINDOWP (minibuf_selected_window)
-              && w == XWINDOW (minibuf_selected_window))))
-    {
-      it->region_beg_charpos = min (PT, markpos);
-      it->region_end_charpos = max (PT, markpos);
-    }
-  else
-    it->region_beg_charpos = it->region_end_charpos = -1;
-
   /* Get the position at which the redisplay_end_trigger hook should
      be run, if it is to be run at all.  */
   if (MARKERP (w->redisplay_end_trigger)
@@ -3406,16 +3365,6 @@ compute_stop_pos (struct it *it)
       if (pos < it->stop_charpos)
         it->stop_charpos = pos;
 
-      /* If showing the region, we have to stop at the region
-         start or end because the face might change there.  */
-      if (it->region_beg_charpos > 0)
-        {
-          if (IT_CHARPOS (*it) < it->region_beg_charpos)
-            it->stop_charpos = min (it->stop_charpos, it->region_beg_charpos);
-          else if (IT_CHARPOS (*it) < it->region_end_charpos)
-            it->stop_charpos = min (it->stop_charpos, it->region_end_charpos);
-        }
-
       /* Set up variables for computing the stop position from text
          property changes.  */
       XSETBUFFER (object, current_buffer);
@@ -3799,8 +3748,6 @@ handle_face_prop (struct it *it)
       new_face_id
         = face_at_buffer_position (it->w,
                                    IT_CHARPOS (*it),
-                                   it->region_beg_charpos,
-                                   it->region_end_charpos,
                                    &next_stop,
                                    (IT_CHARPOS (*it)
                                     + TEXT_PROP_DISTANCE_LIMIT),
@@ -3877,8 +3824,6 @@ handle_face_prop (struct it *it)
           base_face_id
             = face_for_overlay_string (it->w,
                                        IT_CHARPOS (*it),
-                                       it->region_beg_charpos,
-                                       it->region_end_charpos,
                                        &next_stop,
                                        (IT_CHARPOS (*it)
                                         + TEXT_PROP_DISTANCE_LIMIT),
@@ -3907,8 +3852,6 @@ handle_face_prop (struct it *it)
                                              it->string,
                                              IT_STRING_CHARPOS (*it),
                                              bufpos,
-                                             it->region_beg_charpos,
-                                             it->region_end_charpos,
                                              &next_stop,
                                              base_face_id, 0);
 
@@ -4051,8 +3994,6 @@ face_before_or_after_it_pos (struct it *it, int before_p)
                                          it->string,
                                          charpos,
                                          bufpos,
-                                         it->region_beg_charpos,
-                                         it->region_end_charpos,
                                          &next_check_charpos,
                                          base_face_id, 0);
 
@@ -4142,8 +4083,6 @@ face_before_or_after_it_pos (struct it *it, int before_p)
       /* Determine face for CHARSET_ASCII, or unibyte.  */
       face_id = face_at_buffer_position (it->w,
                                          CHARPOS (pos),
-                                         it->region_beg_charpos,
-                                         it->region_end_charpos,
                                          &next_check_charpos,
                                          limit, 0, -1);
 
@@ -4473,8 +4412,8 @@ setup_for_ellipsis (struct it *it, int len)
   if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
     {
       struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
-      it->dpvec = v->u.contents;
-      it->dpend = v->u.contents + v->header.size;
+      it->dpvec = v->contents;
+      it->dpend = v->contents + v->header.size;
     }
   else
     {
@@ -6441,9 +6380,6 @@ reseat_to_string (struct it *it, const char *s, Lisp_Object string,
                   ptrdiff_t charpos, ptrdiff_t precision, int field_width,
                   int multibyte)
 {
-  /* No region in strings.  */
-  it->region_beg_charpos = it->region_end_charpos = -1;
-
   /* No text property checks performed by default, but see below.  */
   it->stop_charpos = -1;
 
@@ -6618,8 +6554,8 @@ lookup_glyphless_char_display (int c, struct it *it)
       if (c >= 0)
         {
           glyphless_method = CHAR_TABLE_REF (Vglyphless_char_display, c);
-          if (CONSP (glyphless_method))
-            glyphless_method = FRAME_WINDOW_P (it->f)
+      if (CONSP (glyphless_method))
+        glyphless_method = FRAME_WINDOW_P (it->f)
               ? XCAR (glyphless_method)
               : XCDR (glyphless_method);
         }
@@ -6778,8 +6714,8 @@ get_next_display_element (struct it *it)
               if (v->header.size)
                 {
                   it->dpvec_char_len = it->len;
-                  it->dpvec = v->u.contents;
-                  it->dpend = v->u.contents + v->header.size;
+                  it->dpvec = v->contents;
+                  it->dpend = v->contents + v->header.size;
                   it->current.dpvec_index = 0;
                   it->dpvec_face_id = -1;
                   it->saved_face_id = it->face_id;
@@ -6823,7 +6759,7 @@ get_next_display_element (struct it *it)
 
              Non-printable characters and raw-byte characters are also
              translated to octal form.  */
-          if (((c < ' ' || c == 127) /* ASCII control chars */
+          if (((c < ' ' || c == 127) /* ASCII control chars.  */
                ? (it->area != TEXT_AREA
                   /* In mode line, treat \n, \t like other crl chars.  */
                   || (c != '\t'
@@ -7033,8 +6969,7 @@ get_next_display_element (struct it *it)
                   INC_TEXT_POS (pos, it->multibyte_p);
 
                   next_face_id = face_at_buffer_position
-                    (it->w, CHARPOS (pos), it->region_beg_charpos,
-                     it->region_end_charpos, &ignore,
+                    (it->w, CHARPOS (pos), &ignore,
                      (IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT), 0,
                      -1);
                   it->end_of_box_run_p
@@ -9337,7 +9272,7 @@ move_it_by_lines (struct it *it, ptrdiff_t dvpos)
 
   /* The commented-out optimization uses vmotion on terminals.  This
      gives bad results, because elements like it->what, on which
-     callers such as pos_visible_p rely, aren't updated. */
+     callers such as pos_visible_p rely, aren't updated.  */
   /* struct position pos;
     if (!FRAME_WINDOW_P (it->f))
     {
@@ -9355,7 +9290,7 @@ move_it_by_lines (struct it *it, ptrdiff_t dvpos)
     {
       /* DVPOS == 0 means move to the start of the screen line.  */
       move_it_vertically_backward (it, 0);
-      /* Let next call to line_bottom_y calculate real line height */
+      /* Let next call to line_bottom_y calculate real line height.  */
       last_height = 0;
     }
   else if (dvpos > 0)
@@ -9553,6 +9488,7 @@ message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
       }
 
       bset_undo_list (current_buffer, Qt);
+      bset_cache_long_scans (current_buffer, Qnil);
 
       oldpoint = message_dolog_marker1;
       set_marker_restricted_both (oldpoint, Qnil, PT, PT_BYTE);
@@ -9698,7 +9634,7 @@ message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
          shown in some window.  So we must manually incrementing
          windows_or_buffers_changed here to make up for that.  */
       if (shown)
-        windows_or_buffers_changed++;
+        windows_or_buffers_changed = 41;
       else
         windows_or_buffers_changed = old_windows_or_buffers_changed;
       message_log_need_newline = !nlflag;
@@ -9793,7 +9729,11 @@ message3_nolog (Lisp_Object m)
         putc ('\n', stderr);
       noninteractive_need_newline = 0;
       if (STRINGP (m))
-        fwrite (SDATA (m), SBYTES (m), 1, stderr);
+        {
+          Lisp_Object s = ENCODE_SYSTEM (m);
+
+          fwrite (SDATA (s), SBYTES (s), 1, stderr);
+        }
       if (cursor_in_echo_area == 0)
         fprintf (stderr, "\n");
       fflush (stderr);
@@ -9868,13 +9808,19 @@ message_with_string (const char *m, Lisp_Object string, int log)
     {
       if (m)
         {
+          /* ENCODE_SYSTEM below can GC and/or relocate the Lisp
+             String whose data pointer might be passed to us in M.  So
+             we use a local copy.  */
+          char *fmt = xstrdup (m);
+
           if (noninteractive_need_newline)
             putc ('\n', stderr);
           noninteractive_need_newline = 0;
-          fprintf (stderr, m, SDATA (string));
+          fprintf (stderr, fmt, SDATA (ENCODE_SYSTEM (string)));
           if (!cursor_in_echo_area)
             fprintf (stderr, "\n");
           fflush (stderr);
+          xfree (fmt);
         }
     }
   else if (INTERACTIVE)
@@ -10391,8 +10337,8 @@ resize_echo_area_exactly (void)
                                          (intptr_t) w, resize_exactly);
       if (resized_p)
         {
-          ++windows_or_buffers_changed;
-          ++update_mode_lines;
+          windows_or_buffers_changed = 42;
+          update_mode_lines = 30;
           redisplay_internal ();
         }
     }
@@ -10788,7 +10734,7 @@ clear_garbaged_frames (void)
 
       frame_garbaged = 0;
       if (changed_count)
-        ++windows_or_buffers_changed;
+        windows_or_buffers_changed = 43;
     }
 }
 
@@ -10857,7 +10803,7 @@ echo_area_display (int update_frame_p)
                  pending input.  */
               ptrdiff_t count = SPECPDL_INDEX ();
               specbind (Qredisplay_dont_pause, Qt);
-              windows_or_buffers_changed = 1;
+              windows_or_buffers_changed = 44;
               redisplay_internal ();
               unbind_to (count, Qnil);
             }
@@ -10876,11 +10822,11 @@ echo_area_display (int update_frame_p)
              redisplay displays the minibuffer, so that the cursor will
              be replaced with what the minibuffer wants.  */
           if (cursor_in_echo_area)
-            ++windows_or_buffers_changed;
+            windows_or_buffers_changed = 45;
         }
     }
   else if (!EQ (mini_window, selected_window))
-    windows_or_buffers_changed++;
+    windows_or_buffers_changed = 46;
 
   /* Last displayed message is now the current message.  */
   echo_area_buffer[1] = echo_area_buffer[0];
@@ -10906,8 +10852,7 @@ buffer_shared_and_changed (void)
           && UNCHANGED_MODIFIED < MODIFF);
 }
 
-/* Nonzero if W's buffer was changed but not saved or Transient Mark mode
-   is enabled and mark of W's buffer was changed since last W's update.  */
+/* Nonzero if W's buffer was changed but not saved.  */
 
 static int
 window_buffer_changed (struct window *w)
@@ -10916,9 +10861,7 @@ window_buffer_changed (struct window *w)
 
   eassert (BUFFER_LIVE_P (b));
 
-  return (((BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)) != w->last_had_star)
-          || ((!NILP (Vtransient_mark_mode) && !NILP (BVAR (b, mark_active)))
-              != (w->region_showing != 0)));
+  return (((BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)) != w->last_had_star));
 }
 
 /* Nonzero if W has %c in its mode line and mode line should be updated.  */
@@ -11225,7 +11168,7 @@ x_consider_frame_title (Lisp_Object frame)
 /* Prepare for redisplay by updating menu-bar item lists when
    appropriate.  This can call eval.  */
 
-void
+static void
 prepare_menu_bars (void)
 {
   int all_windows;
@@ -11273,6 +11216,10 @@ prepare_menu_bars (void)
   all_windows = (update_mode_lines
                  || buffer_shared_and_changed ()
                  || windows_or_buffers_changed);
+
+  if (FUNCTIONP (Vpre_redisplay_function))
+    safe_call1 (Vpre_redisplay_function, all_windows ? Qt : Qnil);
+
   if (all_windows)
     {
       Lisp_Object tail, frame;
@@ -12940,12 +12887,12 @@ redisplay_internal (void)
   int polling_stopped_here = 0;
   Lisp_Object tail, frame;
 
-  /* Non-zero means redisplay has to consider all windows on all
-     frames.  Zero means, only selected_window is considered.  */
-  int consider_all_windows_p;
+  /* True means redisplay has to consider all windows on all
+     frames.  False, only selected_window is considered.  */
+  bool consider_all_windows_p;
 
-  /* Non-zero means redisplay has to redisplay the miniwindow.  */
-  int update_miniwindow_p = 0;
+  /* True means redisplay has to redisplay the miniwindow.  */
+  bool update_miniwindow_p = false;
 
   TRACE ((stderr, "redisplay_internal %d\n", redisplaying_p));
 
@@ -13001,7 +12948,7 @@ redisplay_internal (void)
      realized faces, which includes the faces referenced from current
      matrices.  So, we can't reuse current matrices in this case.  */
   if (face_change_count)
-    ++windows_or_buffers_changed;
+    windows_or_buffers_changed = 47;
 
   if ((FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf))
       && FRAME_TTY (sf)->previous_frame != sf)
@@ -13009,7 +12956,7 @@ redisplay_internal (void)
       /* Since frames on a single ASCII terminal share the same
          display area, displaying a different frame means redisplay
          the whole thing.  */
-      windows_or_buffers_changed++;
+      windows_or_buffers_changed = 48;
       SET_FRAME_GARBAGED (sf);
 #ifndef DOS_NT
       set_tty_color_mode (FRAME_TTY (sf), sf);
@@ -13038,7 +12985,7 @@ redisplay_internal (void)
           /* If cursor type has been changed on the frame
              other than selected, consider all frames.  */
           if (f != sf && f->cursor_type_changed)
-            update_mode_lines++;
+            update_mode_lines = 31;
         }
       clear_desired_matrices (f);
     }
@@ -13058,8 +13005,8 @@ redisplay_internal (void)
   if (NILP (Vmemory_full))
     prepare_menu_bars ();
 
-  if (windows_or_buffers_changed)
-    update_mode_lines++;
+  if (windows_or_buffers_changed && !update_mode_lines)
+    update_mode_lines = 32;
 
   reconsider_clip_changes (w);
 
@@ -13072,7 +13019,7 @@ redisplay_internal (void)
         {
           w->update_mode_line = 1;
           if (buffer_shared_and_changed ())
-            update_mode_lines++;
+            update_mode_lines = 33;
         }
 
       if (mode_line_update_needed (w))
@@ -13085,7 +13032,10 @@ redisplay_internal (void)
   /* If specs for an arrow have changed, do thorough redisplay
      to ensure we remove any arrow that should no longer exist.  */
   if (overlay_arrows_changed_p ())
-    consider_all_windows_p = windows_or_buffers_changed = 1;
+    {
+      consider_all_windows_p = true;
+      windows_or_buffers_changed = 49;
+    }
 
   /* Normally the message* functions will have already displayed and
      updated the echo area, but the frame may have been trashed, or
@@ -13103,7 +13053,7 @@ redisplay_internal (void)
       int window_height_changed_p = echo_area_display (0);
 
       if (message_cleared_p)
-        update_miniwindow_p = 1;
+        update_miniwindow_p = true;
 
       must_finish = 1;
 
@@ -13116,9 +13066,9 @@ redisplay_internal (void)
 
       if (window_height_changed_p)
         {
-          consider_all_windows_p = 1;
-          ++update_mode_lines;
-          ++windows_or_buffers_changed;
+          consider_all_windows_p = true;
+          update_mode_lines = 34;
+          windows_or_buffers_changed = 50;
 
           /* If window configuration was changed, frames may have been
              marked garbaged.  Clear them or we will experience
@@ -13137,9 +13087,9 @@ redisplay_internal (void)
          since only the current frame needs to be considered.  This function
          needs to be rewritten with two variables, consider_all_windows and
          consider_all_frames.  */
-      consider_all_windows_p = 1;
-      ++windows_or_buffers_changed;
-      ++update_mode_lines;
+      consider_all_windows_p = true;
+      windows_or_buffers_changed = 51;
+      update_mode_lines = 35;
 
       /* If window configuration was changed, frames may have been
          marked garbaged.  Clear them or we will experience
@@ -13147,16 +13097,23 @@ redisplay_internal (void)
       clear_garbaged_frames ();
     }
 
-  /* If showing the region, and mark has changed, we must redisplay
-     the whole window.  The assignment to this_line_start_pos prevents
-     the optimization directly below this if-statement.  */
-  if (((!NILP (Vtransient_mark_mode)
-        && !NILP (BVAR (XBUFFER (w->contents), mark_active)))
-       != (w->region_showing > 0))
-      || (w->region_showing
-          && w->region_showing
-          != XINT (Fmarker_position (BVAR (XBUFFER (w->contents), mark)))))
-    CHARPOS (this_line_start_pos) = 0;
+  if (VECTORP (Vredisplay__all_windows_cause)
+      && windows_or_buffers_changed >= 0
+      && windows_or_buffers_changed < ASIZE (Vredisplay__all_windows_cause)
+      && INTEGERP (AREF (Vredisplay__all_windows_cause,
+                         windows_or_buffers_changed)))
+    ASET (Vredisplay__all_windows_cause, windows_or_buffers_changed,
+          make_number (1 + XINT (AREF (Vredisplay__all_windows_cause,
+                                       windows_or_buffers_changed))));
+
+  if (VECTORP (Vredisplay__mode_lines_cause)
+      && update_mode_lines >= 0
+      && update_mode_lines < ASIZE (Vredisplay__mode_lines_cause)
+      && INTEGERP (AREF (Vredisplay__mode_lines_cause,
+                         update_mode_lines)))
+    ASET (Vredisplay__mode_lines_cause, update_mode_lines,
+          make_number (1 + XINT (AREF (Vredisplay__mode_lines_cause,
+                                       update_mode_lines))));
 
   /* Optimize the case that only the line containing the cursor in the
      selected window has changed.  Variables starting with this_ are
@@ -13317,13 +13274,7 @@ redisplay_internal (void)
         }
       /* If highlighting the region, or if the cursor is in the echo area,
          then we can't just move the cursor.  */
-      else if (! (!NILP (Vtransient_mark_mode)
-                  && !NILP (BVAR (current_buffer, mark_active)))
-               && (EQ (selected_window,
-                       BVAR (current_buffer, last_selected_window))
-                   || highlight_nonselected_windows)
-               && !w->region_showing
-               && NILP (Vshow_trailing_whitespace)
+      else if (NILP (Vshow_trailing_whitespace)
                && !cursor_in_echo_area)
         {
           struct it it;
@@ -13365,7 +13316,6 @@ redisplay_internal (void)
     }
 
   CHARPOS (this_line_start_pos) = 0;
-  consider_all_windows_p |= buffer_shared_and_changed ();
   ++clear_face_cache_count;
 #ifdef HAVE_WINDOW_SYSTEM
   ++clear_image_cache_count;
@@ -13544,7 +13494,7 @@ redisplay_internal (void)
          matrices of some windows are not valid.  */
       if (!WINDOW_FULL_WIDTH_P (w)
           && !FRAME_WINDOW_P (XFRAME (w->frame)))
-        update_mode_lines = 1;
+        update_mode_lines = 36;
     }
   else
     {
@@ -13595,7 +13545,7 @@ redisplay_internal (void)
         }
 
       if (new_count != number_of_visible_frames)
-        windows_or_buffers_changed++;
+        windows_or_buffers_changed = 52;
     }
 
   /* Change frame size now if a change is pending.  */
@@ -15003,11 +14953,6 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
       && !update_mode_lines
       && !windows_or_buffers_changed
       && !f->cursor_type_changed
-      /* Can't use this case if highlighting a region.  When a
-         region exists, cursor movement has to do more than just
-         set the cursor.  */
-      && markpos_of_region () < 0
-      && !w->region_showing
       && NILP (Vshow_trailing_whitespace)
       /* This code is not used for mini-buffer for the sake of the case
          of redisplaying to replace an echo area message; since in
@@ -15413,7 +15358,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
         }
       else if ((w != XWINDOW (minibuf_window)
                 || minibuf_level == 0)
-               /* When buffer is nonempty, redisplay window normally. */
+               /* When buffer is nonempty, redisplay window normally.  */
                && BUF_Z (XBUFFER (w->contents)) == BUF_BEG (XBUFFER (w->contents))
                /* Quail displays non-mini buffers in minibuffer window.
                   In that case, redisplay the window normally.  */
@@ -15622,7 +15567,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
              Move it back to a fully-visible line.  */
           new_vpos = window_box_height (w);
         }
-      else if (w->cursor.vpos >=0)
+      else if (w->cursor.vpos >= 0)
         {
           /* Some people insist on not letting point enter the scroll
              margin, even though this part handles windows that didn't
@@ -15680,12 +15625,14 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
           /* If we are highlighting the region, then we just changed
              the region, so redisplay to show it.  */
-          if (markpos_of_region () >= 0)
+          /* FIXME: We need to (re)run pre-redisplay-function!  */
+          /* if (markpos_of_region () >= 0)
             {
               clear_glyph_matrix (w->desired_matrix);
               if (!try_window (window, startp, 0))
                 goto need_larger_matrices;
             }
+          */
         }
 
 #ifdef GLYPH_DEBUG
@@ -16380,10 +16327,8 @@ try_window_reusing_current_matrix (struct window *w)
       || f->cursor_type_changed)
     return 0;
 
-  /* Can't do this if region may have changed.  */
-  if (markpos_of_region () >= 0
-      || w->region_showing
-      || !NILP (Vshow_trailing_whitespace))
+  /* Can't do this if showing trailing whitespace.  */
+  if (!NILP (Vshow_trailing_whitespace))
     return 0;
 
   /* If top-line visibility has changed, give up.  */
@@ -17181,19 +17126,10 @@ try_window_id (struct window *w)
   if (!w->window_end_valid)
     GIVE_UP (8);
 
-  /* Can't use this if highlighting a region because a cursor movement
-     will do more than just set the cursor.  */
-  if (markpos_of_region () >= 0)
-    GIVE_UP (9);
-
   /* Likewise if highlighting trailing whitespace.  */
   if (!NILP (Vshow_trailing_whitespace))
     GIVE_UP (11);
 
-  /* Likewise if showing a region.  */
-  if (w->region_showing)
-    GIVE_UP (10);
-
   /* Can't use this if overlay arrow position and/or string have
      changed.  */
   if (overlay_arrows_changed_p ())
@@ -18537,7 +18473,7 @@ append_space_for_newline (struct it *it, int default_face_p)
           it->len = 1;
 
           /* If the default face was remapped, be sure to use the
-             remapped face for the appended newline. */
+             remapped face for the appended newline.  */
           if (default_face_p)
             it->face_id = lookup_basic_face (it->f, DEFAULT_FACE_ID);
           else if (it->face_before_selective_p)
@@ -18615,7 +18551,9 @@ extend_face_to_end_of_line (struct it *it)
       && MATRIX_ROW_DISPLAYS_TEXT_P (it->glyph_row)
       && face->box == FACE_NO_BOX
       && face->background == FRAME_BACKGROUND_PIXEL (f)
+#ifdef HAVE_WINDOW_SYSTEM
       && !face->stipple
+#endif
       && !it->glyph_row->reversed_p)
     return;
 
@@ -19275,9 +19213,6 @@ display_line (struct it *it)
       return 0;
     }
 
-  /* Is IT->w showing the region?  */
-  it->w->region_showing = it->region_beg_charpos > 0 ? it->region_beg_charpos : 0;
-
   /* Clear the result glyph row and enable it.  */
   prepare_desired_row (row);
 
@@ -22411,9 +22346,7 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
 
       it->face_id
         = face_at_string_position (it->w, face_string, face_string_pos,
-                                   0, it->region_beg_charpos,
-                                   it->region_end_charpos,
-                                   &endptr, it->base_face_id, 0);
+                                   0, &endptr, it->base_face_id, 0);
       face = FACE_FROM_ID (it->f, it->face_id);
       it->face_box_p = face->box != FACE_NO_BOX;
     }
@@ -25140,7 +25073,7 @@ produce_glyphless_glyph (struct it *it, int for_no_font, Lisp_Object acronym)
       lower_yoff = descent - 2 - metrics_lower.descent;
       upper_yoff = (lower_yoff - metrics_lower.ascent - 1
                     - metrics_upper.descent);
-      /* Don't make the height shorter than the base height. */
+      /* Don't make the height shorter than the base height.  */
       if (height > base_height)
         {
           it->ascent = ascent;
@@ -25177,16 +25110,16 @@ x_produce_glyphs (struct it *it)
       struct face *face = FACE_FROM_ID (it->f, it->face_id);
       struct font *font = face->font;
       struct font_metrics *pcm = NULL;
-      int boff;                 /* baseline offset */
+      int boff;                 /* Baseline offset.  */
 
       if (font == NULL)
         {
           /* When no suitable font is found, display this character by
              the method specified in the first extra slot of
              Vglyphless_char_display.  */
-          Lisp_Object acronym = lookup_glyphless_char_display (-1, it);
+              Lisp_Object acronym = lookup_glyphless_char_display (-1, it);
 
-          eassert (it->what == IT_GLYPHLESS);
+              eassert (it->what == IT_GLYPHLESS);
           produce_glyphless_glyph (it, 1, STRINGP (acronym) ? acronym : Qnil);
           goto done;
         }
@@ -25324,7 +25257,7 @@ x_produce_glyphs (struct it *it)
         {
           /* A newline has no width, but we need the height of the
              line.  But if previous part of the line sets a height,
-             don't increase that height */
+             don't increase that height.  */
 
           Lisp_Object height;
           Lisp_Object total_height = Qnil;
@@ -25334,7 +25267,7 @@ x_produce_glyphs (struct it *it)
           it->nglyphs = 0;
 
           height = get_it_property (it, Qline_height);
-          /* Split (line-height total-height) list */
+          /* Split (line-height total-height) list.  */
           if (CONSP (height)
               && CONSP (XCDR (height))
               && NILP (XCDR (XCDR (height))))
@@ -26412,7 +26345,7 @@ draw_phys_cursor_glyph (struct window *w, struct glyph_row *row,
 
 /* Erase the image of a cursor of window W from the screen.  */
 
-#ifndef WINDOWSNT
+#ifndef HAVE_NTGUI
 static
 #endif
 void
@@ -27417,7 +27350,7 @@ mouse_face_from_buffer_pos (Lisp_Object window,
 
   hlinfo->mouse_face_window = window;
   hlinfo->mouse_face_face_id
-    = face_at_buffer_position (w, mouse_charpos, 0, 0, &ignore,
+    = face_at_buffer_position (w, mouse_charpos, &ignore,
                                mouse_charpos + 1,
                                !hlinfo->mouse_face_hidden, -1);
   show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
@@ -27683,7 +27616,7 @@ on_hot_spot_p (Lisp_Object hot_spot, int x, int y)
       if (VECTORP (XCDR (hot_spot)))
         {
           struct Lisp_Vector *v = XVECTOR (XCDR (hot_spot));
-          Lisp_Object *poly = v->u.contents;
+          Lisp_Object *poly = v->contents;
           ptrdiff_t n = v->header.size;
           ptrdiff_t i;
           int inside = 0;
@@ -28098,8 +28031,7 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
 
           hlinfo->mouse_face_face_id = face_at_string_position (w, string,
                                                                 charpos,
-                                                                0, 0, 0,
-                                                                &ignore,
+                                                                0, &ignore,
                                                                 glyph->face_id,
                                                                 1);
           show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
@@ -28400,7 +28332,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
               hlinfo->mouse_face_past_end = 0;
               hlinfo->mouse_face_window = window;
               hlinfo->mouse_face_face_id
-                = face_at_string_position (w, object, pos, 0, 0, 0, &ignore,
+                = face_at_string_position (w, object, pos, 0, &ignore,
                                            glyph->face_id, 1);
               show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
               cursor = No_Cursor;
@@ -28447,13 +28379,14 @@ note_mouse_highlight (struct frame *f, int x, int y)
                      the first row visible in a window does not
                      necessarily display the character whose position
                      is the smallest.  */
-                  Lisp_Object lim1 =
-                    NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
+                  Lisp_Object lim1
+                    = NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
                     ? Fmarker_position (w->start)
                     : Qnil;
-                  Lisp_Object lim2 =
-                    NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
-                    ? make_number (BUF_Z (XBUFFER (buffer)) - w->window_end_pos)
+                  Lisp_Object lim2
+                    = NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
+                    ? make_number (BUF_Z (XBUFFER (buffer))
+                                   - w->window_end_pos)
                     : Qnil;
 
                   if (NILP (overlay))
@@ -29786,6 +29719,13 @@ cursor shapes.  */);
   DEFSYM (Qthin_space, "thin-space");
   DEFSYM (Qzero_width, "zero-width");
 
+  DEFVAR_LISP ("pre-redisplay-function", Vpre_redisplay_function,
+               doc: /* Function run just before redisplay.
+It is called with one argument, which is the set of windows that are to
+be redisplayed.  This set can be nil (meaning, only the selected window),
+or t (meaning all windows).  */);
+  Vpre_redisplay_function = intern ("ignore");
+
   DEFSYM (Qglyphless_char_display, "glyphless-char-display");
   Fput (Qglyphless_char_display, Qchar_table_extra_slots, make_number (1));
 
@@ -29804,7 +29744,11 @@ GRAPHICAL and TEXT should each have one of the values listed above.
 The char-table has one extra slot to control the display of a character for
 which no font is found.  This slot only takes effect on graphical terminals.
 Its value should be an ASCII acronym string, `hex-code', `empty-box', or
-`thin-space'.  The default is `empty-box'.  */);
+`thin-space'.  The default is `empty-box'.
+
+If a character has a non-nil entry in an active display table, the
+display table takes effect; in this case, Emacs does not consult
+`glyphless-char-display' at all.  */);
   Vglyphless_char_display = Fmake_char_table (Qglyphless_char_display, Qnil);
   Fset_char_table_extra_slot (Vglyphless_char_display, make_number (0),
                               Qempty_box);
@@ -29812,6 +29756,16 @@ Its value should be an ASCII acronym string, `hex-code', `empty-box', or
   DEFVAR_LISP ("debug-on-message", Vdebug_on_message,
                doc: /* If non-nil, debug if a message matching this regexp is displayed.  */);
   Vdebug_on_message = Qnil;
+
+  DEFVAR_LISP ("redisplay--all-windows-cause", Vredisplay__all_windows_cause,
+               doc: /*  */);
+  Vredisplay__all_windows_cause
+    = Fmake_vector (make_number (100), make_number (0));
+
+  DEFVAR_LISP ("redisplay--mode-lines-cause", Vredisplay__mode_lines_cause,
+               doc: /*  */);
+  Vredisplay__mode_lines_cause
+    = Fmake_vector (make_number (100), make_number (0));
 }
 
 
diff --git a/src/xfaces.c b/src/xfaces.c
index 363d3bb0784..b9ddddfd9e2 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -292,7 +292,7 @@ Lisp_Object QCwidth;
 static Lisp_Object QCfont, QCbold, QCitalic;
 static Lisp_Object QCreverse_video;
 static Lisp_Object QCoverline, QCstrike_through, QCbox, QCinherit;
-static Lisp_Object QCfontset;
+static Lisp_Object QCfontset, QCdistant_foreground;
 
 /* Symbols used for attribute values.  */
 
@@ -440,6 +440,7 @@ static struct face_cache *make_face_cache (struct frame *);
 static void free_face_cache (struct face_cache *);
 static int merge_face_ref (struct frame *, Lisp_Object, Lisp_Object *,
                            int, struct named_merge_point *);
+static int color_distance (XColor *x, XColor *y);
 
 #ifdef HAVE_WINDOW_SYSTEM
 static void set_font_frame_param (Lisp_Object, Lisp_Object);
@@ -535,7 +536,7 @@ DEFUN ("dump-colors", Fdump_colors, Sdump_colors, 0, 0, 0,
    is called.  */
 
 void
-x_free_colors (struct frame *f, long unsigned int *pixels, int npixels)
+x_free_colors (struct frame *f, unsigned long *pixels, int npixels)
 {
   int class = FRAME_DISPLAY_INFO (f)->visual->class;
 
@@ -560,7 +561,7 @@ x_free_colors (struct frame *f, long unsigned int *pixels, int npixels)
 
 void
 x_free_dpy_colors (Display *dpy, Screen *screen, Colormap cmap,
-                   long unsigned int *pixels, int npixels)
+                   unsigned long *pixels, int npixels)
 {
   struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
   int class = dpyinfo->visual->class;
@@ -581,7 +582,7 @@ x_free_dpy_colors (Display *dpy, Screen *screen, Colormap cmap,
    are given by XGCV and MASK.  */
 
 static GC
-x_create_gc (struct frame *f, long unsigned int mask, XGCValues *xgcv)
+x_create_gc (struct frame *f, unsigned long mask, XGCValues *xgcv)
 {
   GC gc;
   block_input ();
@@ -787,7 +788,7 @@ Optional THOROUGHLY non-nil means try to free unused fonts, too.  */)
 {
   clear_face_cache (!NILP (thoroughly));
   ++face_change_count;
-  ++windows_or_buffers_changed;
+  windows_or_buffers_changed = 53;
   return Qnil;
 }
 
@@ -853,12 +854,10 @@ the pixmap.  Bits are stored row by row, each row occupies
    pixmap spec) for use on frame F.  Value is the bitmap_id (see
    xfns.c).  If NAME is nil, return with a bitmap id of zero.  If
    bitmap cannot be loaded, display a message saying so, and return
-   zero.  Store the bitmap width in *W_PTR and its height in *H_PTR,
-   if these pointers are not null.  */
+   zero.  */
 
 static ptrdiff_t
-load_pixmap (struct frame *f, Lisp_Object name, unsigned int *w_ptr,
-             unsigned int *h_ptr)
+load_pixmap (struct frame *f, Lisp_Object name)
 {
   ptrdiff_t bitmap_id;
 
@@ -893,22 +892,12 @@ load_pixmap (struct frame *f, Lisp_Object name, unsigned int *w_ptr,
     {
       add_to_log ("Invalid or undefined bitmap `%s'", name, Qnil);
       bitmap_id = 0;
-
-      if (w_ptr)
-        *w_ptr = 0;
-      if (h_ptr)
-        *h_ptr = 0;
     }
   else
     {
 #ifdef GLYPH_DEBUG
       ++npixmaps_allocated;
 #endif
-      if (w_ptr)
-        *w_ptr = x_bitmap_width (f, bitmap_id);
-
-      if (h_ptr)
-        *h_ptr = x_bitmap_height (f, bitmap_id);
     }
 
   return bitmap_id;
@@ -922,6 +911,8 @@ load_pixmap (struct frame *f, Lisp_Object name, unsigned int *w_ptr,
                                 X Colors
  ***********************************************************************/
 
+#define NEAR_SAME_COLOR_THRESHOLD 30000
+
 /* Parse RGB_LIST, and fill in the RGB fields of COLOR.
    RGB_LIST should contain (at least) 3 lisp integers.
    Return 0 if there's a problem with RGB_LIST, otherwise return 1.  */
@@ -1188,24 +1179,10 @@ COLOR must be a valid color name.  */)
 }
 
 
-/* Load color with name NAME for use by face FACE on frame F.
-   TARGET_INDEX must be one of LFACE_FOREGROUND_INDEX,
-   LFACE_BACKGROUND_INDEX, LFACE_UNDERLINE_INDEX, LFACE_OVERLINE_INDEX,
-   LFACE_STRIKE_THROUGH_INDEX, or LFACE_BOX_INDEX.  Value is the
-   pixel color.  If color cannot be loaded, display a message, and
-   return the foreground, background or underline color of F, but
-   record that fact in flags of the face so that we don't try to free
-   these colors.  */
-
-#ifndef MSDOS
-static
-#endif
-unsigned long
-load_color (struct frame *f, struct face *face, Lisp_Object name,
-            enum lface_attribute_index target_index)
+static unsigned long
+load_color2 (struct frame *f, struct face *face, Lisp_Object name,
+             enum lface_attribute_index target_index, XColor *color)
 {
-  XColor color;
-
   eassert (STRINGP (name));
   eassert (target_index == LFACE_FOREGROUND_INDEX
            || target_index == LFACE_BACKGROUND_INDEX
@@ -1216,7 +1193,7 @@ load_color (struct frame *f, struct face *face, Lisp_Object name,
 
   /* if the color map is full, defined_color will return a best match
      to the values in an existing cell. */
-  if (!defined_color (f, SSDATA (name), &color, 1))
+  if (!defined_color (f, SSDATA (name), color, 1))
     {
       add_to_log ("Unable to load color \"%s\"", name, Qnil);
 
@@ -1224,32 +1201,32 @@ load_color (struct frame *f, struct face *face, Lisp_Object name,
         {
         case LFACE_FOREGROUND_INDEX:
           face->foreground_defaulted_p = 1;
-          color.pixel = FRAME_FOREGROUND_PIXEL (f);
+          color->pixel = FRAME_FOREGROUND_PIXEL (f);
           break;
 
         case LFACE_BACKGROUND_INDEX:
           face->background_defaulted_p = 1;
-          color.pixel = FRAME_BACKGROUND_PIXEL (f);
+          color->pixel = FRAME_BACKGROUND_PIXEL (f);
           break;
 
         case LFACE_UNDERLINE_INDEX:
           face->underline_defaulted_p = 1;
-          color.pixel = FRAME_FOREGROUND_PIXEL (f);
+          color->pixel = FRAME_FOREGROUND_PIXEL (f);
           break;
 
         case LFACE_OVERLINE_INDEX:
           face->overline_color_defaulted_p = 1;
-          color.pixel = FRAME_FOREGROUND_PIXEL (f);
+          color->pixel = FRAME_FOREGROUND_PIXEL (f);
           break;
 
         case LFACE_STRIKE_THROUGH_INDEX:
           face->strike_through_color_defaulted_p = 1;
-          color.pixel = FRAME_FOREGROUND_PIXEL (f);
+          color->pixel = FRAME_FOREGROUND_PIXEL (f);
           break;
 
         case LFACE_BOX_INDEX:
           face->box_color_defaulted_p = 1;
-          color.pixel = FRAME_FOREGROUND_PIXEL (f);
+          color->pixel = FRAME_FOREGROUND_PIXEL (f);
           break;
 
         default:
@@ -1261,7 +1238,27 @@ load_color (struct frame *f, struct face *face, Lisp_Object name,
     ++ncolors_allocated;
 #endif
 
-  return color.pixel;
+  return color->pixel;
+}
+
+/* Load color with name NAME for use by face FACE on frame F.
+   TARGET_INDEX must be one of LFACE_FOREGROUND_INDEX,
+   LFACE_BACKGROUND_INDEX, LFACE_UNDERLINE_INDEX, LFACE_OVERLINE_INDEX,
+   LFACE_STRIKE_THROUGH_INDEX, or LFACE_BOX_INDEX.  Value is the
+   pixel color.  If color cannot be loaded, display a message, and
+   return the foreground, background or underline color of F, but
+   record that fact in flags of the face so that we don't try to free
+   these colors.  */
+
+#ifndef MSDOS
+static
+#endif
+unsigned long
+load_color (struct frame *f, struct face *face, Lisp_Object name,
+            enum lface_attribute_index target_index)
+{
+  XColor color;
+  return load_color2 (f, face, name, target_index, &color);
 }
 
 
@@ -1276,7 +1273,8 @@ static void
 load_face_colors (struct frame *f, struct face *face,
                   Lisp_Object attrs[LFACE_VECTOR_SIZE])
 {
-  Lisp_Object fg, bg;
+  Lisp_Object fg, bg, dfg;
+  XColor xfg, xbg;
 
   bg = attrs[LFACE_BACKGROUND_INDEX];
   fg = attrs[LFACE_FOREGROUND_INDEX];
@@ -1298,38 +1296,45 @@ load_face_colors (struct frame *f, struct face *face,
       && !NILP (Fbitmap_spec_p (Vface_default_stipple)))
     {
       x_destroy_bitmap (f, face->stipple);
-      face->stipple = load_pixmap (f, Vface_default_stipple,
-                                   &face->pixmap_w, &face->pixmap_h);
+      face->stipple = load_pixmap (f, Vface_default_stipple);
     }
 
-  face->background = load_color (f, face, bg, LFACE_BACKGROUND_INDEX);
-  face->foreground = load_color (f, face, fg, LFACE_FOREGROUND_INDEX);
+  face->background = load_color2 (f, face, bg, LFACE_BACKGROUND_INDEX, &xbg);
+  face->foreground = load_color2 (f, face, fg, LFACE_FOREGROUND_INDEX, &xfg);
+
+  dfg = attrs[LFACE_DISTANT_FOREGROUND_INDEX];
+  if (!NILP (dfg) && !UNSPECIFIEDP (dfg)
+      && color_distance (&xbg, &xfg) < NEAR_SAME_COLOR_THRESHOLD)
+    {
+      if (EQ (attrs[LFACE_INVERSE_INDEX], Qt))
+        face->background = load_color (f, face, dfg, LFACE_BACKGROUND_INDEX);
+      else
+        face->foreground = load_color (f, face, dfg, LFACE_FOREGROUND_INDEX);
+    }
 }
 
+#ifdef HAVE_X_WINDOWS
 
 /* Free color PIXEL on frame F.  */
 
 void
-unload_color (struct frame *f, long unsigned int pixel)
+unload_color (struct frame *f, unsigned long pixel)
 {
-#ifdef HAVE_X_WINDOWS
   if (pixel != -1)
     {
       block_input ();
       x_free_colors (f, &pixel, 1);
       unblock_input ();
     }
-#endif
 }
 
-
 /* Free colors allocated for FACE.  */
 
 static void
 free_face_colors (struct frame *f, struct face *face)
 {
-/* PENDING(NS): need to do something here? */
-#ifdef HAVE_X_WINDOWS
+  /* PENDING(NS): need to do something here? */
+
   if (face->colors_copied_bitwise_p)
     return;
 
@@ -1376,9 +1381,10 @@ free_face_colors (struct frame *f, struct face *face)
     }
 
   unblock_input ();
-#endif /* HAVE_X_WINDOWS */
 }
 
+#endif /* HAVE_X_WINDOWS */
+
 #endif /* HAVE_WINDOW_SYSTEM */
 
 
@@ -1563,7 +1569,7 @@ the face font sort order.  */)
   vec = Fvconcat (ndrivers, drivers);
   nfonts = ASIZE (vec);
 
-  qsort (XVECTOR (vec)->u.contents, nfonts, word_size,
+  qsort (XVECTOR (vec)->contents, nfonts, word_size,
          compare_fonts_by_sort_order);
 
   result = Qnil;
@@ -1735,6 +1741,8 @@ the WIDTH times as wide as FACE on FRAME.  */)
 #define LFACE_FONT(LFACE)           AREF ((LFACE), LFACE_FONT_INDEX)
 #define LFACE_INHERIT(LFACE)        AREF ((LFACE), LFACE_INHERIT_INDEX)
 #define LFACE_FONTSET(LFACE)        AREF ((LFACE), LFACE_FONTSET_INDEX)
+#define LFACE_DISTANT_FOREGROUND(LFACE) \
+  AREF ((LFACE), LFACE_DISTANT_FOREGROUND_INDEX)
 
 /* Non-zero if LFACE is a Lisp face.  A Lisp face is a vector of size
    LFACE_VECTOR_SIZE which has the symbol `face' in slot 0.  */
@@ -1797,6 +1805,9 @@ check_lface_attrs (Lisp_Object attrs[LFACE_VECTOR_SIZE])
   eassert (UNSPECIFIEDP (attrs[LFACE_FOREGROUND_INDEX])
            || IGNORE_DEFFACE_P (attrs[LFACE_FOREGROUND_INDEX])
            || STRINGP (attrs[LFACE_FOREGROUND_INDEX]));
+  eassert (UNSPECIFIEDP (attrs[LFACE_DISTANT_FOREGROUND_INDEX])
+           || IGNORE_DEFFACE_P (attrs[LFACE_DISTANT_FOREGROUND_INDEX])
+           || STRINGP (attrs[LFACE_DISTANT_FOREGROUND_INDEX]));
   eassert (UNSPECIFIEDP (attrs[LFACE_BACKGROUND_INDEX])
            || IGNORE_DEFFACE_P (attrs[LFACE_BACKGROUND_INDEX])
            || STRINGP (attrs[LFACE_BACKGROUND_INDEX]));
@@ -1828,7 +1839,7 @@ check_lface (Lisp_Object lface)
   if (!NILP (lface))
     {
       eassert (LFACEP (lface));
-      check_lface_attrs (XVECTOR (lface)->u.contents);
+      check_lface_attrs (XVECTOR (lface)->contents);
     }
 }
 
@@ -2005,7 +2016,7 @@ get_lface_attributes_no_remap (struct frame *f, Lisp_Object face_name,
   lface = lface_from_face_name_no_resolve (f, face_name, signal_p);
 
   if (! NILP (lface))
-    memcpy (attrs, XVECTOR (lface)->u.contents,
+    memcpy (attrs, XVECTOR (lface)->contents,
             LFACE_VECTOR_SIZE * sizeof *attrs);
 
   return !NILP (lface);
@@ -2062,7 +2073,8 @@ lface_fully_specified_p (Lisp_Object attrs[LFACE_VECTOR_SIZE])
   int i;
 
   for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
-    if (i != LFACE_FONT_INDEX && i != LFACE_INHERIT_INDEX)
+    if (i != LFACE_FONT_INDEX && i != LFACE_INHERIT_INDEX
+        && i != LFACE_DISTANT_FOREGROUND_INDEX)
       if ((UNSPECIFIEDP (attrs[i]) || IGNORE_DEFFACE_P (attrs[i])))
         break;
 
@@ -2463,6 +2475,13 @@ merge_face_ref (struct frame *f, Lisp_Object face_ref, Lisp_Object *to,
                   else
                     err = 1;
                 }
+              else if (EQ (keyword, QCdistant_foreground))
+                {
+                  if (STRINGP (value))
+                    to[LFACE_DISTANT_FOREGROUND_INDEX] = value;
+                  else
+                    err = 1;
+                }
               else if (EQ (keyword, QCbackground))
                 {
                   if (STRINGP (value))
@@ -2619,7 +2638,7 @@ Value is a vector of face attributes.  */)
   if (NILP (Fget (face, Qface_no_inherit)))
     {
       ++face_change_count;
-      ++windows_or_buffers_changed;
+      windows_or_buffers_changed = 54;
     }
 
   eassert (LFACEP (lface));
@@ -2688,7 +2707,7 @@ The value is TO.  */)
       copy = Finternal_make_lisp_face (to, new_frame);
     }
 
-  vcopy (copy, 0, XVECTOR (lface)->u.contents, LFACE_VECTOR_SIZE);
+  vcopy (copy, 0, XVECTOR (lface)->contents, LFACE_VECTOR_SIZE);
 
   /* Changing a named face means that all realized faces depending on
      that face are invalid.  Since we cannot tell which realized faces
@@ -2698,7 +2717,7 @@ The value is TO.  */)
   if (NILP (Fget (to, Qface_no_inherit)))
     {
       ++face_change_count;
-      ++windows_or_buffers_changed;
+      windows_or_buffers_changed = 55;
     }
 
   return to;
@@ -3019,6 +3038,23 @@ FRAME 0 means change the face on all frames, and change the default
       old_value = LFACE_FOREGROUND (lface);
       ASET (lface, LFACE_FOREGROUND_INDEX, value);
     }
+  else if (EQ (attr, QCdistant_foreground))
+    {
+      /* Compatibility with 20.x.  */
+      if (NILP (value))
+        value = Qunspecified;
+      if (!UNSPECIFIEDP (value) && !IGNORE_DEFFACE_P (value))
+        {
+          /* Don't check for valid color names here because it depends
+             on the frame (display) whether the color will be valid
+             when the face is realized.  */
+          CHECK_STRING (value);
+          if (SCHARS (value) == 0)
+            signal_error ("Empty distant-foreground color value", value);
+        }
+      old_value = LFACE_DISTANT_FOREGROUND (lface);
+      ASET (lface, LFACE_DISTANT_FOREGROUND_INDEX, value);
+    }
   else if (EQ (attr, QCbackground))
     {
       /* Compatibility with 20.x.  */
@@ -3091,7 +3127,7 @@ FRAME 0 means change the face on all frames, and change the default
                 f = XFRAME (frame);
               if (! FONT_OBJECT_P (value))
                 {
-                  Lisp_Object *attrs = XVECTOR (lface)->u.contents;
+                  Lisp_Object *attrs = XVECTOR (lface)->contents;
                   Lisp_Object font_object;
 
                   font_object = font_load_for_lface (f, attrs, value);
@@ -3159,7 +3195,7 @@ FRAME 0 means change the face on all frames, and change the default
          the font to nil so that the font selector doesn't think that
          the attribute is mandatory.  Also, clear the average
          width.  */
-      font_clear_prop (XVECTOR (lface)->u.contents, prop_index);
+      font_clear_prop (XVECTOR (lface)->contents, prop_index);
     }
 
   /* Changing a named face means that all realized faces depending on
@@ -3172,7 +3208,7 @@ FRAME 0 means change the face on all frames, and change the default
       && NILP (Fequal (old_value, value)))
     {
       ++face_change_count;
-      ++windows_or_buffers_changed;
+      windows_or_buffers_changed = 56;
     }
 
   if (!UNSPECIFIEDP (value) && !IGNORE_DEFFACE_P (value)
@@ -3186,10 +3222,10 @@ FRAME 0 means change the face on all frames, and change the default
         {
 #ifdef HAVE_WINDOW_SYSTEM
           /* Changed font-related attributes of the `default' face are
-             reflected in changed `font' frame parameters. */
+             reflected in changed `font' frame parameters.  */
           if (FRAMEP (frame)
               && (prop_index || EQ (attr, QCfont))
-              && lface_fully_specified_p (XVECTOR (lface)->u.contents))
+              && lface_fully_specified_p (XVECTOR (lface)->contents))
             set_font_frame_param (frame, lface);
           else
 #endif /* HAVE_WINDOW_SYSTEM */
@@ -3345,7 +3381,7 @@ update_face_from_frame_parameter (struct frame *f, Lisp_Object param,
       && NILP (Fget (face, Qface_no_inherit)))
     {
       ++face_change_count;
-      ++windows_or_buffers_changed;
+      windows_or_buffers_changed = 57;
     }
 }
 
@@ -3369,7 +3405,7 @@ set_font_frame_param (Lisp_Object frame, Lisp_Object lface)
     {
       if (FONT_SPEC_P (font))
         {
-          font = font_load_for_lface (f, XVECTOR (lface)->u.contents, font);
+          font = font_load_for_lface (f, XVECTOR (lface)->contents, font);
           if (NILP (font))
             return;
           ASET (lface, LFACE_FONT_INDEX, font);
@@ -3663,6 +3699,8 @@ frames).  If FRAME is omitted or nil, use the selected frame.  */)
     value = LFACE_INVERSE (lface);
   else if (EQ (keyword, QCforeground))
     value = LFACE_FOREGROUND (lface);
+  else if (EQ (keyword, QCdistant_foreground))
+    value = LFACE_DISTANT_FOREGROUND (lface);
   else if (EQ (keyword, QCbackground))
     value = LFACE_BACKGROUND (lface);
   else if (EQ (keyword, QCstipple))
@@ -3726,8 +3764,8 @@ Default face attributes override any local face attributes.  */)
      the local frame is defined from default specs in `face-defface-spec'
      and those should be overridden by global settings.  Hence the strange
      "global before local" priority.  */
-  lvec = XVECTOR (local_lface)->u.contents;
-  gvec = XVECTOR (global_lface)->u.contents;
+  lvec = XVECTOR (local_lface)->contents;
+  gvec = XVECTOR (global_lface)->contents;
   for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
     if (IGNORE_DEFFACE_P (gvec[i]))
       ASET (local_lface, i, Qunspecified);
@@ -3911,8 +3949,8 @@ If FRAME is omitted or nil, use the selected frame.  */)
 
   lface1 = lface_from_face_name (f, face1, 1);
   lface2 = lface_from_face_name (f, face2, 1);
-  equal_p = lface_equal_p (XVECTOR (lface1)->u.contents,
-                           XVECTOR (lface2)->u.contents);
+  equal_p = lface_equal_p (XVECTOR (lface1)->contents,
+                           XVECTOR (lface2)->contents);
   return equal_p ? Qt : Qnil;
 }
 
@@ -4018,9 +4056,13 @@ lface_same_font_attributes_p (Lisp_Object *lface1, Lisp_Object *lface2)
 static struct face *
 make_realized_face (Lisp_Object *attr)
 {
-  struct face *face = xzalloc (sizeof *face);
-  face->ascii_face = face;
+  enum { off = offsetof (struct face, id) };
+  struct face *face = xmalloc (sizeof *face);
+
   memcpy (face->lface, attr, sizeof face->lface);
+  memset (&face->id, 0, sizeof *face - off);
+  face->ascii_face = face;
+
   return face;
 }
 
@@ -4048,8 +4090,9 @@ free_realized_face (struct frame *f, struct face *face)
               face->gc = 0;
               unblock_input ();
             }
-
+#ifdef HAVE_X_WINDOWS
           free_face_colors (f, face);
+#endif /* HAVE_X_WINDOWS */
           x_destroy_bitmap (f, face->stipple);
         }
 #endif /* HAVE_WINDOW_SYSTEM */
@@ -4231,7 +4274,7 @@ free_realized_faces (struct face_cache *c)
       if (WINDOWP (f->root_window))
         {
           clear_current_matrices (f);
-          ++windows_or_buffers_changed;
+          windows_or_buffers_changed = 58;
         }
 
       unblock_input ();
@@ -4649,7 +4692,7 @@ DEFUN ("face-attributes-as-vector", Fface_attributes_as_vector,
   Lisp_Object lface;
   lface = Fmake_vector (make_number (LFACE_VECTOR_SIZE),
                         Qunspecified);
-  merge_face_ref (XFRAME (selected_frame), plist, XVECTOR (lface)->u.contents,
+  merge_face_ref (XFRAME (selected_frame), plist, XVECTOR (lface)->contents,
                   1, 0);
   return lface;
 }
@@ -4669,7 +4712,7 @@ DEFUN ("face-attributes-as-vector", Fface_attributes_as_vector,
 
 #ifdef HAVE_WINDOW_SYSTEM
 
-/* Return non-zero if all the face attributes in ATTRS are supported
+/* Return true if all the face attributes in ATTRS are supported
    on the window-system frame F.
 
    The definition of `supported' is somewhat heuristic, but basically means
@@ -4679,7 +4722,7 @@ DEFUN ("face-attributes-as-vector", Fface_attributes_as_vector,
     \(1) different in appearance than the default face, and
     \(2) `close in spirit' to what the attributes specify, if not exact.  */
 
-static int
+static bool
 x_supports_face_attributes_p (struct frame *f,
                               Lisp_Object attrs[LFACE_VECTOR_SIZE],
                               struct face *def_face)
@@ -4697,6 +4740,9 @@ x_supports_face_attributes_p (struct frame *f,
       || (!UNSPECIFIEDP (attrs[LFACE_FOREGROUND_INDEX])
           && face_attr_equal_p (attrs[LFACE_FOREGROUND_INDEX],
                                 def_attrs[LFACE_FOREGROUND_INDEX]))
+      || (!UNSPECIFIEDP (attrs[LFACE_DISTANT_FOREGROUND_INDEX])
+          && face_attr_equal_p (attrs[LFACE_DISTANT_FOREGROUND_INDEX],
+                                def_attrs[LFACE_DISTANT_FOREGROUND_INDEX]))
       || (!UNSPECIFIEDP (attrs[LFACE_BACKGROUND_INDEX])
           && face_attr_equal_p (attrs[LFACE_BACKGROUND_INDEX],
                                 def_attrs[LFACE_BACKGROUND_INDEX]))
@@ -4766,7 +4812,7 @@ x_supports_face_attributes_p (struct frame *f,
 
 #endif  /* HAVE_WINDOW_SYSTEM */
 
-/* Return non-zero if all the face attributes in ATTRS are supported
+/* Return true if all the face attributes in ATTRS are supported
    on the tty frame F.
 
    The definition of `supported' is somewhat heuristic, but basically means
@@ -4782,7 +4828,7 @@ x_supports_face_attributes_p (struct frame *f,
    will _not_ be satisfied by the tty display code's automatic
    substitution of a `dim' face for italic.  */
 
-static int
+static bool
 tty_supports_face_attributes_p (struct frame *f,
                                 Lisp_Object attrs[LFACE_VECTOR_SIZE],
                                 struct face *def_face)
@@ -4876,12 +4922,6 @@ tty_supports_face_attributes_p (struct frame *f,
 
   /* Color testing.  */
 
-  /* Default the color indices in FG_TTY_COLOR and BG_TTY_COLOR, since
-     we use them when calling `tty_capable_p' below, even if the face
-     specifies no colors.  */
-  fg_tty_color.pixel = FACE_TTY_DEFAULT_FG_COLOR;
-  bg_tty_color.pixel = FACE_TTY_DEFAULT_BG_COLOR;
-
   /* Check if foreground color is close enough.  */
   fg = attrs[LFACE_FOREGROUND_INDEX];
   if (STRINGP (fg))
@@ -4947,14 +4987,7 @@ tty_supports_face_attributes_p (struct frame *f,
 
   /* See if the capabilities we selected above are supported, with the
      given colors.  */
-  if (test_caps != 0 &&
-      ! tty_capable_p (FRAME_TTY (f), test_caps, fg_tty_color.pixel,
-                       bg_tty_color.pixel))
-    return 0;
-
-
-  /* Hmmm, everything checks out, this terminal must support this face.  */
-  return 1;
+  return tty_capable_p (FRAME_TTY (f), test_caps);
 }
 
 
@@ -4979,7 +5012,8 @@ satisfied by the tty display code's automatic substitution of a `dim'
 face for italic.  */)
   (Lisp_Object attributes, Lisp_Object display)
 {
-  int supports = 0, i;
+  bool supports = 0;
+  int i;
   Lisp_Object frame;
   struct frame *f;
   struct face *def_face;
@@ -5329,9 +5363,9 @@ realize_default_face (struct frame *f)
     ASET (lface, LFACE_STIPPLE_INDEX, Qnil);
 
   /* Realize the face; it must be fully-specified now.  */
-  eassert (lface_fully_specified_p (XVECTOR (lface)->u.contents));
+  eassert (lface_fully_specified_p (XVECTOR (lface)->contents));
   check_lface (lface);
-  memcpy (attrs, XVECTOR (lface)->u.contents, sizeof attrs);
+  memcpy (attrs, XVECTOR (lface)->contents, sizeof attrs);
   face = realize_face (c, attrs, DEFAULT_FACE_ID);
 
 #ifdef HAVE_WINDOW_SYSTEM
@@ -5716,7 +5750,7 @@ realize_x_face (struct face_cache *cache, Lisp_Object attrs[LFACE_VECTOR_SIZE])
 
   stipple = attrs[LFACE_STIPPLE_INDEX];
   if (!NILP (stipple))
-    face->stipple = load_pixmap (f, stipple, &face->pixmap_w, &face->pixmap_h);
+    face->stipple = load_pixmap (f, stipple);
 #endif /* HAVE_WINDOW_SYSTEM */
 
   return face;
@@ -5925,7 +5959,6 @@ compute_char_face (struct frame *f, int ch, Lisp_Object prop)
 
 int
 face_at_buffer_position (struct window *w, ptrdiff_t pos,
-                         ptrdiff_t region_beg, ptrdiff_t region_end,
                          ptrdiff_t *endptr, ptrdiff_t limit,
                          int mouse, int base_face_id)
 {
@@ -5946,8 +5979,6 @@ face_at_buffer_position (struct window *w, ptrdiff_t pos,
   XSETFASTINT (position, pos);
 
   endpos = ZV;
-  if (pos < region_beg && region_beg < endpos)
-    endpos = region_beg;
 
   /* Get the `face' or `mouse_face' text property at POS, and
      determine the next position at which the property changes.  */
@@ -5983,8 +6014,7 @@ 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)
-      && !(pos >= region_beg && pos < region_end))
+      && NILP (prop))
     return default_face->id;
 
   /* Begin with attributes from the default face.  */
@@ -6011,15 +6041,6 @@ face_at_buffer_position (struct window *w, ptrdiff_t pos,
         endpos = oendpos;
     }
 
-  /* If in the region, merge in the region face.  */
-  if (pos >= region_beg && pos < region_end)
-    {
-      merge_named_face (f, Qregion, attrs, 0);
-
-      if (region_end < endpos)
-        endpos = region_end;
-    }
-
   *endptr = endpos;
 
   /* Look up a realized face with the given face attributes,
@@ -6035,7 +6056,6 @@ face_at_buffer_position (struct window *w, ptrdiff_t pos,
 
 int
 face_for_overlay_string (struct window *w, ptrdiff_t pos,
-                         ptrdiff_t region_beg, ptrdiff_t region_end,
                          ptrdiff_t *endptr, ptrdiff_t limit,
                          int mouse, Lisp_Object overlay)
 {
@@ -6054,8 +6074,6 @@ face_for_overlay_string (struct window *w, ptrdiff_t pos,
   XSETFASTINT (position, pos);
 
   endpos = ZV;
-  if (pos < region_beg && region_beg < endpos)
-    endpos = region_beg;
 
   /* Get the `face' or `mouse_face' text property at POS, and
      determine the next position at which the property changes.  */
@@ -6069,7 +6087,6 @@ face_for_overlay_string (struct window *w, ptrdiff_t pos,
 
   /* Optimize common case where we can use the default face.  */
   if (NILP (prop)
-      && !(pos >= region_beg && pos < region_end)
       && NILP (Vface_remapping_alist))
     return DEFAULT_FACE_ID;
 
@@ -6081,15 +6098,6 @@ face_for_overlay_string (struct window *w, ptrdiff_t pos,
   if (!NILP (prop))
     merge_face_ref (f, prop, attrs, 1, 0);
 
-  /* If in the region, merge in the region face.  */
-  if (pos >= region_beg && pos < region_end)
-    {
-      merge_named_face (f, Qregion, attrs, 0);
-
-      if (region_end < endpos)
-        endpos = region_end;
-    }
-
   *endptr = endpos;
 
   /* Look up a realized face with the given face attributes,
@@ -6122,7 +6130,6 @@ face_for_overlay_string (struct window *w, ptrdiff_t pos,
 int
 face_at_string_position (struct window *w, Lisp_Object string,
                          ptrdiff_t pos, ptrdiff_t bufpos,
-                         ptrdiff_t region_beg, ptrdiff_t region_end,
                          ptrdiff_t *endptr, enum face_id base_face_id,
                          int mouse_p)
 {
@@ -6154,15 +6161,8 @@ face_at_string_position (struct window *w, Lisp_Object string,
   base_face = FACE_FROM_ID (f, base_face_id);
   eassert (base_face);
 
-  /* Optimize the default case that there is no face property and we
-     are not in the region.  */
+  /* Optimize the default case that there is no face property.  */
   if (NILP (prop)
-      && (base_face_id != DEFAULT_FACE_ID
-          /* BUFPOS <= 0 means STRING is not an overlay string, so
-             that the region doesn't have to be taken into account.  */
-          || bufpos <= 0
-          || bufpos < region_beg
-          || bufpos >= region_end)
       && (multibyte_p
           /* We can't realize faces for different charsets differently
              if we don't have fonts, so we can stop here if not working
@@ -6178,12 +6178,6 @@ face_at_string_position (struct window *w, Lisp_Object string,
   if (!NILP (prop))
     merge_face_ref (f, prop, attrs, 1, 0);
 
-  /* If in the region, merge in the region face.  */
-  if (bufpos
-      && bufpos >= region_beg
-      && bufpos < region_end)
-    merge_named_face (f, Qregion, attrs, 0);
-
   /* Look up a realized face with the given face attributes,
      or realize a new one for ASCII characters.  */
   return lookup_face (f, attrs);
@@ -6410,6 +6404,7 @@ syms_of_xfaces (void)
   DEFSYM (QCwidth, ":width");
   DEFSYM (QCfont, ":font");
   DEFSYM (QCfontset, ":fontset");
+  DEFSYM (QCdistant_foreground, ":distant-foreground");
   DEFSYM (QCbold, ":bold");
   DEFSYM (QCitalic, ":italic");
   DEFSYM (QCoverline, ":overline");
diff --git a/src/xfns.c b/src/xfns.c
index 9cd7d3e6627..46f377042f6 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -959,7 +959,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
     nlines = 0;
 
   /* Make sure we redisplay all windows in this frame.  */
-  windows_or_buffers_changed++;
+  windows_or_buffers_changed = 59;
 
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
   FRAME_MENU_BAR_LINES (f) = 0;
@@ -1068,8 +1068,8 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 
 #else /* !USE_GTK */
 
-     /* Make sure we redisplay all windows in this frame.  */
-  ++windows_or_buffers_changed;
+  /* Make sure we redisplay all windows in this frame.  */
+  windows_or_buffers_changed = 60;
 
   delta = nlines - FRAME_TOOL_BAR_LINES (f);
 
@@ -1383,7 +1383,7 @@ x_set_name (struct frame *f, Lisp_Object name, int explicit)
       /* If we're switching from explicit to implicit, we had better
          update the mode lines and thereby update the title.  */
       if (f->explicit_name && NILP (name))
-        update_mode_lines = 1;
+        update_mode_lines = 37;
 
       f->explicit_name = ! NILP (name);
     }
@@ -1445,7 +1445,7 @@ x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
   if (EQ (name, f->title))
     return;
 
-  update_mode_lines = 1;
+  update_mode_lines = 38;
 
   fset_title (f, name);
 
@@ -1750,7 +1750,7 @@ xic_create_fontsetname (const char *base_fontname, int motif)
         }
     }
   if (motif)
-    strcat (fontsetname, ":");
+    return strcat (fontsetname, ":");
   return fontsetname;
 }
 #endif /* HAVE_X_WINDOWS && USE_X_TOOLKIT */
@@ -2880,6 +2880,8 @@ This function is an internal primitive--use `make-frame' instead.  */)
   f->output_data.x->scroll_bar_top_shadow_pixel = -1;
   f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
 #endif /* USE_TOOLKIT_SCROLL_BARS */
+  f->output_data.x->white_relief.pixel = -1;
+  f->output_data.x->black_relief.pixel = -1;
 
   fset_icon_name (f,
                   x_get_arg (dpyinfo, parms, Qicon_name, "iconName", "Title",
@@ -4824,6 +4826,9 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
   f->output_data.x->scroll_bar_top_shadow_pixel = -1;
   f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
 #endif /* USE_TOOLKIT_SCROLL_BARS */
+  f->output_data.x->white_relief.pixel = -1;
+  f->output_data.x->black_relief.pixel = -1;
+
   fset_icon_name (f, Qnil);
   FRAME_DISPLAY_INFO (f) = dpyinfo;
   f->output_data.x->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
diff --git a/src/xfont.c b/src/xfont.c
index c5b8db3830c..d4d6ee7c10f 100644
--- a/src/xfont.c
+++ b/src/xfont.c
@@ -119,7 +119,7 @@ static Lisp_Object xfont_list (struct frame *, Lisp_Object);
 static Lisp_Object xfont_match (struct frame *, Lisp_Object);
 static Lisp_Object xfont_list_family (struct frame *);
 static Lisp_Object xfont_open (struct frame *, Lisp_Object, int);
-static void xfont_close (struct frame *, struct font *);
+static void xfont_close (struct font *);
 static int xfont_prepare_face (struct frame *, struct face *);
 static int xfont_has_char (Lisp_Object, int);
 static unsigned xfont_encode_char (struct font *, int);
@@ -384,7 +384,7 @@ xfont_list_pattern (Display *display, const char *pattern,
   if (num_fonts > 0)
     {
       char **indices = alloca (sizeof (char *) * num_fonts);
-      Lisp_Object *props = XVECTOR (xfont_scratch_props)->u.contents;
+      Lisp_Object *props = XVECTOR (xfont_scratch_props)->contents;
       Lisp_Object scripts = Qnil;
 
       for (i = 0; i < ASIZE (xfont_scratch_props); i++)
@@ -890,11 +890,17 @@ xfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
 }
 
 static void
-xfont_close (struct frame *f, struct font *font)
+xfont_close (struct font *font)
 {
-  block_input ();
-  XFreeFont (FRAME_X_DISPLAY (f), ((struct xfont_info *) font)->xfont);
-  unblock_input ();
+  struct xfont_info *xfi = (struct xfont_info *) font;
+
+  if (xfi->xfont)
+    {
+      block_input ();
+      XFreeFont (xfi->display, xfi->xfont);
+      unblock_input ();
+      xfi->xfont = NULL;
+    }
 }
 
 static int
diff --git a/src/xftfont.c b/src/xftfont.c
index f2b4c2abe2b..37b33b3ead8 100644
--- a/src/xftfont.c
+++ b/src/xftfont.c
@@ -58,7 +58,6 @@ struct xftfont_info
   int index;
   FT_Matrix matrix;
   Display *display;
-  int screen;
   XftFont *xftfont;
 };
 
@@ -70,11 +69,6 @@ struct xftface_info
   XftColor xft_bg;              /* color for face->background */
 };
 
-static void xftfont_get_colors (struct frame *, struct face *, GC gc,
-                                struct xftface_info *,
-                                XftColor *fg, XftColor *bg);
-
-
 /* Setup foreground and background colors of GC into FG and BG.  If
    XFTFACE_INFO is not NULL, reuse the colors in it if possible.  BG
    may be NULL.  */
@@ -377,7 +371,6 @@ xftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
 
   xftfont_info = (struct xftfont_info *) font;
   xftfont_info->display = display;
-  xftfont_info->screen = FRAME_X_SCREEN_NUMBER (f);
   xftfont_info->xftfont = xftfont;
   /* This means that there's no need of transformation.  */
   xftfont_info->matrix.xx = 0;
@@ -486,18 +479,26 @@ xftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
 }
 
 static void
-xftfont_close (struct frame *f, struct font *font)
+xftfont_close (struct font *font)
 {
   struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
 
 #ifdef HAVE_LIBOTF
   if (xftfont_info->otf)
-    OTF_close (xftfont_info->otf);
+    {
+      OTF_close (xftfont_info->otf);
+      xftfont_info->otf = NULL;
+    }
 #endif
-  block_input ();
-  XftUnlockFace (xftfont_info->xftfont);
-  XftFontClose (xftfont_info->display, xftfont_info->xftfont);
-  unblock_input ();
+
+  if (xftfont_info->xftfont)
+    {
+      block_input ();
+      XftUnlockFace (xftfont_info->xftfont);
+      XftFontClose (xftfont_info->display, xftfont_info->xftfont);
+      unblock_input ();
+      xftfont_info->xftfont = NULL;
+    }
 }
 
 static int
diff --git a/src/xmenu.c b/src/xmenu.c
index d910100f77f..b2c7fb5f073 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -847,7 +847,7 @@ set_frame_menubar (struct frame *f, bool first_time, bool deep_p)
 
       /* Save the frame's previous menu bar contents data.  */
       if (previous_menu_items_used)
-        memcpy (previous_items, XVECTOR (f->menu_bar_vector)->u.contents,
+        memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
                 previous_menu_items_used * word_size);
 
       /* Fill in menu_items with the current menu bar contents.
@@ -2086,7 +2086,7 @@ menu_help_callback (char const *help_string, int pane, int item)
   Lisp_Object pane_name;
   Lisp_Object menu_object;
 
-  first_item = XVECTOR (menu_items)->u.contents;
+  first_item = XVECTOR (menu_items)->contents;
   if (EQ (first_item[0], Qt))
     pane_name = first_item[MENU_ITEMS_PANE_NAME];
   else if (EQ (first_item[0], Qquote))
diff --git a/src/xrdb.c b/src/xrdb.c
index 52988f0818a..ea823b2b313 100644
--- a/src/xrdb.c
+++ b/src/xrdb.c
@@ -234,9 +234,7 @@ gethomedir (void)
 
   copy = xmalloc (strlen (ptr) + 2);
   strcpy (copy, ptr);
-  strcat (copy, "/");
-
-  return copy;
+  return strcat (copy, "/");
 }
 
 
diff --git a/src/xselect.c b/src/xselect.c
index b4f4f9d43b6..6dbeb539f77 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -972,7 +972,6 @@ x_handle_selection_clear (struct input_event *event)
     Frun_hook_with_args (2, args);
   }
 
-  prepare_menu_bars ();
   redisplay_preserve_echo_area (20);
 }
 
@@ -2365,7 +2364,7 @@ x_fill_property_data (Display *dpy, Lisp_Object data, void *ret, int format)
 
 Lisp_Object
 x_property_data_to_lisp (struct frame *f, const unsigned char *data,
-                         Atom type, int format, long unsigned int size)
+                         Atom type, int format, unsigned long size)
 {
   ptrdiff_t format_bytes = format >> 3;
   if (PTRDIFF_MAX / format_bytes < size)
diff --git a/src/xsettings.c b/src/xsettings.c
index e5a66c4cf0a..cff0c99548d 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -393,7 +393,7 @@ get_prop_window (struct x_display_info *dpyinfo)
 
 static int
 parse_settings (unsigned char *prop,
-                long unsigned int bytes,
+                unsigned long bytes,
                 struct xsettings *settings)
 {
   Lisp_Object byteorder = Fbyteorder ();
diff --git a/src/xterm.c b/src/xterm.c
index 26ad5267625..446b2cf1e45 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -1643,7 +1643,7 @@ x_alloc_nearest_color (struct frame *f, Colormap cmap, XColor *color)
    get color reference counts right.  */
 
 unsigned long
-x_copy_color (struct frame *f, long unsigned int pixel)
+x_copy_color (struct frame *f, unsigned long pixel)
 {
   XColor color;
 
@@ -1681,7 +1681,8 @@ x_copy_color (struct frame *f, long unsigned int pixel)
    Value is non-zero if successful.  */
 
 static bool
-x_alloc_lighter_color (struct frame *f, Display *display, Colormap cmap, long unsigned int *pixel, double factor, int delta)
+x_alloc_lighter_color (struct frame *f, Display *display, Colormap cmap,
+                       unsigned long *pixel, double factor, int delta)
 {
   XColor color, new;
   long bright;
@@ -1757,7 +1758,8 @@ x_alloc_lighter_color (struct frame *f, Display *display, Colormap cmap, long un
    be allocated, use DEFAULT_PIXEL, instead.  */
 
 static void
-x_setup_relief_color (struct frame *f, struct relief *relief, double factor, int delta, long unsigned int default_pixel)
+x_setup_relief_color (struct frame *f, struct relief *relief, double factor,
+                      int delta, unsigned long default_pixel)
 {
   XGCValues xgcv;
   struct x_output *di = f->output_data.x;
@@ -1774,11 +1776,10 @@ x_setup_relief_color (struct frame *f, struct relief *relief, double factor, int
   /* Free previously allocated color.  The color cell will be reused
      when it has been freed as many times as it was allocated, so this
      doesn't affect faces using the same colors.  */
-  if (relief->gc
-      && relief->allocated_p)
+  if (relief->gc && relief->pixel != -1)
     {
       x_free_colors (f, &relief->pixel, 1);
-      relief->allocated_p = 0;
+      relief->pixel = -1;
     }
 
   /* Allocate new color.  */
@@ -1786,10 +1787,7 @@ x_setup_relief_color (struct frame *f, struct relief *relief, double factor, int
   pixel = background;
   if (dpyinfo->n_planes != 1
       && x_alloc_lighter_color (f, dpy, cmap, &pixel, factor, delta))
-    {
-      relief->allocated_p = 1;
-      xgcv.foreground = relief->pixel = pixel;
-    }
+    xgcv.foreground = relief->pixel = pixel;
 
   if (relief->gc == 0)
     {
@@ -9338,9 +9336,9 @@ x_free_frame_resources (struct frame *f)
       if (f->output_data.x->scroll_bar_bottom_shadow_pixel != -1)
         unload_color (f, f->output_data.x->scroll_bar_bottom_shadow_pixel);
 #endif /* USE_TOOLKIT_SCROLL_BARS */
-      if (f->output_data.x->white_relief.allocated_p)
+      if (f->output_data.x->white_relief.pixel != -1)
         unload_color (f, f->output_data.x->white_relief.pixel);
-      if (f->output_data.x->black_relief.allocated_p)
+      if (f->output_data.x->black_relief.pixel != -1)
         unload_color (f, f->output_data.x->black_relief.pixel);
 
       x_free_gcs (f);
@@ -9690,7 +9688,7 @@ same_x_server (const char *name1, const char *name2)
    get to the first bit.  With MASK 0x7e0, *BITS is set to 6, and *OFFSET
    to 5.  */
 static void
-get_bits_and_offset (long unsigned int mask, int *bits, int *offset)
+get_bits_and_offset (unsigned long mask, int *bits, int *offset)
 {
   int nr = 0;
   int off = 0;
@@ -10589,14 +10587,14 @@ With MS Windows or Nextstep, the value is t.  */);
   Vx_toolkit_scroll_bars = Qnil;
 #endif
 
-  Qmodifier_value = intern_c_string ("modifier-value");
-  Qalt = intern_c_string ("alt");
+  DEFSYM (Qmodifier_value, "modifier-value");
+  DEFSYM (Qalt, "alt");
   Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
-  Qhyper = intern_c_string ("hyper");
+  DEFSYM (Qhyper, "hyper");
   Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
-  Qmeta = intern_c_string ("meta");
+  DEFSYM (Qmeta, "meta");
   Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
-  Qsuper = intern_c_string ("super");
+  DEFSYM (Qsuper, "super");
   Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
 
   DEFVAR_LISP ("x-alt-keysym", Vx_alt_keysym,
diff --git a/src/xterm.h b/src/xterm.h
index 06c0d4882b8..753debff1bb 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -605,7 +605,6 @@ struct x_output
   {
     GC gc;
     unsigned long pixel;
-    int allocated_p;
   }
   black_relief, white_relief;