Merge from emacs--devo--0

Patches applied:

 * emacs--devo--0  (patch 357-381)

   - Merge from gnus--rel--5.10
   - Update from CVS
   - Merge from erc--emacs--21

 * gnus--rel--5.10  (patch 116-122)

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

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

17 files changed, 413 insertions, 114 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 1ea2005e0c4..474ead0cde6 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,84 @@
+2006-08-01  Kim F. Storm  <storm@cua.dk>
+
+        * process.c (wait_reading_process_output_unwind): New function.
+        Restores waiting_for_user_input_p to saved value.
+        (wait_reading_process_output): Unwind protect waiting_for_user_input_p
+        instead of save/restore old value on stack.
+
+2006-07-30  Thien-Thi Nguyen  <ttn@gnu.org>
+
+        * editfns.c: Undo 2006-06-27 change.
+
+2006-07-29  Eli Zaretskii  <eliz@gnu.org>
+
+        * coding.c (Ffind_operation_coding_system): Revert the change from
+        2006-05-29.
+
+        * alloc.c [WINDOWSNT]: Include fcntl.h, to fix last change.
+
+2006-07-28  Richard Stallman  <rms@gnu.org>
+
+        * xfaces.c (lookup_named_face, Fdisplay_supports_face_attributes_p):
+        Add conditional aborts for clarity.
+
+        * xdisp.c (update_menu_bar): New arg HOOKS_RUN.  Callers changed.
+        Used to avoid running the hooks over and over for each frame.
+        (prepare_menu_bars): Pass value from update_menu_bar
+        as HOOKS_RUN of next call.
+
+        * keyboard.c (safe_run_hooks_1): Don't crash if Vrun_hooks is nil.
+
+2006-07-28  Kim F. Storm  <storm@cua.dk>
+
+        * alloc.c (valid_pointer_p): New function (from valid_lisp_object_p).
+        (valid_lisp_object_p): Use it to check for valid SUBRP obj.
+
+2006-07-26  Chong Yidong  <cyd@stupidchicken.com>
+
+        * keyboard.c (read_char): New arg END_TIME specifying timeout.
+        All callers changed.  Turn off echoing if END_TIME is non-NULL.
+        (kbd_buffer_get_event): New arg END_TIME.
+
+        * lread.c (read_filtered_event): New arg SECONDS to wait until.
+        (Fread_char, Fread_event, Fread_char_exclusive): New arg SECONDS.
+
+        * lisp.h: Update read-char, read-event, and read_filtered_event
+        prototypes.
+
+        * keyboard.h: Include systime.h.  Update read_char prototype.
+
+2006-07-25  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * alloc.c (find_string_data_in_pure): New function.
+        (make_pure_string): Use it to reuse existing string data if possible.
+
+        * puresize.h (BASE_PURESIZE): Decrease to 1102000.
+
+2006-07-22  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keymap.c (Fdefine_key): If the key binding definition looks like an
+        XEmacs-style key sequence, convert it to Emacs's format.
+
+2006-07-22  Ralf Angeli  <angeli@caeruleus.net>
+
+        * w32fns.c (w32_createwindow): If `left' and/or `top' frame
+        parameters are bound to some values, use that instead of
+        CW_USEDEFAULT.
+
+2006-07-21  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (convert_time): Use explicit long double constants to
+        ensure long double arithmetics is used throughout.
+
+2006-07-20  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * alloc.c (pure_bytes_used_lisp, pure_bytes_used_non_lisp): New vars.
+        (init_alloc_once): Initialize them.
+        (pure_alloc): Allocate non-Lisp objects from the end of pure storage
+        without alignment.
+
+        * puresize.h (BASE_PURESIZE): Decrease to 1141000.
+
 2006-07-18  Francis Litterio  <franl@world.std.com>
 
         * w32term.c (x_calc_absolute_position): Fix frame positioning
@@ -131,6 +212,14 @@
         (mac_initialize_display_info) [MAC_OSX]: Use CGDisplaySamplesPerPixel.
         (x_delete_display): Apply 2006-07-04 change for xterm.c.
 
+2006-07-17  Richard Stallman  <rms@gnu.org>
+
+        * keyboard.c (Vcommand_error_function): New variable.
+        (syms_of_keyboard): Defvar it.
+        (cmd_error_internal): Simplify, and handle Vcommand_error_function.
+
+        * dispnew.c (init_display): Mention DISPLAY as well as TERM in err msg.
+
 2006-07-17  Kim F. Storm  <storm@cua.dk>
 
         * xdisp.c (handle_single_display_spec): Ensure the right value of
diff --git a/src/alloc.c b/src/alloc.c
index 2cf3ff40e3b..9f93e62d2ed 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -78,6 +78,10 @@ extern POINTER_TYPE *sbrk ();
 #define O_WRONLY 1
 #endif
 
+#ifdef WINDOWSNT
+#include <fcntl.h>
+#endif
+
 #ifdef DOUG_LEA_MALLOC
 
 #include <malloc.h>
@@ -289,10 +293,18 @@ static size_t pure_bytes_used_before_overflow;
       && ((PNTR_COMPARISON_TYPE) (P)                            \
           >= (PNTR_COMPARISON_TYPE) purebeg))
 
-/* Index in pure at which next pure object will be allocated.. */
+/* Total number of bytes allocated in pure storage. */
 
 EMACS_INT pure_bytes_used;
 
+/* Index in pure at which next pure Lisp object will be allocated.. */
+
+static EMACS_INT pure_bytes_used_lisp;
+
+/* Number of bytes allocated for non-Lisp objects in pure storage.  */
+
+static EMACS_INT pure_bytes_used_non_lisp;
+
 /* If nonzero, this is a warning delivered by malloc and not yet
    displayed.  */
 
@@ -4555,6 +4567,28 @@ mark_stack ()
 #endif /* GC_MARK_STACK != 0 */
 
 
+/* Determine whether it is safe to access memory at address P.  */
+int
+valid_pointer_p (p)
+     void *p;
+{
+  int fd;
+
+  /* Obviously, we cannot just access it (we would SEGV trying), so we
+     trick the o/s to tell us whether p is a valid pointer.
+     Unfortunately, we cannot use NULL_DEVICE here, as emacs_write may
+     not validate p in that case.  */
+
+  if ((fd = emacs_open ("__Valid__Lisp__Object__", O_CREAT | O_WRONLY | O_TRUNC, 0666)) >= 0)
+    {
+      int valid = (emacs_write (fd, (char *)p, 16) == 16);
+      emacs_close (fd);
+      unlink ("__Valid__Lisp__Object__");
+      return valid;
+    }
+
+    return -1;
+}
 
 /* Return 1 if OBJ is a valid lisp object.
    Return 0 if OBJ is NOT a valid lisp object.
@@ -4567,9 +4601,7 @@ valid_lisp_object_p (obj)
      Lisp_Object obj;
 {
   void *p;
-#if !GC_MARK_STACK
-  int fd;
-#else
+#if GC_MARK_STACK
   struct mem_node *m;
 #endif
 
@@ -4581,26 +4613,22 @@ valid_lisp_object_p (obj)
     return 1;
 
 #if !GC_MARK_STACK
-  /* We need to determine whether it is safe to access memory at
-     address P.  Obviously, we cannot just access it (we would SEGV
-     trying), so we trick the o/s to tell us whether p is a valid
-     pointer.  Unfortunately, we cannot use NULL_DEVICE here, as
-     emacs_write may not validate p in that case.  */
-  if ((fd = emacs_open ("__Valid__Lisp__Object__", O_CREAT | O_WRONLY | O_TRUNC, 0666)) >= 0)
-    {
-      int valid = (emacs_write (fd, (char *)p, 16) == 16);
-      emacs_close (fd);
-      unlink ("__Valid__Lisp__Object__");
-      return valid;
-    }
-
-    return -1;
+  return valid_pointer_p (p);
 #else
 
   m = mem_find (p);
 
   if (m == MEM_NIL)
-    return 0;
+    {
+      int valid = valid_pointer_p (p);
+      if (valid <= 0)
+        return valid;
+
+      if (SUBRP (obj))
+        return 1;
+
+      return 0;
+    }
 
   switch (m->type)
     {
@@ -4649,10 +4677,7 @@ valid_lisp_object_p (obj)
 
 /* Allocate room for SIZE bytes from pure Lisp storage and return a
    pointer to it.  TYPE is the Lisp type for which the memory is
-   allocated.  TYPE < 0 means it's not used for a Lisp object.
-
-   If store_pure_type_info is set and TYPE is >= 0, the type of
-   the allocated object is recorded in pure_types.  */
+   allocated.  TYPE < 0 means it's not used for a Lisp object.  */
 
 static POINTER_TYPE *
 pure_alloc (size, type)
@@ -4677,8 +4702,21 @@ pure_alloc (size, type)
 #endif
 
  again:
-  result = ALIGN (purebeg + pure_bytes_used, alignment);
-  pure_bytes_used = ((char *)result - (char *)purebeg) + size;
+  if (type >= 0)
+    {
+      /* Allocate space for a Lisp object from the beginning of the free
+         space with taking account of alignment.  */
+      result = ALIGN (purebeg + pure_bytes_used_lisp, alignment);
+      pure_bytes_used_lisp = ((char *)result - (char *)purebeg) + size;
+    }
+  else
+    {
+      /* Allocate space for a non-Lisp object from the end of the free
+         space.  */
+      pure_bytes_used_non_lisp += size;
+      result = purebeg + pure_size - pure_bytes_used_non_lisp;
+    }
+  pure_bytes_used = pure_bytes_used_lisp + pure_bytes_used_non_lisp;
 
   if (pure_bytes_used <= pure_size)
     return result;
@@ -4690,6 +4728,7 @@ pure_alloc (size, type)
   pure_size = 10000;
   pure_bytes_used_before_overflow += pure_bytes_used - size;
   pure_bytes_used = 0;
+  pure_bytes_used_lisp = pure_bytes_used_non_lisp = 0;
   goto again;
 }
 
@@ -4705,6 +4744,73 @@ check_pure_size ()
 }
 
 
+/* Find the byte sequence {DATA[0], ..., DATA[NBYTES-1], '\0'} from
+   the non-Lisp data pool of the pure storage, and return its start
+   address.  Return NULL if not found.  */
+
+static char *
+find_string_data_in_pure (data, nbytes)
+     char *data;
+     int nbytes;
+{
+  int i, skip, bm_skip[256], last_char_skip, infinity, start, start_max;
+  unsigned char *p;
+  char *non_lisp_beg;
+
+  if (pure_bytes_used_non_lisp < nbytes + 1)
+    return NULL;
+
+  /* Set up the Boyer-Moore table.  */
+  skip = nbytes + 1;
+  for (i = 0; i < 256; i++)
+    bm_skip[i] = skip;
+
+  p = (unsigned char *) data;
+  while (--skip > 0)
+    bm_skip[*p++] = skip;
+
+  last_char_skip = bm_skip['\0'];
+
+  non_lisp_beg = purebeg + pure_size - pure_bytes_used_non_lisp;
+  start_max = pure_bytes_used_non_lisp - (nbytes + 1);
+
+  /* See the comments in the function `boyer_moore' (search.c) for the
+     use of `infinity'.  */
+  infinity = pure_bytes_used_non_lisp + 1;
+  bm_skip['\0'] = infinity;
+
+  p = (unsigned char *) non_lisp_beg + nbytes;
+  start = 0;
+  do
+    {
+      /* Check the last character (== '\0').  */
+      do
+        {
+          start += bm_skip[*(p + start)];
+        }
+      while (start <= start_max);
+
+      if (start < infinity)
+        /* Couldn't find the last character.  */
+        return NULL;
+
+      /* No less than `infinity' means we could find the last
+         character at `p[start - infinity]'.  */
+      start -= infinity;
+
+      /* Check the remaining characters.  */
+      if (memcmp (data, non_lisp_beg + start, nbytes) == 0)
+        /* Found.  */
+        return non_lisp_beg + start;
+
+      start += last_char_skip;
+    }
+  while (start <= start_max);
+
+  return NULL;
+}
+
+
 /* Return a string allocated in pure space.  DATA is a buffer holding
    NCHARS characters, and NBYTES bytes of string data.  MULTIBYTE
    non-zero means make the result string multibyte.
@@ -4723,11 +4829,15 @@ make_pure_string (data, nchars, nbytes, multibyte)
   struct Lisp_String *s;
 
   s = (struct Lisp_String *) pure_alloc (sizeof *s, Lisp_String);
-  s->data = (unsigned char *) pure_alloc (nbytes + 1, -1);
+  s->data = find_string_data_in_pure (data, nbytes);
+  if (s->data == NULL)
+    {
+      s->data = (unsigned char *) pure_alloc (nbytes + 1, -1);
+      bcopy (data, s->data, nbytes);
+      s->data[nbytes] = '\0';
+    }
   s->size = nchars;
   s->size_byte = multibyte ? nbytes : -1;
-  bcopy (data, s->data, nbytes);
-  s->data[nbytes] = '\0';
   s->intervals = NULL_INTERVAL;
   XSETSTRING (string, s);
   return string;
@@ -6182,6 +6292,7 @@ init_alloc_once ()
   purebeg = PUREBEG;
   pure_size = PURESIZE;
   pure_bytes_used = 0;
+  pure_bytes_used_lisp = pure_bytes_used_non_lisp = 0;
   pure_bytes_used_before_overflow = 0;
 
   /* Initialize the list of free aligned blocks.  */
diff --git a/src/callint.c b/src/callint.c
index 475042abbe1..4c8a5718cd9 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -563,7 +563,7 @@ If KEYS is omitted or nil, the return value of `this-command-keys' is used.  */)
           break;
 
         case 'c':               /* Character */
-          args[i] = Fread_char (build_string (callint_message), Qnil);
+          args[i] = Fread_char (build_string (callint_message), Qnil, Qnil);
           message1_nolog ((char *) 0);
           /* Passing args[i] directly stimulates compiler bug */
           teml = args[i];
@@ -635,7 +635,7 @@ If KEYS is omitted or nil, the return value of `this-command-keys' is used.  */)
                 /* Ignore first element, which is the base key.  */
                 tem2 = Fmemq (intern ("down"), Fcdr (teml));
                 if (! NILP (tem2))
-                  up_event = Fread_event (Qnil, Qnil);
+                  up_event = Fread_event (Qnil, Qnil, Qnil);
               }
           }
           break;
@@ -663,7 +663,7 @@ If KEYS is omitted or nil, the return value of `this-command-keys' is used.  */)
                 /* Ignore first element, which is the base key.  */
                 tem2 = Fmemq (intern ("down"), Fcdr (teml));
                 if (! NILP (tem2))
-                  up_event = Fread_event (Qnil, Qnil);
+                  up_event = Fread_event (Qnil, Qnil, Qnil);
               }
           }
           break;
diff --git a/src/coding.c b/src/coding.c
index cb6df79fca0..9ba96981c7f 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -8390,7 +8390,10 @@ usage: (find-operation-coding-system OPERATION ARGUMENTS ...)  */)
             return Fcons (val, val);
           if (! NILP (Ffboundp (val)))
             {
-              val = safe_call1 (val, Flist (nargs, args));
+              /* We use call1 rather than safe_call1
+                 so as to get bug reports about functions called here
+                 which don't handle the current interface.  */
+              val = call1 (val, Flist (nargs, args));
               if (CONSP (val))
                 return val;
               if (SYMBOLP (val) && ! NILP (Fcoding_system_p (val)))
diff --git a/src/editfns.c b/src/editfns.c
index 46d661452b2..02ea2d2abb8 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -627,10 +627,7 @@ find_field (pos, merge_at_boundary, beg_limit, beg, end_limit, end)
 DEFUN ("delete-field", Fdelete_field, Sdelete_field, 0, 1, 0,
        doc: /* Delete the field surrounding POS.
 A field is a region of text with the same `field' property.
-If POS is nil, the value of point is used for POS.
-
-An `args-out-of-range' error is signaled if POS is outside the
-buffer's accessible portion.  */)
+If POS is nil, the value of point is used for POS.  */)
      (pos)
      Lisp_Object pos;
 {
@@ -644,10 +641,7 @@ buffer's accessible portion.  */)
 DEFUN ("field-string", Ffield_string, Sfield_string, 0, 1, 0,
        doc: /* Return the contents of the field surrounding POS as a string.
 A field is a region of text with the same `field' property.
-If POS is nil, the value of point is used for POS.
-
-An `args-out-of-range' error is signaled if POS is outside the
-buffer's accessible portion.  */)
+If POS is nil, the value of point is used for POS.  */)
      (pos)
      Lisp_Object pos;
 {
@@ -659,10 +653,7 @@ buffer's accessible portion.  */)
 DEFUN ("field-string-no-properties", Ffield_string_no_properties, Sfield_string_no_properties, 0, 1, 0,
        doc: /* Return the contents of the field around POS, without text-properties.
 A field is a region of text with the same `field' property.
-If POS is nil, the value of point is used for POS.
-
-An `args-out-of-range' error is signaled if POS is outside the
-buffer's accessible portion.  */)
+If POS is nil, the value of point is used for POS.  */)
      (pos)
      Lisp_Object pos;
 {
@@ -678,10 +669,7 @@ If POS is nil, the value of point is used for POS.
 If ESCAPE-FROM-EDGE is non-nil and POS is at the beginning of its
 field, then the beginning of the *previous* field is returned.
 If LIMIT is non-nil, it is a buffer position; if the beginning of the field
-is before LIMIT, then LIMIT will be returned instead.
-
-An `args-out-of-range' error is signaled if POS is outside the
-buffer's accessible portion.  */)
+is before LIMIT, then LIMIT will be returned instead.  */)
      (pos, escape_from_edge, limit)
      Lisp_Object pos, escape_from_edge, limit;
 {
@@ -697,10 +685,7 @@ If POS is nil, the value of point is used for POS.
 If ESCAPE-FROM-EDGE is non-nil and POS is at the end of its field,
 then the end of the *following* field is returned.
 If LIMIT is non-nil, it is a buffer position; if the end of the field
-is after LIMIT, then LIMIT will be returned instead.
-
-An `args-out-of-range' error is signaled if POS is outside the
-buffer's accessible portion.  */)
+is after LIMIT, then LIMIT will be returned instead.  */)
      (pos, escape_from_edge, limit)
      Lisp_Object pos, escape_from_edge, limit;
 {
diff --git a/src/fns.c b/src/fns.c
index 4c1e5b79ae2..a01cb97d685 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2618,7 +2618,7 @@ is nil and `use-dialog-box' is non-nil.  */)
           Fraise_frame (mini_frame);
         }
 
-      obj = read_filtered_event (1, 0, 0, 0);
+      obj = read_filtered_event (1, 0, 0, 0, Qnil);
       cursor_in_echo_area = 0;
       /* If we need to quit, quit with cursor_in_echo_area = 0.  */
       QUIT;
diff --git a/src/keyboard.c b/src/keyboard.c
index e58c78c84ac..45d5832a905 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -2032,6 +2032,8 @@ static Lisp_Object
 safe_run_hooks_1 (hook)
      Lisp_Object hook;
 {
+  if (NILP (Vrun_hooks))
+    return Qnil;
   return call1 (Vrun_hooks, Vinhibit_quit);
 }
 
@@ -2385,15 +2387,20 @@ do { if (polling_stopped_here) start_polling ();	\
    if we used a mouse menu to read the input, or zero otherwise.  If
    USED_MOUSE_MENU is null, we don't dereference it.
 
+   If END_TIME is non-null, it is a pointer to an EMACS_TIME
+   specifying the maximum time to wait until.  If no input arrives by
+   that time, stop waiting and return nil.
+
    Value is t if we showed a menu and the user rejected it.  */
 
 Lisp_Object
-read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
+read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu, end_time)
      int commandflag;
      int nmaps;
      Lisp_Object *maps;
      Lisp_Object prev_event;
      int *used_mouse_menu;
+     EMACS_TIME *end_time;
 {
   volatile Lisp_Object c;
   int count;
@@ -2673,6 +2680,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
      start echoing if enough time elapses.  */
 
   if (minibuf_level == 0
+      && !end_time
       && !current_kboard->immediate_echo
       && this_command_key_count > 0
       && ! noninteractive
@@ -2855,11 +2863,19 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
     {
       KBOARD *kb;
 
+      if (end_time)
+        {
+          EMACS_TIME now;
+          EMACS_GET_TIME (now);
+          if (EMACS_TIME_GE (now, *end_time))
+            goto exit;
+        }
+
       /* Actually read a character, waiting if necessary.  */
       save_getcjmp (save_jump);
       restore_getcjmp (local_getcjmp);
       timer_start_idle ();
-      c = kbd_buffer_get_event (&kb, used_mouse_menu);
+      c = kbd_buffer_get_event (&kb, used_mouse_menu, end_time);
       restore_getcjmp (save_jump);
 
 #ifdef MULTI_KBOARD
@@ -3196,7 +3212,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
 
       cancel_echoing ();
       do
-        c = read_char (0, 0, 0, Qnil, 0);
+        c = read_char (0, 0, 0, Qnil, 0, NULL);
       while (BUFFERP (c));
       /* Remove the help from the frame */
       unbind_to (count, Qnil);
@@ -3206,7 +3222,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
         {
           cancel_echoing ();
           do
-            c = read_char (0, 0, 0, Qnil, 0);
+            c = read_char (0, 0, 0, Qnil, 0, NULL);
           while (BUFFERP (c));
         }
     }
@@ -3885,9 +3901,10 @@ clear_event (event)
    We always read and discard one event.  */
 
 static Lisp_Object
-kbd_buffer_get_event (kbp, used_mouse_menu)
+kbd_buffer_get_event (kbp, used_mouse_menu, end_time)
      KBOARD **kbp;
      int *used_mouse_menu;
+     EMACS_TIME *end_time;
 {
   register int c;
   Lisp_Object obj;
@@ -3931,13 +3948,24 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
       if (!NILP (do_mouse_tracking) && some_mouse_moved ())
         break;
 #endif
-      {
+      if (end_time)
+        {
+          EMACS_TIME duration;
+          EMACS_GET_TIME (duration);
+          EMACS_SUB_TIME (duration, *end_time, duration);
+          if (EMACS_TIME_NEG_P (duration))
+            return Qnil;
+          else
+            wait_reading_process_output (EMACS_SECS (duration),
+                                         EMACS_USECS (duration), 
+                                         -1, 1, Qnil, NULL, 0);
+        }
+      else
         wait_reading_process_output (0, 0, -1, 1, Qnil, NULL, 0);
 
-        if (!interrupt_input && kbd_fetch_ptr == kbd_store_ptr)
-          /* Pass 1 for EXPECT since we just waited to have input.  */
-          read_avail_input (1);
-      }
+      if (!interrupt_input && kbd_fetch_ptr == kbd_store_ptr)
+        /* Pass 1 for EXPECT since we just waited to have input.  */
+        read_avail_input (1);
 #endif /* not VMS */
     }
 
@@ -8282,7 +8310,7 @@ read_char_minibuf_menu_prompt (commandflag, nmaps, maps)
       orig_defn_macro = current_kboard->defining_kbd_macro;
       current_kboard->defining_kbd_macro = Qnil;
       do
-        obj = read_char (commandflag, 0, 0, Qt, 0);
+        obj = read_char (commandflag, 0, 0, Qt, 0, NULL);
       while (BUFFERP (obj));
       current_kboard->defining_kbd_macro = orig_defn_macro;
 
@@ -8655,7 +8683,7 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
   /* Read the first char of the sequence specially, before setting
      up any keymaps, in case a filter runs and switches buffers on us.  */
   first_event = read_char (NILP (prompt), 0, submaps, last_nonmenu_event,
-                           &junk);
+                           &junk, NULL);
 #endif /* GOBBLE_FIRST_EVENT */
 
   orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
@@ -8858,7 +8886,7 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
 #endif
             key = read_char (NILP (prompt), nmaps,
                              (Lisp_Object *) submaps, last_nonmenu_event,
-                             &used_mouse_menu);
+                             &used_mouse_menu, NULL);
           }
 
           /* read_char returns t when it shows a menu and the user rejects it.
diff --git a/src/keyboard.h b/src/keyboard.h
index c0c941a0646..96ac7d2e856 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -19,6 +19,8 @@ along with GNU Emacs; see the file COPYING.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.  */
 
+#include "systime.h"            /* for EMACS_TIME */
+
 /* Length of echobuf field in each KBOARD.  */
 
 /* Each KBOARD represents one logical input stream from which Emacs gets input.
@@ -297,7 +299,8 @@ struct input_event;
 
 extern Lisp_Object parse_modifiers P_ ((Lisp_Object));
 extern Lisp_Object reorder_modifiers P_ ((Lisp_Object));
-extern Lisp_Object read_char P_ ((int, int, Lisp_Object *, Lisp_Object, int *));
+extern Lisp_Object read_char P_ ((int, int, Lisp_Object *, Lisp_Object,
+                                  int *, EMACS_TIME *));
 /* User-supplied string to translate input characters through.  */
 extern Lisp_Object Vkeyboard_translate_table;
 
diff --git a/src/keymap.c b/src/keymap.c
index af9d817a1eb..cdc45485e0a 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1172,6 +1172,20 @@ binding KEY to DEF is added at the front of KEYMAP.  */)
 
   meta_bit = VECTORP (key) ? meta_modifier : 0x80;
 
+  if (VECTORP (def) && ASIZE (def) > 0 && CONSP (AREF (def, make_number (0))))
+    { /* DEF is apparently an XEmacs-style keyboard macro.  */
+      Lisp_Object tmp = Fmake_vector (make_number (ASIZE (def)), Qnil);
+      int i = ASIZE (def);
+      while (--i >= 0)
+        {
+          Lisp_Object c = AREF (def, i);
+          if (CONSP (c) && lucid_event_type_list_p (c))
+            c = Fevent_convert_list (c);
+          ASET (tmp, i, c);
+        }
+      def = tmp;
+    }
+
   idx = 0;
   while (1)
     {
diff --git a/src/lisp.h b/src/lisp.h
index 8224117241c..171f8340885 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2681,9 +2681,9 @@ EXFUN (Fintern_soft, 2);
 EXFUN (Fload, 5);
 EXFUN (Fget_load_suffixes, 0);
 EXFUN (Fget_file_char, 0);
-EXFUN (Fread_char, 2);
-EXFUN (Fread_event, 2);
-extern Lisp_Object read_filtered_event P_ ((int, int, int, int));
+EXFUN (Fread_char, 3);
+EXFUN (Fread_event, 3);
+extern Lisp_Object read_filtered_event P_ ((int, int, int, int, Lisp_Object));
 EXFUN (Feval_region, 4);
 extern Lisp_Object intern P_ ((const char *));
 extern Lisp_Object make_symbol P_ ((char *));
diff --git a/src/lread.c b/src/lread.c
index 08ba5123fcb..c263c458a12 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -630,14 +630,19 @@ extern Lisp_Object read_char ();
    character.
 
    If INPUT_METHOD is nonzero, we invoke the current input method
-   if the character warrants that.  */
+   if the character warrants that.
+
+   If SECONDS is a number, we wait that many seconds for input, and
+   return Qnil if no input arrives within that time.  */
 
 Lisp_Object
 read_filtered_event (no_switch_frame, ascii_required, error_nonascii,
-                     input_method)
+                     input_method, seconds)
      int no_switch_frame, ascii_required, error_nonascii, input_method;
+     Lisp_Object seconds;
 {
   Lisp_Object val, delayed_switch_frame;
+  EMACS_TIME end_time;
 
 #ifdef HAVE_WINDOW_SYSTEM
   if (display_hourglass_p)
@@ -646,11 +651,24 @@ read_filtered_event (no_switch_frame, ascii_required, error_nonascii,
 
   delayed_switch_frame = Qnil;
 
+  /* Compute timeout.  */
+  if (NUMBERP (seconds))
+    {
+      EMACS_TIME wait_time;
+      int sec, usec;
+      double duration = extract_float (seconds);         
+
+      sec  = (int) duration;
+      usec = (duration - sec) * 1000000;
+      EMACS_GET_TIME (end_time);
+      EMACS_SET_SECS_USECS (wait_time, sec, usec);
+      EMACS_ADD_TIME (end_time, end_time, wait_time);
+    }
+
   /* Read until we get an acceptable event.  */
  retry:
-  val = read_char (0, 0, 0,
-                   (input_method ? Qnil : Qt),
-                   0);
+  val = read_char (0, 0, 0, (input_method ? Qnil : Qt), 0,
+                   NUMBERP (seconds) ? &end_time : NULL);
 
   if (BUFFERP (val))
     goto retry;
@@ -668,7 +686,7 @@ read_filtered_event (no_switch_frame, ascii_required, error_nonascii,
       goto retry;
     }
 
-  if (ascii_required)
+  if (ascii_required && !(NUMBERP (seconds) && NILP (val)))
     {
       /* Convert certain symbols to their ASCII equivalents.  */
       if (SYMBOLP (val))
@@ -713,7 +731,7 @@ read_filtered_event (no_switch_frame, ascii_required, error_nonascii,
   return val;
 }
 
-DEFUN ("read-char", Fread_char, Sread_char, 0, 2, 0,
+DEFUN ("read-char", Fread_char, Sread_char, 0, 3, 0,
        doc: /* Read a character from the command input (keyboard or macro).
 It is returned as a number.
 If the user generates an event which is not a character (i.e. a mouse
@@ -726,43 +744,55 @@ If you want to read non-character events, or ignore them, call
 If the optional argument PROMPT is non-nil, display that as a prompt.
 If the optional argument INHERIT-INPUT-METHOD is non-nil and some
 input method is turned on in the current buffer, that input method
-is used for reading a character.  */)
-     (prompt, inherit_input_method)
-     Lisp_Object prompt, inherit_input_method;
+is used for reading a character.
+If the optional argument SECONDS is non-nil, it should be a number
+specifying the maximum number of seconds to wait for input.  If no
+input arrives in that time, return nil.  SECONDS may be a
+floating-point value.  */)
+     (prompt, inherit_input_method, seconds)
+     Lisp_Object prompt, inherit_input_method, seconds;
 {
   if (! NILP (prompt))
     message_with_string ("%s", prompt, 0);
-  return read_filtered_event (1, 1, 1, ! NILP (inherit_input_method));
+  return read_filtered_event (1, 1, 1, ! NILP (inherit_input_method), seconds);
 }
 
-DEFUN ("read-event", Fread_event, Sread_event, 0, 2, 0,
+DEFUN ("read-event", Fread_event, Sread_event, 0, 3, 0,
        doc: /* Read an event object from the input stream.
 If the optional argument PROMPT is non-nil, display that as a prompt.
 If the optional argument INHERIT-INPUT-METHOD is non-nil and some
 input method is turned on in the current buffer, that input method
-is used for reading a character.  */)
-     (prompt, inherit_input_method)
-     Lisp_Object prompt, inherit_input_method;
+is used for reading a character.
+If the optional argument SECONDS is non-nil, it should be a number
+specifying the maximum number of seconds to wait for input.  If no
+input arrives in that time, return nil.  SECONDS may be a
+floating-point value.  */)
+     (prompt, inherit_input_method, seconds)
+     Lisp_Object prompt, inherit_input_method, seconds;
 {
   if (! NILP (prompt))
     message_with_string ("%s", prompt, 0);
-  return read_filtered_event (0, 0, 0, ! NILP (inherit_input_method));
+  return read_filtered_event (0, 0, 0, ! NILP (inherit_input_method), seconds);
 }
 
-DEFUN ("read-char-exclusive", Fread_char_exclusive, Sread_char_exclusive, 0, 2, 0,
+DEFUN ("read-char-exclusive", Fread_char_exclusive, Sread_char_exclusive, 0, 3, 0,
        doc: /* Read a character from the command input (keyboard or macro).
 It is returned as a number.  Non-character events are ignored.
 
 If the optional argument PROMPT is non-nil, display that as a prompt.
 If the optional argument INHERIT-INPUT-METHOD is non-nil and some
 input method is turned on in the current buffer, that input method
-is used for reading a character.  */)
-     (prompt, inherit_input_method)
-     Lisp_Object prompt, inherit_input_method;
+is used for reading a character.
+If the optional argument SECONDS is non-nil, it should be a number
+specifying the maximum number of seconds to wait for input.  If no
+input arrives in that time, return nil.  SECONDS may be a
+floating-point value.  */)
+     (prompt, inherit_input_method, seconds)
+     Lisp_Object prompt, inherit_input_method, seconds;
 {
   if (! NILP (prompt))
     message_with_string ("%s", prompt, 0);
-  return read_filtered_event (1, 1, 0, ! NILP (inherit_input_method));
+  return read_filtered_event (1, 1, 0, ! NILP (inherit_input_method), seconds);
 }
 
 DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
diff --git a/src/process.c b/src/process.c
index 45bf6446644..b218a952e5f 100644
--- a/src/process.c
+++ b/src/process.c
@@ -4157,6 +4157,14 @@ server_accept_connection (server, channel)
    when not inside wait_reading_process_output.  */
 static int waiting_for_user_input_p;
 
+static Lisp_Object
+wait_reading_process_output_unwind (data)
+     Lisp_Object data;
+{
+  waiting_for_user_input_p = XINT (data);
+  return Qnil;
+}
+
 /* This is here so breakpoints can be put on it.  */
 static void
 wait_reading_process_output_1 ()
@@ -4239,9 +4247,7 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
   EMACS_TIME timeout, end_time;
   int wait_channel = -1;
   int got_some_input = 0;
-  /* Either nil or a cons cell, the car of which is of interest and
-     may be changed outside of this routine.  */
-  int saved_waiting_for_user_input_p = waiting_for_user_input_p;
+  int count = SPECPDL_INDEX ();
 
   FD_ZERO (&Available);
 #ifdef NON_BLOCKING_CONNECT
@@ -4252,6 +4258,8 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
   if (wait_proc != NULL)
     wait_channel = XINT (wait_proc->infd);
 
+  record_unwind_protect (wait_reading_process_output_unwind,
+                         make_number (waiting_for_user_input_p));
   waiting_for_user_input_p = read_kbd;
 
   /* Since we may need to wait several times,
@@ -4878,7 +4886,7 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
         }                       /* end for each file descriptor */
     }                           /* end while exit conditions not met */
 
-  waiting_for_user_input_p = saved_waiting_for_user_input_p;
+  unbind_to (count, Qnil);
 
   /* If calling from keyboard input, do not quit
      since we want to return C-g as an input character.
diff --git a/src/puresize.h b/src/puresize.h
index 457a75ea023..bae7cbb6d6a 100644
--- a/src/puresize.h
+++ b/src/puresize.h
@@ -43,7 +43,7 @@ Boston, MA 02110-1301, USA.  */
 #endif
 
 #ifndef BASE_PURESIZE
-#define BASE_PURESIZE (1211000 + SYSTEM_PURESIZE_EXTRA + SITELOAD_PURESIZE_EXTRA)
+#define BASE_PURESIZE (1102000 + SYSTEM_PURESIZE_EXTRA + SITELOAD_PURESIZE_EXTRA)
 #endif
 
 /* Increase BASE_PURESIZE by a ratio depending on the machine's word size.  */
diff --git a/src/w32.c b/src/w32.c
index d01a1022a19..c093eab599e 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -2256,16 +2256,17 @@ convert_time (FILETIME ft)
 
       SystemTimeToFileTime (&st, &utc_base_ft);
       utc_base = (long double) utc_base_ft.dwHighDateTime
-        * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
+        * 4096.0L * 1024.0L * 1024.0L + utc_base_ft.dwLowDateTime;
       init = 1;
     }
 
   if (CompareFileTime (&ft, &utc_base_ft) < 0)
     return 0;
 
-  ret = (long double) ft.dwHighDateTime * 4096 * 1024 * 1024 + ft.dwLowDateTime;
+  ret = (long double) ft.dwHighDateTime
+    * 4096.0L * 1024.0L * 1024.0L + ft.dwLowDateTime;
   ret -= utc_base;
-  return (time_t) (ret * 1e-7);
+  return (time_t) (ret * 1e-7L);
 }
 
 void
diff --git a/src/w32fns.c b/src/w32fns.c
index b548c2c1efe..9c0198f288d 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -2067,6 +2067,7 @@ w32_createwindow (f)
 {
   HWND hwnd;
   RECT rect;
+  Lisp_Object top, left;
 
   rect.left = rect.top = 0;
   rect.right = FRAME_PIXEL_WIDTH (f);
@@ -2082,12 +2083,17 @@ w32_createwindow (f)
       w32_init_class (hinst);
     }
 
+  /* When called with RES_TYPE_NUMBER, w32_get_arg will return zero
+     for anything that is not a number and is not Qunbound.  */
+  left = w32_get_arg (Qnil, Qleft, "left", "Left", RES_TYPE_NUMBER);
+  top = w32_get_arg (Qnil, Qtop, "top", "Top", RES_TYPE_NUMBER);
+
   FRAME_W32_WINDOW (f) = hwnd
     = CreateWindow (EMACS_CLASS,
                     f->namebuf,
                     f->output_data.w32->dwStyle | WS_CLIPCHILDREN,
-                    CW_USEDEFAULT,
-                    SW_SHOW,
+                    EQ (left, Qunbound) ? CW_USEDEFAULT : XINT (left),
+                    EQ (top, Qunbound) ? CW_USEDEFAULT : XINT (top),
                     rect.right - rect.left,
                     rect.bottom - rect.top,
                     NULL,
diff --git a/src/xdisp.c b/src/xdisp.c
index b9b630d2e74..073b100694f 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -909,7 +909,7 @@ static void redisplay_window P_ ((Lisp_Object, int));
 static Lisp_Object redisplay_window_error ();
 static Lisp_Object redisplay_window_0 P_ ((Lisp_Object));
 static Lisp_Object redisplay_window_1 P_ ((Lisp_Object));
-static void update_menu_bar P_ ((struct frame *, int));
+static int update_menu_bar P_ ((struct frame *, int, int));
 static int try_window_reusing_current_matrix P_ ((struct window *));
 static int try_window_id P_ ((struct window *));
 static int display_line P_ ((struct it *));
@@ -9190,6 +9190,9 @@ prepare_menu_bars ()
     {
       Lisp_Object tail, frame;
       int count = SPECPDL_INDEX ();
+      /* 1 means that update_menu_bar has run its hooks
+         so any further calls to update_menu_bar shouldn't do so again.  */
+      int menu_bar_hooks_run = 0;
 
       record_unwind_save_match_data ();
 
@@ -9221,7 +9224,7 @@ prepare_menu_bars ()
             }
 
           GCPRO1 (tail);
-          update_menu_bar (f, 0);
+          menu_bar_hooks_run = update_menu_bar (f, 0, menu_bar_hooks_run);
 #ifdef HAVE_WINDOW_SYSTEM
           update_tool_bar (f, 0);
 #ifdef MAC_OS
@@ -9236,7 +9239,7 @@ prepare_menu_bars ()
   else
     {
       struct frame *sf = SELECTED_FRAME ();
-      update_menu_bar (sf, 1);
+      update_menu_bar (sf, 1, 0);
 #ifdef HAVE_WINDOW_SYSTEM
       update_tool_bar (sf, 1);
 #ifdef MAC_OS
@@ -9257,12 +9260,18 @@ prepare_menu_bars ()
    before we start to fill in any display lines, because it can call
    eval.
 
-   If SAVE_MATCH_DATA is non-zero, we must save and restore it here.  */
+   If SAVE_MATCH_DATA is non-zero, we must save and restore it here.
 
-static void
-update_menu_bar (f, save_match_data)
+   If HOOKS_RUN is 1, that means a previous call to update_menu_bar
+   already ran the menu bar hooks for this redisplay, so there
+   is no need to run them again.  The return value is the
+   updated value of this flag, to pass to the next call.  */
+
+static int
+update_menu_bar (f, save_match_data, hooks_run)
      struct frame *f;
      int save_match_data;
+     int hooks_run;
 {
   Lisp_Object window;
   register struct window *w;
@@ -9327,15 +9336,21 @@ update_menu_bar (f, save_match_data)
               specbind (Qoverriding_local_map, Qnil);
             }
 
-          /* Run the Lucid hook.  */
-          safe_run_hooks (Qactivate_menubar_hook);
+          if (!hooks_run)
+            {
+              /* Run the Lucid hook.  */
+              safe_run_hooks (Qactivate_menubar_hook);
+
+              /* If it has changed current-menubar from previous value,
+                 really recompute the menu-bar from the value.  */
+              if (! NILP (Vlucid_menu_bar_dirty_flag))
+                call0 (Qrecompute_lucid_menubar);
+
+              safe_run_hooks (Qmenu_bar_update_hook);
 
-          /* If it has changed current-menubar from previous value,
-             really recompute the menu-bar from the value.  */
-          if (! NILP (Vlucid_menu_bar_dirty_flag))
-            call0 (Qrecompute_lucid_menubar);
+              hooks_run = 1;
+            }
 
-          safe_run_hooks (Qmenu_bar_update_hook);
           FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
 
           /* Redisplay the menu bar in case we changed it.  */
@@ -9364,6 +9379,8 @@ update_menu_bar (f, save_match_data)
           set_buffer_internal_1 (prev);
         }
     }
+
+  return hooks_run;
 }
 
 
diff --git a/src/xfaces.c b/src/xfaces.c
index 6a05611939e..ea263929df6 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -6125,6 +6125,8 @@ lookup_named_face (f, symbol, signal_p)
       if (!realize_basic_faces (f))
         return -1;
       default_face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
+      if (default_face == NULL)
+        abort ();  /* realize_basic_faces must have set it up  */
     }
 
   if (!get_lface_attributes (f, symbol, symbol_attrs, signal_p))
@@ -6630,6 +6632,8 @@ face for italic.  */)
       if (! realize_basic_faces (f))
         error ("Cannot realize default face");
       def_face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
+      if (def_face == NULL)
+        abort ();  /* realize_basic_faces must have set it up  */
     }
 
   /* Dispatch to the appropriate handler.  */