merge from trunk

38 files changed, 833 insertions, 649 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index c0c85c15ee9..115b8d42915 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,9 +1,249 @@
+2013-01-15  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * alloc.c (free_save_value): Now static.
+
+2013-01-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * keymap.c (map_keymap_internal): Use format_save_value.
+        (map_keymap_char_table_item): Adjust accordingly.
+        * fileio.c (non_regular_fd, non_regular_inserted)
+        (non_regular_nbytes): Remove.
+        (Finsert_file_contents): Convert trytry to ptrdiff_t.  Use
+        format_save_value to pass parameters to read_non_regular.
+        (read_non_regular): Use XSAVE_ macros to extract parameters.
+        Adjust comment.
+        * xmenu.c (xmenu_show) [!USE_X_TOOLKIT && !USE_GTK]: Use
+        format_save_value.
+        (pop_down_menu) [!USE_X_TOOLKIT && !USE_GTK]: Adjust user.
+
+2013-01-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (XSAVE_POINTER, XSAVE_INTEGER): Change to allow
+        extraction from any Lisp_Save_Value slot.  Add type checking.
+        * alloc.c, dired.c, editfns.c, fileio.c, ftfont.c, gtkutil.c:
+        * keymap.c, lread.c, nsterm.h, nsmenu.c, xfns.c, xmenu.c:
+        * xselect.c: All users changed.
+
+2013-01-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Some convenient bits to deal with Lisp_Save_Values.
+        * lisp.h (XSAVE_OBJECT): New macro to extract saved objects.
+        (allocate_misc): Remove prototype.
+        (format_save_value): New prototype.
+        * alloc.c (allocate_misc): Revert back to static.
+        (format_save_value): New function to build Lisp_Save_Value
+        object with the specified internal structure.
+        (make_save_value): Reimplement using format_save_value.
+        * editfns.c (save_excursion_save): Use format_save_value.
+        (save_excursion_restore): Use XSAVE_OBJECT.
+
+2013-01-14  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Avoid needless casts with XSAVE_POINTER.
+        * alloc.c (mark_object) [GC_MARK_STACK]:
+        * dired.c (directory_files_internal_unwind):
+        * fileio.c (do_auto_save_unwind):
+        * gtkutil.c (pop_down_dialog):
+        * keymap.c (map_keymap_char_table_item):
+        * lread.c (load_unwind):
+        * nsmenu.m (pop_down_menu):
+        * print.c (print_object) [GC_MARK_STACK]:
+        * xfns.c (clean_up_file_dialog):
+        * xmenu.c (cleanup_widget_value_tree):
+        Omit casts between XSAVE_POINTER and a pointer type.
+
+2013-01-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix compilation with GC_MARK_STACK == GC_USE_GCPROS_AS_BEFORE.
+        * eval.c (eval_sub): Protect `form' from being GCed before its
+        car and cdr becomes protected with the backtrace entry.
+
+2013-01-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Make Lisp_Save_Value more versatile storage for up to four objects.
+        * lisp.h (toplevel): Enumeration to describe types of saved objects.
+        (struct Lisp_Save_Value): New layout.  Adjust comments.
+        (XSAVE_POINTER): New macro.
+        (XSAVE_INTEGER): Likewise.
+        (allocate_misc): Add prototype.
+        (free_misc): Likewise.
+        * alloc.c (allocate_misc): Now global.
+        (free_misc): Likewise.  Adjust comment.
+        (make_save_value): Use new Lisp_Save_Value layout.  Adjust comment.
+        (free_save_value): Likewise.
+        (mark_object): Likewise.
+        * editfns.c (save_excursion_save): Pack everything within
+        Lisp_Save_Value and so avoid xmalloc.
+        (save_excursion_restore): Adjust to match new layout.  Use free_misc
+        because we do not allocate extra memory any more.  Add eassert.
+        * print.c (print_object): New code to print Lisp_Save_Value.  Do not
+        rely on valid_lisp_object_p if !GC_MARK_STACK.  Adjust comments.
+        * dired.c, fileio.c, font.c, ftfont.c, gtkutil.c, keymap.c,
+        * lread.c, nsmenu.m, nsterm.h, xfns.c, xmenu.c, xselect.c:
+        Use XSAVE_POINTER and XSAVE_INTEGER where appropriate.
+
+2013-01-13  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfont.m (LCD_SMOOTHING_MARGIN): New define.
+        (nsfont_draw): Remove disabling of LCD smoothing.
+        (ns_glyph_metrics): Add LCD_SMOOTHING_MARGIN to bearings to fix
+        Bug#11484 with LCD smoothing on.
+
+2013-01-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix SIGDANGER handlers, for AIX (Bug#13408).
+        * sysdep.c.c (handle_danger_signal, deliver_danger_signal) [SIGDANGER]:
+        Move handlers here from emacs.c; they were out of place.
+
+2013-01-11  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xterm.c (syms_of_xterm): Adjust documentation for
+        scroll-bar-adjust-thumb-portion.
+
+2012-12-31  Adam Sjøgren  <asjo@koldfront.dk>  (tiny change)
+
+        * xterm.c (scroll-bar-adjust-thumb-portion): New variable to
+        determine whether scroll bar thumb size should be adjusted or
+        not. Use variable for MOTIF.
+
+        * gtkutil.c (scroll-bar-adjust-thumb-portion): Use variable for
+        GTK.
+
+2013-01-13  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (keyDown:): Set processingCompose to NO if an emacs key
+        event is generated.
+        (doCommandBySelector:): Set processingCompose to NO.
+
+        * nsfont.m (ns_findfonts): Add block/unblock_input calls.
+        Remove check for fkeys count > zero, block/unblock fixes the real bug.
+        (nsfont_list_family): Add block/unblock_input calls.
+        (nsfont_open): Move block_input earlier.  Add unblock_input before early
+        return.
+        (nsfont_draw): Add block/unblock_input calls.
+
+2013-01-12  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * indent.c (Fvertical_motion): Remove now-incorrect GCPROs
+        for old_charpos and old_bytepos.
+
+2013-01-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix bug with set-time-zone-rule and LOCALTIME_CACHE (Bug#13415).
+        * editfns.c (set_time_zone_rule) [LOCALTIME_CACHE]:
+        Clear tzvalbuf_in_environ if this workaround is in effect.
+        Problem and fix reported by Kazuhiro Ito.
+
+2013-01-11  Aaron S. Hawley  <Aaron.Hawley@vtinfo.com>
+
+        * insdel.c (Fcombine_after_change_execute, syms_of_insdel): Fix
+         ambiguous doc string cross-reference(s).
+
+        * keyboard.c (Fcommand_execute, syms_of_keyboard): Fix ambiguous
+         doc string cross-reference(s).
+
+        * window.c (Fwindow_point, syms_of_window): Fix ambiguous doc
+         string cross-reference(s).
+
+2013-01-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Avoid unnecessary byte position calculation for the gap movement.
+        Since all users of move_gap do CHAR_TO_BYTE for other purposes
+        anyway, all of them should use move_gap_both instead.
+        * lisp.h (move_gap): Remove prototype.
+        * insdel.c (move_gap): Remove.
+        (move_gap_both): Add eassert.
+        * editfns.c (Ftranspose_regions): Tweak to use move_gap_both.
+        * xml.c (parse_region): Likewise.
+
+2013-01-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        emacsclient -t should not suspend Emacs server (Bug#13387)
+        * lisp.h, sysdep.c (block_tty_out_signal, unblock_tty_out_signal):
+        New functions.
+        * term.c (init_tty): Use them instead of rolling our own code.
+        * sysdep.c (tcsetpgrp_without_stopping): Likewise.  Here, this
+        switches from 'signal' to 'pthread_sigmask', which is safer in
+        multithreaded applications.
+        * term.c (Fresume_tty): Don't bother dissociating if O_IGNORE_CTTY,
+        which has already arranged for that.
+        (dissociate_if_controlling_tty): If setsid fails, fall back on TIOCNOTTY.
+        This is the main part of the bug fix.
+
+2013-01-10  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>  (tiny change)
+
+        * gtkutil.c (xg_initialize): Add ifdef HAVE_FREETYPE around
+        x_last_font_name (Bug#13403).
+
+2013-01-10  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Omit buffer_slot_type_mismatch and use generic predicates to enforce
+        the type of per-buffer values where appropriate.
+        * lisp.h (struct Lisp_Buffer_Objfwd): Rename slottype member to
+        predicate, which is how it's really used now.  Adjust comment.
+        * buffer.h (buffer_slot_type_mismatch): Remove prototype.
+        * buffer.c (buffer_slot_type_mismatch): Remove.
+        (DEFVAR_PER_BUFFER, defvar_per_buffer): Rename type argument to
+        predicate.  Adjust comment.
+        (syms_of_buffer): Use Qsymbolp for major-mode.  Use Qintegerp for
+        fill-column, left-margin, tab-width, buffer-saved-size,
+        left-margin-width, right-margin-width, left-fringe-width,
+        right-fringe-width, scroll-bar-width and buffer-display-count.
+        Use Qstringp for default-directory, buffer-file-name,
+        buffer-file-truename and buffer-auto-save-file-name.  Use Qfloatp for
+        scroll-up-aggressively and scroll-down-aggressively.  Use Qnumberp for
+        line-spacing.
+        * data.c (store_symval_forwarding): Adjust to call the predicate.
+
+2013-01-09  Juanma Barranquero  <lekktu@gmail.com>
+
+        * w32.c (get_name_and_id, acl_set_file):
+        * w32term.c (w32fullscreen_hook): Remove unused local variables.
+
+2013-01-09  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (make_gap_1): New prototype.
+        * buffer.h (GAP_BYTES_DFL, GAP_BYTES_MIN): New macros for the special
+        gap size values.
+        * editfns.c (Fbuffer_size): Rename from Fbufsize to fit the common
+        naming convention.
+        (syms_of_editfns): Adjust defsubr.  Drop commented-out obsolete code.
+        * insdel.c (make_gap_larger): Use GAP_BYTES_DFL.  Adjust comment.
+        (make_gap_smaller): Use GAP_BYTES_MIN.  Adjust comment.
+        (make_gap_1): New function to adjust the gap of any buffer.
+        * coding.c (coding_alloc_by_making_gap): Use it.
+        * buffer.c (compact_buffer): Likewise.  Use BUF_Z_BYTE, BUF_GAP_SIZE,
+        GAP_BYTES_DFL and GAP_BYTES_MIN.  Adjust comment.
+
+2013-01-08  Juri Linkov  <juri@jurta.org>
+
+        * xfaces.c (tty_supports_face_attributes_p): Return 0 for the case
+        of (supports :underline (:style wave)).  (Bug#13000)
+
+2013-01-08  Aaron S. Hawley  <aaron.s.hawley@gmail.com>
+
+        * undo.c (Fprimitive_undo): Move to simple.el.
+        (syms_of_undo): Remove declarations for Sprimitive_undo.
+
+2013-01-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (echo_add_key): Rename from echo_add_char.
+
+2013-01-06  Chong Yidong  <cyd@gnu.org>
+
+        * keyboard.c (echo_add_char): New function, factored out from
+        echo_char.  Don't add a space if the previous echo string was
+        empty (Bug#13255).
+        (echo_char): Use it.
+        (read_key_sequence): When echoing mock input, ensure that the
+        trailing dash is properly added.
+
 2013-01-05  Eli Zaretskii  <eliz@gnu.org>
 
         * xdisp.c (dump_glyph): Align glyph data better.  Use "pD" instead
         of a non-portable "t" to print ptrdiff_t values.  Allow up to 9
-        digits for buffer positions, before misalignment starts.  Display
-        "0" for integer "object" field.
+        digits for buffer positions, before misalignment starts.
+        Display "0" for integer "object" field.
         (dump_glyph_row): Adapt the header line to changes in dump_glyph.
         Display the newline glyph more unambiguously.
 
@@ -44,8 +284,8 @@
 2012-12-31  Eli Zaretskii  <eliz@gnu.org>
 
         * w32.c (unsetenv): Set up the string passed to _putenv
-        correctly.  See
-        http://lists.gnu.org/archive/html/emacs-devel/2012-12/msg00863.html
+        correctly.
+        See http://lists.gnu.org/archive/html/emacs-devel/2012-12/msg00863.html
         for the bug this caused.
 
 2012-12-30  Paul Eggert  <eggert@cs.ucla.edu>
@@ -117,8 +357,8 @@
 
 2012-12-27  Eli Zaretskii  <eliz@gnu.org>
 
-        * fileio.c (file_name_as_directory, directory_file_name): Accept
-        an additional argument MULTIBYTE to indicate whether the input C
+        * fileio.c (file_name_as_directory, directory_file_name):
+        Accept an additional argument MULTIBYTE to indicate whether the input C
         came from a multibyte or a unibyte Lisp string; all callers
         adjusted.  Don't assume the input string is always multibyte.
         (Bug#13262)
@@ -202,8 +442,8 @@
         * w32.c (sys_close): Do not call delete_child on a subprocess
         whose handle is not yet closed.  Instead, set its file descriptor
         to a negative value, so that reap_subprocess will call
-        delete_child on that subprocess when its SIGCHLD arrives.  This
-        avoids closing handles used for communications between sys_select
+        delete_child on that subprocess when its SIGCHLD arrives.
+        This avoids closing handles used for communications between sys_select
         and reader_thread, which doesn't give sys_select a chance to
         notice that the process exited and invoke the SIGCHLD handler for
         it.
@@ -1642,7 +1882,7 @@
         * image.c (xpm_make_color_table_h): Fix compiler error because
         make_hash_table changed.
 
-2012-11-08  Thomas Kappler <tkappler@gmail.com> (tiny change)
+2012-11-08  Thomas Kappler  <tkappler@gmail.com>  (tiny change)
 
         * nsfont.m (ns_findfonts): Handle empty matchingDescs (Bug#11541).
 
diff --git a/src/alloc.c b/src/alloc.c
index c2b2a4c1ed7..b7c17fbd6fb 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -209,6 +209,7 @@ Lisp_Object Qchar_table_extra_slots;
 
 static Lisp_Object Qpost_gc_hook;
 
+static void free_save_value (Lisp_Object);
 static void mark_terminals (void);
 static void gc_sweep (void);
 static Lisp_Object make_pure_vector (ptrdiff_t);
@@ -219,7 +220,6 @@ static void refill_memory_reserve (void);
 #endif
 static void compact_small_strings (void);
 static void free_large_strings (void);
-static void free_misc (Lisp_Object);
 extern Lisp_Object which_symbols (Lisp_Object, EMACS_INT) EXTERNALLY_VISIBLE;
 
 /* When scanning the C stack for live Lisp objects, Emacs keeps track of
@@ -3337,9 +3337,9 @@ allocate_misc (enum Lisp_Misc_Type type)
   return val;
 }
 
-/* Free a Lisp_Misc object */
+/* Free a Lisp_Misc object.  */
 
-static void
+void
 free_misc (Lisp_Object misc)
 {
   XMISCTYPE (misc) = Lisp_Misc_Free;
@@ -3349,34 +3349,77 @@ free_misc (Lisp_Object misc)
   total_free_markers++;
 }
 
-/* Return a Lisp_Misc_Save_Value object containing POINTER and
-   INTEGER.  This is used to package C values to call record_unwind_protect.
-   The unwind function can get the C values back using XSAVE_VALUE.  */
+/* Return a Lisp_Save_Value object with the data saved according to
+   FMT.  Format specifiers are `i' for an integer, `p' for a pointer
+   and `o' for Lisp_Object.  Up to 4 objects can be specified.  */
 
 Lisp_Object
-make_save_value (void *pointer, ptrdiff_t integer)
+format_save_value (const char *fmt, ...)
 {
-  register Lisp_Object val;
-  register struct Lisp_Save_Value *p;
+  va_list ap;
+  int len = strlen (fmt);
+  Lisp_Object val = allocate_misc (Lisp_Misc_Save_Value);
+  struct Lisp_Save_Value *p = XSAVE_VALUE (val);
+
+  eassert (0 < len && len < 5);
+  va_start (ap, fmt);
+
+#define INITX(index)                                           \
+  do {                                                         \
+    if (len <= index)                                          \
+      p->type ## index = SAVE_UNUSED;                          \
+    else                                                       \
+      {                                                        \
+        if (fmt[index] == 'i')                                 \
+         {                                                     \
+           p->type ## index = SAVE_INTEGER;                    \
+           p->data[index].integer = va_arg (ap, ptrdiff_t);    \
+         }                                                     \
+       else if (fmt[index] == 'p')                             \
+         {                                                     \
+           p->type ## index = SAVE_POINTER;                    \
+           p->data[index].pointer = va_arg (ap, void *);       \
+         }                                                     \
+       else if (fmt[index] == 'o')                             \
+         {                                                     \
+           p->type ## index = SAVE_OBJECT;                     \
+           p->data[index].object = va_arg (ap, Lisp_Object);   \
+         }                                                     \
+       else                                                    \
+         emacs_abort ();                                       \
+      }                                                        \
+  } while (0)
+
+  INITX (0);
+  INITX (1);
+  INITX (2);
+  INITX (3);
 
-  val = allocate_misc (Lisp_Misc_Save_Value);
-  p = XSAVE_VALUE (val);
-  p->pointer = pointer;
-  p->integer = integer;
-  p->dogc = 0;
+#undef INITX
+
+  va_end (ap);
+  p->area = 0;
   return val;
 }
 
-/* Free a Lisp_Misc_Save_Value object.  */
+/* Return a Lisp_Save_Value object containing POINTER and INTEGER.
+   Most code should use this to package C integers and pointers
+   to call record_unwind_protect.  The unwind function can get the
+   C values back using XSAVE_POINTER and XSAVE_INTEGER.  */
 
-void
-free_save_value (Lisp_Object save)
+Lisp_Object
+make_save_value (void *pointer, ptrdiff_t integer)
 {
-  register struct Lisp_Save_Value *p = XSAVE_VALUE (save);
+  return format_save_value ("pi", pointer, integer);
+}
+
+/* Free a Lisp_Save_Value object.  Do not use this function
+   if SAVE contains pointer other than returned by xmalloc.  */
 
-  p->dogc = 0;
-  xfree (p->pointer);
-  p->pointer = NULL;
+static void
+free_save_value (Lisp_Object save)
+{
+  xfree (XSAVE_POINTER (save, 0));
   free_misc (save);
 }
 
@@ -4444,11 +4487,6 @@ mark_memory (void *start, void *end)
       }
 }
 
-/* setjmp will work with GCC unless NON_SAVING_SETJMP is defined in
-   the GCC system configuration.  In gcc 3.2, the only systems for
-   which this is so are i386-sco5 non-ELF, i386-sysv3 (maybe included
-   by others?) and ns32k-pc532-min.  */
-
 #if !defined GC_SAVE_REGISTERS_ON_STACK && !defined GC_SETJMP_WORKS
 
 static bool setjmp_tested_p;
@@ -5913,20 +5951,33 @@ mark_object (Lisp_Object arg)
 
         case Lisp_Misc_Save_Value:
           XMISCANY (obj)->gcmarkbit = 1;
-#if GC_MARK_STACK
           {
             register struct Lisp_Save_Value *ptr = XSAVE_VALUE (obj);
-            /* If DOGC is set, POINTER is the address of a memory
-               area containing INTEGER potential Lisp_Objects.  */
-            if (ptr->dogc)
+            /* If `area' is nonzero, `data[0].pointer' is the address
+               of a memory area containing `data[1].integer' potential
+               Lisp_Objects.  */
+#if GC_MARK_STACK
+            if (ptr->area)
               {
-                Lisp_Object *p = (Lisp_Object *) ptr->pointer;
+                Lisp_Object *p = ptr->data[0].pointer;
                 ptrdiff_t nelt;
-                for (nelt = ptr->integer; nelt > 0; nelt--, p++)
+                for (nelt = ptr->data[1].integer; nelt > 0; nelt--, p++)
                   mark_maybe_object (*p);
               }
+            else
+#endif /* GC_MARK_STACK */
+              {
+                /* Find Lisp_Objects in `data[N]' slots and mark them.  */
+                if (ptr->type0 == SAVE_OBJECT)
+                  mark_object (ptr->data[0].object);
+                if (ptr->type1 == SAVE_OBJECT)
+                  mark_object (ptr->data[1].object);
+                if (ptr->type2 == SAVE_OBJECT)
+                  mark_object (ptr->data[2].object);
+                if (ptr->type3 == SAVE_OBJECT)
+                  mark_object (ptr->data[3].object);
+              }
           }
-#endif
           break;
 
         case Lisp_Misc_Overlay:
diff --git a/src/buffer.c b/src/buffer.c
index 61b457e4558..a06868ec6c3 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1680,17 +1680,13 @@ compact_buffer (struct buffer *buffer)
       if (!buffer->text->inhibit_shrinking)
         {
           /* If a buffer's gap size is more than 10% of the buffer
-             size, or larger than 2000 bytes, then shrink it
-             accordingly.  Keep a minimum size of 20 bytes.  */
-          int size = min (2000, max (20, (buffer->text->z_byte / 10)));
-
-          if (buffer->text->gap_size > size)
-            {
-              struct buffer *save_current = current_buffer;
-              current_buffer = buffer;
-              make_gap (-(buffer->text->gap_size - size));
-              current_buffer = save_current;
-            }
+             size, or larger than GAP_BYTES_DFL bytes, then shrink it
+             accordingly.  Keep a minimum size of GAP_BYTES_MIN bytes.  */
+          ptrdiff_t size = clip_to_bounds (GAP_BYTES_MIN,
+                                           BUF_Z_BYTE (buffer) / 10,
+                                           GAP_BYTES_DFL);
+          if (BUF_GAP_SIZE (buffer) > size)
+            make_gap_1 (buffer, -(BUF_GAP_SIZE (buffer) - size));
         }
       BUF_COMPACT (buffer) = BUF_MODIFF (buffer);
     }
@@ -4578,27 +4574,7 @@ evaporate_overlays (ptrdiff_t pos)
   for (; CONSP (hit_list); hit_list = XCDR (hit_list))
     Fdelete_overlay (XCAR (hit_list));
 }
-
-/* Somebody has tried to store a value with an unacceptable type
-   in the slot with offset OFFSET.  */
-
-void
-buffer_slot_type_mismatch (Lisp_Object newval, int type)
-{
-  Lisp_Object predicate;
-
-  switch (type)
-    {
-    case_Lisp_Int:    predicate = Qintegerp; break;
-    case Lisp_String: predicate = Qstringp;  break;
-    case Lisp_Symbol: predicate = Qsymbolp;  break;
-    default: emacs_abort ();
-    }
-
-  wrong_type_argument (predicate, newval);
-}
 
-
 /***********************************************************************
                          Allocation with mmap
  ***********************************************************************/
@@ -5372,25 +5348,23 @@ init_buffer (void)
   free (pwd);
 }
 
-/* Similar to defvar_lisp but define a variable whose value is the Lisp
-   Object stored in the current buffer.  address is the address of the slot
-   in the buffer that is current now. */
-
-/* TYPE is nil for a general Lisp variable.
-   An integer specifies a type; then only Lisp values
-   with that type code are allowed (except that nil is allowed too).
-   LNAME is the Lisp-level variable name.
-   VNAME is the name of the buffer slot.
-   DOC is a dummy where you write the doc string as a comment.  */
-#define DEFVAR_PER_BUFFER(lname, vname, type, doc)                      \
-  do {                                                                  \
-    static struct Lisp_Buffer_Objfwd bo_fwd;                            \
-    defvar_per_buffer (&bo_fwd, lname, vname, type);                    \
+/* Similar to defvar_lisp but define a variable whose value is the
+   Lisp_Object stored in the current buffer.  LNAME is the Lisp-level
+   variable name.  VNAME is the name of the buffer slot.  PREDICATE
+   is nil for a general Lisp variable.  If PREDICATE is non-nil, then
+   only Lisp values that satisfies the PREDICATE are allowed (except
+   that nil is allowed too).  DOC is a dummy where you write the doc
+   string as a comment.  */
+
+#define DEFVAR_PER_BUFFER(lname, vname, predicate, doc)         \
+  do {                                                          \
+    static struct Lisp_Buffer_Objfwd bo_fwd;                    \
+    defvar_per_buffer (&bo_fwd, lname, vname, predicate);       \
   } while (0)
 
 static void
 defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
-                   Lisp_Object *address, Lisp_Object type)
+                   Lisp_Object *address, Lisp_Object predicate)
 {
   struct Lisp_Symbol *sym;
   int offset;
@@ -5400,7 +5374,7 @@ defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
 
   bo_fwd->type = Lisp_Fwd_Buffer_Obj;
   bo_fwd->offset = offset;
-  bo_fwd->slottype = type;
+  bo_fwd->predicate = predicate;
   sym->declared_special = 1;
   sym->redirect = SYMBOL_FORWARDED;
   {
@@ -5663,7 +5637,7 @@ Decimal digits after the % specify field width to which to pad.  */);
                           doc: /* Value of `major-mode' for new buffers.  */);
 
   DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer, major_mode),
-                     make_number (Lisp_Symbol),
+                     Qsymbolp,
                      doc: /* Symbol for current buffer's major mode.
 The default value (normally `fundamental-mode') affects new buffers.
 A value of nil means to use the current buffer's major mode, provided
@@ -5694,17 +5668,17 @@ Use the command `abbrev-mode' to change this variable.  */);
                      doc: /* Non-nil if searches and matches should ignore case.  */);
 
   DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer, fill_column),
-                     make_number (Lisp_Int0),
+                     Qintegerp,
                      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_Int0),
+                     Qintegerp,
                      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_Int0),
+                     Qintegerp,
                      doc: /* Distance between tab stops (for display of tab characters), in columns.
 This should be an integer greater than zero.  */);
 
@@ -5789,7 +5763,7 @@ visual lines rather than logical lines.  See the documentation of
 `visual-line-mode'.  */);
 
   DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer, directory),
-                     make_number (Lisp_String),
+                     Qstringp,
                      doc: /* Name of default directory of current buffer.  Should end with slash.
 To interactively change the default directory, use command `cd'.  */);
 
@@ -5802,18 +5776,18 @@ NOTE: This variable is not a hook;
 its value may not be a list of functions.  */);
 
   DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer, filename),
-                     make_number (Lisp_String),
+                     Qstringp,
                      doc: /* Name of file visited in current buffer, or nil if not visiting a file.  */);
 
   DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer, file_truename),
-                     make_number (Lisp_String),
+                     Qstringp,
                      doc: /* Abbreviated truename of file visited in current buffer, or nil if none.
 The truename of a file is calculated by `file-truename'
 and then abbreviated with `abbreviate-file-name'.  */);
 
   DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
                      &BVAR (current_buffer, auto_save_file_name),
-                     make_number (Lisp_String),
+                     Qstringp,
                      doc: /* Name of file for auto-saving current buffer.
 If it is nil, that means don't auto-save this buffer.  */);
 
@@ -5825,7 +5799,7 @@ If it is nil, that means don't auto-save this buffer.  */);
 Backing up is done before the first time the file is saved.  */);
 
   DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer, save_length),
-                     make_number (Lisp_Int0),
+                     Qintegerp,
                      doc: /* Length of current buffer when last read in, saved or auto-saved.
 0 initially.
 -1 means auto-saving turned off until next real save.
@@ -5895,23 +5869,23 @@ In addition, a char-table has six extra slots to control the display of:
 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,
+                     Qintegerp,
                      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,
+                     Qintegerp,
                      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,
+                     Qintegerp,
                      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,
+                     Qintegerp,
                      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.  */);
@@ -5922,7 +5896,7 @@ A value of nil means to use the right fringe width from the window's frame.  */)
 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,
+                     Qintegerp,
                      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.  */);
 
@@ -6002,7 +5976,7 @@ BITMAP is the corresponding fringe bitmap shown for the logical
 cursor type.  */);
 
   DEFVAR_PER_BUFFER ("scroll-up-aggressively",
-                     &BVAR (current_buffer, scroll_up_aggressively), Qnil,
+                     &BVAR (current_buffer, scroll_up_aggressively), Qfloatp,
                      doc: /* How far to scroll windows upward.
 If you move point off the bottom, the window scrolls automatically.
 This variable controls how far it scrolls.  The value nil, the default,
@@ -6015,7 +5989,7 @@ window scrolls by a full window height.  Meaningful values are
 between 0.0 and 1.0, inclusive.  */);
 
   DEFVAR_PER_BUFFER ("scroll-down-aggressively",
-                     &BVAR (current_buffer, scroll_down_aggressively), Qnil,
+                     &BVAR (current_buffer, scroll_down_aggressively), Qfloatp,
                      doc: /* How far to scroll windows downward.
 If you move point off the top, the window scrolls automatically.
 This variable controls how far it scrolls.  The value nil, the default,
@@ -6169,7 +6143,7 @@ then characters with property value PROP are invisible,
 and they have an ellipsis as well if ELLIPSIS is non-nil.  */);
 
   DEFVAR_PER_BUFFER ("buffer-display-count",
-                     &BVAR (current_buffer, display_count), Qnil,
+                     &BVAR (current_buffer, display_count), Qintegerp,
                      doc: /* A number incremented each time this buffer is displayed in a window.
 The function `set-window-buffer' increments it.  */);
 
@@ -6228,7 +6202,7 @@ cursor's appearance is instead controlled by the variable
 `cursor-in-non-selected-windows'.  */);
 
   DEFVAR_PER_BUFFER ("line-spacing",
-                     &BVAR (current_buffer, extra_line_spacing), Qnil,
+                     &BVAR (current_buffer, extra_line_spacing), Qnumberp,
                      doc: /* Additional space to put between lines when displaying a buffer.
 The space is measured in pixels, and put below lines on graphic displays,
 see `display-graphic-p'.
diff --git a/src/buffer.h b/src/buffer.h
index 4bf2b4c2a0b..c0b0e227725 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -320,6 +320,16 @@ while (0)
 #define BUF_BYTES_MAX \
   (ptrdiff_t) min (MOST_POSITIVE_FIXNUM - 1, min (SIZE_MAX, PTRDIFF_MAX))
 
+/* Maximum gap size after compact_buffer, in bytes.  Also
+   used in make_gap_larger to get some extra reserved space.  */
+
+#define GAP_BYTES_DFL 2000
+
+/* Minimum gap size after compact_buffer, in bytes.  Also
+   used in make_gap_smaller to avoid too small gap size.  */
+
+#define GAP_BYTES_MIN 20
+
 /* Return the address of byte position N in current buffer.  */
 
 #define BYTE_POS_ADDR(n) \
@@ -1064,7 +1074,6 @@ extern void set_buffer_internal_1 (struct buffer *);
 extern void set_buffer_temp (struct buffer *);
 extern Lisp_Object buffer_local_value_1 (Lisp_Object, Lisp_Object);
 extern void record_buffer (Lisp_Object);
-extern _Noreturn void buffer_slot_type_mismatch (Lisp_Object, int);
 extern void fix_overlays_before (struct buffer *, ptrdiff_t, ptrdiff_t);
 extern void mmap_set_vars (bool);
 
diff --git a/src/coding.c b/src/coding.c
index 5285a906823..a9bf9032a69 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -1049,14 +1049,7 @@ coding_alloc_by_making_gap (struct coding_system *coding,
       GPT -= gap_head_used, GPT_BYTE -= gap_head_used;
     }
   else
-    {
-      Lisp_Object this_buffer;
-
-      this_buffer = Fcurrent_buffer ();
-      set_buffer_internal (XBUFFER (coding->dst_object));
-      make_gap (bytes);
-      set_buffer_internal (XBUFFER (this_buffer));
-    }
+    make_gap_1 (XBUFFER (coding->dst_object), bytes);
 }
 
 
diff --git a/src/data.c b/src/data.c
index e9f3a2cff3f..8a66cbe9197 100644
--- a/src/data.c
+++ b/src/data.c
@@ -951,13 +951,11 @@ store_symval_forwarding (union Lisp_Fwd *valcontents, register Lisp_Object newva
     case Lisp_Fwd_Buffer_Obj:
       {
         int offset = XBUFFER_OBJFWD (valcontents)->offset;
-        Lisp_Object type = XBUFFER_OBJFWD (valcontents)->slottype;
+        Lisp_Object predicate = XBUFFER_OBJFWD (valcontents)->predicate;
 
-        if (!(NILP (type) || NILP (newval)
-              || (XINT (type) == Lisp_Int0
-                  ? INTEGERP (newval)
-                  : XTYPE (newval) == XINT (type))))
-          buffer_slot_type_mismatch (newval, XINT (type));
+        if (!NILP (predicate) && !NILP (newval)
+            && NILP (call1 (predicate, newval)))
+          wrong_type_argument (predicate, newval);
 
         if (buf == NULL)
           buf = current_buffer;
diff --git a/src/dired.c b/src/dired.c
index b4dc702112e..3dca9d24f67 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -78,7 +78,7 @@ directory_files_internal_w32_unwind (Lisp_Object arg)
 static Lisp_Object
 directory_files_internal_unwind (Lisp_Object dh)
 {
-  DIR *d = (DIR *) XSAVE_VALUE (dh)->pointer;
+  DIR *d = XSAVE_POINTER (dh, 0);
   block_input ();
   closedir (d);
   unblock_input ();
diff --git a/src/editfns.c b/src/editfns.c
index df0dad0669d..8910b66e4d3 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -833,21 +833,17 @@ This function does not move point.  */)
 Lisp_Object
 save_excursion_save (void)
 {
-  Lisp_Object save, *data = xmalloc (word_size * 4);
-
-  data[0] = Fpoint_marker ();
-  /* Do not copy the mark if it points to nowhere.  */
-  data[1] = (XMARKER (BVAR (current_buffer, mark))->buffer
-             ? Fcopy_marker (BVAR (current_buffer, mark), Qnil)
-             : Qnil);
-  /* Selected window if current buffer is shown in it, nil otherwise.  */
-  data[2] = ((XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
-             ? selected_window : Qnil);
-  data[3] = BVAR (current_buffer, mark_active);
-
-  save = make_save_value (data, 4);
-  XSAVE_VALUE (save)->dogc = 1;
-  return save;
+  return format_save_value
+    ("oooo",
+     Fpoint_marker (),
+     /* Do not copy the mark if it points to nowhere.  */
+     (XMARKER (BVAR (current_buffer, mark))->buffer
+      ? Fcopy_marker (BVAR (current_buffer, mark), Qnil)
+      : Qnil),
+     /* Selected window if current buffer is shown in it, nil otherwise.  */
+     ((XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
+      ? selected_window : Qnil),
+     BVAR (current_buffer, mark_active));
 }
 
 /* Restore saved buffer before leaving `save-excursion' special form.  */
@@ -855,10 +851,10 @@ save_excursion_save (void)
 Lisp_Object
 save_excursion_restore (Lisp_Object info)
 {
-  Lisp_Object tem, tem1, omark, nmark, *data = XSAVE_VALUE (info)->pointer;
+  Lisp_Object tem, tem1, omark, nmark;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
-  tem = Fmarker_buffer (data[0]);
+  tem = Fmarker_buffer (XSAVE_OBJECT (info, 0));
   /* If we're unwinding to top level, saved buffer may be deleted.  This
      means that all of its markers are unchained and so tem is nil.  */
   if (NILP (tem))
@@ -870,12 +866,12 @@ save_excursion_restore (Lisp_Object info)
   Fset_buffer (tem);
 
   /* Point marker.  */
-  tem = data[0];
+  tem = XSAVE_OBJECT (info, 0);
   Fgoto_char (tem);
   unchain_marker (XMARKER (tem));
 
   /* Mark marker.  */
-  tem = data[1];
+  tem = XSAVE_OBJECT (info, 1);
   omark = Fmarker_position (BVAR (current_buffer, mark));
   if (NILP (tem))
     unchain_marker (XMARKER (BVAR (current_buffer, mark)));
@@ -887,7 +883,7 @@ save_excursion_restore (Lisp_Object info)
     }
 
   /* Mark active.  */
-  tem = data[3];
+  tem = XSAVE_OBJECT (info, 3);
   tem1 = BVAR (current_buffer, mark_active);
   bset_mark_active (current_buffer, tem);
 
@@ -911,7 +907,7 @@ save_excursion_restore (Lisp_Object info)
   /* If buffer was visible in a window, and a different window was
      selected, and the old selected window is still showing this
      buffer, restore point in that window.  */
-  tem = data[2];
+  tem = XSAVE_OBJECT (info, 2);
   if (WINDOWP (tem)
       && !EQ (tem, selected_window)
       && (tem1 = XWINDOW (tem)->buffer,
@@ -925,7 +921,7 @@ save_excursion_restore (Lisp_Object info)
 
  out:
 
-  free_save_value (info);
+  free_misc (info);
   return Qnil;
 }
 
@@ -968,7 +964,7 @@ usage: (save-current-buffer &rest BODY)  */)
   return unbind_to (count, Fprogn (args));
 }
 
-DEFUN ("buffer-size", Fbufsize, Sbufsize, 0, 1, 0,
+DEFUN ("buffer-size", Fbuffer_size, Sbuffer_size, 0, 1, 0,
        doc: /* Return the number of characters in the current buffer.
 If BUFFER, return the number of characters in that buffer instead.  */)
   (Lisp_Object buffer)
@@ -2188,6 +2184,7 @@ set_time_zone_rule (const char *tzstring)
       xputenv (set_time_zone_rule_tz[1]);
     }
   tzset ();
+  tzvalbuf_in_environ = 0;
 #endif
 
   if (!tzstring)
@@ -4257,7 +4254,7 @@ usage: (format STRING &rest OBJECTS)  */)
             memcpy (buf, initial_buffer, used);
           }
         else
-          XSAVE_VALUE (buf_save_value)->pointer = buf = xrealloc (buf, bufsize);
+          XSAVE_POINTER (buf_save_value, 0) = buf = xrealloc (buf, bufsize);
 
         p = buf + used;
       }
@@ -4522,7 +4519,7 @@ Transposing beyond buffer boundaries is an error.  */)
   (Lisp_Object startr1, Lisp_Object endr1, Lisp_Object startr2, Lisp_Object endr2, Lisp_Object leave_markers)
 {
   register ptrdiff_t start1, end1, start2, end2;
-  ptrdiff_t start1_byte, start2_byte, len1_byte, len2_byte;
+  ptrdiff_t start1_byte, start2_byte, len1_byte, len2_byte, end2_byte;
   ptrdiff_t gap, len1, len_mid, len2;
   unsigned char *start1_addr, *start2_addr, *temp;
 
@@ -4583,20 +4580,22 @@ Transposing beyond buffer boundaries is an error.  */)
      the gap the minimum distance to get it out of the way, and then
      deal with an unbroken array.  */
 
+  start1_byte = CHAR_TO_BYTE (start1);
+  end2_byte = CHAR_TO_BYTE (end2);
+
   /* Make sure the gap won't interfere, by moving it out of the text
      we will operate on.  */
   if (start1 < gap && gap < end2)
     {
       if (gap - start1 < end2 - gap)
-        move_gap (start1);
+        move_gap_both (start1, start1_byte);
       else
-        move_gap (end2);
+        move_gap_both (end2, end2_byte);
     }
 
-  start1_byte = CHAR_TO_BYTE (start1);
   start2_byte = CHAR_TO_BYTE (start2);
   len1_byte = CHAR_TO_BYTE (end1) - start1_byte;
-  len2_byte = CHAR_TO_BYTE (end2) - start2_byte;
+  len2_byte = end2_byte - start2_byte;
 
 #ifdef BYTE_COMBINING_DEBUG
   if (end1 == start2)
@@ -4883,12 +4882,10 @@ functions if all the text being accessed has this property.  */);
   defsubr (&Sline_beginning_position);
   defsubr (&Sline_end_position);
 
-/*  defsubr (&Smark); */
-/*  defsubr (&Sset_mark); */
   defsubr (&Ssave_excursion);
   defsubr (&Ssave_current_buffer);
 
-  defsubr (&Sbufsize);
+  defsubr (&Sbuffer_size);
   defsubr (&Spoint_max);
   defsubr (&Spoint_min);
   defsubr (&Spoint_min_marker);
diff --git a/src/emacs.c b/src/emacs.c
index 57de81f05b0..1848c71a22f 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -340,25 +340,6 @@ terminate_due_to_signal (int sig, int backtrace_limit)
   /* This shouldn't be executed, but it prevents a warning.  */
   exit (1);
 }
-
-#ifdef SIGDANGER
-
-/* Handler for SIGDANGER.  */
-static void
-handle_danger_signal (int sig)
-{
-  malloc_warning ("Operating system warns that virtual memory is running low.\n");
-
-  /* It might be unsafe to call do_auto_save now.  */
-  force_auto_save_soon ();
-}
-
-static void
-deliver_danger_signal (int sig)
-{
-  deliver_process_signal (sig, handle_danger_signal);
-}
-#endif
 
 /* Code for dealing with Lisp access to the Unix command line.  */
 
diff --git a/src/eval.c b/src/eval.c
index f88567f14cb..18031236c7d 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1950,7 +1950,10 @@ eval_sub (Lisp_Object form)
     return form;
 
   QUIT;
+
+  GCPRO1 (form);
   maybe_gc ();
+  UNGCPRO;
 
   if (++lisp_eval_depth > max_lisp_eval_depth)
     {
diff --git a/src/fileio.c b/src/fileio.c
index 5e9b36ee44a..87d945c1e5e 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -3408,30 +3408,22 @@ decide_coding_unwind (Lisp_Object unwind_data)
   return Qnil;
 }
 
-
-/* Used to pass values from insert-file-contents to read_non_regular.  */
-
-static int non_regular_fd;
-static ptrdiff_t non_regular_inserted;
-static int non_regular_nbytes;
-
-
-/* Read from a non-regular file.
-   Read non_regular_nbytes bytes max from non_regular_fd.
-   Non_regular_inserted specifies where to put the read bytes.
-   Value is the number of bytes read.  */
+/* Read from a non-regular file.  STATE is a Lisp_Save_Value
+   object where slot 0 is the file descriptor, slot 1 specifies
+   an offset to put the read bytes, and slot 2 is the maximum
+   amount of bytes to read.  Value is the number of bytes read.  */
 
 static Lisp_Object
-read_non_regular (Lisp_Object ignore)
+read_non_regular (Lisp_Object state)
 {
   int nbytes;
 
   immediate_quit = 1;
   QUIT;
-  nbytes = emacs_read (non_regular_fd,
+  nbytes = emacs_read (XSAVE_INTEGER (state, 0),
                        ((char *) BEG_ADDR + PT_BYTE - BEG_BYTE
-                        + non_regular_inserted),
-                       non_regular_nbytes);
+                        + XSAVE_INTEGER (state, 1)),
+                       XSAVE_INTEGER (state, 2));
   immediate_quit = 0;
   return make_number (nbytes);
 }
@@ -4238,7 +4230,7 @@ by calling `format-decode', which see.  */)
     while (how_much < total)
       {
         /* try is reserved in some compilers (Microsoft C) */
-        int trytry = min (total - how_much, READ_BUF_SIZE);
+        ptrdiff_t trytry = min (total - how_much, READ_BUF_SIZE);
         ptrdiff_t this;
 
         if (not_regular)
@@ -4255,12 +4247,11 @@ by calling `format-decode', which see.  */)
             /* Read from the file, capturing `quit'.  When an
                error occurs, end the loop, and arrange for a quit
                to be signaled after decoding the text we read.  */
-            non_regular_fd = fd;
-            non_regular_inserted = inserted;
-            non_regular_nbytes = trytry;
-            nbytes = internal_condition_case_1 (read_non_regular,
-                                                Qnil, Qerror,
-                                                read_non_regular_quit);
+            nbytes = internal_condition_case_1
+              (read_non_regular,
+               format_save_value ("iii", (ptrdiff_t) fd, inserted, trytry),
+               Qerror, read_non_regular_quit);
+
             if (NILP (nbytes))
               {
                 read_quit = 1;
@@ -5507,7 +5498,7 @@ static Lisp_Object
 do_auto_save_unwind (Lisp_Object arg)  /* used as unwind-protect function */
 
 {
-  FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
+  FILE *stream = XSAVE_POINTER (arg, 0);
   auto_saving = 0;
   if (stream != NULL)
     {
diff --git a/src/font.c b/src/font.c
index a3a41006f9b..89931f6ec76 100644
--- a/src/font.c
+++ b/src/font.c
@@ -1857,7 +1857,7 @@ otf_open (Lisp_Object file)
   OTF *otf;
 
   if (! NILP (val))
-    otf = XSAVE_VALUE (XCDR (val))->pointer;
+    otf = XSAVE_POINTER (XCDR (val), 0);
   else
     {
       otf = STRINGP (file) ? OTF_open (SSDATA (file)) : NULL;
diff --git a/src/ftfont.c b/src/ftfont.c
index 1ada95d377c..5bf91832c7c 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -393,16 +393,14 @@ ftfont_lookup_cache (Lisp_Object key, enum ftfont_cache_for cache_for)
       cache_data = xmalloc (sizeof *cache_data);
       cache_data->ft_face = NULL;
       cache_data->fc_charset = NULL;
-      val = make_save_value (NULL, 0);
-      XSAVE_VALUE (val)->integer = 0;
-      XSAVE_VALUE (val)->pointer = cache_data;
+      val = make_save_value (cache_data, 0);
       cache = Fcons (Qnil, val);
       Fputhash (key, cache, ft_face_cache);
     }
   else
     {
       val = XCDR (cache);
-      cache_data = XSAVE_VALUE (val)->pointer;
+      cache_data = XSAVE_POINTER (val, 0);
     }
 
   if (cache_for == FTFONT_CACHE_FOR_ENTITY)
@@ -468,7 +466,7 @@ ftfont_get_fc_charset (Lisp_Object entity)
 
   cache = ftfont_lookup_cache (entity, FTFONT_CACHE_FOR_CHARSET);
   val = XCDR (cache);
-  cache_data = XSAVE_VALUE (val)->pointer;
+  cache_data = XSAVE_POINTER (val, 0);
   return cache_data->fc_charset;
 }
 
@@ -1200,9 +1198,9 @@ ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
   filename = XCAR (val);
   idx = XCDR (val);
   val = XCDR (cache);
-  cache_data = XSAVE_VALUE (XCDR (cache))->pointer;
+  cache_data = XSAVE_POINTER (XCDR (cache), 0);
   ft_face = cache_data->ft_face;
-  if (XSAVE_VALUE (val)->integer > 0)
+  if (XSAVE_INTEGER (val, 1) > 0)
     {
       /* FT_Face in this cache is already used by the different size.  */
       if (FT_New_Size (ft_face, &ft_size) != 0)
@@ -1213,13 +1211,13 @@ ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
           return Qnil;
         }
     }
-  XSAVE_VALUE (val)->integer++;
+  XSAVE_INTEGER (val, 1)++;
   size = XINT (AREF (entity, FONT_SIZE_INDEX));
   if (size == 0)
     size = pixel_size;
   if (FT_Set_Pixel_Sizes (ft_face, size, size) != 0)
     {
-      if (XSAVE_VALUE (val)->integer == 0)
+      if (XSAVE_INTEGER (val, 1) == 0)
         FT_Done_Face (ft_face);
       return Qnil;
     }
@@ -1328,10 +1326,10 @@ ftfont_close (FRAME_PTR f, struct font *font)
   cache = ftfont_lookup_cache (val, FTFONT_CACHE_FOR_FACE);
   eassert (CONSP (cache));
   val = XCDR (cache);
-  (XSAVE_VALUE (val)->integer)--;
-  if (XSAVE_VALUE (val)->integer == 0)
+  XSAVE_INTEGER (val, 1)--;
+  if (XSAVE_INTEGER (val, 1) == 0)
     {
-      struct ftfont_cache_data *cache_data = XSAVE_VALUE (val)->pointer;
+      struct ftfont_cache_data *cache_data = XSAVE_POINTER (val, 0);
 
       FT_Done_Face (cache_data->ft_face);
 #ifdef HAVE_LIBOTF
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 95ac04b8ff0..f045deacd33 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -1650,8 +1650,7 @@ xg_dialog_response_cb (GtkDialog *w,
 static Lisp_Object
 pop_down_dialog (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  struct xg_dialog_data *dd = (struct xg_dialog_data *) p->pointer;
+  struct xg_dialog_data *dd = XSAVE_POINTER (arg, 0);
 
   block_input ();
   if (dd->w) gtk_widget_destroy (dd->w);
@@ -3795,13 +3794,17 @@ xg_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar,
 
       adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
 
-      /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
-         rather than the real portion value.  This makes the thumb less likely
-         to resize and that looks better.  */
-      portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
-      /* When the thumb is at the bottom, position == whole.
-         So we need to increase `whole' to make space for the thumb.  */
-      whole += portion;
+      if (scroll_bar_adjust_thumb_portion_p)
+        {
+          /* We do the same as for MOTIF in xterm.c, use 30 chars per
+             line rather than the real portion value.  This makes the
+             thumb less likely to resize and that looks better.  */
+          portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
+
+          /* When the thumb is at the bottom, position == whole.
+             So we need to increase `whole' to make space for the thumb.  */
+          whole += portion;
+        }
 
       if (whole <= 0)
         top = 0, shown = 1;
@@ -5041,7 +5044,9 @@ xg_initialize (void)
                                 "cancel", 0);
   update_theme_scrollbar_width ();
 
+#ifdef HAVE_FREETYPE
   x_last_font_name = NULL;
+#endif
 }
 
 #endif /* USE_GTK */
diff --git a/src/indent.c b/src/indent.c
index 4a30c00dd27..45b6afbd395 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1970,7 +1970,7 @@ whether or not it is currently displayed in some window.  */)
   struct window *w;
   Lisp_Object old_buffer;
   EMACS_INT old_charpos IF_LINT (= 0), old_bytepos IF_LINT (= 0);
-  struct gcpro gcpro1, gcpro2, gcpro3;
+  struct gcpro gcpro1;
   Lisp_Object lcols = Qnil;
   double cols IF_LINT (= 0);
   void *itdata = NULL;
@@ -1987,7 +1987,7 @@ whether or not it is currently displayed in some window.  */)
   w = decode_live_window (window);
 
   old_buffer = Qnil;
-  GCPRO3 (old_buffer, old_charpos, old_bytepos);
+  GCPRO1 (old_buffer);
   if (XBUFFER (w->buffer) != current_buffer)
     {
       /* Set the window's buffer temporarily to the current buffer.  */
diff --git a/src/insdel.c b/src/insdel.c
index 52a017a62a2..303247816ca 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -84,21 +84,14 @@ check_markers (void)
 
 #endif /* MARKER_DEBUG */
 
-/* Move gap to position CHARPOS.
-   Note that this can quit!  */
-
-void
-move_gap (ptrdiff_t charpos)
-{
-  move_gap_both (charpos, CHAR_TO_BYTE (charpos));
-}
-
 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
    Note that this can quit!  */
 
 void
 move_gap_both (ptrdiff_t charpos, ptrdiff_t bytepos)
 {
+  eassert (charpos == BYTE_TO_CHAR (bytepos)
+           && bytepos == CHAR_TO_BYTE (charpos));
   if (bytepos < GPT_BYTE)
     gap_left (charpos, bytepos, 0);
   else if (bytepos > GPT_BYTE)
@@ -388,14 +381,13 @@ make_gap_larger (ptrdiff_t nbytes_added)
   ptrdiff_t real_gap_loc_byte;
   ptrdiff_t old_gap_size;
   ptrdiff_t current_size = Z_BYTE - BEG_BYTE + GAP_SIZE;
-  enum { enough_for_a_while = 2000 };
 
   if (BUF_BYTES_MAX - current_size < nbytes_added)
     buffer_overflow ();
 
   /* If we have to get more space, get enough to last a while;
      but do not exceed the maximum buffer size.  */
-  nbytes_added = min (nbytes_added + enough_for_a_while,
+  nbytes_added = min (nbytes_added + GAP_BYTES_DFL,
                       BUF_BYTES_MAX - current_size);
 
   enlarge_buffer_text (current_buffer, nbytes_added);
@@ -413,8 +405,7 @@ make_gap_larger (ptrdiff_t nbytes_added)
   GPT_BYTE = Z_BYTE + GAP_SIZE;
   GAP_SIZE = nbytes_added;
 
-  /* Move the new gap down to be consecutive with the end of the old one.
-     This adjusts the markers properly too.  */
+  /* Move the new gap down to be consecutive with the end of the old one.  */
   gap_left (real_gap_loc + old_gap_size, real_gap_loc_byte + old_gap_size, 1);
 
   /* Now combine the two into one large gap.  */
@@ -443,9 +434,9 @@ make_gap_smaller (ptrdiff_t nbytes_removed)
   ptrdiff_t real_beg_unchanged;
   ptrdiff_t new_gap_size;
 
-  /* Make sure the gap is at least 20 bytes.  */
-  if (GAP_SIZE - nbytes_removed < 20)
-    nbytes_removed = GAP_SIZE - 20;
+  /* Make sure the gap is at least GAP_BYTES_MIN bytes.  */
+  if (GAP_SIZE - nbytes_removed < GAP_BYTES_MIN)
+    nbytes_removed = GAP_SIZE - GAP_BYTES_MIN;
 
   /* Prevent quitting in move_gap.  */
   tem = Vinhibit_quit;
@@ -468,8 +459,7 @@ make_gap_smaller (ptrdiff_t nbytes_removed)
   Z_BYTE += new_gap_size;
   GAP_SIZE = nbytes_removed;
 
-  /* Move the unwanted pretend gap to the end of the buffer.  This
-     adjusts the markers properly too.  */
+  /* Move the unwanted pretend gap to the end of the buffer.  */
   gap_right (Z, Z_BYTE);
 
   enlarge_buffer_text (current_buffer, -nbytes_removed);
@@ -500,7 +490,20 @@ make_gap (ptrdiff_t nbytes_added)
     make_gap_smaller (-nbytes_added);
 #endif
 }
-
+
+/* Add NBYTES to B's gap.  It's enough to temporarily
+   fake current_buffer and avoid real switch to B.  */
+
+void
+make_gap_1 (struct buffer *b, ptrdiff_t nbytes)
+{
+  struct buffer *oldb = current_buffer;
+
+  current_buffer = b;
+  make_gap (nbytes);
+  current_buffer = oldb;
+}
+
 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
    FROM_MULTIBYTE says whether the incoming text is multibyte.
    TO_MULTIBYTE says whether to store the text as multibyte.
@@ -2081,7 +2084,7 @@ Fcombine_after_change_execute_1 (Lisp_Object val)
 
 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute,
        Scombine_after_change_execute, 0, 0, 0,
-       doc: /* This function is for use internally in `combine-after-change-calls'.  */)
+       doc: /* This function is for use internally in the function `combine-after-change-calls'.  */)
   (void)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
@@ -2173,7 +2176,7 @@ syms_of_insdel (void)
   combine_after_change_buffer = Qnil;
 
   DEFVAR_LISP ("combine-after-change-calls", Vcombine_after_change_calls,
-               doc: /* Used internally by the `combine-after-change-calls' macro.  */);
+               doc: /* Used internally by the function `combine-after-change-calls' macro.  */);
   Vcombine_after_change_calls = Qnil;
 
   DEFVAR_BOOL ("inhibit-modification-hooks", inhibit_modification_hooks,
diff --git a/src/keyboard.c b/src/keyboard.c
index 8edd705135f..7594a4f72fc 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -497,97 +497,103 @@ kset_system_key_syms (struct kboard *kb, Lisp_Object val)
 }
 
 
-/* Add C to the echo string, if echoing is going on.
-   C can be a character, which is printed prettily ("M-C-x" and all that
-   jazz), or a symbol, whose name is printed.  */
+/* Add C to the echo string, without echoing it immediately.  C can be
+   a character, which is pretty-printed, or a symbol, whose name is
+   printed.  */
 
 static void
-echo_char (Lisp_Object c)
+echo_add_key (Lisp_Object c)
 {
-  if (current_kboard->immediate_echo)
-    {
-      int size = KEY_DESCRIPTION_SIZE + 100;
-      char *buffer = alloca (size);
-      char *ptr = buffer;
-      Lisp_Object echo_string;
+  int size = KEY_DESCRIPTION_SIZE + 100;
+  char *buffer = alloca (size);
+  char *ptr = buffer;
+  Lisp_Object echo_string;
 
-      echo_string = KVAR (current_kboard, echo_string);
+  echo_string = KVAR (current_kboard, echo_string);
 
-      /* If someone has passed us a composite event, use its head symbol.  */
-      c = EVENT_HEAD (c);
+  /* If someone has passed us a composite event, use its head symbol.  */
+  c = EVENT_HEAD (c);
 
-      if (INTEGERP (c))
+  if (INTEGERP (c))
+    ptr = push_key_description (XINT (c), ptr);
+  else if (SYMBOLP (c))
+    {
+      Lisp_Object name = SYMBOL_NAME (c);
+      int nbytes = SBYTES (name);
+
+      if (size - (ptr - buffer) < nbytes)
         {
-          ptr = push_key_description (XINT (c), ptr);
+          int offset = ptr - buffer;
+          size = max (2 * size, size + nbytes);
+          buffer = alloca (size);
+          ptr = buffer + offset;
         }
-      else if (SYMBOLP (c))
-        {
-          Lisp_Object name = SYMBOL_NAME (c);
-          int nbytes = SBYTES (name);
 
-          if (size - (ptr - buffer) < nbytes)
-            {
-              int offset = ptr - buffer;
-              size = max (2 * size, size + nbytes);
-              buffer = alloca (size);
-              ptr = buffer + offset;
-            }
+      ptr += copy_text (SDATA (name), (unsigned char *) ptr, nbytes,
+                        STRING_MULTIBYTE (name), 1);
+    }
 
-          ptr += copy_text (SDATA (name), (unsigned char *) ptr, nbytes,
-                            STRING_MULTIBYTE (name), 1);
-        }
+  if ((NILP (echo_string) || SCHARS (echo_string) == 0)
+      && help_char_p (c))
+    {
+      const char *text = " (Type ? for further options)";
+      int len = strlen (text);
 
-      if ((NILP (echo_string) || SCHARS (echo_string) == 0)
-          && help_char_p (c))
+      if (size - (ptr - buffer) < len)
         {
-          const char *text = " (Type ? for further options)";
-          int len = strlen (text);
-
-          if (size - (ptr - buffer) < len)
-            {
-              int offset = ptr - buffer;
-              size += len;
-              buffer = alloca (size);
-              ptr = buffer + offset;
-            }
-
-          memcpy (ptr, text, len);
-          ptr += len;
+          int offset = ptr - buffer;
+          size += len;
+          buffer = alloca (size);
+          ptr = buffer + offset;
         }
 
-      /* Replace a dash from echo_dash with a space, otherwise
-         add a space at the end as a separator between keys.  */
-      if (STRINGP (echo_string)
-          && SCHARS (echo_string) > 1)
-        {
-          Lisp_Object last_char, prev_char, idx;
+      memcpy (ptr, text, len);
+      ptr += len;
+    }
 
-          idx = make_number (SCHARS (echo_string) - 2);
-          prev_char = Faref (echo_string, idx);
+  /* Replace a dash from echo_dash with a space, otherwise add a space
+     at the end as a separator between keys.  */
+  if (STRINGP (echo_string) && SCHARS (echo_string) > 1)
+    {
+      Lisp_Object last_char, prev_char, idx;
 
-          idx = make_number (SCHARS (echo_string) - 1);
-          last_char = Faref (echo_string, idx);
+      idx = make_number (SCHARS (echo_string) - 2);
+      prev_char = Faref (echo_string, idx);
 
-          /* We test PREV_CHAR to make sure this isn't the echoing
-             of a minus-sign.  */
-          if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
-            Faset (echo_string, idx, make_number (' '));
-          else
-            echo_string = concat2 (echo_string, build_string (" "));
-        }
-      else if (STRINGP (echo_string))
+      idx = make_number (SCHARS (echo_string) - 1);
+      last_char = Faref (echo_string, idx);
+
+      /* We test PREV_CHAR to make sure this isn't the echoing of a
+         minus-sign.  */
+      if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
+        Faset (echo_string, idx, make_number (' '));
+      else
         echo_string = concat2 (echo_string, build_string (" "));
+    }
+  else if (STRINGP (echo_string) && SCHARS (echo_string) > 0)
+    echo_string = concat2 (echo_string, build_string (" "));
 
-      kset_echo_string
-        (current_kboard,
-         concat2 (echo_string, make_string (buffer, ptr - buffer)));
+  kset_echo_string
+    (current_kboard,
+     concat2 (echo_string, make_string (buffer, ptr - buffer)));
+}
+
+/* Add C to the echo string, if echoing is going on.  C can be a
+   character or a symbol.  */
 
+static void
+echo_char (Lisp_Object c)
+{
+  if (current_kboard->immediate_echo)
+    {
+      echo_add_key (c);
       echo_now ();
     }
 }
 
 /* Temporarily add a dash to the end of the echo string if it's not
-   empty, so that it serves as a mini-prompt for the very next character.  */
+   empty, so that it serves as a mini-prompt for the very next
+   character.  */
 
 static void
 echo_dash (void)
@@ -9218,8 +9224,12 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
           key = keybuf[t];
           add_command_key (key);
           if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
-              && NILP (Fzerop (Vecho_keystrokes)))
-            echo_char (key);
+              && NILP (Fzerop (Vecho_keystrokes))
+              && current_kboard->immediate_echo)
+            {
+              echo_add_key (key);
+              echo_dash ();
+            }
         }
 
       /* If not, we should actually read a character.  */
@@ -10160,7 +10170,7 @@ DEFUN ("command-execute", Fcommand_execute, Scommand_execute, 1, 4, 0,
        doc: /* Execute CMD as an editor command.
 CMD must be a symbol that satisfies the `commandp' predicate.
 Optional second arg RECORD-FLAG non-nil
-means unconditionally put this command in `command-history'.
+means unconditionally put this command in the variable `command-history'.
 Otherwise, that is done only if an arg is read using the minibuffer.
 The argument KEYS specifies the value to use instead of (this-command-keys)
 when reading the arguments; if it is nil, (this-command-keys) is used.
@@ -12045,8 +12055,8 @@ This takes effect only when Transient Mark mode is enabled.  */);
                Vsaved_region_selection,
                doc: /* Contents of active region prior to buffer modification.
 If `select-active-regions' is non-nil, Emacs sets this to the
-text in the region before modifying the buffer.  The next
-`deactivate-mark' call uses this to set the window selection.  */);
+text in the region before modifying the buffer.  The next call to
+the function `deactivate-mark' uses this to set the window selection.  */);
   Vsaved_region_selection = Qnil;
 
   DEFVAR_LISP ("selection-inhibit-update-commands",
diff --git a/src/keymap.c b/src/keymap.c
index d1ddd55a358..a9266120e86 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -565,15 +565,13 @@ map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val)
 {
   if (!NILP (val))
     {
-      map_keymap_function_t fun
-        = (map_keymap_function_t) XSAVE_VALUE (XCAR (args))->pointer;
-      args = XCDR (args);
+      map_keymap_function_t fun = XSAVE_POINTER (args, 0);
       /* If the key is a range, make a copy since map_char_table modifies
          it in place.  */
       if (CONSP (key))
         key = Fcons (XCAR (key), XCDR (key));
-      map_keymap_item (fun, XCDR (args), key, val,
-                       XSAVE_VALUE (XCAR (args))->pointer);
+      map_keymap_item (fun, XSAVE_OBJECT (args, 2), key,
+                       val, XSAVE_POINTER (args, 1));
     }
 }
 
@@ -611,12 +609,8 @@ map_keymap_internal (Lisp_Object map,
             }
         }
       else if (CHAR_TABLE_P (binding))
-        {
-          map_char_table (map_keymap_char_table_item, Qnil, binding,
-                          Fcons (make_save_value ((void *) fun, 0),
-                                 Fcons (make_save_value (data, 0),
-                                        args)));
-        }
+        map_char_table (map_keymap_char_table_item, Qnil, binding,
+                        format_save_value ("ppo", fun, data, args));
     }
   UNGCPRO;
   return tail;
diff --git a/src/lisp.h b/src/lisp.h
index e96c9664743..9cebdef2b20 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1389,20 +1389,60 @@ struct Lisp_Overlay
     Lisp_Object plist;
   };
 
-/* Hold a C pointer for later use.
-   This type of object is used in the arg to record_unwind_protect.  */
+/* Types of data which may be saved in a Lisp_Save_Value.  */
+
+enum
+  {
+    SAVE_UNUSED,
+    SAVE_INTEGER,
+    SAVE_POINTER,
+    SAVE_OBJECT
+  };
+
+/* Special object used to hold a different values for later use.  */
+
 struct Lisp_Save_Value
   {
     ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Save_Value */
     unsigned gcmarkbit : 1;
-    int spacer : 14;
-    /* If DOGC is set, POINTER is the address of a memory
-       area containing INTEGER potential Lisp_Objects.  */
-    unsigned int dogc : 1;
-    void *pointer;
-    ptrdiff_t integer;
+    int spacer : 6;
+    /* If `area' is nonzero, `data[0].pointer' is the address of a memory area
+       containing `data[1].integer' potential Lisp_Objects.  The rest of `data'
+       fields are unused.  */
+    unsigned area : 1;
+    /* If `area' is zero, `data[N]' may hold different objects which type is
+       encoded in `typeN' fields as described by the anonymous enum above.
+       E.g. if `type0' is SAVE_INTEGER, `data[0].integer' is in use.  */
+    unsigned type0 : 2;
+    unsigned type1 : 2;
+    unsigned type2 : 2;
+    unsigned type3 : 2;
+    union {
+      void *pointer;
+      ptrdiff_t integer;
+      Lisp_Object object;
+    } data[4];
   };
 
+/* Macro to set and extract Nth saved pointer.  Type
+   checking is ugly because it's used as an lvalue.  */
+
+#define XSAVE_POINTER(obj, n)                                   \
+  XSAVE_VALUE (obj)->data[(eassert (XSAVE_VALUE (obj)->type     \
+    ## n == SAVE_POINTER), n)].pointer
+
+/* Likewise for the saved integer.  */
+
+#define XSAVE_INTEGER(obj, n)                                   \
+  XSAVE_VALUE (obj)->data[(eassert (XSAVE_VALUE (obj)->type     \
+    ## n == SAVE_INTEGER), n)].integer
+
+/* Macro to extract Nth saved object.  This is never used as
+   an lvalue, so we can do more convenient type checking.  */
+
+#define XSAVE_OBJECT(obj, n)                                    \
+  (eassert (XSAVE_VALUE (obj)->type ## n == SAVE_OBJECT),       \
+   XSAVE_VALUE (obj)->data[n].object)
 
 /* A miscellaneous object, when it's on the free list.  */
 struct Lisp_Free
@@ -1461,7 +1501,8 @@ struct Lisp_Buffer_Objfwd
   {
     enum Lisp_Fwd_Type type;    /* = Lisp_Fwd_Buffer_Obj */
     int offset;
-    Lisp_Object slottype; /* Qnil, Lisp_Int, Lisp_Symbol, or Lisp_String.  */
+    /* One of Qnil, Qintegerp, Qsymbolp, Qstringp, Qfloatp or Qnumberp.  */
+    Lisp_Object predicate;
   };
 
 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
@@ -2231,8 +2272,12 @@ struct gcpro
    2    Mark the stack, and check that everything GCPRO'd is
         marked.
    3    Mark using GCPRO's, mark stack last, and count how many
-        dead objects are kept alive.  */
+        dead objects are kept alive.
 
+   Formerly, method 0 was used.  Currently, method 1 is used unless
+   otherwise specified by hand when building, e.g.,
+   "make CPPFLAGS='-DGC_MARK_STACK=GC_USE_GCPROS_AS_BEFORE'".
+   Methods 2 and 3 are present mainly to debug the transition from 0 to 1.  */
 
 #define GC_USE_GCPROS_AS_BEFORE         0
 #define GC_MAKE_GCPROS_NOOPS            1
@@ -2788,10 +2833,10 @@ extern void syms_of_image (void);
 
 /* Defined in insdel.c.  */
 extern Lisp_Object Qinhibit_modification_hooks;
-extern void move_gap (ptrdiff_t);
 extern void move_gap_both (ptrdiff_t, ptrdiff_t);
 extern _Noreturn void buffer_overflow (void);
 extern void make_gap (ptrdiff_t);
+extern void make_gap_1 (struct buffer *, ptrdiff_t);
 extern ptrdiff_t copy_text (const unsigned char *, unsigned char *,
                             ptrdiff_t, bool, bool);
 extern int count_combining_before (const unsigned char *,
@@ -2902,6 +2947,7 @@ extern void memory_warnings (void *, void (*warnfun) (const char *));
 
 /* Defined in alloc.c.  */
 extern void check_pure_size (void);
+extern void free_misc (Lisp_Object);
 extern void allocate_string_data (struct Lisp_String *, EMACS_INT, EMACS_INT);
 extern void malloc_warning (const char *);
 extern _Noreturn void memory_full (size_t);
@@ -2989,8 +3035,8 @@ extern bool abort_on_gc;
 extern Lisp_Object make_float (double);
 extern void display_malloc_warning (void);
 extern ptrdiff_t inhibit_garbage_collection (void);
+extern Lisp_Object format_save_value (const char *, ...);
 extern Lisp_Object make_save_value (void *, ptrdiff_t);
-extern void free_save_value (Lisp_Object);
 extern Lisp_Object build_overlay (Lisp_Object, Lisp_Object, Lisp_Object);
 extern void free_marker (Lisp_Object);
 extern void free_cons (struct Lisp_Cons *);
@@ -3479,6 +3525,8 @@ extern void init_sigio (int);
 extern void sys_subshell (void);
 extern void sys_suspend (void);
 extern void discard_tty_input (void);
+extern void block_tty_out_signal (void);
+extern void unblock_tty_out_signal (void);
 extern void init_sys_modes (struct tty_display_info *);
 extern void reset_sys_modes (struct tty_display_info *);
 extern void init_all_sys_modes (void);
@@ -3707,7 +3755,7 @@ extern void *record_xmalloc (size_t);
         Lisp_Object arg_;                                      \
         buf = xmalloc ((nelt) * word_size);                    \
         arg_ = make_save_value (buf, nelt);                    \
-        XSAVE_VALUE (arg_)->dogc = 1;                          \
+        XSAVE_VALUE (arg_)->area = 1;                          \
         sa_must_free = 1;                                      \
         record_unwind_protect (safe_alloca_unwind, arg_);      \
       }                                                        \
diff --git a/src/lread.c b/src/lread.c
index 2b96dc16359..a01cf099b49 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1357,7 +1357,7 @@ Return t if the file exists and loads successfully.  */)
 static Lisp_Object
 load_unwind (Lisp_Object arg)  /* Used as unwind-protect function in load.  */
 {
-  FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
+  FILE *stream = XSAVE_POINTER (arg, 0);
   if (stream != NULL)
     {
       block_input ();
diff --git a/src/nsfns.m b/src/nsfns.m
index 1750eb62cdf..fac61d2ab53 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -1503,12 +1503,12 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
   [panel setDelegate: fileDelegate];
 
   panelOK = 0;
-  if (! NILP (dir_only_p)) 
+  if (! NILP (dir_only_p))
     {
       [panel setCanChooseDirectories: YES];
       [panel setCanChooseFiles: NO];
     }
-  
+
   block_input ();
 #if defined (NS_IMPL_COCOA) && \
   MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
@@ -1519,7 +1519,7 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
     [panel setNameFieldStringValue: [initS lastPathComponent]];
   else
     [panel setNameFieldStringValue: @""];
-    
+
   ret = [panel runModal];
 #else
   if (NILP (mustmatch) && NILP (dir_only_p))
@@ -2147,7 +2147,7 @@ In case the execution fails, an error is signaled. */)
   [NSApp postEvent: nxev atStart: NO];
 
   // If there are other events, the event loop may exit.  Keep running
-  // until the script has been handeled.  */
+  // until the script has been handled.  */
   while (! NILP (as_script))
     [NSApp run];
 
diff --git a/src/nsfont.m b/src/nsfont.m
index c0bea2e225c..5039f0c9013 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -44,6 +44,7 @@ Author: Adrian Robert (arobert@cogsci.ucsd.edu)
 #endif
 
 #define NSFONT_TRACE 0
+#define LCD_SMOOTHING_MARGIN 2
 
 extern Lisp_Object Qns;
 extern Lisp_Object Qnormal, Qbold, Qitalic;
@@ -546,6 +547,7 @@ ns_findfonts (Lisp_Object font_spec, BOOL isMatch)
     NSSet *cFamilies;
     BOOL foundItal = NO;
 
+    block_input ();
     if (NSFONT_TRACE)
       {
         fprintf (stderr, "nsfont: %s for fontspec:\n    ",
@@ -560,10 +562,7 @@ ns_findfonts (Lisp_Object font_spec, BOOL isMatch)
     if (isMatch)
         [fkeys removeObject: NSFontFamilyAttribute];
 
-    if ([fkeys count] > 0)
-      matchingDescs = [fdesc matchingFontDescriptorsWithMandatoryKeys: fkeys];
-    else
-      matchingDescs = [NSMutableArray array];
+    matchingDescs = [fdesc matchingFontDescriptorsWithMandatoryKeys: fkeys];
 
     if (NSFONT_TRACE)
         NSLog(@"Got desc %@ and found %d matching fonts from it: ", fdesc,
@@ -598,6 +597,8 @@ ns_findfonts (Lisp_Object font_spec, BOOL isMatch)
         [s1 release];
       }
 
+    unblock_input ();
+
     /* Return something if was a match and nothing found. */
     if (isMatch)
       return ns_fallback_entity ();
@@ -701,10 +702,12 @@ static Lisp_Object
 nsfont_list_family (Lisp_Object frame)
 {
   Lisp_Object list = Qnil;
-  NSEnumerator *families =
-    [[[NSFontManager sharedFontManager] availableFontFamilies]
-      objectEnumerator];
+  NSEnumerator *families;
   NSString *family;
+
+  block_input ();
+  families = [[[NSFontManager sharedFontManager] availableFontFamilies]
+               objectEnumerator];
   while ((family = [families nextObject]))
       list = Fcons (intern ([family UTF8String]), list);
   /* FIXME: escape the name? */
@@ -713,6 +716,7 @@ nsfont_list_family (Lisp_Object frame)
     fprintf (stderr, "nsfont: list families returning %"pI"d entries\n",
              XINT (Flength (list)));
 
+  unblock_input ();
   return list;
 }
 
@@ -735,6 +739,8 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
   Lisp_Object font_object;
   int fixLeopardBug;
 
+  block_input ();
+
   if (NSFONT_TRACE)
     {
       fprintf (stderr, "nsfont: open size %d of fontentity:\n    ", pixel_size);
@@ -794,13 +800,14 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
   font_info = (struct nsfont_info *) XFONT_OBJECT (font_object);
   font = (struct font *) font_info;
   if (!font)
-    return Qnil; /* FIXME: other terms do, but return Qnil causes segfault */
+    {
+      unblock_input ();
+      return Qnil; /* FIXME: other terms do, but return Qnil causes segfault */
+    }
 
   font_info->glyphs = xzalloc (0x100 * sizeof *font_info->glyphs);
   font_info->metrics = xzalloc (0x100 * sizeof *font_info->metrics);
 
-  block_input ();
-
   /* for metrics */
 #ifdef NS_IMPL_COCOA
   sfont = [nsfont screenFontWithRenderingMode:
@@ -1051,6 +1058,7 @@ nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
   char isComposite = s->first_glyph->type == COMPOSITE_GLYPH;
   int end = isComposite ? s->cmp_to : s->nchars;
 
+  block_input ();
   /* Select face based on input flags */
   switch (ns_tmp_flags)
     {
@@ -1240,7 +1248,6 @@ nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
     else
       CGContextSetShouldAntialias (gcontext, 1);
 
-    CGContextSetShouldSmoothFonts (gcontext, NO);
     CGContextSetTextMatrix (gcontext, fliptf);
 
     if (bgCol != nil)
@@ -1273,6 +1280,7 @@ nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
   /* Draw underline, overline, strike-through. */
   ns_draw_text_decoration (s, face, col, r.size.width, r.origin.x);
 
+  unblock_input ();
   return to-from;
 }
 
@@ -1406,11 +1414,12 @@ ns_glyph_metrics (struct nsfont_info *font_info, unsigned char block)
 
       lb = r.origin.x;
       rb = r.size.width - w;
+      // Add to bearing for LCD smoothing.  We don't know if it is there.
       if (lb < 0)
-        metrics->lbearing = round (lb);
+        metrics->lbearing = round (lb - LCD_SMOOTHING_MARGIN);
       if (font_info->ital)
         rb += 0.22 * font_info->height;
-      metrics->rbearing = lrint (w + rb);
+      metrics->rbearing = lrint (w + rb + LCD_SMOOTHING_MARGIN);
 
       metrics->descent = r.origin.y < 0 ? -r.origin.y : 0;
  /*lrint (hshrink * [sfont ascender] + expand * hd/2); */
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 39797d414f0..b0369e76a27 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -1347,8 +1347,7 @@ struct Popdown_data
 static Lisp_Object
 pop_down_menu (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  struct Popdown_data *unwind_data = (struct Popdown_data *) p->pointer;
+  struct Popdown_data *unwind_data = XSAVE_POINTER (arg, 0);
 
   block_input ();
   if (popup_activated_flag)
diff --git a/src/nsterm.h b/src/nsterm.h
index e58b8493c94..0cf4aa60d08 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -675,9 +675,9 @@ struct x_output
 #define FRAME_FONT(f) ((f)->output_data.ns->font)
 
 #ifdef __OBJC__
-#define XNS_SCROLL_BAR(vec) ((id) XSAVE_VALUE (vec)->pointer)
+#define XNS_SCROLL_BAR(vec) ((id) XSAVE_POINTER (vec, 0))
 #else
-#define XNS_SCROLL_BAR(vec) XSAVE_VALUE (vec)->pointer
+#define XNS_SCROLL_BAR(vec) XSAVE_POINTER (vec, 0)
 #endif
 
 /* Compute pixel size for vertical scroll bars */
diff --git a/src/nsterm.m b/src/nsterm.m
index 0fd062b7f17..48efac3f70b 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -4981,6 +4981,7 @@ not_in_argv (NSString *arg)
 
           emacs_event->code = code;
           EV_TRAILER (theEvent);
+          processingCompose = NO;
           return;
         }
     }
@@ -5171,6 +5172,7 @@ not_in_argv (NSString *arg)
   if (NS_KEYLOG)
     NSLog (@"doCommandBySelector: %@", NSStringFromSelector (aSelector));
 
+  processingCompose = NO;
   if (aSelector == @selector (deleteBackward:))
     {
       /* happens when user backspaces over an ongoing composition:
diff --git a/src/print.c b/src/print.c
index 2ffe7def396..62009e17686 100644
--- a/src/print.c
+++ b/src/print.c
@@ -2063,8 +2063,9 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           PRINTCHAR ('>');
           break;
 
-      /* Remaining cases shouldn't happen in normal usage, but let's print
-         them anyway for the benefit of the debugger.  */
+          /* Remaining cases shouldn't happen in normal usage, but let's
+             print them anyway for the benefit of the debugger.  */
+
         case Lisp_Misc_Free:
           strout ("#<misc free cell>", -1, -1, printcharfun);
           break;
@@ -2075,20 +2076,28 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
             struct Lisp_Save_Value *v = XSAVE_VALUE (obj);
 
             strout ("#<save-value ", -1, -1, printcharfun);
-            if (v->dogc)
+
+            if (v->area)
               {
-                int lim = min (v->integer, 8);
-                
-                /* Try to print up to 8 objects we have saved.  Although
-                   valid_lisp_object_p is slow, this shouldn't be a real
-                   bottleneck because such a saved values are quite rare.  */
+                ptrdiff_t amount = v->data[1].integer;
+
+#if GC_MARK_STACK
+
+                /* If GC_MARK_STACK, valid_lisp_object_p is quite reliable,
+                   and so we try to print up to 8 objects we have saved.
+                   Although valid_lisp_object_p is slow, this shouldn't be
+                   a real bottleneck because we do not use this code under
+                   normal circumstances.  */
 
-                i = sprintf (buf, "with %"pD"d objects", v->integer);
+                int limit = min (amount, 8);
+                Lisp_Object *area = v->data[0].pointer;
+
+                i = sprintf (buf, "with %"pD"d objects", amount);
                 strout (buf, i, i, printcharfun);
 
-                for (i = 0; i < lim; i++)
+                for (i = 0; i < limit; i++)
                   {
-                    Lisp_Object maybe = ((Lisp_Object *) v->pointer)[i];
+                    Lisp_Object maybe = area[i];
 
                     if (valid_lisp_object_p (maybe) > 0)
                       {
@@ -2098,13 +2107,49 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                     else
                       strout (" <invalid>", -1, -1, printcharfun);
                   }
-                if (i == lim && i < v->integer)
+                if (i == limit && i < amount)
                   strout (" ...", 4, 4, printcharfun);
+
+#else /* not GC_MARK_STACK */
+
+                /* If !GC_MARK_STACK, we have no reliable way to find
+                   whether Lisp_Object pointers points to an initialized
+                   objects, and so we do not ever trying to print them.  */
+
+                i = sprintf (buf, "with %"pD"d objects", amount);
+                strout (buf, i, i, printcharfun);
+
+#endif /* GC_MARK_STACK */
               }
             else
               {
-                i = sprintf (buf, "ptr=%p int=%"pD"d", v->pointer, v->integer);
-                strout (buf, i, i, printcharfun);
+                /* Print each `data[N]' slot according to its type.  */
+
+#define PRINTX(index)                                                   \
+  do {                                                                  \
+    i = 0;                                                              \
+    if (v->type ## index == SAVE_UNUSED)                                \
+      i = sprintf (buf, "<unused>");                                    \
+    else if (v->type ## index == SAVE_INTEGER)                          \
+      i = sprintf (buf, "<integer %"pD"d>", v->data[index].integer);    \
+    else if (v->type ## index == SAVE_POINTER)                          \
+      i = sprintf (buf, "<pointer %p>", v->data[index].pointer);        \
+    else /* SAVE_OBJECT */                                              \
+      print_object (v->data[index].object, printcharfun, escapeflag);   \
+    if (i)                                                              \
+      strout (buf, i, i, printcharfun);                                 \
+  } while (0)
+
+                PRINTX (0);
+                PRINTCHAR (' ');
+                PRINTX (1);
+                PRINTCHAR (' ');
+                PRINTX (2);
+                PRINTCHAR (' ');
+                PRINTX (3);
+
+#undef PRINTX
+
               }
             PRINTCHAR ('>');
           }
diff --git a/src/sysdep.c b/src/sysdep.c
index 049eb85afe5..0e9a6826005 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -714,6 +714,27 @@ init_foreground_group (void)
   inherited_pgroup = getpid () == pgrp ? 0 : pgrp;
 }
 
+/* Block and unblock SIGTTOU.  */
+
+void
+block_tty_out_signal (void)
+{
+#ifdef SIGTTOU
+  sigset_t blocked;
+  sigemptyset (&blocked);
+  sigaddset (&blocked, SIGTTOU);
+  pthread_sigmask (SIG_BLOCK, &blocked, 0);
+#endif
+}
+
+void
+unblock_tty_out_signal (void)
+{
+#ifdef SIGTTOU
+  pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
+#endif
+}
+
 /* Safely set a controlling terminal FD's process group to PGID.
    If we are not in the foreground already, POSIX requires tcsetpgrp
    to deliver a SIGTTOU signal, which would stop us.  This is an
@@ -725,11 +746,10 @@ static void
 tcsetpgrp_without_stopping (int fd, pid_t pgid)
 {
 #ifdef SIGTTOU
-  signal_handler_t handler;
   block_input ();
-  handler = signal (SIGTTOU, SIG_IGN);
+  block_tty_out_signal ();
   tcsetpgrp (fd, pgid);
-  signal (SIGTTOU, handler);
+  unblock_tty_out_signal ();
   unblock_input ();
 #endif
 }
@@ -1658,6 +1678,25 @@ deliver_arith_signal (int sig)
   deliver_thread_signal (sig, handle_arith_signal);
 }
 
+#ifdef SIGDANGER
+
+/* Handler for SIGDANGER.  */
+static void
+handle_danger_signal (int sig)
+{
+  malloc_warning ("Operating system warns that virtual memory is running low.\n");
+
+  /* It might be unsafe to call do_auto_save now.  */
+  force_auto_save_soon ();
+}
+
+static void
+deliver_danger_signal (int sig)
+{
+  deliver_process_signal (sig, handle_danger_signal);
+}
+#endif
+
 /* Treat SIG as a terminating signal, unless it is already ignored and
    we are in --batch mode.  Among other things, this makes nohup work.  */
 static void
diff --git a/src/term.c b/src/term.c
index d76562bb4db..f66a0bddc33 100644
--- a/src/term.c
+++ b/src/term.c
@@ -2423,7 +2423,7 @@ frame's terminal). */)
       if (fd == -1)
         error ("Can not reopen tty device %s: %s", t->display_info.tty->name, strerror (errno));
 
-      if (strcmp (t->display_info.tty->name, DEV_TTY))
+      if (!O_IGNORE_CTTY && strcmp (t->display_info.tty->name, DEV_TTY) != 0)
         dissociate_if_controlling_tty (fd);
 
       t->display_info.tty->output = fdopen (fd, "w+");
@@ -2903,13 +2903,23 @@ set_tty_hooks (struct terminal *terminal)
   terminal->delete_terminal_hook = &delete_tty;
 }
 
-/* Drop the controlling terminal if fd is the same device. */
+/* If FD is the controlling terminal, drop it.  */
 static void
 dissociate_if_controlling_tty (int fd)
 {
-  pid_t pgid = tcgetpgrp (fd); /* If tcgetpgrp succeeds, fd is the ctty. */
-  if (0 <= pgid)
-    setsid ();
+  /* If tcgetpgrp succeeds, fd is the controlling terminal,
+     so dissociate it by invoking setsid.  */
+  if (0 <= tcgetpgrp (fd) && setsid () < 0)
+    {
+#ifdef TIOCNOTTY
+      /* setsid failed, presumably because Emacs is already a process
+         group leader.  Fall back on the obsolescent way to dissociate
+         a controlling tty.  */
+      block_tty_out_signal ();
+      ioctl (fd, TIOCNOTTY, 0);
+      unblock_tty_out_signal ();
+#endif
+    }
 }
 
 /* Create a termcap display on the tty device with the given name and
@@ -3030,14 +3040,9 @@ init_tty (const char *name, const char *terminal_type, int must_succeed)
 
   /* On some systems, tgetent tries to access the controlling
      terminal. */
-  {
-    sigset_t blocked;
-    sigemptyset (&blocked);
-    sigaddset (&blocked, SIGTTOU);
-    pthread_sigmask (SIG_BLOCK, &blocked, 0);
-    status = tgetent (tty->termcap_term_buffer, terminal_type);
-    pthread_sigmask (SIG_UNBLOCK, &blocked, 0);
-  }
+  block_tty_out_signal ();
+  status = tgetent (tty->termcap_term_buffer, terminal_type);
+  unblock_tty_out_signal ();
 
   if (status < 0)
     {
diff --git a/src/undo.c b/src/undo.c
index 2626fd4ccfe..63edc8e9b8d 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -452,217 +452,6 @@ user_error (const char *msg)
 }
 
 
-DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
-       doc: /* Undo N records from the front of the list LIST.
-Return what remains of the list.  */)
-  (Lisp_Object n, Lisp_Object list)
-{
-  struct gcpro gcpro1, gcpro2;
-  Lisp_Object next;
-  ptrdiff_t count = SPECPDL_INDEX ();
-  register EMACS_INT arg;
-  Lisp_Object oldlist;
-  int did_apply = 0;
-
-#if 0  /* This is a good feature, but would make undo-start
-          unable to do what is expected.  */
-  Lisp_Object tem;
-
-  /* If the head of the list is a boundary, it is the boundary
-     preceding this command.  Get rid of it and don't count it.  */
-  tem = Fcar (list);
-  if (NILP (tem))
-    list = Fcdr (list);
-#endif
-
-  CHECK_NUMBER (n);
-  arg = XINT (n);
-  next = Qnil;
-  GCPRO2 (next, list);
-  /* I don't think we need to gcpro oldlist, as we use it only
-     to check for EQ.  ++kfs  */
-
-  /* In a writable buffer, enable undoing read-only text that is so
-     because of text properties.  */
-  if (NILP (BVAR (current_buffer, read_only)))
-    specbind (Qinhibit_read_only, Qt);
-
-  /* Don't let `intangible' properties interfere with undo.  */
-  specbind (Qinhibit_point_motion_hooks, Qt);
-
-  oldlist = BVAR (current_buffer, undo_list);
-
-  while (arg > 0)
-    {
-      while (CONSP (list))
-        {
-          next = XCAR (list);
-          list = XCDR (list);
-          /* Exit inner loop at undo boundary.  */
-          if (NILP (next))
-            break;
-          /* Handle an integer by setting point to that value.  */
-          if (INTEGERP (next))
-            SET_PT (clip_to_bounds (BEGV, XINT (next), ZV));
-          else if (CONSP (next))
-            {
-              Lisp_Object car, cdr;
-
-              car = XCAR (next);
-              cdr = XCDR (next);
-              if (EQ (car, Qt))
-                {
-                  /* Element (t . TIME) records previous modtime.
-                     Preserve any flag of NONEXISTENT_MODTIME_NSECS or
-                     UNKNOWN_MODTIME_NSECS.  */
-                  struct buffer *base_buffer = current_buffer;
-                  EMACS_TIME mod_time;
-
-                  if (CONSP (cdr)
-                      && CONSP (XCDR (cdr))
-                      && CONSP (XCDR (XCDR (cdr)))
-                      && CONSP (XCDR (XCDR (XCDR (cdr))))
-                      && INTEGERP (XCAR (XCDR (XCDR (XCDR (cdr)))))
-                      && XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) < 0)
-                    mod_time =
-                      (make_emacs_time
-                       (0, XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) / 1000));
-                  else
-                    mod_time = lisp_time_argument (cdr);
-
-                  if (current_buffer->base_buffer)
-                    base_buffer = current_buffer->base_buffer;
-
-                  /* If this records an obsolete save
-                     (not matching the actual disk file)
-                     then don't mark unmodified.  */
-                  if (EMACS_TIME_NE (mod_time, base_buffer->modtime))
-                    continue;
-#ifdef CLASH_DETECTION
-                  Funlock_buffer ();
-#endif /* CLASH_DETECTION */
-                  Fset_buffer_modified_p (Qnil);
-                }
-              else if (EQ (car, Qnil))
-                {
-                  /* Element (nil PROP VAL BEG . END) is property change.  */
-                  Lisp_Object beg, end, prop, val;
-
-                  prop = Fcar (cdr);
-                  cdr = Fcdr (cdr);
-                  val = Fcar (cdr);
-                  cdr = Fcdr (cdr);
-                  beg = Fcar (cdr);
-                  end = Fcdr (cdr);
-
-                  if (XINT (beg) < BEGV || XINT (end) > ZV)
-                    user_error ("Changes to be undone are outside visible portion of buffer");
-                  Fput_text_property (beg, end, prop, val, Qnil);
-                }
-              else if (INTEGERP (car) && INTEGERP (cdr))
-                {
-                  /* Element (BEG . END) means range was inserted.  */
-
-                  if (XINT (car) < BEGV
-                      || XINT (cdr) > ZV)
-                    user_error ("Changes to be undone are outside visible portion of buffer");
-                  /* Set point first thing, so that undoing this undo
-                     does not send point back to where it is now.  */
-                  Fgoto_char (car);
-                  Fdelete_region (car, cdr);
-                }
-              else if (EQ (car, Qapply))
-                {
-                  /* Element (apply FUN . ARGS) means call FUN to undo.  */
-                  struct buffer *save_buffer = current_buffer;
-
-                  car = Fcar (cdr);
-                  cdr = Fcdr (cdr);
-                  if (INTEGERP (car))
-                    {
-                      /* Long format: (apply DELTA START END FUN . ARGS).  */
-                      Lisp_Object delta = car;
-                      Lisp_Object start = Fcar (cdr);
-                      Lisp_Object end   = Fcar (Fcdr (cdr));
-                      Lisp_Object start_mark = Fcopy_marker (start, Qnil);
-                      Lisp_Object end_mark   = Fcopy_marker (end, Qt);
-
-                      cdr = Fcdr (Fcdr (cdr));
-                      apply1 (Fcar (cdr), Fcdr (cdr));
-
-                      /* Check that the function did what the entry said it
-                         would do.  */
-                      if (!EQ (start, Fmarker_position (start_mark))
-                          || (XINT (delta) + XINT (end)
-                              != marker_position (end_mark)))
-                        error ("Changes to be undone by function different than announced");
-                      Fset_marker (start_mark, Qnil, Qnil);
-                      Fset_marker (end_mark, Qnil, Qnil);
-                    }
-                  else
-                    apply1 (car, cdr);
-
-                  if (save_buffer != current_buffer)
-                    error ("Undo function switched buffer");
-                  did_apply = 1;
-                }
-              else if (STRINGP (car) && INTEGERP (cdr))
-                {
-                  /* Element (STRING . POS) means STRING was deleted.  */
-                  Lisp_Object membuf;
-                  EMACS_INT pos = XINT (cdr);
-
-                  membuf = car;
-                  if (pos < 0)
-                    {
-                      if (-pos < BEGV || -pos > ZV)
-                        user_error ("Changes to be undone are outside visible portion of buffer");
-                      SET_PT (-pos);
-                      Finsert (1, &membuf);
-                    }
-                  else
-                    {
-                      if (pos < BEGV || pos > ZV)
-                        user_error ("Changes to be undone are outside visible portion of buffer");
-                      SET_PT (pos);
-
-                      /* Now that we record marker adjustments
-                         (caused by deletion) for undo,
-                         we should always insert after markers,
-                         so that undoing the marker adjustments
-                         put the markers back in the right place.  */
-                      Finsert (1, &membuf);
-                      SET_PT (pos);
-                    }
-                }
-              else if (MARKERP (car) && INTEGERP (cdr))
-                {
-                  /* (MARKER . INTEGER) means a marker MARKER
-                     was adjusted by INTEGER.  */
-                  if (XMARKER (car)->buffer)
-                    Fset_marker (car,
-                                 make_number (marker_position (car) - XINT (cdr)),
-                                 Fmarker_buffer (car));
-                }
-            }
-        }
-      arg--;
-    }
-
-
-  /* Make sure an apply entry produces at least one undo entry,
-     so the test in `undo' for continuing an undo series
-     will work right.  */
-  if (did_apply
-      && EQ (oldlist, BVAR (current_buffer, undo_list)))
-    bset_undo_list
-      (current_buffer,
-       Fcons (list3 (Qapply, Qcdr, Qnil), BVAR (current_buffer, undo_list)));
-
-  UNGCPRO;
-  return unbind_to (count, list);
-}
-
 void
 syms_of_undo (void)
 {
@@ -675,7 +464,6 @@ syms_of_undo (void)
   last_undo_buffer = NULL;
   last_boundary_buffer = NULL;
 
-  defsubr (&Sprimitive_undo);
   defsubr (&Sundo_boundary);
 
   DEFVAR_INT ("undo-limit", undo_limit,
diff --git a/src/w32.c b/src/w32.c
index 55581a17de5..812003e96c0 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -3648,7 +3648,6 @@ static int
 get_name_and_id (PSECURITY_DESCRIPTOR psd, unsigned *id, char *nm, int what)
 {
   PSID sid = NULL;
-  char machine[MAX_COMPUTERNAME_LENGTH+1];
   BOOL dflt;
   SID_NAME_USE ignore;
   char name[UNLEN+1];
@@ -4800,7 +4799,6 @@ acl_set_file (const char *fname, acl_type_t type, acl_t acl)
 {
   TOKEN_PRIVILEGES old1, old2;
   DWORD err;
-  BOOL res;
   int st = 0, retval = -1;
   SECURITY_INFORMATION flags = 0;
   PSID psid;
diff --git a/src/w32term.c b/src/w32term.c
index 36ae4d7797f..16c7bd415a5 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -5652,7 +5652,7 @@ x_check_fullscreen (struct frame *f)
 static void
 w32fullscreen_hook (FRAME_PTR f)
 {
-  static int normal_width, normal_height, normal_top, normal_left;
+  static int normal_width, normal_height;
 
   if (f->async_visible)
     {
diff --git a/src/window.c b/src/window.c
index 71d8eb7f778..32a6759f9f4 100644
--- a/src/window.c
+++ b/src/window.c
@@ -1436,7 +1436,7 @@ window were selected.
 
 Note that, when WINDOW is selected, the value returned is the same as
 that returned by `point' for WINDOW's buffer.  It would be more strictly
-correct to return the `top-level' value of `point', outside of any
+correct to return the top-level value of `point', outside of any
 `save-excursion' forms.  But that is hard to define.  */)
   (Lisp_Object window)
 {
@@ -6793,7 +6793,8 @@ same combination.
 
 Other values are reserved for future use.
 
-This variable takes no effect if `window-combination-limit' is non-nil.  */);
+This variable takes no effect if the variable `window-combination-limit' is
+non-nil.  */);
   Vwindow_combination_resize = Qnil;
 
   DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit,
diff --git a/src/xfaces.c b/src/xfaces.c
index ed2895c014c..43535b9ea0c 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -4877,6 +4877,8 @@ tty_supports_face_attributes_p (struct frame *f,
     {
       if (STRINGP (val))
         return 0;               /* ttys can't use colored underlines */
+      else if (EQ (CAR_SAFE (val), QCstyle) && EQ (CAR_SAFE (CDR_SAFE (val)), Qwave))
+        return 0;               /* ttys can't use wave underlines */
       else if (face_attr_equal_p (val, def_attrs[LFACE_UNDERLINE_INDEX]))
         return 0;               /* same as default */
       else
diff --git a/src/xfns.c b/src/xfns.c
index 315d5093716..65148d1c9e1 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -5292,8 +5292,7 @@ file_dialog_unmap_cb (Widget widget, XtPointer client_data, XtPointer call_data)
 static Lisp_Object
 clean_up_file_dialog (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  Widget dialog = (Widget) p->pointer;
+  Widget dialog = XSAVE_POINTER (arg, 0);
 
   /* Clean up.  */
   block_input ();
diff --git a/src/xmenu.c b/src/xmenu.c
index 3d76070c336..7f6914d26ac 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -1411,11 +1411,9 @@ popup_selection_callback (GtkWidget *widget, gpointer client_data)
 static Lisp_Object
 pop_down_menu (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-
   popup_activated_flag = 0;
   block_input ();
-  gtk_widget_destroy (GTK_WIDGET (p->pointer));
+  gtk_widget_destroy (GTK_WIDGET (XSAVE_POINTER (arg, 0)));
   unblock_input ();
   return Qnil;
 }
@@ -1612,11 +1610,7 @@ create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv,
 static Lisp_Object
 cleanup_widget_value_tree (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  widget_value *wv = p->pointer;
-
-  free_menubar_widget_value_tree (wv);
-
+  free_menubar_widget_value_tree (XSAVE_POINTER (arg, 0));
   return Qnil;
 }
 
@@ -2242,11 +2236,8 @@ menu_help_callback (char const *help_string, int pane, int item)
 static Lisp_Object
 pop_down_menu (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p1 = XSAVE_VALUE (Fcar (arg));
-  struct Lisp_Save_Value *p2 = XSAVE_VALUE (Fcdr (arg));
-
-  FRAME_PTR f = p1->pointer;
-  XMenu *menu = p2->pointer;
+  FRAME_PTR f = XSAVE_POINTER (arg, 0);
+  XMenu *menu = XSAVE_POINTER (arg, 1);
 
   block_input ();
 #ifndef MSDOS
@@ -2488,8 +2479,7 @@ xmenu_show (FRAME_PTR f, int x, int y, bool for_click, bool keymaps,
 #endif
 
   record_unwind_protect (pop_down_menu,
-                         Fcons (make_save_value (f, 0),
-                                make_save_value (menu, 0)));
+                         format_save_value ("pp", f, menu));
 
   /* Help display under X won't work because XMenuActivate contains
      a loop that doesn't give Emacs a chance to process it.  */
diff --git a/src/xml.c b/src/xml.c
index 5939c58a564..5a52b0c2a1e 100644
--- a/src/xml.c
+++ b/src/xml.c
@@ -180,8 +180,7 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
   xmlDoc *doc;
   Lisp_Object result = Qnil;
   const char *burl = "";
-  ptrdiff_t bytes;
-  ptrdiff_t istart, iend;
+  ptrdiff_t istart, iend, istart_byte, iend_byte;
 
   fn_xmlCheckVersion (LIBXML_VERSION);
 
@@ -189,9 +188,11 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
 
   istart = XINT (start);
   iend = XINT (end);
+  istart_byte = CHAR_TO_BYTE (istart);
+  iend_byte = CHAR_TO_BYTE (iend);
 
   if (istart < GPT && GPT < iend)
-    move_gap (iend);
+    move_gap_both (iend, iend_byte);
 
   if (! NILP (base_url))
     {
@@ -199,17 +200,15 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
       burl = SSDATA (base_url);
     }
 
-  bytes = CHAR_TO_BYTE (iend) - CHAR_TO_BYTE (istart);
-
   if (htmlp)
-    doc = fn_htmlReadMemory ((char *) BYTE_POS_ADDR (CHAR_TO_BYTE (istart)),
-                             bytes, burl, "utf-8",
+    doc = fn_htmlReadMemory ((char *) BYTE_POS_ADDR (istart_byte),
+                             iend_byte - istart_byte, burl, "utf-8",
                              HTML_PARSE_RECOVER|HTML_PARSE_NONET|
                              HTML_PARSE_NOWARNING|HTML_PARSE_NOERROR|
                              HTML_PARSE_NOBLANKS);
   else
-    doc = fn_xmlReadMemory ((char *) BYTE_POS_ADDR (CHAR_TO_BYTE (istart)),
-                            bytes, burl, "utf-8",
+    doc = fn_xmlReadMemory ((char *) BYTE_POS_ADDR (istart_byte),
+                            iend_byte - istart_byte, burl, "utf-8",
                             XML_PARSE_NONET|XML_PARSE_NOWARNING|
                             XML_PARSE_NOBLANKS |XML_PARSE_NOERROR);
 
diff --git a/src/xselect.c b/src/xselect.c
index f43efab827b..b7cdf70ff77 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1120,7 +1120,7 @@ unexpect_property_change (struct prop_location *location)
 static Lisp_Object
 wait_for_property_change_unwind (Lisp_Object loc)
 {
-  struct prop_location *location = XSAVE_VALUE (loc)->pointer;
+  struct prop_location *location = XSAVE_POINTER (loc, 0);
 
   unexpect_property_change (location);
   if (location == property_change_reply_object)
diff --git a/src/xterm.c b/src/xterm.c
index f63f10566f6..26d40859ed3 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -4802,21 +4802,24 @@ x_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar, int portion, int positio
 
 #ifdef USE_MOTIF
 
-  /* We use an estimate of 30 chars per line rather than the real
-     `portion' value.  This has the disadvantage that the thumb size
-     is not very representative, but it makes our life a lot easier.
-     Otherwise, we have to constantly adjust the thumb size, which
-     we can't always do quickly enough: while dragging, the size of
-     the thumb might prevent the user from dragging the thumb all the
-     way to the end.  but Motif and some versions of Xaw3d don't allow
-     updating the thumb size while dragging.  Also, even if we can update
-     its size, the update will often happen too late.
-     If you don't believe it, check out revision 1.650 of xterm.c to see
-     what hoops we were going through and the still poor behavior we got.  */
-  portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
-  /* When the thumb is at the bottom, position == whole.
-     So we need to increase `whole' to make space for the thumb.  */
-  whole += portion;
+  if (scroll_bar_adjust_thumb_portion_p)
+    {
+      /* We use an estimate of 30 chars per line rather than the real
+         `portion' value.  This has the disadvantage that the thumb size
+         is not very representative, but it makes our life a lot easier.
+         Otherwise, we have to constantly adjust the thumb size, which
+         we can't always do quickly enough: while dragging, the size of
+         the thumb might prevent the user from dragging the thumb all the
+         way to the end.  but Motif and some versions of Xaw3d don't allow
+         updating the thumb size while dragging.  Also, even if we can update
+         its size, the update will often happen too late.
+         If you don't believe it, check out revision 1.650 of xterm.c to see
+         what hoops we were going through and the still poor behavior we got.  */
+      portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
+      /* When the thumb is at the bottom, position == whole.
+         So we need to increase `whole' to make space for the thumb.  */
+      whole += portion;
+    }
 
   if (whole <= 0)
     top = 0, shown = 1;
@@ -10784,6 +10787,16 @@ With MS Windows or Nextstep, the value is t.  */);
   Vx_toolkit_scroll_bars = Qnil;
 #endif
 
+  DEFVAR_BOOL ("scroll-bar-adjust-thumb-portion",
+               scroll_bar_adjust_thumb_portion_p,
+               doc: /* Adjust thumb for overscrolling for Gtk+ and MOTIF.
+Non-nil means adjust the thumb in the scroll bar so it can be dragged downwards
+even if the end of the buffer is shown (i.e. overscrolling).
+Set to nil if you want the thumb to be at the bottom when the end of the buffer
+is shown.  Also, the thumb fills the whole scroll bar when the entire buffer
+is visible.  In this case you can not overscroll.  */);
+  scroll_bar_adjust_thumb_portion_p = 1;
+
   staticpro (&last_mouse_motion_frame);
   last_mouse_motion_frame = Qnil;