Merge from mainline.

11 files changed, 123 insertions, 45 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index ac909cc7885..ce4fe1cd7b4 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,47 @@
+2010-03-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Make it possible to C-g in a tight bytecode loop again (bug#5680).
+        * lisp.h (ELSE_PENDING_SIGNALS): New macro.
+        (QUIT): Use it to consolidate code and remove redundancy.
+        * bytecode.c (BYTE_CODE_QUIT): Use it as well.
+
+        * regex.c (regex_compile): Setup gl_state as well.
+
+        * syntax.c (skip_chars): Setup gl_state (bug#3823).
+        (in_classes): Use CONSP before XCAR/XCDR.
+
+2010-03-03  Chong Yidong  <cyd@stupidchicken.com>
+
+        * keymap.c (Fwhere_is_internal): Use Fequal to compare
+        definitions, so that keyboard macros are correctly handled
+        (Bug#5481).
+
+2010-03-02  Eli Zaretskii  <eliz@gnu.org>
+
+        * coding.c (decode_coding_emacs_mule): Fixup pointers to buffer
+        text that could be relocated inside the call to emacs_mule_char.
+        (emacs_mule_char): Use CODING_DECODE_CHAR instead of DECODE_CHAR.
+        (CODING_DECODE_CHAR): Add a comment describing its purpose.
+
+2010-03-02  Kenichi Handa  <handa@m17n.org>
+
+        * character.c (parse_str_as_multibyte): Fix handling of the
+        multibyte form of raw-bytes.
+        (str_as_multibyte): Likewise.
+
+        * buffer.c (Fset_buffer_multibyte): Fix handling of the multibyte
+        form of raw-bytes.
+
+2010-02-28  Chong Yidong  <cyd@stupidchicken.com>
+
+        * charset.c (load_charset_map_from_file)
+        (load_charset_map_from_vector): Zero out allocated
+        charset_map_entries before using them.
+
+2010-02-27  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * w32uniscribe.c (uniscribe_check_otf): Fix length check.
+
 2010-02-27  Chong Yidong  <cyd@stupidchicken.com>
 
         * font.c (font_parse_fcname): Recognize "Book", "Condensed",
diff --git a/src/buffer.c b/src/buffer.c
index 4d590248e24..0c6e57d45be 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -2499,7 +2499,9 @@ current buffer is cleared.  */)
 
           if (ASCII_BYTE_P (*p))
             p++, pos++;
-          else if (EQ (flag, Qt) && (bytes = MULTIBYTE_LENGTH (p, pend)) > 0)
+          else if (EQ (flag, Qt)
+                   && ! CHAR_BYTE8_HEAD_P (*p)
+                   && (bytes = MULTIBYTE_LENGTH (p, pend)) > 0)
             p += bytes, pos += bytes;
           else
             {
diff --git a/src/bytecode.c b/src/bytecode.c
index 31df65fd303..e95614c72a9 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -393,6 +393,7 @@ unmark_byte_stack ()
         Fsignal (Qquit, Qnil);                          \
         AFTER_POTENTIAL_GC ();                          \
       }                                                 \
+    ELSE_PENDING_SIGNALS                                \
   } while (0)
 
 
diff --git a/src/character.c b/src/character.c
index 583602fccb7..5912a70d0ce 100644
--- a/src/character.c
+++ b/src/character.c
@@ -630,7 +630,8 @@ parse_str_as_multibyte (str, len, nchars, nbytes)
       const unsigned char *adjusted_endp = endp - MAX_MULTIBYTE_LENGTH;
       while (str < adjusted_endp)
         {
-          if ((n = MULTIBYTE_LENGTH_NO_CHECK (str)) > 0)
+          if (! CHAR_BYTE8_HEAD_P (*str)
+              && (n = MULTIBYTE_LENGTH_NO_CHECK (str)) > 0)
             str += n, bytes += n;
           else
             str++, bytes += 2;
@@ -639,7 +640,8 @@ parse_str_as_multibyte (str, len, nchars, nbytes)
     }
   while (str < endp)
     {
-      if ((n = MULTIBYTE_LENGTH (str, endp)) > 0)
+      if (! CHAR_BYTE8_HEAD_P (*str)
+          && (n = MULTIBYTE_LENGTH (str, endp)) > 0)
         str += n, bytes += n;
       else
         str++, bytes += 2;
@@ -673,10 +675,13 @@ str_as_multibyte (str, len, nbytes, nchars)
     {
       unsigned char *adjusted_endp = endp - MAX_MULTIBYTE_LENGTH;
       while (p < adjusted_endp
+             && ! CHAR_BYTE8_HEAD_P (*p)
              && (n = MULTIBYTE_LENGTH_NO_CHECK (p)) > 0)
         p += n, chars++;
     }
-  while ((n = MULTIBYTE_LENGTH (p, endp)) > 0)
+  while (p < endp
+         && ! CHAR_BYTE8_HEAD_P (*p)
+         && (n = MULTIBYTE_LENGTH (p, endp)) > 0)
     p += n, chars++;
   if (nchars)
     *nchars = chars;
@@ -694,7 +699,8 @@ str_as_multibyte (str, len, nbytes, nchars)
       unsigned char *adjusted_endp = endp - MAX_MULTIBYTE_LENGTH;
       while (p < adjusted_endp)
         {
-          if ((n = MULTIBYTE_LENGTH_NO_CHECK (p)) > 0)
+          if (! CHAR_BYTE8_HEAD_P (*p)
+              && (n = MULTIBYTE_LENGTH_NO_CHECK (p)) > 0)
             {
               while (n--)
                 *to++ = *p++;
@@ -710,7 +716,8 @@ str_as_multibyte (str, len, nbytes, nchars)
     }
   while (p < endp)
     {
-      if ((n = MULTIBYTE_LENGTH (p, endp)) > 0)
+      if (! CHAR_BYTE8_HEAD_P (*p)
+          && (n = MULTIBYTE_LENGTH (p, endp)) > 0)
         {
           while (n--)
             *to++ = *p++;
diff --git a/src/charset.c b/src/charset.c
index 1db9ec17ae7..125c9131687 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -531,6 +531,7 @@ load_charset_map_from_file (charset, mapfile, control_flag)
   SAFE_ALLOCA (head, struct charset_map_entries *,
                sizeof (struct charset_map_entries));
   entries = head;
+  bzero (entries, sizeof (struct charset_map_entries));
 
   n_entries = 0;
   eof = 0;
@@ -557,6 +558,7 @@ load_charset_map_from_file (charset, mapfile, control_flag)
           SAFE_ALLOCA (entries->next, struct charset_map_entries *,
                        sizeof (struct charset_map_entries));
           entries = entries->next;
+          bzero (entries, sizeof (struct charset_map_entries));
         }
       idx = n_entries % 0x10000;
       entries->entry[idx].from = from;
@@ -596,6 +598,7 @@ load_charset_map_from_vector (charset, vec, control_flag)
   SAFE_ALLOCA (head, struct charset_map_entries *,
                sizeof (struct charset_map_entries));
   entries = head;
+  bzero (entries, sizeof (struct charset_map_entries));
 
   n_entries = 0;
   for (i = 0; i < len; i += 2)
@@ -632,6 +635,7 @@ load_charset_map_from_vector (charset, vec, control_flag)
           SAFE_ALLOCA (entries->next, struct charset_map_entries *,
                        sizeof (struct charset_map_entries));
           entries = entries->next;
+          bzero (entries, sizeof (struct charset_map_entries));
         }
       idx = n_entries % 0x10000;
       entries->entry[idx].from = from;
diff --git a/src/coding.c b/src/coding.c
index 2144fe5fcd4..df81eaba16e 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -1005,6 +1005,10 @@ record_conversion_result (struct coding_system *coding,
     }
 }
 
+/* This wrapper macro is used to preserve validity of pointers into
+   buffer text across calls to decode_char, which could cause
+   relocation of buffers if it loads a charset map, because loading a
+   charset map allocates large structures.  */
 #define CODING_DECODE_CHAR(coding, src, src_base, src_end, charset, code, c) \
   do {                                                                       \
     charset_map_loaded = 0;                                                  \
@@ -2061,7 +2065,7 @@ detect_coding_emacs_mule (coding, detect_info)
 /* Parse emacs-mule multibyte sequence at SRC and return the decoded
    character.  If CMP_STATUS indicates that we must expect MSEQ or
    RULE described above, decode it and return the negative value of
-   the deocded character or rule.  If an invalid byte is found, return
+   the decoded character or rule.  If an invalid byte is found, return
    -1.  If SRC is too short, return -2.  */
 
 int
@@ -2178,7 +2182,7 @@ emacs_mule_char (coding, src, nbytes, nchars, id, cmp_status)
         default:
           abort ();
         }
-      c = DECODE_CHAR (charset, code);
+      CODING_DECODE_CHAR (coding, src, src_base, src_end, charset, code, c);
       if (c < 0)
         goto invalid_code;
     }
@@ -2525,9 +2529,23 @@ decode_coding_emacs_mule (coding)
       else
         {
           int nchars, nbytes;
+          /* emacs_mule_char can load a charset map from a file, which
+             allocates a large structure and might cause buffer text
+             to be relocated as result.  Thus, we need to remember the
+             original pointer to buffer text, and fixup all related
+             pointers after the call.  */
+          const unsigned char *orig = coding->source;
+          EMACS_INT offset;
 
           c = emacs_mule_char (coding, src_base, &nbytes, &nchars, &id,
                                cmp_status);
+          offset = coding->source - orig;
+          if (offset)
+            {
+              src += offset;
+              src_base += offset;
+              src_end += offset;
+            }
           if (c < 0)
             {
               if (c == -1)
diff --git a/src/keymap.c b/src/keymap.c
index 98774d5d685..88e0687272f 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1633,13 +1633,13 @@ like in the respective argument of `key-binding'. */)
   /* If a mouse click position is given, our variables are based on
      the buffer clicked on, not the current buffer.  So we may have to
      switch the buffer here. */
-  
+
   if (CONSP (position))
     {
       Lisp_Object window;
-      
+
       window = POSN_WINDOW (position);
-          
+
       if (WINDOWP (window)
           && BUFFERP (XWINDOW (window)->buffer)
           && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
@@ -1651,14 +1651,14 @@ like in the respective argument of `key-binding'. */)
              would not be a problem here, but it is easier to keep
              things the same.
           */
-              
+
           record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
-          
+
           set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
         }
     }
 
-  keymaps = Fcons (current_global_map, Qnil);  
+  keymaps = Fcons (current_global_map, Qnil);
 
   if (!NILP (olp))
     {
@@ -1685,8 +1685,8 @@ like in the respective argument of `key-binding'. */)
       /* Get the buffer local maps, possibly overriden by text or
          overlay properties */
 
-      local_map = get_local_map (pt, current_buffer, Qlocal_map); 
-      keymap = get_local_map (pt, current_buffer, Qkeymap); 
+      local_map = get_local_map (pt, current_buffer, Qlocal_map);
+      keymap = get_local_map (pt, current_buffer, Qkeymap);
 
       if (CONSP (position))
         {
@@ -1694,7 +1694,7 @@ like in the respective argument of `key-binding'. */)
 
           /* For a mouse click, get the local text-property keymap
              of the place clicked on, rather than point.  */
-          
+
           if (POSN_INBUFFER_P (position))
             {
               Lisp_Object pos;
@@ -1705,7 +1705,7 @@ like in the respective argument of `key-binding'. */)
                 {
                   local_map = get_local_map (XINT (pos),
                                              current_buffer, Qlocal_map);
-                  
+
                   keymap = get_local_map (XINT (pos),
                                           current_buffer, Qkeymap);
                 }
@@ -1716,12 +1716,12 @@ like in the respective argument of `key-binding'. */)
              string displayed via the `display' property,
              consider `local-map' and `keymap' properties of
              that string.  */
-          
+
           if (string = POSN_STRING (position),
               (CONSP (string) && STRINGP (XCAR (string))))
             {
               Lisp_Object pos, map;
-              
+
               pos = XCDR (string);
               string = XCAR (string);
               if (INTEGERP (pos)
@@ -1737,7 +1737,7 @@ like in the respective argument of `key-binding'. */)
                     keymap = map;
                 }
             }
-          
+
         }
 
       if (!NILP (local_map))
@@ -2890,7 +2890,7 @@ remapped command in the returned list.  */)
              CONSP (sequences)))
     {
       Lisp_Object sequence, function;
-          
+
       sequence = XCAR (sequences);
       sequences = XCDR (sequences);
 
@@ -2903,8 +2903,8 @@ remapped command in the returned list.  */)
 
          Either nil or number as value from Flookup_key
          means undefined.  */
-      if (!EQ (shadow_lookup (keymaps, sequence, Qnil, remapped),
-               definition))
+      if (NILP (Fequal (shadow_lookup (keymaps, sequence, Qnil, remapped),
+                        definition)))
         continue;
 
       /* If the current sequence is a command remapping with
@@ -2933,12 +2933,12 @@ remapped command in the returned list.  */)
             Faset (sequence, make_number (ASIZE (sequence) - 1),
                    build_string ("(any string)"));
         }
-      
+
       /* It is a true unshadowed match.  Record it, unless it's already
          been seen (as could happen when inheriting keymaps).  */
       if (NILP (Fmember (sequence, found)))
         found = Fcons (sequence, found);
-      
+
       /* If firstonly is Qnon_ascii, then we can return the first
          binding we find.  If firstonly is not Qnon_ascii but not
          nil, then we should return the first ascii-only binding
diff --git a/src/lisp.h b/src/lisp.h
index 7032a3f48f4..7f5d5df66c6 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1933,22 +1933,12 @@ extern char *stack_bottom;
 #ifdef SYNC_INPUT
 extern void process_pending_signals P_ ((void));
 extern int pending_signals;
-
-#define QUIT                                            \
-  do {                                                  \
-    if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))     \
-      {                                                 \
-        Lisp_Object flag = Vquit_flag;                  \
-        Vquit_flag = Qnil;                              \
-        if (EQ (Vthrow_on_input, flag))                 \
-          Fthrow (Vthrow_on_input, Qt);                 \
-        Fsignal (Qquit, Qnil);                          \
-      }                                                 \
-    else if (pending_signals)                           \
-      process_pending_signals ();                       \
-  } while (0)
-
+#define ELSE_PENDING_SIGNALS                            \
+  else if (pending_signals)                             \
+    process_pending_signals ();
 #else  /* not SYNC_INPUT */
+#define ELSE_PENDING_SIGNALS
+#endif  /* not SYNC_INPUT */
 
 #define QUIT                                            \
   do {                                                  \
@@ -1960,10 +1950,9 @@ extern int pending_signals;
           Fthrow (Vthrow_on_input, Qt);                 \
         Fsignal (Qquit, Qnil);                          \
       }                                                 \
+    ELSE_PENDING_SIGNALS                                \
   } while (0)
 
-#endif  /* not SYNC_INPUT */
-
 
 /* Nonzero if ought to quit now.  */
 
diff --git a/src/regex.c b/src/regex.c
index bb921a5b519..f242446796d 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -3065,6 +3065,13 @@ regex_compile (pattern, size, syntax, bufp)
                            don't need to handle them for multibyte.
                            They are distinguished by a negative wctype.  */
 
+                        /* Setup the gl_state object to its buffer-defined
+                           value.  This hardcodes the buffer-global
+                           syntax-table for ASCII chars, while the other chars
+                           will obey syntax-table properties.  It's not ideal,
+                           but it's the way it's been done until now.  */
+                        SETUP_SYNTAX_TABLE (BEGV, 0);
+
                         for (ch = 0; ch < 256; ++ch)
                           {
                             c = RE_CHAR_TO_MULTIBYTE (ch);
diff --git a/src/syntax.c b/src/syntax.c
index 01b4cfb8892..47b4caf5ade 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -1747,6 +1747,12 @@ skip_chars (forwardp, string, lim, handle_iso_classes)
       }
 
     immediate_quit = 1;
+    /* This code may look up syntax tables using macros that rely on the
+       gl_state object.  To make sure this object is not out of date,
+       let's initialize it manually.
+       We ignore syntax-table text-properties for now, since that's
+       what we've done in the past.  */
+    SETUP_SYNTAX_TABLE (BEGV, 0);
     if (forwardp)
       {
         if (multibyte)
@@ -2072,7 +2078,7 @@ in_classes (c, iso_classes)
 {
   int fits_class = 0;
 
-  while (! NILP (iso_classes))
+  while (CONSP (iso_classes))
     {
       Lisp_Object elt;
       elt = XCAR (iso_classes);
diff --git a/src/w32uniscribe.c b/src/w32uniscribe.c
index f2bd0f44b50..cfdf629ceee 100644
--- a/src/w32uniscribe.c
+++ b/src/w32uniscribe.c
@@ -666,7 +666,7 @@ int uniscribe_check_otf (font, otf_spec)
   struct gcpro gcpro1;
 
   /* Check the spec is in the right format.  */
-  if (!CONSP (otf_spec) || Flength (otf_spec) < 3)
+  if (!CONSP (otf_spec) || XINT (Flength (otf_spec)) < 3)
     return 0;
 
   /* Break otf_spec into its components.  */