(skip_chars): Merge mule changes back in.

1 files changed, 165 insertions, 20 deletions

diff --git a/src/syntax.c b/src/syntax.c
index a259aafeede..9ead7e64346 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -1133,9 +1133,21 @@ skip_chars (forwardp, syntaxp, string, lim)
 {
   register unsigned char *p, *pend;
   register unsigned int c;
+  register int ch;
   unsigned char fastmap[0400];
+  /* If SYNTAXP is 0, STRING may contain multi-byte form of characters
+     of which codes don't fit in FASTMAP.  In that case, we set the
+     first byte of multibyte form (i.e. base leading-code) in FASTMAP
+     and set the actual ranges of characters in CHAR_RANGES.  In the
+     form "X-Y" of STRING, both X and Y must belong to the same
+     character set because a range striding across character sets is
+     meaningless.  */
+  int *char_ranges
+    = (int *) alloca (XSTRING (string)->size * (sizeof (int)) * 2);
+  int n_char_ranges = 0;
   int negate = 0;
   register int i;
+  int multibyte = !NILP (current_buffer->enable_multibyte_characters);
 
   CHECK_STRING (string, 0);
 
@@ -1168,7 +1180,17 @@ skip_chars (forwardp, syntaxp, string, lim)
 
   while (p != pend)
     {
-      c = *p++;
+      c = *p;
+      if (multibyte)
+        {
+          ch = STRING_CHAR (p, pend - p);
+          p += BYTES_BY_CHAR_HEAD (*p);
+        }
+      else
+        {
+          ch = c;
+          p++;
+        }
       if (syntaxp)
         fastmap[syntax_spec_code[c]] = 1;
       else
@@ -1180,25 +1202,51 @@ skip_chars (forwardp, syntaxp, string, lim)
             }
           if (p != pend && *p == '-')
             {
+              unsigned int ch2;
+
               p++;
               if (p == pend) break;
-              while (c <= *p)
+              if (SINGLE_BYTE_CHAR_P (ch))
+                while (c <= *p)
+                  {
+                    fastmap[c] = 1;
+                    c++;
+                  }
+              else
                 {
-                  fastmap[c] = 1;
-                  c++;
+                  fastmap[c] = 1; /* C is the base leading-code.  */
+                  ch2 = STRING_CHAR (p, pend - p);
+                  if (ch <= ch2)
+                    char_ranges[n_char_ranges++] = ch,
+                    char_ranges[n_char_ranges++] = ch2;
                 }
-              p++;
+              p += multibyte ? BYTES_BY_CHAR_HEAD (*p) : 1;
             }
           else
-            fastmap[c] = 1;
+            {
+              fastmap[c] = 1;
+              if (!SINGLE_BYTE_CHAR_P (ch))
+                {
+                  char_ranges[n_char_ranges++] = ch;
+                  char_ranges[n_char_ranges++] = ch;
+                }
+            }
         }
     }
 
-  /* If ^ was the first character, complement the fastmap.  */
+  /* If ^ was the first character, complement the fastmap.  In
+     addition, as all multibyte characters have possibility of
+     matching, set all entries for base leading codes, which is
+     harmless even if SYNTAXP is 1.  */
 
   if (negate)
     for (i = 0; i < sizeof fastmap; i++)
-      fastmap[i] ^= 1;
+      {
+        if (!multibyte || !BASE_LEADING_CODE_P (i))
+          fastmap[i] ^= 1;
+        else
+          fastmap[i] = 1;
+      }
 
   {
     int start_point = PT;
@@ -1210,20 +1258,49 @@ skip_chars (forwardp, syntaxp, string, lim)
         SETUP_SYNTAX_TABLE (pos, forwardp ? 1 : -1);
         if (forwardp)
           {
-            while (pos < XINT (lim)
-                   && fastmap[(int) SYNTAX (FETCH_CHAR (pos))])
+            if (multibyte)
               {
-                pos++;
-                UPDATE_SYNTAX_TABLE_FORWARD (pos);
+                while (pos < XINT (lim)
+                       && fastmap[(int) SYNTAX (FETCH_CHAR (pos))])
+                  {
+                    INC_POS (pos);
+                    UPDATE_SYNTAX_TABLE_FORWARD (pos);
+                  }
+              }
+            else
+              {
+                while (pos < XINT (lim)
+                       && fastmap[(int) SYNTAX (FETCH_BYTE (pos))])
+                  {
+                    pos++;
+                    UPDATE_SYNTAX_TABLE_FORWARD (pos);
+                  }
               }
           }
         else
           {
-            while (pos > XINT (lim)
-                   && fastmap[(int) SYNTAX (FETCH_CHAR (pos - 1))])
+            if (multibyte)
               {
-                pos--;
-                UPDATE_SYNTAX_TABLE_BACKWARD (pos - 1);
+                while (pos > XINT (lim))
+                  {
+                    int savepos = pos;
+                    DEC_POS (pos);
+                    if (!fastmap[(int) SYNTAX (FETCH_CHAR (pos))])
+                      {
+                        pos = savepos;
+                        break;
+                      }
+                    UPDATE_SYNTAX_TABLE_BACKWARD (pos - 1);
+                  }
+              }
+            else
+              {
+                while (pos > XINT (lim)
+                       && fastmap[(int) SYNTAX (FETCH_BYTE (pos - 1))])
+                  {
+                    pos--;
+                    UPDATE_SYNTAX_TABLE_BACKWARD (pos - 1);
+                  }
               }
           }
       }
@@ -1231,15 +1308,83 @@ skip_chars (forwardp, syntaxp, string, lim)
       {
         if (forwardp)
           {
-            while (pos < XINT (lim) && fastmap[FETCH_CHAR (pos)])
-              pos++;
+            if (multibyte)
+              while (pos < XINT (lim) && fastmap[(c = FETCH_BYTE (pos))])
+                {
+                  if (!BASE_LEADING_CODE_P (c))
+                    pos++;
+                  else if (n_char_ranges)
+                    {
+                      /* We much check CHAR_RANGES for a multibyte
+                         character.  */
+                      ch = FETCH_MULTIBYTE_CHAR (pos);
+                      for (i = 0; i < n_char_ranges; i += 2)
+                        if ((ch >= char_ranges[i] && ch <= char_ranges[i + 1]))
+                          break;
+                      if (!(negate ^ (i < n_char_ranges)))
+                        break;
+
+                      INC_POS (pos);
+                    }
+                  else
+                    {
+                      if (!negate) break;
+                      INC_POS (pos);
+                    }
+                }
+            else
+              while (pos < XINT (lim) && fastmap[FETCH_BYTE (pos)])
+                pos++;
           }
         else
           {
-            while (pos > XINT (lim) && fastmap[FETCH_CHAR (pos - 1)])
-              pos--;
+            if (multibyte)
+              while (pos > XINT (lim))
+                {
+                  int savepos = pos;
+                  DEC_POS (pos);
+                  if (fastmap[(c = FETCH_BYTE (pos))])
+                    {
+                      if (!BASE_LEADING_CODE_P (c))
+                        ;
+                      else if (n_char_ranges)
+                        {
+                          /* We much check CHAR_RANGES for a multibyte
+                             character.  */
+                          ch = FETCH_MULTIBYTE_CHAR (pos);
+                          for (i = 0; i < n_char_ranges; i += 2)
+                            if (ch >= char_ranges[i] && ch <= char_ranges[i + 1])
+                              break;
+                          if (!(negate ^ (i < n_char_ranges)))
+                            {
+                              pos = savepos;
+                              break;
+                            }
+                        }
+                      else
+                        if (!negate)
+                          {
+                            pos = savepos;
+                            break;
+                          }
+                    }
+                  else
+                    {
+                      pos = savepos;
+                      break;
+                    }
+                }
+            else
+              while (pos > XINT (lim) && fastmap[FETCH_BYTE (pos - 1)])
+                pos--;
           }
       }
+
+    if (multibyte
+        /* INC_POS or DEC_POS might have moved POS over LIM.  */
+        && (forwardp ? (pos > XINT (lim)) : (pos < XINT (lim))))
+      pos = XINT (lim);
+
     SET_PT (pos);
     immediate_quit = 0;