Merged in changes from CVS head

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-5
   Add =cvs-sync-make-log script

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

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-7
   Use absolute tla-tools filenames in =cvs-sync-make-log

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-8
   Use proper arch-tag: syntax for lispintro/texinfo.tex

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


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

10 files changed, 335 insertions, 36 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index f471cc99230..121142703c9 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,46 @@
+2003-12-29  James Clark <jjc@jclark.com>  (tiny change)
+
+        * fns.c (internal_equal): Return t for two NaN arguments.
+
+2003-12-29  Richard M. Stallman  <rms@gnu.org>
+
+        * data.c (store_symval_forwarding): Handle setting
+        default-fill-column, etc., by changing the value in
+        buffers that use the default.
+
+        * minibuf.c (Fset_minibuffer_window): Doc fix.
+
+        * fileio.c (choose_write_coding_system): Ignore auto_saving
+        if using the visited file for auto saves.
+        (Fwrite_region): Don't update SAVE_MODIFF
+        if auto-saving in visited file.
+
+2003-12-29  Kenichi Handa  <handa@m17n.org>
+
+        * dispextern.h (face_font_available_p): Extern it.
+
+        * fontset.c (Voverriding_fontspec_alist): New variable.
+        (lookup_overriding_fontspec): New function.
+        (fontset_ref_via_base): Call lookup_overriding_fontspec if
+        necessary.
+        (fontset_font_pattern): Likewise.
+        (regulalize_fontname): New function.
+        (Fset_fontset_font): Call regulalize_fontname.
+        (Fset_overriding_fontspec_internal): New function.
+        (syms_of_fontset): Initialize and staticprop
+        Voverriding_fontspec_alist. Defsubr
+        Sset_overriding_fontspec_internal.
+
+        * xfaces.c (face_font_available_p): New function.
+
+2003-12-28  Richard M. Stallman  <rms@gnu.org>
+
+        * buffer.c (Fother_buffer): Don't crash if BUF is nil
+        or if its name is nil.
+
+        * buffer.c (Fkill_buffer): Don't delete auto-save file
+        if it's the same as the visited file.
+
 2003-12-28  Luc Teirlinck  <teirllm@auburn.edu>
 
         * coding.c (Fcheck_coding_system): Doc fix.
diff --git a/src/buffer.h b/src/buffer.h
index 14d3aa6d5ee..930424b0b49 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -906,8 +906,26 @@ extern int last_per_buffer_idx;
        (B)->local_flags[IDX] = (VAL);                   \
      } while (0)
 
-/* Return the index of the per-buffer variable at offset OFFSET in the
-   buffer structure.  */
+/* Return the index value of the per-buffer variable at offset OFFSET
+   in the buffer structure.
+
+   If the slot OFFSET has a corresponding default value in
+   buffer_defaults, the index value is positive and has only one
+   nonzero bit.  When a buffer has its own local value for a slot, the
+   bit for that slot (found in the same slot in this structure) is
+   turned on in the buffer's local_flags array.
+
+   If the index value is -1, even though there may be a
+   DEFVAR_PER_BUFFER for the slot, there is no default value for it;
+   and the corresponding slot in buffer_defaults is not used.
+
+   If the index value is -2, then there is no DEFVAR_PER_BUFFER for
+   the slot, but there is a default value which is copied into each
+   new buffer.
+
+   If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
+   zero, that is a bug */
+
 
 #define PER_BUFFER_IDX(OFFSET) \
       XINT (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_flags))
diff --git a/src/data.c b/src/data.c
index a246271c1f6..c4e3937f3fa 100644
--- a/src/data.c
+++ b/src/data.c
@@ -873,6 +873,8 @@ store_symval_forwarding (symbol, valcontents, newval, buf)
      register Lisp_Object valcontents, newval;
      struct buffer *buf;
 {
+  int offset;
+
   switch (SWITCH_ENUM_CAST (XTYPE (valcontents)))
     {
     case Lisp_Misc:
@@ -892,6 +894,36 @@ store_symval_forwarding (symbol, valcontents, newval, buf)
 
         case Lisp_Misc_Objfwd:
           *XOBJFWD (valcontents)->objvar = newval;
+
+          /* If this variable is a default for something stored
+             in the buffer itself, such as default-fill-column,
+             find the buffers that don't have local values for it
+             and update them.  */
+          if (XOBJFWD (valcontents)->objvar > (Lisp_Object *) &buffer_defaults
+              && XOBJFWD (valcontents)->objvar < (Lisp_Object *) (&buffer_defaults + 1))
+            {
+              int offset = ((char *) XOBJFWD (valcontents)->objvar
+                            - (char *) &buffer_defaults);
+              int idx = PER_BUFFER_IDX (offset);
+
+              Lisp_Object tail, buf;
+
+              if (idx <= 0)
+                break;
+
+              for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
+                {
+                  Lisp_Object buf;
+                  struct buffer *b;
+
+                  buf = Fcdr (XCAR (tail));
+                  if (!BUFFERP (buf)) continue;
+                  b = XBUFFER (buf);
+
+                  if (! PER_BUFFER_VALUE_P (b, idx))
+                    PER_BUFFER_VALUE (b, offset) = newval;
+                }
+            }
           break;
 
         case Lisp_Misc_Buffer_Objfwd:
diff --git a/src/dispextern.h b/src/dispextern.h
index cb0a7a7d91d..e53f36d4a01 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -2582,6 +2582,7 @@ void clear_face_cache P_ ((int));
 unsigned long load_color P_ ((struct frame *, struct face *, Lisp_Object,
                               enum lface_attribute_index));
 void unload_color P_ ((struct frame *, unsigned long));
+int face_font_available_p P_ ((struct frame *, Lisp_Object));
 int ascii_face_of_lisp_face P_ ((struct frame *, int));
 void prepare_face_for_display P_ ((struct frame *, struct face *));
 int xstricmp P_ ((const unsigned char *, const unsigned char *));
diff --git a/src/eval.c b/src/eval.c
index e5dba1b888f..8a6d0d3ff54 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -2641,6 +2641,8 @@ call6 (fn, arg1, arg2, arg3, arg4, arg5, arg6)
 #endif /* not NO_ARG_ARRAY */
 }
 
+/* The caller should GCPRO all the elements of ARGS.  */
+
 DEFUN ("funcall", Ffuncall, Sfuncall, 1, MANY, 0,
        doc: /* Call first argument as a function, passing remaining arguments to it.
 Return the value that function returns.
diff --git a/src/fileio.c b/src/fileio.c
index e586407cecc..a2b207169cf 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -4685,7 +4685,9 @@ choose_write_coding_system (start, end, filename,
 {
   Lisp_Object val;
 
-  if (auto_saving)
+  if (auto_saving
+      && NILP (Fstring_equal (current_buffer->filename,
+                              current_buffer->auto_save_file_name)))
     {
       /* We use emacs-mule for auto saving... */
       setup_coding_system (Qemacs_mule, coding);
@@ -5221,7 +5223,14 @@ This does code conversion according to the value of
       update_mode_lines++;
     }
   else if (quietly)
-    return Qnil;
+    {
+      if (auto_saving
+          && ! NILP (Fstring_equal (current_buffer->filename,
+                                    current_buffer->auto_save_file_name)))
+        SAVE_MODIFF = MODIFF;
+
+      return Qnil;
+    }
 
   if (!auto_saving)
     message_with_string ((INTEGERP (append)
@@ -5776,11 +5785,14 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
   minibuffer_auto_raise = 0;
   auto_saving = 1;
 
-  /* First, save all files which don't have handlers.  If Emacs is
-     crashing, the handlers may tweak what is causing Emacs to crash
-     in the first place, and it would be a shame if Emacs failed to
-     autosave perfectly ordinary files because it couldn't handle some
-     ange-ftp'd file.  */
+  /* On first pass, save all files that don't have handlers.
+     On second pass, save all files that do have handlers.
+
+     If Emacs is crashing, the handlers may tweak what is causing
+     Emacs to crash in the first place, and it would be a shame if
+     Emacs failed to autosave perfectly ordinary files because it
+     couldn't handle some ange-ftp'd file.  */
+
   for (do_handled_files = 0; do_handled_files < 2; do_handled_files++)
     for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCDR (tail))
       {
diff --git a/src/fns.c b/src/fns.c
index e4252c98ca5..ff40c706edd 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2169,7 +2169,15 @@ internal_equal (o1, o2, depth)
   switch (XTYPE (o1))
     {
     case Lisp_Float:
-      return (extract_float (o1) == extract_float (o2));
+      {
+        double d1, d2;
+
+        d1 = extract_float (o1);
+        d2 = extract_float (o2);
+        /* If d is a NaN, then d != d. Two NaNs should be `equal' even
+           though they are not =. */
+        return d1 == d2 || (d1 != d1 && d2 != d2);
+      }
 
     case Lisp_Cons:
       if (!internal_equal (XCAR (o1), XCAR (o2), depth + 1))
diff --git a/src/fontset.c b/src/fontset.c
index e462387beae..b199f53df17 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -140,6 +140,10 @@ static int next_fontset_id;
    font for each characters.  */
 static Lisp_Object Vdefault_fontset;
 
+/* Alist of font specifications.  It override the font specification
+   in the default fontset.  */
+static Lisp_Object Voverriding_fontspec_alist;
+
 Lisp_Object Vfont_encoding_alist;
 Lisp_Object Vuse_default_ascent;
 Lisp_Object Vignore_relative_composition;
@@ -184,11 +188,13 @@ void (*check_window_system_func) P_ ((void));
 
 /* Prototype declarations for static functions.  */
 static Lisp_Object fontset_ref P_ ((Lisp_Object, int));
+static Lisp_Object lookup_overriding_fontspec P_ ((Lisp_Object, int));
 static void fontset_set P_ ((Lisp_Object, int, Lisp_Object));
 static Lisp_Object make_fontset P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
 static int fontset_id_valid_p P_ ((int));
 static Lisp_Object fontset_pattern_regexp P_ ((Lisp_Object));
 static Lisp_Object font_family_registry P_ ((Lisp_Object, int));
+static Lisp_Object regulalize_fontname P_ ((Lisp_Object));
 
 
 /********** MACROS AND FUNCTIONS TO HANDLE FONTSET **********/
@@ -241,6 +247,46 @@ fontset_ref (fontset, c)
 }
 
 
+static Lisp_Object
+lookup_overriding_fontspec (frame, c)
+     Lisp_Object frame;
+     int c;
+{
+  Lisp_Object tail;
+
+  for (tail = Voverriding_fontspec_alist; CONSP (tail); tail = XCDR (tail))
+    {
+      Lisp_Object val, target, elt;
+
+      val = XCAR (tail);
+      target = XCAR (val);
+      val = XCDR (val);
+      /* Now VAL is (NO-FRAME-LIST OK-FRAME-LIST CHAR FONTNAME).  */
+      if (NILP (Fmemq (frame, XCAR (val)))
+          && (CHAR_TABLE_P (target)
+              ? ! NILP (CHAR_TABLE_REF (target, c))
+              : XINT (target) == CHAR_CHARSET (c)))
+        {
+          val = XCDR (val);
+          elt = XCDR (val);
+          if (NILP (Fmemq (frame, XCAR (val))))
+            {
+              if (! face_font_available_p (XFRAME (frame), XCDR (elt)))
+                {
+                  val = XCDR (XCAR (tail));
+                  XSETCAR (val, Fcons (frame, XCAR (val)));
+                  continue;
+                }
+              XSETCAR (val, Fcons (frame, XCAR (val)));
+            }
+          if (NILP (XCAR (elt)))
+            XSETCAR (elt, make_number (c));
+          return elt;
+        }
+    }
+  return Qnil;
+}
+
 #define FONTSET_REF_VIA_BASE(fontset, c) fontset_ref_via_base (fontset, &c)
 
 static Lisp_Object
@@ -254,8 +300,12 @@ fontset_ref_via_base (fontset, c)
   if (SINGLE_BYTE_CHAR_P (*c))
     return FONTSET_ASCII (fontset);
 
-  elt = FONTSET_REF (FONTSET_BASE (fontset), *c);
-  if (NILP (elt) && ! EQ (fontset, Vdefault_fontset))
+  elt = Qnil;
+  if (! EQ (FONTSET_BASE (fontset), Vdefault_fontset))
+    elt = FONTSET_REF (FONTSET_BASE (fontset), *c);
+  if (NILP (elt))
+    elt = lookup_overriding_fontspec (FONTSET_FRAME (fontset), *c);
+  if (NILP (elt) && ! EQ (FONTSET_BASE (fontset), Vdefault_fontset))
     elt = FONTSET_REF (Vdefault_fontset, *c);
   if (NILP (elt))
     return Qnil;
@@ -551,6 +601,13 @@ fontset_font_pattern (f, id, c)
       elt = FONTSET_REF (fontset, c);
     }
   if (NILP (elt))
+    {
+      Lisp_Object frame;
+
+      XSETFRAME (frame, f);
+      elt = lookup_overriding_fontspec (frame, c);
+    }
+  if (NILP (elt))
     elt = FONTSET_REF (Vdefault_fontset, c);
 
   if (!CONSP (elt))
@@ -980,6 +1037,33 @@ check_fontset_name (name)
   return FONTSET_FROM_ID (id);
 }
 
+/* Downcase FONTNAME or car and cdr of FONTNAME.  If FONTNAME is a
+   string, maybe change FONTNAME to (FAMILY . REGISTRY).  */
+
+static Lisp_Object
+regulalize_fontname (Lisp_Object fontname)
+{
+  Lisp_Object family, registry;
+
+  if (STRINGP (fontname))
+    return font_family_registry (Fdowncase (fontname), 0);
+
+  CHECK_CONS (fontname);
+  family = XCAR (fontname);
+  registry = XCDR (fontname);
+  if (!NILP (family))
+    {
+      CHECK_STRING (family);
+      family = Fdowncase (family);
+    }
+  if (!NILP (registry))
+    {
+      CHECK_STRING (registry);
+      registry = Fdowncase (registry);
+    }
+  return Fcons (family, registry);
+}
+
 DEFUN ("set-fontset-font", Fset_fontset_font, Sset_fontset_font, 3, 4, 0,
        doc: /* Modify fontset NAME to use FONTNAME for CHARACTER.
 
@@ -1043,34 +1127,12 @@ name of a font, REGISTRY is a registry name of a font.  */)
         error ("Can't change font for a single byte character");
     }
 
-  if (STRINGP (fontname))
-    {
-      fontname = Fdowncase (fontname);
-      elt = Fcons (make_number (from), font_family_registry (fontname, 0));
-    }
-  else
-    {
-      CHECK_CONS (fontname);
-      family = XCAR (fontname);
-      registry = XCDR (fontname);
-      if (!NILP (family))
-        {
-          CHECK_STRING (family);
-          family = Fdowncase (family);
-        }
-      if (!NILP (registry))
-        {
-          CHECK_STRING (registry);
-          registry = Fdowncase (registry);
-        }
-      elt = Fcons (make_number (from), Fcons (family, registry));
-    }
-
   /* The arg FRAME is kept for backward compatibility.  We only check
      the validity.  */
   if (!NILP (frame))
     CHECK_LIVE_FRAME (frame);
 
+  elt = Fcons (make_number (from), regulalize_fontname (fontname));
   for (; from <= to; from++)
     FONTSET_SET (fontset, from, elt);
   Foptimize_char_table (fontset);
@@ -1445,6 +1507,60 @@ DEFUN ("fontset-list", Ffontset_list, Sfontset_list, 0, 0, 0,
   return list;
 }
 
+DEFUN ("set-overriding-fontspec-internal", Fset_overriding_fontspec_internal,
+       Sset_overriding_fontspec_internal, 1, 1, 0,
+       doc: /* Internal use only.
+
+FONTLIST is an alist of TARGET vs FONTNAME, where TARGET is a charset
+or a char-table, FONTNAME have the same meanings as in
+`set-fontset-font'.
+
+It overrides the font specifications for each TARGET in the default
+fontset by the corresponding FONTNAME.
+
+If TARGET is a charset, targets are all characters in the charset.  If
+TARGET is a char-table, targets are characters whose value is non-nil
+in the table.
+
+It is intended that this function is called only from
+`set-language-environment'.  */)
+     (fontlist)
+     Lisp_Object fontlist;
+{
+  Lisp_Object tail;
+
+  fontlist = Fcopy_sequence (fontlist);
+  /* Now FONTLIST is ((TARGET . FONTNAME) ...).  Reform it to ((TARGET
+     nil nil nil FONTSPEC) ...), where TARGET is a charset-id or a
+     char-table.  */
+  for (tail = fontlist; CONSP (tail); tail = XCDR (tail))
+    {
+      Lisp_Object elt, target;
+
+      elt = XCAR (tail);
+      target = Fcar (elt);
+      elt = Fcons (Qnil, regulalize_fontname (Fcdr (elt)));
+      if (! CHAR_TABLE_P (target))
+        {
+          int charset, c;
+
+          CHECK_SYMBOL (target);
+          charset = get_charset_id (target);
+          if (charset < 0)
+            error ("Invalid charset %s", SDATA (SYMBOL_NAME (target)));
+          target = make_number (charset);
+          c = MAKE_CHAR (charset, 0, 0);
+          XSETCAR (elt, make_number (c));
+        }
+      elt = Fcons (target, Fcons (Qnil, Fcons (Qnil, elt)));
+      XSETCAR (tail, elt);
+    }
+  Voverriding_fontspec_alist = fontlist;
+  clear_face_cache (0);
+  ++windows_or_buffers_changed;
+  return Qnil;
+}
+
 void
 syms_of_fontset ()
 {
@@ -1483,6 +1599,9 @@ syms_of_fontset ()
   AREF (Vfontset_table, 0) = Vdefault_fontset;
   next_fontset_id = 1;
 
+  Voverriding_fontspec_alist = Qnil;
+  staticpro (&Voverriding_fontspec_alist);
+
   DEFVAR_LISP ("font-encoding-alist", &Vfont_encoding_alist,
                doc: /* Alist of fontname patterns vs corresponding encoding info.
 Each element looks like (REGEXP . ENCODING-INFO),
@@ -1548,6 +1667,7 @@ at the vertical center of lines.  */);
   defsubr (&Sfontset_info);
   defsubr (&Sfontset_font);
   defsubr (&Sfontset_list);
+  defsubr (&Sset_overriding_fontspec_internal);
 }
 
 /* arch-tag: ea861585-2f5f-4e5b-9849-d04a9c3a3537
diff --git a/src/minibuf.c b/src/minibuf.c
index baeb0cef7b5..9a05a4d1ce0 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -189,7 +189,7 @@ choose_minibuf_frame_1 (ignore)
 DEFUN ("set-minibuffer-window", Fset_minibuffer_window,
        Sset_minibuffer_window, 1, 1, 0,
        doc: /* Specify which minibuffer window to use for the minibuffer.
-This effects where the minibuffer is displayed if you put text in it
+This affects where the minibuffer is displayed if you put text in it
 without invoking the usual minibuffer commands.  */)
      (window)
      Lisp_Object window;
diff --git a/src/xfaces.c b/src/xfaces.c
index 84d49e30a9b..47f406d7012 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -2564,6 +2564,69 @@ x_face_list_fonts (f, pattern, pfonts, nfonts, try_alternatives_p)
 }
 
 
+/* Check if a font matching pattern_offset_t on frame F is available
+   or not.  PATTERN may be a cons (FAMILY . REGISTRY), in which case,
+   a font name pattern is generated from FAMILY and REGISTRY.  */
+
+int
+face_font_available_p (f, pattern)
+     struct frame *f;
+     Lisp_Object pattern;
+{
+  Lisp_Object fonts;
+
+  if (! STRINGP (pattern))
+    {
+      Lisp_Object family, registry;
+      char *family_str, *registry_str, *pattern_str;
+
+      CHECK_CONS (pattern);
+      family = XCAR (pattern);
+      if (NILP (family))
+        family_str = "*";
+      else
+        {
+          CHECK_STRING (family);
+          family_str = (char *) SDATA (family);
+        }
+      registry = XCDR (pattern);
+      if (NILP (registry))
+        registry_str = "*";
+      else
+        {
+          CHECK_STRING (registry);
+          registry_str = (char *) SDATA (registry);
+        }
+
+      pattern_str = (char *) alloca (strlen (family_str)
+                                     + strlen (registry_str)
+                                     + 10);
+      strcpy (pattern_str, index (family_str, '-') ? "-" : "-*-");
+      strcat (pattern_str, family_str);
+      strcat (pattern_str, "-*-");
+      strcat (pattern_str, registry_str);
+      if (!index (registry_str, '-'))
+        {
+          if (registry_str[strlen (registry_str) - 1] == '*')
+            strcat (pattern_str, "-*");
+          else
+            strcat (pattern_str, "*-*");
+        }
+      pattern = build_string (pattern_str);
+    }
+
+  /* Get the list of fonts matching PATTERN.  */
+#ifdef WINDOWSNT
+  BLOCK_INPUT;
+  fonts = w32_list_fonts (f, pattern, 0, 1);
+  UNBLOCK_INPUT;
+#else
+  fonts = x_list_fonts (f, pattern, -1, 1);
+#endif
+  return XINT (Flength (fonts));
+}
+
+
 /* Determine fonts matching PATTERN on frame F.  Sort resulting fonts
    using comparison function CMPFN.  Value is the number of fonts
    found.  If value is non-zero, *FONTS is set to a vector of