Merge from trunk.

55 files changed, 983 insertions, 428 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index d477d0574b3..3bc8900f01f 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,4 +1,4 @@
-2012-03-02  Paul Eggert  <eggert@cs.ucla.edu>
+2012-04-09  Paul Eggert  <eggert@cs.ucla.edu>
 
         Fix integer width and related bugs (Bug#9874).
         * alloc.c (pure_bytes_used_lisp, pure_bytes_used_non_lisp):
@@ -788,6 +788,322 @@
         rather than rolling our own approximation.
         (SCROLL_BAR_VEC_SIZE): Remove; not used.
 
+2012-04-09  Glenn Morris  <rgm@gnu.org>
+
+        * doc.c (Fsnarf_documentation): Check variables, functions are bound,
+        not just in the obarray, before snarfing them.  (Bug#11036)
+
+        * Makefile.in ($(leimdir)/leim-list.el):
+        Pass EMACS rather than BUILT_EMACS.
+
+2012-04-09  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * process.c (make_process):
+        * process.h: Add integer `gnutls_handshakes_tried' member to
+        process struct.
+
+        * gnutls.h: Add `GNUTLS_EMACS_HANDSHAKES_LIMIT' upper limit.  Add
+        convenience `GNUTLS_LOG2i' macro.
+
+        * gnutls.c (gnutls_log_function2i): Convenience log function.
+        (emacs_gnutls_read): Use new log functions,
+        `gnutls_handshakes_tried' process member, and
+        `GNUTLS_EMACS_HANDSHAKES_LIMIT' to limit the number of handshake
+        attempts per process (connection).
+
+2012-04-09  Chong Yidong  <cyd@gnu.org>
+
+        * eval.c (Fuser_variable_p, user_variable_p_eh)
+        (lisp_indirect_variable): Functions deleted.
+        (Fdefvar): Caller changed.
+
+        * callint.c (Finteractive, Fcall_interactively):
+        * minibuf.c (Fread_variable): Callers changed.
+
+2012-04-09  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (set_cursor_from_row): If the display string appears in
+        the buffer at position that is closer to point than the position
+        after the display string, display the cursor on the first glyph of
+        the display string.  Fixes cursor display when a 'display' text
+        property immediately follows invisible text.  (Bug#11094)
+
+2012-04-09  Paul Eggert  <eggert@cs.ucla.edu>
+
+        composite.c: use 'double' consistently
+        * composite.c (get_composition_id): Use 'double' consistently
+        instead of converting 'float' to 'double' and vice versa; this is
+        easier to understand and avoids a GCC warning.
+
+2012-04-09  Glenn Morris  <rgm@gnu.org>
+
+        * Makefile.in: Generate leim-list with bootstrap-emacs, in
+        preparation for dumping it with emacs.  (Bug#4789)
+        (leimdir): New variable.
+        ($(leimdir)/leim-list.el): New rule.
+        (emacs$(EXEEXT)): Depend on leim-list.el.
+
+        * buffer.c (Qucs_set_table_for_input): Remove.  (Bug#9821)
+        (Fget_buffer_create): Don't call Qucs_set_table_for_input.
+        (init_buffer_once, syms_of_buffer): Remove Qucs_set_table_for_input.
+
+2012-04-08  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * lisp.h (struct Lisp_Symbol): Add explicit padding to ensure
+        proper alignment.
+
+2012-04-07  Juanma Barranquero  <lekktu@gmail.com>
+
+        * xml.c (init_libxml2_functions) [WINDOWSNT]:
+        Remove unused local variable.
+
+2012-04-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Avoid unnecessary pointer scanning in garbage collection (Bug#10780).
+        * alloc.c (POINTERS_MIGHT_HIDE_IN_OBJECTS): New macro.
+        (mark_memory): Mark Lisp_Objects only if pointers might hide in
+        objects, as mark_maybe_pointer will catch them otherwise.
+        (GC_LISP_OBJECT_ALIGNMENT): Remove; no longer needed.
+        * s/gnu-linux.h (GC_LISP_OBJECT_ALIGNMENT) [__mc68000__]: Likewise.
+
+2012-04-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix typo that broke non-Windows builds.
+        * xml.c (libxml2_loaded_p) [!!WINDOWSNT]: 'inine' -> 'inline'.
+
+2012-04-07  Eli Zaretskii  <eliz@gnu.org>
+
+        Support building on MS-Windows with libxml2.
+
+        * makefile.w32-in (OBJ2): Add xml.$(O).
+        (GLOBAL_SOURCES): Add xml.c.
+        ($(BLD)/xml.$(O)): New dependency list.
+
+        * xml.c (DEF_XML2_FN, LOAD_XML2_FN) [WINDOWSNT]: New macros.
+        (fn_htmlReadMemory, fn_xmlReadMemory, fn_xmlDocGetRootElement)
+        (fn_xmlFreeDoc, fn_xmlCleanupParser, fn_xmlCheckVersion)
+        [!WINDOWSNT]: New macros.
+        (init_libxml2_functions, libxml2_loaded_p): New functions.
+        (parse_region): Call fn_xmlCheckVersion instead of using the macro
+        LIBXML_TEST_VERSION.  Call libxml2 functions via the fn_* macros.
+        (xml_cleanup_parser): New function, export for fn_xmlCleanupParser.
+        Calls xmlCleanupParser only if libxml2 was loaded (or statically
+        linked in).
+        (Flibxml_parse_html_region, Flibxml_parse_xml_region): Call
+        init_libxml2_functions before calling libxml2 functions.
+        (syms_of_xml) <Qlibxml2_dll>: DEFSYM it.
+
+        * emacs.c: Don't include libxml/parser.h.
+        (shut_down_emacs): Call xml_cleanup_parser, instead of calling
+        xmlCleanupParser directly.
+
+        * lisp.h [HAVE_LIBXML2]: Add prototype for xml_cleanup_parser.
+
+2012-04-07  Eli Zaretskii  <eliz@gnu.org>
+
+        * indent.c (Fvertical_motion): If there is a display string at
+        point, use it.vpos to compute how many lines to backtrack after
+        move_it_to point.  (Bug#11133)
+
+2012-04-06  Eli Zaretskii  <eliz@gnu.org>
+
+        * buffer.h (FETCH_CHAR, FETCH_MULTIBYTE_CHAR):
+        * character.h (STRING_CHAR, STRING_CHAR_AND_LENGTH): Add comments
+        about subtle differences between FETCH_CHAR* and STRING_CHAR*
+        macros related to unification of CJK characters.  For the details,
+        see the discussion following the message here:
+        http://debbugs.gnu.org/cgi/bugreport.cgi?bug=11073#14.
+
+2012-04-04  Chong Yidong  <cyd@gnu.org>
+
+        * keyboard.c (Vdelayed_warnings_list): Doc fix.
+
+2012-04-01  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32menu.c (simple_dialog_show, add_menu_item): Use SAFE_ALLOCA
+        instead of alloca.  (Bug#11138)
+
+2012-04-01  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * w32menu.c (is_simple_dialog): Properly check lisp types.
+        (Bug#11141)
+
+2012-03-31  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (move_it_by_lines): When DVPOS is positive, and the
+        position we get to after a call to move_it_to fails the
+        IS_POS_VALID_AFTER_MOVE_P test, move to the next buffer position
+        only if we wind up in a string from display property.  (Bug#11063)
+
+        * window.c (Fdelete_other_windows_internal): Invalidate the row
+        and column information about mouse highlight, so that redisplay
+        restores it after reallocating the glyph matrices.  (Bug#7464)
+
+        * xdisp.c (set_cursor_from_row): If `cursor' property on a display
+        string comes from a `display' text property, use the buffer
+        position of that property as if we actually saw that position in
+        the row's glyphs.
+        (move_it_by_lines): Remove the assertion that
+        "it->current_x == 0 && it->hpos == 0" which can be legitimately
+        violated when there's a before-string at the beginning of a line.
+        (Bug#11063)
+
+2012-03-30  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (append_space_for_newline): If the default face was
+        remapped, use the remapped face for the appended newline.
+        (extend_face_to_end_of_line): Use the remapped default face for
+        extending the face to the end of the line.
+        (display_line): Call extend_face_to_end_of_line when the default
+        face was remapped.  (Bug#11068)
+
+2012-03-29  Eli Zaretskii  <eliz@gnu.org>
+
+        * s/ms-w32.h: Discourage from defining HAVE_GETCWD.
+
+2012-03-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (safe_run_hooks_error): Don't unquote strings.
+
+2012-03-27  Glenn Morris  <rgm@gnu.org>
+
+        * search.c (Fword_search_backward_lax, Fword_search_forward_lax):
+        Doc fixes.
+
+2012-03-26  Kenichi Handa  <handa@m17n.org>
+
+        * dispextern.h (struct glyph): Fix previous change.  Change the
+        bit length of glyphless.ch to 25 (Bug#11082).
+
+2012-03-26  Chong Yidong  <cyd@gnu.org>
+
+        * keyboard.c (Vselection_inhibit_update_commands): New variable.
+        (command_loop_1): Use it; inhibit selection update for
+        handle-select-window too (Bug#8996).
+
+2012-03-25  Fabrice Popineau  <fabrice.popineau@supelec.fr>
+
+        * w32heap.c (_heap_init, _heap_term): Remove dead MSVC-specific code.
+
+2012-03-25  Kenichi Handa  <handa@m17n.org>
+
+        * dispextern.h (struct glyph): Change the bit length of
+        glyphless.ch to 22 to make the member glyphless fit in 32 bits.
+
+2012-03-24  Eli Zaretskii  <eliz@gnu.org>
+
+        * s/ms-w32.h (tzname): Include time.h before redirecting to
+        _tzname.  Fixes the MSVC build.  (Bug#9960)
+
+2012-03-24  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * xdisp.c (produce_glyphless_glyph): Limit length of acronym to 6
+        characters.
+
+        * xterm.c (XTread_socket): Only modify handling_signal if
+        !SYNC_INPUT.  (Bug#11080)
+
+2012-03-23  Eli Zaretskii  <eliz@gnu.org>
+
+        * bidi.c (bidi_fetch_char): Use STRING_CHAR_AND_LENGTH instead of
+        FETCH_MULTIBYTE_CHAR followed by CHAR_BYTES.  Prevents crashes
+        when fetching a multibyte character consumes more bytes than
+        CHAR_BYTES returns, due to unification of CJK characters in
+        string_char.  (Bug#11073)
+
+2012-03-23  Troels Nielsen  <bn.troels@gmail.com>  (tiny change)
+
+        * process.c (wait_reading_process_output): Handle pty disconnect
+        by refraining from sending oneself a SIGCHLD (bug#10933).
+
+2012-03-22  Chong Yidong  <cyd@gnu.org>
+
+        * dispextern.h (struct it): New member string_from_prefix_prop_p.
+
+        * xdisp.c (push_prefix_prop): Rename from push_display_prop.
+        Mark string as coming from a prefix property.
+        (handle_face_prop): Use default face for prefix strings (Bug#4281).
+        (pop_it, reseat_1): Save and restore string_from_prefix_prop_p.
+
+2012-03-21  Chong Yidong  <cyd@gnu.org>
+
+        * xfaces.c (Vface_remapping_alist): Doc fix.
+
+2012-03-20  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32proc.c (Fw32_set_console_codepage)
+        (Fw32_set_console_output_codepage, Fw32_get_codepage_charset):
+        Doc fixes.
+
+2012-03-20  Chong Yidong  <cyd@gnu.org>
+
+        * dispnew.c (Fredisplay, Vredisplay_preemption_period): Update doc
+        to reflect default non-nil value of redisplay-dont-pause.
+
+2012-03-19  Kenichi Handa  <handa@m17n.org>
+
+        * ftfont.c (ftfont_drive_otf): Mask bits of character code to make
+        it fit in a valid range (Bug#11003).
+
+2012-03-18  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (cursor_row_p): Even if the glyph row ends in a string
+        that is not from display property, accept the row as a "cursor
+        row" if one of the string's character has a non-nil `cursor'
+        property.  Fixes cursor positioning when there are newlines in
+        overlay strings, e.g. in icomplete.el.  (Bug#11035)
+
+2012-03-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * buffer.c (compare_overlays): Don't assume args differ (Bug#6830).
+
+2012-03-12  Chong Yidong  <cyd@gnu.org>
+
+        * eval.c (inhibit_lisp_code): Rename from
+        inhibit_window_configuration_change_hook; move from window.c.
+
+        * xfns.c (unwind_create_frame_1, Fx_create_frame):
+        * window.c (run_window_configuration_change_hook)
+        (syms_of_window): Callers changed.
+
+2012-03-11  Chong Yidong  <cyd@gnu.org>
+
+        * keymap.c (Fkey_description): Doc fix (Bug#9700).
+
+        * editfns.c (Fconstrain_to_field): Doc fix (Bug#9452).
+
+2012-03-10  Chong Yidong  <cyd@gnu.org>
+
+        * frame.c (other_visible_frames): Don't assume the selected frame
+        is visible (Bug#10955).
+
+2012-03-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * buffer.c (compare_overlays): Avoid qsort's instability (bug#6830).
+
+2012-03-08  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (x_wm_set_size_hint): Use one row in call to
+        FRAME_TEXT_LINES_TO_PIXEL_HEIGHT so base_height is greater than
+        zero (Bug#10954).
+
+2012-03-03  Glenn Morris  <rgm@gnu.org>
+
+        * alloc.c (Fgarbage_collect, misc-objects-consed): Doc fixes.
+
+2012-03-02  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (try_window_reusing_current_matrix): Don't move cursor
+        position past the first glyph_row that ends at ZV.  (Bug#10902)
+        (redisplay_window, next_element_from_string): Fix typos in
+        comments.
+        (redisplay_window): Pass to move_it_vertically the margin in
+        pixels, not in screen lines.
+
+2012-03-02  Glenn Morris  <rgm@gnu.org>
+
+        * buffer.c (buffer-list-update-hook): Doc fix.
+
 2012-02-29  Eli Zaretskii  <eliz@gnu.org>
 
         * xdisp.c (get_overlay_strings_1): Under bidi redisplay, call
@@ -968,8 +1284,8 @@
 
 2012-02-04  Eli Zaretskii  <eliz@gnu.org>
 
-        * w32.c (get_emacs_configuration_options): Include
-        --enable-checking, if specified, in the return value.
+        * w32.c (get_emacs_configuration_options):
+        Include --enable-checking, if specified, in the return value.
 
 2012-02-04  Martin Rudalics  <rudalics@gmx.at>
 
@@ -1075,8 +1391,8 @@
 2012-01-19  Martin Rudalics  <rudalics@gmx.at>
 
         * window.c (save_window_save, Fcurrent_window_configuration)
-        (Vwindow_persistent_parameters): Do not use Qstate.  Rewrite
-        doc-strings.
+        (Vwindow_persistent_parameters): Do not use Qstate.
+        Rewrite doc-strings.
 
 2012-01-19  Kenichi Handa  <handa@m17n.org>
 
@@ -1250,9 +1566,9 @@
         * nsselect.m (CUT_BUFFER_SUPPORT): Remove define.
         (symbol_to_nsstring): Fix indentation.
         (ns_symbol_to_pb): New function.
-        (Fns_get_selection_internal): Renamed from Fns_get_cut_buffer_internal.
-        (Fns_rotate_cut_buffers_internal): Removed.
-        (Fns_store_selection_internal): Renamed from
+        (Fns_get_selection_internal): Rename from Fns_get_cut_buffer_internal.
+        (Fns_rotate_cut_buffers_internal): Remove.
+        (Fns_store_selection_internal): Rename from
         Fns_store_cut_buffer_internal.
         (ns_get_foreign_selection, Fx_own_selection_internal)
         (Fx_disown_selection_internal, Fx_selection_exists_p)
@@ -1393,7 +1709,7 @@
         (coding_set_destination): Return how many bytes
         coding->destination was relocated.
         (CODING_DECODE_CHAR, CODING_ENCODE_CHAR, CODING_CHAR_CHARSET)
-        (CODING_CHAR_CHARSET_P): Adjusted for the avove changes.
+        (CODING_CHAR_CHARSET_P): Adjust for the avove changes.
 
 2011-12-05  Kazuhiro Ito  <kzhr@d1.dion.ne.jp>  (tiny change)
 
diff --git a/src/ChangeLog.11 b/src/ChangeLog.11
index 2e5404779b1..97d5a65281a 100644
--- a/src/ChangeLog.11
+++ b/src/ChangeLog.11
@@ -9627,7 +9627,7 @@
         * frame.c (Vdefault_frame_scroll_bars): Put non-GTK X scroll-bars
         on left.
 
-2010-03-13  Andreas Politz  <politza@fh-trier.de>  (tiny change)
+2010-03-13  Andreas Politz  <politza@fh-trier.de>
 
         * editfns.c (Fformat): Account for string precision when computing
         field width (Bug#5710).
diff --git a/src/Makefile.in b/src/Makefile.in
index 035ea277454..a90fd5841e4 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -49,6 +49,7 @@ lispsource = $(srcdir)/../lisp
 lib = ../lib
 libsrc = ../lib-src
 etc = ../etc
+leimdir = ../leim
 oldXMenudir = ../oldXMenu
 lwlibdir = ../lwlib
 lispdir = ../lisp
@@ -393,13 +394,16 @@ LIBES = $(LIBS) $(LIBX_BASE) $(LIBX_OTHER) $(LIBSOUND) \
 
 all: emacs$(EXEEXT) $(OTHER_FILES)
 
+$(leimdir)/leim-list.el: bootstrap-emacs$(EXEEXT)
+        cd $(leimdir) && $(MAKE) $(MFLAGS) leim-list.el EMACS=$(bootstrap_exe)
+
 ## Does anyone ever pay attention to the load-path-shadows output here?
 ## The dumped Emacs is as functional and more efficient than
 ## bootstrap-emacs, so we replace the latter with the former.
 ## Strictly speaking, emacs does not depend directly on all of $lisp,
 ## since not all pieces are used on all platforms.  But DOC depends
 ## on all of $lisp, and emacs depends on DOC, so it is ok to use $lisp here.
-emacs$(EXEEXT): temacs$(EXEEXT) $(etc)/DOC $(lisp)
+emacs$(EXEEXT): temacs$(EXEEXT) $(etc)/DOC $(lisp) $(leimdir)/leim-list.el
         if test "$(CANNOT_DUMP)" = "yes"; then \
           ln -f temacs$(EXEEXT) emacs$(EXEEXT); \
           EMACSLOADPATH=$(lispsource) ./emacs -batch \
diff --git a/src/alloc.c b/src/alloc.c
index 6e4cfa07fa0..27118c91c9c 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -1,6 +1,7 @@
 /* Storage allocation and gc for GNU Emacs Lisp interpreter.
-   Copyright (C) 1985-1986, 1988, 1993-1995, 1997-2012
-      Free Software Foundation, Inc.
+
+Copyright (C) 1985-1986, 1988, 1993-1995, 1997-2012
+  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -4251,23 +4252,38 @@ mark_maybe_pointer (void *p)
 }
 
 
-/* Alignment of Lisp_Object and pointer values.  Use offsetof, as it
-   sometimes returns a smaller alignment than GCC's __alignof__ and
-   mark_memory might miss objects if __alignof__ were used.  For
-   example, on x86 with WIDE_EMACS_INT, __alignof__ (Lisp_Object) is 8
-   but GC_LISP_OBJECT_ALIGNMENT should be 4.  */
-#ifndef GC_LISP_OBJECT_ALIGNMENT
-# define GC_LISP_OBJECT_ALIGNMENT offsetof (struct {char a; Lisp_Object b;}, b)
-#endif
+/* Alignment of pointer values.  Use offsetof, as it sometimes returns
+   a smaller alignment than GCC's __alignof__ and mark_memory might
+   miss objects if __alignof__ were used.  */
 #define GC_POINTER_ALIGNMENT offsetof (struct {char a; void *b;}, b)
 
+/* Define POINTERS_MIGHT_HIDE_IN_OBJECTS to 1 if marking via C pointers does
+   not suffice, which is the typical case.  A host where a Lisp_Object is
+   wider than a pointer might allocate a Lisp_Object in non-adjacent halves.
+   If USE_LSB_TAG, the bottom half is not a valid pointer, but it should
+   suffice to widen it to to a Lisp_Object and check it that way.  */
+#if defined USE_LSB_TAG || UINTPTR_MAX >> VALBITS != 0
+# if !defined USE_LSB_TAG && UINTPTR_MAX >> VALBITS >> GCTYPEBITS != 0
+  /* If tag bits straddle pointer-word boundaries, neither mark_maybe_pointer
+     nor mark_maybe_object can follow the pointers.  This should not occur on
+     any practical porting target.  */
+#  error "MSB type bits straddle pointer-word boundaries"
+# endif
+  /* Marking via C pointers does not suffice, because Lisp_Objects contain
+     pointer words that hold pointers ORed with type bits.  */
+# define POINTERS_MIGHT_HIDE_IN_OBJECTS 1
+#else
+  /* Marking via C pointers suffices, because Lisp_Objects contain pointer
+     words that hold unmodified pointers.  */
+# define POINTERS_MIGHT_HIDE_IN_OBJECTS 0
+#endif
+
 /* Mark Lisp objects referenced from the address range START+OFFSET..END
    or END+OFFSET..START. */
 
 static void
 mark_memory (void *start, void *end)
 {
-  Lisp_Object *p;
   void **pp;
   int i;
 
@@ -4284,11 +4300,6 @@ mark_memory (void *start, void *end)
       end = tem;
     }
 
-  /* Mark Lisp_Objects.  */
-  for (p = start; (void *) p < end; p++)
-    for (i = 0; i < sizeof *p; i += GC_LISP_OBJECT_ALIGNMENT)
-      mark_maybe_object (*(Lisp_Object *) ((char *) p + i));
-
   /* Mark Lisp data pointed to.  This is necessary because, in some
      situations, the C compiler optimizes Lisp objects away, so that
      only a pointer to them remains.  Example:
@@ -4310,17 +4321,10 @@ mark_memory (void *start, void *end)
   for (pp = start; (void *) pp < end; pp++)
     for (i = 0; i < sizeof *pp; i += GC_POINTER_ALIGNMENT)
       {
-        void *w = *(void **) ((char *) pp + i);
-        mark_maybe_pointer (w);
-
-#ifdef USE_LSB_TAG
-        /* A host where a Lisp_Object is wider than a pointer might
-           allocate a Lisp_Object in non-adjacent halves.  If
-           USE_LSB_TAG, the bottom half is not a valid pointer, so
-           widen it to to a Lisp_Object and check it that way.  */
-        if (sizeof w < sizeof (Lisp_Object))
-          mark_maybe_object (widen_to_Lisp_Object (w));
-#endif
+        void *p = *(void **) ((char *) pp + i);
+        mark_maybe_pointer (p);
+        if (POINTERS_MIGHT_HIDE_IN_OBJECTS)
+          mark_maybe_object (widen_to_Lisp_Object (p));
       }
 }
 
@@ -5011,11 +5015,12 @@ Garbage collection happens automatically if you cons more than
 `gc-cons-threshold' bytes of Lisp data since previous garbage collection.
 `garbage-collect' normally returns a list with info on amount of space in use:
  ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
-  (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS
+  (USED-MISCS . FREE-MISCS) USED-STRING-CHARS USED-VECTOR-SLOTS
   (USED-FLOATS . FREE-FLOATS) (USED-INTERVALS . FREE-INTERVALS)
   (USED-STRINGS . FREE-STRINGS))
 However, if there was overflow in pure space, `garbage-collect'
-returns nil, because real GC can't be done.  */)
+returns nil, because real GC can't be done.
+See Info node `(elisp)Garbage Collection'.  */)
   (void)
 {
   register struct specbinding *bind;
@@ -6409,7 +6414,7 @@ void
 syms_of_alloc (void)
 {
   DEFVAR_INT ("gc-cons-threshold", gc_cons_threshold,
-              doc: /* *Number of bytes of consing between garbage collections.
+              doc: /* Number of bytes of consing between garbage collections.
 Garbage collection can happen automatically once this many bytes have been
 allocated since the last garbage collection.  All data types count.
 
@@ -6420,7 +6425,7 @@ prevent garbage collection during a part of the program.
 See also `gc-cons-percentage'.  */);
 
   DEFVAR_LISP ("gc-cons-percentage", Vgc_cons_percentage,
-               doc: /* *Portion of the heap used for allocation.
+               doc: /* Portion of the heap used for allocation.
 Garbage collection can happen automatically once this portion of the heap
 has been allocated since the last garbage collection.
 If this portion is smaller than `gc-cons-threshold', this is ignored.  */);
@@ -6445,7 +6450,9 @@ If this portion is smaller than `gc-cons-threshold', this is ignored.  */);
               doc: /* Number of string characters that have been consed so far.  */);
 
   DEFVAR_INT ("misc-objects-consed", misc_objects_consed,
-              doc: /* Number of miscellaneous objects that have been consed so far.  */);
+              doc: /* Number of miscellaneous objects that have been consed so far.
+These include markers and overlays, plus certain objects not visible
+to users.  */);
 
   DEFVAR_INT ("intervals-consed", intervals_consed,
               doc: /* Number of intervals that have been consed so far.  */);
diff --git a/src/bidi.c b/src/bidi.c
index 99936d93e4f..6c9dcd2a2b9 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -932,6 +932,7 @@ bidi_fetch_char (ptrdiff_t bytepos, ptrdiff_t charpos, ptrdiff_t *disp_pos,
   ptrdiff_t endpos
     = (string->s || STRINGP (string->lstring)) ? string->schars : ZV;
   struct text_pos pos;
+  int len;
 
   /* If we got past the last known position of display string, compute
      the position of the next one.  That position could be at CHARPOS.  */
@@ -1003,7 +1004,6 @@ bidi_fetch_char (ptrdiff_t bytepos, ptrdiff_t charpos, ptrdiff_t *disp_pos,
     normal_char:
       if (string->s)
         {
-          int len;
 
           if (!string->unibyte)
             {
@@ -1018,8 +1018,6 @@ bidi_fetch_char (ptrdiff_t bytepos, ptrdiff_t charpos, ptrdiff_t *disp_pos,
         }
       else if (STRINGP (string->lstring))
         {
-          int len;
-
           if (!string->unibyte)
             {
               ch = STRING_CHAR_AND_LENGTH (SDATA (string->lstring) + bytepos,
@@ -1034,8 +1032,8 @@ bidi_fetch_char (ptrdiff_t bytepos, ptrdiff_t charpos, ptrdiff_t *disp_pos,
         }
       else
         {
-          ch = FETCH_MULTIBYTE_CHAR (bytepos);
-          *ch_len = CHAR_BYTES (ch);
+          ch = STRING_CHAR_AND_LENGTH (BYTE_POS_ADDR (bytepos), len);
+          *ch_len = len;
         }
       *nchars = 1;
     }
diff --git a/src/buffer.c b/src/buffer.c
index acee3c45158..8cb68317bed 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1,6 +1,6 @@
 /* Buffer manipulation primitives for GNU Emacs.
 
-Copyright (C) 1985-1989, 1993-1995, 1997-2012  Free Software Foundation, Inc.
+Copyright (C) 1985-1989, 1993-1995, 1997-2012 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -128,7 +128,6 @@ static Lisp_Object Qchange_major_mode_hook;
 Lisp_Object Qfirst_change_hook;
 Lisp_Object Qbefore_change_functions;
 Lisp_Object Qafter_change_functions;
-static Lisp_Object Qucs_set_table_for_input;
 
 static Lisp_Object Qfundamental_mode, Qmode_class, Qpermanent_local;
 static Lisp_Object Qpermanent_local_hook;
@@ -402,13 +401,6 @@ even if it is dead.  The return value is never nil.  */)
   if (!NILP (Vrun_hooks))
     call1 (Vrun_hooks, Qbuffer_list_update_hook);
 
-  /* An error in calling the function here (should someone redefine it)
-     can lead to infinite regress until you run out of stack.  rms
-     says that's not worth protecting against.  */
-  if (!NILP (Ffboundp (Qucs_set_table_for_input)))
-    /* buffer is on buffer-alist, so no gcpro.  */
-    call1 (Qucs_set_table_for_input, buffer);
-
   return buffer;
 }
 
@@ -1717,7 +1709,7 @@ record_buffer (Lisp_Object buffer)
 /* Move BUFFER to the end of the buffer (a)lists.  Do nothing if the
    buffer is killed.  For the selected frame's buffer list this moves
    BUFFER to its end even if it was never shown in that frame.  If
-   this happens we have a feature, hence `unrecord-buffer' should be
+   this happens we have a feature, hence `bury-buffer-internal' should be
    called only when BUFFER was shown in the selected frame.  */
 
 DEFUN ("bury-buffer-internal", Fbury_buffer_internal, Sbury_buffer_internal,
@@ -2863,6 +2855,12 @@ compare_overlays (const void *v1, const void *v2)
     return s1->beg < s2->beg ? -1 : 1;
   if (s1->end != s2->end)
     return s2->end < s1->end ? -1 : 1;
+  /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
+     between "equal" overlays.  The result can still change between
+     invocations of Emacs, but it won't change in the middle of
+     `find_field' (bug#6830).  */
+  if (XHASH (s1->overlay) != XHASH (s2->overlay))
+    return XHASH (s1->overlay) < XHASH (s2->overlay) ? -1 : 1;
   return 0;
 }
 
@@ -5036,8 +5034,6 @@ init_buffer_once (void)
   Qkill_buffer_hook = intern_c_string ("kill-buffer-hook");
   Fput (Qkill_buffer_hook, Qpermanent_local, Qt);
 
-  Qucs_set_table_for_input = intern_c_string ("ucs-set-table-for-input");
-
   /* super-magic invisible buffer */
   Vprin1_to_string_buffer = Fget_buffer_create (make_pure_c_string (" prin1"));
   Vbuffer_alist = Qnil;
@@ -5193,9 +5189,6 @@ syms_of_buffer (void)
   DEFSYM (Qafter_change_functions, "after-change-functions");
   DEFSYM (Qkill_buffer_query_functions, "kill-buffer-query-functions");
 
-  /* The next one is initialized in init_buffer_once.  */
-  staticpro (&Qucs_set_table_for_input);
-
   Fput (Qprotected_field, Qerror_conditions,
         pure_cons (Qprotected_field, pure_cons (Qerror, Qnil)));
   Fput (Qprotected_field, Qerror_message,
@@ -5237,7 +5230,7 @@ This is the same as (default-value 'ctl-arrow).  */);
 
   DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
                           enable_multibyte_characters,
-                          doc: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
+                          doc: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
 This is the same as (default-value 'enable-multibyte-characters).  */);
 
   DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
@@ -5399,7 +5392,7 @@ A string is printed verbatim in the mode line except for %-constructs:
 Decimal digits after the % specify field width to which to pad.  */);
 
   DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode,
-                          doc: /* *Value of `major-mode' for new buffers.  */);
+                          doc: /* Value of `major-mode' for new buffers.  */);
 
   DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer, major_mode),
                      make_number (Lisp_Symbol),
@@ -5430,25 +5423,25 @@ Use the command `abbrev-mode' to change this variable.  */);
 
   DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer, case_fold_search),
                      Qnil,
-                     doc: /* *Non-nil if searches and matches should ignore case.  */);
+                     doc: /* Non-nil if searches and matches should ignore case.  */);
 
   DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer, fill_column),
                      make_number (LISP_INT_TAG),
-                     doc: /* *Column beyond which automatic line-wrapping should happen.
+                     doc: /* Column beyond which automatic line-wrapping should happen.
 Interactively, you can set the buffer local value using \\[set-fill-column].  */);
 
   DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer, left_margin),
                      make_number (LISP_INT_TAG),
-                     doc: /* *Column for the default `indent-line-function' to indent to.
+                     doc: /* Column for the default `indent-line-function' to indent to.
 Linefeed indents to this column in Fundamental mode.  */);
 
   DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer, tab_width),
                      make_number (LISP_INT_TAG),
-                     doc: /* *Distance between tab stops (for display of tab characters), in columns.
+                     doc: /* Distance between tab stops (for display of tab characters), in columns.
 This should be an integer greater than zero.  */);
 
   DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer, ctl_arrow), Qnil,
-                     doc: /* *Non-nil means display control chars with uparrow.
+                     doc: /* Non-nil means display control chars with uparrow.
 A value of nil means use backslash and octal digits.
 This variable does not apply to characters whose display is specified
 in the current display table (if there is one).  */);
@@ -5489,7 +5482,7 @@ This variable is never applied to a way of decoding a file while reading it.  */
 
   DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
                      &BVAR (current_buffer, bidi_paragraph_direction), Qnil,
-                     doc: /* *If non-nil, forces directionality of text paragraphs in the buffer.
+                     doc: /* If non-nil, forces directionality of text paragraphs in the buffer.
 
 If this is nil (the default), the direction of each paragraph is
 determined by the first strong directional character of its text.
@@ -5500,7 +5493,7 @@ This variable has no effect unless the buffer's value of
 \`bidi-display-reordering' is non-nil.  */);
 
  DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer, truncate_lines), Qnil,
-                     doc: /* *Non-nil means do not display continuation lines.
+                     doc: /* Non-nil means do not display continuation lines.
 Instead, give each line of text just one screen line.
 
 Note that this is overridden by the variable
@@ -5510,7 +5503,7 @@ and this buffer is not full-frame width.
 Minibuffers set this variable to nil.  */);
 
   DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer, word_wrap), Qnil,
-                     doc: /* *Non-nil means to use word-wrapping for continuation lines.
+                     doc: /* Non-nil means to use word-wrapping for continuation lines.
 When word-wrapping is on, continuation lines are wrapped at the space
 or tab character nearest to the right window edge.
 If nil, continuation lines are wrapped at the right screen edge.
@@ -5631,39 +5624,39 @@ See also the functions `display-table-slot' and `set-display-table-slot'.  */);
 
   DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer, left_margin_cols),
                      Qnil,
-                     doc: /* *Width of left marginal area for display of a buffer.
+                     doc: /* Width of left marginal area for display of a buffer.
 A value of nil means no marginal area.  */);
 
   DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer, right_margin_cols),
                      Qnil,
-                     doc: /* *Width of right marginal area for display of a buffer.
+                     doc: /* Width of right marginal area for display of a buffer.
 A value of nil means no marginal area.  */);
 
   DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer, left_fringe_width),
                      Qnil,
-                     doc: /* *Width of this buffer's left fringe (in pixels).
+                     doc: /* Width of this buffer's left fringe (in pixels).
 A value of 0 means no left fringe is shown in this buffer's window.
 A value of nil means to use the left fringe width from the window's frame.  */);
 
   DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer, right_fringe_width),
                      Qnil,
-                     doc: /* *Width of this buffer's right fringe (in pixels).
+                     doc: /* Width of this buffer's right fringe (in pixels).
 A value of 0 means no right fringe is shown in this buffer's window.
 A value of nil means to use the right fringe width from the window's frame.  */);
 
   DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer, fringes_outside_margins),
                      Qnil,
-                     doc: /* *Non-nil means to display fringes outside display margins.
+                     doc: /* Non-nil means to display fringes outside display margins.
 A value of nil means to display fringes between margins and buffer text.  */);
 
   DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer, scroll_bar_width),
                      Qnil,
-                     doc: /* *Width of this buffer's scroll bars in pixels.
+                     doc: /* Width of this buffer's scroll bars in pixels.
 A value of nil means to use the scroll bar width from the window's frame.  */);
 
   DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer, vertical_scroll_bar_type),
                      Qnil,
-                     doc: /* *Position of this buffer's vertical scroll bar.
+                     doc: /* Position of this buffer's vertical scroll bar.
 The value takes effect whenever you tell a window to display this buffer;
 for instance, with `set-window-buffer' or when `display-buffer' displays it.
 
@@ -5673,13 +5666,13 @@ A value of t (the default) means do whatever the window's frame specifies.  */);
 
   DEFVAR_PER_BUFFER ("indicate-empty-lines",
                      &BVAR (current_buffer, indicate_empty_lines), Qnil,
-                     doc: /* *Visually indicate empty lines after the buffer end.
+                     doc: /* Visually indicate empty lines after the buffer end.
 If non-nil, a bitmap is displayed in the left fringe of a window on
 window-systems.  */);
 
   DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
                      &BVAR (current_buffer, indicate_buffer_boundaries), Qnil,
-                     doc: /* *Visually indicate buffer boundaries and scrolling.
+                     doc: /* Visually indicate buffer boundaries and scrolling.
 If non-nil, the first and last line of the buffer are marked in the fringe
 of a window on window-systems with angle bitmaps, or if the window can be
 scrolled, the top and bottom line of the window are marked with up and down
@@ -5704,7 +5697,7 @@ fringe, but no arrow bitmaps, use ((top .  left) (bottom . left)).  */);
 
   DEFVAR_PER_BUFFER ("fringe-indicator-alist",
                      &BVAR (current_buffer, fringe_indicator_alist), Qnil,
-                     doc: /* *Mapping from logical to physical fringe indicator bitmaps.
+                     doc: /* Mapping from logical to physical fringe indicator bitmaps.
 The value is an alist where each element (INDICATOR . BITMAPS)
 specifies the fringe bitmaps used to display a specific logical
 fringe indicator.
@@ -5723,7 +5716,7 @@ symbol which is used in both left and right fringes.  */);
 
   DEFVAR_PER_BUFFER ("fringe-cursor-alist",
                      &BVAR (current_buffer, fringe_cursor_alist), Qnil,
-                     doc: /* *Mapping from logical to physical fringe cursor bitmaps.
+                     doc: /* Mapping from logical to physical fringe cursor bitmaps.
 The value is an alist where each element (CURSOR . BITMAP)
 specifies the fringe bitmaps used to display a specific logical
 cursor type in the fringe.
@@ -5887,7 +5880,7 @@ set when a file is visited.  */);
 
   DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
                      &BVAR (current_buffer, auto_save_file_format), Qnil,
-                     doc: /* *Format in which to write auto-save files.
+                     doc: /* Format in which to write auto-save files.
 Should be a list of symbols naming formats that are defined in `format-alist'.
 If it is t, which is the default, auto-save files are written in the
 same format as a regular save would use.  */);
@@ -5937,7 +5930,7 @@ Lisp programs may give this variable certain special values:
   Vtransient_mark_mode = Qnil;
 
   DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only,
-               doc: /* *Non-nil means disregard read-only status of buffers or characters.
+               doc: /* Non-nil means disregard read-only status of buffers or characters.
 If the value is t, disregard `buffer-read-only' and all `read-only'
 text properties.  If the value is a list, disregard `buffer-read-only'
 and disregard a `read-only' text property if the property value
@@ -5972,7 +5965,7 @@ to the default frame line height.  A value of nil means add no extra space.  */)
 
   DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
                      &BVAR (current_buffer, cursor_in_non_selected_windows), Qnil,
-                     doc: /* *Non-nil means show a cursor in non-selected windows.
+                     doc: /* Non-nil means show a cursor in non-selected windows.
 If nil, only shows a cursor in the selected window.
 If t, displays a cursor related to the usual cursor type
 \(a solid box becomes hollow, a bar becomes a narrower bar).
@@ -5995,7 +5988,7 @@ The function `kill-all-local-variables' runs this before doing anything else.  *
                doc: /* Hook run when the buffer list changes.
 Functions running this hook are `get-buffer-create',
 `make-indirect-buffer', `rename-buffer', `kill-buffer',
-`record-buffer' and `unrecord-buffer'.  */);
+and `bury-buffer-internal'.  */);
   Vbuffer_list_update_hook = Qnil;
   DEFSYM (Qbuffer_list_update_hook, "buffer-list-update-hook");
 
diff --git a/src/buffer.h b/src/buffer.h
index c75a09c5579..97d891f044b 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -343,7 +343,8 @@ while (0)
  - (ptr - (current_buffer)->text->beg <= GPT_BYTE - BEG_BYTE ? 0 : GAP_SIZE) \
  + BEG_BYTE)
 
-/* Return character at byte position POS.  */
+/* Return character at byte position POS.  See the caveat WARNING for
+   FETCH_MULTIBYTE_CHAR below.  */
 
 #define FETCH_CHAR(pos)                                 \
   (!NILP (BVAR (current_buffer, enable_multibyte_characters))   \
@@ -359,7 +360,17 @@ extern unsigned char *_fetch_multibyte_char_p;
 
 /* Return character code of multi-byte form at byte position POS.  If POS
    doesn't point the head of valid multi-byte form, only the byte at
-   POS is returned.  No range checking.  */
+   POS is returned.  No range checking.
+
+   WARNING: The character returned by this macro could be "unified"
+   inside STRING_CHAR, if the original character in the buffer belongs
+   to one of the Private Use Areas (PUAs) of codepoints that Emacs
+   uses to support non-unified CJK characters.  If that happens,
+   CHAR_BYTES will return a value that is different from the length of
+   the original multibyte sequence stored in the buffer.  Therefore,
+   do _not_ use FETCH_MULTIBYTE_CHAR if you need to advance through
+   the buffer to the next character after fetching this one.  Instead,
+   use either FETCH_CHAR_ADVANCE or STRING_CHAR_AND_LENGTH.  */
 
 #define FETCH_MULTIBYTE_CHAR(pos)                                       \
   (_fetch_multibyte_char_p = (((pos) >= GPT_BYTE ? GAP_SIZE : 0)        \
diff --git a/src/callint.c b/src/callint.c
index 78daa8f8fce..506698a4e4e 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -97,7 +97,7 @@ r -- Region: point and mark as 2 numeric args, smallest first.  Does no I/O.
 s -- Any string.  Does not inherit the current input method.
 S -- Any symbol.
 U -- Mouse up event discarded by a previous k or K argument.
-v -- Variable name: symbol that is user-variable-p.
+v -- Variable name: symbol that is `custom-variable-p'.
 x -- Lisp expression read but not evaluated.
 X -- Lisp expression read and evaluated.
 z -- Coding system.
@@ -748,7 +748,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
           break;
 
         case 'v':               /* Variable name: symbol that is
-                                   user-variable-p. */
+                                   custom-variable-p. */
           args[i] = Fread_variable (callint_message, Qnil);
           visargs[i] = last_minibuf_string;
           break;
@@ -945,7 +945,7 @@ may be set by the debugger as a reminder for itself.  */);
   Vcommand_debug_status = Qnil;
 
   DEFVAR_LISP ("mark-even-if-inactive", Vmark_even_if_inactive,
-               doc: /* *Non-nil means you can use the mark even when inactive.
+               doc: /* Non-nil means you can use the mark even when inactive.
 This option makes a difference in Transient Mark mode.
 When the option is non-nil, deactivation of the mark
 turns off region highlighting, but commands that use the mark
diff --git a/src/callproc.c b/src/callproc.c
index e17e082a0d4..1dd56749e16 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -1646,16 +1646,16 @@ syms_of_callproc (void)
   staticpro (&Vtemp_file_name_pattern);
 
   DEFVAR_LISP ("shell-file-name", Vshell_file_name,
-               doc: /* *File name to load inferior shells from.
+               doc: /* File name to load inferior shells from.
 Initialized from the SHELL environment variable, or to a system-dependent
 default if SHELL is not set.  */);
 
   DEFVAR_LISP ("exec-path", Vexec_path,
-               doc: /* *List of directories to search programs to run in subprocesses.
+               doc: /* List of directories to search programs to run in subprocesses.
 Each element is a string (directory name) or nil (try default directory).  */);
 
   DEFVAR_LISP ("exec-suffixes", Vexec_suffixes,
-               doc: /* *List of suffixes to try to find executable file names.
+               doc: /* List of suffixes to try to find executable file names.
 Each element is a string.  */);
   Vexec_suffixes = Qnil;
 
diff --git a/src/character.h b/src/character.h
index cc76ab213fc..d2a7a11fa56 100644
--- a/src/character.h
+++ b/src/character.h
@@ -292,7 +292,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
   } while (0)
 
 /* Return the character code of character whose multibyte form is at
-   P.  */
+   P.  Note that this macro unifies CJK characters whose codepoints
+   are in the Private Use Areas (PUAs), so it might return a different
+   codepoint from the one actually stored at P.  */
 
 #define STRING_CHAR(p)                                          \
   (!((p)[0] & 0x80)                                             \
@@ -309,7 +311,15 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
 /* Like STRING_CHAR, but set ACTUAL_LEN to the length of multibyte
-   form.  */
+   form.
+
+   Note: This macro returns the actual length of the character's
+   multibyte sequence as it is stored in a buffer or string.  The
+   character it returns might have a different codepoint that has a
+   different multibyte sequence of a different legth, due to possible
+   unification of CJK characters inside string_char.  Therefore do NOT
+   assume that the length returned by this macro is identical to the
+   length of the multibyte sequence of the character it returns.  */
 
 #define STRING_CHAR_AND_LENGTH(p, actual_len)                   \
   (!((p)[0] & 0x80)                                             \
diff --git a/src/charset.c b/src/charset.c
index 688247de1b0..6ecc8d2c4d1 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -2395,7 +2395,7 @@ syms_of_charset (void)
   defsubr (&Ssort_charsets);
 
   DEFVAR_LISP ("charset-map-path", Vcharset_map_path,
-               doc: /* *List of directories to search for charset map files.  */);
+               doc: /* List of directories to search for charset map files.  */);
   Vcharset_map_path = Qnil;
 
   DEFVAR_BOOL ("inhibit-load-charset-map", inhibit_load_charset_map,
diff --git a/src/composite.c b/src/composite.c
index 0d1ab266309..50aca156ba4 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -355,7 +355,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
   else
     {
       /* Rule-base composition.  */
-      float leftmost = 0.0, rightmost;
+      double leftmost = 0.0, rightmost;
 
       ch = XINT (key_contents[0]);
       rightmost = ch != '\t' ? CHAR_WIDTH (ch) : 1;
@@ -364,7 +364,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
         {
           int rule, gref, nref;
           int this_width;
-          float this_left;
+          double this_left;
 
           rule = XINT (key_contents[i]);
           ch = XINT (key_contents[i + 1]);
diff --git a/src/dispextern.h b/src/dispextern.h
index 82ad1d265a5..93611403649 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -454,7 +454,7 @@ struct glyph
       /* Length of acronym or hexadecimal code string (at most 8).  */
       unsigned len : 4;
       /* Character to display.  Actually we need only 22 bits.  */
-      unsigned ch : 26;
+      unsigned ch : 25;
     } glyphless;
 
     /* Used to compare all bit-fields above in one step.  */
@@ -2152,6 +2152,10 @@ struct it
      Don't handle some `display' properties in these strings.  */
   unsigned string_from_display_prop_p : 1;
 
+  /* 1 means `string' comes from a `line-prefix' or `wrap-prefix'
+     property.  */
+  unsigned string_from_prefix_prop_p : 1;
+
   /* 1 means we are iterating an object that came from a value of a
      `display' property.  */
   unsigned from_disp_prop_p : 1;
@@ -2272,6 +2276,7 @@ struct it
     bidi_dir_t paragraph_embedding;
     unsigned multibyte_p : 1;
     unsigned string_from_display_prop_p : 1;
+    unsigned string_from_prefix_prop_p : 1;
     unsigned display_ellipsis_p : 1;
     unsigned avoid_cursor_p : 1;
     unsigned bidi_p:1;
diff --git a/src/dispnew.c b/src/dispnew.c
index f25e69e89a7..41e6e5b8df6 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -6077,10 +6077,14 @@ sit_for (Lisp_Object timeout, int reading, int do_display)
 
 
 DEFUN ("redisplay", Fredisplay, Sredisplay, 0, 1, 0,
-       doc: /* Perform redisplay if no input is available.
-If optional arg FORCE is non-nil or `redisplay-dont-pause' is non-nil,
-perform a full redisplay even if input is available.
-Return t if redisplay was performed, nil otherwise.  */)
+       doc: /* Perform redisplay.
+Optional arg FORCE, if non-nil, prevents redisplay from being
+preempted by arriving input, even if `redisplay-dont-pause' is nil.
+If `redisplay-dont-pause' is non-nil (the default), redisplay is never
+preempted by arriving input, so FORCE does nothing.
+
+Return t if redisplay was performed, nil if redisplay was preempted
+immediately by pending input.  */)
   (Lisp_Object force)
 {
   ptrdiff_t count;
@@ -6530,21 +6534,21 @@ syms_of_display (void)
   DEFSYM (Qredisplay_dont_pause, "redisplay-dont-pause");
 
   DEFVAR_INT ("baud-rate", baud_rate,
-              doc: /* *The output baud rate of the terminal.
+              doc: /* The output baud rate of the terminal.
 On most systems, changing this value will affect the amount of padding
 and the other strategic decisions made during redisplay.  */);
 
   DEFVAR_BOOL ("inverse-video", inverse_video,
-               doc: /* *Non-nil means invert the entire frame display.
+               doc: /* Non-nil means invert the entire frame display.
 This means everything is in inverse video which otherwise would not be.  */);
 
   DEFVAR_BOOL ("visible-bell", visible_bell,
-               doc: /* *Non-nil means try to flash the frame to represent a bell.
+               doc: /* Non-nil means try to flash the frame to represent a bell.
 
 See also `ring-bell-function'.  */);
 
   DEFVAR_BOOL ("no-redraw-on-reenter", no_redraw_on_reenter,
-               doc: /* *Non-nil means no need to redraw entire frame after suspending.
+               doc: /* Non-nil means no need to redraw entire frame after suspending.
 A non-nil value is useful if the terminal can automatically preserve
 Emacs's frame display when you reenter Emacs.
 It is up to you to set this variable if your terminal can do that.  */);
@@ -6599,14 +6603,15 @@ See `buffer-display-table' for more information.  */);
   Vstandard_display_table = Qnil;
 
   DEFVAR_BOOL ("redisplay-dont-pause", redisplay_dont_pause,
-               doc: /* *Non-nil means display update isn't paused when input is detected.  */);
+               doc: /* Non-nil means display update isn't paused when input is detected.  */);
   redisplay_dont_pause = 1;
 
 #if PERIODIC_PREEMPTION_CHECKING
   DEFVAR_LISP ("redisplay-preemption-period", Vredisplay_preemption_period,
-               doc: /* *The period in seconds between checking for input during redisplay.
-If input is detected, redisplay is pre-empted, and the input is processed.
-If nil, never pre-empt redisplay.  */);
+               doc: /* Period in seconds between checking for input during redisplay.
+This has an effect only if `redisplay-dont-pause' is nil; in that
+case, arriving input preempts redisplay until the input is processed.
+If the value is nil, redisplay is never preempted.  */);
   Vredisplay_preemption_period = make_float (0.10);
 #endif
 
diff --git a/src/doc.c b/src/doc.c
index d71a3ce1d80..bec20fb0d94 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -1,6 +1,6 @@
 /* Record indices of function doc strings stored in a file.
-   Copyright (C) 1985-1986, 1993-1995, 1997-2012
-                 Free Software Foundation, Inc.
+
+Copyright (C) 1985-1986, 1993-1995, 1997-2012 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -675,15 +675,18 @@ the same file name is found in the `doc-directory'.  */)
                   /* Install file-position as variable-documentation property
                      and make it negative for a user-variable
                      (doc starts with a `*').  */
-                  Fput (sym, Qvariable_documentation,
-                        make_number ((pos + end + 1 - buf)
-                                     * (end[1] == '*' ? -1 : 1)));
+                  if (!NILP (Fboundp (sym)))
+                    Fput (sym, Qvariable_documentation,
+                          make_number ((pos + end + 1 - buf)
+                                       * (end[1] == '*' ? -1 : 1)));
                 }
 
               /* Attach a docstring to a function?  */
               else if (p[1] == 'F')
-                store_function_docstring (sym, pos + end + 1 - buf);
-
+                {
+                  if (!NILP (Ffboundp (sym)))
+                    store_function_docstring (sym, pos + end + 1 - buf);
+                }
               else if (p[1] == 'S')
                 ; /* Just a source file name boundary marker.  Ignore it.  */
 
diff --git a/src/dosfns.c b/src/dosfns.c
index 8ef672fb8bb..d4b96e9df90 100644
--- a/src/dosfns.c
+++ b/src/dosfns.c
@@ -710,7 +710,7 @@ Implicitly modified when the TZ variable is changed.  */);
 #endif
 
   DEFVAR_LISP ("dos-display-scancodes", Vdos_display_scancodes,
-               doc: /* *Controls whether DOS raw keyboard events are displayed as you type.
+               doc: /* Whether DOS raw keyboard events are displayed as you type.
 When non-nil, the keyboard scan-codes are displayed at the bottom right
 corner of the display (typically at the end of the mode line).
 The output format is: scan code:char code*modifiers.  */);
@@ -718,17 +718,17 @@ The output format is: scan code:char code*modifiers.  */);
   Vdos_display_scancodes = Qnil;
 
   DEFVAR_INT ("dos-hyper-key", dos_hyper_key,
-              doc: /* *If set to 1, use right ALT key as hyper key.
+              doc: /* If set to 1, use right ALT key as hyper key.
 If set to 2, use right CTRL key as hyper key.  */);
   dos_hyper_key = 0;
 
   DEFVAR_INT ("dos-super-key", dos_super_key,
-              doc: /* *If set to 1, use right ALT key as super key.
+              doc: /* If set to 1, use right ALT key as super key.
 If set to 2, use right CTRL key as super key.  */);
   dos_super_key = 0;
 
   DEFVAR_INT ("dos-keypad-mode", dos_keypad_mode,
-              doc: /* *Controls what key code is returned by a key in the numeric keypad.
+              doc: /* Controls what key code is returned by a key in the numeric keypad.
 The `numlock ON' action is only taken if no modifier keys are pressed.
 The value is an integer constructed by adding the following bits together:
 
diff --git a/src/editfns.c b/src/editfns.c
index afd4ed48333..7e7f82c5992 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -658,10 +658,11 @@ is after LIMIT, then LIMIT will be returned instead.  */)
 
 DEFUN ("constrain-to-field", Fconstrain_to_field, Sconstrain_to_field, 2, 5, 0,
        doc: /* Return the position closest to NEW-POS that is in the same field as OLD-POS.
-
 A field is a region of text with the same `field' property.
-If NEW-POS is nil, then the current point is used instead, and set to the
-constrained position if that is different.
+
+If NEW-POS is nil, then use the current point instead, and move point
+to the resulting constrained position, in addition to returning that
+position.
 
 If OLD-POS is at the boundary of two fields, then the allowable
 positions for NEW-POS depends on the value of the optional argument
diff --git a/src/emacs.c b/src/emacs.c
index 29bc44191ab..d3e8e4466e3 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -82,10 +82,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <sys/personality.h>
 #endif
 
-#ifdef HAVE_LIBXML2
-#include <libxml/parser.h>
-#endif
-
 #ifndef O_RDWR
 #define O_RDWR 2
 #endif
@@ -2129,7 +2125,7 @@ shut_down_emacs (int sig, int no_x, Lisp_Object stuff)
 #endif
 
 #ifdef HAVE_LIBXML2
-  xmlCleanupParser ();
+  xml_cleanup_parser ();
 #endif
 }
 
diff --git a/src/eval.c b/src/eval.c
index 7f3bf6a866f..d266d995c4b 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -124,6 +124,12 @@ Lisp_Object Vsignaling_function;
 
 int handling_signal;
 
+/* If non-nil, Lisp code must not be run since some part of Emacs is
+   in an inconsistent state.  Currently, x-create-frame uses this to
+   avoid triggering window-configuration-change-hook while the new
+   frame is half-initialized.  */
+Lisp_Object inhibit_lisp_code;
+
 static Lisp_Object funcall_lambda (Lisp_Object, ptrdiff_t, Lisp_Object *);
 static void unwind_to_catch (struct catchtag *, Lisp_Object) NO_RETURN;
 static int interactive_p (int);
@@ -774,8 +780,6 @@ The optional argument DOCSTRING is a documentation string for the
 variable.
 
 To define a user option, use `defcustom' instead of `defvar'.
-The function `user-variable-p' also identifies a variable as a user
-option if its DOCSTRING starts with *, but this behavior is obsolete.
 usage: (defvar SYMBOL &optional INITVALUE DOCSTRING)  */)
   (Lisp_Object args)
 {
@@ -889,71 +893,6 @@ usage: (defconst SYMBOL INITVALUE [DOCSTRING])  */)
   return sym;
 }
 
-/* Error handler used in Fuser_variable_p.  */
-static Lisp_Object
-user_variable_p_eh (Lisp_Object ignore)
-{
-  return Qnil;
-}
-
-static Lisp_Object
-lisp_indirect_variable (Lisp_Object sym)
-{
-  struct Lisp_Symbol *s = indirect_variable (XSYMBOL (sym));
-  XSETSYMBOL (sym, s);
-  return sym;
-}
-
-DEFUN ("user-variable-p", Fuser_variable_p, Suser_variable_p, 1, 1, 0,
-       doc: /* Return t if VARIABLE is intended to be set and modified by users.
-\(The alternative is a variable used internally in a Lisp program.)
-
-This function returns t if (i) the first character of its
-documentation is `*', or (ii) it is customizable (its property list
-contains a non-nil value of `standard-value' or `custom-autoload'), or
-\(iii) it is an alias for a user variable.
-
-But condition (i) is considered obsolete, so for most purposes this is
-equivalent to `custom-variable-p'.  */)
-  (Lisp_Object variable)
-{
-  Lisp_Object documentation;
-
-  if (!SYMBOLP (variable))
-      return Qnil;
-
-  /* If indirect and there's an alias loop, don't check anything else.  */
-  if (XSYMBOL (variable)->redirect == SYMBOL_VARALIAS
-      && NILP (internal_condition_case_1 (lisp_indirect_variable, variable,
-                                          Qt, user_variable_p_eh)))
-    return Qnil;
-
-  while (1)
-    {
-      documentation = Fget (variable, Qvariable_documentation);
-      if (INTEGERP (documentation) && XINT (documentation) < 0)
-        return Qt;
-      if (STRINGP (documentation)
-          && ((unsigned char) SREF (documentation, 0) == '*'))
-        return Qt;
-      /* If it is (STRING . INTEGER), a negative integer means a user variable.  */
-      if (CONSP (documentation)
-          && STRINGP (XCAR (documentation))
-          && INTEGERP (XCDR (documentation))
-          && XINT (XCDR (documentation)) < 0)
-        return Qt;
-      /* Customizable?  See `custom-variable-p'.  */
-      if ((!NILP (Fget (variable, intern ("standard-value"))))
-          || (!NILP (Fget (variable, intern ("custom-autoload")))))
-        return Qt;
-
-      if (!(XSYMBOL (variable)->redirect == SYMBOL_VARALIAS))
-        return Qnil;
-
-      /* An indirect variable?  Let's follow the chain.  */
-      XSETSYMBOL (variable, SYMBOL_ALIAS (XSYMBOL (variable)));
-    }
-}
 
 DEFUN ("let*", FletX, SletX, 1, UNEVALLED, 0,
        doc: /* Bind variables according to VARLIST then eval BODY.
@@ -3592,7 +3531,7 @@ void
 syms_of_eval (void)
 {
   DEFVAR_INT ("max-specpdl-size", max_specpdl_size,
-              doc: /* *Limit on number of Lisp variable bindings and `unwind-protect's.
+              doc: /* Limit on number of Lisp variable bindings and `unwind-protect's.
 If Lisp code tries to increase the total number past this amount,
 an error is signaled.
 You can safely use a value considerably larger than the default value,
@@ -3600,7 +3539,7 @@ if that proves inconveniently small.  However, if you increase it too far,
 Emacs could run out of memory trying to make the stack bigger.  */);
 
   DEFVAR_INT ("max-lisp-eval-depth", max_lisp_eval_depth,
-              doc: /* *Limit on depth in `eval', `apply' and `funcall' before error.
+              doc: /* Limit on depth in `eval', `apply' and `funcall' before error.
 
 This limit serves to catch infinite recursions for you before they cause
 actual stack overflow in C, which would be fatal for Emacs.
@@ -3644,7 +3583,7 @@ before making `inhibit-quit' nil.  */);
   DEFSYM (Qdebug, "debug");
 
   DEFVAR_LISP ("debug-on-error", Vdebug_on_error,
-               doc: /* *Non-nil means enter debugger if an error is signaled.
+               doc: /* Non-nil means enter debugger if an error is signaled.
 Does not apply to errors handled by `condition-case' or those
 matched by `debug-ignored-errors'.
 If the value is a list, an error only means to enter the debugger
@@ -3656,7 +3595,7 @@ See also the variable `debug-on-quit'.  */);
   Vdebug_on_error = Qnil;
 
   DEFVAR_LISP ("debug-ignored-errors", Vdebug_ignored_errors,
-    doc: /* *List of errors for which the debugger should not be called.
+    doc: /* List of errors for which the debugger should not be called.
 Each element may be a condition-name or a regexp that matches error messages.
 If any element applies to a given error, that error skips the debugger
 and just returns to top level.
@@ -3665,7 +3604,7 @@ It does not apply to errors handled by `condition-case'.  */);
   Vdebug_ignored_errors = Qnil;
 
   DEFVAR_BOOL ("debug-on-quit", debug_on_quit,
-    doc: /* *Non-nil means enter debugger if quit is signaled (C-g, for example).
+    doc: /* Non-nil means enter debugger if quit is signaled (C-g, for example).
 Does not apply if quit is handled by a `condition-case'.  */);
   debug_on_quit = 0;
 
@@ -3694,7 +3633,7 @@ The Edebug package uses this to regain control.  */);
   Vsignal_hook_function = Qnil;
 
   DEFVAR_LISP ("debug-on-signal", Vdebug_on_signal,
-               doc: /* *Non-nil means call the debugger regardless of condition handlers.
+               doc: /* Non-nil means call the debugger regardless of condition handlers.
 Note that `debug-on-error', `debug-on-quit' and friends
 still determine whether to handle the particular condition.  */);
   Vdebug_on_signal = Qnil;
@@ -3734,6 +3673,8 @@ alist of active lexical bindings.  */);
   staticpro (&Vsignaling_function);
   Vsignaling_function = Qnil;
 
+  inhibit_lisp_code = Qnil;
+
   defsubr (&Sor);
   defsubr (&Sand);
   defsubr (&Sif);
@@ -3749,7 +3690,6 @@ alist of active lexical bindings.  */);
   defsubr (&Sdefvar);
   defsubr (&Sdefvaralias);
   defsubr (&Sdefconst);
-  defsubr (&Suser_variable_p);
   defsubr (&Slet);
   defsubr (&SletX);
   defsubr (&Swhile);
diff --git a/src/fileio.c b/src/fileio.c
index 3cd44df012b..c5442d560fd 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -5618,7 +5618,7 @@ syms_of_fileio (void)
   DEFSYM (Qexcl, "excl");
 
   DEFVAR_LISP ("file-name-coding-system", Vfile_name_coding_system,
-               doc: /* *Coding system for encoding file names.
+               doc: /* Coding system for encoding file names.
 If it is nil, `default-file-name-coding-system' (which see) is used.  */);
   Vfile_name_coding_system = Qnil;
 
@@ -5772,7 +5772,7 @@ file is usually more useful if it contains the deleted text.  */);
 
 #ifdef HAVE_FSYNC
   DEFVAR_BOOL ("write-region-inhibit-fsync", write_region_inhibit_fsync,
-               doc: /* *Non-nil means don't call fsync in `write-region'.
+               doc: /* Non-nil means don't call fsync in `write-region'.
 This variable affects calls to `write-region' as well as save commands.
 A non-nil value may result in data loss!  */);
   write_region_inhibit_fsync = 0;
diff --git a/src/fns.c b/src/fns.c
index ed4f9d40b59..6c7c1b21045 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -4937,7 +4937,7 @@ Used by `featurep' and `require', and altered by `provide'.  */);
 #endif  /* HAVE_LANGINFO_CODESET */
 
   DEFVAR_BOOL ("use-dialog-box", use_dialog_box,
-    doc: /* *Non-nil means mouse commands use dialog boxes to ask questions.
+    doc: /* Non-nil means mouse commands use dialog boxes to ask questions.
 This applies to `y-or-n-p' and `yes-or-no-p' questions asked by commands
 invoked by mouse clicks and mouse menu items.
 
@@ -4946,7 +4946,7 @@ non-nil.  */);
   use_dialog_box = 1;
 
   DEFVAR_BOOL ("use-file-dialog", use_file_dialog,
-    doc: /* *Non-nil means mouse commands use a file dialog to ask for files.
+    doc: /* Non-nil means mouse commands use a file dialog to ask for files.
 This applies to commands from menus and tool bar buttons even when
 they are initiated from the keyboard.  If `use-dialog-box' is nil,
 that disables the use of a file dialog, regardless of the value of
diff --git a/src/fontset.c b/src/fontset.c
index 7057167cfd4..b2c7249625e 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -2229,7 +2229,7 @@ alternate fontnames (if any) are tried instead.  */);
 
   DEFVAR_LISP ("vertical-centering-font-regexp",
                Vvertical_centering_font_regexp,
-               doc: /* *Regexp matching font names that require vertical centering on display.
+               doc: /* Regexp matching font names that require vertical centering on display.
 When a character is displayed with such fonts, the character is displayed
 at the vertical center of lines.  */);
   Vvertical_centering_font_regexp = Qnil;
diff --git a/src/frame.c b/src/frame.c
index 8b285437288..e962251f420 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -1118,41 +1118,32 @@ Otherwise, include all frames.  */)
 static int
 other_visible_frames (FRAME_PTR f)
 {
-  /* We know the selected frame is visible,
-     so if F is some other frame, it can't be the sole visible one.  */
-  if (f == SELECTED_FRAME ())
-    {
-      Lisp_Object frames;
-      int count = 0;
+  Lisp_Object frames;
 
-      for (frames = Vframe_list;
-           CONSP (frames);
-           frames = XCDR (frames))
-        {
-          Lisp_Object this;
+  for (frames = Vframe_list; CONSP (frames); frames = XCDR (frames))
+    {
+      Lisp_Object this = XCAR (frames);
+      if (f == XFRAME (this))
+        continue;
 
-          this = XCAR (frames);
-          /* Verify that the frame's window still exists
-             and we can still talk to it.  And note any recent change
-             in visibility.  */
+      /* Verify that we can still talk to the frame's X window,
+         and note any recent change in visibility.  */
 #ifdef HAVE_WINDOW_SYSTEM
-          if (FRAME_WINDOW_P (XFRAME (this)))
-            {
-              x_sync (XFRAME (this));
-              FRAME_SAMPLE_VISIBILITY (XFRAME (this));
-            }
+      if (FRAME_WINDOW_P (XFRAME (this)))
+        {
+          x_sync (XFRAME (this));
+          FRAME_SAMPLE_VISIBILITY (XFRAME (this));
+        }
 #endif
 
-          if (FRAME_VISIBLE_P (XFRAME (this))
-              || FRAME_ICONIFIED_P (XFRAME (this))
-              /* Allow deleting the terminal frame when at least
-                 one X frame exists!  */
-              || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f)))
-            count++;
-        }
-      return count > 1;
+      if (FRAME_VISIBLE_P (XFRAME (this))
+          || FRAME_ICONIFIED_P (XFRAME (this))
+          /* Allow deleting the terminal frame when at least one X
+             frame exists.  */
+          || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f)))
+        return 1;
     }
-  return 1;
+  return 0;
 }
 
 /* Delete FRAME.  When FORCE equals Qnoelisp, delete FRAME
diff --git a/src/fringe.c b/src/fringe.c
index 4bc2f8806f3..c591d391e9f 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -1756,7 +1756,7 @@ syms_of_fringe (void)
   defsubr (&Sset_fringe_bitmap_face);
 
   DEFVAR_LISP ("overflow-newline-into-fringe", Voverflow_newline_into_fringe,
-    doc: /* *Non-nil means that newline may flow into the right fringe.
+    doc: /* Non-nil means that newline may flow into the right fringe.
 This means that display lines which are exactly as wide as the window
 (not counting the final newline) will only occupy one screen line, by
 showing (or hiding) the final newline in the right fringe; when point
diff --git a/src/ftfont.c b/src/ftfont.c
index 3c0b09b7f74..5545b4b4ae2 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -1856,7 +1856,7 @@ ftfont_drive_otf (MFLTFont *font,
   setup_otf_gstring (len);
   for (i = 0; i < len; i++)
     {
-      otf_gstring.glyphs[i].c = in->glyphs[from + i].c;
+      otf_gstring.glyphs[i].c = in->glyphs[from + i].c & 0x11FFFF;
       otf_gstring.glyphs[i].glyph_id = in->glyphs[from + i].code;
     }
 
diff --git a/src/gnutls.c b/src/gnutls.c
index 99fc5c10e2b..8dbf01cedc9 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -247,18 +247,27 @@ init_gnutls_functions (Lisp_Object libraries)
 #endif /* !WINDOWSNT */
 
 
+/* Function to log a simple message.  */
 static void
 gnutls_log_function (int level, const char* string)
 {
   message ("gnutls.c: [%d] %s", level, string);
 }
 
+/* Function to log a message and a string.  */
 static void
 gnutls_log_function2 (int level, const char* string, const char* extra)
 {
   message ("gnutls.c: [%d] %s %s", level, string, extra);
 }
 
+/* Function to log a message and an integer.  */
+static void
+gnutls_log_function2i (int level, const char* string, int extra)
+{
+  message ("gnutls.c: [%d] %s %d", level, string, extra);
+}
+
 static int
 emacs_gnutls_handshake (struct Lisp_Process *proc)
 {
@@ -399,10 +408,25 @@ emacs_gnutls_read (struct Lisp_Process *proc, char *buf, ptrdiff_t nbyte)
   ssize_t rtnval;
   gnutls_session_t state = proc->gnutls_state;
 
+  int log_level = proc->gnutls_log_level;
+
   if (proc->gnutls_initstage != GNUTLS_STAGE_READY)
     {
-      emacs_gnutls_handshake (proc);
-      return -1;
+      /* If the handshake count is under the limit, try the handshake
+         again and increment the handshake count.  This count is kept
+         per process (connection), not globally.  */
+      if (proc->gnutls_handshakes_tried < GNUTLS_EMACS_HANDSHAKES_LIMIT)
+        {
+          proc->gnutls_handshakes_tried++;
+          emacs_gnutls_handshake (proc);
+          GNUTLS_LOG2i (5, log_level, "Retried handshake", 
+                        proc->gnutls_handshakes_tried);
+          return -1;
+        }
+
+      GNUTLS_LOG (2, log_level, "Giving up on handshake; resetting retries");
+      proc->gnutls_handshakes_tried = 0;
+      return 0;
     }
   rtnval = fn_gnutls_record_recv (state, buf, nbyte);
   if (rtnval >= 0)
diff --git a/src/gnutls.h b/src/gnutls.h
index b6afba25355..2b13908a748 100644
--- a/src/gnutls.h
+++ b/src/gnutls.h
@@ -23,6 +23,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <gnutls/gnutls.h>
 #include <gnutls/x509.h>
 
+/* This limits the attempts to handshake per process (connection).  */
+#define GNUTLS_EMACS_HANDSHAKES_LIMIT 100
+
 typedef enum
 {
   /* Initialization stages.  */
@@ -53,6 +56,8 @@ typedef enum
 
 #define GNUTLS_LOG2(level, max, string, extra) do { if (level <= max) { gnutls_log_function2 (level, "(Emacs) " string, extra); } } while (0)
 
+#define GNUTLS_LOG2i(level, max, string, extra) do { if (level <= max) { gnutls_log_function2i (level, "(Emacs) " string, extra); } } while (0)
+
 extern ptrdiff_t
 emacs_gnutls_write (struct Lisp_Process *proc, const char *buf, ptrdiff_t nbyte);
 extern ptrdiff_t
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 433cd8aa412..d39a0eedf41 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -1304,10 +1304,13 @@ x_wm_set_size_hint (FRAME_PTR f, long int flags, int user_position)
 
   hint_flags |= GDK_HINT_BASE_SIZE;
   base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0) + FRAME_TOOLBAR_WIDTH (f);
-  base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 0)
+  /* Use one row here so base_height does not become zero.
+     Gtk+ and/or Unity on Ubuntu 12.04 can't handle it.  */
+  base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 1)
     + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
 
   check_frame_size (f, &min_rows, &min_cols);
+  if (min_rows > 0) --min_rows; /* We used one row in base_height = ... 1); */
 
   size_hints.base_width = base_width;
   size_hints.base_height = base_height;
diff --git a/src/indent.c b/src/indent.c
index b1c86c3ab13..22b0bb2c668 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -2021,6 +2021,7 @@ whether or not it is currently displayed in some window.  */)
       ptrdiff_t it_start, it_overshoot_count = 0;
       int first_x;
       int overshoot_handled = 0;
+      int disp_string_at_start_p = 0;
 
       itdata = bidi_shelve_cache ();
       SET_TEXT_POS (pt, PT, PT_BYTE);
@@ -2035,6 +2036,8 @@ whether or not it is currently displayed in some window.  */)
         {
           const char *s = SSDATA (it.string);
           const char *e = s + SBYTES (it.string);
+
+          disp_string_at_start_p = it.string_from_display_prop_p;
           while (s < e)
             {
               if (*s++ == '\n')
@@ -2062,7 +2065,8 @@ whether or not it is currently displayed in some window.  */)
       /* IT may move too far if truncate-lines is on and PT lies
          beyond the right margin.  IT may also move too far if the
          starting point is on a Lisp string that has embedded
-         newlines.  In these cases, backtrack.  */
+         newlines, or spans several screen lines.  In these cases,
+         backtrack.  */
       if (IT_CHARPOS (it) > it_start)
         {
           /* We need to backtrack also if the Lisp string contains no
@@ -2073,6 +2077,14 @@ whether or not it is currently displayed in some window.  */)
               && it.method == GET_FROM_BUFFER
               && it.c == '\n')
             it_overshoot_count = 1;
+          else if (disp_string_at_start_p && it.vpos > 0)
+            {
+              /* This is the case of a display string that spans
+                 several screen lines.  In that case, we end up at the
+                 end of the string, and it.vpos tells us how many
+                 screen lines we need to backtrack.  */
+              it_overshoot_count = it.vpos;
+            }
           if (it_overshoot_count > 0)
             move_it_by_lines (&it, -it_overshoot_count);
 
@@ -2151,7 +2163,7 @@ void
 syms_of_indent (void)
 {
   DEFVAR_BOOL ("indent-tabs-mode", indent_tabs_mode,
-               doc: /* *Indentation can insert tabs if this is non-nil.  */);
+               doc: /* Indentation can insert tabs if this is non-nil.  */);
   indent_tabs_mode = 1;
 
   defsubr (&Scurrent_indentation);
diff --git a/src/keyboard.c b/src/keyboard.c
index eb9152f2c6c..bad91ea3f72 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -241,6 +241,7 @@ Lisp_Object internal_last_event_frame;
 Time last_event_timestamp;
 
 static Lisp_Object Qx_set_selection, Qhandle_switch_frame;
+static Lisp_Object Qhandle_select_window;
 Lisp_Object QPRIMARY;
 
 static Lisp_Object Qself_insert_command;
@@ -1645,7 +1646,8 @@ command_loop_1 (void)
                       ? EQ (CAR_SAFE (Vtransient_mark_mode), Qonly)
                       : (!NILP (Vselect_active_regions)
                          && !NILP (Vtransient_mark_mode)))
-                  && !EQ (Vthis_command, Qhandle_switch_frame))
+                  && NILP (Fmemq (Vthis_command,
+                                  Vselection_inhibit_update_commands)))
                 {
                   ptrdiff_t beg =
                     XINT (Fmarker_position (BVAR (current_buffer, mark)));
@@ -1877,7 +1879,7 @@ safe_run_hooks_error (Lisp_Object error_data)
     = CONSP (Vinhibit_quit) ? XCAR (Vinhibit_quit) : Vinhibit_quit;
   Lisp_Object fun = CONSP (Vinhibit_quit) ? XCDR (Vinhibit_quit) : Qnil;
   Lisp_Object args[4];
-  args[0] = build_string ("Error in %s (%s): %s");
+  args[0] = build_string ("Error in %s (%s): %S");
   args[1] = hook;
   args[2] = fun;
   args[3] = error_data;
@@ -11654,6 +11656,7 @@ syms_of_keyboard (void)
   DEFSYM (Qx_set_selection, "x-set-selection");
   DEFSYM (QPRIMARY, "PRIMARY");
   DEFSYM (Qhandle_switch_frame, "handle-switch-frame");
+  DEFSYM (Qhandle_select_window, "handle-select-window");
 
   DEFSYM (Qinput_method_function, "input-method-function");
   DEFSYM (Qinput_method_exit_on_first_char, "input-method-exit-on-first-char");
@@ -12170,7 +12173,7 @@ whenever `deferred-action-list' is non-nil.  */);
   Vdeferred_action_function = Qnil;
 
   DEFVAR_LISP ("delayed-warnings-list", Vdelayed_warnings_list,
-               doc: /* List of warnings to be displayed as soon as possible.
+               doc: /* List of warnings to be displayed after this command.
 Each element must be a list (TYPE MESSAGE [LEVEL [BUFFER-NAME]]),
 as per the args of `display-warning' (which see).
 If this variable is non-nil, `delayed-warnings-hook' will be run
@@ -12290,6 +12293,16 @@ text in the region before modifying the buffer.  The next
 `deactivate-mark' call uses this to set the window selection.  */);
   Vsaved_region_selection = Qnil;
 
+  DEFVAR_LISP ("selection-inhibit-update-commands",
+               Vselection_inhibit_update_commands,
+               doc: /* List of commands which should not update the selection.
+Normally, if `select-active-regions' is non-nil and the mark remains
+active after a command (i.e. the mark was not deactivated), the Emacs
+command loop sets the selection to the text in the region.  However,
+if the command is in this list, the selection is not updated.  */);
+  Vselection_inhibit_update_commands
+    = list2 (Qhandle_switch_frame, Qhandle_select_window);
+
   DEFVAR_LISP ("debug-on-event",
                Vdebug_on_event,
                doc: /* Enter debugger on this event.  When Emacs
diff --git a/src/keymap.c b/src/keymap.c
index 328e6d8ed23..e8f2f88bb26 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -2053,8 +2053,9 @@ static Lisp_Object Qsingle_key_description, Qkey_description;
 DEFUN ("key-description", Fkey_description, Skey_description, 1, 2, 0,
        doc: /* Return a pretty description of key-sequence KEYS.
 Optional arg PREFIX is the sequence of keys leading up to KEYS.
-Control characters turn into "C-foo" sequences, meta into "M-foo",
-spaces are put between sequence elements, etc.  */)
+For example, [?\C-x ?l] is converted into the string \"C-x l\".
+
+The `kbd' macro is an approximate inverse of this.  */)
   (Lisp_Object keys, Lisp_Object prefix)
 {
   ptrdiff_t len = 0;
diff --git a/src/lisp.h b/src/lisp.h
index 47570ebee74..864346d85c2 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1139,6 +1139,8 @@ struct Lisp_Symbol
      special (with `defvar' etc), and shouldn't be lexically bound.  */
   unsigned declared_special : 1;
 
+  unsigned spacer : 23;
+
   /* The symbol's name, as a Lisp string.
      The name "xname" is used to intentionally break code referring to
      the old field "name" of type pointer to struct Lisp_String.  */
@@ -2970,6 +2972,7 @@ extern Lisp_Object Qinhibit_quit, Qclosure;
 extern Lisp_Object Qand_rest;
 extern Lisp_Object Vautoload_queue;
 extern Lisp_Object Vsignaling_function;
+extern Lisp_Object inhibit_lisp_code;
 extern int handling_signal;
 #if BYTE_MARK_STACK
 extern struct catchtag *catchlist;
@@ -3580,6 +3583,7 @@ EXFUN (Fmsdos_downcase_filename, 1);
 #ifdef HAVE_LIBXML2
 /* Defined in xml.c */
 extern void syms_of_xml (void);
+extern void xml_cleanup_parser (void);
 #endif
 
 #ifdef HAVE_MENUS
diff --git a/src/lread.c b/src/lread.c
index dfcb3eeab5e..48849cccd2b 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -4448,7 +4448,7 @@ were read in. */);
   Vread_circle = Qt;
 
   DEFVAR_LISP ("load-path", Vload_path,
-               doc: /* *List of directories to search for files to load.
+               doc: /* List of directories to search for files to load.
 Each element is a string (directory name) or nil (try default directory).
 Initialized based on EMACSLOADPATH environment variable, if any,
 otherwise to default specified by file `epaths.h' when Emacs was built.  */);
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index d7ca325e223..303445bc2d6 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -128,6 +128,7 @@ OBJ2 =  $(BLD)/sysdep.$(O)		\
         $(BLD)/image.$(O)               \
         $(BLD)/terminal.$(O)            \
         $(BLD)/menu.$(O)                \
+        $(BLD)/xml.$(O)                 \
         $(BLD)/w32term.$(O)             \
         $(BLD)/w32xfns.$(O)             \
         $(BLD)/w32fns.$(O)              \
@@ -225,7 +226,7 @@ GLOBAL_SOURCES =   dosfns.c msdos.c \
         process.c callproc.c unexw32.c \
         region-cache.c sound.c atimer.c \
         doprnt.c intervals.c textprop.c composite.c \
-        gnutls.c
+        gnutls.c xml.c
 SOME_MACHINE_OBJECTS = dosfns.o msdos.o \
         xterm.o xfns.o xmenu.o xselect.o xrdb.o xsmfns.o dbusbind.o
 obj = $(GLOBAL_SOURCES:.c=.o)
@@ -940,6 +941,13 @@ $(BLD)/gnutls.$(O) : \
         $(LISP_H) \
         $(PROCESS_H)
 
+$(BLD)/xml.$(O) : \
+        $(SRC)/xml.c \
+        $(SRC)/buffer.h \
+        $(SRC)/w32.h \
+        $(CONFIG_H) \
+        $(LISP_H)
+
 $(BLD)/image.$(O) : \
         $(SRC)/image.c \
         $(SRC)/epaths.h \
diff --git a/src/minibuf.c b/src/minibuf.c
index c3a49bff0a5..e9bc36303f9 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -72,7 +72,7 @@ Lisp_Object Qcompletion_ignore_case;
 static Lisp_Object Qminibuffer_completion_table;
 static Lisp_Object Qminibuffer_completion_predicate;
 static Lisp_Object Qminibuffer_completion_confirm;
-static Lisp_Object Quser_variable_p;
+static Lisp_Object Qcustom_variable_p;
 
 static Lisp_Object Qminibuffer_default;
 
@@ -1094,10 +1094,11 @@ Prompt with PROMPT.  */)
 #endif /* NOTDEF */
 
 DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
-       doc: /* Read the name of a user variable and return it as a symbol.
+       doc: /* Read the name of a user option and return it as a symbol.
 Prompt with PROMPT.  By default, return DEFAULT-VALUE or its first element
 if it is a list.
-A user variable is one for which `user-variable-p' returns non-nil.  */)
+A user option, or customizable variable, is one for which
+`custom-variable-p' returns non-nil.  */)
   (Lisp_Object prompt, Lisp_Object default_value)
 {
   Lisp_Object name, default_string;
@@ -1110,7 +1111,7 @@ A user variable is one for which `user-variable-p' returns non-nil.  */)
     default_string = default_value;
 
   name = Fcompleting_read (prompt, Vobarray,
-                           Quser_variable_p, Qt,
+                           Qcustom_variable_p, Qt,
                            Qnil, Qnil, default_string, Qnil);
   if (NILP (name))
     return name;
@@ -1975,11 +1976,11 @@ syms_of_minibuf (void)
   staticpro (&last_minibuf_string);
   last_minibuf_string = Qnil;
 
-  DEFSYM (Quser_variable_p, "user-variable-p");
   DEFSYM (Qminibuffer_history, "minibuffer-history");
   DEFSYM (Qbuffer_name_history, "buffer-name-history");
   Fset (Qbuffer_name_history, Qnil);
 
+  DEFSYM (Qcustom_variable_p, "custom-variable-p");
   DEFSYM (Qminibuffer_setup_hook, "minibuffer-setup-hook");
   DEFSYM (Qminibuffer_exit_hook, "minibuffer-exit-hook");
   DEFSYM (Qhistory_length, "history-length");
diff --git a/src/msdos.c b/src/msdos.c
index 885cedd3df0..5f46829aefd 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -4270,7 +4270,7 @@ syms_of_msdos (void)
   DEFSYM (Qreverse, "reverse");
 
   DEFVAR_LISP ("dos-unsupported-char-glyph", Vdos_unsupported_char_glyph,
-               doc: /* *Glyph to display instead of chars not supported by current codepage.
+               doc: /* Glyph to display instead of chars not supported by current codepage.
 This variable is used only by MS-DOS terminals.  */);
   Vdos_unsupported_char_glyph = make_number ('\177');
 
diff --git a/src/print.c b/src/print.c
index 443869b6fd0..868d61ba2f1 100644
--- a/src/print.c
+++ b/src/print.c
@@ -2141,7 +2141,7 @@ shared once again when the text is read back.  */);
   Vprint_gensym = Qnil;
 
   DEFVAR_LISP ("print-circle", Vprint_circle,
-               doc: /* *Non-nil means print recursive structures using #N= and #N# syntax.
+               doc: /* Non-nil means print recursive structures using #N= and #N# syntax.
 If nil, printing proceeds recursively and may lead to
 `max-lisp-eval-depth' being exceeded or an error may occur:
 \"Apparently circular structure being printed.\"  Also see
@@ -2153,7 +2153,7 @@ where N is a positive decimal integer.  */);
   Vprint_circle = Qnil;
 
   DEFVAR_LISP ("print-continuous-numbering", Vprint_continuous_numbering,
-               doc: /* *Non-nil means number continuously across print calls.
+               doc: /* Non-nil means number continuously across print calls.
 This affects the numbers printed for #N= labels and #M# references.
 See also `print-circle', `print-gensym', and `print-number-table'.
 This variable should not be set with `setq'; bind it with a `let' instead.  */);
diff --git a/src/process.c b/src/process.c
index daa49b129ae..9ccc77e1d83 100644
--- a/src/process.c
+++ b/src/process.c
@@ -640,7 +640,10 @@ make_process (Lisp_Object name)
 
 #ifdef HAVE_GNUTLS
   p->gnutls_initstage = GNUTLS_STAGE_EMPTY;
+  /* Default log level.  */
   p->gnutls_log_level = 0;
+  /* GnuTLS handshakes attempted for this connection.  */
+  p->gnutls_handshakes_tried = 0;
   p->gnutls_p = 0;
   p->gnutls_state = NULL;
   p->gnutls_x509_cred = NULL;
@@ -4874,15 +4877,20 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
                  It can't hurt.  */
               else if (nread == -1 && errno == EIO)
                 {
-                  /* Clear the descriptor now, so we only raise the signal once.  */
-                  FD_CLR (channel, &input_wait_mask);
-                  FD_CLR (channel, &non_keyboard_wait_mask);
-
-                  kill (getpid (), SIGCHLD);
+                  /* Don't do anything if only a pty, with no associated
+                     process (bug#10933).  */
+                  if (XPROCESS (proc)->pid != -2) {
+                    /* Clear the descriptor now, so we only raise the signal
+                       once.  */
+                    FD_CLR (channel, &input_wait_mask);
+                    FD_CLR (channel, &non_keyboard_wait_mask);
+                    
+                    kill (getpid (), SIGCHLD);
+                  }
                 }
 #endif /* HAVE_PTYS */
-              /* If we can detect process termination, don't consider the process
-                 gone just because its pipe is closed.  */
+              /* If we can detect process termination, don't consider the
+                 process gone just because its pipe is closed.  */
 #ifdef SIGCHLD
               else if (nread == 0 && !NETCONN_P (proc) && !SERIALCONN_P (proc))
                 ;
@@ -7426,7 +7434,7 @@ syms_of_process (void)
   DEFSYM (Qargs, "args");
 
   DEFVAR_BOOL ("delete-exited-processes", delete_exited_processes,
-               doc: /* *Non-nil means delete processes immediately when they exit.
+               doc: /* Non-nil means delete processes immediately when they exit.
 A value of nil means don't delete them until `list-processes' is run.  */);
 
   delete_exited_processes = 1;
diff --git a/src/process.h b/src/process.h
index 9efde261386..3eb94cb196b 100644
--- a/src/process.h
+++ b/src/process.h
@@ -134,6 +134,7 @@ struct Lisp_Process
     gnutls_certificate_client_credentials gnutls_x509_cred;
     gnutls_anon_client_credentials_t gnutls_anon_cred;
     int gnutls_log_level;
+    int gnutls_handshakes_tried;
     int gnutls_p;
 #endif
 };
diff --git a/src/s/gnu-linux.h b/src/s/gnu-linux.h
index b54bd985e6b..c1233c0e6ce 100644
--- a/src/s/gnu-linux.h
+++ b/src/s/gnu-linux.h
@@ -146,9 +146,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
     || defined __ia64__ || defined __sh__
 #define GC_SETJMP_WORKS 1
 #define GC_MARK_STACK GC_MAKE_GCPROS_NOOPS
-#ifdef __mc68000__
-#define GC_LISP_OBJECT_ALIGNMENT 2
-#endif
 #ifdef __ia64__
 #define GC_MARK_SECONDARY_STACK()                               \
   do {                                                          \
diff --git a/src/s/ms-w32.h b/src/s/ms-w32.h
index d533ae34ac3..e89ecb05931 100644
--- a/src/s/ms-w32.h
+++ b/src/s/ms-w32.h
@@ -159,6 +159,9 @@ struct sigaction {
 #undef  HAVE_UTIMES
 #undef  HAVE_SETRLIMIT
 #undef  HAVE_SETPGID
+/* If you think about defining HAVE_GETCWD, don't: the alternative
+   getwd is redefined on w32.c, and does not really return the current
+   directory, to get the desired results elsewhere in Emacs */
 #undef  HAVE_GETCWD
 #define HAVE_SHUTDOWN 1
 
@@ -286,6 +289,12 @@ typedef int pid_t;
 #define stricmp   _stricmp
 #define tzset     _tzset
 
+/* Include time.h before redirecting tzname, since MSVC's time.h
+   defines _tzname to call a function, but also declares tzname a
+   2-element array.  Having the redirection before including the
+   header thus has the effect of declaring a function that returns an
+   array, and triggers an error message.  */
+#include <time.h>
 #define tzname    _tzname
 #if !defined (_MSC_VER) || (_MSC_VER < 1400)
 #undef  utime
diff --git a/src/search.c b/src/search.c
index f33965d4d70..503720b70ab 100644
--- a/src/search.c
+++ b/src/search.c
@@ -1,6 +1,7 @@
 /* String search routines for GNU Emacs.
-   Copyright (C) 1985-1987, 1993-1994, 1997-1999, 2001-2012
-                 Free Software Foundation, Inc.
+
+Copyright (C) 1985-1987, 1993-1994, 1997-1999, 2001-2012
+  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -2268,7 +2269,7 @@ DEFUN ("word-search-backward-lax", Fword_search_backward_lax, Sword_search_backw
 Set point to the beginning of the occurrence found, and return point.
 
 Unlike `word-search-backward', the end of STRING need not match a word
-boundary unless it ends in whitespace.
+boundary, unless STRING ends in whitespace.
 
 An optional second argument bounds the search; it is a buffer position.
 The match found must not extend before that position.
@@ -2290,7 +2291,7 @@ DEFUN ("word-search-forward-lax", Fword_search_forward_lax, Sword_search_forward
 Set point to the end of the occurrence found, and return point.
 
 Unlike `word-search-forward', the end of STRING need not match a word
-boundary unless it ends in whitespace.
+boundary, unless STRING ends in whitespace.
 
 An optional second argument bounds the search; it is a buffer position.
 The match found must not extend after that position.
diff --git a/src/syntax.c b/src/syntax.c
index 70e66ba1871..71da13e7a66 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -3498,7 +3498,7 @@ See the info node `(elisp)Syntax Properties' for a description of the
 
   DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
                open_paren_in_column_0_is_defun_start,
-               doc: /* *Non-nil means an open paren in column 0 denotes the start of a defun.  */);
+               doc: /* Non-nil means an open paren in column 0 denotes the start of a defun.  */);
   open_paren_in_column_0_is_defun_start = 1;
 
 
diff --git a/src/w32heap.c b/src/w32heap.c
index 35ac4cbf31f..da8579896f2 100644
--- a/src/w32heap.c
+++ b/src/w32heap.c
@@ -296,27 +296,3 @@ round_heap (unsigned long align)
   if (need_to_alloc)
     sbrk (need_to_alloc);
 }
-
-#if (_MSC_VER >= 1000 && _MSC_VER < 1300 && !defined (USE_CRT_DLL))
-
-/* MSVC 4.2 invokes these functions from mainCRTStartup to initialize
-   a heap via HeapCreate.  They are normally defined by the runtime,
-   but we override them here so that the unnecessary HeapCreate call
-   is not performed.  */
-
-int __cdecl
-_heap_init (void)
-{
-  /* Stepping through the assembly indicates that mainCRTStartup is
-     expecting a nonzero success return value.  */
-  return 1;
-}
-
-void __cdecl
-_heap_term (void)
-{
-  return;
-}
-
-#endif
-
diff --git a/src/w32menu.c b/src/w32menu.c
index 4b3aa4f8047..dd741a01b5b 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -1173,18 +1173,23 @@ w32_dialog_show (FRAME_PTR f, int keymaps,
 static int
 is_simple_dialog (Lisp_Object contents)
 {
-  Lisp_Object options = XCDR (contents);
+  Lisp_Object options;
   Lisp_Object name, yes, no, other;
 
+  if (!CONSP (contents))
+    return 0;
+  options = XCDR (contents);
+
   yes = build_string ("Yes");
   no = build_string ("No");
 
   if (!CONSP (options))
     return 0;
 
-  name = XCAR (XCAR (options));
-  if (!CONSP (options))
+  name = XCAR (options);
+  if (!CONSP (name))
     return 0;
+  name = XCAR (name);
 
   if (!NILP (Fstring_equal (name, yes)))
     other = no;
@@ -1197,7 +1202,10 @@ is_simple_dialog (Lisp_Object contents)
   if (!CONSP (options))
     return 0;
 
-  name = XCAR (XCAR (options));
+  name = XCAR (options);
+  if (!CONSP (name))
+    return 0;
+  name = XCAR (name);
   if (NILP (Fstring_equal (name, other)))
     return 0;
 
@@ -1223,6 +1231,7 @@ simple_dialog_show (FRAME_PTR f, Lisp_Object contents, Lisp_Object header)
   if (unicode_message_box)
     {
       WCHAR *text, *title;
+      USE_SAFE_ALLOCA;
 
       if (STRINGP (temp))
         {
@@ -1232,7 +1241,7 @@ simple_dialog_show (FRAME_PTR f, Lisp_Object contents, Lisp_Object header)
              one utf16 word, so we cannot simply use the character
              length of temp.  */
           int utf8_len = strlen (utf8_text);
-          text = alloca ((utf8_len + 1) * sizeof (WCHAR));
+          SAFE_ALLOCA (text, WCHAR *, (utf8_len + 1) * sizeof (WCHAR));
           utf8to16 (utf8_text, utf8_len, text);
         }
       else
@@ -1252,6 +1261,7 @@ simple_dialog_show (FRAME_PTR f, Lisp_Object contents, Lisp_Object header)
         }
 
       answer = unicode_message_box (FRAME_W32_WINDOW (f), text, title, type);
+      SAFE_FREE ();
     }
   else
     {
@@ -1358,6 +1368,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
   char *out_string, *p, *q;
   int return_value;
   size_t nlen, orig_len;
+  USE_SAFE_ALLOCA;
 
   if (menu_separator_name_p (wv->name))
     {
@@ -1373,7 +1384,8 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
 
       if (wv->key != NULL)
         {
-          out_string = alloca (strlen (wv->name) + strlen (wv->key) + 2);
+          SAFE_ALLOCA (out_string, char *,
+                       strlen (wv->name) + strlen (wv->key) + 2);
           strcpy (out_string, wv->name);
           strcat (out_string, "\t");
           strcat (out_string, wv->key);
@@ -1407,7 +1419,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
       if (nlen > orig_len)
         {
           p = out_string;
-          out_string = alloca (nlen + 1);
+          SAFE_ALLOCA (out_string, char *, nlen + 1);
           q = out_string;
           while (*p)
             {
@@ -1467,7 +1479,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
       if (fuFlags & MF_OWNERDRAW)
         utf16_string = local_alloc ((utf8_len + 1) * sizeof (WCHAR));
       else
-        utf16_string = alloca ((utf8_len + 1) * sizeof (WCHAR));
+        SAFE_ALLOCA (utf16_string, WCHAR *, (utf8_len + 1) * sizeof (WCHAR));
 
       utf8to16 (out_string, utf8_len, utf16_string);
       return_value = unicode_append_menu (menu, fuFlags,
@@ -1536,6 +1548,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
                               FALSE, &info);
         }
     }
+  SAFE_FREE ();
   return return_value;
 }
 
diff --git a/src/w32proc.c b/src/w32proc.c
index f7982f36913..28591f90128 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -2067,8 +2067,8 @@ DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage,
 
 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage,
        Sw32_set_console_codepage, 1, 1, 0,
-       doc: /* Make Windows codepage CP be the current codepage setting for Emacs.
-The codepage setting affects keyboard input and display in tty mode.
+       doc: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
+This codepage setting affects keyboard input in tty mode.
 If successful, the new CP is returned, otherwise nil.  */)
   (Lisp_Object cp)
 {
@@ -2095,8 +2095,8 @@ DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage,
 
 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage,
        Sw32_set_console_output_codepage, 1, 1, 0,
-       doc: /* Make Windows codepage CP be the current codepage setting for Emacs.
-The codepage setting affects keyboard input and display in tty mode.
+       doc: /* Make Windows codepage CP be the codepage for Emacs console output.
+This codepage setting affects display in tty mode.
 If successful, the new CP is returned, otherwise nil.  */)
   (Lisp_Object cp)
 {
@@ -2114,7 +2114,7 @@ If successful, the new CP is returned, otherwise nil.  */)
 
 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset,
        Sw32_get_codepage_charset, 1, 1, 0,
-       doc: /* Return charset of codepage CP.
+       doc: /* Return charset ID corresponding to codepage CP.
 Returns nil if the codepage is not valid.  */)
   (Lisp_Object cp)
 {
diff --git a/src/w32term.c b/src/w32term.c
index 8a0e9efc943..18a3753f9e9 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -6411,7 +6411,7 @@ the cursor have no effect.  */);
      from cus-start.el and other places, like "M-x set-variable".  */
   DEFVAR_BOOL ("x-use-underline-position-properties",
                x_use_underline_position_properties,
-     doc: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
+     doc: /* Non-nil means make use of UNDERLINE_POSITION font properties.
 A value of nil means ignore them.  If you encounter fonts with bogus
 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
 to 4.1, set this to nil.  You can also use `underline-minimum-offset'
@@ -6421,7 +6421,7 @@ sizes.  */);
 
   DEFVAR_BOOL ("x-underline-at-descent-line",
                x_underline_at_descent_line,
-     doc: /* *Non-nil means to draw the underline at the same place as the descent line.
+     doc: /* Non-nil means to draw the underline at the same place as the descent line.
 A value of nil means to draw the underline according to the value of the
 variable `x-use-underline-position-properties', which is usually at the
 baseline level.  The default value is nil.  */);
diff --git a/src/window.c b/src/window.c
index af70890d4e4..7fda1b3bc54 100644
--- a/src/window.c
+++ b/src/window.c
@@ -122,9 +122,6 @@ static int window_initialized;
 /* Hook to run when window config changes.  */
 static Lisp_Object Qwindow_configuration_change_hook;
 
-/* If non-nil, run_window_configuration_change_hook does nothing.  */
-Lisp_Object inhibit_window_configuration_change_hook;
-
 /* Used by the function window_scroll_pixel_based */
 static int window_scroll_pixel_based_preserve_x;
 static int window_scroll_pixel_based_preserve_y;
@@ -2569,6 +2566,7 @@ window-start value is reasonable when this function is called.  */)
   Lisp_Object sibling, pwindow, swindow IF_LINT (= Qnil), delta;
   ptrdiff_t startpos IF_LINT (= 0);
   int top IF_LINT (= 0), new_top, resize_failed;
+  Mouse_HLInfo *hlinfo;
 
   w = decode_any_window (window);
   XSETWINDOW (window, w);
@@ -2649,6 +2647,20 @@ window-start value is reasonable when this function is called.  */)
     }
 
   BLOCK_INPUT;
+  hlinfo = MOUSE_HL_INFO (f);
+  /* We are going to free the glyph matrices of WINDOW, and with that
+     we might lose any information about glyph rows that have some of
+     their glyphs highlighted in mouse face.  (These rows are marked
+     with a non-zero mouse_face_p flag.)  If WINDOW indeed has some
+     glyphs highlighted in mouse face, signal to frame's up-to-date
+     hook that mouse highlight was overwritten, so that it will
+     arrange for redisplaying the highlight.  */
+  if (EQ (hlinfo->mouse_face_window, window))
+    {
+      hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
+      hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
+      hlinfo->mouse_face_window = Qnil;
+    }
   free_window_matrices (r);
 
   windows_or_buffers_changed++;
@@ -2898,7 +2910,7 @@ run_window_configuration_change_hook (struct frame *f)
     = Fdefault_value (Qwindow_configuration_change_hook);
   XSETFRAME (frame, f);
 
-  if (NILP (Vrun_hooks) || !NILP (inhibit_window_configuration_change_hook))
+  if (NILP (Vrun_hooks) || !NILP (inhibit_lisp_code))
     return;
 
   /* Use the right buffer.  Matters when running the local hooks.  */
@@ -6529,8 +6541,6 @@ syms_of_window (void)
   window_scroll_preserve_hpos = -1;
   window_scroll_preserve_vpos = -1;
 
-  inhibit_window_configuration_change_hook = Qnil;
-
   DEFVAR_LISP ("temp-buffer-show-function", Vtemp_buffer_show_function,
                doc: /* Non-nil means call as function to display a help buffer.
 The function is called with one argument, the buffer to be displayed.
diff --git a/src/window.h b/src/window.h
index f4a5f52b9a5..ea127ca95a8 100644
--- a/src/window.h
+++ b/src/window.h
@@ -810,10 +810,6 @@ extern Lisp_Object Vmouse_window;
 
 extern Lisp_Object Vmouse_event;
 
-/* If non-nil, run_window_configuration_change_hook does nothing.  */
-
-extern Lisp_Object inhibit_window_configuration_change_hook;
-
 EXFUN (Fnext_window, 3);
 EXFUN (Fselect_window, 2);
 EXFUN (Fset_window_buffer, 3);
diff --git a/src/xdisp.c b/src/xdisp.c
index c3403031650..d051e88e6bb 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -3676,7 +3676,9 @@ handle_face_prop (struct it *it)
              with, so that overlay strings appear in the same face as
              surrounding text, unless they specify their own
              faces.  */
-          base_face_id = underlying_face_id (it);
+          base_face_id = it->string_from_prefix_prop_p
+            ? DEFAULT_FACE_ID
+            : underlying_face_id (it);
         }
 
       new_face_id = face_at_string_position (it->w,
@@ -5584,6 +5586,7 @@ push_it (struct it *it, struct text_pos *position)
   p->font_height = it->font_height;
   p->voffset = it->voffset;
   p->string_from_display_prop_p = it->string_from_display_prop_p;
+  p->string_from_prefix_prop_p = it->string_from_prefix_prop_p;
   p->display_ellipsis_p = 0;
   p->line_wrap = it->line_wrap;
   p->bidi_p = it->bidi_p;
@@ -5693,6 +5696,7 @@ pop_it (struct it *it)
   it->font_height = p->font_height;
   it->voffset = p->voffset;
   it->string_from_display_prop_p = p->string_from_display_prop_p;
+  it->string_from_prefix_prop_p = p->string_from_prefix_prop_p;
   it->line_wrap = p->line_wrap;
   it->bidi_p = p->bidi_p;
   it->paragraph_embedding = p->paragraph_embedding;
@@ -6123,6 +6127,8 @@ reseat_1 (struct it *it, struct text_pos pos, int set_stop_p)
   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
   it->sp = 0;
   it->string_from_display_prop_p = 0;
+  it->string_from_prefix_prop_p = 0;
+
   it->from_disp_prop_p = 0;
   it->face_before_selective_p = 0;
   if (it->bidi_p)
@@ -7368,7 +7374,7 @@ next_element_from_string (struct it *it)
   if (it->current.overlay_string_index >= 0)
     {
       /* Get the next character from an overlay string.  In overlay
-         strings, There is no field width or padding with spaces to
+         strings, there is no field width or padding with spaces to
          do.  */
       if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
         {
@@ -8966,7 +8972,6 @@ 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);
-      xassert (it->current_x == 0 && it->hpos == 0);
       /* Let next call to line_bottom_y calculate real line height */
       last_height = 0;
     }
@@ -8974,7 +8979,20 @@ move_it_by_lines (struct it *it, ptrdiff_t dvpos)
     {
       move_it_to (it, -1, -1, -1, it->vpos + dvpos, MOVE_TO_VPOS);
       if (!IT_POS_VALID_AFTER_MOVE_P (it))
-        move_it_to (it, IT_CHARPOS (*it) + 1, -1, -1, -1, MOVE_TO_POS);
+        {
+          /* Only move to the next buffer position if we ended up in a
+             string from display property, not in an overlay string
+             (before-string or after-string).  That is because the
+             latter don't conceal the underlying buffer position, so
+             we can ask to move the iterator to the exact position we
+             are interested in.  Note that, even if we are already at
+             IT_CHARPOS (*it), the call below is not a no-op, as it
+             will detect that we are at the end of the string, pop the
+             iterator, and compute it->current_x and it->hpos
+             correctly.  */
+          move_it_to (it, IT_CHARPOS (*it) + it->string_from_display_prop_p,
+                      -1, -1, -1, MOVE_TO_POS);
+        }
     }
   else
     {
@@ -13801,16 +13819,31 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
 
             chprop = Fget_char_property (make_number (glyph_pos), Qcursor,
                                          glyph->object);
+            if (!NILP (chprop))
+              {
+                /* If the string came from a `display' text property,
+                   look up the buffer position of that property and
+                   use that position to update bpos_max, as if we
+                   actually saw such a position in one of the row's
+                   glyphs.  This helps with supporting integer values
+                   of `cursor' property on the display string in
+                   situations where most or all of the row's buffer
+                   text is completely covered by display properties,
+                   so that no glyph with valid buffer positions is
+                   ever seen in the row.  */
+                ptrdiff_t prop_pos =
+                  string_buffer_position_lim (glyph->object, pos_before,
+                                              pos_after, 0);
+
+                if (prop_pos >= pos_before)
+                  bpos_max = prop_pos - 1;
+              }
             if (INTEGERP (chprop))
               {
                 bpos_covered = bpos_max + XINT (chprop);
                 /* If the `cursor' property covers buffer positions up
                    to and including point, we should display cursor on
-                   this glyph.  Note that overlays and text properties
-                   with string values stop bidi reordering, so every
-                   buffer position to the left of the string is always
-                   smaller than any position to the right of the
-                   string.  Therefore, if a `cursor' property on one
+                   this glyph.  Note that, if a `cursor' property on one
                    of the string's characters has an integer value, we
                    will break out of the loop below _before_ we get to
                    the position match above.  IOW, integer values of
@@ -13870,6 +13903,15 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
 
             chprop = Fget_char_property (make_number (glyph_pos), Qcursor,
                                          glyph->object);
+            if (!NILP (chprop))
+              {
+                ptrdiff_t prop_pos =
+                  string_buffer_position_lim (glyph->object, pos_before,
+                                              pos_after, 0);
+
+                if (prop_pos >= pos_before)
+                  bpos_max = prop_pos - 1;
+              }
             if (INTEGERP (chprop))
               {
                 bpos_covered = bpos_max + XINT (chprop);
@@ -14007,15 +14049,18 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
                       || pos <= tem)
                     {
                       /* If the string from which this glyph came is
-                         found in the buffer at point, then we've
-                         found the glyph we've been looking for.  If
-                         it comes from an overlay (tem == 0), and it
-                         has the `cursor' property on one of its
+                         found in the buffer at point, or at position
+                         that is closer to point than pos_after, then
+                         we've found the glyph we've been looking for.
+                         If it comes from an overlay (tem == 0), and
+                         it has the `cursor' property on one of its
                          glyphs, record that glyph as a candidate for
                          displaying the cursor.  (As in the
                          unidirectional version, we will display the
                          cursor on the last candidate we find.)  */
-                      if (tem == 0 || tem == pt_old)
+                      if (tem == 0
+                          || tem == pt_old
+                          || (tem - pt_old > 0 && tem < pos_after))
                         {
                           /* The glyphs from this string could have
                              been reordered.  Find the one with the
@@ -14053,7 +14098,8 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
                                 }
                             }
 
-                          if (tem == pt_old)
+                          if (tem == pt_old
+                              || (tem - pt_old > 0 && tem < pos_after))
                             goto compute_x;
                         }
                       if (tem)
@@ -15609,7 +15655,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
              accessible region of the buffer.  This can happen when we
              have just switched to a different buffer and/or changed
              its restriction.  In that case, startp is initialized to
-             the character position 1 (BEG) because we did not yet
+             the character position 1 (BEGV) because we did not yet
              have chance to display the buffer even once.  */
           && BEGV <= CHARPOS (startp) && CHARPOS (startp) <= ZV)
         {
@@ -15618,7 +15664,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
           SAVE_IT (it1, it, it1data);
           start_display (&it1, w, startp);
-          move_it_vertically (&it1, margin);
+          move_it_vertically (&it1, margin * FRAME_LINE_HEIGHT (f));
           margin_pos = IT_CHARPOS (it1);
           RESTORE_IT (&it, &it, it1data);
         }
@@ -16329,7 +16375,10 @@ try_window_reusing_current_matrix (struct window *w)
            ++first_row_to_display)
         {
           if (PT >= MATRIX_ROW_START_CHARPOS (first_row_to_display)
-              && PT < MATRIX_ROW_END_CHARPOS (first_row_to_display))
+              && (PT < MATRIX_ROW_END_CHARPOS (first_row_to_display)
+                  || (PT == MATRIX_ROW_END_CHARPOS (first_row_to_display)
+                      && first_row_to_display->ends_at_zv_p
+                      && pt_row == NULL)))
             pt_row = first_row_to_display;
         }
 
@@ -16421,7 +16470,9 @@ try_window_reusing_current_matrix (struct window *w)
       if (pt_row)
         {
           for (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
-               row < bottom_row && PT >= MATRIX_ROW_END_CHARPOS (row);
+               row < bottom_row
+                 && PT >= MATRIX_ROW_END_CHARPOS (row)
+                 && !row->ends_at_zv_p;
                row++)
             {
               w->cursor.vpos++;
@@ -18168,8 +18219,10 @@ append_space_for_newline (struct it *it, int default_face_p)
           it->c = it->char_to_display = ' ';
           it->len = 1;
 
+          /* If the default face was remapped, be sure to use the
+             remapped face for the appended newline. */
           if (default_face_p)
-            it->face_id = DEFAULT_FACE_ID;
+            it->face_id = lookup_basic_face (it->f, DEFAULT_FACE_ID);
           else if (it->face_before_selective_p)
             it->face_id = it->saved_face_id;
           face = FACE_FROM_ID (it->f, it->face_id);
@@ -18205,7 +18258,7 @@ append_space_for_newline (struct it *it, int default_face_p)
 static void
 extend_face_to_end_of_line (struct it *it)
 {
-  struct face *face;
+  struct face *face, *default_face;
   struct frame *f = it->f;
 
   /* If line is already filled, do nothing.  Non window-system frames
@@ -18219,6 +18272,9 @@ extend_face_to_end_of_line (struct it *it)
          && !it->glyph_row->continued_p))
     return;
 
+  /* The default face, possibly remapped. */
+  default_face = FACE_FROM_ID (f, lookup_basic_face (f, DEFAULT_FACE_ID));
+
   /* Face extension extends the background and box of IT->face_id
      to the end of the line.  If the background equals the background
      of the frame, we don't have to do anything.  */
@@ -18256,7 +18312,7 @@ extend_face_to_end_of_line (struct it *it)
       if (it->glyph_row->used[TEXT_AREA] == 0)
         {
           it->glyph_row->glyphs[TEXT_AREA][0] = space_glyph;
-          it->glyph_row->glyphs[TEXT_AREA][0].face_id = it->face_id;
+          it->glyph_row->glyphs[TEXT_AREA][0].face_id = face->id;
           it->glyph_row->used[TEXT_AREA] = 1;
         }
 #ifdef HAVE_WINDOW_SYSTEM
@@ -18292,7 +18348,7 @@ extend_face_to_end_of_line (struct it *it)
                  face, to avoid painting the rest of the window with
                  the region face, if the region ends at ZV.  */
               if (it->glyph_row->ends_at_zv_p)
-                it->face_id = DEFAULT_FACE_ID;
+                it->face_id = default_face->id;
               else
                 it->face_id = face->id;
               append_stretch_glyph (it, make_number (0), stretch_width,
@@ -18325,7 +18381,7 @@ extend_face_to_end_of_line (struct it *it)
          avoid painting the rest of the window with the region face,
          if the region ends at ZV.  */
       if (it->glyph_row->ends_at_zv_p)
-        it->face_id = DEFAULT_FACE_ID;
+        it->face_id = default_face->id;
       else
         it->face_id = face->id;
 
@@ -18458,9 +18514,11 @@ cursor_row_p (struct glyph_row *row)
       /* Suppose the row ends on a string.
          Unless the row is continued, that means it ends on a newline
          in the string.  If it's anything other than a display string
-         (e.g. a before-string from an overlay), we don't want the
+         (e.g., a before-string from an overlay), we don't want the
          cursor there.  (This heuristic seems to give the optimal
-         behavior for the various types of multi-line strings.)  */
+         behavior for the various types of multi-line strings.)
+         One exception: if the string has `cursor' property on one of
+         its characters, we _do_ want the cursor there.  */
       if (CHARPOS (row->end.string_pos) >= 0)
         {
           if (row->continued_p)
@@ -18482,6 +18540,25 @@ cursor_row_p (struct glyph_row *row)
                     result =
                       (!NILP (prop)
                        && display_prop_string_p (prop, glyph->object));
+                    /* If there's a `cursor' property on one of the
+                       string's characters, this row is a cursor row,
+                       even though this is not a display string.  */
+                    if (!result)
+                      {
+                        Lisp_Object s = glyph->object;
+
+                        for ( ; glyph >= beg && EQ (glyph->object, s); --glyph)
+                          {
+                            ptrdiff_t gpos = glyph->charpos;
+
+                            if (!NILP (Fget_char_property (make_number (gpos),
+                                                           Qcursor, s)))
+                              {
+                                result = 1;
+                                break;
+                              }
+                          }
+                      }
                     break;
                   }
             }
@@ -18520,7 +18597,7 @@ cursor_row_p (struct glyph_row *row)
    `line-prefix' and `wrap-prefix' properties.  */
 
 static int
-push_display_prop (struct it *it, Lisp_Object prop)
+push_prefix_prop (struct it *it, Lisp_Object prop)
 {
   struct text_pos pos =
     STRINGP (it->string) ? it->current.string_pos : it->current.pos;
@@ -18544,6 +18621,7 @@ push_display_prop (struct it *it, Lisp_Object prop)
         }
 
       it->string = prop;
+      it->string_from_prefix_prop_p = 1;
       it->multibyte_p = STRING_MULTIBYTE (it->string);
       it->current.overlay_string_index = -1;
       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
@@ -18630,7 +18708,7 @@ handle_line_prefix (struct it *it)
       if (NILP (prefix))
         prefix = Vline_prefix;
     }
-  if (! NILP (prefix) && push_display_prop (it, prefix))
+  if (! NILP (prefix) && push_prefix_prop (it, prefix))
     {
       /* If the prefix is wider than the window, and we try to wrap
          it, it would acquire its own wrap prefix, and so on till the
@@ -18967,8 +19045,13 @@ display_line (struct it *it)
           /* A row that displays right-to-left text must always have
              its last face extended all the way to the end of line,
              even if this row ends in ZV, because we still write to
-             the screen left to right.  */
-          if (row->reversed_p)
+             the screen left to right.  We also need to extend the
+             last face if the default face is remapped to some
+             different face, otherwise the functions that clear
+             portions of the screen will clear with the default face's
+             background color.  */
+          if (row->reversed_p
+              || lookup_basic_face (it->f, DEFAULT_FACE_ID) != DEFAULT_FACE_ID)
             extend_face_to_end_of_line (it);
           break;
         }
@@ -23987,7 +24070,7 @@ produce_glyphless_glyph (struct it *it, int for_no_font, Lisp_Object acronym)
           sprintf (buf, "%0*X", it->c < 0x10000 ? 4 : 6, it->c);
           str = buf;
         }
-      for (len = 0; str[len] && ASCII_BYTE_P (str[len]); len++)
+      for (len = 0; str[len] && ASCII_BYTE_P (str[len]) && len < 6; len++)
         code[len] = font->driver->encode_char (font, str[len]);
       upper_len = (len + 1) / 2;
       font->driver->text_extents (font, code, upper_len,
@@ -28208,14 +28291,14 @@ syms_of_xdisp (void)
 
 #ifdef HAVE_WINDOW_SYSTEM
   DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p,
-    doc: /* *Non-nil means draw block cursor as wide as the glyph under it.
+    doc: /* Non-nil means draw block cursor as wide as the glyph under it.
 For example, if a block cursor is over a tab, it will be drawn as
 wide as that tab on the display.  */);
   x_stretch_cursor_p = 0;
 #endif
 
   DEFVAR_LISP ("show-trailing-whitespace", Vshow_trailing_whitespace,
-    doc: /* *Non-nil means highlight trailing whitespace.
+    doc: /* Non-nil means highlight trailing whitespace.
 The face used for trailing whitespace is `trailing-whitespace'.  */);
   Vshow_trailing_whitespace = Qnil;
 
@@ -28235,7 +28318,7 @@ A value of nil means no special handling of these characters.  */);
   Vnobreak_char_display = Qt;
 
   DEFVAR_LISP ("void-text-area-pointer", Vvoid_text_area_pointer,
-    doc: /* *The pointer shape to show in void text areas.
+    doc: /* The pointer shape to show in void text areas.
 A value of nil means to show the text pointer.  Other options are `arrow',
 `text', `hand', `vdrag', `hdrag', `modeline', and `hourglass'.  */);
   Vvoid_text_area_pointer = Qarrow;
@@ -28268,14 +28351,14 @@ where to display overlay arrows.  */);
     = Fcons (intern_c_string ("overlay-arrow-position"), Qnil);
 
   DEFVAR_INT ("scroll-step", emacs_scroll_step,
-    doc: /* *The number of lines to try scrolling a window by when point moves out.
+    doc: /* The number of lines to try scrolling a window by when point moves out.
 If that fails to bring point back on frame, point is centered instead.
 If this is zero, point is always centered after it moves off frame.
 If you want scrolling to always be a line at a time, you should set
 `scroll-conservatively' to a large value rather than set this to 1.  */);
 
   DEFVAR_INT ("scroll-conservatively", scroll_conservatively,
-    doc: /* *Scroll up to this many lines, to bring point back on screen.
+    doc: /* Scroll up to this many lines, to bring point back on screen.
 If point moves off-screen, redisplay will scroll by up to
 `scroll-conservatively' lines in order to bring point just barely
 onto the screen again.  If that cannot be done, then redisplay
@@ -28289,7 +28372,7 @@ A value of zero means always recenter point if it moves off screen.  */);
   scroll_conservatively = 0;
 
   DEFVAR_INT ("scroll-margin", scroll_margin,
-    doc: /* *Number of lines of margin at the top and bottom of a window.
+    doc: /* Number of lines of margin at the top and bottom of a window.
 Recenter the window whenever point gets within this many lines
 of the top or bottom of the window.  */);
   scroll_margin = 0;
@@ -28325,20 +28408,20 @@ Any other value means to use the appropriate face, `mode-line',
   mode_line_inverse_video = 1;
 
   DEFVAR_LISP ("line-number-display-limit", Vline_number_display_limit,
-    doc: /* *Maximum buffer size for which line number should be displayed.
+    doc: /* Maximum buffer size for which line number should be displayed.
 If the buffer is bigger than this, the line number does not appear
 in the mode line.  A value of nil means no limit.  */);
   Vline_number_display_limit = Qnil;
 
   DEFVAR_INT ("line-number-display-limit-width",
               line_number_display_limit_width,
-    doc: /* *Maximum line width (in characters) for line number display.
+    doc: /* Maximum line width (in characters) for line number display.
 If the average length of the lines near point is bigger than this, then the
 line number may be omitted from the mode line.  */);
   line_number_display_limit_width = 200;
 
   DEFVAR_BOOL ("highlight-nonselected-windows", highlight_nonselected_windows,
-    doc: /* *Non-nil means highlight region even in nonselected windows.  */);
+    doc: /* Non-nil means highlight region even in nonselected windows.  */);
   highlight_nonselected_windows = 0;
 
   DEFVAR_BOOL ("multiple-frames", multiple_frames,
@@ -28410,7 +28493,7 @@ See `set-window-redisplay-end-trigger'.  */);
   Vredisplay_end_trigger_functions = Qnil;
 
   DEFVAR_LISP ("mouse-autoselect-window", Vmouse_autoselect_window,
-     doc: /* *Non-nil means autoselect window with mouse pointer.
+     doc: /* Non-nil means autoselect window with mouse pointer.
 If nil, do not autoselect windows.
 A positive number means delay autoselection by that many seconds: a
 window is autoselected only after the mouse has remained in that
@@ -28430,7 +28513,7 @@ When customizing this variable make sure that the actual value of
   Vmouse_autoselect_window = Qnil;
 
   DEFVAR_LISP ("auto-resize-tool-bars", Vauto_resize_tool_bars,
-    doc: /* *Non-nil means automatically resize tool-bars.
+    doc: /* Non-nil means automatically resize tool-bars.
 This dynamically changes the tool-bar's height to the minimum height
 that is needed to make all tool-bar items visible.
 If value is `grow-only', the tool-bar's height is only increased
@@ -28438,15 +28521,15 @@ automatically; to decrease the tool-bar height, use \\[recenter].  */);
   Vauto_resize_tool_bars = Qt;
 
   DEFVAR_BOOL ("auto-raise-tool-bar-buttons", auto_raise_tool_bar_buttons_p,
-    doc: /* *Non-nil means raise tool-bar buttons when the mouse moves over them.  */);
+    doc: /* Non-nil means raise tool-bar buttons when the mouse moves over them.  */);
   auto_raise_tool_bar_buttons_p = 1;
 
   DEFVAR_BOOL ("make-cursor-line-fully-visible", make_cursor_line_fully_visible_p,
-    doc: /* *Non-nil means to scroll (recenter) cursor line if it is not fully visible.  */);
+    doc: /* Non-nil means to scroll (recenter) cursor line if it is not fully visible.  */);
   make_cursor_line_fully_visible_p = 1;
 
   DEFVAR_LISP ("tool-bar-border", Vtool_bar_border,
-    doc: /* *Border below tool-bar in pixels.
+    doc: /* Border below tool-bar in pixels.
 If an integer, use it as the height of the border.
 If it is one of `internal-border-width' or `border-width', use the
 value of the corresponding frame parameter.
@@ -28454,7 +28537,7 @@ Otherwise, no border is added below the tool-bar.  */);
   Vtool_bar_border = Qinternal_border_width;
 
   DEFVAR_LISP ("tool-bar-button-margin", Vtool_bar_button_margin,
-    doc: /* *Margin around tool-bar buttons in pixels.
+    doc: /* Margin around tool-bar buttons in pixels.
 If an integer, use that for both horizontal and vertical margins.
 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
 HORZ specifying the horizontal margin, and VERT specifying the
@@ -28462,7 +28545,7 @@ vertical margin.  */);
   Vtool_bar_button_margin = make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN);
 
   DEFVAR_INT ("tool-bar-button-relief", tool_bar_button_relief,
-    doc: /* *Relief thickness of tool-bar buttons.  */);
+    doc: /* Relief thickness of tool-bar buttons.  */);
   tool_bar_button_relief = DEFAULT_TOOL_BAR_BUTTON_RELIEF;
 
   DEFVAR_LISP ("tool-bar-style", Vtool_bar_style,
@@ -28477,7 +28560,7 @@ It can be one of
   Vtool_bar_style = Qnil;
 
   DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size,
-    doc: /* *Maximum number of characters a label can have to be shown.
+    doc: /* Maximum number of characters a label can have to be shown.
 The tool bar style must also show labels for this to have any effect, see
 `tool-bar-style'.  */);
   tool_bar_max_label_size = DEFAULT_TOOL_BAR_LABEL_SIZE;
@@ -28492,7 +28575,7 @@ fontified regions the property `fontified'.  */);
 
   DEFVAR_BOOL ("unibyte-display-via-language-environment",
                unibyte_display_via_language_environment,
-    doc: /* *Non-nil means display unibyte text according to language environment.
+    doc: /* Non-nil means display unibyte text according to language environment.
 Specifically, this means that raw bytes in the range 160-255 decimal
 are displayed by converting them to the equivalent multibyte characters
 according to the current language environment.  As a result, they are
@@ -28503,7 +28586,7 @@ but does not change the fact they are interpreted as raw bytes.  */);
   unibyte_display_via_language_environment = 0;
 
   DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height,
-    doc: /* *Maximum height for resizing mini-windows (the minibuffer and the echo area).
+    doc: /* Maximum height for resizing mini-windows (the minibuffer and the echo area).
 If a float, it specifies a fraction of the mini-window frame's height.
 If an integer, it specifies a number of lines.  */);
   Vmax_mini_window_height = make_float (0.25);
@@ -28537,12 +28620,12 @@ point visible.  */);
   DEFSYM (Qauto_hscroll_mode, "auto-hscroll-mode");
 
   DEFVAR_INT ("hscroll-margin", hscroll_margin,
-    doc: /* *How many columns away from the window edge point is allowed to get
+    doc: /* How many columns away from the window edge point is allowed to get
 before automatic hscrolling will horizontally scroll the window.  */);
   hscroll_margin = 5;
 
   DEFVAR_LISP ("hscroll-step", Vhscroll_step,
-    doc: /* *How many columns to scroll the window when point gets too close to the edge.
+    doc: /* How many columns to scroll the window when point gets too close to the edge.
 When point is less than `hscroll-margin' columns from the window
 edge, automatic hscrolling will scroll the window by the amount of columns
 determined by this variable.  If its value is a positive integer, scroll that
@@ -28629,7 +28712,7 @@ To add a prefix to continuation lines, use `wrap-prefix'.  */);
 #endif /* GLYPH_DEBUG */
 
   DEFVAR_INT ("overline-margin", overline_margin,
-               doc: /* *Space between overline and text, in pixels.
+               doc: /* Space between overline and text, in pixels.
 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
 margin to the character height.  */);
   overline_margin = 2;
@@ -28650,7 +28733,7 @@ cursor shapes.  */);
   display_hourglass_p = 1;
 
   DEFVAR_LISP ("hourglass-delay", Vhourglass_delay,
-               doc: /* *Seconds to wait before displaying an hourglass pointer when Emacs is busy.  */);
+               doc: /* Seconds to wait before displaying an hourglass pointer when Emacs is busy.  */);
   Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
 
   hourglass_atimer = NULL;
diff --git a/src/xfaces.c b/src/xfaces.c
index 7c3bc8d2749..84a47cf6ccf 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -6562,7 +6562,7 @@ syms_of_xfaces (void)
 #endif
 
   DEFVAR_LISP ("font-list-limit", Vfont_list_limit,
-               doc: /* *Limit for font matching.
+               doc: /* Limit for font matching.
 If an integer > 0, font matching functions won't load more than
 that number of fonts when searching for a matching font.  */);
   Vfont_list_limit = make_number (DEFAULT_FONT_LIST_LIMIT);
@@ -6572,7 +6572,7 @@ that number of fonts when searching for a matching font.  */);
   Vface_new_frame_defaults = Qnil;
 
   DEFVAR_LISP ("face-default-stipple", Vface_default_stipple,
-    doc: /* *Default stipple pattern used on monochrome displays.
+    doc: /* Default stipple pattern used on monochrome displays.
 This stipple pattern is used on monochrome displays
 instead of shades of gray for a face background color.
 See `set-face-stipple' for possible values for this variable.  */);
@@ -6603,20 +6603,22 @@ ignore.  */);
                doc: /* Alist of face remappings.
 Each element is of the form:
 
-   (FACE REPLACEMENT...),
+   (FACE . REPLACEMENT),
 
-which causes display of the face FACE to use REPLACEMENT... instead.
-REPLACEMENT... is interpreted the same way as the value of a `face'
-text property: it may be (1) A face name, (2) A list of face names,
-(3) A property-list of face attribute/value pairs, or (4) A list of
-face names or lists containing face attribute/value pairs.
+which causes display of the face FACE to use REPLACEMENT instead.
+REPLACEMENT is a face specification, i.e. one of the following:
 
-Multiple entries in REPLACEMENT... are merged together to form the final
-result, with faces or attributes earlier in the list taking precedence
-over those that are later.
+  (1) a face name
+  (2) a property list of attribute/value pairs, or
+  (3) a list in which each element has the form of (1) or (2).
 
-Face-name remapping cycles are suppressed; recursive references use the
-underlying face instead of the remapped face.  So a remapping of the form:
+List values for REPLACEMENT are merged to form the final face
+specification, with earlier entries taking precedence, in the same as
+as in the `face' text property.
+
+Face-name remapping cycles are suppressed; recursive references use
+the underlying face instead of the remapped face.  So a remapping of
+the form:
 
    (FACE EXTRA-FACE... FACE)
 
@@ -6624,13 +6626,13 @@ or:
 
    (FACE (FACE-ATTR VAL ...) FACE)
 
-will cause EXTRA-FACE... or (FACE-ATTR VAL ...) to be _merged_ with the
-existing definition of FACE.  Note that for the default face, this isn't
-necessary, as every face inherits from the default face.
+causes EXTRA-FACE... or (FACE-ATTR VAL ...) to be _merged_ with the
+existing definition of FACE.  Note that this isn't necessary for the
+default face, since every face inherits from the default face.
 
-Making this variable buffer-local is a good way to allow buffer-specific
-face definitions.  For instance, the mode my-mode could define a face
-`my-mode-default', and then in the mode setup function, do:
+If this variable is made buffer-local, the face remapping takes effect
+only in that buffer.  For instance, the mode my-mode could define a
+face `my-mode-default', and then in the mode setup function, do:
 
    (set (make-local-variable 'face-remapping-alist)
         '((default my-mode-default)))).
diff --git a/src/xfns.c b/src/xfns.c
index 4cf4a059a67..2d2ab46fb36 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -2952,7 +2952,7 @@ unwind_create_frame (Lisp_Object frame)
 static Lisp_Object
 unwind_create_frame_1 (Lisp_Object val)
 {
-  inhibit_window_configuration_change_hook = val;
+  inhibit_lisp_code = val;
   return Qnil;
 }
 
@@ -3337,9 +3337,8 @@ This function is an internal primitive--use `make-frame' instead.  */)
      Vframe_list.  */
   {
     ptrdiff_t count2 = SPECPDL_INDEX ();
-    record_unwind_protect (unwind_create_frame_1,
-                           inhibit_window_configuration_change_hook);
-    inhibit_window_configuration_change_hook = Qt;
+    record_unwind_protect (unwind_create_frame_1, inhibit_lisp_code);
+    inhibit_lisp_code = Qt;
 
     x_default_parameter (f, parms, Qmenu_bar_lines,
                          NILP (Vmenu_bar_mode)
@@ -5919,32 +5918,32 @@ Chinese, Japanese, and Korean.  */);
 
 /* This is not ifdef:ed, so other builds than GTK can customize it.  */
   DEFVAR_BOOL ("x-gtk-use-old-file-dialog", x_gtk_use_old_file_dialog,
-    doc: /* *Non-nil means prompt with the old GTK file selection dialog.
+    doc: /* Non-nil means prompt with the old GTK file selection dialog.
 If nil or if the file selection dialog is not available, the new GTK file
 chooser is used instead.  To turn off all file dialogs set the
 variable `use-file-dialog'.  */);
   x_gtk_use_old_file_dialog = 0;
 
   DEFVAR_BOOL ("x-gtk-show-hidden-files", x_gtk_show_hidden_files,
-    doc: /* *If non-nil, the GTK file chooser will by default show hidden files.
+    doc: /* If non-nil, the GTK file chooser will by default show hidden files.
 Note that this is just the default, there is a toggle button on the file
 chooser to show or not show hidden files on a case by case basis.  */);
   x_gtk_show_hidden_files = 0;
 
   DEFVAR_BOOL ("x-gtk-file-dialog-help-text", x_gtk_file_dialog_help_text,
-    doc: /* *If non-nil, the GTK file chooser will show additional help text.
+    doc: /* If non-nil, the GTK file chooser will show additional help text.
 If more space for files in the file chooser dialog is wanted, set this to nil
 to turn the additional text off.  */);
   x_gtk_file_dialog_help_text = 1;
 
   DEFVAR_BOOL ("x-gtk-whole-detached-tool-bar", x_gtk_whole_detached_tool_bar,
-    doc: /* *If non-nil, a detached tool bar is shown in full.
+    doc: /* If non-nil, a detached tool bar is shown in full.
 The default is to just show an arrow and pressing on that arrow shows
 the tool bar buttons.  */);
   x_gtk_whole_detached_tool_bar = 0;
 
   DEFVAR_BOOL ("x-gtk-use-system-tooltips", x_gtk_use_system_tooltips,
-    doc: /* *If non-nil with a Gtk+ built Emacs, the Gtk+ tooltip is used.
+    doc: /* If non-nil with a Gtk+ built Emacs, the Gtk+ tooltip is used.
 Otherwise use Emacs own tooltip implementation.
 When using Gtk+ tooltips, the tooltip face is not used.  */);
   x_gtk_use_system_tooltips = 1;
diff --git a/src/xml.c b/src/xml.c
index 8c88226b505..e462a1adf57 100644
--- a/src/xml.c
+++ b/src/xml.c
@@ -28,6 +28,97 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "buffer.h"
 
+
+static Lisp_Object Qlibxml2_dll;
+
+#ifdef WINDOWSNT
+
+#include <windows.h>
+#include "w32.h"
+
+/* Macro for defining functions that will be loaded from the libxml2 DLL.  */
+#define DEF_XML2_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
+
+/* Macro for loading libxml2 functions from the library.  */
+#define LOAD_XML2_FN(lib,func) {                                        \
+    fn_##func = (void *) GetProcAddress (lib, #func);                   \
+    if (!fn_##func) goto bad_library;                                   \
+  }
+
+DEF_XML2_FN (htmlDocPtr, htmlReadMemory,
+             (const char *, int, const char *, const char *, int));
+DEF_XML2_FN (xmlDocPtr, xmlReadMemory,
+             (const char *, int, const char *, const char *, int));
+DEF_XML2_FN (xmlNodePtr, xmlDocGetRootElement, (xmlDocPtr));
+DEF_XML2_FN (void, xmlFreeDoc, (xmlDocPtr));
+DEF_XML2_FN (void, xmlCleanupParser, (void));
+DEF_XML2_FN (void, xmlCheckVersion, (int));
+
+static int
+libxml2_loaded_p (void)
+{
+  Lisp_Object found = Fassq (Qlibxml2_dll, Vlibrary_cache);
+
+  if (CONSP (found))
+    return EQ (XCDR (found), Qt) ? 1 : 0;
+  return 0;
+}
+
+#else  /* !WINDOWSNT */
+
+#define fn_htmlReadMemory       htmlReadMemory
+#define fn_xmlReadMemory        xmlReadMemory
+#define fn_xmlDocGetRootElement xmlDocGetRootElement
+#define fn_xmlFreeDoc           xmlFreeDoc
+#define fn_xmlCleanupParser     xmlCleanupParser
+#define fn_xmlCheckVersion      xmlCheckVersion
+
+static inline int
+libxml2_loaded_p (void)
+{
+  return 1;
+}
+
+#endif  /* !WINDOWSNT */
+
+static int
+init_libxml2_functions (Lisp_Object libraries)
+{
+#ifdef WINDOWSNT
+  if (libxml2_loaded_p ())
+    return 1;
+  else
+    {
+      HMODULE library;
+
+      if (!(library = w32_delayed_load (libraries, Qlibxml2_dll)))
+        {
+          message ("%s", "libxml2 library not found");
+          return 0;
+        }
+
+      /* LOAD_XML2_FN jumps to bad_library if it fails to find the
+         named function.  */
+      LOAD_XML2_FN (library, htmlReadMemory);
+      LOAD_XML2_FN (library, xmlReadMemory);
+      LOAD_XML2_FN (library, xmlDocGetRootElement);
+      LOAD_XML2_FN (library, xmlFreeDoc);
+      LOAD_XML2_FN (library, xmlCleanupParser);
+      LOAD_XML2_FN (library, xmlCheckVersion);
+
+      Vlibrary_cache = Fcons (Fcons (Qlibxml2_dll, Qt), Vlibrary_cache);
+      return 1;
+    }
+
+ bad_library:
+  Vlibrary_cache = Fcons (Fcons (Qlibxml2_dll, Qnil), Vlibrary_cache);
+
+  return 0;
+#else  /* !WINDOWSNT */
+  return 1;
+#endif  /* !WINDOWSNT */
+}
+
 static Lisp_Object
 make_dom (xmlNode *node)
 {
@@ -92,7 +183,7 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
   ptrdiff_t bytes;
   ptrdiff_t istart, iend;
 
-  LIBXML_TEST_VERSION;
+  fn_xmlCheckVersion (LIBXML_VERSION);
 
   validate_region (&start, &end);
 
@@ -111,16 +202,16 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
   bytes = CHAR_TO_BYTE (iend) - CHAR_TO_BYTE (istart);
 
   if (htmlp)
-    doc = htmlReadMemory ((char *) BYTE_POS_ADDR (CHAR_TO_BYTE (istart)),
-                          bytes, burl, "utf-8",
-                          HTML_PARSE_RECOVER|HTML_PARSE_NONET|
-                          HTML_PARSE_NOWARNING|HTML_PARSE_NOERROR|
-                          HTML_PARSE_NOBLANKS);
+    doc = fn_htmlReadMemory ((char *) BYTE_POS_ADDR (CHAR_TO_BYTE (istart)),
+                             bytes, burl, "utf-8",
+                             HTML_PARSE_RECOVER|HTML_PARSE_NONET|
+                             HTML_PARSE_NOWARNING|HTML_PARSE_NOERROR|
+                             HTML_PARSE_NOBLANKS);
   else
-    doc = xmlReadMemory ((char *) BYTE_POS_ADDR (CHAR_TO_BYTE (istart)),
-                         bytes, burl, "utf-8",
-                         XML_PARSE_NONET|XML_PARSE_NOWARNING|
-                         XML_PARSE_NOBLANKS |XML_PARSE_NOERROR);
+    doc = fn_xmlReadMemory ((char *) BYTE_POS_ADDR (CHAR_TO_BYTE (istart)),
+                            bytes, burl, "utf-8",
+                            XML_PARSE_NONET|XML_PARSE_NOWARNING|
+                            XML_PARSE_NOBLANKS |XML_PARSE_NOERROR);
 
   if (doc != NULL)
     {
@@ -139,19 +230,26 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
       if (NILP (result)) {
         /* The document isn't just comments, so get the tree the
            proper way. */
-        xmlNode *node = xmlDocGetRootElement (doc);
+        xmlNode *node = fn_xmlDocGetRootElement (doc);
         if (node != NULL)
           result = make_dom (node);
       } else
         result = Fcons (intern ("top"),
                         Fcons (Qnil, Fnreverse (Fcons (r, result))));
 
-      xmlFreeDoc (doc);
+      fn_xmlFreeDoc (doc);
     }
 
   return result;
 }
 
+void
+xml_cleanup_parser (void)
+{
+  if (libxml2_loaded_p ())
+    fn_xmlCleanupParser ();
+}
+
 DEFUN ("libxml-parse-html-region", Flibxml_parse_html_region,
        Slibxml_parse_html_region,
        2, 3, 0,
@@ -159,7 +257,9 @@ DEFUN ("libxml-parse-html-region", Flibxml_parse_html_region,
 If BASE-URL is non-nil, it is used to expand relative URLs.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object base_url)
 {
-  return parse_region (start, end, base_url, 1);
+  if (init_libxml2_functions (Vdynamic_library_alist))
+    return parse_region (start, end, base_url, 1);
+  return Qnil;
 }
 
 DEFUN ("libxml-parse-xml-region", Flibxml_parse_xml_region,
@@ -169,7 +269,9 @@ DEFUN ("libxml-parse-xml-region", Flibxml_parse_xml_region,
 If BASE-URL is non-nil, it is used to expand relative URLs.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object base_url)
 {
-  return parse_region (start, end, base_url, 0);
+  if (init_libxml2_functions (Vdynamic_library_alist))
+    return parse_region (start, end, base_url, 0);
+  return Qnil;
 }
 
 
@@ -181,6 +283,8 @@ syms_of_xml (void)
 {
   defsubr (&Slibxml_parse_html_region);
   defsubr (&Slibxml_parse_xml_region);
+
+  DEFSYM (Qlibxml2_dll, "libxml2");
 }
 
 #endif /* HAVE_LIBXML2 */
diff --git a/src/xsettings.c b/src/xsettings.c
index 066c6e795e9..69ef22f55d7 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -1024,7 +1024,7 @@ syms_of_xsettings (void)
   defsubr (&Sfont_get_system_normal_font);
 
   DEFVAR_BOOL ("font-use-system-font", use_system_font,
-    doc: /* *Non-nil means to apply the system defined font dynamically.
+    doc: /* Non-nil means to apply the system defined font dynamically.
 When this is non-nil and the system defined fixed width font changes, we
 update frames dynamically.
 If this variable is nil, Emacs ignores system font changes.  */);
diff --git a/src/xterm.c b/src/xterm.c
index 88cd0bf4091..1a5bc913f60 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -7099,7 +7099,8 @@ x_dispatch_event (XEvent *event, Display *display)
 
 
 /* Read events coming from the X server.
-   This routine is called by the SIGIO handler.
+   This routine is called by the SIGIO handler only if SYNC_INPUT is
+   not defined.
    We return as soon as there are no more events to be read.
 
    We return the number of characters stored into the buffer,
@@ -7133,7 +7134,9 @@ XTread_socket (struct terminal *terminal, int expected, struct input_event *hold
   /* So people can tell when we have read the available input.  */
   input_signal_count++;
 
+#ifndef SYNC_INPUT
   ++handling_signal;
+#endif
 
   /* For debugging, this gives a way to fake an I/O error.  */
   if (terminal->display_info.x == XTread_socket_fake_io_error)
@@ -7223,7 +7226,9 @@ XTread_socket (struct terminal *terminal, int expected, struct input_event *hold
       pending_autoraise_frame = 0;
     }
 
+#ifndef SYNC_INPUT
   --handling_signal;
+#endif
   UNBLOCK_INPUT;
 
   return count;
@@ -10825,7 +10830,7 @@ syms_of_xterm (void)
 
   DEFVAR_BOOL ("x-use-underline-position-properties",
                x_use_underline_position_properties,
-     doc: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
+     doc: /* Non-nil means make use of UNDERLINE_POSITION font properties.
 A value of nil means ignore them.  If you encounter fonts with bogus
 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
 to 4.1, set this to nil.  You can also use `underline-minimum-offset'
@@ -10835,7 +10840,7 @@ sizes.  */);
 
   DEFVAR_BOOL ("x-underline-at-descent-line",
                x_underline_at_descent_line,
-     doc: /* *Non-nil means to draw the underline at the same place as the descent line.
+     doc: /* Non-nil means to draw the underline at the same place as the descent line.
 A value of nil means to draw the underline according to the value of the
 variable `x-use-underline-position-properties', which is usually at the
 baseline level.  The default value is nil.  */);