Merged in changes from CVS trunk.

Patches applied:

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

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-410
   Make sure image types are initialized for lookup too

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

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

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

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

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

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

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

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

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


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

35 files changed, 591 insertions, 250 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index e4bcca81ede..6fae7580745 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,10 +1,142 @@
+2004-06-23  David Kastrup  <dak@gnu.org>
+
+        * search.c (Freplace_match): Adjust the match-data more
+        thoroughly when replacing strings in the buffer.
+        search.c (match-data): When INTEGERS is non-nil and the last match
+        was in a buffer, add the buffer as last element to the match data.
+        (Fset_match_data): If an additional element of the match-data is
+        a buffer, restore it to last_thing_searched.
+        (save_search_regs): Save last_thing_searched as part of the match
+        data.
+        (restore_match_data): Restore it again.
+
+2004-06-23  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * keymap.c (Ftext_char_description): Doc fix.
+        * doc.c (Fsnarf_documentation): Doc fix.
+
+2004-06-22  Kim F. Storm  <storm@cua.dk>
+
+        * fns.c (Fmapcar, Fmapconcat): GCPRO the args array.
+
+        * lisp.h (struct Lisp_Save_Value): New member dogc.
+        (SAFE_ALLOCA_LISP): Change second arg to number of elements.
+        Set dogc member in Lisp_Save_Value object so it will be GC'ed.
+        (SAFE_FREE_LISP): New macro.
+
+        * alloc.c (safe_alloca_unwind): Clear dogc and pointer members.
+        (make_save_value): Init new dogc member.
+        (mark_object): Mark Lisp_Save_Value pointer array if dogc is set.
+
+        * fns.c (Fmapconcat, Fmapcar): Use new SAFE_ALLOCA_LISP and
+        SAFE_FREE_LISP macros.
+
+2004-06-22  Kim F. Storm  <storm@cua.dk>
+
+        * lisp.h (SAFE_ALLOCA_LISP): New macro to allocate Lisp_Objects.
+        Temporarily inhibits GC if memory is xmalloc'ed, as the Lisp_Objects
+        in that memory area are unknown to GC.  Add comments.
+
+        * fns.c (Fmapconcat, Fmapcar): Use SAFE_ALLOCA_LISP.
+
+2004-06-21  Kim F. Storm  <storm@cua.dk>
+
+        * lisp.h (MAX_ALLOCA): Define here.
+        (safe_alloca_unwind): Add prototype.
+        (USE_SAFE_ALLOCA, SAFE_ALLOCA, SAFE_FREE): New macros.
+
+        * alloc.c (safe_alloca_unwind): New function.
+
+        * casefiddle.c (casify_object): Use SAFE_ALLOCA.
+
+        * charset.c (Fstring): Use SAFE_ALLOCA.
+
+        * coding.c (MAX_ALLOCA): Remove define.
+
+        * data.c (MAX_ALLOCA): Remove define.
+        (Faset): Use SAFE_ALLOCA.
+
+        * editfns.c (Fformat, Ftranspose_regions): Use SAFE_ALLOCA.
+
+        * fns.c (string_make_multibyte, string_to_multibyte)
+        (string_make_unibyte, Fmapconcat, Fmapcar): Use SAFE_ALLOCA.
+        (MAX_ALLOCA): Remove define.
+        (Fbase64_encode_region, Fbase64_encode_string)
+        (Fbase64_decode_region, Fbase64_decode_string): Use SAFE_ALLOCA.
+        (Fbase64_encode_region, Fbase64_encode_string): Fix potential
+        memory leak if encoding fails.
+
+        * xdisp.c (add_to_log): Use SAFE_ALLOCA.
+
+2004-06-21  Eli Zaretskii  <eliz@gnu.org>
+
+        * print.c (Fwith_output_to_temp_buffer): Doc fix.
+
+2004-06-20  Richard M. Stallman  <rms@gnu.org>
+
+        * xfaces.c (Finternal_copy_lisp_face): Small cleanup; doc fix.
+
+        * search.c (match_limit): Cleaner err msg when no match data available.
+
+        * window.c (syms_of_window): Doc fix.
+
+        * keyboard.c (command_loop_1): Handle values `only' and `identity'
+        for Vtransient_mark_mode.
+
+        * buffer.c (syms_of_buffer): Doc fix.
+
+2004-06-21  David Kastrup  <dak@gnu.org>
+
+        * minibuf.c (Ftry_completion, Fall_completions): Do lazy binding
+        and unbinding of `case-fold-search' according to
+        `completion-ignore-case' around calls of string-match and
+        predicates, respectively.  Should give satisfactory performance
+        in all relevant cases.
+
+2004-06-17  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * xterm.c (x_draw_image_foreground_1): Subtract slice.x/y from
+        clip_x/y_origin.
+
+        * fns.c (string_to_multibyte): Use xmalloc/xfree instead of alloca.
+
+        * macfns.c (Fx_display_color_cells): Do not limit return value to 256.
+
+        * macterm.c (mac_initialize_display_info): Initialize n_planes correctly
+        on Mac OSX.
+
+2004-06-16  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * buffer.c (syms_of_buffer): Clarify `fill-column' docstring.
+
+2004-06-16  Kim F. Storm  <storm@cua.dk>
+
+        * dispextern.h (Vimage_types): Remove extern.
+
+2004-06-16  Miles Bader  <miles@gnu.org>
+
+        * image.c (lookup_image_type): Initialize image type if necessary.
+
+2004-06-15  Kim F. Storm  <storm@cua.dk>
+
+        * xdisp.c (try_cursor_movement): Exclude header line from scroll
+        margin at top of window.
+        (try_window_reusing_current_matrix): Calculate proper cursor position
+        after scrolling up with non-zero scroll margin, as the old cursor
+        position corresponds to value of PT before executing this command.
+        (try_window_id): Consider scroll margin at bottom of window too;
+        otherwise we fail to scroll when hl-line-mode is enabled.
+
+        * syntax.c (skip_chars): Only recognize [:class:] when it has the
+        proper format and class is a lower-case word.
+
 2004-06-14  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
 
         * gtkutil.c (xg_get_image_for_pixmap): New function.
         (xg_get_gdk_pixmap_and_mask): Removed.
         (update_frame_tool_bar): Call xg_get_image_for_pixmap instead of
         xg_get_gdk_pixmap_and_mask.
-        
+
         * xterm.h (struct x_display_info): Typo in comment fixed.
 
 2004-06-14  Juanma Barranquero  <lektu@terra.es>
diff --git a/src/abbrev.c b/src/abbrev.c
index 41e329ac95d..ac132f20023 100644
--- a/src/abbrev.c
+++ b/src/abbrev.c
@@ -1,5 +1,5 @@
 /* Primitives for word-abbrev mode.
-   Copyright (C) 1985, 1986, 1993, 1996, 1998, 2001
+   Copyright (C) 1985, 1986, 1993, 1996, 1998, 2001,02,03,04
    Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
diff --git a/src/alloc.c b/src/alloc.c
index 3a3628f40fd..baf7afa0094 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -580,6 +580,21 @@ xstrdup (s)
 }
 
 
+/* Unwind for SAFE_ALLOCA */
+
+Lisp_Object
+safe_alloca_unwind (arg)
+     Lisp_Object arg;
+{
+  register struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
+
+  p->dogc = 0;
+  xfree (p->pointer);
+  p->pointer = 0;
+  return Qnil;
+}
+
+
 /* Like malloc but used for allocating Lisp data.  NBYTES is the
    number of bytes to allocate, TYPE describes the intended use of the
    allcated memory block (for strings, for conses, ...).  */
@@ -2935,6 +2950,7 @@ make_save_value (pointer, integer)
   p = XSAVE_VALUE (val);
   p->pointer = pointer;
   p->integer = integer;
+  p->dogc = 0;
   return val;
 }
 
@@ -4969,6 +4985,7 @@ mark_object (arg)
       if (XMARKER (obj)->gcmarkbit)
         break;
       XMARKER (obj)->gcmarkbit = 1;
+
       switch (XMISCTYPE (obj))
         {
         case Lisp_Misc_Buffer_Local_Value:
@@ -4993,6 +5010,8 @@ mark_object (arg)
           /* DO NOT mark thru the marker's chain.
              The buffer's markers chain does not preserve markers from gc;
              instead, markers are removed from the chain when freed by gc.  */
+          break;
+
         case Lisp_Misc_Intfwd:
         case Lisp_Misc_Boolfwd:
         case Lisp_Misc_Objfwd:
@@ -5002,7 +5021,21 @@ mark_object (arg)
              since all markable slots in current buffer marked anyway.  */
           /* Don't need to do Lisp_Objfwd, since the places they point
              are protected with staticpro.  */
+          break;
+
         case Lisp_Misc_Save_Value:
+          {
+            register struct Lisp_Save_Value *ptr = XSAVE_VALUE (obj);
+            /* If DOGC is set, POINTER is the address of a memory
+               area containing INTEGER potential Lisp_Objects.  */
+            if (ptr->dogc)
+              {
+                Lisp_Object *p = (Lisp_Object *) ptr->pointer;
+                int nelt;
+                for (nelt = ptr->integer; nelt > 0; nelt--, p++)
+                  mark_maybe_object (*p);
+              }
+          }
           break;
 
         case Lisp_Misc_Overlay:
diff --git a/src/atimer.c b/src/atimer.c
index 2ddc7427f56..7e78bdad9c0 100644
--- a/src/atimer.c
+++ b/src/atimer.c
@@ -1,5 +1,5 @@
 /* Asynchronous timers.
-   Copyright (C) 2000 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2004 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/atimer.h b/src/atimer.h
index 3ecc97e5511..f987a47a6bd 100644
--- a/src/atimer.h
+++ b/src/atimer.h
@@ -1,5 +1,5 @@
 /* Asynchronous timers.
-   Copyright (C) 2000 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2003 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/blockinput.h b/src/blockinput.h
index e9f2f3bc217..a4c8a9b9c22 100644
--- a/src/blockinput.h
+++ b/src/blockinput.h
@@ -1,5 +1,5 @@
 /* blockinput.h - interface to blocking complicated interrupt-driven input.
-   Copyright (C) 1989, 1993 Free Software Foundation, Inc.
+   Copyright (C) 1989, 1993, 2004 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/buffer.c b/src/buffer.c
index 532a768ba50..031f5da8e6e 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5437,7 +5437,7 @@ nil here means use current buffer's major mode.  */);
   DEFVAR_PER_BUFFER ("fill-column", &current_buffer->fill_column,
                      make_number (Lisp_Int),
                      doc: /* *Column beyond which automatic line-wrapping should happen.
-Interactively, you can set this using \\[set-fill-column].  */);
+Interactively, you can set the buffer local value using \\[set-fill-column].  */);
 
   DEFVAR_PER_BUFFER ("left-margin", &current_buffer->left_margin,
                      make_number (Lisp_Int),
@@ -5847,7 +5847,11 @@ If the buffer has never been shown in a window, the value is nil.  */);
                doc: /* *Non-nil means deactivate the mark when the buffer contents change.
 Non-nil also enables highlighting of the region whenever the mark is active.
 The variable `highlight-nonselected-windows' controls whether to highlight
-all windows or just the selected window.  */);
+all windows or just the selected window.
+
+If the value is `lambda', that enables Transient Mark mode temporarily
+until the next buffer modification.  If a command sets the value to `only',
+that enables Transient Mark mode for the following command only.  */);
   Vtransient_mark_mode = Qnil;
 
   DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only,
diff --git a/src/buffer.h b/src/buffer.h
index b5227cb9981..e59211d4111 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -1,5 +1,5 @@
 /* Header file for the buffer manipulation primitives.
-   Copyright (C) 1985, 86, 93, 94, 95, 97, 1998, 1999, 2000, 01, 2003
+   Copyright (C) 1985,86,93,94,95,97,98,99,2000,01,03,04
    Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
diff --git a/src/callproc.c b/src/callproc.c
index 73d81d81b18..c3345eb3707 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -1,5 +1,5 @@
 /* Synchronous subprocess invocation for GNU Emacs.
-   Copyright (C) 1985,86,87,88,93,94,95,99, 2000, 2001
+   Copyright (C) 1985,86,87,88,93,94,95,99, 2000,01,02,03,04
    Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -222,7 +222,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
   register int pid;
   char buf[16384];
   char *bufptr = buf;
-  int bufsize = 16384;
+  int bufsize = sizeof buf;
   int count = SPECPDL_INDEX ();
 
   register const unsigned char **new_argv
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 6387c4bc845..25a5a3d12b8 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -1,5 +1,6 @@
 /* GNU Emacs case conversion functions.
-   Copyright (C) 1985, 1994, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1985,94,97,98,99, 2001, 2002, 2004
+   Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -109,8 +110,12 @@ casify_object (flag, obj)
               /* The work is not yet finished because of a multibyte
                  character just encountered.  */
               int fromlen, j_byte = i;
-              char *buf
-                = (char *) alloca ((len - i) * MAX_MULTIBYTE_LENGTH + i);
+              char *buf;
+              int bufsize;
+              USE_SAFE_ALLOCA;
+
+              bufsize = (len - i) * MAX_MULTIBYTE_LENGTH + i;
+              SAFE_ALLOCA (buf, char *, bufsize);
 
               /* Copy data already handled.  */
               bcopy (SDATA (obj), buf, i);
@@ -132,6 +137,7 @@ casify_object (flag, obj)
                 }
               obj = make_multibyte_string (buf, SCHARS (obj),
                                            j_byte);
+              SAFE_FREE (bufsize);
             }
           return obj;
         }
diff --git a/src/charset.c b/src/charset.c
index 57a12b2398d..8eeddd51c92 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -1645,11 +1645,16 @@ usage: (string &rest CHARACTERS)  */)
      int n;
      Lisp_Object *args;
 {
-  int i;
-  unsigned char *buf = (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH * n);
-  unsigned char *p = buf;
+  int i, bufsize;
+  unsigned char *buf, *p;
   int c;
   int multibyte = 0;
+  Lisp_Object ret;
+  USE_SAFE_ALLOCA;
+
+  bufsize = MAX_MULTIBYTE_LENGTH * n;
+  SAFE_ALLOCA (buf, unsigned char *, bufsize);
+  p = buf;
 
   for (i = 0; i < n; i++)
     {
@@ -1667,7 +1672,10 @@ usage: (string &rest CHARACTERS)  */)
         *p++ = c;
     }
 
-  return make_string_from_bytes (buf, n, p - buf);
+  ret = make_string_from_bytes (buf, n, p - buf);
+  SAFE_FREE (bufsize);
+
+  return ret;
 }
 
 #endif /* emacs */
diff --git a/src/coding.c b/src/coding.c
index ed4b131b3a9..b36f7fbfbff 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -2094,7 +2094,7 @@ decode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
                   int dim, M, L;
                   int size, required;
                   int produced_chars;
-                  
+
                   ONE_MORE_BYTE (dim);
                   ONE_MORE_BYTE (M);
                   ONE_MORE_BYTE (L);
@@ -4548,10 +4548,6 @@ struct conversion_buffer
   unsigned char *data;
 };
 
-/* Don't use alloca for allocating memory space larger than this, lest
-   we overflow their stack.  */
-#define MAX_ALLOCA 16*1024
-
 /* Allocate LEN bytes of memory for BUF (struct conversion_buffer).  */
 #define allocate_conversion_buffer(buf, len)            \
   do {                                                  \
@@ -6654,7 +6650,7 @@ find_safe_codings (p, pend, safe_codings, work_table, single_byte_char_found)
                                         accept_latin_extra));
                 }
             }
-              
+
           if (! encodable
               && ((CHAR_TABLE_P (translation_table)
                    && ! NILP (Faref (translation_table, ch)))
diff --git a/src/data.c b/src/data.c
index 5a1a648dcb7..1259c5891a1 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2052,11 +2052,6 @@ or a byte-code object.  IDX starts at 0.  */)
     }
 }
 
-/* Don't use alloca for relocating string data larger than this, lest
-   we overflow their stack.  The value is the same as what used in
-   fns.c for base64 handling.  */
-#define MAX_ALLOCA 16*1024
-
 DEFUN ("aset", Faset, Saset, 3, 3, 0,
        doc: /* Store into the element of ARRAY at index IDX the value NEWELT.
 Return NEWELT.  ARRAY may be a vector, a string, a char-table or a
@@ -2156,10 +2151,9 @@ bool-vector.  IDX starts at 0.  */)
           /* We must relocate the string data.  */
           int nchars = SCHARS (array);
           unsigned char *str;
+          USE_SAFE_ALLOCA;
 
-          str = (nbytes <= MAX_ALLOCA
-                 ? (unsigned char *) alloca (nbytes)
-                 : (unsigned char *) xmalloc (nbytes));
+          SAFE_ALLOCA (str, unsigned char *, nbytes);
           bcopy (SDATA (array), str, nbytes);
           allocate_string_data (XSTRING (array), nchars,
                                 nbytes + new_bytes - prev_bytes);
@@ -2167,8 +2161,7 @@ bool-vector.  IDX starts at 0.  */)
           p1 = SDATA (array) + idxval_byte;
           bcopy (str + idxval_byte + prev_bytes, p1 + new_bytes,
                  nbytes - (idxval_byte + prev_bytes));
-          if (nbytes > MAX_ALLOCA)
-            xfree (str);
+          SAFE_FREE (nbytes);
           clear_string_char_byte_cache ();
         }
       while (new_bytes--)
@@ -2190,14 +2183,13 @@ bool-vector.  IDX starts at 0.  */)
           unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *p0 = workbuf, *p1;
           unsigned char *origstr = SDATA (array), *str;
           int nchars, nbytes;
+          USE_SAFE_ALLOCA;
 
           nchars = SCHARS (array);
           nbytes = idxval_byte = count_size_as_multibyte (origstr, idxval);
           nbytes += count_size_as_multibyte (origstr + idxval,
                                              nchars - idxval);
-          str = (nbytes <= MAX_ALLOCA
-                 ? (unsigned char *) alloca (nbytes)
-                 : (unsigned char *) xmalloc (nbytes));
+          SAFE_ALLOCA (str, unsigned char *, nbytes);
           copy_text (SDATA (array), str, nchars, 0, 1);
           PARSE_MULTIBYTE_SEQ (str + idxval_byte, nbytes - idxval_byte,
                                prev_bytes);
@@ -2210,8 +2202,7 @@ bool-vector.  IDX starts at 0.  */)
             *p1++ = *p0++;
           bcopy (str + idxval_byte + prev_bytes, p1,
                  nbytes - (idxval_byte + prev_bytes));
-          if (nbytes > MAX_ALLOCA)
-            xfree (str);
+          SAFE_FREE (nbytes);
           clear_string_char_byte_cache ();
         }
     }
diff --git a/src/dispextern.h b/src/dispextern.h
index 2b9ef2adbf0..f48cdbbe273 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1,5 +1,5 @@
 /* Interface definitions for display code.
-   Copyright (C) 1985, 1993, 1994, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+   Copyright (C) 1985,93,94,97,98,99, 2000,01,02,03, 2004
      Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -2645,8 +2645,6 @@ void w32_reset_fringes P_ ((void));
 
 #ifdef HAVE_WINDOW_SYSTEM
 
-extern Lisp_Object Vimage_types;
-
 extern int x_bitmap_height P_ ((struct frame *, int));
 extern int x_bitmap_width P_ ((struct frame *, int));
 extern int x_bitmap_pixmap P_ ((struct frame *, int));
diff --git a/src/doc.c b/src/doc.c
index a0b840637e0..120d35767b2 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -570,7 +570,7 @@ records them in function and variable definitions.
 The function takes one argument, FILENAME, a string;
 it specifies the file name (without a directory) of the DOC file.
 That file is found in `../etc' now; later, when the dumped Emacs is run,
-the same file name is found in the `data-directory'.  */)
+the same file name is found in the `doc-directory'.  */)
      (filename)
      Lisp_Object filename;
 {
diff --git a/src/editfns.c b/src/editfns.c
index c9dd4ecefdf..9fbdc0363bb 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -3225,6 +3225,7 @@ usage: (format STRING &rest OBJECTS)  */)
   int longest_format;
   Lisp_Object val;
   int arg_intervals = 0;
+  USE_SAFE_ALLOCA;
 
   /* discarded[I] is 1 if byte I of the format
      string was not copied into the output.
@@ -3273,7 +3274,7 @@ usage: (format STRING &rest OBJECTS)  */)
   longest_format = 0;
 
   /* Make room in result for all the non-%-codes in the control string.  */
-  total = 5 + CONVERTED_BYTE_SIZE (multibyte, args[0]);
+  total = 5 + CONVERTED_BYTE_SIZE (multibyte, args[0]) + 1;
 
   /* Allocate the info and discarded tables.  */
   {
@@ -3466,10 +3467,7 @@ usage: (format STRING &rest OBJECTS)  */)
 
   /* Allocate the space for the result.
      Note that TOTAL is an overestimate.  */
-  if (total < 1000)
-    buf = (char *) alloca (total + 1);
-  else
-    buf = (char *) xmalloc (total + 1);
+  SAFE_ALLOCA (buf, char *, total);
 
   p = buf;
   nchars = 0;
@@ -3602,7 +3600,7 @@ usage: (format STRING &rest OBJECTS)  */)
                 maybe_combine_byte = 1;
               this_nchars = strlen (p);
               if (multibyte)
-                p += str_to_multibyte (p, buf + total - p, this_nchars);
+                p += str_to_multibyte (p, buf + total - 1 - p, this_nchars);
               else
                 p += this_nchars;
               nchars += this_nchars;
@@ -3639,7 +3637,7 @@ usage: (format STRING &rest OBJECTS)  */)
         *p++ = *format++, nchars++;
     }
 
-  if (p > buf + total + 1)
+  if (p > buf + total)
     abort ();
 
   if (maybe_combine_byte)
@@ -3647,8 +3645,7 @@ usage: (format STRING &rest OBJECTS)  */)
   val = make_specified_string (buf, nchars, p - buf, multibyte);
 
   /* If we allocated BUF with malloc, free it too.  */
-  if (total >= 1000)
-    xfree (buf);
+  SAFE_FREE (total);
 
   /* If the format string has text properties, or any of the string
      arguments has text properties, set up text properties of the
@@ -4005,12 +4002,9 @@ Transposing beyond buffer boundaries is an error.  */)
       /* First region smaller than second.  */
       if (len1_byte < len2_byte)
         {
-          /* We use alloca only if it is small,
-             because we want to avoid stack overflow.  */
-          if (len2_byte > 20000)
-            temp = (unsigned char *) xmalloc (len2_byte);
-          else
-            temp = (unsigned char *) alloca (len2_byte);
+          USE_SAFE_ALLOCA;
+
+          SAFE_ALLOCA (temp, unsigned char *, len2_byte);
 
           /* Don't precompute these addresses.  We have to compute them
              at the last minute, because the relocating allocator might
@@ -4021,23 +4015,20 @@ Transposing beyond buffer boundaries is an error.  */)
           bcopy (start2_addr, temp, len2_byte);
           bcopy (start1_addr, start1_addr + len2_byte, len1_byte);
           bcopy (temp, start1_addr, len2_byte);
-          if (len2_byte > 20000)
-            xfree (temp);
+          SAFE_FREE (len2_byte);
         }
       else
         /* First region not smaller than second.  */
         {
-          if (len1_byte > 20000)
-            temp = (unsigned char *) xmalloc (len1_byte);
-          else
-            temp = (unsigned char *) alloca (len1_byte);
+          USE_SAFE_ALLOCA;
+
+          SAFE_ALLOCA (temp, unsigned char *, len1_byte);
           start1_addr = BYTE_POS_ADDR (start1_byte);
           start2_addr = BYTE_POS_ADDR (start2_byte);
           bcopy (start1_addr, temp, len1_byte);
           bcopy (start2_addr, start1_addr, len2_byte);
           bcopy (temp, start1_addr + len2_byte, len1_byte);
-          if (len1_byte > 20000)
-            xfree (temp);
+          SAFE_FREE (len1_byte);
         }
       graft_intervals_into_buffer (tmp_interval1, start1 + len2,
                                    len1, current_buffer, 0);
@@ -4054,6 +4045,8 @@ Transposing beyond buffer boundaries is an error.  */)
       if (len1_byte == len2_byte)
         /* Regions are same size, though, how nice.  */
         {
+          USE_SAFE_ALLOCA;
+
           modify_region (current_buffer, start1, end1);
           modify_region (current_buffer, start2, end2);
           record_change (start1, len1);
@@ -4065,17 +4058,14 @@ Transposing beyond buffer boundaries is an error.  */)
           Fset_text_properties (make_number (start2), make_number (end2),
                                 Qnil, Qnil);
 
-          if (len1_byte > 20000)
-            temp = (unsigned char *) xmalloc (len1_byte);
-          else
-            temp = (unsigned char *) alloca (len1_byte);
+          SAFE_ALLOCA (temp, unsigned char *, len1_byte);
           start1_addr = BYTE_POS_ADDR (start1_byte);
           start2_addr = BYTE_POS_ADDR (start2_byte);
           bcopy (start1_addr, temp, len1_byte);
           bcopy (start2_addr, start1_addr, len2_byte);
           bcopy (temp, start2_addr, len1_byte);
-          if (len1_byte > 20000)
-            xfree (temp);
+          SAFE_FREE (len1_byte);
+
           graft_intervals_into_buffer (tmp_interval1, start2,
                                        len1, current_buffer, 0);
           graft_intervals_into_buffer (tmp_interval2, start1,
@@ -4085,6 +4075,8 @@ Transposing beyond buffer boundaries is an error.  */)
       else if (len1_byte < len2_byte)   /* Second region larger than first */
         /* Non-adjacent & unequal size, area between must also be shifted.  */
         {
+          USE_SAFE_ALLOCA;
+
           modify_region (current_buffer, start1, end2);
           record_change (start1, (end2 - start1));
           tmp_interval1 = copy_intervals (cur_intv, start1, len1);
@@ -4094,18 +4086,15 @@ Transposing beyond buffer boundaries is an error.  */)
                                 Qnil, Qnil);
 
           /* holds region 2 */
-          if (len2_byte > 20000)
-            temp = (unsigned char *) xmalloc (len2_byte);
-          else
-            temp = (unsigned char *) alloca (len2_byte);
+          SAFE_ALLOCA (temp, unsigned char *, len2_byte);
           start1_addr = BYTE_POS_ADDR (start1_byte);
           start2_addr = BYTE_POS_ADDR (start2_byte);
           bcopy (start2_addr, temp, len2_byte);
           bcopy (start1_addr, start1_addr + len_mid + len2_byte, len1_byte);
           safe_bcopy (start1_addr + len1_byte, start1_addr + len2_byte, len_mid);
           bcopy (temp, start1_addr, len2_byte);
-          if (len2_byte > 20000)
-            xfree (temp);
+          SAFE_FREE (len2_byte);
+
           graft_intervals_into_buffer (tmp_interval1, end2 - len1,
                                        len1, current_buffer, 0);
           graft_intervals_into_buffer (tmp_interval_mid, start1 + len2,
@@ -4116,6 +4105,8 @@ Transposing beyond buffer boundaries is an error.  */)
       else
         /* Second region smaller than first.  */
         {
+          USE_SAFE_ALLOCA;
+
           record_change (start1, (end2 - start1));
           modify_region (current_buffer, start1, end2);
 
@@ -4126,18 +4117,15 @@ Transposing beyond buffer boundaries is an error.  */)
                                 Qnil, Qnil);
 
           /* holds region 1 */
-          if (len1_byte > 20000)
-            temp = (unsigned char *) xmalloc (len1_byte);
-          else
-            temp = (unsigned char *) alloca (len1_byte);
+          SAFE_ALLOCA (temp, unsigned char *, len1_byte);
           start1_addr = BYTE_POS_ADDR (start1_byte);
           start2_addr = BYTE_POS_ADDR (start2_byte);
           bcopy (start1_addr, temp, len1_byte);
           bcopy (start2_addr, start1_addr, len2_byte);
           bcopy (start1_addr + len1_byte, start1_addr + len2_byte, len_mid);
           bcopy (temp, start1_addr + len2_byte + len_mid, len1_byte);
-          if (len1_byte > 20000)
-            xfree (temp);
+          SAFE_FREE (len1_byte);
+
           graft_intervals_into_buffer (tmp_interval1, end2 - len1,
                                        len1, current_buffer, 0);
           graft_intervals_into_buffer (tmp_interval_mid, start1 + len2,
diff --git a/src/fns.c b/src/fns.c
index 6001d99fb49..7e84b775fbb 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -994,6 +994,8 @@ string_make_multibyte (string)
 {
   unsigned char *buf;
   int nbytes;
+  Lisp_Object ret;
+  USE_SAFE_ALLOCA;
 
   if (STRING_MULTIBYTE (string))
     return string;
@@ -1005,11 +1007,14 @@ string_make_multibyte (string)
   if (nbytes == SBYTES (string))
     return string;
 
-  buf = (unsigned char *) alloca (nbytes);
+  SAFE_ALLOCA (buf, unsigned char *, nbytes);
   copy_text (SDATA (string), buf, SBYTES (string),
              0, 1);
 
-  return make_multibyte_string (buf, SCHARS (string), nbytes);
+  ret = make_multibyte_string (buf, SCHARS (string), nbytes);
+  SAFE_FREE (nbytes);
+
+  return ret;
 }
 
 
@@ -1024,6 +1029,8 @@ string_to_multibyte (string)
 {
   unsigned char *buf;
   int nbytes;
+  Lisp_Object ret;
+  USE_SAFE_ALLOCA;
 
   if (STRING_MULTIBYTE (string))
     return string;
@@ -1034,11 +1041,14 @@ string_to_multibyte (string)
   if (nbytes == SBYTES (string))
     return make_multibyte_string (SDATA (string), nbytes, nbytes);
 
-  buf = (unsigned char *) alloca (nbytes);
+  SAFE_ALLOCA (buf, unsigned char *, nbytes);
   bcopy (SDATA (string), buf, SBYTES (string));
   str_to_multibyte (buf, nbytes, SBYTES (string));
 
-  return make_multibyte_string (buf, SCHARS (string), nbytes);
+  ret = make_multibyte_string (buf, SCHARS (string), nbytes);
+  SAFE_FREE (nbytes);
+
+  return ret;
 }
 
 
@@ -1048,17 +1058,24 @@ Lisp_Object
 string_make_unibyte (string)
      Lisp_Object string;
 {
+  int nchars;
   unsigned char *buf;
+  Lisp_Object ret;
+  USE_SAFE_ALLOCA;
 
   if (! STRING_MULTIBYTE (string))
     return string;
 
-  buf = (unsigned char *) alloca (SCHARS (string));
+  nchars = SCHARS (string);
 
+  SAFE_ALLOCA (buf, unsigned char *, nchars);
   copy_text (SDATA (string), buf, SBYTES (string),
              1, 0);
 
-  return make_unibyte_string (buf, SCHARS (string));
+  ret = make_unibyte_string (buf, nchars);
+  SAFE_FREE (nchars);
+
+  return ret;
 }
 
 DEFUN ("string-make-multibyte", Fstring_make_multibyte, Sstring_make_multibyte,
@@ -2983,13 +3000,15 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   register Lisp_Object *args;
   register int i;
   struct gcpro gcpro1;
+  Lisp_Object ret;
+  USE_SAFE_ALLOCA;
 
   len = Flength (sequence);
   leni = XINT (len);
   nargs = leni + leni - 1;
   if (nargs < 0) return build_string ("");
 
-  args = (Lisp_Object *) alloca (nargs * sizeof (Lisp_Object));
+  SAFE_ALLOCA_LISP (args, nargs);
 
   GCPRO1 (separator);
   mapcar1 (leni, args, function, sequence);
@@ -3001,7 +3020,14 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   for (i = 1; i < nargs; i += 2)
     args[i] = separator;
 
-  return Fconcat (nargs, args);
+  GCPRO1 (*args);
+  gcpro1.nvars = nargs;
+  ret = Fconcat (nargs, args);
+  UNGCPRO;
+
+  SAFE_FREE_LISP (nargs);
+
+  return ret;
 }
 
 DEFUN ("mapcar", Fmapcar, Smapcar, 2, 2, 0,
@@ -3014,14 +3040,25 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   register Lisp_Object len;
   register int leni;
   register Lisp_Object *args;
+  struct gcpro gcpro1;
+  Lisp_Object ret;
+  USE_SAFE_ALLOCA;
 
   len = Flength (sequence);
   leni = XFASTINT (len);
-  args = (Lisp_Object *) alloca (leni * sizeof (Lisp_Object));
+
+  SAFE_ALLOCA_LISP (args, leni);
 
   mapcar1 (leni, args, function, sequence);
 
-  return Flist (leni, args);
+  GCPRO1 (*args);
+  gcpro1.nvars = leni;
+  ret = Flist (leni, args);
+  UNGCPRO;
+
+  SAFE_FREE_LISP (leni);
+
+  return ret;
 }
 
 DEFUN ("mapc", Fmapc, Smapc, 2, 2, 0,
@@ -3636,10 +3673,6 @@ The data read from the system are decoded using `locale-coding-system'.  */)
     }                                   \
   while (IS_BASE64_IGNORABLE (c))
 
-/* Don't use alloca for regions larger than this, lest we overflow
-   their stack.  */
-#define MAX_ALLOCA 16*1024
-
 /* Table of characters coding the 64 values.  */
 static char base64_value_to_char[64] =
 {
@@ -3705,6 +3738,7 @@ into shorter lines.  */)
   int allength, length;
   int ibeg, iend, encoded_length;
   int old_pos = PT;
+  USE_SAFE_ALLOCA;
 
   validate_region (&beg, &end);
 
@@ -3719,10 +3753,7 @@ into shorter lines.  */)
   allength = length + length/3 + 1;
   allength += allength / MIME_LINE_LENGTH + 1 + 6;
 
-  if (allength <= MAX_ALLOCA)
-    encoded = (char *) alloca (allength);
-  else
-    encoded = (char *) xmalloc (allength);
+  SAFE_ALLOCA (encoded, char *, allength);
   encoded_length = base64_encode_1 (BYTE_POS_ADDR (ibeg), encoded, length,
                                     NILP (no_line_break),
                                     !NILP (current_buffer->enable_multibyte_characters));
@@ -3732,8 +3763,7 @@ into shorter lines.  */)
   if (encoded_length < 0)
     {
       /* The encoding wasn't possible. */
-      if (length > MAX_ALLOCA)
-        xfree (encoded);
+      SAFE_FREE (allength);
       error ("Multibyte character in data for base64 encoding");
     }
 
@@ -3741,8 +3771,7 @@ into shorter lines.  */)
      and delete the old.  (Insert first in order to preserve markers.)  */
   SET_PT_BOTH (XFASTINT (beg), ibeg);
   insert (encoded, encoded_length);
-  if (allength > MAX_ALLOCA)
-    xfree (encoded);
+  SAFE_FREE (allength);
   del_range_byte (ibeg + encoded_length, iend + encoded_length, 1);
 
   /* If point was outside of the region, restore it exactly; else just
@@ -3768,6 +3797,7 @@ into shorter lines.  */)
   int allength, length, encoded_length;
   char *encoded;
   Lisp_Object encoded_string;
+  USE_SAFE_ALLOCA;
 
   CHECK_STRING (string);
 
@@ -3779,10 +3809,7 @@ into shorter lines.  */)
   allength += allength / MIME_LINE_LENGTH + 1 + 6;
 
   /* We need to allocate enough room for decoding the text. */
-  if (allength <= MAX_ALLOCA)
-    encoded = (char *) alloca (allength);
-  else
-    encoded = (char *) xmalloc (allength);
+  SAFE_ALLOCA (encoded, char *, allength);
 
   encoded_length = base64_encode_1 (SDATA (string),
                                     encoded, length, NILP (no_line_break),
@@ -3793,14 +3820,12 @@ into shorter lines.  */)
   if (encoded_length < 0)
     {
       /* The encoding wasn't possible. */
-      if (length > MAX_ALLOCA)
-        xfree (encoded);
+      SAFE_FREE (allength);
       error ("Multibyte character in data for base64 encoding");
     }
 
   encoded_string = make_unibyte_string (encoded, encoded_length);
-  if (allength > MAX_ALLOCA)
-    xfree (encoded);
+  SAFE_FREE (allength);
 
   return encoded_string;
 }
@@ -3913,6 +3938,7 @@ If the region can't be decoded, signal an error and don't modify the buffer.  */
   int decoded_length;
   int inserted_chars;
   int multibyte = !NILP (current_buffer->enable_multibyte_characters);
+  USE_SAFE_ALLOCA;
 
   validate_region (&beg, &end);
 
@@ -3925,10 +3951,7 @@ If the region can't be decoded, signal an error and don't modify the buffer.  */
      working on a multibyte buffer, each decoded code may occupy at
      most two bytes.  */
   allength = multibyte ? length * 2 : length;
-  if (allength <= MAX_ALLOCA)
-    decoded = (char *) alloca (allength);
-  else
-    decoded = (char *) xmalloc (allength);
+  SAFE_ALLOCA (decoded, char *, allength);
 
   move_gap_both (XFASTINT (beg), ibeg);
   decoded_length = base64_decode_1 (BYTE_POS_ADDR (ibeg), decoded, length,
@@ -3939,8 +3962,7 @@ If the region can't be decoded, signal an error and don't modify the buffer.  */
   if (decoded_length < 0)
     {
       /* The decoding wasn't possible. */
-      if (allength > MAX_ALLOCA)
-        xfree (decoded);
+      SAFE_FREE (allength);
       error ("Invalid base64 data");
     }
 
@@ -3948,8 +3970,8 @@ If the region can't be decoded, signal an error and don't modify the buffer.  */
      and delete the old.  (Insert first in order to preserve markers.)  */
   TEMP_SET_PT_BOTH (XFASTINT (beg), ibeg);
   insert_1_both (decoded, inserted_chars, decoded_length, 0, 1, 0);
-  if (allength > MAX_ALLOCA)
-    xfree (decoded);
+  SAFE_FREE (allength);
+
   /* Delete the original text.  */
   del_range_both (PT, PT_BYTE, XFASTINT (end) + inserted_chars,
                   iend + decoded_length, 1);
@@ -3974,15 +3996,13 @@ DEFUN ("base64-decode-string", Fbase64_decode_string, Sbase64_decode_string,
   char *decoded;
   int length, decoded_length;
   Lisp_Object decoded_string;
+  USE_SAFE_ALLOCA;
 
   CHECK_STRING (string);
 
   length = SBYTES (string);
   /* We need to allocate enough room for decoding the text. */
-  if (length <= MAX_ALLOCA)
-    decoded = (char *) alloca (length);
-  else
-    decoded = (char *) xmalloc (length);
+  SAFE_ALLOCA (decoded, char *, length);
 
   /* The decoded result should be unibyte. */
   decoded_length = base64_decode_1 (SDATA (string), decoded, length,
@@ -3994,8 +4014,7 @@ DEFUN ("base64-decode-string", Fbase64_decode_string, Sbase64_decode_string,
   else
     decoded_string = Qnil;
 
-  if (length > MAX_ALLOCA)
-    xfree (decoded);
+  SAFE_FREE (length);
   if (!STRINGP (decoded_string))
     error ("Invalid base64 data");
 
diff --git a/src/image.c b/src/image.c
index 3eccf0f001e..438e132807f 100644
--- a/src/image.c
+++ b/src/image.c
@@ -689,6 +689,10 @@ lookup_image_type (symbol)
 {
   struct image_type *type;
 
+  /* We must initialize the image-type if it hasn't been already.  */
+  if (NILP (Finit_image_library (symbol)))
+    return 0;                   /* unimplemented */
+
   for (type = image_types; type; type = type->next)
     if (EQ (symbol, *type->type))
       break;
diff --git a/src/keyboard.c b/src/keyboard.c
index de2bcf825a0..e9c9edbd239 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -670,6 +670,8 @@ static void handle_interrupt P_ ((void));
    to support it.  */
 static int cannot_suspend;
 
+extern Lisp_Object Qidentity, Qonly;
+
 /* Install the string STR as the beginning of the string of echoing,
    so that it serves as a prompt for the next character.
    Also start echoing.  */
@@ -1809,6 +1811,16 @@ command_loop_1 ()
             call1 (Vrun_hooks, intern ("activate-mark-hook"));
         }
 
+      /* Setting transient-mark-mode to `only' is a way of
+         turning it on for just one command.  */
+      if (!NILP (current_buffer->mark_active) && !NILP (Vrun_hooks))
+        {
+          if (EQ (Vtransient_mark_mode, Qidentity))
+            Vtransient_mark_mode = Qnil;
+          if (EQ (Vtransient_mark_mode, Qonly))
+            Vtransient_mark_mode = Qidentity;
+        }
+
     finalize:
 
       if (current_buffer == prev_buffer
diff --git a/src/keymap.c b/src/keymap.c
index 30d66972094..42bbeb92a18 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -2283,7 +2283,11 @@ push_text_char_description (c, p)
 
 DEFUN ("text-char-description", Ftext_char_description, Stext_char_description, 1, 1, 0,
        doc: /* Return a pretty description of file-character CHARACTER.
-Control characters turn into "^char", etc.  */)
+Control characters turn into "^char", etc.  This differs from
+`single-key-description' which turns them into "C-char".
+Also, this function recognizes the 2**7 bit as the Meta character,
+whereas `single-key-description' uses the 2**27 bit for Meta.
+See Info node `(elisp)Describing Characters' for examples.  */)
      (character)
      Lisp_Object character;
 {
diff --git a/src/lisp.h b/src/lisp.h
index fdf76399e5d..ba2508e827b 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1199,7 +1199,10 @@ struct Lisp_Save_Value
   {
     int type : 16;      /* = Lisp_Misc_Save_Value */
     unsigned gcmarkbit : 1;
-    int spacer : 15;
+    int spacer : 14;
+    /* If DOGC is set, POINTER is the address of a memory
+       area containing INTEGER potential Lisp_Objects.  */
+    unsigned int dogc : 1;
     void *pointer;
     int integer;
   };
@@ -3248,6 +3251,64 @@ extern Lisp_Object Vdirectory_sep_char;
          : Fcons ((el), (check)))))
 
 
+/* SAFE_ALLOCA normally allocates memory on the stack, but if size is
+   larger than MAX_ALLOCA, use xmalloc to avoid overflowing the stack.  */
+
+#define MAX_ALLOCA 16*1024
+
+extern Lisp_Object safe_alloca_unwind (Lisp_Object);
+
+#define USE_SAFE_ALLOCA                 \
+  int sa_count = SPECPDL_INDEX ()
+
+/* SAFE_ALLOCA allocates a simple buffer.  */
+
+#define SAFE_ALLOCA(buf, type, size)                      \
+  do {                                                    \
+    if ((size) < MAX_ALLOCA)                              \
+      buf = (type) alloca (size);                         \
+    else                                                  \
+      {                                                   \
+        buf = (type) xmalloc (size);                      \
+        record_unwind_protect (safe_alloca_unwind,        \
+                               make_save_value (buf, 0)); \
+      }                                                   \
+  } while (0)
+
+/* SAFE_FREE frees xmalloced memory and enables GC as needed.  */
+
+#define SAFE_FREE(size)                 \
+  do {                                  \
+    if ((size) >= MAX_ALLOCA)           \
+      unbind_to (sa_count, Qnil);       \
+  } while (0)
+
+
+/* SAFE_ALLOCA_LISP allocates an array of Lisp_Objects.  */
+
+#define SAFE_ALLOCA_LISP(buf, nelt)                       \
+  do {                                                    \
+    int size_ = (nelt) * sizeof (Lisp_Object);            \
+    if (size_ < MAX_ALLOCA)                               \
+      buf = (Lisp_Object *) alloca (size_);               \
+    else                                                  \
+      {                                                   \
+        Lisp_Object arg_;                                 \
+        buf = (Lisp_Object *) xmalloc (size_);            \
+        arg_ = make_save_value (buf, nelt);               \
+        XSAVE_VALUE (arg_)->dogc = 1;                     \
+        record_unwind_protect (safe_alloca_unwind, arg_); \
+      }                                                   \
+  } while (0)
+
+#define SAFE_FREE_LISP(nelt)                            \
+  do {                                                  \
+    if (((nelt) * sizeof (Lisp_Object)) >= MAX_ALLOCA)  \
+      unbind_to (sa_count, Qnil);                       \
+  } while (0)
+
+
+
 #endif /* EMACS_LISP_H */
 
 /* arch-tag: 9b2ed020-70eb-47ac-94ee-e1c2a5107d5e
diff --git a/src/macfns.c b/src/macfns.c
index 5c1b7770640..ec014e772e3 100644
--- a/src/macfns.c
+++ b/src/macfns.c
@@ -2939,8 +2939,8 @@ If omitted or nil, that stands for the selected frame's display.  */)
 {
   struct mac_display_info *dpyinfo = check_x_display_info (display);
 
-  /* MAC_TODO: check whether this is right */
-  return make_number (dpyinfo->n_planes >= 8 ? 256 : 1 << dpyinfo->n_planes - 1);
+  /* We force 24+ bit depths to 24-bit to prevent an overflow.  */
+  return make_number (1 << min (dpyinfo->n_planes, 24));
 }
 
 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
diff --git a/src/macterm.c b/src/macterm.c
index 6a3cad56f46..2af910c5003 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -8840,10 +8840,16 @@ mac_initialize_display_info ()
   dpyinfo->resx = 75.0;
   dpyinfo->resy = 75.0;
   dpyinfo->color_p = TestDeviceAttribute (main_device_handle, gdDevType);
+#ifdef MAC_OSX
+  /* HasDepth returns true if it is possible to have a 32 bit display,
+     but this may not be what is actually used.  Mac OSX can do better.  */
+  dpyinfo->n_planes = CGDisplayBitsPerPixel (CGMainDisplayID ());
+#else
   for (dpyinfo->n_planes = 32; dpyinfo->n_planes > 0; dpyinfo->n_planes >>= 1)
     if (HasDepth (main_device_handle, dpyinfo->n_planes,
                   gdDevType, dpyinfo->color_p))
       break;
+#endif
   dpyinfo->height = (**main_device_handle).gdRect.bottom;
   dpyinfo->width = (**main_device_handle).gdRect.right;
   dpyinfo->grabbed = 0;
diff --git a/src/minibuf.c b/src/minibuf.c
index 2f05a56d7dd..d28a5799afa 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1212,6 +1212,7 @@ is used to further constrain the set of candidates.  */)
                            || NILP (XCAR (alist))));
   int index = 0, obsize = 0;
   int matchcount = 0;
+  int bindcount = -1;
   Lisp_Object bucket, zero, end, tem;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 
@@ -1290,21 +1291,22 @@ is used to further constrain the set of candidates.  */)
           XSETFASTINT (zero, 0);
 
           /* Ignore this element if it fails to match all the regexps.  */
-          if (CONSP (Vcompletion_regexp_list))
-            {
-              int count = SPECPDL_INDEX ();
-              specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
-              for (regexps = Vcompletion_regexp_list; CONSP (regexps);
-                   regexps = XCDR (regexps))
-                {
-                  tem = Fstring_match (XCAR (regexps), eltstring, zero);
-                  if (NILP (tem))
-                    break;
+          {
+            for (regexps = Vcompletion_regexp_list; CONSP (regexps);
+                 regexps = XCDR (regexps))
+              {
+                if (bindcount < 0) {
+                  bindcount = SPECPDL_INDEX ();
+                  specbind (Qcase_fold_search,
+                            completion_ignore_case ? Qt : Qnil);
                 }
-              unbind_to (count, Qnil);
-              if (CONSP (regexps))
-                continue;
-            }
+                tem = Fstring_match (XCAR (regexps), eltstring, zero);
+                if (NILP (tem))
+                  break;
+              }
+            if (CONSP (regexps))
+              continue;
+          }
 
           /* Ignore this element if there is a predicate
              and the predicate doesn't like it. */
@@ -1315,6 +1317,10 @@ is used to further constrain the set of candidates.  */)
                 tem = Fcommandp (elt, Qnil);
               else
                 {
+                  if (bindcount >= 0) {
+                    unbind_to (bindcount, Qnil);
+                    bindcount = -1;
+                  }
                   GCPRO4 (tail, string, eltstring, bestmatch);
                   tem = type == 3
                     ? call2 (predicate, elt,
@@ -1396,6 +1402,11 @@ is used to further constrain the set of candidates.  */)
         }
     }
 
+  if (bindcount >= 0) {
+    unbind_to (bindcount, Qnil);
+    bindcount = -1;
+  }
+
   if (NILP (bestmatch))
     return Qnil;                /* No completions found */
   /* If we are ignoring case, and there is no exact match,
@@ -1458,6 +1469,7 @@ are ignored unless STRING itself starts with a space.  */)
                        && (!SYMBOLP (XCAR (alist))
                            || NILP (XCAR (alist))));
   int index = 0, obsize = 0;
+  int bindcount = -1;
   Lisp_Object bucket, tem;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 
@@ -1542,21 +1554,22 @@ are ignored unless STRING itself starts with a space.  */)
           XSETFASTINT (zero, 0);
 
           /* Ignore this element if it fails to match all the regexps.  */
-          if (CONSP (Vcompletion_regexp_list))
-            {
-              int count = SPECPDL_INDEX ();
-              specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
-              for (regexps = Vcompletion_regexp_list; CONSP (regexps);
-                   regexps = XCDR (regexps))
-                {
-                  tem = Fstring_match (XCAR (regexps), eltstring, zero);
-                  if (NILP (tem))
-                    break;
+          {
+            for (regexps = Vcompletion_regexp_list; CONSP (regexps);
+                 regexps = XCDR (regexps))
+              {
+                if (bindcount < 0) {
+                  bindcount = SPECPDL_INDEX ();
+                  specbind (Qcase_fold_search,
+                            completion_ignore_case ? Qt : Qnil);
                 }
-              unbind_to (count, Qnil);
-              if (CONSP (regexps))
-                continue;
-            }
+                tem = Fstring_match (XCAR (regexps), eltstring, zero);
+                if (NILP (tem))
+                  break;
+              }
+            if (CONSP (regexps))
+              continue;
+          }
 
           /* Ignore this element if there is a predicate
              and the predicate doesn't like it. */
@@ -1567,6 +1580,10 @@ are ignored unless STRING itself starts with a space.  */)
                 tem = Fcommandp (elt, Qnil);
               else
                 {
+                  if (bindcount >= 0) {
+                    unbind_to (bindcount, Qnil);
+                    bindcount = -1;
+                  }
                   GCPRO4 (tail, eltstring, allmatches, string);
                   tem = type == 3
                     ? call2 (predicate, elt,
@@ -1581,6 +1598,11 @@ are ignored unless STRING itself starts with a space.  */)
         }
     }
 
+  if (bindcount >= 0) {
+    unbind_to (bindcount, Qnil);
+    bindcount = -1;
+  }
+
   return Fnreverse (allmatches);
 }
 
diff --git a/src/print.c b/src/print.c
index a91276d409a..0abd30b5ce0 100644
--- a/src/print.c
+++ b/src/print.c
@@ -658,7 +658,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 BUFFNAME BODY ...)  */)
+usage: (with-output-to-temp-buffer BUFNAME BODY ...)  */)
      (args)
      Lisp_Object args;
 {
diff --git a/src/search.c b/src/search.c
index 24f21f053a5..dc1ca91e38f 100644
--- a/src/search.c
+++ b/src/search.c
@@ -2589,15 +2589,20 @@ since only regular expressions have distinguished subexpressions.  */)
   /* Adjust search data for this change.  */
   {
     int oldend = search_regs.end[sub];
+    int oldstart = search_regs.start[sub];
     int change = newpoint - search_regs.end[sub];
     int i;
 
     for (i = 0; i < search_regs.num_regs; i++)
       {
-        if (search_regs.start[i] > oldend)
+        if (search_regs.start[i] >= oldend)
           search_regs.start[i] += change;
-        if (search_regs.end[i] > oldend)
+        else if (search_regs.start[i] > oldstart)
+          search_regs.start[i] = oldstart;
+        if (search_regs.end[i] >= oldend)
           search_regs.end[i] += change;
+        else if (search_regs.end[i] > oldstart)
+          search_regs.end[i] = oldstart;
       }
   }
 
@@ -2622,8 +2627,10 @@ match_limit (num, beginningp)
 
   CHECK_NUMBER (num);
   n = XINT (num);
-  if (n < 0 || search_regs.num_regs <= 0)
-    args_out_of_range (num, make_number (search_regs.num_regs));
+  if (n < 0)
+    args_out_of_range (num, 0);
+  if (search_regs.num_regs <= 0)
+    error ("No match data, because no search succeeded");
   if (n >= search_regs.num_regs
       || search_regs.start[n] < 0)
     return Qnil;
@@ -2664,8 +2671,11 @@ All the elements are markers or nil (nil if the Nth pair didn't match)
 if the last match was on a buffer; integers or nil if a string was matched.
 Use `store-match-data' to reinstate the data in this list.
 
-If INTEGERS (the optional first argument) is non-nil, always use integers
-\(rather than markers) to represent buffer positions.
+If INTEGERS (the optional first argument) is non-nil, always use
+integers \(rather than markers) to represent buffer positions.  In
+this case, and if the last match was in a buffer, the buffer will get
+stored as one additional element at the end of the list.
+
 If REUSE is a list, reuse it as part of the value.  If REUSE is long enough
 to hold all the values, and if INTEGERS is non-nil, no consing is done.
 
@@ -2682,10 +2692,10 @@ Return value is undefined if the last search failed.  */)
 
   prev = Qnil;
 
-  data = (Lisp_Object *) alloca ((2 * search_regs.num_regs)
+  data = (Lisp_Object *) alloca ((2 * search_regs.num_regs + 1)
                                  * sizeof (Lisp_Object));
 
-  len = -1;
+  len = 0;
   for (i = 0; i < search_regs.num_regs; i++)
     {
       int start = search_regs.start[i];
@@ -2712,22 +2722,29 @@ Return value is undefined if the last search failed.  */)
             /* last_thing_searched must always be Qt, a buffer, or Qnil.  */
             abort ();
 
-          len = i;
+          len = 2*(i+1);
         }
       else
         data[2 * i] = data [2 * i + 1] = Qnil;
     }
 
+  if (BUFFERP(last_thing_searched)
+      && ! NILP (integers))
+    {
+      XSETBUFFER(data[len], last_thing_searched);
+      len++;
+    }
+
   /* If REUSE is not usable, cons up the values and return them.  */
   if (! CONSP (reuse))
-    return Flist (2 * len + 2, data);
+    return Flist (len, data);
 
   /* If REUSE is a list, store as many value elements as will fit
      into the elements of REUSE.  */
   for (i = 0, tail = reuse; CONSP (tail);
        i++, tail = XCDR (tail))
     {
-      if (i < 2 * len + 2)
+      if (i < len)
         XSETCAR (tail, data[i]);
       else
         XSETCAR (tail, Qnil);
@@ -2736,8 +2753,8 @@ Return value is undefined if the last search failed.  */)
 
   /* If we couldn't fit all value elements into REUSE,
      cons up the rest of them and add them to the end of REUSE.  */
-  if (i < 2 * len + 2)
-    XSETCDR (prev, Flist (2 * len + 2 - i, data + i));
+  if (i < len)
+    XSETCDR (prev, Flist (len - i, data + i));
 
   return reuse;
 }
@@ -2758,8 +2775,8 @@ LIST should have been created by calling `match-data' previously.  */)
   if (!CONSP (list) && !NILP (list))
     list = wrong_type_argument (Qconsp, list);
 
-  /* Unless we find a marker with a buffer in LIST, assume that this
-     match data came from a string.  */
+  /* Unless we find a marker with a buffer or an explicit buffer
+     in LIST, assume that this match data came from a string.  */
   last_thing_searched = Qt;
 
   /* Allocate registers if they don't already exist.  */
@@ -2790,42 +2807,49 @@ LIST should have been created by calling `match-data' previously.  */)
 
         search_regs.num_regs = length;
       }
-  }
 
-  for (i = 0; i < search_regs.num_regs; i++)
-    {
-      marker = Fcar (list);
-      if (NILP (marker))
-        {
-          search_regs.start[i] = -1;
-          list = Fcdr (list);
-        }
-      else
-        {
-          int from;
-
-          if (MARKERP (marker))
-            {
-              if (XMARKER (marker)->buffer == 0)
-                XSETFASTINT (marker, 0);
-              else
-                XSETBUFFER (last_thing_searched, XMARKER (marker)->buffer);
-            }
-
-          CHECK_NUMBER_COERCE_MARKER (marker);
-          from = XINT (marker);
-          list = Fcdr (list);
+    for (i = 0; i < length; i++)
+      {
+        marker = Fcar (list);
+        if (NILP (marker))
+          {
+            search_regs.start[i] = -1;
+            list = Fcdr (list);
+          }
+        else
+          {
+            int from;
+            
+            if (MARKERP (marker))
+              {
+                if (XMARKER (marker)->buffer == 0)
+                  XSETFASTINT (marker, 0);
+                else
+                  XSETBUFFER (last_thing_searched, XMARKER (marker)->buffer);
+              }
+            
+            CHECK_NUMBER_COERCE_MARKER (marker);
+            from = XINT (marker);
+            list = Fcdr (list);
+            
+            marker = Fcar (list);
+            if (MARKERP (marker) && XMARKER (marker)->buffer == 0)
+              XSETFASTINT (marker, 0);
+            
+            CHECK_NUMBER_COERCE_MARKER (marker);
+            search_regs.start[i] = from;
+            search_regs.end[i] = XINT (marker);
+          }
+        list = Fcdr (list);
+      }
 
-          marker = Fcar (list);
-          if (MARKERP (marker) && XMARKER (marker)->buffer == 0)
-            XSETFASTINT (marker, 0);
+    for (; i < search_regs.num_regs; i++)
+      search_regs.start[i] = -1;
+  }
 
-          CHECK_NUMBER_COERCE_MARKER (marker);
-          search_regs.start[i] = from;
-          search_regs.end[i] = XINT (marker);
-        }
-      list = Fcdr (list);
-    }
+  if (CONSP(list) && BUFFERP(XCAR(list))) {
+    XSETBUFFER(last_thing_searched, XCAR(list));
+  }
 
   return Qnil;
 }
@@ -2834,6 +2858,7 @@ LIST should have been created by calling `match-data' previously.  */)
    during the execution of a sentinel or filter. */
 static int search_regs_saved;
 static struct re_registers saved_search_regs;
+static Lisp_Object saved_last_thing_searched;
 
 /* Called from Flooking_at, Fstring_match, search_buffer, Fstore_match_data
    if asynchronous code (filter or sentinel) is running. */
@@ -2845,6 +2870,8 @@ save_search_regs ()
       saved_search_regs.num_regs = search_regs.num_regs;
       saved_search_regs.start = search_regs.start;
       saved_search_regs.end = search_regs.end;
+      saved_last_thing_searched = last_thing_searched;
+      last_thing_searched = Qnil;
       search_regs.num_regs = 0;
       search_regs.start = 0;
       search_regs.end = 0;
@@ -2867,7 +2894,8 @@ restore_match_data ()
       search_regs.num_regs = saved_search_regs.num_regs;
       search_regs.start = saved_search_regs.start;
       search_regs.end = saved_search_regs.end;
-
+      last_thing_searched = saved_last_thing_searched;
+      saved_last_thing_searched = Qnil;
       search_regs_saved = 0;
     }
 }
diff --git a/src/syntax.c b/src/syntax.c
index 62612620f03..302250c39a4 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -1455,7 +1455,7 @@ skip_chars (forwardp, syntaxp, string, lim, handle_iso_classes)
             {
               const unsigned char *class_beg = str + i_byte + 1;
               const unsigned char *class_end = class_beg;
-              const unsigned char *class_limit = str + size_byte;
+              const unsigned char *class_limit = str + size_byte - 2;
               /* Leave room for the null.        */
               unsigned char class_name[CHAR_CLASS_MAX_LENGTH + 1];
               re_wctype_t cc;
@@ -1463,17 +1463,13 @@ skip_chars (forwardp, syntaxp, string, lim, handle_iso_classes)
               if (class_limit - class_beg > CHAR_CLASS_MAX_LENGTH)
                 class_limit = class_beg + CHAR_CLASS_MAX_LENGTH;
 
-              while (class_end != class_limit
-                     && ! (*class_end >= 0200
-                           || *class_end <= 040
-                           || (*class_end == ':'
-                               && class_end[1] == ']')))
+              while (class_end < class_limit
+                     && *class_end >= 'a' && *class_end <= 'z')
                 class_end++;
 
-              if (class_end == class_limit
-                  || *class_end >= 0200
-                  || *class_end <= 040)
-                error ("Invalid ISO C character class");
+              if (class_end == class_beg
+                  || *class_end != ':' || class_end[1] != ']')
+                goto not_a_class_name;
 
               bcopy (class_beg, class_name, class_end - class_beg);
               class_name[class_end - class_beg] = 0;
@@ -1488,6 +1484,7 @@ skip_chars (forwardp, syntaxp, string, lim, handle_iso_classes)
               continue;
             }
 
+        not_a_class_name:
           if (c == '\\')
             {
               if (i_byte == size_byte)
diff --git a/src/window.c b/src/window.c
index ff0d810a9c8..5b4c8928232 100644
--- a/src/window.c
+++ b/src/window.c
@@ -6506,9 +6506,10 @@ using `special-display-function'.  See also `special-display-regexps'.
 An element of the list can be a list instead of just a string.
 There are two ways to use a list as an element:
   (BUFFER FRAME-PARAMETERS...)   (BUFFER FUNCTION OTHER-ARGS...)
-In the first case, FRAME-PARAMETERS are used to create the frame.
-In the latter case, FUNCTION is called with BUFFER as the first argument,
-followed by OTHER-ARGS--it can display BUFFER in any way it likes.
+In the first case, the FRAME-PARAMETERS are pairs of the form
+\(PARAMETER . VALUE); these parameter values are used to create the frame.
+In the second case, FUNCTION is called with BUFFER as the first argument,
+followed by the OTHER-ARGS--it can display BUFFER in any way it likes.
 All this is done by the function found in `special-display-function'.
 
 If the specified frame parameters include (same-buffer . t), the
@@ -6531,9 +6532,10 @@ using `special-display-function'.
 An element of the list can be a list instead of just a string.
 There are two ways to use a list as an element:
   (REGEXP FRAME-PARAMETERS...)   (REGEXP FUNCTION OTHER-ARGS...)
-In the first case, FRAME-PARAMETERS are used to create the frame.
-In the latter case, FUNCTION is called with the buffer as first argument,
-followed by OTHER-ARGS--it can display the buffer in any way it likes.
+In the first case, the FRAME-PARAMETERS are pairs of the form
+\(PARAMETER . VALUE); these parameter values are used to create the frame.
+In the second case, FUNCTION is called with BUFFER as the first argument,
+followed by the OTHER-ARGS--it can display the buffer in any way it likes.
 All this is done by the function found in `special-display-function'.
 
 If the specified frame parameters include (same-buffer . t), the
diff --git a/src/window.h b/src/window.h
index 59052af96a5..63a19cc4b0d 100644
--- a/src/window.h
+++ b/src/window.h
@@ -1,5 +1,5 @@
 /* Window definitions for GNU Emacs.
-   Copyright (C) 1985, 1986, 1993, 1995, 1997, 1998, 1999, 2000, 2001, 2003
+   Copyright (C) 1985,86,93,95,97,98,99, 2000,01,03,04
    Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
diff --git a/src/xdisp.c b/src/xdisp.c
index d2410aa82bb..b04eb7ab7b7 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -6311,6 +6311,7 @@ add_to_log (format, arg1, arg2)
   char *buffer;
   int len;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+  USE_SAFE_ALLOCA;
 
   /* Do nothing if called asynchronously.  Inserting text into
      a buffer may call after-change-functions and alike and
@@ -6327,10 +6328,12 @@ add_to_log (format, arg1, arg2)
   msg = Fformat (3, args);
 
   len = SBYTES (msg) + 1;
-  buffer = (char *) alloca (len);
+  SAFE_ALLOCA (buffer, char *, len);
   bcopy (SDATA (msg), buffer, len);
 
   message_dolog (buffer, len - 1, 1, 0);
+  SAFE_FREE (len);
+
   UNGCPRO;
 }
 
@@ -11263,7 +11266,7 @@ try_cursor_movement (window, startp, scroll_step)
       && (FRAME_WINDOW_P (f)
           || !overlay_arrow_in_current_buffer_p ()))
     {
-      int this_scroll_margin;
+      int this_scroll_margin, top_scroll_margin;
       struct glyph_row *row = NULL;
 
 #if GLYPH_DEBUG
@@ -11276,6 +11279,10 @@ try_cursor_movement (window, startp, scroll_step)
       this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
       this_scroll_margin *= FRAME_LINE_HEIGHT (f);
 
+      top_scroll_margin = this_scroll_margin;
+      if (WINDOW_WANTS_HEADER_LINE_P (w))
+        top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
+
       /* Start with the row the cursor was displayed during the last
          not paused redisplay.  Give up if that row is not valid.  */
       if (w->last_cursor.vpos < 0
@@ -11336,7 +11343,7 @@ try_cursor_movement (window, startp, scroll_step)
                      && (MATRIX_ROW_START_CHARPOS (row) > PT
                          || (MATRIX_ROW_START_CHARPOS (row) == PT
                              && MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row)))
-                     && (row->y > this_scroll_margin
+                     && (row->y > top_scroll_margin
                          || CHARPOS (startp) == BEGV))
                 {
                   xassert (row->enabled_p);
@@ -11364,7 +11371,7 @@ try_cursor_movement (window, startp, scroll_step)
                 ++row;
 
               /* If within the scroll margin, scroll.  */
-              if (row->y < this_scroll_margin
+              if (row->y < top_scroll_margin
                   && CHARPOS (startp) != BEGV)
                 scroll_p = 1;
             }
@@ -12537,9 +12544,8 @@ try_window_reusing_current_matrix (w)
          position.  */
       if (pt_row)
         {
-          w->cursor.vpos -= MATRIX_ROW_VPOS (first_reusable_row,
-                                             w->current_matrix);
-          w->cursor.y -= first_reusable_row->y;
+          w->cursor.vpos -= nrows_scrolled;
+          w->cursor.y -= first_reusable_row->y - start_row->y;
         }
 
       /* Scroll the display.  */
@@ -12584,6 +12590,29 @@ try_window_reusing_current_matrix (w)
       for (row -= nrows_scrolled; row < bottom_row; ++row)
         row->enabled_p = 0;
 
+      /* Point may have moved to a different line, so we cannot assume that
+         the previous cursor position is valid; locate the correct row.  */
+      if (pt_row)
+        {
+          for (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
+               row < bottom_row && PT >= MATRIX_ROW_END_CHARPOS (row);
+               row++)
+            {
+              w->cursor.vpos++;
+              w->cursor.y = row->y;
+            }
+          if (row < bottom_row)
+            {
+              struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
+              while (glyph->charpos < PT)
+                {
+                  w->cursor.hpos++;
+                  w->cursor.x += glyph->pixel_width;
+                  glyph++;
+                }
+            }
+        }
+
       /* Adjust window end.  A null value of last_text_row means that
          the window end is in reused rows which in turn means that
          only its vpos can have changed.  */
@@ -13367,9 +13396,9 @@ try_window_id (w)
 
     if ((w->cursor.y < this_scroll_margin
          && CHARPOS (start) > BEGV)
-        /* Don't take scroll margin into account at the bottom because
-           old redisplay didn't do it either.  */
-        || w->cursor.y + cursor_height > it.last_visible_y)
+        /* Old redisplay didn't take scroll margin into account at the bottom,
+           but then global-hl-line-mode doesn't scroll.  KFS 2004-06-14 */
+        || w->cursor.y + cursor_height + this_scroll_margin > it.last_visible_y)
       {
         w->cursor.vpos = -1;
         clear_glyph_matrix (w->desired_matrix);
diff --git a/src/xfaces.c b/src/xfaces.c
index 171472dbb31..a5d5c97a332 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -3899,12 +3899,13 @@ Otherwise check for the existence of a global face.  */)
 DEFUN ("internal-copy-lisp-face", Finternal_copy_lisp_face,
        Sinternal_copy_lisp_face, 4, 4, 0,
        doc: /* Copy face FROM to TO.
-If FRAME is t, copy the global face definition of FROM to the
-global face definition of TO.  Otherwise, copy the frame-local
-definition of FROM on FRAME to the frame-local definition of TO
-on NEW-FRAME, or FRAME if NEW-FRAME is nil.
+If FRAME is t, copy the global face definition of FROM.
+Otherwise, copy the frame-local definition of FROM on FRAME.
+If NEW-FRAME is a frame, copy that data into the frame-local
+definition of TO on NEW-FRAME.  If NEW-FRAME is nil.
+FRAME controls where the data is copied to.
 
-Value is TO.  */)
+The value is TO.  */)
      (from, to, frame, new_frame)
      Lisp_Object from, to, frame, new_frame;
 {
@@ -3912,8 +3913,6 @@ Value is TO.  */)
 
   CHECK_SYMBOL (from);
   CHECK_SYMBOL (to);
-  if (NILP (new_frame))
-    new_frame = frame;
 
   if (EQ (frame, Qt))
     {
@@ -3925,6 +3924,8 @@ Value is TO.  */)
   else
     {
       /* Copy frame-local definition of FROM.  */
+      if (NILP (new_frame))
+        new_frame = frame;
       CHECK_LIVE_FRAME (frame);
       CHECK_LIVE_FRAME (new_frame);
       lface = lface_from_face_name (XFRAME (frame), from, 1);
diff --git a/src/xselect.c b/src/xselect.c
index 637b39272b7..8c8f1f98668 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1,5 +1,5 @@
 /* X Selection processing for Emacs.
-   Copyright (C) 1993, 1994, 1995, 1996, 1997, 2000, 2001, 2003
+   Copyright (C) 1993, 1994, 1995, 1996, 1997, 2000, 2001, 2003, 2004
    Free Software Foundation.
 
 This file is part of GNU Emacs.
@@ -2608,7 +2608,7 @@ are ignored.  */)
   if (event.xclient.format != 8 && event.xclient.format != 16
       && event.xclient.format != 32)
     error ("FORMAT must be one of 8, 16 or 32");
-  
+
   if (FRAMEP (dest) || NILP (dest))
     {
       struct frame *fdest = check_x_frame (dest);
diff --git a/src/xsmfns.c b/src/xsmfns.c
index 35c7429b66b..080f998e779 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -1,6 +1,6 @@
 /* Session management module for systems which understand the X Session
    management protocol.
-   Copyright (C) 2002 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/xterm.c b/src/xterm.c
index 289f7771852..c17146bde1d 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -1,5 +1,5 @@
 /* X Communication module for terminals which understand the X protocol.
-   Copyright (C) 1989, 93, 94, 95, 96, 97, 98, 1999, 2000, 01, 02, 2003
+   Copyright (C) 1989, 93, 94, 95, 96, 97, 98, 1999, 2000,01,02,03,04
    Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -2359,8 +2359,8 @@ x_draw_image_foreground_1 (s, pixmap)
           XGCValues xgcv;
 
           xgcv.clip_mask = s->img->mask;
-          xgcv.clip_x_origin = x;
-          xgcv.clip_y_origin = y;
+          xgcv.clip_x_origin = x - s->slice.x;
+          xgcv.clip_y_origin = y - s->slice.y;
           xgcv.function = GXcopy;
           XChangeGC (s->display, s->gc, mask, &xgcv);
 
diff --git a/src/xterm.h b/src/xterm.h
index a71bd275e6f..f0e86f0ecab 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -1,5 +1,5 @@
 /* Definitions and headers for communication with X protocol.
-   Copyright (C) 1989, 1993, 1994, 1998, 1999, 2000, 2001, 2001
+   Copyright (C) 1989, 1993, 1994, 1998, 1999, 2000,01,02,03,04
    Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.