Merge from emacs--devo--0

Patches applied:

 * emacs--devo--0  (patch 806-813)

   - Merge from emacs--rel--22
   - Update from CVS

 * emacs--rel--22  (patch 51-58)

   - Update from CVS
   - Merge from gnus--rel--5.10

 * gnus--rel--5.10  (patch 233-236)

   - Merge from emacs--devo--0
   - Update from CVS

Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-230

16 files changed, 553 insertions, 341 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 101dd489fb3..76c8c8ef163 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,98 @@
+2007-07-14  Jason Rumney  <jasonr@gnu.org>
+
+        * process.c [WINDOWSNT]: Don't undefine AF_INET6.
+
+2007-07-14  Richard Stallman  <rms@gnu.org>
+
+        * eval.c (maybe_call_debugger): New function.
+        (find_handler_clause): Use maybe_call_debugger.
+        Call it when the handler says `debug'.
+        Eliminate DEBUGGER_VALUE_PTR.
+        (Fsignal): Eliminate debugger_value.
+        (Qdebug): New variable.
+        (syms_of_eval): Initialize it.
+
+2007-07-14  Juanma Barranquero  <lekktu@gmail.com>
+
+        * eval.c (Fprogn):
+        * keyboard.c (Ftrack_mouse):
+        * print.c (Fwith_output_to_temp_buffer):
+        * window.c (Fsave_window_excursion): Doc fix.
+
+2007-07-13  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (init_eval_once): Bump max_lisp_eval_depth to 400.
+
+2007-07-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * process.h (struct Lisp_Process): Turn slots infd, outfd,
+        kill_without_query, pty_flag, tick, update_tick, decoding_carryover,
+        inherit_coding_system_flag, filter_multibyte, adaptive_read_buffering,
+        read_output_delay, and read_output_skip from Lisp_Objects to ints.
+        Remove unused encoding_carryover.
+        * process.c: Adjust all functions accordingly.
+
+2007-07-12  Richard Stallman  <rms@gnu.org>
+
+        * term.c: Include unistd.h only if HAVE_UNISTD_H.
+
+2007-07-11  Jason Rumney  <jasonr@gnu.org>
+
+        * makefile.w32-in (LIBS): Include OLE32.
+
+        * w32fns.c (w32_msg_pump) <WM_EMACS_CREATEWINDOW>: Initialize COM.
+        (w32_msg_pump) <WM_DESTROY>: Uninitialize COM.
+
+2007-07-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lisp.h (struct Lisp_Hash_Table): Turn next_weak into a bare pointer.
+        * fns.c (weak_hash_tables): Rename from Vweak_hash_tables and turned
+        from a Lisp_Object into a bare pointer.
+        (make_hash_table, copy_hash_table, sweep_weak_hash_tables, init_fns):
+        Adjust the code correspondingly.
+
+        * alloc.c (emacs_blocked_free): Remove unused var `bytes_used_now'.
+
+        * term.c: Include unistd.h for ttyname, used in handle_one_term_event.
+        (term_show_mouse_face): Remove unused var `j'.
+        (handle_one_term_event): Remove unused vars `i' and `j'.
+        Don't cast return value of ttyname since it's not necessary.
+
+2007-07-10  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * alloc.c (mark_maybe_pointer): Enforce mult-of-8 alignment when using
+        USE_LSB_TAG.  Suggested by Dmitry Antipov <dmantipov@yandex.ru>.
+
+        * fns.c (map_char_table): Use an array of int for `indices' rather than
+        an array of Lisp_Objects (which are only ever integers anyway).
+        (Fmap_char_table): Update caller.
+        * lisp.h: Update prototype.
+        * keymap.c (Fset_keymap_parent, map_keymap, Fcopy_keymap):
+        * fontset.c (Ffontset_info):
+        * casetab.c (set_case_table): Update callers.
+
+        * editfns.c (Ftranspose_regions): Use EMACS_INT for positions.
+
+        * keymap.c (struct accessible_keymaps_data)
+        (struct where_is_internal_data): New structures.
+        (accessible_keymaps_1, where_is_internal_1): Use them to change
+        interface to adhere to the one used by map_keymap.
+        (Faccessible_keymaps, where_is_internal): Use map_keymap.
+        (accessible_keymaps_char_table, where_is_internal_2): Remove.
+
+        * keymap.h (map_keymap_function_t): More informative prototype.
+
+2007-07-10  Guanpeng Xu  <herberteuler@hotmail.com>
+
+        * search.c (Vinhibit_changing_match_data, search_regs_1): New vars.
+        (looking_at_1): Don't change search_regs and last_thing_searched
+        if `inhibit-changing-match-data' is non-nil.
+        (string_match_1, search_buffer, set_search_regs): Likewise.
+        (syms_of_search): Add Lisp level definition for
+        `inhibit-changing-match-data' and set it to nil.
+        (boyer_moore): If `inhibit-changing-match-data' is non-nil, compute
+        start and end of the match, instead of using values in search_regs.
+
 2007-07-01  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * minibuf.c (Fcompleting_read): New value `confirm-only'
@@ -1118,13 +1213,13 @@
         when popup menu finishes.
 
         * w32fns.c (menubar_in_use): New flag.
-        (w32_wnd_proc) [WM_INITMENU, WM_EXITMENULOOP, WM_TIMER, WM_COMMAND]:
+        (w32_wnd_proc) <WM_INITMENU, WM_EXITMENULOOP, WM_TIMER, WM_COMMAND>:
         Use it.
 
         * w32menu.c (Fx_popup_menu): Don't free menu strings here.
         (w32_menu_show): Do it here instead.
 
-        * w32fns.c (w32_wnd_proc) [WM_INITMENU]: Set menubar_active frame
+        * w32fns.c (w32_wnd_proc) <WM_INITMENU>: Set menubar_active frame
         parameter.
 
         * w32menu.c (current_popup_menu): Make available globally.
@@ -1132,7 +1227,7 @@
         menu event into the keyboard buffer.  Remove menu_command_in_progress.
 
         * w32fns.c (current_popup_menu): Use from w32menu.c.
-        (w32_wnd_proc) [WM_EXITMENULOOP, WM_TIMER]: Use menubar_active
+        (w32_wnd_proc) <WM_EXITMENULOOP, WM_TIMER>: Use menubar_active
         and current_popup_menu to determine whether a menubar menu has
         been cancelled.
 
@@ -10243,7 +10338,7 @@
         * w32term.h (x_output): Add focus_state.
 
         * w32term.c (x_focus_changed, w32_detect_focus_change): New functions.
-        (w32_read_socket) [WM_SETFOCUS]: Call w32_detect_focus_change.
+        (w32_read_socket) <WM_SETFOCUS>: Call w32_detect_focus_change.
 
 2005-03-25  Stefan Monnier  <monnier@iro.umontreal.ca>
 
@@ -13531,7 +13626,7 @@
 
         * w32term.h (AppendMenuW_Proc): Move declaration from w32menu.c.
 
-        * w32fns.c (w32_wnd_proc) [WM_MEASUREITEM, WM_DRAWITEM]:
+        * w32fns.c (w32_wnd_proc) <WM_MEASUREITEM, WM_DRAWITEM>:
         Handle Unicode menu titles.
 
 2004-09-07  Kim F. Storm  <storm@cua.dk>
diff --git a/src/alloc.c b/src/alloc.c
index d5de5f7296b..fd366339a53 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -1179,8 +1179,6 @@ emacs_blocked_free (ptr, ptr2)
      void *ptr;
      const void *ptr2;
 {
-  EMACS_INT bytes_used_now;
-
   BLOCK_INPUT_ALLOC;
 
 #ifdef GC_MALLOC_CHECK
@@ -4220,9 +4218,14 @@ mark_maybe_pointer (p)
 {
   struct mem_node *m;
 
-  /* Quickly rule out some values which can't point to Lisp data.  We
-     assume that Lisp data is aligned on even addresses.  */
-  if ((EMACS_INT) p & 1)
+  /* Quickly rule out some values which can't point to Lisp data.  */
+  if ((EMACS_INT) 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
+      )
     return;
 
   m = mem_find (p);
diff --git a/src/editfns.c b/src/editfns.c
index b615012c700..43dc59e78b3 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -4256,9 +4256,9 @@ Transposing beyond buffer boundaries is an error.  */)
      (startr1, endr1, startr2, endr2, leave_markers)
      Lisp_Object startr1, endr1, startr2, endr2, leave_markers;
 {
-  register int start1, end1, start2, end2;
-  int start1_byte, start2_byte, len1_byte, len2_byte;
-  int gap, len1, len_mid, len2;
+  register EMACS_INT start1, end1, start2, end2;
+  EMACS_INT start1_byte, start2_byte, len1_byte, len2_byte;
+  EMACS_INT gap, len1, len_mid, len2;
   unsigned char *start1_addr, *start2_addr, *temp;
 
   INTERVAL cur_intv, tmp_interval1, tmp_interval_mid, tmp_interval2, tmp_interval3;
diff --git a/src/eval.c b/src/eval.c
index 6707849a840..cd0d0fc1c5c 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -97,6 +97,7 @@ Lisp_Object Qinhibit_quit, Vinhibit_quit, Vquit_flag;
 Lisp_Object Qand_rest, Qand_optional;
 Lisp_Object Qdebug_on_error;
 Lisp_Object Qdeclare;
+Lisp_Object Qdebug;
 
 /* This holds either the symbol `run-hooks' or nil.
    It is nil at an early stage of startup, and when Emacs
@@ -220,7 +221,7 @@ init_eval_once ()
   specpdl_ptr = specpdl;
   /* Don't forget to update docs (lispref node "Local Variables").  */
   max_specpdl_size = 1000;
-  max_lisp_eval_depth = 300;
+  max_lisp_eval_depth = 400;
 
   Vrun_hooks = Qnil;
 }
@@ -433,7 +434,7 @@ usage: (cond CLAUSES...)  */)
 
 DEFUN ("progn", Fprogn, Sprogn, 0, UNEVALLED, 0,
        doc: /* Eval BODY forms sequentially and return value of last one.
-usage: (progn BODY ...)  */)
+usage: (progn BODY...)  */)
      (args)
      Lisp_Object args;
 {
@@ -1585,8 +1586,7 @@ internal_condition_case_2 (bfun, nargs, args, handlers, hfun)
 
 
 static Lisp_Object find_handler_clause P_ ((Lisp_Object, Lisp_Object,
-                                            Lisp_Object, Lisp_Object,
-                                            Lisp_Object *));
+                                            Lisp_Object, Lisp_Object));
 
 DEFUN ("signal", Fsignal, Ssignal, 2, 2, 0,
        doc: /* Signal an error.  Args are ERROR-SYMBOL and associated DATA.
@@ -1612,7 +1612,6 @@ See also the function `condition-case'.  */)
   Lisp_Object conditions;
   extern int gc_in_progress;
   extern int waiting_for_input;
-  Lisp_Object debugger_value;
   Lisp_Object string;
   Lisp_Object real_error_symbol;
   struct backtrace *bp;
@@ -1670,7 +1669,7 @@ See also the function `condition-case'.  */)
       register Lisp_Object clause;
 
       clause = find_handler_clause (handlerlist->handler, conditions,
-                                    error_symbol, data, &debugger_value);
+                                    error_symbol, data);
 
       if (EQ (clause, Qlambda))
         {
@@ -1701,7 +1700,7 @@ See also the function `condition-case'.  */)
   handlerlist = allhandlers;
   /* If no handler is present now, try to run the debugger,
      and if that fails, throw to top level.  */
-  find_handler_clause (Qerror, conditions, error_symbol, data, &debugger_value);
+  find_handler_clause (Qerror, conditions, error_symbol, data);
   if (catchlist != 0)
     Fthrow (Qtop_level, Qt);
 
@@ -1853,75 +1852,54 @@ skip_debugger (conditions, data)
     = SIG is nil, and DATA is (SYMBOL . REST-OF-DATA).
        This is for memory-full errors only.
 
-   Store value returned from debugger into *DEBUGGER_VALUE_PTR.
-
    We need to increase max_specpdl_size temporarily around
    anything we do that can push on the specpdl, so as not to get
    a second error here in case we're handling specpdl overflow.  */
 
 static Lisp_Object
-find_handler_clause (handlers, conditions, sig, data, debugger_value_ptr)
+find_handler_clause (handlers, conditions, sig, data)
      Lisp_Object handlers, conditions, sig, data;
-     Lisp_Object *debugger_value_ptr;
 {
   register Lisp_Object h;
   register Lisp_Object tem;
+  int debugger_called = 0;
+  int debugger_considered = 0;
 
-  if (EQ (handlers, Qt))  /* t is used by handlers for all conditions, set up by C code.  */
+  /* t is used by handlers for all conditions, set up by C code.  */
+  if (EQ (handlers, Qt))
     return Qt;
+
+  /* Don't run the debugger for a memory-full error.
+     (There is no room in memory to do that!)  */
+  if (NILP (sig))
+    debugger_considered = 1;
+
   /* error is used similarly, but means print an error message
      and run the debugger if that is enabled.  */
   if (EQ (handlers, Qerror)
       || !NILP (Vdebug_on_signal)) /* This says call debugger even if
                                       there is a handler.  */
     {
-      int debugger_called = 0;
-      Lisp_Object sig_symbol, combined_data;
-      /* This is set to 1 if we are handling a memory-full error,
-         because these must not run the debugger.
-         (There is no room in memory to do that!)  */
-      int no_debugger = 0;
-
-      if (NILP (sig))
-        {
-          combined_data = data;
-          sig_symbol = Fcar (data);
-          no_debugger = 1;
-        }
-      else
-        {
-          combined_data = Fcons (sig, data);
-          sig_symbol = sig;
-        }
-
-      if (wants_debugger (Vstack_trace_on_error, conditions))
+      if (!NILP (sig) && wants_debugger (Vstack_trace_on_error, conditions))
         {
           max_specpdl_size++;
-#ifdef PROTOTYPES
+    #ifdef PROTOTYPES
           internal_with_output_to_temp_buffer ("*Backtrace*",
                                                (Lisp_Object (*) (Lisp_Object)) Fbacktrace,
                                                Qnil);
-#else
+    #else
           internal_with_output_to_temp_buffer ("*Backtrace*",
                                                Fbacktrace, Qnil);
-#endif
+    #endif
           max_specpdl_size--;
         }
-      if (! no_debugger
-          /* Don't try to run the debugger with interrupts blocked.
-             The editing loop would return anyway.  */
-          && ! INPUT_BLOCKED_P
-          && (EQ (sig_symbol, Qquit)
-              ? debug_on_quit
-              : wants_debugger (Vdebug_on_error, conditions))
-          && ! skip_debugger (conditions, combined_data)
-          && when_entered_debugger < num_nonmacro_input_events)
+
+      if (!debugger_considered)
         {
-          *debugger_value_ptr
-            = call_debugger (Fcons (Qerror,
-                                    Fcons (combined_data, Qnil)));
-          debugger_called = 1;
+          debugger_considered = 1;
+          debugger_called = maybe_call_debugger (conditions, sig, data);
         }
+
       /* If there is no handler, return saying whether we ran the debugger.  */
       if (EQ (handlers, Qerror))
         {
@@ -1930,6 +1908,7 @@ find_handler_clause (handlers, conditions, sig, data, debugger_value_ptr)
           return Qt;
         }
     }
+
   for (h = handlers; CONSP (h); h = Fcdr (h))
     {
       Lisp_Object handler, condit;
@@ -1948,18 +1927,55 @@ find_handler_clause (handlers, conditions, sig, data, debugger_value_ptr)
       /* Handle a list of condition names in handler HANDLER.  */
       else if (CONSP (condit))
         {
-          while (CONSP (condit))
+          Lisp_Object tail;
+          for (tail = condit; CONSP (tail); tail = XCDR (tail))
             {
-              tem = Fmemq (Fcar (condit), conditions);
+              tem = Fmemq (Fcar (tail), conditions);
               if (!NILP (tem))
-                return handler;
-              condit = XCDR (condit);
+                {
+                  /* This handler is going to apply.
+                     Does it allow the debugger to run first?  */
+                  if (! debugger_considered && !NILP (Fmemq (Qdebug, condit)))
+                    maybe_call_debugger (conditions, sig, data);
+                  return handler;
+                }
             }
         }
     }
+
   return Qnil;
 }
 
+/* Call the debugger if calling it is currently enabled for CONDITIONS.
+   SIG and DATA describe the signal, as in find_handler_clause.  */
+
+int
+maybe_call_debugger (conditions, sig, data)
+     Lisp_Object conditions, sig, data;
+{
+  Lisp_Object combined_data;
+
+  combined_data = Fcons (sig, data);
+
+  if (
+      /* Don't try to run the debugger with interrupts blocked.
+         The editing loop would return anyway.  */
+      ! INPUT_BLOCKED_P
+      /* Does user wants to enter debugger for this kind of error?  */
+      && (EQ (sig, Qquit)
+          ? debug_on_quit
+          : wants_debugger (Vdebug_on_error, conditions))
+      && ! skip_debugger (conditions, combined_data)
+      /* rms: what's this for? */
+      && when_entered_debugger < num_nonmacro_input_events)
+    {
+      call_debugger (Fcons (Qerror, Fcons (combined_data, Qnil)));
+      return 1;
+    }
+
+  return 0;
+}
+
 /* dump an error message; called like printf */
 
 /* VARARGS 1 */
@@ -3600,6 +3616,9 @@ before making `inhibit-quit' nil.  */);
   Qand_optional = intern ("&optional");
   staticpro (&Qand_optional);
 
+  Qdebug = intern ("debug");
+  staticpro (&Qdebug);
+
   DEFVAR_LISP ("stack-trace-on-error", &Vstack_trace_on_error,
                doc: /* *Non-nil means errors display a backtrace buffer.
 More precisely, this happens for any error that is handled
diff --git a/src/keyboard.c b/src/keyboard.c
index 6df2d1b0b25..b21242f7918 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -1422,7 +1422,7 @@ DEFUN ("track-mouse", Ftrack_mouse, Strack_mouse, 0, UNEVALLED, 0,
 Within a `track-mouse' form, mouse motion generates input events that
 you can read with `read-event'.
 Normally, mouse motion is ignored.
-usage: (track-mouse BODY ...)  */)
+usage: (track-mouse BODY...)  */)
      (args)
      Lisp_Object args;
 {
diff --git a/src/keymap.c b/src/keymap.c
index 29898fe7a8e..413de76f7d5 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1179,7 +1179,7 @@ binding KEY to DEF is added at the front of KEYMAP.  */)
   if (SYMBOLP (def) && !EQ (Vdefine_key_rebound_commands, Qt))
     Vdefine_key_rebound_commands = Fcons (def, Vdefine_key_rebound_commands);
 
-  meta_bit = (VECTORP (key) || STRINGP (key) && STRING_MULTIBYTE (key)
+  meta_bit = (VECTORP (key) || (STRINGP (key) && STRING_MULTIBYTE (key))
               ? meta_modifier : 0x80);
 
   if (VECTORP (def) && ASIZE (def) > 0 && CONSP (AREF (def, 0)))
@@ -2079,12 +2079,23 @@ DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_
 
 /* Help functions for describing and documenting keymaps.               */
 
+struct accessible_keymaps_data {
+  Lisp_Object maps, tail, thisseq;
+  /* Does the current sequence end in the meta-prefix-char?  */
+  int is_metized;
+};
 
 static void
-accessible_keymaps_1 (key, cmd, maps, tail, thisseq, is_metized)
-     Lisp_Object maps, tail, thisseq, key, cmd;
-     int is_metized;            /* If 1, `key' is assumed to be INTEGERP.  */
+accessible_keymaps_1 (key, cmd, args, data)
+     Lisp_Object key, cmd, args;
+     /* Use void* to be compatible with map_keymap_function_t.  */
+     void *data;
 {
+  struct accessible_keymaps_data *d = data; /* Cast! */
+  Lisp_Object maps = d->maps;
+  Lisp_Object tail = d->tail;
+  Lisp_Object thisseq = d->thisseq;
+  int is_metized = d->is_metized && INTEGERP (key);
   Lisp_Object tem;
 
   cmd = get_keymap (get_keyelt (cmd, 0), 0, 0);
@@ -2138,17 +2149,6 @@ accessible_keymaps_1 (key, cmd, maps, tail, thisseq, is_metized)
     }
 }
 
-static void
-accessible_keymaps_char_table (args, index, cmd)
-     Lisp_Object args, index, cmd;
-{
-  accessible_keymaps_1 (index, cmd,
-                        XCAR (XCAR (args)),
-                        XCAR (XCDR (args)),
-                        XCDR (XCDR (args)),
-                        XINT (XCDR (XCAR (args))));
-}
-
 /* This function cannot GC.  */
 
 DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps,
@@ -2163,14 +2163,11 @@ then the value includes only maps for prefixes that start with PREFIX.  */)
      Lisp_Object keymap, prefix;
 {
   Lisp_Object maps, tail;
-  int prefixlen = 0;
+  int prefixlen = XINT (Flength (prefix));
 
   /* no need for gcpro because we don't autoload any keymaps.  */
 
   if (!NILP (prefix))
-    prefixlen = XINT (Flength (prefix));
-
-  if (!NILP (prefix))
     {
       /* If a prefix was specified, start with the keymap (if any) for
          that prefix, so we don't waste time considering other prefixes.  */
@@ -2180,7 +2177,9 @@ then the value includes only maps for prefixes that start with PREFIX.  */)
          if the prefix is not defined in this particular map.
          It might even give us a list that isn't a keymap.  */
       tem = get_keymap (tem, 0, 0);
-      if (CONSP (tem))
+      /* If the keymap is autoloaded `tem' is not a cons-cell, but we still
+         want to return it.  */
+      if (!NILP (tem))
         {
           /* Convert PREFIX to a vector now, so that later on
              we don't have to deal with the possibility of a string.  */
@@ -2620,8 +2619,8 @@ ascii_sequence_p (seq)
 /* where-is - finding a command in a set of keymaps.                    */
 
 static Lisp_Object where_is_internal ();
-static Lisp_Object where_is_internal_1 ();
-static void where_is_internal_2 ();
+static void where_is_internal_1 P_ ((Lisp_Object key, Lisp_Object binding,
+                                     Lisp_Object args, void *data));
 
 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
    Returns the first non-nil binding found in any of those maps.  */
@@ -2650,6 +2649,12 @@ shadow_lookup (shadow, key, flag)
 
 static Lisp_Object Vmouse_events;
 
+struct where_is_internal_data {
+  Lisp_Object definition, noindirect, this, last;
+  int last_is_meta;
+  Lisp_Object sequences;
+};
+
 /* This function can GC if Flookup_key autoloads any keymaps.  */
 
 static Lisp_Object
@@ -2687,6 +2692,7 @@ where_is_internal (definition, keymaps, firstonly, noindirect, no_remap)
     {
       /* Key sequence to reach map, and the map that it reaches */
       register Lisp_Object this, map, tem;
+      struct where_is_internal_data data;
 
       /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
          [M-CHAR] sequences, check if last character of the sequence
@@ -3059,7 +3065,7 @@ where_is_internal_1 (binding, key, definition, noindirect, this, last,
         || EQ (binding, definition)
         || (CONSP (definition) && !NILP (Fequal (binding, definition)))))
     /* Doesn't match.  */
-    return Qnil;
+    return;
 
   /* We have found a match.  Construct the key sequence where we found it.  */
   if (INTEGERP (key) && last_is_meta)
@@ -3074,10 +3080,9 @@ where_is_internal_1 (binding, key, definition, noindirect, this, last,
     {
       Lisp_Object sequences = Fgethash (binding, where_is_cache, Qnil);
       Fputhash (binding, Fcons (sequence, sequences), where_is_cache);
-      return Qnil;
     }
   else
-    return sequence;
+    d->sequences = Fcons (sequence, d->sequences);
 }
 
 /* describe-bindings - summarizing all the bindings in a set of keymaps.  */
diff --git a/src/keymap.h b/src/keymap.h
index 185ae70d945..df135114c87 100644
--- a/src/keymap.h
+++ b/src/keymap.h
@@ -47,7 +47,7 @@ extern void syms_of_keymap P_ ((void));
 extern void keys_of_keymap P_ ((void));
 
 typedef void (*map_keymap_function_t)
-     P_ ((Lisp_Object, Lisp_Object, Lisp_Object, void*));
+     P_ ((Lisp_Object key, Lisp_Object val, Lisp_Object args, void* data));
 extern void map_keymap P_ ((Lisp_Object map, map_keymap_function_t fun, Lisp_Object largs, void* cargs, int autoload));
 
 #endif
diff --git a/src/lisp.h b/src/lisp.h
index 9f144c4c973..188749b2cfb 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -56,7 +56,7 @@ Boston, MA 02110-1301, USA.  */
 #ifdef GC_CHECK_CONS_LIST
 #define CHECK_CONS_LIST() check_cons_list()
 #else
-#define CHECK_CONS_LIST() 0
+#define CHECK_CONS_LIST() ((void)0)
 #endif
 
 /* These are default choices for the types to use.  */
@@ -3234,6 +3234,7 @@ EXFUN (Fx_file_dialog, 5);
 #endif
 
 /* Defined in xfaces.c */
+EXFUN (Fclear_face_cache, 1);
 extern void syms_of_xfaces P_ ((void));
 
 #ifndef HAVE_GETLOADAVG
@@ -3249,6 +3250,7 @@ extern void syms_of_xfns P_ ((void));
 extern void syms_of_xsmfns P_ ((void));
 
 /* Defined in xselect.c */
+EXFUN (Fx_send_client_event, 6);
 extern void syms_of_xselect P_ ((void));
 
 /* Defined in xterm.c */
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index 40f921961ac..280429b5a71 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -147,7 +147,7 @@ LIBS =  $(TLIB0)	\
         $(TLIB1)        \
         $(TLIBW32)      \
         $(TLASTLIB)     \
-        $(WINMM)    \
+        $(WINMM)        \
         $(ADVAPI32)     \
         $(GDI32)        \
         $(COMDLG32)     \
@@ -155,6 +155,7 @@ LIBS =  $(TLIB0)	\
         $(MPR)          \
         $(SHELL32)      \
         $(WINSPOOL)     \
+        $(OLE32)        \
         $(libc)
 
 #
diff --git a/src/print.c b/src/print.c
index 524207ce298..f4b02868703 100644
--- a/src/print.c
+++ b/src/print.c
@@ -690,7 +690,7 @@ If variable `temp-buffer-show-function' is non-nil, call it at the end
 to get the buffer displayed instead of just displaying the non-selected
 buffer and calling the hook.  It gets one argument, the buffer to display.
 
-usage: (with-output-to-temp-buffer BUFNAME BODY ...)  */)
+usage: (with-output-to-temp-buffer BUFNAME BODY...)  */)
      (args)
      Lisp_Object args;
 {
diff --git a/src/process.c b/src/process.c
index 067eae7f286..5551c0610d0 100644
--- a/src/process.c
+++ b/src/process.c
@@ -121,14 +121,6 @@ Boston, MA 02110-1301, USA.  */
 #include <sys/wait.h>
 #endif
 
-/* Disable IPv6 support for w32 until someone figures out how to do it
-   properly.  */
-#ifdef WINDOWSNT
-# ifdef AF_INET6
-#  undef AF_INET6
-# endif
-#endif
-
 #include "lisp.h"
 #include "systime.h"
 #include "systty.h"
@@ -393,7 +385,7 @@ struct sockaddr_and_len {
   int len;
 } datagram_address[MAXDESC];
 #define DATAGRAM_CHAN_P(chan)   (datagram_address[chan].sa != 0)
-#define DATAGRAM_CONN_P(proc)   (PROCESSP (proc) && datagram_address[XINT (XPROCESS (proc)->infd)].sa != 0)
+#define DATAGRAM_CONN_P(proc)   (PROCESSP (proc) && datagram_address[XPROCESS (proc)->infd].sa != 0)
 #else
 #define DATAGRAM_CHAN_P(chan)   (0)
 #define DATAGRAM_CONN_P(proc)   (0)
@@ -628,19 +620,19 @@ make_process (name)
 
   p = allocate_process ();
 
-  XSETINT (p->infd, -1);
-  XSETINT (p->outfd, -1);
-  XSETFASTINT (p->tick, 0);
-  XSETFASTINT (p->update_tick, 0);
+  p->infd = -1;
+  p->outfd = -1;
+  p->tick = 0;
+  p->update_tick = 0;
   p->pid = 0;
   p->raw_status_new = 0;
   p->status = Qrun;
   p->mark = Fmake_marker ();
 
 #ifdef ADAPTIVE_READ_BUFFERING
-  p->adaptive_read_buffering = Qnil;
-  XSETFASTINT (p->read_output_delay, 0);
-  p->read_output_skip = Qnil;
+  p->adaptive_read_buffering = 0;
+  p->read_output_delay = 0;
+  p->read_output_skip = 0;
 #endif
 
   /* If name is already in use, modify it until it is unused.  */
@@ -679,8 +671,8 @@ setup_process_coding_systems (process)
      Lisp_Object process;
 {
   struct Lisp_Process *p = XPROCESS (process);
-  int inch = XINT (p->infd);
-  int outch = XINT (p->outfd);
+  int inch = p->infd;
+  int outch = p->outfd;
   Lisp_Object coding_system;
 
   if (inch < 0 || outch < 0)
@@ -692,7 +684,7 @@ setup_process_coding_systems (process)
   coding_system = p->decode_coding_system;
   if (! NILP (p->filter))
     {
-      if (NILP (p->filter_multibyte))
+      if (!p->filter_multibyte)
         coding_system = raw_text_coding_system (coding_system);
     }
   else if (BUFFERP (p->buffer))
@@ -814,10 +806,10 @@ nil, indicating the current buffer's process.  */)
   if (NETCONN1_P (p))
     {
       p->status = Fcons (Qexit, Fcons (make_number (0), Qnil));
-      XSETINT (p->tick, ++process_tick);
+      p->tick = ++process_tick;
       status_notify (p);
     }
-  else if (XINT (p->infd) >= 0)
+  else if (p->infd >= 0)
     {
 #ifdef SIGCHLD
       Lisp_Object symbol;
@@ -845,7 +837,7 @@ nil, indicating the current buffer's process.  */)
           /* Do this now, since remove_process will make sigchld_handler do nothing.  */
           p->status
             = Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil));
-          XSETINT (p->tick, ++process_tick);
+          p->tick = ++process_tick;
           status_notify (p);
         }
     }
@@ -1037,18 +1029,18 @@ The string argument is normally a multibyte string, except:
      (debug)
      (set-process-filter process ...)  */
 
-  if (XINT (p->infd) >= 0)
+  if (p->infd >= 0)
     {
       if (EQ (filter, Qt) && !EQ (p->status, Qlisten))
         {
-          FD_CLR (XINT (p->infd), &input_wait_mask);
-          FD_CLR (XINT (p->infd), &non_keyboard_wait_mask);
+          FD_CLR (p->infd, &input_wait_mask);
+          FD_CLR (p->infd, &non_keyboard_wait_mask);
         }
       else if (EQ (p->filter, Qt)
                && !EQ (p->command, Qt)) /* Network process not stopped. */
         {
-          FD_SET (XINT (p->infd), &input_wait_mask);
-          FD_SET (XINT (p->infd), &non_keyboard_wait_mask);
+          FD_SET (p->infd, &input_wait_mask);
+          FD_SET (p->infd, &non_keyboard_wait_mask);
         }
     }
 
@@ -1110,8 +1102,8 @@ DEFUN ("set-process-window-size", Fset_process_window_size,
   CHECK_NATNUM (height);
   CHECK_NATNUM (width);
 
-  if (XINT (XPROCESS (process)->infd) < 0
-      || set_window_size (XINT (XPROCESS (process)->infd),
+  if (XPROCESS (process)->infd < 0
+      || set_window_size (XPROCESS (process)->infd,
                           XINT (height), XINT (width)) <= 0)
     return Qnil;
   else
@@ -1139,7 +1131,7 @@ for the process which will run.  */)
      register Lisp_Object process, flag;
 {
   CHECK_PROCESS (process);
-  XPROCESS (process)->inherit_coding_system_flag = flag;
+  XPROCESS (process)->inherit_coding_system_flag = !NILP (flag);
   return flag;
 }
 
@@ -1154,7 +1146,7 @@ the process output.  */)
      register Lisp_Object process;
 {
   CHECK_PROCESS (process);
-  return XPROCESS (process)->inherit_coding_system_flag;
+  return XPROCESS (process)->inherit_coding_system_flag ? Qt : Qnil;
 }
 
 DEFUN ("set-process-query-on-exit-flag",
@@ -1167,7 +1159,7 @@ exiting if PROCESS is running.  */)
      register Lisp_Object process, flag;
 {
   CHECK_PROCESS (process);
-  XPROCESS (process)->kill_without_query = Fnull (flag);
+  XPROCESS (process)->kill_without_query = NILP (flag);
   return flag;
 }
 
@@ -1179,7 +1171,7 @@ DEFUN ("process-query-on-exit-flag",
      register Lisp_Object process;
 {
   CHECK_PROCESS (process);
-  return Fnull (XPROCESS (process)->kill_without_query);
+  return (XPROCESS (process)->kill_without_query ? Qnil : Qt);
 }
 
 #ifdef DATAGRAM_SOCKETS
@@ -1354,7 +1346,7 @@ list_processes_1 (query_only)
       p = XPROCESS (proc);
       if (NILP (p->childp))
         continue;
-      if (!NILP (query_only) && !NILP (p->kill_without_query))
+      if (!NILP (query_only) && p->kill_without_query)
         continue;
       if (STRINGP (p->name)
           && ( i = SCHARS (p->name), (i > w_proc)))
@@ -1417,7 +1409,7 @@ list_processes_1 (query_only)
       p = XPROCESS (proc);
       if (NILP (p->childp))
         continue;
-      if (!NILP (query_only) && !NILP (p->kill_without_query))
+      if (!NILP (query_only) && p->kill_without_query)
         continue;
 
       Finsert (1, &p->name);
@@ -1493,7 +1485,7 @@ list_processes_1 (query_only)
           if (NILP (port))
             port = Fformat_network_address (Fplist_get (p->childp, QClocal), Qnil);
           sprintf (tembuf, "(network %s server on %s)\n",
-                   (DATAGRAM_CHAN_P (XINT (p->infd)) ? "datagram" : "stream"),
+                   (DATAGRAM_CHAN_P (p->infd) ? "datagram" : "stream"),
                    (STRINGP (port) ? (char *)SDATA (port) : "?"));
           insert_string (tembuf);
         }
@@ -1511,7 +1503,7 @@ list_processes_1 (query_only)
           if (NILP (host))
             host = Fformat_network_address (Fplist_get (p->childp, QCremote), Qnil);
           sprintf (tembuf, "(network %s connection to %s)\n",
-                   (DATAGRAM_CHAN_P (XINT (p->infd)) ? "datagram" : "stream"),
+                   (DATAGRAM_CHAN_P (p->infd) ? "datagram" : "stream"),
                    (STRINGP (host) ? (char *)SDATA (host) : "?"));
           insert_string (tembuf);
         }
@@ -1642,11 +1634,13 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
   XPROCESS (proc)->sentinel = Qnil;
   XPROCESS (proc)->filter = Qnil;
   XPROCESS (proc)->filter_multibyte
-    = buffer_defaults.enable_multibyte_characters;
+    = !NILP (buffer_defaults.enable_multibyte_characters);
   XPROCESS (proc)->command = Flist (nargs - 2, args + 2);
 
 #ifdef ADAPTIVE_READ_BUFFERING
-  XPROCESS (proc)->adaptive_read_buffering = Vprocess_adaptive_read_buffering;
+  XPROCESS (proc)->adaptive_read_buffering
+    = (NILP (Vprocess_adaptive_read_buffering) ? 0
+       : EQ (Vprocess_adaptive_read_buffering, Qt) ? 1 : 2);
 #endif
 
   /* Make the process marker point into the process buffer (if any).  */
@@ -1777,13 +1771,11 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
 #endif /* not VMS */
 
   XPROCESS (proc)->decoding_buf = make_uninit_string (0);
-  XPROCESS (proc)->decoding_carryover = make_number (0);
+  XPROCESS (proc)->decoding_carryover = 0;
   XPROCESS (proc)->encoding_buf = make_uninit_string (0);
-  XPROCESS (proc)->encoding_carryover = make_number (0);
 
   XPROCESS (proc)->inherit_coding_system_flag
-    = (NILP (buffer) || !inherit_process_coding_system
-       ? Qnil : Qt);
+    = (NILP (buffer) || !inherit_process_coding_system);
 
   create_process (proc, (char **) new_argv, current_dir);
 
@@ -1955,15 +1947,15 @@ create_process (process, new_argv, current_dir)
   /* Record this as an active process, with its channels.
      As a result, child_setup will close Emacs's side of the pipes.  */
   chan_process[inchannel] = process;
-  XSETINT (XPROCESS (process)->infd, inchannel);
-  XSETINT (XPROCESS (process)->outfd, outchannel);
+  XPROCESS (process)->infd = inchannel;
+  XPROCESS (process)->outfd = outchannel;
 
   /* Previously we recorded the tty descriptor used in the subprocess.
      It was only used for getting the foreground tty process, so now
      we just reopen the device (see emacs_get_tty_pgrp) as this is
      more portable (see USG_SUBTTY_WORKS above).  */
 
-  XPROCESS (process)->pty_flag = (pty_flag ? Qt : Qnil);
+  XPROCESS (process)->pty_flag = pty_flag;
   XPROCESS (process)->status = Qrun;
   setup_process_coding_systems (process);
 
@@ -2480,7 +2472,7 @@ DEFUN ("process-datagram-address", Fprocess_datagram_address, Sprocess_datagram_
   if (!DATAGRAM_CONN_P (process))
     return Qnil;
 
-  channel = XINT (XPROCESS (process)->infd);
+  channel = XPROCESS (process)->infd;
   return conv_sockaddr_to_lisp (datagram_address[channel].sa,
                                 datagram_address[channel].len);
 }
@@ -2500,7 +2492,7 @@ Returns nil upon error setting address, ADDRESS otherwise.  */)
   if (!DATAGRAM_CONN_P (process))
     return Qnil;
 
-  channel = XINT (XPROCESS (process)->infd);
+  channel = XPROCESS (process)->infd;
 
   len = get_lisp_to_sockaddr_size (address, &family);
   if (datagram_address[channel].len != len)
@@ -2665,7 +2657,7 @@ OPTION is not a supported option, return nil instead; otherwise return t.  */)
   if (!NETCONN1_P (p))
     error ("Process is not a network process");
 
-  s = XINT (p->infd);
+  s = p->infd;
   if (s < 0)
     error ("Process is not running");
 
@@ -3419,18 +3411,18 @@ usage: (make-network-process &rest ARGS)  */)
   p->buffer = buffer;
   p->sentinel = sentinel;
   p->filter = filter;
-  p->filter_multibyte = buffer_defaults.enable_multibyte_characters;
+  p->filter_multibyte = !NILP (buffer_defaults.enable_multibyte_characters);
   /* Override the above only if :filter-multibyte is specified.  */
   if (! NILP (Fplist_member (contact, QCfilter_multibyte)))
-    p->filter_multibyte = Fplist_get (contact, QCfilter_multibyte);
+    p->filter_multibyte = !NILP (Fplist_get (contact, QCfilter_multibyte));
   p->log = Fplist_get (contact, QClog);
   if (tem = Fplist_get (contact, QCnoquery), !NILP (tem))
-    p->kill_without_query = Qt;
+    p->kill_without_query = 1;
   if ((tem = Fplist_get (contact, QCstop), !NILP (tem)))
     p->command = Qt;
   p->pid = 0;
-  XSETINT (p->infd, inch);
-  XSETINT (p->outfd, outch);
+  p->infd  = inch;
+  p->outfd = outch;
   if (is_server && socktype == SOCK_STREAM)
     p->status = Qlisten;
 
@@ -3551,13 +3543,11 @@ usage: (make-network-process &rest ARGS)  */)
   setup_process_coding_systems (proc);
 
   p->decoding_buf = make_uninit_string (0);
-  p->decoding_carryover = make_number (0);
+  p->decoding_carryover = 0;
   p->encoding_buf = make_uninit_string (0);
-  p->encoding_carryover = make_number (0);
 
   p->inherit_coding_system_flag
-    = (!NILP (tem) || NILP (buffer) || !inherit_process_coding_system
-       ? Qnil : Qt);
+    = (!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
 
   UNGCPRO;
   return proc;
@@ -3820,16 +3810,16 @@ deactivate_process (proc)
   register int inchannel, outchannel;
   register struct Lisp_Process *p = XPROCESS (proc);
 
-  inchannel = XINT (p->infd);
-  outchannel = XINT (p->outfd);
+  inchannel  = p->infd;
+  outchannel = p->outfd;
 
 #ifdef ADAPTIVE_READ_BUFFERING
-  if (XINT (p->read_output_delay) > 0)
+  if (p->read_output_delay > 0)
     {
       if (--process_output_delay_count < 0)
         process_output_delay_count = 0;
-      XSETINT (p->read_output_delay, 0);
-      p->read_output_skip = Qnil;
+      p->read_output_delay = 0;
+      p->read_output_skip = 0;
     }
 #endif
 
@@ -3851,8 +3841,8 @@ deactivate_process (proc)
         emacs_close (outchannel);
 #endif
 
-      XSETINT (p->infd, -1);
-      XSETINT (p->outfd, -1);
+      p->infd  = -1;
+      p->outfd = -1;
 #ifdef DATAGRAM_SOCKETS
       if (DATAGRAM_CHAN_P (inchannel))
         {
@@ -3900,8 +3890,8 @@ close_process_descs ()
       process = chan_process[i];
       if (!NILP (process))
         {
-          int in = XINT (XPROCESS (process)->infd);
-          int out = XINT (XPROCESS (process)->outfd);
+          int in  = XPROCESS (process)->infd;
+          int out = XPROCESS (process)->outfd;
           if (in >= 0)
             emacs_close (in);
           if (out >= 0 && in != out)
@@ -4145,8 +4135,8 @@ server_accept_connection (server, channel)
   p->filter = ps->filter;
   p->command = Qnil;
   p->pid = 0;
-  XSETINT (p->infd, s);
-  XSETINT (p->outfd, s);
+  p->infd  = s;
+  p->outfd = s;
   p->status = Qrun;
 
   /* Client processes for accepted connections are not stopped initially.  */
@@ -4169,12 +4159,11 @@ server_accept_connection (server, channel)
   setup_process_coding_systems (proc);
 
   p->decoding_buf = make_uninit_string (0);
-  p->decoding_carryover = make_number (0);
+  p->decoding_carryover = 0;
   p->encoding_buf = make_uninit_string (0);
-  p->encoding_carryover = make_number (0);
 
   p->inherit_coding_system_flag
-    = (NILP (buffer) ? Qnil : ps->inherit_coding_system_flag);
+    = (NILP (buffer) ? 0 : ps->inherit_coding_system_flag);
 
   if (!NILP (ps->log))
       call3 (ps->log, server, proc,
@@ -4299,7 +4288,7 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
 
   /* If wait_proc is a process to watch, set wait_channel accordingly.  */
   if (wait_proc != NULL)
-    wait_channel = XINT (wait_proc->infd);
+    wait_channel = wait_proc->infd;
 
   record_unwind_protect (wait_reading_process_output_unwind,
                          make_number (waiting_for_user_input_p));
@@ -4484,9 +4473,9 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
           XSETPROCESS (proc, wait_proc);
 
           /* Read data from the process, until we exhaust it.  */
-          while (XINT (wait_proc->infd) >= 0)
+          while (wait_proc->infd >= 0)
             {
-              nread = read_process_output (proc, XINT (wait_proc->infd));
+              nread = read_process_output (proc, wait_proc->infd);
 
               if (nread == 0)
                 break;
@@ -4516,9 +4505,9 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
 
       if (wait_proc && just_wait_proc)
         {
-          if (XINT (wait_proc->infd) < 0)  /* Terminated */
+          if (wait_proc->infd < 0)  /* Terminated */
             break;
-          FD_SET (XINT (wait_proc->infd), &Available);
+          FD_SET (wait_proc->infd, &Available);
           check_delay = 0;
           IF_NON_BLOCKING_CONNECT (check_connect = 0);
         }
@@ -4566,7 +4555,7 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
 
 #ifdef ADAPTIVE_READ_BUFFERING
           /* Set the timeout for adaptive read buffering if any
-             process has non-nil read_output_skip and non-zero
+             process has non-zero read_output_skip and non-zero
              read_output_delay, and we are not reading output for a
              specific wait_channel.  It is not executed if
              Vprocess_adaptive_read_buffering is nil.  */
@@ -4581,16 +4570,16 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
                   if (NILP (proc))
                     continue;
                   /* Find minimum non-zero read_output_delay among the
-                     processes with non-nil read_output_skip.  */
-                  if (XINT (XPROCESS (proc)->read_output_delay) > 0)
+                     processes with non-zero read_output_skip.  */
+                  if (XPROCESS (proc)->read_output_delay > 0)
                     {
                       check_delay--;
-                      if (NILP (XPROCESS (proc)->read_output_skip))
+                      if (!XPROCESS (proc)->read_output_skip)
                         continue;
                       FD_CLR (channel, &Available);
-                      XPROCESS (proc)->read_output_skip = Qnil;
-                      if (XINT (XPROCESS (proc)->read_output_delay) < usecs)
-                        usecs = XINT (XPROCESS (proc)->read_output_delay);
+                      XPROCESS (proc)->read_output_skip = 0;
+                      if (XPROCESS (proc)->read_output_delay < usecs)
+                        usecs = XPROCESS (proc)->read_output_delay;
                     }
                 }
               EMACS_SET_SECS_USECS (timeout, 0, usecs);
@@ -4863,7 +4852,7 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
               else
                 {
                   /* Preserve status of processes already terminated.  */
-                  XSETINT (XPROCESS (proc)->tick, ++process_tick);
+                  XPROCESS (proc)->tick = ++process_tick;
                   deactivate_process (proc);
                   if (XPROCESS (proc)->raw_status_new)
                     update_status (XPROCESS (proc));
@@ -4915,7 +4904,7 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
 #endif
               if (xerrno)
                 {
-                  XSETINT (p->tick, ++process_tick);
+                  p->tick = ++process_tick;
                   p->status = Fcons (Qfailed, Fcons (make_number (xerrno), Qnil));
                   deactivate_process (proc);
                 }
@@ -4928,8 +4917,8 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
                   exec_sentinel (proc, build_string ("open\n"));
                   if (!EQ (p->filter, Qt) && !EQ (p->command, Qt))
                     {
-                      FD_SET (XINT (p->infd), &input_wait_mask);
-                      FD_SET (XINT (p->infd), &non_keyboard_wait_mask);
+                      FD_SET (p->infd, &input_wait_mask);
+                      FD_SET (p->infd, &non_keyboard_wait_mask);
                     }
                 }
             }
@@ -5003,7 +4992,7 @@ read_process_output (proc, channel)
   register struct Lisp_Process *p = XPROCESS (proc);
   register int opoint;
   struct coding_system *coding = proc_decode_coding_system[channel];
-  int carryover = XINT (p->decoding_carryover);
+  int carryover = p->decoding_carryover;
   int readmax = 4096;
 
 #ifdef VMS
@@ -5056,9 +5045,9 @@ read_process_output (proc, channel)
     {
       nbytes = emacs_read (channel, chars + carryover, readmax);
 #ifdef ADAPTIVE_READ_BUFFERING
-      if (nbytes > 0 && !NILP (p->adaptive_read_buffering))
+      if (nbytes > 0 && p->adaptive_read_buffering)
         {
-          int delay = XINT (p->read_output_delay);
+          int delay = p->read_output_delay;
           if (nbytes < 256)
             {
               if (delay < READ_OUTPUT_DELAY_MAX_MAX)
@@ -5074,10 +5063,10 @@ read_process_output (proc, channel)
               if (delay == 0)
                 process_output_delay_count--;
             }
-          XSETINT (p->read_output_delay, delay);
+          p->read_output_delay = delay;
           if (delay)
             {
-              p->read_output_skip = Qt;
+              p->read_output_skip = 1;
               process_output_skip = 1;
             }
         }
@@ -5095,7 +5084,7 @@ read_process_output (proc, channel)
     }
 #endif /* not VMS */
 
-  XSETINT (p->decoding_carryover, 0);
+  p->decoding_carryover = 0;
 
   /* At this point, NBYTES holds number of bytes just received
      (including the one in proc_buffered_char[channel]).  */
@@ -5169,12 +5158,12 @@ read_process_output (proc, channel)
              valid memory because p->outfd will be changed once EOF is
              sent to the process.  */
           if (NILP (p->encode_coding_system)
-              && proc_encode_coding_system[XINT (p->outfd)])
+              && proc_encode_coding_system[p->outfd])
             {
               p->encode_coding_system
                 = coding_inherit_eol_type (Vlast_coding_system_used, Qnil);
               setup_coding_system (p->encode_coding_system,
-                                   proc_encode_coding_system[XINT (p->outfd)]);
+                                   proc_encode_coding_system[p->outfd]);
             }
         }
 
@@ -5184,10 +5173,10 @@ read_process_output (proc, channel)
             p->decoding_buf = make_uninit_string (coding->carryover_bytes);
           bcopy (coding->carryover, SDATA (p->decoding_buf),
                  coding->carryover_bytes);
-          XSETINT (p->decoding_carryover, coding->carryover_bytes);
+          p->decoding_carryover = coding->carryover_bytes;
         }
       /* Adjust the multibyteness of TEXT to that of the filter.  */
-      if (NILP (p->filter_multibyte) != ! STRING_MULTIBYTE (text))
+      if (p->filter_multibyte != STRING_MULTIBYTE (text))
         text = (STRING_MULTIBYTE (text)
                 ? Fstring_as_unibyte (text)
                 : Fstring_to_multibyte (text));
@@ -5279,12 +5268,12 @@ read_process_output (proc, channel)
         {
           p->decode_coding_system = Vlast_coding_system_used;
           if (NILP (p->encode_coding_system)
-              && proc_encode_coding_system[XINT (p->outfd)])
+              && proc_encode_coding_system[p->outfd])
             {
               p->encode_coding_system
                 = coding_inherit_eol_type (Vlast_coding_system_used, Qnil);
               setup_coding_system (p->encode_coding_system,
-                                   proc_encode_coding_system[XINT (p->outfd)]);
+                                   proc_encode_coding_system[p->outfd]);
             }
         }
       if (coding->carryover_bytes > 0)
@@ -5293,7 +5282,7 @@ read_process_output (proc, channel)
             p->decoding_buf = make_uninit_string (coding->carryover_bytes);
           bcopy (coding->carryover, SDATA (p->decoding_buf),
                  coding->carryover_bytes);
-          XSETINT (p->decoding_carryover, coding->carryover_bytes);
+          p->decoding_carryover = coding->carryover_bytes;
         }
       /* Adjust the multibyteness of TEXT to that of the buffer.  */
       if (NILP (current_buffer->enable_multibyte_characters)
@@ -5412,10 +5401,10 @@ send_process (proc, buf, len, object)
     update_status (p);
   if (! EQ (p->status, Qrun))
     error ("Process %s not running", SDATA (p->name));
-  if (XINT (p->outfd) < 0)
+  if (p->outfd < 0)
     error ("Output file descriptor of %s is closed", SDATA (p->name));
 
-  coding = proc_encode_coding_system[XINT (p->outfd)];
+  coding = proc_encode_coding_system[p->outfd];
   Vlast_coding_system_used = CODING_ID_NAME (coding->id);
 
   if ((STRINGP (object) && STRING_MULTIBYTE (object))
@@ -5499,7 +5488,7 @@ send_process (proc, buf, len, object)
   if (pty_max_bytes == 0)
     {
 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
-      pty_max_bytes = fpathconf (XFASTINT (p->outfd), _PC_MAX_CANON);
+      pty_max_bytes = fpathconf (p->outfd, _PC_MAX_CANON);
       if (pty_max_bytes < 0)
         pty_max_bytes = 250;
 #else
@@ -5521,7 +5510,7 @@ send_process (proc, buf, len, object)
 
           /* Decide how much data we can send in one batch.
              Long lines need to be split into multiple batches.  */
-          if (!NILP (p->pty_flag))
+          if (p->pty_flag)
             {
               /* Starting this at zero is always correct when not the first
                  iteration because the previous iteration ended by sending C-d.
@@ -5550,7 +5539,7 @@ send_process (proc, buf, len, object)
           /* Send this batch, using one or more write calls.  */
           while (this > 0)
             {
-              int outfd = XINT (p->outfd);
+              int outfd = p->outfd;
               old_sigpipe = (SIGTYPE (*) ()) signal (SIGPIPE, send_process_trap);
 #ifdef DATAGRAM_SOCKETS
               if (DATAGRAM_CHAN_P (outfd))
@@ -5570,12 +5559,12 @@ send_process (proc, buf, len, object)
                 {
                   rv = emacs_write (outfd, (char *) buf, this);
 #ifdef ADAPTIVE_READ_BUFFERING
-                  if (XINT (p->read_output_delay) > 0
-                      && EQ (p->adaptive_read_buffering, Qt))
+                  if (p->read_output_delay > 0
+                      && p->adaptive_read_buffering == 1)
                     {
-                      XSETFASTINT (p->read_output_delay, 0);
+                      p->read_output_delay = 0;
                       process_output_delay_count--;
-                      p->read_output_skip = Qnil;
+                      p->read_output_skip = 0;
                     }
 #endif
                 }
@@ -5618,7 +5607,7 @@ send_process (proc, buf, len, object)
                       if (errno == EAGAIN)
                         {
                           int flags = FWRITE;
-                          ioctl (XINT (p->outfd), TIOCFLUSH, &flags);
+                          ioctl (p->outfd, TIOCFLUSH, &flags);
                         }
 #endif /* BROKEN_PTY_READ_AFTER_EAGAIN */
 
@@ -5667,7 +5656,7 @@ send_process (proc, buf, len, object)
 #endif
       p->raw_status_new = 0;
       p->status = Fcons (Qexit, Fcons (make_number (256), Qnil));
-      XSETINT (p->tick, ++process_tick);
+      p->tick = ++process_tick;
       deactivate_process (proc);
 #ifdef VMS
       error ("Error writing to process %s; closed it", SDATA (p->name));
@@ -5736,7 +5725,7 @@ emacs_get_tty_pgrp (p)
   int gid = -1;
 
 #ifdef TIOCGPGRP
-  if (ioctl (XINT (p->infd), TIOCGPGRP, &gid) == -1 && ! NILP (p->tty_name))
+  if (ioctl (p->infd, TIOCGPGRP, &gid) == -1 && ! NILP (p->tty_name))
     {
       int fd;
       /* Some OS:es (Solaris 8/9) does not allow TIOCGPGRP from the
@@ -5774,7 +5763,7 @@ return t unconditionally.  */)
   if (!EQ (p->childp, Qt))
     error ("Process %s is not a subprocess",
            SDATA (p->name));
-  if (XINT (p->infd) < 0)
+  if (p->infd < 0)
     error ("Process %s is not active",
            SDATA (p->name));
 
@@ -5817,11 +5806,11 @@ process_send_signal (process, signo, current_group, nomsg)
   if (!EQ (p->childp, Qt))
     error ("Process %s is not a subprocess",
            SDATA (p->name));
-  if (XINT (p->infd) < 0)
+  if (p->infd < 0)
     error ("Process %s is not active",
            SDATA (p->name));
 
-  if (NILP (p->pty_flag))
+  if (!p->pty_flag)
     current_group = Qnil;
 
   /* If we are using pgrps, get a pgrp number and make it negative.  */
@@ -5840,7 +5829,7 @@ process_send_signal (process, signo, current_group, nomsg)
       struct termios t;
       cc_t *sig_char = NULL;
 
-      tcgetattr (XINT (p->infd), &t);
+      tcgetattr (p->infd, &t);
 
       switch (signo)
         {
@@ -5880,16 +5869,16 @@ process_send_signal (process, signo, current_group, nomsg)
       switch (signo)
         {
         case SIGINT:
-          ioctl (XINT (p->infd), TIOCGETC, &c);
+          ioctl (p->infd, TIOCGETC, &c);
           send_process (proc, &c.t_intrc, 1, Qnil);
           return;
         case SIGQUIT:
-          ioctl (XINT (p->infd), TIOCGETC, &c);
+          ioctl (p->infd, TIOCGETC, &c);
           send_process (proc, &c.t_quitc, 1, Qnil);
           return;
 #ifdef SIGTSTP
         case SIGTSTP:
-          ioctl (XINT (p->infd), TIOCGLTC, &lc);
+          ioctl (p->infd, TIOCGLTC, &lc);
           send_process (proc, &lc.t_suspc, 1, Qnil);
           return;
 #endif /* ! defined (SIGTSTP) */
@@ -5904,16 +5893,16 @@ process_send_signal (process, signo, current_group, nomsg)
       switch (signo)
         {
         case SIGINT:
-          ioctl (XINT (p->infd), TCGETA, &t);
+          ioctl (p->infd, TCGETA, &t);
           send_process (proc, &t.c_cc[VINTR], 1, Qnil);
           return;
         case SIGQUIT:
-          ioctl (XINT (p->infd), TCGETA, &t);
+          ioctl (p->infd, TCGETA, &t);
           send_process (proc, &t.c_cc[VQUIT], 1, Qnil);
           return;
 #ifdef SIGTSTP
         case SIGTSTP:
-          ioctl (XINT (p->infd), TCGETA, &t);
+          ioctl (p->infd, TCGETA, &t);
           send_process (proc, &t.c_cc[VSWTCH], 1, Qnil);
           return;
 #endif /* ! defined (SIGTSTP) */
@@ -5971,7 +5960,7 @@ process_send_signal (process, signo, current_group, nomsg)
     case SIGCONT:
       p->raw_status_new = 0;
       p->status = Qrun;
-      XSETINT (p->tick, ++process_tick);
+      p->tick = ++process_tick;
       if (!nomsg)
         status_notify (NULL);
       break;
@@ -5991,7 +5980,7 @@ process_send_signal (process, signo, current_group, nomsg)
       sys$forcex (&(p->pid), 0, 1);
       whoosh:
 #endif
-      flush_pending_output (XINT (p->infd));
+      flush_pending_output (p->infd);
       break;
     }
 
@@ -6008,7 +5997,7 @@ process_send_signal (process, signo, current_group, nomsg)
 #ifdef TIOCSIGSEND
   if (!NILP (current_group))
     {
-      if (ioctl (XINT (p->infd), TIOCSIGSEND, signo) == -1)
+      if (ioctl (p->infd, TIOCSIGSEND, signo) == -1)
         EMACS_KILLPG (gid, signo);
     }
   else
@@ -6074,10 +6063,10 @@ If PROCESS is a network process, inhibit handling of incoming traffic.  */)
 
       p = XPROCESS (process);
       if (NILP (p->command)
-          && XINT (p->infd) >= 0)
+          && p->infd >= 0)
         {
-          FD_CLR (XINT (p->infd), &input_wait_mask);
-          FD_CLR (XINT (p->infd), &non_keyboard_wait_mask);
+          FD_CLR (p->infd, &input_wait_mask);
+          FD_CLR (p->infd, &non_keyboard_wait_mask);
         }
       p->command = Qt;
       return process;
@@ -6105,11 +6094,11 @@ If PROCESS is a network process, resume handling of incoming traffic.  */)
 
       p = XPROCESS (process);
       if (EQ (p->command, Qt)
-          && XINT (p->infd) >= 0
+          && p->infd >= 0
           && (!EQ (p->filter, Qt) || EQ (p->status, Qlisten)))
         {
-          FD_SET (XINT (p->infd), &input_wait_mask);
-          FD_SET (XINT (p->infd), &non_keyboard_wait_mask);
+          FD_SET (p->infd, &input_wait_mask);
+          FD_SET (p->infd, &non_keyboard_wait_mask);
         }
       p->command = Qnil;
       return process;
@@ -6306,7 +6295,7 @@ text to PROCESS after you call this function.  */)
     return process;
 
   proc = get_process (process);
-  coding = proc_encode_coding_system[XINT (XPROCESS (proc)->outfd)];
+  coding = proc_encode_coding_system[XPROCESS (proc)->outfd];
 
   /* Make sure the process is really alive.  */
   if (XPROCESS (proc)->raw_status_new)
@@ -6323,7 +6312,7 @@ text to PROCESS after you call this function.  */)
 #ifdef VMS
   send_process (proc, "\032", 1, Qnil);         /* ^z */
 #else
-  if (!NILP (XPROCESS (proc)->pty_flag))
+  if (XPROCESS (proc)->pty_flag)
     send_process (proc, "\004", 1, Qnil);
   else
     {
@@ -6335,18 +6324,18 @@ text to PROCESS after you call this function.  */)
          (In some old system, shutdown to socketpair doesn't work.
          Then we just can't win.)  */
       if (XPROCESS (proc)->pid == 0
-          || XINT (XPROCESS (proc)->outfd) == XINT (XPROCESS (proc)->infd))
-        shutdown (XINT (XPROCESS (proc)->outfd), 1);
+          || XPROCESS (proc)->outfd == XPROCESS (proc)->infd)
+        shutdown (XPROCESS (proc)->outfd, 1);
       /* In case of socketpair, outfd == infd, so don't close it.  */
-      if (XINT (XPROCESS (proc)->outfd) != XINT (XPROCESS (proc)->infd))
-        emacs_close (XINT (XPROCESS (proc)->outfd));
+      if (XPROCESS (proc)->outfd != XPROCESS (proc)->infd)
+        emacs_close (XPROCESS (proc)->outfd);
 #else /* not HAVE_SHUTDOWN */
-      emacs_close (XINT (XPROCESS (proc)->outfd));
+      emacs_close (XPROCESS (proc)->outfd);
 #endif /* not HAVE_SHUTDOWN */
       new_outfd = emacs_open (NULL_DEVICE, O_WRONLY, 0);
       if (new_outfd < 0)
         abort ();
-      old_outfd = XINT (XPROCESS (proc)->outfd);
+      old_outfd = XPROCESS (proc)->outfd;
 
       if (!proc_encode_coding_system[new_outfd])
         proc_encode_coding_system[new_outfd]
@@ -6357,7 +6346,7 @@ text to PROCESS after you call this function.  */)
       bzero (proc_encode_coding_system[old_outfd],
              sizeof (struct coding_system));
 
-      XSETINT (XPROCESS (proc)->outfd, new_outfd);
+      XPROCESS (proc)->outfd = new_outfd;
     }
 #endif /* VMS */
   return process;
@@ -6380,7 +6369,7 @@ kill_buffer_processes (buffer)
         {
           if (NETCONN_P (proc))
             Fdelete_process (proc);
-          else if (XINT (XPROCESS (proc)->infd) >= 0)
+          else if (XPROCESS (proc)->infd >= 0)
             process_send_signal (proc, SIGHUP, Qnil, 1);
         }
     }
@@ -6510,21 +6499,21 @@ sigchld_handler (signo)
           union { int i; WAITTYPE wt; } u;
           int clear_desc_flag = 0;
 
-          XSETINT (p->tick, ++process_tick);
+          p->tick = ++process_tick;
           u.wt = w;
           p->raw_status = u.i;
           p->raw_status_new = 1;
 
           /* If process has terminated, stop waiting for its output.  */
           if ((WIFSIGNALED (w) || WIFEXITED (w))
-              && XINT (p->infd) >= 0)
+              && p->infd >= 0)
             clear_desc_flag = 1;
 
           /* We use clear_desc_flag to avoid a compiler bug in Microsoft C.  */
           if (clear_desc_flag)
             {
-              FD_CLR (XINT (p->infd), &input_wait_mask);
-              FD_CLR (XINT (p->infd), &non_keyboard_wait_mask);
+              FD_CLR (p->infd, &input_wait_mask);
+              FD_CLR (p->infd, &non_keyboard_wait_mask);
             }
 
           /* Tell wait_reading_process_output that it needs to wake up and
@@ -6701,18 +6690,18 @@ status_notify (deleting_process)
       proc = Fcdr (Fcar (tail));
       p = XPROCESS (proc);
 
-      if (XINT (p->tick) != XINT (p->update_tick))
+      if (p->tick != p->update_tick)
         {
-          XSETINT (p->update_tick, XINT (p->tick));
+          p->update_tick = p->tick;
 
           /* If process is still active, read any output that remains.  */
           while (! EQ (p->filter, Qt)
                  && ! EQ (p->status, Qconnect)
                  && ! EQ (p->status, Qlisten)
                  && ! EQ (p->command, Qt)  /* Network process not stopped.  */
-                 && XINT (p->infd) >= 0
+                 && p->infd >= 0
                  && p != deleting_process
-                 && read_process_output (proc, XINT (p->infd)) > 0);
+                 && read_process_output (proc, p->infd) > 0);
 
           buffer = p->buffer;
 
@@ -6739,7 +6728,7 @@ status_notify (deleting_process)
              So set p->update_tick again
              so that an error in the sentinel will not cause
              this code to be run again.  */
-          XSETINT (p->update_tick, XINT (p->tick));
+          p->update_tick = p->tick;
           /* Now output the message suitably.  */
           if (!NILP (p->sentinel))
             exec_sentinel (proc, msg);
@@ -6812,9 +6801,9 @@ encode subprocess input.  */)
 
   CHECK_PROCESS (process);
   p = XPROCESS (process);
-  if (XINT (p->infd) < 0)
+  if (p->infd < 0)
     error ("Input file descriptor of %s closed", SDATA (p->name));
-  if (XINT (p->outfd) < 0)
+  if (p->outfd < 0)
     error ("Output file descriptor of %s closed", SDATA (p->name));
   Fcheck_coding_system (decoding);
   Fcheck_coding_system (encoding);
@@ -6851,7 +6840,7 @@ suppressed.  */)
 
   CHECK_PROCESS (process);
   p = XPROCESS (process);
-  p->filter_multibyte = flag;
+  p->filter_multibyte = !NILP (flag);
   setup_process_coding_systems (process);
 
   return Qnil;
@@ -6868,7 +6857,7 @@ DEFUN ("process-filter-multibyte-p", Fprocess_filter_multibyte_p,
   CHECK_PROCESS (process);
   p = XPROCESS (process);
 
-  return (NILP (p->filter_multibyte) ? Qnil : Qt);
+  return (p->filter_multibyte ? Qt : Qnil);
 }
 
 
diff --git a/src/process.h b/src/process.h
index 718d2a70ea8..fd7847b5e29 100644
--- a/src/process.h
+++ b/src/process.h
@@ -36,10 +36,6 @@ struct Lisp_Process
   {
     EMACS_INT size;
     struct Lisp_Vector *v_next;
-    /* Descriptor by which we read from this process */
-    Lisp_Object infd;
-    /* Descriptor by which we write to this process */
-    Lisp_Object outfd;
     /* Name of subprocess terminal.  */
     Lisp_Object tty_name;
     /* Name of this process */
@@ -64,61 +60,65 @@ struct Lisp_Process
     Lisp_Object plist;
     /* Marker set to end of last buffer-inserted output from this process */
     Lisp_Object mark;
-    /* Non-nil means kill silently if Emacs is exited.
-       This is the inverse of the `query-on-exit' flag.  */
-    Lisp_Object kill_without_query;
     /* Symbol indicating status of process.
        This may be a symbol: run, open, or closed.
        Or it may be a list, whose car is stop, exit or signal
        and whose cdr is a pair (EXIT_CODE . COREDUMP_FLAG)
        or (SIGNAL_NUMBER . COREDUMP_FLAG).  */
     Lisp_Object status;
-    /* Non-nil if communicating through a pty.  */
-    Lisp_Object pty_flag;
-    /* Event-count of last event in which this process changed status.  */
-    Lisp_Object tick;
-    /* Event-count of last such event reported.  */
-    Lisp_Object update_tick;
     /* Coding-system for decoding the input from this process.  */
     Lisp_Object decode_coding_system;
     /* Working buffer for decoding.  */
     Lisp_Object decoding_buf;
-    /* Size of carryover in decoding.  */
-    Lisp_Object decoding_carryover;
     /* Coding-system for encoding the output to this process.  */
     Lisp_Object encode_coding_system;
     /* Working buffer for encoding.  */
     Lisp_Object encoding_buf;
-    /* Size of carryover in encoding.  */
-    Lisp_Object encoding_carryover;
-    /* Flag to set coding-system of the process buffer from the
-       coding_system used to decode process output.  */
-    Lisp_Object inherit_coding_system_flag;
-    /* Flat to decide the multibyteness of a string given to the
-       filter (if any).  It is initialized to the value of
-       `default-enable-multibyte-characters' when the process is
-       generated, and can be changed by the function
-       `set-process-fileter-multibyte'. */
-    Lisp_Object filter_multibyte;
-    /* Should we delay reading output from this process.
-       Initialized from `Vprocess_adaptive_read_buffering'.  */
-    Lisp_Object adaptive_read_buffering;
-    /* Hysteresis to try to read process output in larger blocks.
-       On some systems, e.g. GNU/Linux, Emacs is seen as 
-       an interactive app also when reading process output, meaning
-       that process output can be read in as little as 1 byte at a
-       time.  Value is micro-seconds to delay reading output from
-       this process.  Range is 0 .. 50000.  */
-    Lisp_Object read_output_delay;
-    /* Skip reading this process on next read.  */
-    Lisp_Object read_output_skip;
 
     /* After this point, there are no Lisp_Objects any more.  */
+    /* alloc.c assumes that `pid' is the first such non-Lisp slot.  */
 
     /* Number of this process.
        allocate_process assumes this is the first non-Lisp_Object field.
        A value 0 is used for pseudo-processes such as network connections.  */
     pid_t pid;
+    /* Descriptor by which we read from this process */
+    int infd;
+    /* Descriptor by which we write to this process */
+    int outfd;
+    /* Event-count of last event in which this process changed status.  */
+    int tick;
+    /* Event-count of last such event reported.  */
+    int update_tick;
+    /* Size of carryover in decoding.  */
+    int decoding_carryover;
+    /* Hysteresis to try to read process output in larger blocks.
+       On some systems, e.g. GNU/Linux, Emacs is seen as
+       an interactive app also when reading process output, meaning
+       that process output can be read in as little as 1 byte at a
+       time.  Value is micro-seconds to delay reading output from
+       this process.  Range is 0 .. 50000.  */
+    int read_output_delay;
+    /* Should we delay reading output from this process.
+       Initialized from `Vprocess_adaptive_read_buffering'.
+       0 = nil, 1 = t, 2 = other.  */
+    int adaptive_read_buffering : 2;
+    /* Skip reading this process on next read.  */
+    int read_output_skip : 1;
+    /* Non-nil means kill silently if Emacs is exited.
+       This is the inverse of the `query-on-exit' flag.  */
+    int kill_without_query : 1;
+    /* Non-nil if communicating through a pty.  */
+    int pty_flag : 1;
+    /* Flag to set coding-system of the process buffer from the
+       coding_system used to decode process output.  */
+    int inherit_coding_system_flag : 1;
+    /* Flag to decide the multibyteness of a string given to the
+       filter (if any).  It is initialized to the value of
+       `default-enable-multibyte-characters' when the process is
+       generated, and can be changed by the function
+       `set-process-filter-multibyte'. */
+    int filter_multibyte : 1;
     /* Record the process status in the raw form in which it comes from `wait'.
        This is to avoid consing in a signal handler.  The `raw_status_new'
        flag indicates that `raw_status' contains a new status that still
diff --git a/src/search.c b/src/search.c
index fd7b474e4ab..ae5ae608e4a 100644
--- a/src/search.c
+++ b/src/search.c
@@ -93,6 +93,11 @@ Lisp_Object Qsearch_failed;
 
 Lisp_Object Vsearch_spaces_regexp;
 
+/* If non-nil, the match data will not be changed during call to
+   searching or matching functions.  This variable is for internal use
+   only.  */
+Lisp_Object Vinhibit_changing_match_data;
+
 static void set_search_regs ();
 static void save_search_regs ();
 static int simple_search ();
@@ -289,7 +294,9 @@ looking_at_1 (string, posix)
     = current_buffer->case_eqv_table;
 
   CHECK_STRING (string);
-  bufp = compile_pattern (string, &search_regs,
+  bufp = compile_pattern (string,
+                          (NILP (Vinhibit_changing_match_data)
+                           ? &search_regs : NULL),
                           (!NILP (current_buffer->case_fold_search)
                            ? current_buffer->case_canon_table : Qnil),
                           posix,
@@ -320,7 +327,9 @@ looking_at_1 (string, posix)
   re_match_object = Qnil;
 
   i = re_match_2 (bufp, (char *) p1, s1, (char *) p2, s2,
-                  PT_BYTE - BEGV_BYTE, &search_regs,
+                  PT_BYTE - BEGV_BYTE,
+                  (NILP (Vinhibit_changing_match_data)
+                   ? &search_regs : NULL),
                   ZV_BYTE - BEGV_BYTE);
   immediate_quit = 0;
 
@@ -328,7 +337,7 @@ looking_at_1 (string, posix)
     matcher_overflow ();
 
   val = (0 <= i ? Qt : Qnil);
-  if (i >= 0)
+  if (NILP (Vinhibit_changing_match_data) && i >= 0)
     for (i = 0; i < search_regs.num_regs; i++)
       if (search_regs.start[i] >= 0)
         {
@@ -337,7 +346,11 @@ looking_at_1 (string, posix)
           search_regs.end[i]
             = BYTE_TO_CHAR (search_regs.end[i] + BEGV_BYTE);
         }
-  XSETBUFFER (last_thing_searched, current_buffer);
+
+  /* Set last_thing_searched only when match data is changed.  */
+  if (NILP (Vinhibit_changing_match_data))
+    XSETBUFFER (last_thing_searched, current_buffer);
+
   return val;
 }
 
@@ -399,7 +412,9 @@ string_match_1 (regexp, string, start, posix)
   XCHAR_TABLE (current_buffer->case_canon_table)->extras[2]
     = current_buffer->case_eqv_table;
 
-  bufp = compile_pattern (regexp, &search_regs,
+  bufp = compile_pattern (regexp,
+                          (NILP (Vinhibit_changing_match_data)
+                           ? &search_regs : NULL),
                           (!NILP (current_buffer->case_fold_search)
                            ? current_buffer->case_canon_table : Qnil),
                           posix,
@@ -410,21 +425,27 @@ string_match_1 (regexp, string, start, posix)
   val = re_search (bufp, (char *) SDATA (string),
                    SBYTES (string), pos_byte,
                    SBYTES (string) - pos_byte,
-                   &search_regs);
+                   (NILP (Vinhibit_changing_match_data)
+                    ? &search_regs : NULL));
   immediate_quit = 0;
-  last_thing_searched = Qt;
+
+  /* Set last_thing_searched only when match data is changed.  */
+  if (NILP (Vinhibit_changing_match_data))
+    last_thing_searched = Qt;
+
   if (val == -2)
     matcher_overflow ();
   if (val < 0) return Qnil;
 
-  for (i = 0; i < search_regs.num_regs; i++)
-    if (search_regs.start[i] >= 0)
-      {
-        search_regs.start[i]
-          = string_byte_to_char (string, search_regs.start[i]);
-        search_regs.end[i]
-          = string_byte_to_char (string, search_regs.end[i]);
-      }
+  if (NILP (Vinhibit_changing_match_data))
+    for (i = 0; i < search_regs.num_regs; i++)
+      if (search_regs.start[i] >= 0)
+        {
+          search_regs.start[i]
+            = string_byte_to_char (string, search_regs.start[i]);
+          search_regs.end[i]
+            = string_byte_to_char (string, search_regs.end[i]);
+        }
 
   return make_number (string_byte_to_char (string, val));
 }
@@ -1042,6 +1063,11 @@ do						\
   }                                             \
 while (0)
 
+/* Only used in search_buffer, to record the end position of the match
+   when searching regexps and SEARCH_REGS should not be changed
+   (i.e. Vinhibit_changing_match_data is non-nil).  */
+static struct re_registers search_regs_1;
+
 static int
 search_buffer (string, pos, pos_byte, lim, lim_byte, n,
                RE, trt, inverse_trt, posix)
@@ -1077,7 +1103,10 @@ search_buffer (string, pos, pos_byte, lim, lim_byte, n,
       int s1, s2;
       struct re_pattern_buffer *bufp;
 
-      bufp = compile_pattern (string, &search_regs, trt, posix,
+      bufp = compile_pattern (string,
+                              (NILP (Vinhibit_changing_match_data)
+                               ? &search_regs : &search_regs_1),
+                              trt, posix,
                               !NILP (current_buffer->enable_multibyte_characters));
 
       immediate_quit = 1;       /* Quit immediately if user types ^G,
@@ -1110,7 +1139,8 @@ search_buffer (string, pos, pos_byte, lim, lim_byte, n,
           int val;
           val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2,
                              pos_byte - BEGV_BYTE, lim_byte - pos_byte,
-                             &search_regs,
+                             (NILP (Vinhibit_changing_match_data)
+                              ? &search_regs : &search_regs_1),
                              /* Don't allow match past current point */
                              pos_byte - BEGV_BYTE);
           if (val == -2)
@@ -1119,18 +1149,27 @@ search_buffer (string, pos, pos_byte, lim, lim_byte, n,
             }
           if (val >= 0)
             {
-              pos_byte = search_regs.start[0] + BEGV_BYTE;
-              for (i = 0; i < search_regs.num_regs; i++)
-                if (search_regs.start[i] >= 0)
-                  {
-                    search_regs.start[i]
-                      = BYTE_TO_CHAR (search_regs.start[i] + BEGV_BYTE);
-                    search_regs.end[i]
-                      = BYTE_TO_CHAR (search_regs.end[i] + BEGV_BYTE);
-                  }
-              XSETBUFFER (last_thing_searched, current_buffer);
-              /* Set pos to the new position. */
-              pos = search_regs.start[0];
+              if (NILP (Vinhibit_changing_match_data))
+                {
+                  pos_byte = search_regs.start[0] + BEGV_BYTE;
+                  for (i = 0; i < search_regs.num_regs; i++)
+                    if (search_regs.start[i] >= 0)
+                      {
+                        search_regs.start[i]
+                          = BYTE_TO_CHAR (search_regs.start[i] + BEGV_BYTE);
+                        search_regs.end[i]
+                          = BYTE_TO_CHAR (search_regs.end[i] + BEGV_BYTE);
+                      }
+                  XSETBUFFER (last_thing_searched, current_buffer);
+                  /* Set pos to the new position. */
+                  pos = search_regs.start[0];
+                }
+              else
+                {
+                  pos_byte = search_regs_1.start[0] + BEGV_BYTE;
+                  /* Set pos to the new position.  */
+                  pos = BYTE_TO_CHAR (search_regs_1.start[0] + BEGV_BYTE);
+                }
             }
           else
             {
@@ -1144,7 +1183,8 @@ search_buffer (string, pos, pos_byte, lim, lim_byte, n,
           int val;
           val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2,
                              pos_byte - BEGV_BYTE, lim_byte - pos_byte,
-                             &search_regs,
+                             (NILP (Vinhibit_changing_match_data)
+                              ? &search_regs : &search_regs_1),
                              lim_byte - BEGV_BYTE);
           if (val == -2)
             {
@@ -1152,17 +1192,25 @@ search_buffer (string, pos, pos_byte, lim, lim_byte, n,
             }
           if (val >= 0)
             {
-              pos_byte = search_regs.end[0] + BEGV_BYTE;
-              for (i = 0; i < search_regs.num_regs; i++)
-                if (search_regs.start[i] >= 0)
-                  {
-                    search_regs.start[i]
-                      = BYTE_TO_CHAR (search_regs.start[i] + BEGV_BYTE);
-                    search_regs.end[i]
-                      = BYTE_TO_CHAR (search_regs.end[i] + BEGV_BYTE);
-                  }
-              XSETBUFFER (last_thing_searched, current_buffer);
-              pos = search_regs.end[0];
+              if (NILP (Vinhibit_changing_match_data))
+                {
+                  pos_byte = search_regs.end[0] + BEGV_BYTE;
+                  for (i = 0; i < search_regs.num_regs; i++)
+                    if (search_regs.start[i] >= 0)
+                      {
+                        search_regs.start[i]
+                          = BYTE_TO_CHAR (search_regs.start[i] + BEGV_BYTE);
+                        search_regs.end[i]
+                          = BYTE_TO_CHAR (search_regs.end[i] + BEGV_BYTE);
+                      }
+                  XSETBUFFER (last_thing_searched, current_buffer);
+                  pos = search_regs.end[0];
+                }
+              else
+                {
+                  pos_byte = search_regs_1.end[0] + BEGV_BYTE;
+                  pos = BYTE_TO_CHAR (search_regs_1.end[0] + BEGV_BYTE);
+                }
             }
           else
             {
@@ -1907,7 +1955,7 @@ boyer_moore (n, base_pat, len, len_byte, trt, inverse_trt,
               cursor += dirlen - i - direction; /* fix cursor */
               if (i + direction == 0)
                 {
-                  int position;
+                  int position, start, end;
 
                   cursor -= direction;
 
@@ -1915,11 +1963,24 @@ boyer_moore (n, base_pat, len, len_byte, trt, inverse_trt,
                                                        ? 1 - len_byte : 0);
                   set_search_regs (position, len_byte);
 
+                  if (NILP (Vinhibit_changing_match_data))
+                    {
+                      start = search_regs.start[0];
+                      end = search_regs.end[0];
+                    }
+                  else
+                    /* If Vinhibit_changing_match_data is non-nil,
+                       search_regs will not be changed.  So let's
+                       compute start and end here.  */
+                    {
+                      start = BYTE_TO_CHAR (position);
+                      end = BYTE_TO_CHAR (position + len_byte);
+                    }
+
                   if ((n -= direction) != 0)
                     cursor += dirlen; /* to resume search */
                   else
-                    return ((direction > 0)
-                            ? search_regs.end[0] : search_regs.start[0]);
+                    return direction > 0 ? end : start;
                 }
               else
                 cursor += stride_for_teases; /* <sigh> we lose -  */
@@ -1984,18 +2045,30 @@ boyer_moore (n, base_pat, len, len_byte, trt, inverse_trt,
               pos_byte += dirlen - i- direction;
               if (i + direction == 0)
                 {
-                  int position;
+                  int position, start, end;
                   pos_byte -= direction;
 
                   position = pos_byte + ((direction > 0) ? 1 - len_byte : 0);
-
                   set_search_regs (position, len_byte);
 
+                  if (NILP (Vinhibit_changing_match_data))
+                    {
+                      start = search_regs.start[0];
+                      end = search_regs.end[0];
+                    }
+                  else
+                    /* If Vinhibit_changing_match_data is non-nil,
+                       search_regs will not be changed.  So let's
+                       compute start and end here.  */
+                    {
+                      start = BYTE_TO_CHAR (position);
+                      end = BYTE_TO_CHAR (position + len_byte);
+                    }
+
                   if ((n -= direction) != 0)
                     pos_byte += dirlen; /* to resume search */
                   else
-                    return ((direction > 0)
-                            ? search_regs.end[0] : search_regs.start[0]);
+                    return direction > 0 ? end : start;
                 }
               else
                 pos_byte += stride_for_teases;
@@ -2018,6 +2091,9 @@ set_search_regs (beg_byte, nbytes)
 {
   int i;
 
+  if (!NILP (Vinhibit_changing_match_data))
+    return;
+
   /* Make sure we have registers in which to store
      the match position.  */
   if (search_regs.num_regs == 0)
@@ -3145,6 +3221,13 @@ or other such regexp constructs are not replaced with this.
 A value of nil (which is the normal value) means treat spaces literally.  */);
   Vsearch_spaces_regexp = Qnil;
 
+  DEFVAR_LISP ("inhibit-changing-match-data", &Vinhibit_changing_match_data,
+      doc: /* Internal use only.
+If non-nil, the match data will not be changed during call to searching or
+matching functions, such as `looking-at', `string-match', `re-search-forward'
+etc.  */);
+  Vinhibit_changing_match_data = Qnil;
+
   defsubr (&Slooking_at);
   defsubr (&Sposix_looking_at);
   defsubr (&Sstring_match);
diff --git a/src/term.c b/src/term.c
index 0210a66afa9..331d9f20e4c 100644
--- a/src/term.c
+++ b/src/term.c
@@ -25,6 +25,9 @@ Boston, MA 02110-1301, USA.  */
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
 
 #include "termchar.h"
 #include "termopts.h"
@@ -2493,9 +2496,9 @@ set_tty_color_mode (f, val)
 void
 term_mouse_moveto (int x, int y)
 {
+  /* TODO: how to set mouse position?
   const char *name;
   int fd;
-  /* TODO: how to set mouse position?
   name = (const char *) ttyname (0);
   fd = open (name, O_WRONLY);
      SOME_FUNCTION (x, y, fd);
@@ -2509,7 +2512,7 @@ term_show_mouse_face (enum draw_glyphs_face draw)
 {
   struct window *w = XWINDOW (Qmouse_face_window);
   int save_x, save_y;
-  int i, j;
+  int i;
 
   if (/* If window is in the process of being destroyed, don't bother
          to do anything.  */
@@ -3029,7 +3032,7 @@ int
 handle_one_term_event (Gpm_Event *event, struct input_event* hold_quit)
 {
   struct frame *f = SELECTED_FRAME ();
-  int i, j, fd;
+  int fd;
   struct input_event ie;
   int do_help = 0;
   int count = 0;
@@ -3053,7 +3056,7 @@ handle_one_term_event (Gpm_Event *event, struct input_event* hold_quit)
     arg[1] = arg[3] = (unsigned short) event->y + gpm_zerobased;
     arg[4] = (unsigned short) 3;
     
-    name = (const char *) ttyname (0);
+    name = ttyname (0);
     fd = open (name, O_WRONLY);
     ioctl (fd, TIOCLINUX, buf + sizeof (short) - 1);
     close (fd);
diff --git a/src/w32fns.c b/src/w32fns.c
index fbdb11ca922..e0c763aef99 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -53,6 +53,7 @@ Boston, MA 02110-1301, USA.  */
 #include <shellapi.h>
 #include <ctype.h>
 #include <winspool.h>
+#include <objbase.h>
 
 #include <dlgs.h>
 #define FILE_NAME_TEXT_FIELD edt1
@@ -2518,6 +2519,13 @@ w32_msg_pump (deferred_msg * msg_buf)
               /* Produced by complete_deferred_msg; just ignore.  */
               break;
             case WM_EMACS_CREATEWINDOW:
+              /* Initialize COM for this window. Even though we don't use it,
+                 some third party shell extensions can cause it to be used in
+                 system dialogs, which causes a crash if it is not initialized.
+                 This is a known bug in Windows, which was fixed long ago, but
+                 the patch for XP is not publically available until XP SP3,
+                 and older versions will never be patched.  */
+              CoInitialize (NULL);
               w32_createwindow ((struct frame *) msg.wParam);
               if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
                 abort ();
@@ -3664,6 +3672,10 @@ w32_wnd_proc (hwnd, msg, wParam, lParam)
       my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
       goto dflt;
 
+    case WM_DESTROY:
+      CoUninitialize ();
+      return 0;
+
     case WM_CLOSE:
       wmsg.dwModifiers = w32_get_modifiers ();
       my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
diff --git a/src/window.c b/src/window.c
index 61be973e180..42a33828d8d 100644
--- a/src/window.c
+++ b/src/window.c
@@ -6643,7 +6643,7 @@ and the value of point and mark for each window.
 Also restore the choice of selected window.
 Also restore which buffer is current.
 Does not restore the value of point in current buffer.
-usage: (save-window-excursion BODY ...)  */)
+usage: (save-window-excursion BODY...)  */)
      (args)
      Lisp_Object args;
 {