Merged in changes from CVS trunk.

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-344
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-345
   Tweak source regexps so that building in place won't cause problems

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-346
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-347
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-348
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-349
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-350
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-351
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-352
   Update from CVS: lisp/flymake.el: New file.


git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-182

7 files changed, 125 insertions, 127 deletions

diff --git a/src/.arch-inventory b/src/.arch-inventory
new file mode 100644
index 00000000000..9f6d601a788
--- /dev/null
+++ b/src/.arch-inventory
@@ -0,0 +1,3 @@
+precious ^(config\.stamp|config\.h|epaths\.h)$
+
+# arch-tag: 277cc7ae-b3f5-44af-abf1-84c073164543
diff --git a/src/ChangeLog b/src/ChangeLog
index f15b1e582d9..df10f95e500 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,35 @@
+2004-05-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * alloc.c: Undo Kim's recent changes and fix the same bug differently.
+        (marker_blocks_pending_free): Remove.
+        (Fgarbage_collect): Sweep after cleaning up undo-lists.
+        Mark the undo lists after claning them up.
+        Don't free block in marker_blocks_pending_free.
+        (mark_buffer): Don't mark undo_list.
+        (gc_sweep): Sweep hash-tables and strings first.
+        Do free marker blocks that are empty.
+
+2004-05-28  Jim Blandy  <jimb@redhat.com>
+
+        * regex.c (print_partial_compiled_pattern): Add missing 'break'
+        after 'case wordend'.  For symbeg and symend, print to stderr,
+        like the other cases.
+
+2004-05-28  Noah Friedman  <friedman@splode.com>
+
+        * process.c (Fdelete_process): Do not call remove_process.
+
+2004-05-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * alloc.c (struct backtrace): Remove.
+        (Fgarbage_collect): Use the new mark_backtrace.
+
+        * eval.c (mark_backtrace): New function.
+
+        * minibuf.c (run_exit_minibuf_hook): New function.
+        (read_minibuf_unwind): Don't run exit-minibuffer-hook any more.
+        (read_minibuf): Use separate unwind handler to run exit-minibuf-hook.
+
 2004-05-27  Kim F. Storm  <storm@cua.dk>
 
         * xdisp.c (back_to_previous_visible_line_start): Skip backwards
@@ -15,8 +47,8 @@
 
 2004-05-23  K,Ba(Broly L,Bu(Brentey  <lorentey@elte.hu>  (tiny change)
 
-        * coding.c (Fset_safe_terminal_coding_system_internal): Set
-        suppress_error in safe_terminal_coding, not terminal_coding.
+        * coding.c (Fset_safe_terminal_coding_system_internal):
+        Set suppress_error in safe_terminal_coding, not terminal_coding.
 
 2004-05-22  Richard M. Stallman  <rms@gnu.org>
 
@@ -71,7 +103,7 @@
         (re_opcode_t): New opcodes `symbeg' and `symend'.
         (print_partial_compiled_pattern): Print the new opcodes properly.
         (regex_compile): Parse the new operators.
-        (analyse_first): Skip symbeg and symend (they match only the empty string).
+        (analyse_first): Skip sym(beg|end) (they match only the empty string).
         (mutually_exclusive_p): `symend' is mutually exclusive with \s_ and
         \sw; `symbeg' is mutually exclusive with \S_ and \Sw.
         (re_match_2_internal): Match symbeg and symend.
diff --git a/src/alloc.c b/src/alloc.c
index 1d50f19e921..adedb414aad 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -257,6 +257,7 @@ EMACS_INT gcs_done;		/* accumulated GCs  */
 static void mark_buffer P_ ((Lisp_Object));
 extern void mark_kboards P_ ((void));
 extern void mark_ttys P_ ((void));
+extern void mark_backtrace P_ ((void));
 static void gc_sweep P_ ((void));
 static void mark_glyph_matrix P_ ((struct glyph_matrix *));
 static void mark_face_cache P_ ((struct face_cache *));
@@ -2866,10 +2867,6 @@ int marker_block_index;
 
 union Lisp_Misc *marker_free_list;
 
-/* Marker blocks which should be freed at end of GC.  */
-
-struct marker_block *marker_blocks_pending_free;
-
 /* Total number of marker blocks now in use.  */
 
 int n_marker_blocks;
@@ -2880,7 +2877,6 @@ init_marker ()
   marker_block = NULL;
   marker_block_index = MARKER_BLOCK_SIZE;
   marker_free_list = 0;
-  marker_blocks_pending_free = 0;
   n_marker_blocks = 0;
 }
 
@@ -4283,20 +4279,6 @@ struct catchtag
     struct catchtag *next;
 };
 
-struct backtrace
-{
-  struct backtrace *next;
-  Lisp_Object *function;
-  Lisp_Object *args;    /* Points to vector of args.  */
-  int nargs;            /* Length of vector.  */
-  /* If nargs is UNEVALLED, args points to slot holding list of
-     unevalled args.  */
-  char evalargs;
-  /* Nonzero means call value of debugger when done with this operation. */
-  char debug_on_exit;
-};
-
-
 
 /***********************************************************************
                           Protection from GC
@@ -4331,7 +4313,6 @@ returns nil, because real GC can't be done.  */)
   register struct specbinding *bind;
   struct catchtag *catch;
   struct handler *handler;
-  register struct backtrace *backlist;
   char stack_top_variable;
   register int i;
   int message_p;
@@ -4460,17 +4441,7 @@ returns nil, because real GC can't be done.  */)
       mark_object (handler->handler);
       mark_object (handler->var);
     }
-  for (backlist = backtrace_list; backlist; backlist = backlist->next)
-    {
-      mark_object (*backlist->function);
-
-      if (backlist->nargs == UNEVALLED || backlist->nargs == MANY)
-        i = 0;
-      else
-        i = backlist->nargs - 1;
-      for (; i >= 0; i--)
-        mark_object (backlist->args[i]);
-    }
+  mark_backtrace ();
   mark_kboards ();
   mark_ttys ();
 
@@ -4485,42 +4456,36 @@ returns nil, because real GC can't be done.  */)
   }
 #endif
 
-  gc_sweep ();
-
-  /* Look thru every buffer's undo list for elements that used to
-     contain update markers that were changed to Lisp_Misc_Free
-     objects and delete them.  This may leave a few cons cells
-     unchained, but we will get those on the next sweep.  */
+  /* Everything is now marked, except for the things that require special
+     finalization, i.e. the undo_list.
+     Look thru every buffer's undo list
+     for elements that update markers that were not marked,
+     and delete them.  */
   {
     register struct buffer *nextb = all_buffers;
 
     while (nextb)
       {
         /* If a buffer's undo list is Qt, that means that undo is
-           turned off in that buffer.  */
+           turned off in that buffer.  Calling truncate_undo_list on
+           Qt tends to return NULL, which effectively turns undo back on.
+           So don't call truncate_undo_list if undo_list is Qt.  */
         if (! EQ (nextb->undo_list, Qt))
           {
-            Lisp_Object tail, prev, elt, car;
+            Lisp_Object tail, prev;
             tail = nextb->undo_list;
             prev = Qnil;
             while (CONSP (tail))
               {
-                if ((elt = XCAR (tail), GC_CONSP (elt))
-                    && (car = XCAR (elt), GC_MISCP (car))
-                    && XMISCTYPE (car) == Lisp_Misc_Free)
+                if (GC_CONSP (XCAR (tail))
+                    && GC_MARKERP (XCAR (XCAR (tail)))
+                    && !XMARKER (XCAR (XCAR (tail)))->gcmarkbit)
                   {
-                    Lisp_Object cdr = XCDR (tail);
-                    /* Do not use free_cons here, as we don't know if
-                       anybody else has a pointer to these conses.  */
-                    XSETCAR (elt, Qnil);
-                    XSETCDR (elt, Qnil);
-                    XSETCAR (tail, Qnil);
-                    XSETCDR (tail, Qnil);
                     if (NILP (prev))
-                      nextb->undo_list = tail = cdr;
+                      nextb->undo_list = tail = XCDR (tail);
                     else
                       {
-                        tail = cdr;
+                        tail = XCDR (tail);
                         XSETCDR (prev, tail);
                       }
                   }
@@ -4531,22 +4496,15 @@ returns nil, because real GC can't be done.  */)
                   }
               }
           }
+        /* Now that we have stripped the elements that need not be in the
+           undo_list any more, we can finally mark the list.  */
+        mark_object (nextb->undo_list);
 
         nextb = nextb->next;
       }
   }
 
-  /* Undo lists have been cleaned up, so we can free marker blocks now.  */
-
-  {
-    struct marker_block *mblk;
-
-    while ((mblk = marker_blocks_pending_free) != 0)
-      {
-        marker_blocks_pending_free = mblk->next;
-        lisp_free (mblk);
-      }
-  }
+  gc_sweep ();
 
   /* Clear the mark bits that we set in certain root slots.  */
 
@@ -5114,41 +5072,9 @@ mark_buffer (buf)
 
   MARK_INTERVAL_TREE (BUF_INTERVALS (buffer));
 
-  if (CONSP (buffer->undo_list))
-    {
-      Lisp_Object tail;
-      tail = buffer->undo_list;
-
-      /* We mark the undo list specially because
-         its pointers to markers should be weak.  */
-
-      while (CONSP (tail))
-        {
-          register struct Lisp_Cons *ptr = XCONS (tail);
-
-          if (CONS_MARKED_P (ptr))
-            break;
-          CONS_MARK (ptr);
-          if (GC_CONSP (ptr->car)
-              && !CONS_MARKED_P (XCONS (ptr->car))
-              && GC_MARKERP (XCAR (ptr->car)))
-            {
-              CONS_MARK (XCONS (ptr->car));
-              mark_object (XCDR (ptr->car));
-            }
-          else
-            mark_object (ptr->car);
-
-          if (CONSP (ptr->cdr))
-            tail = ptr->cdr;
-          else
-            break;
-        }
-
-      mark_object (XCDR (tail));
-    }
-  else
-    mark_object (buffer->undo_list);
+  /* For now, we just don't mark the undo_list.  It's done later in
+     a special way just before the sweep phase, and after stripping
+     some of its elements that are not needed any more.  */
 
   if (buffer->overlays_before)
     {
@@ -5228,6 +5154,16 @@ survives_gc_p (obj)
 static void
 gc_sweep ()
 {
+  /* Remove or mark entries in weak hash tables.
+     This must be done before any object is unmarked.  */
+  sweep_weak_hash_tables ();
+
+  sweep_strings ();
+#ifdef GC_CHECK_STRING_BYTES
+  if (!noninteractive)
+    check_string_bytes (1);
+#endif
+
   /* Put all unmarked conses on free list */
   {
     register struct cons_block *cblk;
@@ -5278,16 +5214,6 @@ gc_sweep ()
     total_free_conses = num_free;
   }
 
-  /* Remove or mark entries in weak hash tables.
-     This must be done before any object is unmarked.  */
-  sweep_weak_hash_tables ();
-
-  sweep_strings ();
-#ifdef GC_CHECK_STRING_BYTES
-  if (!noninteractive)
-    check_string_bytes (1);
-#endif
-
   /* Put all unmarked floats on free list */
   {
     register struct float_block *fblk;
@@ -5456,7 +5382,6 @@ gc_sweep ()
     register int num_free = 0, num_used = 0;
 
     marker_free_list = 0;
-    marker_blocks_pending_free = 0;
 
     for (mblk = marker_block; mblk; mblk = *mprev)
       {
@@ -5492,13 +5417,8 @@ gc_sweep ()
             *mprev = mblk->next;
             /* Unhook from the free list.  */
             marker_free_list = mblk->markers[0].u_free.chain;
+            lisp_free (mblk);
             n_marker_blocks--;
-
-            /* It is not safe to free the marker block at this stage,
-               since there may still be pointers to these markers from
-               a buffer's undo list.  KFS 2004-05-25.  */
-            mblk->next = marker_blocks_pending_free;
-            marker_blocks_pending_free = mblk;
           }
         else
           {
diff --git a/src/eval.c b/src/eval.c
index 0326a828a81..921a7533a60 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -3243,6 +3243,25 @@ If NFRAMES is more than the number of frames, the value is nil.  */)
 
 
 void
+mark_backtrace ()
+{
+  register struct backtrace *backlist;
+  register int i;
+
+  for (backlist = backtrace_list; backlist; backlist = backlist->next)
+    {
+      mark_object (*backlist->function);
+
+      if (backlist->nargs == UNEVALLED || backlist->nargs == MANY)
+        i = 0;
+      else
+        i = backlist->nargs - 1;
+      for (; i >= 0; i--)
+        mark_object (backlist->args[i]);
+    }
+}
+
+void
 syms_of_eval ()
 {
   DEFVAR_INT ("max-specpdl-size", &max_specpdl_size,
diff --git a/src/minibuf.c b/src/minibuf.c
index 1f5a114540d..8ed19516080 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1,5 +1,5 @@
 /* Minibuffer input and completion.
-   Copyright (C) 1985,86,93,94,95,96,97,98,99,2000,01,03
+   Copyright (C) 1985,86,93,94,95,96,97,98,99,2000,01,03,04
              Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -210,6 +210,7 @@ without invoking the usual minibuffer commands.  */)
 /* Actual minibuffer invocation. */
 
 static Lisp_Object read_minibuf_unwind P_ ((Lisp_Object));
+static Lisp_Object run_exit_minibuf_hook P_ ((Lisp_Object));
 static Lisp_Object read_minibuf P_ ((Lisp_Object, Lisp_Object,
                                      Lisp_Object, Lisp_Object,
                                      int, Lisp_Object,
@@ -564,6 +565,12 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
 
   record_unwind_protect (read_minibuf_unwind, Qnil);
   minibuf_level++;
+  /* We are exiting the minibuffer one way or the other, so run the hook.
+     It should be run before unwinding the minibuf settings.  Do it
+     separately from read_minibuf_unwind because we need to make sure that
+     read_minibuf_unwind is fully executed even if exit-minibuffer-hook
+     signals an error.  --Stef  */
+  record_unwind_protect (run_exit_minibuf_hook, Qnil);
 
   /* Now that we can restore all those variables, start changing them.  */
 
@@ -827,6 +834,17 @@ get_minibuffer (depth)
   return buf;
 }
 
+static Lisp_Object
+run_exit_minibuf_hook (data)
+     Lisp_Object data;
+{
+  if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
+      && !NILP (Vrun_hooks))
+    safe_run_hooks (Qminibuffer_exit_hook);
+
+  return Qnil;
+}
+
 /* This function is called on exiting minibuffer, whether normally or
    not, and it restores the current window, buffer, etc. */
 
@@ -837,12 +855,6 @@ read_minibuf_unwind (data)
   Lisp_Object old_deactivate_mark;
   Lisp_Object window;
 
-  /* We are exiting the minibuffer one way or the other,
-     so run the hook.  */
-  if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
-      && !NILP (Vrun_hooks))
-    safe_run_hooks (Qminibuffer_exit_hook);
-
   /* If this was a recursive minibuffer,
      tie the minibuffer window back to the outer level minibuffer buffer.  */
   minibuf_level--;
diff --git a/src/process.c b/src/process.c
index 9d76b5bd1f9..c05bcbf88d5 100644
--- a/src/process.c
+++ b/src/process.c
@@ -774,7 +774,18 @@ nil, indicating the current buffer's process.  */)
       XSETINT (XPROCESS (process)->tick, ++process_tick);
       status_notify ();
     }
-  remove_process (process);
+  /* Do not call remove_process here; either status_notify has already done
+     it, or will do so the next time emacs polls for input.  Thus network
+     processes are not immediately removed, and their sentinel will be
+     called.
+
+     Since Fdelete_process is called by kill_buffer_processes, this also
+     means that a network process sentinel will run after the buffer is
+     dead, which would not be the case if status_notify() were called
+     unconditionally here.  This way process sentinels observe consistent
+     behavior with regard to buffer-live-p.
+  */
+  /* remove_process (process); */
   return Qnil;
 }
 
diff --git a/src/regex.c b/src/regex.c
index 0c1343bf584..db69275c312 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -1096,13 +1096,14 @@ print_partial_compiled_pattern (start, end)
 
         case wordend:
           fprintf (stderr, "/wordend");
+          break;
 
         case symbeg:
-          printf ("/symbeg");
+          fprintf (stderr, "/symbeg");
           break;
 
         case symend:
-          printf ("/symend");
+          fprintf (stderr, "/symend");
           break;
 
         case syntaxspec: