upstream, doesn build yet

55 files changed, 1307 insertions, 862 deletions

diff --git a/src/.gdbinit b/src/.gdbinit
index 8f8508f291f..df3a9cd7124 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -49,17 +49,26 @@ handle SIGALRM ignore
 # Using a constant runs into GDB bugs sometimes.
 define xgetptr
   set $bugfix = $arg0
-  set $ptr = (gdb_use_union ? (gdb_use_lsb ? $bugfix.u.val << gdb_gctypebits : $bugfix.u.val) : $bugfix & $valmask) | gdb_data_seg_bits
+  if gdb_use_struct
+    set $bugfix = $bugfix.i
+  end
+  set $ptr = $bugfix & $valmask | gdb_data_seg_bits
 end
 
 define xgetint
   set $bugfix = $arg0
-  set $int = gdb_use_union ? $bugfix.s.val : (gdb_use_lsb ? $bugfix >> (gdb_gctypebits - 1) : $bugfix << gdb_gctypebits) >> gdb_gctypebits
+  if gdb_use_struct
+    set $bugfix = $bugfix.i
+  end
+  set $int = gdb_use_lsb ? $bugfix >> (gdb_gctypebits - 1) : $bugfix << gdb_gctypebits) >> gdb_gctypebits
 end
 
 define xgettype
   set $bugfix = $arg0
-  set $type = gdb_use_union ? $bugfix.s.type : (enum Lisp_Type) (gdb_use_lsb ? $bugfix & $tagmask : $bugfix >> gdb_valbits)
+  if gdb_use_struct
+    set $bugfix = $bugfix.i
+  end
+  set $type = (enum Lisp_Type) (gdb_use_lsb ? $bugfix & $tagmask : $bugfix >> gdb_valbits)
 end
 
 # Set up something to print out s-expressions.
@@ -949,15 +958,8 @@ end
 
 define xpr
   xtype
-  if gdb_use_union
-    if $type == Lisp_Int
-      xint
-    end
-  end
-  if !gdb_use_union
-    if $type == Lisp_Int0 || $type == Lisp_Int1
-      xint
-    end
+  if $type == Lisp_Int0 || $type == Lisp_Int1
+    xint
   end
   if $type == Lisp_Symbol
     xsymbol
diff --git a/src/ChangeLog b/src/ChangeLog
index 6d71346dd78..19a9ace0728 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,276 @@
+2012-06-13  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * lisp.h (Lisp_Object) [CHECK_LISP_OBJECT_TYPE]: Define as struct
+        instead of union.
+        (XLI, XIL): Define.
+        (XHASH, XTYPE, XINT, XUINT, make_number, XSET, XPNTR, XUNTAG): Use
+        them.
+        * emacs.c (gdb_use_struct): Renamed from gdb_use_union.
+        * .gdbinit: Check gdb_use_struct instead of gdb_use_union.
+        * alloc.c (widen_to_Lisp_Object): Removed.
+        (mark_memory): Use XIL instead of widen_to_Lisp_Object.
+        * frame.c (delete_frame): Remove outdated comment.
+        * w32fns.c (Fw32_register_hot_key): Use XLI instead of checking
+        USE_LISP_UNION_TYPE.
+        (Fw32_unregister_hot_key): Likewise.
+        (Fw32_toggle_lock_key): Likewise.
+        * w32menu.c (add_menu_item): Likewise.
+        (w32_menu_display_help): Use XIL instead of checking
+        USE_LISP_UNION_TYPE.
+        * w32heap.c (allocate_heap): Don't check USE_LISP_UNION_TYPE.
+        (init_heap): Likewise.
+        * w32term.c (w32_read_socket): Update comment.
+
+2012-06-13  Glenn Morris  <rgm@gnu.org>
+
+        * s/usg5-4-common.h, src/s/unixware.h:
+        Remove define/undef of HAVE_SYSV_SIGPAUSE (not used since 2010-05-04).
+
+        * s/gnu.h (POSIX_SIGNALS): Remove (not used since 2010-05-04).
+
+2012-06-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        USE_LISP_UNION_TYPE + USE_LSB_TAG cleanup (Bug#11604)
+        * alloc.c (make_number) [!defined make_number]:
+        Remove, as lisp.h always defines this now.
+        (mark_maybe_pointer): Simplify since USE_LSB_TAG is always defined now.
+        (roundup_size): Verify that it is a power of 2.
+        * data.c (Fmake_variable_buffer_local, Fmake_local_variable):
+        * ftfont.c (ftfont_driver): Use LISP_INITIALLY_ZERO.
+        * lisp.h (USE_LSB_TAG): Allow the builder to compile with
+        -DUSE_LSB_TAG=0, to override the automatically-selected default.
+        USE_LSB_TAG now is always defined to be either 0 or 1.
+        All uses changed.
+        (union Lisp_Object): Don't worry about WORDS_BIGENDIAN; the
+        code works fine either way, and efficiency is not a concern here,
+        as the union type is for debugging, not for production.
+        (LISP_MAKE_RVALUE, make_number) [USE_LISP_UNION_TYPE]:
+        Use an inline function on all platforms when using the union type,
+        since this is simpler and 'static inline' can be used portably
+        within Emacs now.
+        (LISP_INITIALLY_ZERO): New macro.
+        (XFASTINT, XSETFASTINT) [USE_LISP_UNION_TYPE]: Remove.
+        (XSET) [USE_LISP_UNION_TYPE]: Don't overparenthesize.
+
+2012-06-12  Glenn Morris  <rgm@gnu.org>
+
+        * s/gnu-kfreebsd.h, s/hpux11.h, s/openbsd.h, s/sol2-10.h: Remove files.
+
+        * s/gnu-linux.h (HAVE_PROCFS): Move to configure.
+
+        * s/hpux10-20.h, s/openbsd.h, s/usg5-4-common.h:
+        Move BROKEN_SIGIO to configure.
+
+        * s/bsd-common.h, s/darwin.h, s/gnu-kfreebsd.h, s/hpux10-20.h:
+        Move NO_TERMIO to configure.
+
+2012-06-12  Chong Yidong  <cyd@gnu.org>
+
+        * image.c (imagemagick_load_image): Use MagickFlattenImage if
+        MagickMergeImageLayers is undefined.  Use pixel pusher loop if
+        MagickExportImagePixels is undefined.
+
+2012-06-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * image.c (imagemagick_load_image): Remove unused label.
+
+2012-06-11  Glenn Morris  <rgm@gnu.org>
+
+        * s/aix4-2.h, s/bsd-common.h, s/cygwin.h, s/darwin.h:
+        * s/gnu-kfreebsd.h, s/gnu-linux.h, s/gnu.h, s/hpux10-20.h:
+        * s/irix6-5.h, s/ms-w32.h, s/msdos.h, s/template.h:
+        * s/usg5-4-common.h: Move SYSTEM_TYPE to configure.
+
+2012-06-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * alloc.c (make_byte_code): New function.
+        (Fmake_byte_code): Use it.  Don't purify here.
+        * lread.c (read1): Use it as well to avoid extra allocation.
+
+2012-06-11  Chong Yidong  <cyd@gnu.org>
+
+        * image.c (imagemagick_load_image): Implement transparency.
+
+2012-06-10  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * regex.c (at_begline_loc_p): Also recognize `(?N:' and correctly
+        account for preceding backslashes.  (Bug#11663)
+
+2012-06-09  Chong Yidong  <cyd@gnu.org>
+
+        * term.c: Support italics in capable terminals (Bug#9652).
+        (no_color_bit): Replace unused NC_BLINK with NC_ITALIC.
+        (turn_on_face): Output using TS_enter_italic_mode if available.
+        Don't handle unused blinking and alt-charset cases.
+        (turn_off_face): Handle italic case; discard unused tty_blinking_p
+        and tty_alt_charset_p cases.
+        (tty_capable_p, init_tty): Support italics.
+
+        * termchar.h (struct tty_display_info): Add field for italics.
+        Remove unused blink field.
+
+        * xfaces.c (tty_supports_face_attributes_p, realize_tty_face):
+        Handle slant.
+
+        * dispextern.h: Replace unused TTY_CAP_BLINK with TTY_CAP_ITALIC.
+        (struct face): Remove unused fields tty_dim_p, tty_blinking_p, and
+        tty_alt_charset_p.  Add tty_italic_p.
+
+2012-06-09  Michael Albinus  <michael.albinus@gmx.de>
+
+        * dbusbind.c (XD_BASIC_DBUS_TYPE): Use dbus_type_is_valid and
+        dbus_type_is_basic if available.
+        (xd_extract_signed, xd_extract_unsigned): Rename from
+        extract_signed and extract_unsigned, respectively.  Adapt callers.
+
+2012-06-09  Chong Yidong  <cyd@gnu.org>
+
+        * xfaces.c (face_for_overlay_string): Handle face remapping (Bug#2066).
+
+        * fringe.c (Fset_fringe_bitmap_face): Handle the noninteractive
+        case (Bug#9752).
+
+2012-06-08  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xdisp.c (vmessage): Treat frame message as multibyte.
+        Without this change, (let ((§ 1)) (make-variable-buffer-local '§))
+        would generate the diagnostic "Making \302\247 buffer-local while
+        let-bound!".
+
+2012-06-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * dispnew.c (showing_window_margins_p): Undo last change, which
+        was done due to an inadvertent commit.
+        (adjust_frame_glyphs_for_frame_redisplay): Do call
+        showing_window_margins_p.
+
+2012-06-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (Fmake_var_non_special): New primitive.
+        (syms_of_eval): Defsubr it.
+        * lread.c (syms_of_lread): Mark `values' as lexically scoped.
+
+2012-06-08  Juanma Barranquero  <lekktu@gmail.com>
+
+        * dispnew.c (showing_window_margins_p): Wrap in #if 0 to prevent unused
+        function warning (the only call is inside #if 0 since 2012-06-08T08:44:45Z!eliz@gnu.org).
+
+2012-06-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * alloc.c (allocate_vectorlike): Fix last change.
+
+2012-06-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Block-based vector allocation of small vectors.
+        * lisp.h (struct vectorlike_header): New field `nbytes',
+        adjust comment accordingly.
+        * alloc.c (enum mem_type): New type `MEM_TYPE_VECTOR_BLOCK'
+        to denote vector blocks. Adjust users (live_vector_p,
+        mark_maybe_pointer, valid_lisp_object_p) accordingly.
+        (COMMON_MULTIPLE): Move outside #if USE_LSB_TAG.
+        (VECTOR_BLOCK_SIZE, vroundup, VECTOR_BLOCK_BYTES),
+        (VBLOCK_BYTES_MIN, VBLOCK_BYTES_MAX, VECTOR_MAX_FREE_LIST_INDEX),
+        (VECTOR_FREE_LIST_FLAG, ADVANCE, VINDEX, SETUP_ON_FREE_LIST),
+        (VECTOR_SIZE, VECTOR_IN_BLOCK): New macros.
+        (roundup_size): New constant.
+        (struct vector_block): New data type.
+        (vector_blocks, vector_free_lists, zero_vector): New variables.
+        (all_vectors): Rename to `large_vectors'.
+        (allocate_vector_from_block, init_vectors, allocate_vector_from_block)
+        (sweep_vectors): New functions.
+        (allocate_vectorlike): Return `zero_vector' as the only vector of
+        0 items. Allocate new vector from block if vector size is less than
+        or equal to VBLOCK_BYTES_MAX.
+        (Fgarbage_collect): Move all vector sweeping code to sweep_vectors.
+        (init_alloc_once): Add call to init_vectors.
+
+2012-06-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (Fmacroexpand): Stop if the macro returns the same form.
+
+2012-06-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * doprnt.c (doprnt): Truncate multibyte char correctly.
+        Without this change, doprnt (buf, 2, "%s", FORMAT_END, AP)
+        would mishandle a string argument "Xc" if X was a multibyte
+        character of length 2: it would truncate after X's first byte
+        rather than including all of X.
+
+2012-06-06  Chong Yidong  <cyd@gnu.org>
+
+        * buffer.c (word_wrap): Doc fix.
+
+2012-06-04  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xdisp.c (note_mode_line_or_margin_highlight): Pacify gcc -Wall.
+
+2012-06-03  Glenn Morris  <rgm@gnu.org>
+
+        * xdisp.c (tool-bar-style): Doc fix.
+
+2012-06-03  Ulrich Müller  <ulm@gentoo.org>
+
+        * Makefile.in (PAXCTL): Define.
+        (temacs$(EXEEXT)): Disable memory randomization for the temacs
+        binary via PaX flags if the paxctl utility is available.
+        (emacs$(EXEEXT), bootstrap-emacs$(EXEEXT)):
+        Restore PaX flags to their default.  (Bug#11398)
+
+2012-06-03  Chong Yidong  <cyd@gnu.org>
+
+        * xdisp.c (decode_mode_spec_coding): Display a space for a unibyte
+        buffer (Bug#11226).
+
+2012-06-03  Chong Yidong  <cyd@gnu.org>
+
+        * xdisp.c (calc_pixel_width_or_height): Use Fbuffer_local_value.
+        (note_mode_line_or_margin_highlight): If there is no help echo,
+        use mode-line-default-help-echo.  Handle the case where the mouse
+        position is past the end of the mode line string.
+
+        * buffer.c (buffer_local_value_1): New function, split from
+        Fbuffer_local_value; can return Qunbound.
+        (Fbuffer_local_value): Use it.
+        (Vmode_line_format): Docstring tweaks.
+
+2012-06-02  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * sysdep.c (system_process_attributes): Improve comment.
+
+2012-06-02  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c: Export real-this-command to Elisp.
+        (syms_of_keyboard): Rename real_this_command to Vreal_this_command
+        and DEFVAR it.  Update all users.
+
+2012-06-02  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * minibuf.c (Fassoc_string): Remove duplicate declaration.
+
+        * sysdep.c (system_process_attributes) [SOLARIS2 && HAVE_PROCFS]:
+        Convert pctcpu and pctmem to Lisp float properly.
+        Let the compiler fold better, as 100.0/0x8000 is exact.
+
+2012-06-02  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * alloc.c (CONS_BLOCK_SIZE): Account for padding at the end of
+        cons_block.
+
+2012-06-01  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xfns.c (x_set_tool_bar_lines) [USE_GTK]: Adjust to bitfield change.
+
+2012-06-01  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        For a 'struct window', replace some Lisp_Object fields to
+        bitfields where appropriate, remove unused fields.
+        * window.h (struct window): Remove unused 'last_mark_x' and
+        'last_mark_y' fields.  Rename 'mini_p' field to 'mini',
+        change it's type from Lisp_Object to bitfield.
+        Change type of 'force_start', 'optional_new_start',
+        'last_had_star', 'update_mode_line' and 'start_at_line_beg'
+        fields from Lisp_Object to bitfield. Adjust users accordingly.
+
 2012-05-31  Paul Eggert  <eggert@cs.ucla.edu>
 
         Pacify gcc -Wdouble-precision when using Xaw.
diff --git a/src/Makefile.in b/src/Makefile.in
index 1dd966ec0a7..b02d49ff5b0 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -113,6 +113,12 @@ TEMACS_LDFLAGS = $(LD_SWITCH_SYSTEM) $(LD_SWITCH_SYSTEM_TEMACS)
 ## $LDFLAGS or empty if NS_IMPL_GNUSTEP (for some reason).
 TEMACS_LDFLAGS2 = @TEMACS_LDFLAGS2@
 
+## If available, the full path to the paxctl program.
+## On grsecurity/PaX systems, unexec will fail due to a gap between
+## the bss section and the heap.  This can be prevented by disabling
+## memory randomization in temacs with "paxctl -r".  See bug#11398.
+PAXCTL = @PAXCTL@
+
 ## Some systems define this to request special libraries.
 LIBS_SYSTEM=@LIBS_SYSTEM@
 
@@ -413,6 +419,7 @@ emacs$(EXEEXT): temacs$(EXEEXT) $(etc)/DOC $(lisp) $(leimdir)/leim-list.el
             -f list-load-path-shadows || true; \
         else \
           LC_ALL=C $(RUN_TEMACS) -batch -l loadup dump || exit 1; \
+          test "X$(PAXCTL)" = X || $(PAXCTL) -zex emacs$(EXEEXT); \
           ln -f emacs$(EXEEXT) bootstrap-emacs$(EXEEXT); \
           ./emacs -batch -f list-load-path-shadows || true; \
         fi
@@ -460,6 +467,8 @@ $(lib)/libgnu.a: $(config_h)
 temacs$(EXEEXT): $(START_FILES) stamp-oldxmenu $(obj) $(otherobj) $(lib)/libgnu.a
         $(CC) $(LD_FIRSTFLAG) $(ALL_CFLAGS) $(TEMACS_LDFLAGS) $(TEMACS_LDFLAGS2) \
           -o temacs $(START_FILES) $(obj) $(otherobj) $(lib)/libgnu.a $(LIBES)
+        test "$(CANNOT_DUMP)" = "yes" || \
+          test "X$(PAXCTL)" = X || $(PAXCTL) -r temacs$(EXEEXT)
 
 ## The following oldxmenu-related rules are only (possibly) used if
 ## HAVE_X11 && !USE_GTK, but there is no harm in always defining them
@@ -607,6 +616,7 @@ bootstrap-emacs$(EXEEXT): temacs$(EXEEXT)
           ln -f temacs$(EXEEXT) bootstrap-emacs$(EXEEXT); \
         else \
           $(RUN_TEMACS) --batch --load loadup bootstrap || exit 1; \
+          test "X$(PAXCTL)" = X || $(PAXCTL) -zex emacs$(EXEEXT); \
           mv -f emacs$(EXEEXT) bootstrap-emacs$(EXEEXT); \
         fi
         @: Compile some files earlier to speed up further compilation.
diff --git a/src/alloc.c b/src/alloc.c
index cf7778c05f6..1478ce9ae4e 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -304,7 +304,9 @@ enum mem_type
      process, hash_table, frame, terminal, and window, but we never made
      use of the distinction, so it only caused source-code complexity
      and runtime slowdown.  Minor but pointless.  */
-  MEM_TYPE_VECTORLIKE
+  MEM_TYPE_VECTORLIKE,
+  /* Special type to denote vector blocks.  */
+  MEM_TYPE_VECTOR_BLOCK
 };
 
 static void *lisp_malloc (size_t, enum mem_type);
@@ -494,6 +496,11 @@ buffer_memory_full (ptrdiff_t nbytes)
   xsignal (Qnil, Vmemory_signal_data);
 }
 
+/* A common multiple of the positive integers A and B.  Ideally this
+   would be the least common multiple, but there's no way to do that
+   as a constant expression in C, so do the best that we can easily do.  */
+#define COMMON_MULTIPLE(a, b) \
+  ((a) % (b) == 0 ? (a) : (b) % (a) == 0 ? (b) : (a) * (b))
 
 #ifndef XMALLOC_OVERRUN_CHECK
 #define XMALLOC_OVERRUN_CHECK_OVERHEAD 0
@@ -525,12 +532,8 @@ buffer_memory_full (ptrdiff_t nbytes)
       char c;                                           \
     },                                                  \
     c)
-#ifdef USE_LSB_TAG
-/* A common multiple of the positive integers A and B.  Ideally this
-   would be the least common multiple, but there's no way to do that
-   as a constant expression in C, so do the best that we can easily do.  */
-# define COMMON_MULTIPLE(a, b) \
-    ((a) % (b) == 0 ? (a) : (b) % (a) == 0 ? (b) : (a) * (b))
+
+#if USE_LSB_TAG
 # define XMALLOC_HEADER_ALIGNMENT \
     COMMON_MULTIPLE (1 << GCTYPEBITS, XMALLOC_BASE_ALIGNMENT)
 #else
@@ -890,8 +893,8 @@ safe_alloca_unwind (Lisp_Object arg)
    number of bytes to allocate, TYPE describes the intended use of the
    allocated memory block (for strings, for conses, ...).  */
 
-#ifndef USE_LSB_TAG
-static void *lisp_malloc_loser;
+#if ! USE_LSB_TAG
+void *lisp_malloc_loser EXTERNALLY_VISIBLE;
 #endif
 
 static void *
@@ -907,7 +910,7 @@ lisp_malloc (size_t nbytes, enum mem_type type)
 
   val = (void *) malloc (nbytes);
 
-#ifndef USE_LSB_TAG
+#if ! USE_LSB_TAG
   /* If the memory just allocated cannot be addressed thru a Lisp
      object's pointer, and it needs to be,
      that's equivalent to running out of memory.  */
@@ -1088,7 +1091,7 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
       mallopt (M_MMAP_MAX, MMAP_MAX_AREAS);
 #endif
 
-#ifndef USE_LSB_TAG
+#if ! USE_LSB_TAG
       /* If the memory just allocated cannot be addressed thru a Lisp
          object's pointer, and it needs to be, that's equivalent to
          running out of memory.  */
@@ -1581,35 +1584,6 @@ mark_interval_tree (register INTERVAL tree)
    if (! NULL_INTERVAL_P (i))                           \
      (i) = balance_intervals (i);                       \
   } while (0)
-
-
-/* Number support.  If USE_LISP_UNION_TYPE is in effect, we
-   can't create number objects in macros.  */
-#ifndef make_number
-Lisp_Object
-make_number (EMACS_INT n)
-{
-  Lisp_Object obj;
-  obj.s.val = n;
-  obj.s.type = Lisp_Int;
-  return obj;
-}
-#endif
-
-/* Convert the pointer-sized word P to EMACS_INT while preserving its
-   type and ptr fields.  */
-static Lisp_Object
-widen_to_Lisp_Object (void *p)
-{
-  intptr_t i = (intptr_t) p;
-#ifdef USE_LISP_UNION_TYPE
-  Lisp_Object obj;
-  obj.i = i;
-  return obj;
-#else
-  return i;
-#endif
-}
 
 /***********************************************************************
                           String Allocation
@@ -2701,8 +2675,10 @@ make_float (double float_value)
    GC are put on a free list to be reallocated before allocating
    any new cons cells from the latest cons_block.  */
 
-#define CONS_BLOCK_SIZE \
-  (((BLOCK_BYTES - sizeof (struct cons_block *)) * CHAR_BIT) \
+#define CONS_BLOCK_SIZE                                         \
+  (((BLOCK_BYTES - sizeof (struct cons_block *)                 \
+     /* The compiler might add padding at the end.  */          \
+     - (sizeof (struct Lisp_Cons) - sizeof (int))) * CHAR_BIT)  \
    / (sizeof (struct Lisp_Cons) * CHAR_BIT + 1))
 
 #define CONS_BLOCK(fptr) \
@@ -2926,17 +2902,302 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
                            Vector Allocation
  ***********************************************************************/
 
-/* Singly-linked list of all vectors.  */
+/* This value is balanced well enough to avoid too much internal overhead
+   for the most common cases; it's not required to be a power of two, but
+   it's expected to be a mult-of-ROUNDUP_SIZE (see below).  */
 
-static struct Lisp_Vector *all_vectors;
+#define VECTOR_BLOCK_SIZE 4096
 
 /* Handy constants for vectorlike objects.  */
 enum
   {
     header_size = offsetof (struct Lisp_Vector, contents),
-    word_size = sizeof (Lisp_Object)
+    word_size = sizeof (Lisp_Object),
+    roundup_size = COMMON_MULTIPLE (sizeof (Lisp_Object),
+                                    USE_LSB_TAG ? 1 << GCTYPEBITS : 1)
   };
 
+/* ROUNDUP_SIZE must be a power of 2.  */
+verify ((roundup_size & (roundup_size - 1)) == 0);
+
+/* Round up X to nearest mult-of-ROUNDUP_SIZE.  */
+
+#define vroundup(x) (((x) + (roundup_size - 1)) & ~(roundup_size - 1))
+
+/* Rounding helps to maintain alignment constraints if USE_LSB_TAG.  */
+
+#define VECTOR_BLOCK_BYTES (VECTOR_BLOCK_SIZE - vroundup (sizeof (void *)))
+
+/* Size of the minimal vector allocated from block.  */
+
+#define VBLOCK_BYTES_MIN vroundup (sizeof (struct Lisp_Vector))
+
+/* Size of the largest vector allocated from block.  */
+
+#define VBLOCK_BYTES_MAX                                        \
+  vroundup ((VECTOR_BLOCK_BYTES / 2) - sizeof (Lisp_Object))
+
+/* We maintain one free list for each possible block-allocated
+   vector size, and this is the number of free lists we have.  */
+
+#define VECTOR_MAX_FREE_LIST_INDEX                              \
+  ((VECTOR_BLOCK_BYTES - VBLOCK_BYTES_MIN) / roundup_size + 1)
+
+/* When the vector is on a free list, vectorlike_header.SIZE is set to
+   this special value ORed with vector's memory footprint size.  */
+
+#define VECTOR_FREE_LIST_FLAG (~(ARRAY_MARK_FLAG | PSEUDOVECTOR_FLAG    \
+                                 | (VECTOR_BLOCK_SIZE - 1)))
+
+/* Common shortcut to advance vector pointer over a block data.  */
+
+#define ADVANCE(v, nbytes) ((struct Lisp_Vector *) ((char *) (v) + (nbytes)))
+
+/* Common shortcut to calculate NBYTES-vector index in VECTOR_FREE_LISTS.  */
+
+#define VINDEX(nbytes) (((nbytes) - VBLOCK_BYTES_MIN) / roundup_size)
+
+/* Common shortcut to setup vector on a free list.  */
+
+#define SETUP_ON_FREE_LIST(v, nbytes, index)                    \
+  do {                                                          \
+    (v)->header.size = VECTOR_FREE_LIST_FLAG | (nbytes);        \
+    eassert ((nbytes) % roundup_size == 0);                     \
+    (index) = VINDEX (nbytes);                                  \
+    eassert ((index) < VECTOR_MAX_FREE_LIST_INDEX);             \
+    (v)->header.next.vector = vector_free_lists[index];         \
+    vector_free_lists[index] = (v);                             \
+  } while (0)
+
+struct vector_block
+{
+  char data[VECTOR_BLOCK_BYTES];
+  struct vector_block *next;
+};
+
+/* Chain of vector blocks.  */
+
+static struct vector_block *vector_blocks;
+
+/* Vector free lists, where NTH item points to a chain of free
+   vectors of the same NBYTES size, so NTH == VINDEX (NBYTES).  */
+
+static struct Lisp_Vector *vector_free_lists[VECTOR_MAX_FREE_LIST_INDEX];
+
+/* Singly-linked list of large vectors.  */
+
+static struct Lisp_Vector *large_vectors;
+
+/* The only vector with 0 slots, allocated from pure space.  */
+
+static struct Lisp_Vector *zero_vector;
+
+/* Get a new vector block.  */
+
+static struct vector_block *
+allocate_vector_block (void)
+{
+  struct vector_block *block;
+
+#ifdef DOUG_LEA_MALLOC
+  mallopt (M_MMAP_MAX, 0);
+#endif
+
+  block = xmalloc (sizeof (struct vector_block));
+
+#ifdef DOUG_LEA_MALLOC
+  mallopt (M_MMAP_MAX, MMAP_MAX_AREAS);
+#endif
+
+#if GC_MARK_STACK && !defined GC_MALLOC_CHECK
+  mem_insert (block->data, block->data + VECTOR_BLOCK_BYTES,
+              MEM_TYPE_VECTOR_BLOCK);
+#endif
+
+  block->next = vector_blocks;
+  vector_blocks = block;
+  return block;
+}
+
+/* Called once to initialize vector allocation.  */
+
+static void
+init_vectors (void)
+{
+  zero_vector = pure_alloc (header_size, Lisp_Vectorlike);
+  zero_vector->header.size = 0;
+}
+
+/* Allocate vector from a vector block.  */
+
+static struct Lisp_Vector *
+allocate_vector_from_block (size_t nbytes)
+{
+  struct Lisp_Vector *vector, *rest;
+  struct vector_block *block;
+  size_t index, restbytes;
+
+  eassert (VBLOCK_BYTES_MIN <= nbytes && nbytes <= VBLOCK_BYTES_MAX);
+  eassert (nbytes % roundup_size == 0);
+
+  /* First, try to allocate from a free list
+     containing vectors of the requested size.  */
+  index = VINDEX (nbytes);
+  if (vector_free_lists[index])
+    {
+      vector = vector_free_lists[index];
+      vector_free_lists[index] = vector->header.next.vector;
+      vector->header.next.nbytes = nbytes;
+      return vector;
+    }
+
+  /* Next, check free lists containing larger vectors.  Since
+     we will split the result, we should have remaining space
+     large enough to use for one-slot vector at least.  */
+  for (index = VINDEX (nbytes + VBLOCK_BYTES_MIN);
+       index < VECTOR_MAX_FREE_LIST_INDEX; index++)
+    if (vector_free_lists[index])
+      {
+        /* This vector is larger than requested.  */
+        vector = vector_free_lists[index];
+        vector_free_lists[index] = vector->header.next.vector;
+        vector->header.next.nbytes = nbytes;
+
+        /* Excess bytes are used for the smaller vector,
+           which should be set on an appropriate free list.  */
+        restbytes = index * roundup_size + VBLOCK_BYTES_MIN - nbytes;
+        eassert (restbytes % roundup_size == 0);
+        rest = ADVANCE (vector, nbytes);
+        SETUP_ON_FREE_LIST (rest, restbytes, index);
+        return vector;
+      }
+
+  /* Finally, need a new vector block.  */
+  block = allocate_vector_block ();
+
+  /* New vector will be at the beginning of this block.  */
+  vector = (struct Lisp_Vector *) block->data;
+  vector->header.next.nbytes = nbytes;
+
+  /* If the rest of space from this block is large enough
+     for one-slot vector at least, set up it on a free list.  */
+  restbytes = VECTOR_BLOCK_BYTES - nbytes;
+  if (restbytes >= VBLOCK_BYTES_MIN)
+    {
+      eassert (restbytes % roundup_size == 0);
+      rest = ADVANCE (vector, nbytes);
+      SETUP_ON_FREE_LIST (rest, restbytes, index);
+    }
+  return vector;
+ }
+
+/* Return how many Lisp_Objects can be stored in V.  */
+
+#define VECTOR_SIZE(v) ((v)->header.size & PSEUDOVECTOR_FLAG ?          \
+                        (PSEUDOVECTOR_SIZE_MASK & (v)->header.size) :   \
+                        (v)->header.size)
+
+/* Nonzero if VECTOR pointer is valid pointer inside BLOCK.  */
+
+#define VECTOR_IN_BLOCK(vector, block)          \
+  ((char *) (vector) <= (block)->data           \
+   + VECTOR_BLOCK_BYTES - VBLOCK_BYTES_MIN)
+
+/* Reclaim space used by unmarked vectors.  */
+
+static void
+sweep_vectors (void)
+{
+  struct vector_block *block = vector_blocks, **bprev = &vector_blocks;
+  struct Lisp_Vector *vector, *next, **vprev = &large_vectors;
+
+  total_vector_size = 0;
+  memset (vector_free_lists, 0, sizeof (vector_free_lists));
+
+  /* Looking through vector blocks.  */
+
+  for (block = vector_blocks; block; block = *bprev)
+    {
+      int free_this_block = 0;
+
+      for (vector = (struct Lisp_Vector *) block->data;
+           VECTOR_IN_BLOCK (vector, block); vector = next)
+        {
+          if (VECTOR_MARKED_P (vector))
+            {
+              VECTOR_UNMARK (vector);
+              total_vector_size += VECTOR_SIZE (vector);
+              next = ADVANCE (vector, vector->header.next.nbytes);
+            }
+          else
+            {
+              ptrdiff_t nbytes;
+
+              if ((vector->header.size & VECTOR_FREE_LIST_FLAG)
+                  == VECTOR_FREE_LIST_FLAG)
+                vector->header.next.nbytes =
+                  vector->header.size & (VECTOR_BLOCK_SIZE - 1);
+
+              next = ADVANCE (vector, vector->header.next.nbytes);
+
+              /* While NEXT is not marked, try to coalesce with VECTOR,
+                 thus making VECTOR of the largest possible size.  */
+
+              while (VECTOR_IN_BLOCK (next, block))
+                {
+                  if (VECTOR_MARKED_P (next))
+                    break;
+                  if ((next->header.size & VECTOR_FREE_LIST_FLAG)
+                      == VECTOR_FREE_LIST_FLAG)
+                    nbytes = next->header.size & (VECTOR_BLOCK_SIZE - 1);
+                  else
+                    nbytes = next->header.next.nbytes;
+                  vector->header.next.nbytes += nbytes;
+                  next = ADVANCE (next, nbytes);
+                }
+
+              eassert (vector->header.next.nbytes % roundup_size == 0);
+
+              if (vector == (struct Lisp_Vector *) block->data
+                  && !VECTOR_IN_BLOCK (next, block))
+                /* This block should be freed because all of it's
+                   space was coalesced into the only free vector.  */
+                free_this_block = 1;
+              else
+                SETUP_ON_FREE_LIST (vector, vector->header.next.nbytes, nbytes);
+            }
+        }
+
+      if (free_this_block)
+        {
+          *bprev = block->next;
+#if GC_MARK_STACK && !defined GC_MALLOC_CHECK
+          mem_delete (mem_find (block->data));
+#endif
+          xfree (block);
+        }
+      else
+        bprev = &block->next;
+    }
+
+  /* Sweep large vectors.  */
+
+  for (vector = large_vectors; vector; vector = *vprev)
+    {
+      if (VECTOR_MARKED_P (vector))
+        {
+          VECTOR_UNMARK (vector);
+          total_vector_size += VECTOR_SIZE (vector);
+          vprev = &vector->header.next.vector;
+        }
+      else
+        {
+          *vprev = vector->header.next.vector;
+          lisp_free (vector);
+        }
+    }
+}
+
 /* Value is a pointer to a newly allocated Lisp_Vector structure
    with room for LEN Lisp_Objects.  */
 
@@ -2958,8 +3219,22 @@ allocate_vectorlike (ptrdiff_t len)
   /* This gets triggered by code which I haven't bothered to fix.  --Stef  */
   /* eassert (!handling_signal); */
 
+  if (len == 0)
+    {
+      MALLOC_UNBLOCK_INPUT;
+      return zero_vector;
+    }
+
   nbytes = header_size + len * word_size;
-  p = (struct Lisp_Vector *) lisp_malloc (nbytes, MEM_TYPE_VECTORLIKE);
+
+  if (nbytes <= VBLOCK_BYTES_MAX)
+    p = allocate_vector_from_block (vroundup (nbytes));
+  else
+    {
+      p = (struct Lisp_Vector *) lisp_malloc (nbytes, MEM_TYPE_VECTORLIKE);
+      p->header.next.vector = large_vectors;
+      large_vectors = p;
+    }
 
 #ifdef DOUG_LEA_MALLOC
   /* Back to a reasonable maximum of mmap'ed areas.  */
@@ -2969,9 +3244,6 @@ allocate_vectorlike (ptrdiff_t len)
   consing_since_gc += nbytes;
   vector_cells_consed += len;
 
-  p->header.next.vector = all_vectors;
-  all_vectors = p;
-
   MALLOC_UNBLOCK_INPUT;
 
   return p;
@@ -3095,6 +3367,19 @@ usage: (vector &rest OBJECTS)  */)
   return val;
 }
 
+void
+make_byte_code (struct Lisp_Vector *v)
+{
+  if (v->header.size > 1 && STRINGP (v->contents[1])
+      && STRING_MULTIBYTE (v->contents[1]))
+    /* BYTECODE-STRING must have been produced by Emacs 20.2 or the
+       earlier because they produced a raw 8-bit string for byte-code
+       and now such a byte-code string is loaded as multibyte while
+       raw 8-bit characters converted to multibyte form.  Thus, now we
+       must convert them back to the original unibyte form.  */
+    v->contents[1] = Fstring_as_unibyte (v->contents[1]);
+  XSETPVECTYPE (v, PVEC_COMPILED);
+}
 
 DEFUN ("make-byte-code", Fmake_byte_code, Smake_byte_code, 4, MANY, 0,
        doc: /* Create a byte-code object with specified arguments as elements.
@@ -3118,28 +3403,21 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
   ptrdiff_t i;
   register struct Lisp_Vector *p;
 
-  XSETFASTINT (len, nargs);
-  if (!NILP (Vpurify_flag))
-    val = make_pure_vector (nargs);
-  else
-    val = Fmake_vector (len, Qnil);
+  /* We used to purecopy everything here, if purify-flga was set.  This worked
+     OK for Emacs-23, but with Emacs-24's lexical binding code, it can be
+     dangerous, since make-byte-code is used during execution to build
+     closures, so any closure built during the preload phase would end up
+     copied into pure space, including its free variables, which is sometimes
+     just wasteful and other times plainly wrong (e.g. those free vars may want
+     to be setcar'd).  */
 
-  if (nargs > 1 && STRINGP (args[1]) && STRING_MULTIBYTE (args[1]))
-    /* BYTECODE-STRING must have been produced by Emacs 20.2 or the
-       earlier because they produced a raw 8-bit string for byte-code
-       and now such a byte-code string is loaded as multibyte while
-       raw 8-bit characters converted to multibyte form.  Thus, now we
-       must convert them back to the original unibyte form.  */
-    args[1] = Fstring_as_unibyte (args[1]);
+  XSETFASTINT (len, nargs);
+  val = Fmake_vector (len, Qnil);
 
   p = XVECTOR (val);
   for (i = 0; i < nargs; i++)
-    {
-      if (!NILP (Vpurify_flag))
-        args[i] = Fpurecopy (args[i]);
-      p->contents[i] = args[i];
-    }
-  XSETPVECTYPE (p, PVEC_COMPILED);
+    p->contents[i] = args[i];
+  make_byte_code (p);
   XSETCOMPILED (val, p);
   return val;
 }
@@ -3156,7 +3434,7 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
 union aligned_Lisp_Symbol
 {
   struct Lisp_Symbol s;
-#ifdef USE_LSB_TAG
+#if USE_LSB_TAG
   unsigned char c[(sizeof (struct Lisp_Symbol) + (1 << GCTYPEBITS) - 1)
                   & -(1 << GCTYPEBITS)];
 #endif
@@ -3164,7 +3442,7 @@ union aligned_Lisp_Symbol
 
 /* Each symbol_block is just under 1020 bytes long, since malloc
    really allocates in units of powers of two and uses 4 bytes for its
-   own overhead. */
+   own overhead.  */
 
 #define SYMBOL_BLOCK_SIZE \
   ((1020 - sizeof (struct symbol_block *)) / sizeof (union aligned_Lisp_Symbol))
@@ -3262,7 +3540,7 @@ Its value and function definition are void, and its property list is nil.  */)
 union aligned_Lisp_Misc
 {
   union Lisp_Misc m;
-#ifdef USE_LSB_TAG
+#if USE_LSB_TAG
   unsigned char c[(sizeof (union Lisp_Misc) + (1 << GCTYPEBITS) - 1)
                   & -(1 << GCTYPEBITS)];
 #endif
@@ -4070,7 +4348,34 @@ live_misc_p (struct mem_node *m, void *p)
 static inline int
 live_vector_p (struct mem_node *m, void *p)
 {
-  return (p == m->start && m->type == MEM_TYPE_VECTORLIKE);
+  if (m->type == MEM_TYPE_VECTOR_BLOCK)
+    {
+      /* This memory node corresponds to a vector block.  */
+      struct vector_block *block = (struct vector_block *) m->start;
+      struct Lisp_Vector *vector = (struct Lisp_Vector *) block->data;
+
+      /* P is in the block's allocation range.  Scan the block
+         up to P and see whether P points to the start of some
+         vector which is not on a free list.  FIXME: check whether
+         some allocation patterns (probably a lot of short vectors)
+         may cause a substantial overhead of this loop.  */
+      while (VECTOR_IN_BLOCK (vector, block)
+             && vector <= (struct Lisp_Vector *) p)
+        {
+          if ((vector->header.size & VECTOR_FREE_LIST_FLAG)
+              == VECTOR_FREE_LIST_FLAG)
+            vector = ADVANCE (vector, (vector->header.size
+                                       & (VECTOR_BLOCK_SIZE - 1)));
+          else if (vector == p)
+            return 1;
+          else
+            vector = ADVANCE (vector, vector->header.next.nbytes);
+        }
+    }
+  else if (m->type == MEM_TYPE_VECTORLIKE && p == m->start)
+    /* This memory node corresponds to a large vector.  */
+    return 1;
+  return 0;
 }
 
 
@@ -4217,14 +4522,10 @@ mark_maybe_pointer (void *p)
 {
   struct mem_node *m;
 
-  /* Quickly rule out some values which can't point to Lisp data.  */
-  if ((intptr_t) p %
-#ifdef USE_LSB_TAG
-      8 /* USE_LSB_TAG needs Lisp data to be aligned on multiples of 8.  */
-#else
-      2 /* We assume that Lisp data is aligned on even addresses.  */
-#endif
-      )
+  /* Quickly rule out some values which can't point to Lisp data.
+     USE_LSB_TAG needs Lisp data to be aligned on multiples of 1 << GCTYPEBITS.
+     Otherwise, assume that Lisp data is aligned on even addresses.  */
+  if ((intptr_t) p % (USE_LSB_TAG ? 1 << GCTYPEBITS : 2))
     return;
 
   m = mem_find (p);
@@ -4270,6 +4571,7 @@ mark_maybe_pointer (void *p)
           break;
 
         case MEM_TYPE_VECTORLIKE:
+        case MEM_TYPE_VECTOR_BLOCK:
           if (live_vector_p (m, p))
             {
               Lisp_Object tem;
@@ -4299,8 +4601,8 @@ mark_maybe_pointer (void *p)
    wider than a pointer might allocate a Lisp_Object in non-adjacent halves.
    If USE_LSB_TAG, the bottom half is not a valid pointer, but it should
    suffice to widen it to to a Lisp_Object and check it that way.  */
-#if defined USE_LSB_TAG || VAL_MAX < UINTPTR_MAX
-# if !defined USE_LSB_TAG && VAL_MAX < UINTPTR_MAX >> GCTYPEBITS
+#if USE_LSB_TAG || VAL_MAX < UINTPTR_MAX
+# if !USE_LSB_TAG && VAL_MAX < UINTPTR_MAX >> GCTYPEBITS
   /* If tag bits straddle pointer-word boundaries, neither mark_maybe_pointer
      nor mark_maybe_object can follow the pointers.  This should not occur on
      any practical porting target.  */
@@ -4361,7 +4663,7 @@ mark_memory (void *start, void *end)
         void *p = *(void **) ((char *) pp + i);
         mark_maybe_pointer (p);
         if (POINTERS_MIGHT_HIDE_IN_OBJECTS)
-          mark_maybe_object (widen_to_Lisp_Object (p));
+          mark_maybe_object (XIL ((intptr_t) p));
       }
 }
 
@@ -4703,6 +5005,7 @@ valid_lisp_object_p (Lisp_Object obj)
       return live_float_p (m, p);
 
     case MEM_TYPE_VECTORLIKE:
+    case MEM_TYPE_VECTOR_BLOCK:
       return live_vector_p (m, p);
 
     default:
@@ -4728,7 +5031,7 @@ static void *
 pure_alloc (size_t size, int type)
 {
   void *result;
-#ifdef USE_LSB_TAG
+#if USE_LSB_TAG
   size_t alignment = (1 << GCTYPEBITS);
 #else
   size_t alignment = sizeof (EMACS_INT);
@@ -6239,33 +6542,7 @@ gc_sweep (void)
         }
   }
 
-  /* Free all unmarked vectors */
-  {
-    register struct Lisp_Vector *vector = all_vectors, *prev = 0, *next;
-    total_vector_size = 0;
-
-    while (vector)
-      if (!VECTOR_MARKED_P (vector))
-        {
-          if (prev)
-            prev->header.next = vector->header.next;
-          else
-            all_vectors = vector->header.next.vector;
-          next = vector->header.next.vector;
-          lisp_free (vector);
-          vector = next;
-
-        }
-      else
-        {
-          VECTOR_UNMARK (vector);
-          if (vector->header.size & PSEUDOVECTOR_FLAG)
-            total_vector_size += PSEUDOVECTOR_SIZE_MASK & vector->header.size;
-          else
-            total_vector_size += vector->header.size;
-          prev = vector, vector = vector->header.next.vector;
-        }
-  }
+  sweep_vectors ();
 
 #ifdef GC_CHECK_STRING_BYTES
   if (!noninteractive)
@@ -6402,7 +6679,6 @@ init_alloc_once (void)
   Vdead = make_pure_string ("DEAD", 4, 4, 0);
 #endif
 
-  all_vectors = 0;
   ignore_warnings = 1;
 #ifdef DOUG_LEA_MALLOC
   mallopt (M_TRIM_THRESHOLD, 128*1024); /* trim threshold */
@@ -6415,6 +6691,7 @@ init_alloc_once (void)
   init_marker ();
   init_float ();
   init_intervals ();
+  init_vectors ();
   init_weak_hash_tables ();
 
 #ifdef REL_ALLOC
diff --git a/src/buffer.c b/src/buffer.c
index 20260d5a5d8..504d477494b 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -933,6 +933,21 @@ If VARIABLE does not have a buffer-local binding in BUFFER, the value
 is the default binding of the variable. */)
   (register Lisp_Object variable, register Lisp_Object buffer)
 {
+  register Lisp_Object result = buffer_local_value_1 (variable, buffer);
+
+  if (EQ (result, Qunbound))
+    xsignal1 (Qvoid_variable, variable);
+
+  return result;
+}
+
+
+/* Like Fbuffer_local_value, but return Qunbound if the variable is
+   locally unbound.  */
+
+Lisp_Object
+buffer_local_value_1 (Lisp_Object variable, Lisp_Object buffer)
+{
   register struct buffer *buf;
   register Lisp_Object result;
   struct Lisp_Symbol *sym;
@@ -985,10 +1000,7 @@ is the default binding of the variable. */)
     default: abort ();
     }
 
-  if (!EQ (result, Qunbound))
-    return result;
-
-  xsignal1 (Qvoid_variable, variable);
+  return result;
 }
 
 /* Return an alist of the Lisp-level buffer-local bindings of
@@ -5329,31 +5341,40 @@ the mode line appears at the bottom.  */);
   DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer, mode_line_format),
                      Qnil,
                      doc: /* Template for displaying mode line for current buffer.
-Each buffer has its own value of this variable.
-Value may be nil, a string, a symbol or a list or cons cell.
+
+The value may be nil, a string, a symbol or a list.
+
 A value of nil means don't display a mode line.
-For a symbol, its value is used (but it is ignored if t or nil).
- A string appearing directly as the value of a symbol is processed verbatim
- in that the %-constructs below are not recognized.
- Note that unless the symbol is marked as a `risky-local-variable', all
- properties in any strings, as well as all :eval and :propertize forms
- in the value of that symbol will be ignored.
-For a list of the form `(:eval FORM)', FORM is evaluated and the result
- is used as a mode line element.  Be careful--FORM should not load any files,
- because that can cause an infinite recursion.
-For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
- with the specified properties PROPS applied.
-For a list whose car is a symbol, the symbol's value is taken,
- and if that is non-nil, the cadr of the list is processed recursively.
- Otherwise, the caddr of the list (if there is one) is processed.
-For a list whose car is a string or list, each element is processed
- recursively and the results are effectively concatenated.
-For a list whose car is an integer, the cdr of the list is processed
-  and padded (if the number is positive) or truncated (if negative)
-  to the width specified by that number.
+
+For any symbol other than t or nil, the symbol's value is processed as
+ a mode line construct.  As a special exception, if that value is a
+ string, the string is processed verbatim, without handling any
+ %-constructs (see below).  Also, unless the symbol has a non-nil
+ `risky-local-variable' property, all properties in any strings, as
+ well as all :eval and :propertize forms in the value, are ignored.
+
+A list whose car is a string or list is processed by processing each
+ of the list elements recursively, as separate mode line constructs,
+ and concatenating the results.
+
+A list of the form `(:eval FORM)' is processed by evaluating FORM and
+ using the result as a mode line construct.  Be careful--FORM should
+ not load any files, because that can cause an infinite recursion.
+
+A list of the form `(:propertize ELT PROPS...)' is processed by
+ processing ELT as the mode line construct, and adding the text
+ properties PROPS to the result.
+
+A list whose car is a symbol is processed by examining the symbol's
+ value, and, if that value is non-nil, processing the cadr of the list
+ recursively; and if that value is nil, processing the caddr of the
+ list recursively.
+
+A list whose car is an integer is processed by processing the cadr of
+ the list, and padding (if the number is positive) or truncating (if
+ negative) to the width specified by that number.
+
 A string is printed verbatim in the mode line except for %-constructs:
-  (%-constructs are allowed when the string is the entire mode-line-format
-   or when it is found in a cons-cell or a list)
   %b -- print buffer name.      %f -- print visited file name.
   %F -- print frame name.
   %* -- print %, * or hyphen.   %+ -- print *, % or hyphen.
@@ -5501,7 +5522,13 @@ This variable has no effect if long lines are truncated (see
 `truncate-lines' and `truncate-partial-width-windows').  If you use
 word-wrapping, you might want to reduce the value of
 `truncate-partial-width-windows', since wrapping can make text readable
-in narrower windows.  */);
+in narrower windows.
+
+Instead of setting this variable directly, most users should use
+Visual Line mode .  Visual Line mode, when enabled, sets `word-wrap'
+to t, and additionally redefines simple editing commands to act on
+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),
diff --git a/src/buffer.h b/src/buffer.h
index 97d891f044b..3aa4b11c450 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -912,6 +912,7 @@ extern void validate_region (Lisp_Object *, Lisp_Object *);
 extern void set_buffer_internal (struct buffer *);
 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 void buffer_slot_type_mismatch (Lisp_Object, int) NO_RETURN;
 extern void fix_overlays_before (struct buffer *, ptrdiff_t, ptrdiff_t);
diff --git a/src/callint.c b/src/callint.c
index 506698a4e4e..bfa981ec65a 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -284,7 +284,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
 
   save_this_command = Vthis_command;
   save_this_original_command = Vthis_original_command;
-  save_real_this_command = real_this_command;
+  save_real_this_command = Vreal_this_command;
   save_last_command = KVAR (current_kboard, Vlast_command);
 
   if (NILP (keys))
@@ -295,7 +295,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
       key_count = ASIZE (keys);
     }
 
-  /* Save this now, since use of minibuffer will clobber it. */
+  /* Save this now, since use of minibuffer will clobber it.  */
   prefix_arg = Vcurrent_prefix_arg;
 
   if (SYMBOLP (function))
@@ -310,7 +310,8 @@ invoke it.  If KEYS is omitted or nil, the return value of
      The feature is not fully implemented.  */
   filter_specs = Qnil;
 
-  /* If k or K discard an up-event, save it here so it can be retrieved with U */
+  /* If k or K discard an up-event, save it here so it can be retrieved with
+     U.  */
   up_event = Qnil;
 
   /* Set SPECS to the interactive form, or barf if not interactive.  */
@@ -370,14 +371,14 @@ invoke it.  If KEYS is omitted or nil, the return value of
 
       Vthis_command = save_this_command;
       Vthis_original_command = save_this_original_command;
-      real_this_command= save_real_this_command;
+      Vreal_this_command = save_real_this_command;
       KVAR (current_kboard, Vlast_command) = save_last_command;
 
       temporarily_switch_to_single_kboard (NULL);
       return unbind_to (speccount, apply1 (function, specs));
     }
 
-  /* Here if function specifies a string to control parsing the defaults */
+  /* Here if function specifies a string to control parsing the defaults.  */
 
   /* Set next_event to point to the first event with parameters.  */
   for (next_event = 0; next_event < key_count; next_event++)
@@ -841,7 +842,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
 
   Vthis_command = save_this_command;
   Vthis_original_command = save_this_original_command;
-  real_this_command= save_real_this_command;
+  Vreal_this_command = save_real_this_command;
   KVAR (current_kboard, Vlast_command) = save_last_command;
 
   {
diff --git a/src/data.c b/src/data.c
index defcd06a2ed..4449977dbe0 100644
--- a/src/data.c
+++ b/src/data.c
@@ -1500,7 +1500,7 @@ The function `default-value' gets the default value and `set-default' sets it.
 {
   struct Lisp_Symbol *sym;
   struct Lisp_Buffer_Local_Value *blv = NULL;
-  union Lisp_Val_Fwd valcontents IF_LINT (= {0});
+  union Lisp_Val_Fwd valcontents IF_LINT (= {LISP_INITIALLY_ZERO});
   int forwarded IF_LINT (= 0);
 
   CHECK_SYMBOL (variable);
@@ -1577,7 +1577,7 @@ Instead, use `add-hook' and specify t for the LOCAL argument.  */)
 {
   register Lisp_Object tem;
   int forwarded IF_LINT (= 0);
-  union Lisp_Val_Fwd valcontents IF_LINT (= {0});
+  union Lisp_Val_Fwd valcontents IF_LINT (= {LISP_INITIALLY_ZERO});
   struct Lisp_Symbol *sym;
   struct Lisp_Buffer_Local_Value *blv = NULL;
 
diff --git a/src/dbusbind.c b/src/dbusbind.c
index e506380e607..d80bb21cd59 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -147,6 +147,10 @@ static int xd_in_read_queued_messages = 0;
 #endif
 
 /* Check whether TYPE is a basic DBusType.  */
+#ifdef HAVE_DBUS_TYPE_IS_VALID
+#define XD_BASIC_DBUS_TYPE(type)                                        \
+  (dbus_type_is_valid (type) && dbus_type_is_basic (type))
+#else
 #ifdef DBUS_TYPE_UNIX_FD
 #define XD_BASIC_DBUS_TYPE(type)                                        \
   ((type ==  DBUS_TYPE_BYTE)                                            \
@@ -177,6 +181,7 @@ static int xd_in_read_queued_messages = 0;
    || (type ==  DBUS_TYPE_OBJECT_PATH)                                  \
    || (type ==  DBUS_TYPE_SIGNATURE))
 #endif
+#endif
 
 /* This was a macro.  On Solaris 2.11 it was said to compile for
    hours, when optimization is enabled.  So we have transferred it into
@@ -524,7 +529,7 @@ xd_signature (char *signature, int dtype, int parent_type, Lisp_Object object)
 
 /* Convert X to a signed integer with bounds LO and HI.  */
 static intmax_t
-extract_signed (Lisp_Object x, intmax_t lo, intmax_t hi)
+xd_extract_signed (Lisp_Object x, intmax_t lo, intmax_t hi)
 {
   CHECK_NUMBER_OR_FLOAT (x);
   if (INTEGERP (x))
@@ -552,7 +557,7 @@ extract_signed (Lisp_Object x, intmax_t lo, intmax_t hi)
 
 /* Convert X to an unsigned integer with bounds 0 and HI.  */
 static uintmax_t
-extract_unsigned (Lisp_Object x, uintmax_t hi)
+xd_extract_unsigned (Lisp_Object x, uintmax_t hi)
 {
   CHECK_NUMBER_OR_FLOAT (x);
   if (INTEGERP (x))
@@ -611,9 +616,10 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
 
       case DBUS_TYPE_INT16:
         {
-          dbus_int16_t val = extract_signed (object,
-                                             TYPE_MINIMUM (dbus_int16_t),
-                                             TYPE_MAXIMUM (dbus_int16_t));
+          dbus_int16_t val =
+            xd_extract_signed (object,
+                               TYPE_MINIMUM (dbus_int16_t),
+                               TYPE_MAXIMUM (dbus_int16_t));
           int pval = val;
           XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
           if (!dbus_message_iter_append_basic (iter, dtype, &val))
@@ -623,8 +629,9 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
 
       case DBUS_TYPE_UINT16:
         {
-          dbus_uint16_t val = extract_unsigned (object,
-                                                TYPE_MAXIMUM (dbus_uint16_t));
+          dbus_uint16_t val =
+            xd_extract_unsigned (object,
+                                 TYPE_MAXIMUM (dbus_uint16_t));
           unsigned int pval = val;
           XD_DEBUG_MESSAGE ("%c %u", dtype, pval);
           if (!dbus_message_iter_append_basic (iter, dtype, &val))
@@ -634,9 +641,10 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
 
       case DBUS_TYPE_INT32:
         {
-          dbus_int32_t val = extract_signed (object,
-                                             TYPE_MINIMUM (dbus_int32_t),
-                                             TYPE_MAXIMUM (dbus_int32_t));
+          dbus_int32_t val =
+            xd_extract_signed (object,
+                               TYPE_MINIMUM (dbus_int32_t),
+                               TYPE_MAXIMUM (dbus_int32_t));
           int pval = val;
           XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
           if (!dbus_message_iter_append_basic (iter, dtype, &val))
@@ -649,8 +657,9 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
       case DBUS_TYPE_UNIX_FD:
 #endif
         {
-          dbus_uint32_t val = extract_unsigned (object,
-                                                TYPE_MAXIMUM (dbus_uint32_t));
+          dbus_uint32_t val =
+            xd_extract_unsigned (object,
+                                 TYPE_MAXIMUM (dbus_uint32_t));
           unsigned int pval = val;
           XD_DEBUG_MESSAGE ("%c %u", dtype, pval);
           if (!dbus_message_iter_append_basic (iter, dtype, &val))
@@ -660,9 +669,10 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
 
       case DBUS_TYPE_INT64:
         {
-          dbus_int64_t val = extract_signed (object,
-                                             TYPE_MINIMUM (dbus_int64_t),
-                                             TYPE_MAXIMUM (dbus_int64_t));
+          dbus_int64_t val =
+            xd_extract_signed (object,
+                               TYPE_MINIMUM (dbus_int64_t),
+                               TYPE_MAXIMUM (dbus_int64_t));
           printmax_t pval = val;
           XD_DEBUG_MESSAGE ("%c %"pMd, dtype, pval);
           if (!dbus_message_iter_append_basic (iter, dtype, &val))
@@ -672,8 +682,9 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
 
       case DBUS_TYPE_UINT64:
         {
-          dbus_uint64_t val = extract_unsigned (object,
-                                                TYPE_MAXIMUM (dbus_uint64_t));
+          dbus_uint64_t val =
+            xd_extract_unsigned (object,
+                                 TYPE_MAXIMUM (dbus_uint64_t));
           uprintmax_t pval = val;
           XD_DEBUG_MESSAGE ("%c %"pMu, dtype, pval);
           if (!dbus_message_iter_append_basic (iter, dtype, &val))
@@ -1271,7 +1282,7 @@ usage: (dbus-message-internal &rest REST)  */)
     }
   else /* DBUS_MESSAGE_TYPE_METHOD_RETURN, DBUS_MESSAGE_TYPE_ERROR  */
     {
-      serial = extract_unsigned (args[3], TYPE_MAXIMUM (dbus_uint32_t));
+      serial = xd_extract_unsigned (args[3], TYPE_MAXIMUM (dbus_uint32_t));
       count = 4;
     }
 
diff --git a/src/dispextern.h b/src/dispextern.h
index 3076a02b217..76e98437cf1 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1619,15 +1619,12 @@ struct face
   unsigned strike_through_color_defaulted_p : 1;
   unsigned box_color_defaulted_p : 1;
 
-  /* TTY appearances.  Blinking is not yet implemented.  Colors are
-     found in `lface' with empty color string meaning the default
-     color of the TTY.  */
+  /* TTY appearances.  Colors are found in `lface' with empty color
+     string meaning the default color of the TTY.  */
   unsigned tty_bold_p : 1;
-  unsigned tty_dim_p : 1;
+  unsigned tty_italic_p : 1;
   unsigned tty_underline_p : 1;
-  unsigned tty_alt_charset_p : 1;
   unsigned tty_reverse_p : 1;
-  unsigned tty_blinking_p : 1;
 
   /* 1 means that colors of this face may not be freed because they
      have been copied bitwise from a base face (see
@@ -2225,7 +2222,11 @@ struct it
   struct display_pos current;
 
   /* Total number of overlay strings to process.  This can be >
-     OVERLAY_STRING_CHUNK_SIZE.  */
+     OVERLAY_STRING_CHUNK_SIZE.  Value is dependable only when
+     current.overlay_string_index >= 0.  Use the latter to determine
+     whether an overlay string is being iterated over, because
+     n_overlay_strings can be positive even when we are not rendering
+     an overlay string.  */
   ptrdiff_t n_overlay_strings;
 
   /* The charpos where n_overlay_strings was calculated.  This should
@@ -2244,7 +2245,8 @@ struct it
 
   /* If non-nil, a Lisp string being processed.  If
      current.overlay_string_index >= 0, this is an overlay string from
-     pos.  */
+     pos.  Use STRINGP (it.string) to test whether we are rendering a
+     string or something else; do NOT use BUFFERP (it.object).  */
   Lisp_Object string;
 
   /* If non-nil, we are processing a string that came
@@ -2444,6 +2446,9 @@ struct it
      and continuation glyphs, or blanks that extend each line to the
      edge of the window on a TTY.
 
+     Do NOT use !BUFFERP (it.object) as a test whether we are
+     iterating over a string; use STRINGP (it.string) instead.
+
      Position is the current iterator position in object.  */
   Lisp_Object object;
   struct text_pos position;
@@ -3007,8 +3012,7 @@ enum tool_bar_item_image
 #define TTY_CAP_UNDERLINE       0x02
 #define TTY_CAP_BOLD            0x04
 #define TTY_CAP_DIM             0x08
-#define TTY_CAP_BLINK           0x10
-#define TTY_CAP_ALT_CHARSET     0x20
+#define TTY_CAP_ITALIC          0x10
 
 
 /***********************************************************************
diff --git a/src/doprnt.c b/src/doprnt.c
index df9ebc11f9c..b106ffb1938 100644
--- a/src/doprnt.c
+++ b/src/doprnt.c
@@ -392,15 +392,19 @@ doprnt (char *buffer, ptrdiff_t bufsize, const char *format,
                 {
                   /* Truncate the string at character boundary.  */
                   tem = bufsize;
-                  while (!CHAR_HEAD_P (string[tem - 1])) tem--;
-                  /* If the multibyte sequence of this character is
-                     too long for the space we have left in the
-                     buffer, truncate before it.  */
-                  if (tem > 0
-                      && BYTES_BY_CHAR_HEAD (string[tem - 1]) > bufsize)
-                    tem--;
-                  if (tem > 0)
-                    memcpy (bufptr, string, tem);
+                  do
+                    {
+                      tem--;
+                      if (CHAR_HEAD_P (string[tem]))
+                        {
+                          if (BYTES_BY_CHAR_HEAD (string[tem]) <= bufsize - tem)
+                            tem = bufsize;
+                          break;
+                        }
+                    }
+                  while (tem != 0);
+
+                  memcpy (bufptr, string, tem);
                   bufptr[tem] = 0;
                   /* Trigger exit from the loop, but make sure we
                      return to the caller a value which will indicate
diff --git a/src/emacs.c b/src/emacs.c
index 3477d92dc6f..0b679c7747a 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -107,19 +107,19 @@ static const char emacs_copyright[] = "Copyright (C) 2012 Free Software Foundati
 
 /* Make these values available in GDB, which doesn't see macros.  */
 
-#ifdef USE_LSB_TAG
+#if USE_LSB_TAG
 int gdb_use_lsb EXTERNALLY_VISIBLE = 1;
 #else
 int gdb_use_lsb EXTERNALLY_VISIBLE = 0;
 #endif
-#ifndef USE_LISP_UNION_TYPE
-int gdb_use_union EXTERNALLY_VISIBLE  = 0;
+#ifndef CHECK_LISP_OBJECT_TYPE
+int gdb_use_struct EXTERNALLY_VISIBLE = 0;
 #else
-int gdb_use_union EXTERNALLY_VISIBLE = 1;
+int gdb_use_struct EXTERNALLY_VISIBLE = 1;
 #endif
 int gdb_valbits EXTERNALLY_VISIBLE = VALBITS;
 int gdb_gctypebits EXTERNALLY_VISIBLE = GCTYPEBITS;
-#if defined (DATA_SEG_BITS) && ! defined (USE_LSB_TAG)
+#if defined DATA_SEG_BITS && !USE_LSB_TAG
 uintptr_t gdb_data_seg_bits EXTERNALLY_VISIBLE = DATA_SEG_BITS;
 #else
 uintptr_t gdb_data_seg_bits EXTERNALLY_VISIBLE = 0;
diff --git a/src/eval.c b/src/eval.c
index 1da841a4073..5a9327a99d8 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -790,6 +790,17 @@ usage: (defconst SYMBOL INITVALUE [DOCSTRING])  */)
   return sym;
 }
 
+/* Make SYMBOL lexically scoped.  */
+DEFUN ("internal-make-var-non-special", Fmake_var_non_special,
+       Smake_var_non_special, 1, 1, 0,
+       doc: /* Internal function.  */)
+     (Lisp_Object symbol)
+{
+  CHECK_SYMBOL (symbol);
+  XSYMBOL (symbol)->declared_special = 0;
+  return Qnil;
+}
+
 
 DEFUN ("let*", FletX, SletX, 1, UNEVALLED, 0,
        doc: /* Bind variables according to VARLIST then eval BODY.
@@ -1020,7 +1031,13 @@ definitions to shadow the loaded ones for use in file byte-compilation.  */)
           if (NILP (expander))
             break;
         }
-      form = apply1 (expander, XCDR (form));
+      {
+        Lisp_Object newform = apply1 (expander, XCDR (form));
+        if (EQ (form, newform))
+          break;
+        else
+          form = newform;
+      }
     }
   return form;
 }
@@ -3576,6 +3593,7 @@ alist of active lexical bindings.  */);
   defsubr (&Sdefvar);
   defsubr (&Sdefvaralias);
   defsubr (&Sdefconst);
+  defsubr (&Smake_var_non_special);
   defsubr (&Slet);
   defsubr (&SletX);
   defsubr (&Swhile);
diff --git a/src/fileio.c b/src/fileio.c
index c6e2eea5089..496f9d7efa4 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -3735,7 +3735,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
           /* If display currently starts at beginning of line,
              keep it that way.  */
           if (XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
-            XWINDOW (selected_window)->start_at_line_beg = Fbolp ();
+            XWINDOW (selected_window)->start_at_line_beg = !NILP (Fbolp ());
 
           replace_handled = 1;
         }
@@ -3892,7 +3892,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
       /* If display currently starts at beginning of line,
          keep it that way.  */
       if (XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
-        XWINDOW (selected_window)->start_at_line_beg = Fbolp ();
+        XWINDOW (selected_window)->start_at_line_beg = !NILP (Fbolp ());
 
       /* Replace the chars that we need to replace,
          and update INSERTED to equal the number of bytes
diff --git a/src/frame.c b/src/frame.c
index e962251f420..39d26ded5a6 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -331,7 +331,7 @@ make_frame (int mini_p)
       mini_window = make_window ();
       XWINDOW (root_window)->next = mini_window;
       XWINDOW (mini_window)->prev = root_window;
-      XWINDOW (mini_window)->mini_p = Qt;
+      XWINDOW (mini_window)->mini = 1;
       XWINDOW (mini_window)->frame = frame;
       f->minibuffer_window = mini_window;
     }
@@ -480,7 +480,7 @@ make_minibuffer_frame (void)
      as nil. */
 
   mini_window = f->minibuffer_window = f->root_window;
-  XWINDOW (mini_window)->mini_p = Qt;
+  XWINDOW (mini_window)->mini = 1;
   XWINDOW (mini_window)->next = Qnil;
   XWINDOW (mini_window)->prev = Qnil;
   XWINDOW (mini_window)->frame = frame;
@@ -1152,10 +1152,6 @@ other_visible_frames (FRAME_PTR f)
   described for Fdelete_frame.  */
 Lisp_Object
 delete_frame (Lisp_Object frame, Lisp_Object force)
-     /* If we use `register' here, gcc-4.0.2 on amd64 using
-        -DUSE_LISP_UNION_TYPE complains further down that we're getting the
-        address of `force'.  Go figure.  */
-
 {
   struct frame *f;
   struct frame *sf = SELECTED_FRAME ();
diff --git a/src/fringe.c b/src/fringe.c
index c591d391e9f..39f7e8dbb54 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -1671,23 +1671,27 @@ If FACE is nil, reset face to default fringe face.  */)
   (Lisp_Object bitmap, Lisp_Object face)
 {
   int n;
-  int face_id;
 
   CHECK_SYMBOL (bitmap);
   n = lookup_fringe_bitmap (bitmap);
   if (!n)
     error ("Undefined fringe bitmap");
 
+  /* The purpose of the following code is to signal an error if FACE
+     is not a face.  This is for the caller's convenience only; the
+     redisplay code should be able to fail gracefully.  Skip the check
+     if FRINGE_FACE_ID is unrealized (as in batch mode and during
+     daemon startup).  */
   if (!NILP (face))
     {
-      face_id = lookup_derived_face (SELECTED_FRAME (), face,
-                                     FRINGE_FACE_ID, 1);
-      if (face_id < 0)
+      struct frame *f = SELECTED_FRAME ();
+
+      if (FACE_FROM_ID (f, FRINGE_FACE_ID)
+          && lookup_derived_face (f, face, FRINGE_FACE_ID, 1) < 0)
         error ("No such face");
     }
 
   fringe_faces[n] = face;
-
   return Qnil;
 }
 
diff --git a/src/ftfont.c b/src/ftfont.c
index 5545b4b4ae2..bfce7425af4 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -525,7 +525,7 @@ static int ftfont_variation_glyphs (struct font *, int c,
 
 struct font_driver ftfont_driver =
   {
-    0,                          /* Qfreetype */
+    LISP_INITIALLY_ZERO,        /* Qfreetype */
     0,                          /* case insensitive */
     ftfont_get_cache,
     ftfont_list,
diff --git a/src/image.c b/src/image.c
index b6cdb6c8290..bd3a0822fe9 100644
--- a/src/image.c
+++ b/src/image.c
@@ -7599,19 +7599,14 @@ imagemagick_load_image (struct frame *f, struct image *img,
                         unsigned char *contents, unsigned int size,
                         char *filename)
 {
-  size_t width;
-  size_t height;
-
+  size_t width, height;
   MagickBooleanType status;
-
   XImagePtr ximg;
-  int x;
-  int y;
-
-  MagickWand  *image_wand;
-  MagickWand  *ping_wand;
+  int x, y;
+  MagickWand *image_wand;
+  MagickWand *ping_wand;
   PixelIterator *iterator;
-  PixelWand  **pixels;
+  PixelWand **pixels, *bg_wand = NULL;
   MagickPixelPacket  pixel;
   Lisp_Object image;
   Lisp_Object value;
@@ -7620,10 +7615,6 @@ imagemagick_load_image (struct frame *f, struct image *img,
   int desired_width, desired_height;
   double rotation;
   int pixelwidth;
-  ImageInfo  *image_info;
-  ExceptionInfo *exception;
-  Image * im_image;
-
 
   /* Handle image index for image types who can contain more than one image.
      Interface :index is same as for GIF.  First we "ping" the image to see how
@@ -7637,14 +7628,9 @@ imagemagick_load_image (struct frame *f, struct image *img,
   ping_wand = NewMagickWand ();
   /* MagickSetResolution (ping_wand, 2, 2);   (Bug#10112)  */
 
-  if (filename != NULL)
-    {
-      status = MagickPingImage (ping_wand, filename);
-    }
-  else
-    {
-      status = MagickPingImageBlob (ping_wand, contents, size);
-    }
+  status = filename
+    ? MagickPingImage (ping_wand, filename)
+    : MagickPingImageBlob (ping_wand, contents, size);
 
   if (status == MagickFalse)
     {
@@ -7653,7 +7639,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
       return 0;
     }
 
-  if (! (0 <= ino && ino < MagickGetNumberImages (ping_wand)))
+  if (ino < 0 || ino >= MagickGetNumberImages (ping_wand))
     {
       image_error ("Invalid image number `%s' in image `%s'",
                    image, img->spec);
@@ -7670,39 +7656,46 @@ imagemagick_load_image (struct frame *f, struct image *img,
   DestroyMagickWand (ping_wand);
 
   /* Now we know how many images are inside the file.  If it's not a
-     bundle, the number is one.  */
+     bundle, the number is one.  Load the image data.  */
 
-  if (filename != NULL)
-    {
-      image_info = CloneImageInfo ((ImageInfo *) NULL);
-      (void) strcpy (image_info->filename, filename);
-      image_info->number_scenes = 1;
-      image_info->scene = ino;
-      exception = AcquireExceptionInfo ();
-
-      im_image = ReadImage (image_info, exception);
-      DestroyExceptionInfo (exception);
+  image_wand = NewMagickWand ();
 
-      if (im_image == NULL)
-        goto imagemagick_no_wand;
-      image_wand = NewMagickWandFromImage (im_image);
-      DestroyImage (im_image);
-    }
-  else
+  if ((filename
+       ? MagickReadImage (image_wand, filename)
+       : MagickReadImageBlob (image_wand, contents, size))
+      == MagickFalse)
     {
-      image_wand = NewMagickWand ();
-      if (MagickReadImageBlob (image_wand, contents, size) == MagickFalse)
-        {
-          imagemagick_error (image_wand);
-          goto imagemagick_error;
-        }
+      imagemagick_error (image_wand);
+      goto imagemagick_error;
     }
 
+  /* Retrieve the frame's background color, for use later.  */
+  {
+    XColor bgcolor;
+    Lisp_Object specified_bg;
+
+    specified_bg = image_spec_value (img->spec, QCbackground, NULL);
+    if (!STRINGP (specified_bg)
+        || !x_defined_color (f, SSDATA (specified_bg), &bgcolor, 0))
+      {
+#ifndef HAVE_NS
+        bgcolor.pixel = FRAME_BACKGROUND_PIXEL (f);
+        x_query_color (f, &bgcolor);
+#else
+        ns_query_color (FRAME_BACKGROUND_COLOR (f), &bgcolor, 1);
+#endif
+      }
+
+    bg_wand = NewPixelWand ();
+    PixelSetRed   (bg_wand, (double) bgcolor.red   / 65535);
+    PixelSetGreen (bg_wand, (double) bgcolor.green / 65535);
+    PixelSetBlue  (bg_wand, (double) bgcolor.blue  / 65535);
+  }
+
   /* If width and/or height is set in the display spec assume we want
      to scale to those values.  If either h or w is unspecified, the
      unspecified should be calculated from the specified to preserve
      aspect ratio.  */
-
   value = image_spec_value (img->spec, QCwidth, NULL);
   desired_width = (INTEGERP (value)  ? XFASTINT (value) : -1);
   value = image_spec_value (img->spec, QCheight, NULL);
@@ -7768,13 +7761,8 @@ imagemagick_load_image (struct frame *f, struct image *img,
   value = image_spec_value (img->spec, QCrotation, NULL);
   if (FLOATP (value))
     {
-      PixelWand* background = NewPixelWand ();
-      PixelSetColor (background, "#ffffff");/*TODO remove hardcode*/
-
       rotation = extract_float (value);
-
-      status = MagickRotateImage (image_wand, background, rotation);
-      DestroyPixelWand (background);
+      status = MagickRotateImage (image_wand, bg_wand, rotation);
       if (status == MagickFalse)
         {
           image_error ("Imagemagick image rotate failed", Qnil, Qnil);
@@ -7788,6 +7776,22 @@ imagemagick_load_image (struct frame *f, struct image *img,
   height = MagickGetImageHeight (image_wand);
   width = MagickGetImageWidth (image_wand);
 
+  /* Set the canvas background color to the frame or specified
+     background, and flatten the image.  Note: as of ImageMagick
+     6.6.0, SVG image transparency is not handled properly
+     (e.g. etc/images/splash.svg shows a white background always).  */
+  {
+    MagickWand *new_wand;
+    MagickSetImageBackgroundColor (image_wand, bg_wand);
+#ifdef HAVE_MAGICKMERGEIMAGELAYERS
+    new_wand = MagickMergeImageLayers (image_wand, MergeLayer);
+#else
+    new_wand = MagickFlattenImages (image_wand);
+#endif
+    DestroyMagickWand (image_wand);
+    image_wand = new_wand;
+  }
+
   if (! (width <= INT_MAX && height <= INT_MAX
          && check_image_size (f, width, height)))
     {
@@ -7800,7 +7804,50 @@ imagemagick_load_image (struct frame *f, struct image *img,
 
   init_color_table ();
 
-  if (imagemagick_render_type == 0)
+#ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
+  if (imagemagick_render_type != 0)
+    {
+      /* Magicexportimage is normally faster than pixelpushing.  This
+         method is also well tested.  Some aspects of this method are
+         ad-hoc and needs to be more researched. */
+      int imagedepth = 24; /*MagickGetImageDepth(image_wand);*/
+      const char *exportdepth = imagedepth <= 8 ? "I" : "BGRP"; /*"RGBP";*/
+      /* Try to create a x pixmap to hold the imagemagick pixmap.  */
+      if (!x_create_x_image_and_pixmap (f, width, height, imagedepth,
+                                        &ximg, &img->pixmap))
+        {
+#ifdef COLOR_TABLE_SUPPORT
+          free_color_table ();
+#endif
+          image_error ("Imagemagick X bitmap allocation failure", Qnil, Qnil);
+          goto imagemagick_error;
+        }
+
+      /* Oddly, the below code doesn't seem to work:*/
+      /* switch(ximg->bitmap_unit){ */
+      /* case 8: */
+      /*   pixelwidth=CharPixel; */
+      /*   break; */
+      /* case   16: */
+      /*   pixelwidth=ShortPixel; */
+      /*   break; */
+      /* case   32: */
+      /*   pixelwidth=LongPixel; */
+      /*   break; */
+      /* } */
+      /*
+        Here im just guessing the format of the bitmap.
+        happens to work fine for:
+        - bw djvu images
+        on rgb display.
+        seems about 3 times as fast as pixel pushing(not carefully measured)
+      */
+      pixelwidth = CharPixel; /*??? TODO figure out*/
+      MagickExportImagePixels (image_wand, 0, 0, width, height,
+                               exportdepth, pixelwidth, ximg->data);
+    }
+  else
+#endif /* HAVE_MAGICKEXPORTIMAGEPIXELS */
     {
       size_t image_height;
 
@@ -7850,59 +7897,6 @@ imagemagick_load_image (struct frame *f, struct image *img,
         }
       DestroyPixelIterator (iterator);
     }
-  else                          /* imagemagick_render_type != 0 */
-    {
-      /* Magicexportimage is normally faster than pixelpushing.  This
-         method is also well tested. Some aspects of this method are
-         ad-hoc and needs to be more researched. */
-      int imagedepth = 24;/*MagickGetImageDepth(image_wand);*/
-      const char *exportdepth = imagedepth <= 8 ? "I" : "BGRP";/*"RGBP";*/
-      /* Try to create a x pixmap to hold the imagemagick pixmap.  */
-      if (!x_create_x_image_and_pixmap (f, width, height, imagedepth,
-                                        &ximg, &img->pixmap))
-        {
-#ifdef COLOR_TABLE_SUPPORT
-          free_color_table ();
-#endif
-          image_error ("Imagemagick X bitmap allocation failure", Qnil, Qnil);
-          goto imagemagick_error;
-        }
-
-
-      /* Oddly, the below code doesn't seem to work:*/
-      /* switch(ximg->bitmap_unit){ */
-      /* case 8: */
-      /*   pixelwidth=CharPixel; */
-      /*   break; */
-      /* case   16: */
-      /*   pixelwidth=ShortPixel; */
-      /*   break; */
-      /* case   32: */
-      /*   pixelwidth=LongPixel; */
-      /*   break; */
-      /* } */
-      /*
-        Here im just guessing the format of the bitmap.
-        happens to work fine for:
-        - bw djvu images
-        on rgb display.
-        seems about 3 times as fast as pixel pushing(not carefully measured)
-      */
-      pixelwidth = CharPixel;/*??? TODO figure out*/
-#ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
-      MagickExportImagePixels (image_wand,
-                               0, 0,
-                               width, height,
-                               exportdepth,
-                               pixelwidth,
-                               /*&(img->pixmap));*/
-                               ximg->data);
-#else
-      image_error ("You don't have MagickExportImagePixels, upgrade ImageMagick!",
-                   Qnil, Qnil);
-#endif
-    }
-
 
 #ifdef COLOR_TABLE_SUPPORT
   /* Remember colors allocated for this image.  */
@@ -7910,7 +7904,6 @@ imagemagick_load_image (struct frame *f, struct image *img,
   free_color_table ();
 #endif /* COLOR_TABLE_SUPPORT */
 
-
   img->width  = width;
   img->height = height;
 
@@ -7919,9 +7912,10 @@ imagemagick_load_image (struct frame *f, struct image *img,
   x_put_x_image (f, ximg, img->pixmap, width, height);
   x_destroy_x_image (ximg);
 
-
   /* Final cleanup. image_wand should be the only resource left. */
   DestroyMagickWand (image_wand);
+  if (bg_wand) DestroyPixelWand (bg_wand);
+
   /* `MagickWandTerminus' terminates the imagemagick environment.  */
   MagickWandTerminus ();
 
@@ -7929,7 +7923,8 @@ imagemagick_load_image (struct frame *f, struct image *img,
 
  imagemagick_error:
   DestroyMagickWand (image_wand);
- imagemagick_no_wand:
+  if (bg_wand) DestroyPixelWand (bg_wand);
+
   MagickWandTerminus ();
   /* TODO more cleanup.  */
   image_error ("Error parsing IMAGEMAGICK image `%s'", img->spec, Qnil);
diff --git a/src/keyboard.c b/src/keyboard.c
index 37ac8192558..ba473ac8a2b 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -217,9 +217,6 @@ uintmax_t num_input_events;
 
 static EMACS_INT last_auto_save;
 
-/* This is like Vthis_command, except that commands never set it.  */
-Lisp_Object real_this_command;
-
 /* The value of point when the last command was started.  */
 static ptrdiff_t last_point_position;
 
@@ -1379,9 +1376,9 @@ command_loop_1 (void)
 
   /* Do this after running Vpost_command_hook, for consistency.  */
   KVAR (current_kboard, Vlast_command) = Vthis_command;
-  KVAR (current_kboard, Vreal_last_command) = real_this_command;
+  KVAR (current_kboard, Vreal_last_command) = Vreal_this_command;
   if (!CONSP (last_command_event))
-    KVAR (current_kboard, Vlast_repeatable_command) = real_this_command;
+    KVAR (current_kboard, Vlast_repeatable_command) = Vreal_this_command;
 
   while (1)
     {
@@ -1448,7 +1445,7 @@ command_loop_1 (void)
       before_command_echo_length = echo_length ();
 
       Vthis_command = Qnil;
-      real_this_command = Qnil;
+      Vreal_this_command = Qnil;
       Vthis_original_command = Qnil;
       Vthis_command_keys_shift_translated = Qnil;
 
@@ -1487,10 +1484,10 @@ command_loop_1 (void)
          from that position.  But also throw away beg_unchanged and
          end_unchanged information in that case, so that redisplay will
          update the whole window properly.  */
-      if (!NILP (XWINDOW (selected_window)->force_start))
+      if (XWINDOW (selected_window)->force_start)
         {
           struct buffer *b;
-          XWINDOW (selected_window)->force_start = Qnil;
+          XWINDOW (selected_window)->force_start = 0;
           b = XBUFFER (XWINDOW (selected_window)->buffer);
           BUF_BEG_UNCHANGED (b) = BUF_END_UNCHANGED (b) = 0;
         }
@@ -1532,7 +1529,7 @@ command_loop_1 (void)
       /* Execute the command.  */
 
       Vthis_command = cmd;
-      real_this_command = cmd;
+      Vreal_this_command = cmd;
       safe_run_hooks (Qpre_command_hook);
 
       already_adjusted = 0;
@@ -1616,12 +1613,14 @@ command_loop_1 (void)
          If the command didn't actually create a prefix arg,
          but is merely a frame event that is transparent to prefix args,
          then the above doesn't apply.  */
-      if (NILP (KVAR (current_kboard, Vprefix_arg)) || CONSP (last_command_event))
+      if (NILP (KVAR (current_kboard, Vprefix_arg))
+          || CONSP (last_command_event))
         {
           KVAR (current_kboard, Vlast_command) = Vthis_command;
-          KVAR (current_kboard, Vreal_last_command) = real_this_command;
+          KVAR (current_kboard, Vreal_last_command) = Vreal_this_command;
           if (!CONSP (last_command_event))
-            KVAR (current_kboard, Vlast_repeatable_command) = real_this_command;
+            KVAR (current_kboard, Vlast_repeatable_command)
+              = Vreal_this_command;
           cancel_echoing ();
           this_command_key_count = 0;
           this_command_key_count_reset = 0;
@@ -11488,9 +11487,6 @@ syms_of_keyboard (void)
   staticpro (&tool_bar_items_vector);
   tool_bar_items_vector = Qnil;
 
-  staticpro (&real_this_command);
-  real_this_command = Qnil;
-
   DEFSYM (Qtimer_event_handler, "timer-event-handler");
   DEFSYM (Qdisabled_command_function, "disabled-command-function");
   DEFSYM (Qself_insert_command, "self-insert-command");
@@ -11748,12 +11744,14 @@ was a kill command.
 See Info node `(elisp)Multiple Terminals'.  */);
 
   DEFVAR_KBOARD ("real-last-command", Vreal_last_command,
-                 doc: /* Same as `last-command', but never altered by Lisp code.  */);
+                 doc: /* Same as `last-command', but never altered by Lisp code.
+Taken from the previous value of `real-this-command'.  */);
 
   DEFVAR_KBOARD ("last-repeatable-command", Vlast_repeatable_command,
                  doc: /* Last command that may be repeated.
 The last command executed that was not bound to an input event.
-This is the command `repeat' will try to repeat.  */);
+This is the command `repeat' will try to repeat.
+Taken from a previous value of `real-this-command'.  */);
 
   DEFVAR_LISP ("this-command", Vthis_command,
                doc: /* The command now being executed.
@@ -11761,6 +11759,10 @@ The command can set this variable; whatever is put here
 will be in `last-command' during the following command.  */);
   Vthis_command = Qnil;
 
+  DEFVAR_LISP ("real-this-command", Vreal_this_command,
+               doc: /* This is like `this-command', except that commands should never modify it.  */);
+  Vreal_this_command = Qnil;
+
   DEFVAR_LISP ("this-command-keys-shift-translated",
                Vthis_command_keys_shift_translated,
                doc: /* Non-nil if the key sequence activating this command was shift-translated.
diff --git a/src/lisp.h b/src/lisp.h
index 5e64392ec78..c655413544c 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -149,22 +149,18 @@ extern int suppress_checking EXTERNALLY_VISIBLE;
 #endif
 #endif /* ENABLE_CHECKING */
 
-/* Use the configure flag --enable-use-lisp-union-type to make
-   Lisp_Object use a union type instead of the default int.  The flag
-   causes USE_LISP_UNION_TYPE to be defined.  */
+/* Use the configure flag --enable-check-lisp-object-type to make
+   Lisp_Object use a struct type instead of the default int.  The flag
+   causes CHECK_LISP_OBJECT_TYPE to be defined.  */
 
 /***** Select the tagging scheme.  *****/
-/* There are basically two options that control the tagging scheme:
-   - USE_LISP_UNION_TYPE says that Lisp_Object should be a union instead
-     of an integer.
+/* The following option controls the tagging scheme:
    - USE_LSB_TAG means that we can assume the least 3 bits of pointers are
      always 0, and we can thus use them to hold tag bits, without
      restricting our addressing space.
 
-   If USE_LSB_TAG is not set, then we use the top 3 bits for tagging, thus
-   restricting our possible address range.  Currently USE_LSB_TAG is not
-   allowed together with a union.  This is not due to any fundamental
-   technical (or political ;-) problem: nobody wrote the code to do it yet.
+   If ! USE_LSB_TAG, then use the top 3 bits for tagging, thus
+   restricting our possible address range.
 
    USE_LSB_TAG not only requires the least 3 bits of pointers returned by
    malloc to be 0 but also needs to be able to impose a mult-of-8 alignment
@@ -201,25 +197,31 @@ extern int suppress_checking EXTERNALLY_VISIBLE;
 # endif
 #endif
 
-/* Let's USE_LSB_TAG on systems where we know malloc returns mult-of-8.  */
-#if (defined GNU_MALLOC || defined DOUG_LEA_MALLOC || defined __GLIBC__ \
-     || defined DARWIN_OS || defined __sun)
-/* We also need to be able to specify mult-of-8 alignment on static vars.  */
-# if defined DECL_ALIGN
-/* On hosts where pointers-as-ints do not exceed VAL_MAX,
-   USE_LSB_TAG is:
+/* Unless otherwise specified, use USE_LSB_TAG on systems where:  */
+#ifndef USE_LSB_TAG
+/* 1.  We know malloc returns a multiple of 8.  */
+# if (defined GNU_MALLOC || defined DOUG_LEA_MALLOC || defined __GLIBC__ \
+      || defined DARWIN_OS || defined __sun)
+/* 2.  We can specify multiple-of-8 alignment on static variables.  */
+#  ifdef DECL_ALIGN
+/* 3.  Pointers-as-ints exceed VAL_MAX.
+   On hosts where pointers-as-ints do not exceed VAL_MAX, USE_LSB_TAG is:
     a. unnecessary, because the top bits of an EMACS_INT are unused, and
     b. slower, because it typically requires extra masking.
-   So, define USE_LSB_TAG only on hosts where it might be useful.  */
-#  if VAL_MAX < UINTPTR_MAX
-#   define USE_LSB_TAG
+   So, default USE_LSB_TAG to 1 only on hosts where it might be useful.  */
+#   if VAL_MAX < UINTPTR_MAX
+#    define USE_LSB_TAG 1
+#   endif
 #  endif
 # endif
 #endif
+#ifndef USE_LSB_TAG
+# define USE_LSB_TAG 0
+#endif
 
 /* If we cannot use 8-byte alignment, make DECL_ALIGN a no-op.  */
 #ifndef DECL_ALIGN
-# ifdef USE_LSB_TAG
+# if USE_LSB_TAG
 #  error "USE_LSB_TAG used without defining DECL_ALIGN"
 # endif
 # define DECL_ALIGN(type, var) type var
@@ -233,11 +235,6 @@ extern int suppress_checking EXTERNALLY_VISIBLE;
    e.g -2^28..2^28-1 to -2^29..2^29-1.  */
 #define USE_2_TAGS_FOR_INTS
 
-/* Making it work for the union case is too much trouble.  */
-#ifdef USE_LISP_UNION_TYPE
-# undef USE_2_TAGS_FOR_INTS
-#endif
-
 /* This is the set of Lisp data types.  */
 
 #if !defined USE_2_TAGS_FOR_INTS
@@ -248,7 +245,7 @@ extern int suppress_checking EXTERNALLY_VISIBLE;
 #else
 # define LISP_INT_TAG Lisp_Int0
 # define case_Lisp_Int case Lisp_Int0: case Lisp_Int1
-# ifdef USE_LSB_TAG
+# if USE_LSB_TAG
 #  define LISP_INT1_TAG 4
 #  define LISP_STRING_TAG 1
 #  define LISP_INT_TAG_P(x) (((x) & 3) == 0)
@@ -331,80 +328,36 @@ enum Lisp_Fwd_Type
     Lisp_Fwd_Kboard_Obj,        /* Fwd to a Lisp_Object field of kboards.  */
   };
 
-#ifdef USE_LISP_UNION_TYPE
-
-#ifndef WORDS_BIGENDIAN
+#ifdef CHECK_LISP_OBJECT_TYPE
 
-/* Definition of Lisp_Object for little-endian machines.  */
+typedef struct { EMACS_INT i; } Lisp_Object;
 
-typedef
-union Lisp_Object
-  {
-    /* Used for comparing two Lisp_Objects;
-       also, positive integers can be accessed fast this way.  */
-    EMACS_INT i;
-
-    struct
-      {
-        /* Use explicit signed, the signedness of a bit-field of type
-           int is implementation defined.  */
-        signed EMACS_INT val  : VALBITS;
-        ENUM_BF (Lisp_Type) type : GCTYPEBITS;
-      } s;
-    struct
-      {
-        EMACS_UINT val : VALBITS;
-        ENUM_BF (Lisp_Type) type : GCTYPEBITS;
-      } u;
-  }
-Lisp_Object;
-
-#else /* If WORDS_BIGENDIAN */
-
-typedef
-union Lisp_Object
-  {
-    /* Used for comparing two Lisp_Objects;
-       also, positive integers can be accessed fast this way.  */
-    EMACS_INT i;
-
-    struct
-      {
-        ENUM_BF (Lisp_Type) type : GCTYPEBITS;
-        /* Use explicit signed, the signedness of a bit-field of type
-           int is implementation defined.  */
-        signed EMACS_INT val  : VALBITS;
-      } s;
-    struct
-      {
-        ENUM_BF (Lisp_Type) type : GCTYPEBITS;
-        EMACS_UINT val : VALBITS;
-      } u;
-  }
-Lisp_Object;
-
-#endif /* WORDS_BIGENDIAN */
+#define XLI(o) (o).i
+static inline Lisp_Object
+XIL (EMACS_INT i)
+{
+  Lisp_Object o = { i };
+  return o;
+}
 
-#ifdef __GNUC__
 static inline Lisp_Object
 LISP_MAKE_RVALUE (Lisp_Object o)
 {
     return o;
 }
-#else
-/* This is more portable to pre-C99 non-GCC compilers, but for
-   backwards compatibility GCC still accepts an old GNU extension
-   which caused this to only generate a warning.  */
-#define LISP_MAKE_RVALUE(o) (0 ? (o) : (o))
-#endif
 
-#else /* USE_LISP_UNION_TYPE */
+#define LISP_INITIALLY_ZERO {0}
 
-/* If union type is not wanted, define Lisp_Object as just a number.  */
+#else /* CHECK_LISP_OBJECT_TYPE */
+
+/* If a struct type is not wanted, define Lisp_Object as just a number.  */
 
 typedef EMACS_INT Lisp_Object;
+#define XLI(o) (o)
+#define XIL(i) (i)
 #define LISP_MAKE_RVALUE(o) (0+(o))
-#endif /* USE_LISP_UNION_TYPE */
+#define LISP_INITIALLY_ZERO 0
+#endif /* CHECK_LISP_OBJECT_TYPE */
 
 /* In the size word of a vector, this bit means the vector has been marked.  */
 
@@ -466,30 +419,28 @@ enum pvec_type
  For example, if tem is a Lisp_Object whose type is Lisp_Cons,
  XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons.  */
 
-#ifndef USE_LISP_UNION_TYPE
-
 /* Return a perfect hash of the Lisp_Object representation.  */
-#define XHASH(a) (a)
+#define XHASH(a) XLI(a)
 
-#ifdef USE_LSB_TAG
+#if USE_LSB_TAG
 
 #define TYPEMASK ((((EMACS_INT) 1) << GCTYPEBITS) - 1)
-#define XTYPE(a) ((enum Lisp_Type) ((a) & TYPEMASK))
+#define XTYPE(a) ((enum Lisp_Type) (XLI(a) & TYPEMASK))
 #ifdef USE_2_TAGS_FOR_INTS
-# define XINT(a) (((EMACS_INT) (a)) >> (GCTYPEBITS - 1))
-# define XUINT(a) (((EMACS_UINT) (a)) >> (GCTYPEBITS - 1))
-# define make_number(N) (((EMACS_INT) (N)) << (GCTYPEBITS - 1))
+# define XINT(a) (((EMACS_INT) XLI(a)) >> (GCTYPEBITS - 1))
+# define XUINT(a) (((EMACS_UINT) XLI(a)) >> (GCTYPEBITS - 1))
+# define make_number(N) XIL(((EMACS_INT) (N)) << (GCTYPEBITS - 1))
 #else
-# define XINT(a) (((EMACS_INT) (a)) >> GCTYPEBITS)
-# define XUINT(a) (((EMACS_UINT) (a)) >> GCTYPEBITS)
-# define make_number(N) (((EMACS_INT) (N)) << GCTYPEBITS)
+# define XINT(a) (((EMACS_INT) XLI(a)) >> GCTYPEBITS)
+# define XUINT(a) (((EMACS_UINT) XLI(a)) >> GCTYPEBITS)
+# define make_number(N) XIL(((EMACS_INT) (N)) << GCTYPEBITS)
 #endif
-#define XSET(var, type, ptr)                                            \
-    (eassert (XTYPE ((intptr_t) (ptr)) == 0), /* Check alignment.  */ \
-     (var) = (type) | (intptr_t) (ptr))
+#define XSET(var, type, ptr)                                               \
+  (eassert (XTYPE (XIL((intptr_t) (ptr))) == 0), /* Check alignment.  */   \
+   (var) = XIL((type) | (intptr_t) (ptr)))
 
-#define XPNTR(a) ((intptr_t) ((a) & ~TYPEMASK))
-#define XUNTAG(a, type) ((intptr_t) ((a) - (type)))
+#define XPNTR(a) ((intptr_t) (XLI(a) & ~TYPEMASK))
+#define XUNTAG(a, type) ((intptr_t) (XLI(a) - (type)))
 
 #else  /* not USE_LSB_TAG */
 
@@ -499,95 +450,42 @@ enum pvec_type
    (doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
     on all machines, but would penalize machines which don't need it)
  */
-#define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) (a)) >> VALBITS))
+#define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) XLI(a)) >> VALBITS))
 
 /* For integers known to be positive, XFASTINT provides fast retrieval
    and XSETFASTINT provides fast storage.  This takes advantage of the
    fact that Lisp_Int is 0.  */
-#define XFASTINT(a) ((a) + 0)
-#define XSETFASTINT(a, b) ((a) = (b))
+#define XFASTINT(a) (XLI(a) + 0)
+#define XSETFASTINT(a, b) ((a) = XIL(b))
 
 /* Extract the value of a Lisp_Object as a (un)signed integer.  */
 
 #ifdef USE_2_TAGS_FOR_INTS
-# define XINT(a) ((((EMACS_INT) (a)) << (GCTYPEBITS - 1)) >> (GCTYPEBITS - 1))
-# define XUINT(a) ((EMACS_UINT) ((a) & (1 + (VALMASK << 1))))
-# define make_number(N) ((((EMACS_INT) (N)) & (1 + (VALMASK << 1))))
+# define XINT(a) ((((EMACS_INT) XLI(a)) << (GCTYPEBITS - 1)) >> (GCTYPEBITS - 1))
+# define XUINT(a) ((EMACS_UINT) (XLI(a) & (1 + (VALMASK << 1))))
+# define make_number(N) XIL((((EMACS_INT) (N)) & (1 + (VALMASK << 1))))
 #else
-# define XINT(a) ((((EMACS_INT) (a)) << (BITS_PER_EMACS_INT - VALBITS)) \
-                 >> (BITS_PER_EMACS_INT - VALBITS))
-# define XUINT(a) ((EMACS_UINT) ((a) & VALMASK))
+# define XINT(a) ((((EMACS_INT) XLI(a)) << (BITS_PER_EMACS_INT - VALBITS))    \
+                  >> (BITS_PER_EMACS_INT - VALBITS))
+# define XUINT(a) ((EMACS_UINT) (XLI(a) & VALMASK))
 # define make_number(N)         \
-  ((((EMACS_INT) (N)) & VALMASK) | ((EMACS_INT) Lisp_Int) << VALBITS)
+  XIL((((EMACS_INT) (N)) & VALMASK) | ((EMACS_INT) Lisp_Int) << VALBITS)
 #endif
 
 #define XSET(var, type, ptr)                              \
-   ((var) = ((EMACS_INT) ((EMACS_UINT) (type) << VALBITS) \
-             + ((intptr_t) (ptr) & VALMASK)))
+   ((var) = XIL((EMACS_INT) ((EMACS_UINT) (type) << VALBITS) \
+                + ((intptr_t) (ptr) & VALMASK)))
 
 #ifdef DATA_SEG_BITS
 /* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
    which were stored in a Lisp_Object */
-#define XPNTR(a) ((uintptr_t) (((a) & VALMASK)) | DATA_SEG_BITS))
+#define XPNTR(a) ((uintptr_t) ((XLI(a) & VALMASK)) | DATA_SEG_BITS))
 #else
-#define XPNTR(a) ((uintptr_t) ((a) & VALMASK))
+#define XPNTR(a) ((uintptr_t) (XLI(a) & VALMASK))
 #endif
 
 #endif /* not USE_LSB_TAG */
 
-#else /* USE_LISP_UNION_TYPE */
-
-#ifdef USE_2_TAGS_FOR_INTS
-# error "USE_2_TAGS_FOR_INTS is not supported with USE_LISP_UNION_TYPE"
-#endif
-
-#define XHASH(a) ((a).i)
-#define XTYPE(a) ((enum Lisp_Type) (a).u.type)
-#define XINT(a) ((EMACS_INT) (a).s.val)
-#define XUINT(a) ((EMACS_UINT) (a).u.val)
-
-#ifdef USE_LSB_TAG
-
-# define XSET(var, vartype, ptr) \
-  (eassert ((((uintptr_t) (ptr)) & ((1 << GCTYPEBITS) - 1)) == 0),      \
-   (var).u.val = ((uintptr_t) (ptr)) >> GCTYPEBITS,                     \
-   (var).u.type = ((char) (vartype)))
-
-/* Some versions of gcc seem to consider the bitfield width when issuing
-   the "cast to pointer from integer of different size" warning, so the
-   cast is here to widen the value back to its natural size.  */
-# define XPNTR(v) ((intptr_t) (v).s.val << GCTYPEBITS)
-
-#else  /* !USE_LSB_TAG */
-
-/* For integers known to be positive, XFASTINT provides fast retrieval
-   and XSETFASTINT provides fast storage.  This takes advantage of the
-   fact that Lisp_Int is 0.  */
-# define XFASTINT(a) ((a).i + 0)
-# define XSETFASTINT(a, b) ((a).i = (b))
-
-# define XSET(var, vartype, ptr) \
-   (((var).s.val = ((intptr_t) (ptr))), ((var).s.type = ((char) (vartype))))
-
-#ifdef DATA_SEG_BITS
-/* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
-   which were stored in a Lisp_Object */
-#define XPNTR(a) ((intptr_t) (XUINT (a) | DATA_SEG_BITS))
-#else
-#define XPNTR(a) ((intptr_t) XUINT (a))
-#endif
-
-#endif  /* !USE_LSB_TAG */
-
-#if __GNUC__ >= 2 && defined (__OPTIMIZE__)
-#define make_number(N) \
-  (__extension__ ({ Lisp_Object _l; _l.s.val = (N); _l.s.type = Lisp_Int; _l; }))
-#else
-extern Lisp_Object make_number (EMACS_INT);
-#endif
-
-#endif /* USE_LISP_UNION_TYPE */
-
 /* For integers known to be positive, XFASTINT sometimes provides
    faster retrieval and XSETFASTINT provides faster storage.
    If not, fallback on the non-accelerated path.  */
@@ -920,11 +818,15 @@ struct vectorlike_header
   {
     ptrdiff_t size;
 
-    /* Pointer to the next vector-like object.  It is generally a buffer or a
+    /* When the vector is allocated from a vector block, NBYTES is used
+       if the vector is not on a free list, and VECTOR is used otherwise.
+       For large vector-like objects, BUFFER or VECTOR is used as a pointer
+       to the next vector-like object.  It is generally a buffer or a 
        Lisp_Vector alias, so for convenience it is a union instead of a
        pointer: this way, one can write P->next.vector instead of ((struct
        Lisp_Vector *) P->next).  */
     union {
+      ptrdiff_t nbytes;
       struct buffer *buffer;
       struct Lisp_Vector *vector;
     } next;
@@ -2880,6 +2782,7 @@ extern Lisp_Object make_pure_string (const char *, ptrdiff_t, ptrdiff_t, int);
 extern Lisp_Object make_pure_c_string (const char *data);
 extern Lisp_Object pure_cons (Lisp_Object, Lisp_Object);
 EXFUN (Fgarbage_collect, 0);
+extern void make_byte_code (struct Lisp_Vector *);
 EXFUN (Fmake_byte_code, MANY);
 EXFUN (Fmake_bool_vector, 2);
 extern Lisp_Object Qchar_table_extra_slots;
diff --git a/src/lread.c b/src/lread.c
index 38b00a66962..8a9088b8ed2 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -2551,8 +2551,8 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
              build them using function calls.  */
           Lisp_Object tmp;
           tmp = read_vector (readcharfun, 1);
-          return Fmake_byte_code (ASIZE (tmp),
-                                  XVECTOR (tmp)->contents);
+          make_byte_code (XVECTOR (tmp));
+          return tmp;
         }
       if (c == '(')
         {
@@ -4375,7 +4375,8 @@ to find all the symbols in an obarray, use `mapatoms'.  */);
 
   DEFVAR_LISP ("values", Vvalues,
                doc: /* List of values of all expressions which were read, evaluated and printed.
-Order is reverse chronological.  */);
+                       Order is reverse chronological.  */);
+  XSYMBOL (intern ("values"))->declared_special = 0;
 
   DEFVAR_LISP ("standard-input", Vstandard_input,
                doc: /* Stream for read to get input from.
@@ -4393,7 +4394,7 @@ defined, although they may be in the future.
 
 The positions are relative to the last call to `read' or
 `read-from-string'.  It is probably a bad idea to set this variable at
-the toplevel; bind it instead. */);
+the toplevel; bind it instead.  */);
   Vread_with_symbol_positions = Qnil;
 
   DEFVAR_LISP ("read-symbol-positions-list", Vread_symbol_positions_list,
@@ -4408,7 +4409,7 @@ symbol from the position where `read' or `read-from-string' started.
 
 Note that a symbol will appear multiple times in this list, if it was
 read multiple times.  The list is in the same order as the symbols
-were read in. */);
+were read in.  */);
   Vread_symbol_positions_list = Qnil;
 
   DEFVAR_LISP ("read-circle", Vread_circle,
diff --git a/src/macros.c b/src/macros.c
index 3f4f8624479..0db7e63d622 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -259,7 +259,7 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
      from before this macro started.  */
   Vthis_command = KVAR (current_kboard, Vlast_command);
   /* C-x z after the macro should repeat the macro.  */
-  real_this_command = KVAR (current_kboard, Vlast_kbd_macro);
+  Vreal_this_command = KVAR (current_kboard, Vlast_kbd_macro);
 
   if (! NILP (KVAR (current_kboard, defining_kbd_macro)))
     error ("Can't execute anonymous macro while defining one");
@@ -286,7 +286,7 @@ pop_kbd_macro (Lisp_Object info)
   Vexecuting_kbd_macro = XCAR (info);
   tem = XCDR (info);
   executing_kbd_macro_index = XINT (XCAR (tem));
-  real_this_command = XCDR (tem);
+  Vreal_this_command = XCDR (tem);
   Frun_hooks (1, &Qkbd_macro_termination_hook);
   return Qnil;
 }
@@ -321,7 +321,7 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
 
   tem = Fcons (Vexecuting_kbd_macro,
                Fcons (make_number (executing_kbd_macro_index),
-                      real_this_command));
+                      Vreal_this_command));
   record_unwind_protect (pop_kbd_macro, tem);
 
   GCPRO2 (final, loopfunc);
@@ -352,7 +352,7 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
 
   executing_kbd_macro = Qnil;
 
-  real_this_command = Vexecuting_kbd_macro;
+  Vreal_this_command = Vexecuting_kbd_macro;
 
   UNGCPRO;
   return unbind_to (pdlcount, Qnil);
diff --git a/src/mem-limits.h b/src/mem-limits.h
index 1fd53b472f3..01b0e6ebb2b 100644
--- a/src/mem-limits.h
+++ b/src/mem-limits.h
@@ -34,7 +34,7 @@ extern int etext;
 #endif
 
 extern char *start_of_data (void);
-#if defined USE_LSB_TAG || UINTPTR_MAX <= VAL_MAX
+#if USE_LSB_TAG || UINTPTR_MAX <= VAL_MAX
 #define EXCEEDS_LISP_PTR(ptr) 0
 #elif defined DATA_SEG_BITS
 #define EXCEEDS_LISP_PTR(ptr) \
diff --git a/src/minibuf.c b/src/minibuf.c
index e9bc36303f9..d921e80be48 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1726,8 +1726,6 @@ See also `completing-read-function'.  */)
   return Ffuncall (9, args);
 }
 
-Lisp_Object Fassoc_string (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold);
-
 /* Test whether TXT is an exact completion.  */
 DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
        doc: /* Return non-nil if STRING is a valid completion.
diff --git a/src/regex.c b/src/regex.c
index f9a12a3c2dc..0dd3a187898 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -3824,18 +3824,37 @@ static boolean
 at_begline_loc_p (const re_char *pattern, const re_char *p, reg_syntax_t syntax)
 {
   re_char *prev = p - 2;
-  boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
+  boolean odd_backslashes;
 
-  return
-       /* After a subexpression?  */
-       (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash))
-       /* After an alternative?  */
-    || (*prev == '|' && (syntax & RE_NO_BK_VBAR || prev_prev_backslash))
-       /* After a shy subexpression?  */
-    || ((syntax & RE_SHY_GROUPS) && prev - 2 >= pattern
-        && prev[-1] == '?' && prev[-2] == '('
-        && (syntax & RE_NO_BK_PARENS
-            || (prev - 3 >= pattern && prev[-3] == '\\')));
+  /* After a subexpression?  */
+  if (*prev == '(')
+    odd_backslashes = (syntax & RE_NO_BK_PARENS) == 0;
+
+  /* After an alternative?  */
+  else if (*prev == '|')
+    odd_backslashes = (syntax & RE_NO_BK_VBAR) == 0;
+
+  /* After a shy subexpression?  */
+  else if (*prev == ':' && (syntax & RE_SHY_GROUPS))
+    {
+      /* Skip over optional regnum.  */
+      while (prev - 1 >= pattern && prev[-1] >= '0' && prev[-1] <= '9')
+        --prev;
+
+      if (!(prev - 2 >= pattern
+            && prev[-1] == '?' && prev[-2] == '('))
+        return false;
+      prev -= 2;
+      odd_backslashes = (syntax & RE_NO_BK_PARENS) == 0;
+    }
+  else
+    return false;
+
+  /* Count the number of preceding backslashes.  */
+  p = prev;
+  while (prev - 1 >= pattern && prev[-1] == '\\')
+    --prev;
+  return (p - prev) & odd_backslashes;
 }
 
 
diff --git a/src/s/aix4-2.h b/src/s/aix4-2.h
index cacfdc7ed63..51ac9748f27 100644
--- a/src/s/aix4-2.h
+++ b/src/s/aix4-2.h
@@ -26,10 +26,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define _AIX
 #endif
 
-/* SYSTEM_TYPE should indicate the kind of system you are using.
- It sets the Lisp variable system-type.  */
-#define SYSTEM_TYPE "aix"
-
 /* In AIX, you allocate a pty by opening /dev/ptc to get the master side.
    To get the name of the slave side, you just ttyname() the master side.  */
 #define PTY_ITERATION int c; for (c = 0; !c ; c++)
diff --git a/src/s/bsd-common.h b/src/s/bsd-common.h
index c2dbdb9a109..ce67dd7b9af 100644
--- a/src/s/bsd-common.h
+++ b/src/s/bsd-common.h
@@ -37,8 +37,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define TABDLY OXTABS
 #define TAB3 OXTABS
 
-#define NO_TERMIO
-
 /* If the system's imake configuration file defines `NeedWidePrototypes'
    as `NO', we must define NARROWPROTO manually.  Such a define is
    generated in the Makefile generated by `xmkmf'.  If we don't
@@ -46,10 +44,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    for X functions taking float or double parameters.  */
 #define NARROWPROTO 1
 
-/* SYSTEM_TYPE should indicate the kind of system you are using.
- It sets the Lisp variable system-type.  */
-#define SYSTEM_TYPE "berkeley-unix"
-
 /* Do not use interrupt_input = 1 by default, because in 4.3
    we can make noninterrupt input work properly.  */
 #undef INTERRUPT_INPUT
diff --git a/src/s/cygwin.h b/src/s/cygwin.h
index 9310890351e..9b437341324 100644
--- a/src/s/cygwin.h
+++ b/src/s/cygwin.h
@@ -17,10 +17,6 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
-/* SYSTEM_TYPE should indicate the kind of system you are using.
-   It sets the Lisp variable system-type.  */
-#define SYSTEM_TYPE "cygwin"
-
 /* Emacs can read input using SIGIO and buffering characters itself,
    or using CBREAK mode and making C-g cause SIGINT.
    The choice is controlled by the variable interrupt_input.
diff --git a/src/s/darwin.h b/src/s/darwin.h
index 7c8e26f46cc..ce86bc5f578 100644
--- a/src/s/darwin.h
+++ b/src/s/darwin.h
@@ -31,10 +31,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define DARWIN_OS
 
 
-/* SYSTEM_TYPE should indicate the kind of system you are using.
-   It sets the Lisp variable system-type.  */
-#define SYSTEM_TYPE "darwin"
-
 /* Emacs can read input using SIGIO and buffering characters itself,
    or using CBREAK mode and making C-g cause SIGINT.
    The choice is controlled by the variable interrupt_input.
@@ -62,8 +58,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
   if system supports pty's.  'a' means it is /dev/ptya0  */
 #define FIRST_PTY_LETTER 'p'
 
-#define NO_TERMIO
-
 /* Define HAVE_PTYS if the system supports pty devices.
    Note: PTYs are broken on darwin <6.  Use at your own risk.  */
 #define HAVE_PTYS
diff --git a/src/s/gnu-kfreebsd.h b/src/s/gnu-kfreebsd.h
deleted file mode 100644
index a85571915df..00000000000
--- a/src/s/gnu-kfreebsd.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "gnu-linux.h"
-
-/* SYSTEM_TYPE should indicate the kind of system you are using.
-   It sets the Lisp variable system-type.  */
-#undef SYSTEM_TYPE
-#define SYSTEM_TYPE "gnu/kfreebsd" /* All the best software is free */
-
-#define NO_TERMIO               /* use only <termios.h> */
-
diff --git a/src/s/gnu-linux.h b/src/s/gnu-linux.h
index 409d0205520..e3d43249d81 100644
--- a/src/s/gnu-linux.h
+++ b/src/s/gnu-linux.h
@@ -25,10 +25,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define USG
 #define GNU_LINUX
 
-/* SYSTEM_TYPE should indicate the kind of system you are using.
-   It sets the Lisp variable system-type.  */
-#define SYSTEM_TYPE "gnu/linux"         /* All the best software is free. */
-
 #ifdef emacs
 #ifdef HAVE_LINUX_VERSION_H
 #include <linux/version.h>
@@ -85,9 +81,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define HAVE_SOCKETS
 
-/* This is used in list_system_processes.  */
-#define HAVE_PROCFS 1
-
 /* Define CLASH_DETECTION if you want lock files to be written
    so that Emacs can tell instantly when you try to modify
    a file that someone else has modified in his Emacs.  */
diff --git a/src/s/gnu.h b/src/s/gnu.h
index cd72164a520..c2bcf7fd9ab 100644
--- a/src/s/gnu.h
+++ b/src/s/gnu.h
@@ -21,9 +21,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Get most of the stuff from bsd-common */
 #include "bsd-common.h"
 
-#undef SYSTEM_TYPE
-#define SYSTEM_TYPE "gnu"
-
 #define SIGNALS_VIA_CHARACTERS
 
 /* libc defines data_start.  */
@@ -41,5 +38,3 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
   ((FILE)->_IO_write_ptr - (FILE)->_IO_write_base)
 #endif /* !_IO_STDIO_H */
 #endif /* emacs */
-
-#define POSIX_SIGNALS 1
diff --git a/src/s/hpux10-20.h b/src/s/hpux10-20.h
index f1ae50c533a..683837891f4 100644
--- a/src/s/hpux10-20.h
+++ b/src/s/hpux10-20.h
@@ -26,16 +26,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define USG5
 #define HPUX
 
-/* SYSTEM_TYPE should indicate the kind of system you are using.
-   It sets the Lisp variable system-type.  */
-#define SYSTEM_TYPE "hpux"
-
 /* Letter to use in finding device name of first pty,
    if system supports pty's.  'p' means it is /dev/ptym/ptyp0  */
 #define FIRST_PTY_LETTER 'p'
 
-#define NO_TERMIO
-
 /* Define HAVE_PTYS if the system supports pty devices.  */
 #define HAVE_PTYS
 
@@ -49,10 +43,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Special hacks needed to make Emacs run on this system.  */
 
-/* In hpux, the symbol SIGIO is defined, but the feature
-   doesn't work in the way Emacs needs it to.  */
-#define BROKEN_SIGIO
-
 /* Some additional system facilities exist.  */
 #define HAVE_PERROR  /* Delete this line for version 6.  */
 
diff --git a/src/s/hpux11.h b/src/s/hpux11.h
deleted file mode 100644
index 40bcc987973..00000000000
--- a/src/s/hpux11.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "hpux10-20.h"
-
-/* SA_RESTART resets the timeout of `select', so don't use it.  */
-#define BROKEN_SA_RESTART
-
-/* It does work on HPUX to open the pty's tty in the parent (Emacs),
-   then close and reopen it in the child.  */
-#define USG_SUBTTY_WORKS
-
diff --git a/src/s/irix6-5.h b/src/s/irix6-5.h
index e5479c3b8d3..7e5a5505ee2 100644
--- a/src/s/irix6-5.h
+++ b/src/s/irix6-5.h
@@ -26,11 +26,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define SETPGRP_RELEASES_CTTY
 
-#ifdef SYSTEM_TYPE
-#undef SYSTEM_TYPE
-#endif
-#define SYSTEM_TYPE "irix"
-
 #ifdef SETUP_SLAVE_PTY
 #undef SETUP_SLAVE_PTY
 #endif
diff --git a/src/s/ms-w32.h b/src/s/ms-w32.h
index f88128b27aa..5bf71d5f321 100644
--- a/src/s/ms-w32.h
+++ b/src/s/ms-w32.h
@@ -36,10 +36,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    convention must be whatever standard the libraries expect.  */
 #define _CALLBACK_ __cdecl
 
-/* SYSTEM_TYPE should indicate the kind of system you are using.
-   It sets the Lisp variable system-type.  */
-#define SYSTEM_TYPE "windows-nt"
-
 #define NO_MATHERR 1
 
 /* Letter to use in finding device name of first pty,
diff --git a/src/s/msdos.h b/src/s/msdos.h
index add2902d5f3..fc1a8c7506a 100644
--- a/src/s/msdos.h
+++ b/src/s/msdos.h
@@ -33,10 +33,6 @@ You lose; /* Emacs for DOS must be compiled with DJGPP */
 #define DOS_NT  /* MSDOS or WINDOWSNT */
 #undef BSD_SYSTEM
 
-/* SYSTEM_TYPE should indicate the kind of system you are using.
-   It sets the Lisp variable system-type.  */
-#define SYSTEM_TYPE "ms-dos"
-
 /* subprocesses should be defined if you want to have code for
    asynchronous subprocesses (as used in M-x compile and M-x shell).
    This is the only system that needs this.  */
diff --git a/src/s/openbsd.h b/src/s/openbsd.h
deleted file mode 100644
index 0a8bab2290f..00000000000
--- a/src/s/openbsd.h
+++ /dev/null
@@ -1,9 +0,0 @@
-/* System file for openbsd.  */
-
-/* Nearly the same as NetBSD.  Note there are differences in configure.  */
-#include "netbsd.h"
-
-/* The symbol SIGIO is defined, but the feature doesn't work in the
-   way Emacs needs it to.  See
-   <http://article.gmane.org/gmane.os.openbsd.ports/46831>.  */
-#define BROKEN_SIGIO
diff --git a/src/s/sol2-10.h b/src/s/sol2-10.h
deleted file mode 100644
index b20476e7fba..00000000000
--- a/src/s/sol2-10.h
+++ /dev/null
@@ -1,10 +0,0 @@
-/* Handle Solaris 2.10.  */
-
-#include "sol2-6.h"
-
-/* This is used in list_system_processes.  */
-#define HAVE_PROCFS 1
-
-/* This is needed for the system_process_attributes implementation.  */
-#define _STRUCTURED_PROC 1
-
diff --git a/src/s/template.h b/src/s/template.h
index 527694bd4bb..d8f811dc8aa 100644
--- a/src/s/template.h
+++ b/src/s/template.h
@@ -30,11 +30,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* #define BSD4_3 */
 /* #define BSD_SYSTEM */
 
-/* SYSTEM_TYPE should indicate the kind of system you are using.
-   It sets the Lisp variable system-type.  */
-
-#define SYSTEM_TYPE "berkeley-unix"
-
 /* Emacs can read input using SIGIO and buffering characters itself,
    or using CBREAK mode and making C-g cause SIGINT.
    The choice is controlled by the variable interrupt_input.
diff --git a/src/s/unixware.h b/src/s/unixware.h
index 63c36ee40c2..18d24b28507 100644
--- a/src/s/unixware.h
+++ b/src/s/unixware.h
@@ -23,8 +23,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* #define HAVE_GETWD  (appears to be buggy on SVR4.2) */
 #undef HAVE_GETWD
 
-#undef HAVE_SYSV_SIGPAUSE
-
 /* This is the same definition as in usg5-4-common.h, but with sigblock/sigunblock
    rather than sighold/sigrelse, which appear to be BSD4.1 specific.
    It may also be appropriate for SVR4.x
diff --git a/src/s/usg5-4-common.h b/src/s/usg5-4-common.h
index fabdd66f3bb..1502228c0d8 100644
--- a/src/s/usg5-4-common.h
+++ b/src/s/usg5-4-common.h
@@ -26,21 +26,13 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define USG5
 #define USG5_4
 
-/* SYSTEM_TYPE should indicate the kind of system you are using.
-   It sets the Lisp variable system-type.  */
-#define SYSTEM_TYPE "usg-unix-v"
-
 /* setjmp and longjmp can safely replace _setjmp and _longjmp,
    but they will run slower.  */
 #define _setjmp setjmp
 #define _longjmp longjmp
 
-/* The docs for system V/386 suggest v.3 has sigpause, so let's try it.  */
-#define HAVE_SYSV_SIGPAUSE
-
 /* Get FIONREAD from <sys/filio.h>.  Get <sys/ttold.h> to get struct tchars.
-   But get <termio.h> first to make sure ttold.h doesn't interfere.
-   And don't try to use SIGIO yet.  */
+   But get <termio.h> first to make sure ttold.h doesn't interfere.  */
 #include <sys/wait.h>
 
 #ifdef emacs
@@ -51,7 +43,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <sys/stream.h>
 #include <sys/stropts.h>
 #include <sys/termios.h>
-#define BROKEN_SIGIO
 #endif
 
 /* Some SVr4s don't define NSIG in sys/signal.h for ANSI environments;
diff --git a/src/sysdep.c b/src/sysdep.c
index a82f802a785..3356582de0c 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -3106,9 +3106,10 @@ system_process_attributes (Lisp_Object pid)
           attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (pinfo.pr_size)), attrs);
           attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (pinfo.pr_rssize)), attrs);
 
-          /* pr_pctcpu and pr_pctmem are encoded as a fixed point 16 bit number in  [0 ... 1].  */
-          attrs = Fcons (Fcons (Qpcpu, (pinfo.pr_pctcpu * 100.0) / (double)0x8000), attrs);
-          attrs = Fcons (Fcons (Qpmem, (pinfo.pr_pctmem * 100.0) / (double)0x8000), attrs);
+          /* pr_pctcpu and pr_pctmem are unsigned integers in the
+             range 0 .. 2**15, representing 0.0 .. 1.0.  */
+          attrs = Fcons (Fcons (Qpcpu, make_float (100.0 / 0x8000 * pinfo.pr_pctcpu)), attrs);
+          attrs = Fcons (Fcons (Qpmem, make_float (100.0 / 0x8000 * pinfo.pr_pctmem)), attrs);
 
           decoded_cmd
             =  code_convert_string_norecord (make_unibyte_string (pinfo.pr_fname,
diff --git a/src/term.c b/src/term.c
index 3d7a677374c..8ce2efc0929 100644
--- a/src/term.c
+++ b/src/term.c
@@ -122,12 +122,11 @@ enum no_color_bit
   NC_STANDOUT    = 1 << 0,
   NC_UNDERLINE   = 1 << 1,
   NC_REVERSE     = 1 << 2,
-  NC_BLINK       = 1 << 3,
+  NC_ITALIC      = 1 << 3,
   NC_DIM         = 1 << 4,
   NC_BOLD        = 1 << 5,
   NC_INVIS       = 1 << 6,
-  NC_PROTECT     = 1 << 7,
-  NC_ALT_CHARSET = 1 << 8
+  NC_PROTECT     = 1 << 7
 };
 
 /* internal state */
@@ -2022,17 +2021,16 @@ turn_on_face (struct frame *f, int face_id)
   if (face->tty_bold_p && MAY_USE_WITH_COLORS_P (tty, NC_BOLD))
     OUTPUT1_IF (tty, tty->TS_enter_bold_mode);
 
-  if (face->tty_dim_p && MAY_USE_WITH_COLORS_P (tty, NC_DIM))
-    OUTPUT1_IF (tty, tty->TS_enter_dim_mode);
-
-  /* Alternate charset and blinking not yet used.  */
-  if (face->tty_alt_charset_p
-      && MAY_USE_WITH_COLORS_P (tty, NC_ALT_CHARSET))
-    OUTPUT1_IF (tty, tty->TS_enter_alt_charset_mode);
-
-  if (face->tty_blinking_p
-      && MAY_USE_WITH_COLORS_P (tty, NC_BLINK))
-    OUTPUT1_IF (tty, tty->TS_enter_blink_mode);
+  if (face->tty_italic_p && MAY_USE_WITH_COLORS_P (tty, NC_ITALIC))
+    {
+      if (tty->TS_enter_italic_mode)
+        OUTPUT1 (tty, tty->TS_enter_italic_mode);
+      else
+        /* Italics mode is unavailable on many terminals.  In that
+           case, map slant to dimmed text; we want italic text to
+           appear different and dimming is not otherwise used.  */
+        OUTPUT1 (tty, tty->TS_enter_dim_mode);
+    }
 
   if (face->tty_underline_p && MAY_USE_WITH_COLORS_P (tty, NC_UNDERLINE))
     OUTPUT1_IF (tty, tty->TS_enter_underline_mode);
@@ -2077,27 +2075,19 @@ turn_off_face (struct frame *f, int face_id)
          half-bright, reverse-video, standout, underline.  It may or
          may not turn off alt-char-mode.  */
       if (face->tty_bold_p
-          || face->tty_dim_p
+          || face->tty_italic_p
           || face->tty_reverse_p
-          || face->tty_alt_charset_p
-          || face->tty_blinking_p
           || face->tty_underline_p)
         {
           OUTPUT1_IF (tty, tty->TS_exit_attribute_mode);
           if (strcmp (tty->TS_exit_attribute_mode, tty->TS_end_standout_mode) == 0)
             tty->standout_mode = 0;
         }
-
-      if (face->tty_alt_charset_p)
-        OUTPUT_IF (tty, tty->TS_exit_alt_charset_mode);
     }
   else
     {
       /* If we don't have "me" we can only have those appearances
          that have exit sequences defined.  */
-      if (face->tty_alt_charset_p)
-        OUTPUT_IF (tty, tty->TS_exit_alt_charset_mode);
-
       if (face->tty_underline_p)
         OUTPUT_IF (tty, tty->TS_exit_underline_mode);
     }
@@ -2128,8 +2118,7 @@ tty_capable_p (struct tty_display_info *tty, unsigned int caps,
   TTY_CAPABLE_P_TRY (tty, TTY_CAP_UNDERLINE,    tty->TS_enter_underline_mode,   NC_UNDERLINE);
   TTY_CAPABLE_P_TRY (tty, TTY_CAP_BOLD,         tty->TS_enter_bold_mode,        NC_BOLD);
   TTY_CAPABLE_P_TRY (tty, TTY_CAP_DIM,          tty->TS_enter_dim_mode,         NC_DIM);
-  TTY_CAPABLE_P_TRY (tty, TTY_CAP_BLINK,        tty->TS_enter_blink_mode,       NC_BLINK);
-  TTY_CAPABLE_P_TRY (tty, TTY_CAP_ALT_CHARSET,  tty->TS_enter_alt_charset_mode, NC_ALT_CHARSET);
+  TTY_CAPABLE_P_TRY (tty, TTY_CAP_ITALIC,       tty->TS_enter_italic_mode,      NC_ITALIC);
 
   /* We can do it!  */
   return 1;
@@ -3222,8 +3211,8 @@ use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
   tty->TS_enter_underline_mode = tgetstr ("us", address);
   tty->TS_exit_underline_mode = tgetstr ("ue", address);
   tty->TS_enter_bold_mode = tgetstr ("md", address);
+  tty->TS_enter_italic_mode = tgetstr ("ZH", address);
   tty->TS_enter_dim_mode = tgetstr ("mh", address);
-  tty->TS_enter_blink_mode = tgetstr ("mb", address);
   tty->TS_enter_reverse_mode = tgetstr ("mr", address);
   tty->TS_enter_alt_charset_mode = tgetstr ("as", address);
   tty->TS_exit_alt_charset_mode = tgetstr ("ae", address);
diff --git a/src/termchar.h b/src/termchar.h
index d50ee805e03..102fe45350e 100644
--- a/src/termchar.h
+++ b/src/termchar.h
@@ -124,8 +124,8 @@ struct tty_display_info
                                    each as vpos and hpos) */
 
   const char *TS_enter_bold_mode; /* "md" -- turn on bold (extra bright mode).  */
+  const char *TS_enter_italic_mode; /* "ZH" -- turn on italics mode.  */
   const char *TS_enter_dim_mode; /* "mh" -- turn on half-bright mode.  */
-  const char *TS_enter_blink_mode; /* "mb" -- enter blinking mode.  */
   const char *TS_enter_reverse_mode; /* "mr" -- enter reverse video mode.  */
   const char *TS_exit_underline_mode; /* "us" -- start underlining.  */
   const char *TS_enter_underline_mode; /* "ue" -- end underlining.  */
diff --git a/src/w32fns.c b/src/w32fns.c
index b8dc62f5250..a8becea1b74 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -6326,13 +6326,8 @@ The return value is the hotkey-id if registered, otherwise nil.  */)
 
       /* Notify input thread about new hot-key definition, so that it
          takes effect without needing to switch focus.  */
-#ifdef USE_LISP_UNION_TYPE
       PostThreadMessage (dwWindowsThreadId, WM_EMACS_REGISTER_HOT_KEY,
-                         (WPARAM) key.i, 0);
-#else
-      PostThreadMessage (dwWindowsThreadId, WM_EMACS_REGISTER_HOT_KEY,
-                         (WPARAM) key, 0);
-#endif
+                         (WPARAM) XLI (key), 0);
     }
 
   return key;
@@ -6354,13 +6349,8 @@ DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key,
     {
       /* Notify input thread about hot-key definition being removed, so
          that it takes effect without needing focus switch.  */
-#ifdef USE_LISP_UNION_TYPE
-      if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_UNREGISTER_HOT_KEY,
-                             (WPARAM) XINT (XCAR (item)), (LPARAM) item.i))
-#else
       if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_UNREGISTER_HOT_KEY,
-                             (WPARAM) XINT (XCAR (item)), (LPARAM) item))
-#endif
+                             (WPARAM) XINT (XCAR (item)), (LPARAM) XLI (item)))
         {
           MSG msg;
           GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
@@ -6432,13 +6422,8 @@ is set to off if the low bit of NEW-STATE is zero, otherwise on.  */)
   if (!dwWindowsThreadId)
     return make_number (w32_console_toggle_lock_key (vk_code, new_state));
 
-#ifdef USE_LISP_UNION_TYPE
-  if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_TOGGLE_LOCK_KEY,
-                         (WPARAM) vk_code, (LPARAM) new_state.i))
-#else
   if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_TOGGLE_LOCK_KEY,
-                         (WPARAM) vk_code, (LPARAM) new_state))
-#endif
+                         (WPARAM) vk_code, (LPARAM) XLI (new_state)))
     {
       MSG msg;
       GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
diff --git a/src/w32heap.c b/src/w32heap.c
index da8579896f2..cc5e5cd2bf5 100644
--- a/src/w32heap.c
+++ b/src/w32heap.c
@@ -114,7 +114,7 @@ get_data_end (void)
   return data_region_end;
 }
 
-#if !defined (USE_LISP_UNION_TYPE) && !defined (USE_LSB_TAG)
+#if !USE_LSB_TAG
 static char *
 allocate_heap (void)
 {
@@ -141,7 +141,7 @@ allocate_heap (void)
 
   return ptr;
 }
-#else  /* USE_LISP_UNION_TYPE || USE_LSB_TAG */
+#else  /* USE_LSB_TAG */
 static char *
 allocate_heap (void)
 {
@@ -160,7 +160,7 @@ allocate_heap (void)
 
   return ptr;
 }
-#endif /* USE_LISP_UNION_TYPE || USE_LSB_TAG */
+#endif /* USE_LSB_TAG */
 
 
 /* Emulate Unix sbrk.  Note that ralloc.c expects the return value to
@@ -259,7 +259,7 @@ init_heap (void)
           exit (1);
         }
 
-#if !defined (USE_LISP_UNION_TYPE) && !defined (USE_LSB_TAG)
+#if !USE_LSB_TAG
       /* Ensure that the addresses don't use the upper tag bits since
          the Lisp type goes there.  */
       if (((unsigned long) data_region_base & ~VALMASK) != 0)
diff --git a/src/w32menu.c b/src/w32menu.c
index 2bc4c208956..f5f5c6656c4 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -1533,11 +1533,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
              until it is ready to be displayed, since GC can happen while
              menus are active.  */
           if (!NILP (wv->help))
-#ifdef USE_LISP_UNION_TYPE
-            info.dwItemData = (DWORD) (wv->help).i;
-#else
-            info.dwItemData = (DWORD) (wv->help);
-#endif
+            info.dwItemData = (DWORD) XLI (wv->help);
           if (wv->button_type == BUTTON_TYPE_RADIO)
             {
               /* CheckMenuRadioItem allows us to differentiate TOGGLE and
@@ -1612,12 +1608,7 @@ w32_menu_display_help (HWND owner, HMENU menu, UINT item, UINT flags)
           info.fMask = MIIM_DATA;
           get_menu_item_info (menu, item, FALSE, &info);
 
-#ifdef USE_LISP_UNION_TYPE
-          help = info.dwItemData ? (Lisp_Object) ((EMACS_INT) info.dwItemData)
-                                 : Qnil;
-#else
-          help = info.dwItemData ? (Lisp_Object) info.dwItemData : Qnil;
-#endif
+          help = info.dwItemData ? XIL (info.dwItemData) : Qnil;
         }
 
       /* Store the help echo in the keyboard buffer as the X toolkit
diff --git a/src/w32term.c b/src/w32term.c
index a90e067a3fd..38120b77ac9 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -4342,7 +4342,7 @@ w32_read_socket (struct terminal *terminal, int expected,
 
           /* If the contents of the global variable help_echo_string
              has changed, generate a HELP_EVENT.  */
-#if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE.
+#if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
          But it was originally changed to this to fix a bug, so I have
          not removed it completely in case the bug is still there.  */
           if (help_echo_string != previous_help_echo_string ||
diff --git a/src/window.c b/src/window.c
index a10222b1aff..2a498c43d80 100644
--- a/src/window.c
+++ b/src/window.c
@@ -1395,10 +1395,10 @@ overriding motion of point in order to display at this exact start.  */)
   CHECK_NUMBER_COERCE_MARKER (pos);
   set_marker_restricted (w->start, pos, w->buffer);
   /* this is not right, but much easier than doing what is right. */
-  w->start_at_line_beg = Qnil;
+  w->start_at_line_beg = 0;
   if (NILP (noforce))
-    w->force_start = Qt;
-  w->update_mode_line = Qt;
+    w->force_start = 1;
+  w->update_mode_line = 1;
   XSETFASTINT (w->last_modified, 0);
   XSETFASTINT (w->last_overlay_modified, 0);
   if (!EQ (window, selected_window))
@@ -2474,7 +2474,7 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
             if (EQ (w->buffer, obj))
               {
                 mark_window_display_accurate (window, 0);
-                w->update_mode_line = Qt;
+                w->update_mode_line = 1;
                 XBUFFER (obj)->prevent_redisplay_optimizations_p = 1;
                 ++update_mode_lines;
                 best_window = window;
@@ -2773,12 +2773,11 @@ window-start value is reasonable when this function is called.  */)
 
           set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
           w->window_end_valid = Qnil;
-          w->start_at_line_beg = ((pos.bytepos == BEGV_BYTE
-                                   || FETCH_BYTE (pos.bytepos - 1) == '\n') ? Qt
-                                  : Qnil);
+          w->start_at_line_beg = (pos.bytepos == BEGV_BYTE
+                                    || FETCH_BYTE (pos.bytepos - 1) == '\n');
           /* We need to do this, so that the window-scroll-functions
              get called.  */
-          w->optional_new_start = Qt;
+          w->optional_new_start = 1;
 
           set_buffer_internal (obuf);
         }
@@ -3008,8 +3007,8 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
       set_marker_restricted (w->start,
                              make_number (b->last_window_start),
                              buffer);
-      w->start_at_line_beg = Qnil;
-      w->force_start = Qnil;
+      w->start_at_line_beg = 0;
+      w->force_start = 0;
       XSETFASTINT (w->last_modified, 0);
       XSETFASTINT (w->last_overlay_modified, 0);
     }
@@ -3145,7 +3144,7 @@ displaying that buffer.  */)
     {
       struct window *w = XWINDOW (object);
       mark_window_display_accurate (object, 0);
-      w->update_mode_line = Qt;
+      w->update_mode_line = 1;
       if (BUFFERP (w->buffer))
         XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
       ++update_mode_lines;
@@ -3277,7 +3276,8 @@ make_window (void)
 
   w = allocate_window ();
   /* Initialize all Lisp data.  */
-  w->frame = w->mini_p = Qnil;
+  w->frame = Qnil;
+  w->mini = 0;
   w->next = w->prev = w->hchild = w->vchild = w->parent = Qnil;
   XSETFASTINT (w->left_col, 0);
   XSETFASTINT (w->top_line, 0);
@@ -3290,7 +3290,7 @@ make_window (void)
   w->buffer = Qnil;
   w->start = Fmake_marker ();
   w->pointm = Fmake_marker ();
-  w->force_start = w->optional_new_start = Qnil;
+  w->force_start = w->optional_new_start = 0;
   XSETFASTINT (w->hscroll, 0);
   XSETFASTINT (w->min_hscroll, 0);
   XSETFASTINT (w->use_time, 0);
@@ -3298,17 +3298,18 @@ make_window (void)
   XSETFASTINT (w->sequence_number, sequence_number);
   w->temslot = w->last_modified = w->last_overlay_modified = Qnil;
   XSETFASTINT (w->last_point, 0);
-  w->last_had_star = w->vertical_scroll_bar = Qnil;
+  w->last_had_star = 0;
+  w->vertical_scroll_bar = Qnil;
   w->left_margin_cols = w->right_margin_cols = Qnil;
   w->left_fringe_width = w->right_fringe_width = Qnil;
   w->fringes_outside_margins = Qnil;
   w->scroll_bar_width = Qnil;
   w->vertical_scroll_bar_type = Qt;
-  w->last_mark_x = w->last_mark_y = Qnil;
   XSETFASTINT (w->window_end_pos, 0);
   XSETFASTINT (w->window_end_vpos, 0);
-  w->window_end_valid = w->update_mode_line = Qnil;
-  w->start_at_line_beg = w->display_table = w->dedicated = Qnil;
+  w->window_end_valid = w->display_table = Qnil;
+  w->update_mode_line = w->start_at_line_beg = 0;
+  w->dedicated = Qnil;
   w->base_line_number = w->base_line_pos = w->region_showing = Qnil;
   w->column_number_displayed = w->redisplay_end_trigger = Qnil;
   w->combination_limit = w->window_parameters = Qnil;
@@ -4310,13 +4311,13 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
                     spos = min (XINT (Fline_end_position (Qnil)) + 1, ZV);
                   set_marker_restricted (w->start, make_number (spos),
                                          w->buffer);
-                  w->start_at_line_beg = Qt;
-                  w->update_mode_line = Qt;
+                  w->start_at_line_beg = 1;
+                  w->update_mode_line = 1;
                   XSETFASTINT (w->last_modified, 0);
                   XSETFASTINT (w->last_overlay_modified, 0);
                   /* Set force_start so that redisplay_window will run the
                      window-scroll-functions.  */
-                  w->force_start = Qt;
+                  w->force_start = 1;
                   return;
                 }
             }
@@ -4456,14 +4457,13 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
       set_marker_restricted (w->start, make_number (pos),
                              w->buffer);
       bytepos = XMARKER (w->start)->bytepos;
-      w->start_at_line_beg = ((pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n')
-                              ? Qt : Qnil);
-      w->update_mode_line = Qt;
+      w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
+      w->update_mode_line = 1;
       XSETFASTINT (w->last_modified, 0);
       XSETFASTINT (w->last_overlay_modified, 0);
       /* Set force_start so that redisplay_window will run the
          window-scroll-functions.  */
-      w->force_start = Qt;
+      w->force_start = 1;
     }
 
   /* The rest of this function uses current_y in a nonstandard way,
@@ -4656,13 +4656,13 @@ window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
         max (0, min (scroll_margin, XINT (w->total_lines) / 4));
 
       set_marker_restricted_both (w->start, w->buffer, pos, pos_byte);
-      w->start_at_line_beg = bolp;
-      w->update_mode_line = Qt;
+      w->start_at_line_beg = !NILP (bolp);
+      w->update_mode_line = 1;
       XSETFASTINT (w->last_modified, 0);
       XSETFASTINT (w->last_overlay_modified, 0);
       /* Set force_start so that redisplay_window will run
          the window-scroll-functions.  */
-      w->force_start = Qt;
+      w->force_start = 1;
 
       if (!NILP (Vscroll_preserve_screen_position)
           && (whole || !EQ (Vscroll_preserve_screen_position, Qt)))
@@ -5206,12 +5206,10 @@ and redisplay normally--don't erase and redraw the frame.  */)
   set_marker_both (w->start, w->buffer, charpos, bytepos);
   w->window_end_valid = Qnil;
 
-  w->optional_new_start = Qt;
+  w->optional_new_start = 1;
 
-  if (bytepos == BEGV_BYTE || FETCH_BYTE (bytepos - 1) == '\n')
-    w->start_at_line_beg = Qt;
-  else
-    w->start_at_line_beg = Qnil;
+  w->start_at_line_beg = (bytepos == BEGV_BYTE ||
+                          FETCH_BYTE (bytepos - 1) == '\n');
 
   set_buffer_internal (obuf);
   return Qnil;
@@ -5262,8 +5260,8 @@ zero means top of window, negative means relative to bottom of window.  */)
       int height = window_internal_height (w);
       Fvertical_motion (make_number (- (height / 2)), window);
       set_marker_both (w->start, w->buffer, PT, PT_BYTE);
-      w->start_at_line_beg = Fbolp ();
-      w->force_start = Qt;
+      w->start_at_line_beg = !NILP (Fbolp ());
+      w->force_start = 1;
     }
   else
     Fgoto_char (w->start);
@@ -5612,7 +5610,7 @@ the return value is nil.  Otherwise the value is t.  */)
             /* If saved buffer is alive, install it.  */
             {
               w->buffer = p->buffer;
-              w->start_at_line_beg = p->start_at_line_beg;
+              w->start_at_line_beg = !NILP (p->start_at_line_beg);
               set_marker_restricted (w->start, p->start, w->buffer);
               set_marker_restricted (w->pointm, p->pointm, w->buffer);
               Fset_marker (BVAR (XBUFFER (w->buffer), mark),
@@ -5637,7 +5635,7 @@ the return value is nil.  Otherwise the value is t.  */)
                 set_marker_restricted_both (w->pointm, w->buffer,
                                             BUF_PT (XBUFFER (w->buffer)),
                                             BUF_PT_BYTE (XBUFFER (w->buffer)));
-              w->start_at_line_beg = Qt;
+              w->start_at_line_beg = 1;
             }
           else if (STRINGP (auto_buffer_name =
                             Fwindow_parameter (window, Qauto_buffer_name))
@@ -5646,7 +5644,7 @@ the return value is nil.  Otherwise the value is t.  */)
             {
               set_marker_restricted (w->start, make_number (0), w->buffer);
               set_marker_restricted (w->pointm, make_number (0), w->buffer);
-              w->start_at_line_beg = Qt;
+              w->start_at_line_beg = 1;
             }
           else
             /* Window has no live buffer, get one.  */
@@ -5660,7 +5658,7 @@ the return value is nil.  Otherwise the value is t.  */)
                  range.  */
               set_marker_restricted (w->start, make_number (0), w->buffer);
               set_marker_restricted (w->pointm, make_number (0), w->buffer);
-              w->start_at_line_beg = Qt;
+              w->start_at_line_beg = 1;
               if (!NILP (w->dedicated))
                 /* Record this window as dead.  */
                 dead_windows = Fcons (window, dead_windows);
@@ -5961,7 +5959,7 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
             = !NILP (Vwindow_point_insertion_type);
 
           p->start = Fcopy_marker (w->start, Qnil);
-          p->start_at_line_beg = w->start_at_line_beg;
+          p->start_at_line_beg = w->start_at_line_beg ? Qt : Qnil;
 
           tem = BVAR (XBUFFER (w->buffer), mark);
           p->mark = Fcopy_marker (tem, Qnil);
diff --git a/src/window.h b/src/window.h
index 1524805579f..0d3910c8cb0 100644
--- a/src/window.h
+++ b/src/window.h
@@ -94,9 +94,6 @@ struct window
     /* The frame this window is on.  */
     Lisp_Object frame;
 
-    /* t if this window is a minibuffer window.  */
-    Lisp_Object mini_p;
-
     /* Following (to right or down) and preceding (to left or up) child
        at same level of tree.  */
     Lisp_Object next, prev;
@@ -144,15 +141,6 @@ struct window
        each one can have its own value of point.  */
     Lisp_Object pointm;
 
-    /* Non-nil means next redisplay must use the value of start
-       set up for it in advance.  Set by scrolling commands.  */
-    Lisp_Object force_start;
-    /* Non-nil means we have explicitly changed the value of start,
-       but that the next redisplay is not obliged to use the new value.
-       This is used in Fdelete_other_windows to force a call to
-       Vwindow_scroll_functions; also by Frecenter with argument.  */
-    Lisp_Object optional_new_start;
-
     /* Number of columns display within the window is scrolled to the left.  */
     Lisp_Object hscroll;
     /* Minimum hscroll for automatic hscrolling.  This is the value
@@ -176,9 +164,6 @@ struct window
     Lisp_Object last_overlay_modified;
     /* Value of point at that time.  */
     Lisp_Object last_point;
-    /* Non-nil if the buffer was "modified" when the window
-       was last updated.  */
-    Lisp_Object last_had_star;
 
     /* This window's vertical scroll bar.  This field is only for use
        by the window-system-dependent code which implements the
@@ -206,11 +191,6 @@ struct window
        no scroll bar.  A value of t means use frame value.  */
     Lisp_Object vertical_scroll_bar_type;
 
-    /* Frame coords of mark as of last time display completed */
-    /* May be nil if mark does not exist or was not on frame */
-    Lisp_Object last_mark_x;
-    Lisp_Object last_mark_y;
-
     /* Z - the buffer position of the last glyph in the current matrix
        of W.  Only valid if WINDOW_END_VALID is not nil.  */
     Lisp_Object window_end_pos;
@@ -223,18 +203,13 @@ struct window
        did not get onto the frame.  */
     Lisp_Object window_end_valid;
 
-    /* Non-nil means must regenerate mode line of this window */
-    Lisp_Object update_mode_line;
-
-    /* Non-nil means current value of `start'
-       was the beginning of a line when it was chosen.  */
-    Lisp_Object start_at_line_beg;
-
     /* Display-table to use for displaying chars in this window.
        Nil means use the buffer's own display-table.  */
     Lisp_Object display_table;
 
-    /* Non-nil means window is marked as dedicated.  */
+    /* Non-nil usually means window is marked as dedicated.
+       Note Lisp code may set this to something beyond Qnil
+       and Qt, so bitfield can't be used here.  */
     Lisp_Object dedicated;
 
     /* Line number and position of a line somewhere above the top of the
@@ -302,6 +277,30 @@ struct window
     /* This is handy for undrawing the cursor.  */
     int phys_cursor_ascent, phys_cursor_height;
 
+    /* Non-zero if this window is a minibuffer window.  */
+    unsigned mini : 1;
+
+    /* Non-zero means must regenerate mode line of this window */
+    unsigned update_mode_line : 1;
+
+    /* Non-nil if the buffer was "modified" when the window
+       was last updated.  */
+    unsigned last_had_star : 1;
+
+    /* Non-zero means current value of `start'
+       was the beginning of a line when it was chosen.  */
+    unsigned start_at_line_beg : 1;
+
+    /* Non-zero means next redisplay must use the value of start
+       set up for it in advance.  Set by scrolling commands.  */
+    unsigned force_start : 1;
+
+    /* Non-zero means we have explicitly changed the value of start,
+       but that the next redisplay is not obliged to use the new value.
+       This is used in Fdelete_other_windows to force a call to
+       Vwindow_scroll_functions; also by Frecenter with argument.  */
+    unsigned optional_new_start : 1;
+
     /* Non-zero means the cursor is currently displayed.  This can be
        set to zero by functions overpainting the cursor image.  */
     unsigned phys_cursor_on_p : 1;
@@ -337,7 +336,7 @@ struct window
 
 /* 1 if W is a minibuffer window.  */
 
-#define MINI_WINDOW_P(W)        (!NILP ((W)->mini_p))
+#define MINI_WINDOW_P(W)        ((W)->mini)
 
 /* General window layout:
 
diff --git a/src/xdisp.c b/src/xdisp.c
index c8d2de7c9de..39059acdb85 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -1,6 +1,6 @@
 /* Display generation from window structure and buffer text.
 
-Copyright (C) 1985-1988, 1993-1995, 1997-2012  Free Software Foundation, Inc.
+Copyright (C) 1985-1988, 1993-1995, 1997-2012 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -753,6 +753,7 @@ static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 };
 int redisplaying_p;
 
 static Lisp_Object Qinhibit_free_realized_faces;
+static Lisp_Object Qmode_line_default_help_echo;
 
 /* If a string, XTread_socket generates an event to display that string.
    (The display is done in read_char.)  */
@@ -9818,7 +9819,7 @@ vmessage (const char *m, va_list ap)
               len = doprnt (FRAME_MESSAGE_BUF (f),
                             FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, ap);
 
-              message2 (FRAME_MESSAGE_BUF (f), len, 0);
+              message2 (FRAME_MESSAGE_BUF (f), len, 1);
             }
           else
             message1 (0);
@@ -11223,7 +11224,7 @@ update_menu_bar (struct frame *f, int save_match_data, int hooks_run)
           || update_mode_lines
           || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
                < BUF_MODIFF (XBUFFER (w->buffer)))
-              != !NILP (w->last_had_star))
+              != w->last_had_star)
           || ((!NILP (Vtransient_mark_mode)
                && !NILP (BVAR (XBUFFER (w->buffer), mark_active)))
               != !NILP (w->region_showing)))
@@ -11275,11 +11276,11 @@ update_menu_bar (struct frame *f, int save_match_data, int hooks_run)
           else
             /* On a terminal screen, the menu bar is an ordinary screen
                line, and this makes it get updated.  */
-            w->update_mode_line = Qt;
+            w->update_mode_line = 1;
 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
           /* In the non-toolkit version, the menu bar is an ordinary screen
              line, and this makes it get updated.  */
-          w->update_mode_line = Qt;
+          w->update_mode_line = 1;
 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
 
           unbind_to (count, Qnil);
@@ -11417,11 +11418,11 @@ update_tool_bar (struct frame *f, int save_match_data)
          the rest of the redisplay algorithm is about the same as
          windows_or_buffers_changed anyway.  */
       if (windows_or_buffers_changed
-          || !NILP (w->update_mode_line)
+          || w->update_mode_line
           || update_mode_lines
           || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
                < BUF_MODIFF (XBUFFER (w->buffer)))
-              != !NILP (w->last_had_star))
+              != w->last_had_star)
           || ((!NILP (Vtransient_mark_mode)
                && !NILP (BVAR (XBUFFER (w->buffer), mark_active)))
               != !NILP (w->region_showing)))
@@ -11472,7 +11473,7 @@ update_tool_bar (struct frame *f, int save_match_data)
               BLOCK_INPUT;
               f->tool_bar_items = new_tool_bar;
               f->n_tool_bar_items = new_n_tool_bar;
-              w->update_mode_line = Qt;
+              w->update_mode_line = 1;
               UNBLOCK_INPUT;
             }
 
@@ -13021,9 +13022,9 @@ redisplay_internal (void)
     update_mode_lines++;
 
   /* Detect case that we need to write or remove a star in the mode line.  */
-  if ((SAVE_MODIFF < MODIFF) != !NILP (w->last_had_star))
+  if ((SAVE_MODIFF < MODIFF) != w->last_had_star)
     {
-      w->update_mode_line = Qt;
+      w->update_mode_line = 1;
       if (buffer_shared > 1)
         update_mode_lines++;
     }
@@ -13040,7 +13041,7 @@ redisplay_internal (void)
            && XFASTINT (w->last_modified) >= MODIFF
            && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
       && (XFASTINT (w->column_number_displayed) != current_column ()))
-    w->update_mode_line = Qt;
+    w->update_mode_line = 1;
 
   unbind_to (count1, Qnil);
 
@@ -13143,7 +13144,7 @@ redisplay_internal (void)
   tlendpos = this_line_end_pos;
   if (!consider_all_windows_p
       && CHARPOS (tlbufpos) > 0
-      && NILP (w->update_mode_line)
+      && !w->update_mode_line
       && !current_buffer->clip_changed
       && !current_buffer->prevent_redisplay_optimizations_p
       && FRAME_VISIBLE_P (XFRAME (w->frame))
@@ -13151,8 +13152,8 @@ redisplay_internal (void)
       /* Make sure recorded data applies to current buffer, etc.  */
       && this_line_buffer == current_buffer
       && current_buffer == XBUFFER (w->buffer)
-      && NILP (w->force_start)
-      && NILP (w->optional_new_start)
+      && !w->force_start
+      && !w->optional_new_start
       /* Point must be on the line that we have info recorded about.  */
       && PT >= CHARPOS (tlbufpos)
       && PT <= Z - CHARPOS (tlendpos)
@@ -13694,7 +13695,7 @@ mark_window_display_accurate_1 (struct window *w, int accurate_p)
       w->last_overlay_modified
         = make_number (accurate_p ? BUF_OVERLAY_MODIFF (b) : 0);
       w->last_had_star
-        = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b) ? Qt : Qnil;
+        = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b);
 
       if (accurate_p)
         {
@@ -13723,7 +13724,7 @@ mark_window_display_accurate_1 (struct window *w, int accurate_p)
   if (accurate_p)
     {
       w->window_end_valid = w->buffer;
-      w->update_mode_line = Qnil;
+      w->update_mode_line = 0;
     }
 }
 
@@ -15352,7 +15353,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   reconsider_clip_changes (w, buffer);
 
   /* Has the mode line to be updated?  */
-  update_mode_line = (!NILP (w->update_mode_line)
+  update_mode_line = (w->update_mode_line
                       || update_mode_lines
                       || buffer->clip_changed
                       || buffer->prevent_redisplay_optimizations_p);
@@ -15524,32 +15525,31 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
   /* If someone specified a new starting point but did not insist,
      check whether it can be used.  */
-  if (!NILP (w->optional_new_start)
+  if (w->optional_new_start
       && CHARPOS (startp) >= BEGV
       && CHARPOS (startp) <= ZV)
     {
-      w->optional_new_start = Qnil;
+      w->optional_new_start = 0;
       start_display (&it, w, startp);
       move_it_to (&it, PT, 0, it.last_visible_y, -1,
                   MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
       if (IT_CHARPOS (it) == PT)
-        w->force_start = Qt;
+        w->force_start = 1;
       /* IT may overshoot PT if text at PT is invisible.  */
       else if (IT_CHARPOS (it) > PT && CHARPOS (startp) <= PT)
-        w->force_start = Qt;
+        w->force_start = 1;
     }
 
  force_start:
 
   /* Handle case where place to start displaying has been specified,
      unless the specified location is outside the accessible range.  */
-  if (!NILP (w->force_start)
-      || w->frozen_window_start_p)
+  if (w->force_start || w->frozen_window_start_p)
     {
       /* We set this later on if we have to adjust point.  */
       int new_vpos = -1;
 
-      w->force_start = Qnil;
+      w->force_start = 0;
       w->vscroll = 0;
       w->window_end_valid = Qnil;
 
@@ -15568,7 +15568,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
           || ! NILP (Vwindow_scroll_functions))
         {
           update_mode_line = 1;
-          w->update_mode_line = Qt;
+          w->update_mode_line = 1;
           startp = run_window_scroll_functions (window, startp);
         }
 
@@ -15586,7 +15586,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
          the scroll margin (bug#148) -- cyd  */
       if (!try_window (window, startp, 0))
         {
-          w->force_start = Qt;
+          w->force_start = 1;
           clear_glyph_matrix (w->desired_matrix);
           goto need_larger_matrices;
         }
@@ -15665,7 +15665,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
     }
   /* If current starting point was originally the beginning of a line
      but no longer is, find a new starting point.  */
-  else if (!NILP (w->start_at_line_beg)
+  else if (w->start_at_line_beg
            && !(CHARPOS (startp) <= BEGV
                 || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n'))
     {
@@ -15712,7 +15712,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
          new window start, since that would change the position under
          the mouse, resulting in an unwanted mouse-movement rather
          than a simple mouse-click.  */
-      if (NILP (w->start_at_line_beg)
+      if (!w->start_at_line_beg
           && NILP (do_mouse_tracking)
           && CHARPOS (startp) > BEGV
           && CHARPOS (startp) > BEG + beg_unchanged
@@ -15732,7 +15732,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
              See bug#9324.  */
           && pos_visible_p (w, PT, &d1, &d2, &d3, &d4, &d5, &d6))
         {
-          w->force_start = Qt;
+          w->force_start = 1;
           SET_TEXT_POS_FROM_MARKER (startp, w->start);
           goto force_start;
         }
@@ -15793,7 +15793,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   if (!update_mode_line)
     {
       update_mode_line = 1;
-      w->update_mode_line = Qt;
+      w->update_mode_line = 1;
     }
 
   /* Try to scroll by specified few lines.  */
@@ -16048,9 +16048,8 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
  done:
 
   SET_TEXT_POS_FROM_MARKER (startp, w->start);
-  w->start_at_line_beg = ((CHARPOS (startp) == BEGV
-                           || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n')
-                          ? Qt : Qnil);
+  w->start_at_line_beg = (CHARPOS (startp) == BEGV
+                            || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n');
 
   /* Display the mode line, if we must.  */
   if ((update_mode_line
@@ -16274,7 +16273,7 @@ try_window (Lisp_Object window, struct text_pos pos, int flags)
   /* If bottom moved off end of frame, change mode line percentage.  */
   if (XFASTINT (w->window_end_pos) <= 0
       && Z != IT_CHARPOS (it))
-    w->update_mode_line = Qt;
+    w->update_mode_line = 1;
 
   /* Set window_end_pos to the offset of the last character displayed
      on the window from the end of current_buffer.  Set
@@ -21118,8 +21117,7 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_
 
   if (!VECTORP (val))           /* Not yet decided.  */
     {
-      if (multibyte)
-        *buf++ = '-';
+      *buf++ = multibyte ? '-' : ' ';
       if (eol_flag)
         eoltype = eol_mnemonic_undecided;
       /* Don't mention EOL conversion if it isn't decided.  */
@@ -21132,8 +21130,9 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_
       attrs = AREF (val, 0);
       eolvalue = AREF (val, 2);
 
-      if (multibyte)
-        *buf++ = XFASTINT (CODING_ATTR_MNEMONIC (attrs));
+      *buf++ = multibyte
+        ? XFASTINT (CODING_ATTR_MNEMONIC (attrs))
+        : ' ';
 
       if (eol_flag)
         {
@@ -22198,7 +22197,9 @@ calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop,
             return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w));
         }
 
-      prop = Fbuffer_local_value (prop, it->w->buffer);
+      prop = buffer_local_value_1 (prop, it->w->buffer);
+      if (EQ (prop, Qunbound))
+        prop = Qnil;
     }
 
   if (INTEGERP (prop) || FLOATP (prop))
@@ -22255,7 +22256,9 @@ calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop,
               return OK_PIXELS (pixels);
             }
 
-          car = Fbuffer_local_value (car, it->w->buffer);
+          car = buffer_local_value_1 (car, it->w->buffer);
+          if (EQ (car, Qunbound))
+            car = Qnil;
         }
 
       if (INTEGERP (car) || FLOATP (car))
@@ -27202,12 +27205,12 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
   int dx, dy, width, height;
   ptrdiff_t charpos;
   Lisp_Object string, object = Qnil;
-  Lisp_Object pos, help;
+  Lisp_Object pos IF_LINT (= Qnil), help;
 
   Lisp_Object mouse_face;
   int original_x_pixel = x;
   struct glyph * glyph = NULL, * row_start_glyph = NULL;
-  struct glyph_row *row;
+  struct glyph_row *row IF_LINT (= 0);
 
   if (area == ON_MODE_LINE || area == ON_HEADER_LINE)
     {
@@ -27275,7 +27278,6 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
               if (!NILP (help))
                 {
                   help_echo_string = help;
-                  /* Is this correct?  ++kfs */
                   XSETWINDOW (help_echo_window, w);
                   help_echo_object = w->buffer;
                   help_echo_pos = charpos;
@@ -27288,14 +27290,20 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
 #endif  /* HAVE_WINDOW_SYSTEM */
 
   if (STRINGP (string))
+    pos = make_number (charpos);
+
+  /* Set the help text and mouse pointer.  If the mouse is on a part
+     of the mode line without any text (e.g. past the right edge of
+     the mode line text), use the default help text and pointer.  */
+  if (STRINGP (string) || area == ON_MODE_LINE)
     {
-      pos = make_number (charpos);
-      /* If we're on a string with `help-echo' text property, arrange
-         for the help to be displayed.  This is done by setting the
-         global variable help_echo_string to the help string.  */
+      /* Arrange to display the help by setting the global variables
+         help_echo_string, help_echo_object, and help_echo_pos.  */
       if (NILP (help))
         {
-          help = Fget_text_property (pos, Qhelp_echo, string);
+          if (STRINGP (string))
+            help = Fget_text_property (pos, Qhelp_echo, string);
+
           if (!NILP (help))
             {
               help_echo_string = help;
@@ -27303,31 +27311,56 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
               help_echo_object = string;
               help_echo_pos = charpos;
             }
+          else if (area == ON_MODE_LINE)
+            {
+              Lisp_Object default_help
+                = buffer_local_value_1 (Qmode_line_default_help_echo,
+                                        w->buffer);
+
+              if (STRINGP (default_help))
+                {
+                  help_echo_string = default_help;
+                  XSETWINDOW (help_echo_window, w);
+                  help_echo_object = Qnil;
+                  help_echo_pos = -1;
+                }
+            }
         }
 
 #ifdef HAVE_WINDOW_SYSTEM
+      /* Change the mouse pointer according to what is under it.  */
       if (FRAME_WINDOW_P (f))
         {
           dpyinfo = FRAME_X_DISPLAY_INFO (f);
-          cursor  = FRAME_X_OUTPUT (f)->nontext_cursor;
-          if (NILP (pointer))
-            pointer = Fget_text_property (pos, Qpointer, string);
-
-          /* Change the mouse pointer according to what is under X/Y.  */
-          if (NILP (pointer)
-              && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE)))
+          if (STRINGP (string))
             {
-              Lisp_Object map;
-              map = Fget_text_property (pos, Qlocal_map, string);
-              if (!KEYMAPP (map))
-                map = Fget_text_property (pos, Qkeymap, string);
-              if (!KEYMAPP (map))
-                cursor = dpyinfo->vertical_scroll_bar_cursor;
+              cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
+
+              if (NILP (pointer))
+                pointer = Fget_text_property (pos, Qpointer, string);
+
+              /* Change the mouse pointer according to what is under X/Y.  */
+              if (NILP (pointer)
+                  && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE)))
+                {
+                  Lisp_Object map;
+                  map = Fget_text_property (pos, Qlocal_map, string);
+                  if (!KEYMAPP (map))
+                    map = Fget_text_property (pos, Qkeymap, string);
+                  if (!KEYMAPP (map))
+                    cursor = dpyinfo->vertical_scroll_bar_cursor;
+                }
             }
+          else
+            /* Default mode-line pointer.  */
+            cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
         }
 #endif
+    }
 
-     /* Change the mouse face according to what is under X/Y.  */
+  /* Change the mouse face according to what is under X/Y.  */
+  if (STRINGP (string))
+    {
       mouse_face = Fget_text_property (pos, Qmouse_face, string);
       if (!NILP (mouse_face)
           && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))
@@ -28668,6 +28701,8 @@ syms_of_xdisp (void)
   Vmode_line_unwind_vector = Qnil;
   staticpro (&Vmode_line_unwind_vector);
 
+  DEFSYM (Qmode_line_default_help_echo, "mode-line-default-help-echo");
+
   help_echo_string = Qnil;
   staticpro (&help_echo_string);
   help_echo_object = Qnil;
@@ -28948,7 +28983,9 @@ It can be one of
  both             - show both, text below image
  both-horiz       - show text to the right of the image
  text-image-horiz - show text to the left of the image
- any other        - use system default or image if no system default.  */);
+ any other        - use system default or image if no system default.
+
+This variable only affects the GTK+ toolkit version of Emacs.  */);
   Vtool_bar_style = Qnil;
 
   DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size,
diff --git a/src/xfaces.c b/src/xfaces.c
index 84a47cf6ccf..772d2646291 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -4579,7 +4579,7 @@ lookup_named_face (struct frame *f, Lisp_Object symbol, int signal_p)
 }
 
 
-/* Return the display face-id of the basic face who's canonical face-id
+/* Return the display face-id of the basic face whose canonical face-id
    is FACE_ID.  The return value will usually simply be FACE_ID, unless that
    basic face has bee remapped via Vface_remapping_alist.  This function is
    conservative: if something goes wrong, it will simply return FACE_ID
@@ -4884,14 +4884,13 @@ static int
 tty_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs,
                                 struct face *def_face)
 {
-  int weight;
+  int weight, slant;
   Lisp_Object val, fg, bg;
   XColor fg_tty_color, fg_std_color;
   XColor bg_tty_color, bg_std_color;
   unsigned test_caps = 0;
   Lisp_Object *def_attrs = def_face->lface;
 
-
   /* First check some easy-to-check stuff; ttys support none of the
      following attributes, so we can just return false if any are requested
      (even if `nominal' values are specified, we should still return false,
@@ -4907,11 +4906,9 @@ tty_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs,
       || !UNSPECIFIEDP (attrs[LFACE_SWIDTH_INDEX])
       || !UNSPECIFIEDP (attrs[LFACE_OVERLINE_INDEX])
       || !UNSPECIFIEDP (attrs[LFACE_STRIKE_THROUGH_INDEX])
-      || !UNSPECIFIEDP (attrs[LFACE_BOX_INDEX])
-      || !UNSPECIFIEDP (attrs[LFACE_SLANT_INDEX]))
+      || !UNSPECIFIEDP (attrs[LFACE_BOX_INDEX]))
     return 0;
 
-
   /* Test for terminal `capabilities' (non-color character attributes).  */
 
   /* font weight (bold/dim) */
@@ -4937,6 +4934,18 @@ tty_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs,
         return 0;               /* same as default */
     }
 
+  /* font slant */
+  val = attrs[LFACE_SLANT_INDEX];
+  if (!UNSPECIFIEDP (val)
+      && (slant = FONT_SLANT_NAME_NUMERIC (val), slant >= 0))
+    {
+      int def_slant = FONT_SLANT_NAME_NUMERIC (def_attrs[LFACE_SLANT_INDEX]);
+      if (slant == 100 || slant == def_slant)
+        return 0; /* same as default */
+      else
+        test_caps |= TTY_CAP_ITALIC;
+    }
+
   /* underlining */
   val = attrs[LFACE_UNDERLINE_INDEX];
   if (!UNSPECIFIEDP (val))
@@ -5336,11 +5345,11 @@ realize_default_face (struct frame *f)
   /* If the `default' face is not yet known, create it.  */
   lface = lface_from_face_name (f, Qdefault, 0);
   if (NILP (lface))
-  {
+    {
        Lisp_Object frame;
        XSETFRAME (frame, f);
        lface = Finternal_make_lisp_face (Qdefault, frame);
-  }
+    }
 
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (f))
@@ -5857,15 +5866,13 @@ realize_tty_face (struct face_cache *cache, Lisp_Object *attrs)
   face->font_name = FRAME_MSDOS_P (cache->f) ? "ms-dos" : "tty";
 #endif
 
-  /* Map face attributes to TTY appearances.  We map slant to
-     dimmed text because we want italic text to appear differently
-     and because dimmed text is probably used infrequently.  */
+  /* Map face attributes to TTY appearances.  */
   weight = FONT_WEIGHT_NAME_NUMERIC (attrs[LFACE_WEIGHT_INDEX]);
   slant = FONT_SLANT_NAME_NUMERIC (attrs[LFACE_SLANT_INDEX]);
   if (weight > 100)
     face->tty_bold_p = 1;
-  if (weight < 100 || slant != 100)
-    face->tty_dim_p = 1;
+  if (slant != 100)
+    face->tty_italic_p = 1;
   if (!NILP (attrs[LFACE_UNDERLINE_INDEX]))
     face->tty_underline_p = 1;
   if (!NILP (attrs[LFACE_INVERSE_INDEX]))
@@ -6111,14 +6118,14 @@ face_for_overlay_string (struct window *w, ptrdiff_t pos,
 
   *endptr = endpos;
 
-  default_face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
-
-  /* Optimize common cases where we can use the default face.  */
+  /* Optimize common case where we can use the default face.  */
   if (NILP (prop)
-      && !(pos >= region_beg && pos < region_end))
+      && !(pos >= region_beg && pos < region_end)
+      && NILP (Vface_remapping_alist))
     return DEFAULT_FACE_ID;
 
   /* Begin with attributes from the default face.  */
+  default_face = FACE_FROM_ID (f, lookup_basic_face (f, DEFAULT_FACE_ID));
   memcpy (attrs, default_face->lface, sizeof attrs);
 
   /* Merge in attributes specified via text properties.  */
diff --git a/src/xfns.c b/src/xfns.c
index 1f1d3d3ef0c..43ccdfaef1a 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -1207,7 +1207,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
       FRAME_EXTERNAL_MENU_BAR (f) = 1;
       if (FRAME_X_P (f) && f->output_data.x->menubar_widget == 0)
         /* Make sure next redisplay shows the menu bar.  */
-        XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
+        XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = 1;
     }
   else
     {
@@ -1291,7 +1291,7 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
       FRAME_EXTERNAL_TOOL_BAR (f) = 1;
       if (FRAME_X_P (f) && f->output_data.x->toolbar_widget == 0)
         /* Make sure next redisplay shows the tool bar.  */
-        XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
+        XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = 1;
       update_frame_tool_bar (f);
     }
   else
diff --git a/src/xfont.c b/src/xfont.c
index bde76c0ba3c..cc06e27fe02 100644
--- a/src/xfont.c
+++ b/src/xfont.c
@@ -132,7 +132,7 @@ static int xfont_check (FRAME_PTR, struct font *);
 
 struct font_driver xfont_driver =
   {
-    0,                          /* Qx */
+    LISP_INITIALLY_ZERO,        /* Qx */
     0,                          /* case insensitive */
     xfont_get_cache,
     xfont_list,