(skip_chars): Make the code faster by using the common

technique of *p, *stop, and *endp.

diff --git a/src/ChangeLog b/src/ChangeLog
index 3992e51cf2794150367de47fe37d74c4c1468541..2ed1cf6fd4cb12e0aa324e425c4aa914a46edb24 100644 (file)
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,8 @@
+2003-04-24  Kenichi Handa  <handa@m17n.org>
+
+       * syntax.c (skip_chars): Make the code faster by using the common
+       technique of *p, *stop, and *endp.
+
 2003-04-23  Jan Dj\e,Ad\e(Brv  <jan.h.d@swipnet.se>
 
        * xdisp.c (update_tool_bar): BLOCK_INPUT before calling

diff --git a/src/syntax.c b/src/syntax.c
index cd0d52f33902a0df7e97730c4313f3449fc24fc2..dbdac11694d529bd3ba800a7ae6aae4b96a45ed9 100644 (file)
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -1504,6 +1504,18 @@ skip_chars (forwardp, syntaxp, string, lim)
     int start_point = PT;
     int pos = PT;
     int pos_byte = PT_BYTE;
+    unsigned char *p = PT_ADDR, *endp, *stop;
+
+    if (forwardp)
+      {
+       endp = (XINT (lim) == GPT) ? GPT_ADDR : CHAR_POS_ADDR (XINT (lim));
+       stop = (pos < GPT && GPT < XINT (lim)) ? GPT_ADDR : endp; 
+      }
+    else
+      {
+       endp = CHAR_POS_ADDR (XINT (lim));
+       stop = (pos >= GPT && GPT > XINT (lim)) ? GAP_END_ADDR : endp; 
+      }
 
     immediate_quit = 1;
     if (syntaxp)
@@ -1512,60 +1524,85 @@ skip_chars (forwardp, syntaxp, string, lim)
        if (forwardp)
          {
            if (multibyte)
-             {
-               if (pos < XINT (lim))
-                 while (fastmap[(int) SYNTAX (FETCH_CHAR (pos_byte))])
+             while (1)
+               {
+                 int nbytes;
+
+                 if (p >= stop)
                    {
-                     /* Since we already checked for multibyteness,
-                        avoid using INC_BOTH which checks again.  */
-                     INC_POS (pos_byte);
-                     pos++;
-                     if (pos >= XINT (lim))
-                       break;
-                     UPDATE_SYNTAX_TABLE_FORWARD (pos);
+                     if (p >= endp)
+                       break;
+                     p = GAP_END_ADDR;
+                     stop = endp;
                    }
-             }
+                 c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, nbytes);
+                 if (! fastmap[(int) SYNTAX (c)])
+                   break;
+                 p += nbytes, pos++, pos_byte += nbytes;
+                 UPDATE_SYNTAX_TABLE_FORWARD (pos);
+               }
            else
-             {
-               while (pos < XINT (lim)
-                      && fastmap[(int) SYNTAX (FETCH_BYTE (pos))])
-                 {
-                   pos++;
-                   UPDATE_SYNTAX_TABLE_FORWARD (pos);
-                 }
-             }
+             while (1)
+               {
+                 if (p >= stop)
+                   {
+                     if (p >= endp)
+                       break;
+                     p = GAP_END_ADDR;
+                     stop = endp;
+                   }
+                 if (! fastmap[(int) SYNTAX (*p)])
+                   break;
+                 p++, pos++;
+                 UPDATE_SYNTAX_TABLE_FORWARD (pos);
+               }
          }
        else
          {
            if (multibyte)
-             {
-               while (pos > XINT (lim))
-                 {
-                   int savepos = pos_byte;
-                   /* Since we already checked for multibyteness,
-                      avoid using DEC_BOTH which checks again.  */
-                   pos--;
-                   DEC_POS (pos_byte);
-                   UPDATE_SYNTAX_TABLE_BACKWARD (pos);
-                   if (!fastmap[(int) SYNTAX (FETCH_CHAR (pos_byte))])
-                     {
-                       pos++;
-                       pos_byte = savepos;
+             while (1)
+               {
+                 unsigned char *prev_p;
+                 int nbytes;
+
+                 if (p <= stop)
+                   {
+                     if (p <= endp)
                        break;
-                     }
-                 }
-             }
+                     p = GPT_ADDR;
+                     stop = endp;
+                   }
+                 prev_p = p;
+                 while (--p >= stop && ! CHAR_HEAD_P (*p));
+                 PARSE_MULTIBYTE_SEQ (p, MAX_MULTIBYTE_LENGTH, nbytes);
+                 if (prev_p - p > nbytes)
+                   p = prev_p - 1, c = *p, nbytes = 1;
+                 else
+                   c = STRING_CHAR (p, MAX_MULTIBYTE_LENGTH);
+                 pos--, pos_byte -= nbytes;
+                 UPDATE_SYNTAX_TABLE_BACKWARD (pos);
+                 if (! fastmap[(int) SYNTAX (c)])
+                   {
+                     pos++;
+                     pos_byte += nbytes;
+                     break;
+                   }
+               }
            else
-             {
-               if (pos > XINT (lim))
-                 while (fastmap[(int) SYNTAX (FETCH_BYTE (pos - 1))])
+             while (1)
+               {
+                 if (p <= stop)
                    {
-                     pos--;
-                     if (pos <= XINT (lim))
+                     if (p <= endp)
                        break;
-                     UPDATE_SYNTAX_TABLE_BACKWARD (pos - 1);
+                     p = GPT_ADDR;
+                     stop = endp;
                    }
-             }
+                 if (! fastmap[(int) SYNTAX (p[-1])])
+                   break;
+                 p--, pos--;
+                 UPDATE_SYNTAX_TABLE_BACKWARD (pos - 1);
+               }
          }
       }
     else
@@ -1573,9 +1610,18 @@ skip_chars (forwardp, syntaxp, string, lim)
        if (forwardp)
          {
            if (multibyte)
-             while (pos < XINT (lim))
+             while (1)
                {
-                 c = FETCH_MULTIBYTE_CHAR (pos_byte);
+                 int nbytes;
+
+                 if (p >= stop)
+                   {
+                     if (p >= endp)
+                       break;
+                     p = GAP_END_ADDR;
+                     stop = endp;
+                   }
+                 c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, nbytes);
                  if (SINGLE_BYTE_CHAR_P (c))
                    {
                      if (!fastmap[c])
@@ -1598,21 +1644,45 @@ skip_chars (forwardp, syntaxp, string, lim)
                      if (!(negate ^ (i < n_char_ranges)))
                        break;
                    }
-                 INC_BOTH (pos, pos_byte);
+                 p += nbytes, pos++, pos_byte += nbytes;
                }
            else
-             while (pos < XINT (lim) && fastmap[FETCH_BYTE (pos)])
-               pos++;
+             while (1)
+               {
+                 if (p >= stop)
+                   {
+                     if (p >= endp)
+                       break;
+                     p = GAP_END_ADDR;
+                     stop = endp;
+                   }
+                 if (fastmap[*p])
+                   break;
+                 p++, pos++;
+               }
          }
        else
          {
            if (multibyte)
-             while (pos > XINT (lim))
+             while (1)
                {
-                 int prev_pos_byte = pos_byte;
+                 unsigned char *prev_p;
+                 int nbytes;
 
-                 DEC_POS (prev_pos_byte);
-                 c = FETCH_MULTIBYTE_CHAR (prev_pos_byte);
+                 if (p <= stop)
+                   {
+                     if (p <= endp)
+                       break;
+                     p = GPT_ADDR;
+                     stop = endp;
+                   }
+                 prev_p = p;
+                 while (--p >= stop && ! CHAR_HEAD_P (*p));
+                 PARSE_MULTIBYTE_SEQ (p, MAX_MULTIBYTE_LENGTH, nbytes);
+                 if (prev_p - p > nbytes)
+                   p = prev_p - 1, c = *p, nbytes = 1;
+                 else
+                   c = STRING_CHAR (p, MAX_MULTIBYTE_LENGTH);
                  if (SINGLE_BYTE_CHAR_P (c))
                    {
                      if (!fastmap[c])
@@ -1627,12 +1697,22 @@ skip_chars (forwardp, syntaxp, string, lim)
                      if (!(negate ^ (i < n_char_ranges)))
                        break;
                    }
-                 pos--;
-                 pos_byte = prev_pos_byte;
+                 pos--, pos_byte -= nbytes;
                }
            else
-             while (pos > XINT (lim) && fastmap[FETCH_BYTE (pos - 1)])
-               pos--;
+             while (1)
+               {
+                 if (p <= stop)
+                   {
+                     if (p <= endp)
+                       break;
+                     p = GPT_ADDR;
+                     stop = endp;
+                   }
+                 if (fastmap[p[-1]])
+                   break;
+                 p--, pos--;
+               }
          }
       }