(byte-compile-no-warnings): New function.

[gnu-emacs] / src / syntax.c

diff --git a/src/syntax.c b/src/syntax.c
index f020bdbbced90c1c1b4454b30097a9e87d8c1046..706706a53a14013cdbac02fa4f45a3a7c4c513fc 100644 (file)
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -199,7 +199,7 @@ update_syntax_table (charpos, count, init, object)
 
   if (invalidate)
     invalidate = !EQ (tmp_table, gl_state.old_prop); /* Need to invalidate? */
 
   if (invalidate)
     invalidate = !EQ (tmp_table, gl_state.old_prop); /* Need to invalidate? */

-      
+

   if (invalidate)              /* Did not get to adjacent interval.  */
     {                          /* with the same table => */
                                /* invalidate the old range.  */
   if (invalidate)              /* Did not get to adjacent interval.  */
     {                          /* with the same table => */
                                /* invalidate the old range.  */


@@ -222,13 +222,13 @@ update_syntax_table (charpos, count, init, object)
       if (EQ (Fsyntax_table_p (tmp_table), Qt))
        {
          gl_state.use_global = 0;
       if (EQ (Fsyntax_table_p (tmp_table), Qt))
        {
          gl_state.use_global = 0;

-       } 
+       }

       else if (CONSP (tmp_table))
        {
          gl_state.use_global = 1;
          gl_state.global_code = tmp_table;
        }
       else if (CONSP (tmp_table))
        {
          gl_state.use_global = 1;
          gl_state.global_code = tmp_table;
        }

-      else 
+      else

        {
          gl_state.use_global = 0;
          gl_state.current_syntax_table = current_buffer->syntax_table;
        {
          gl_state.use_global = 0;
          gl_state.current_syntax_table = current_buffer->syntax_table;


@@ -251,7 +251,7 @@ update_syntax_table (charpos, count, init, object)
            }
          return;
        }
            }
          return;
        }

-      else if (cnt == INTERVALS_AT_ONCE) 
+      else if (cnt == INTERVALS_AT_ONCE)

        {
          if (count > 0)
            {
        {
          if (count > 0)
            {


@@ -337,7 +337,7 @@ dec_bytepos (bytepos)
    It should be the last one before POS, or nearly the last.
 
    When open_paren_in_column_0_is_defun_start is nonzero,
    It should be the last one before POS, or nearly the last.
 
    When open_paren_in_column_0_is_defun_start is nonzero,

-   the beginning of every line is treated as a defun-start.
+   only the beginning of the buffer is treated as a defun-start.

 
    We record the information about where the scan started
    and what its result was, so that another call in the same area
 
    We record the information about where the scan started
    and what its result was, so that another call in the same area


@@ -353,6 +353,12 @@ find_defun_start (pos, pos_byte)
 {
   int opoint = PT, opoint_byte = PT_BYTE;
 
 {
   int opoint = PT, opoint_byte = PT_BYTE;
 

+  if (!open_paren_in_column_0_is_defun_start)
+    {
+      find_start_value_byte = BEGV_BYTE;
+      return BEGV;
+    }
+

   /* Use previous finding, if it's valid and applies to this inquiry.  */
   if (current_buffer == find_start_buffer
       /* Reuse the defun-start even if POS is a little farther on.
   /* Use previous finding, if it's valid and applies to this inquiry.  */
   if (current_buffer == find_start_buffer
       /* Reuse the defun-start even if POS is a little farther on.


@@ -372,24 +378,21 @@ find_defun_start (pos, pos_byte)
      syntax-tables.  */
   gl_state.current_syntax_table = current_buffer->syntax_table;
   gl_state.use_global = 0;
      syntax-tables.  */
   gl_state.current_syntax_table = current_buffer->syntax_table;
   gl_state.use_global = 0;

-  if (open_paren_in_column_0_is_defun_start)
+  while (PT > BEGV)

     {
     {

-      while (PT > BEGV)
+      /* Open-paren at start of line means we may have found our
+        defun-start.  */
+      if (SYNTAX (FETCH_CHAR (PT_BYTE)) == Sopen)

        {
        {

-         /* Open-paren at start of line means we may have found our
-            defun-start.  */
+         SETUP_SYNTAX_TABLE (PT + 1, -1);      /* Try again... */

          if (SYNTAX (FETCH_CHAR (PT_BYTE)) == Sopen)
          if (SYNTAX (FETCH_CHAR (PT_BYTE)) == Sopen)

-           {
-             SETUP_SYNTAX_TABLE (PT + 1, -1);  /* Try again... */
-             if (SYNTAX (FETCH_CHAR (PT_BYTE)) == Sopen)
-               break;
-             /* Now fallback to the default value.  */
-             gl_state.current_syntax_table = current_buffer->syntax_table;
-             gl_state.use_global = 0;
-           }
-         /* Move to beg of previous line.  */
-         scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -2, 1);
+           break;
+         /* Now fallback to the default value.  */
+         gl_state.current_syntax_table = current_buffer->syntax_table;
+         gl_state.use_global = 0;

        }
        }

+      /* Move to beg of previous line.  */
+      scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -2, 1);

     }
 
   /* Record what we found, for the next try.  */
     }
 
   /* Record what we found, for the next try.  */


@@ -428,7 +431,7 @@ prev_char_comend_first (pos, pos_byte)
  *      int pos, pos_byte;
  * {
  *   int c, val;
  *      int pos, pos_byte;
  * {
  *   int c, val;

- * 
+ *

  *   DEC_BOTH (pos, pos_byte);
  *   UPDATE_SYNTAX_TABLE_BACKWARD (pos);
  *   c = FETCH_CHAR (pos_byte);
  *   DEC_BOTH (pos, pos_byte);
  *   UPDATE_SYNTAX_TABLE_BACKWARD (pos);
  *   c = FETCH_CHAR (pos_byte);


@@ -468,7 +471,7 @@ back_comment (from, from_byte, stop, comnested, comstyle, charpos_ptr, bytepos_p
   int string_style = -1;       /* Presumed outside of any string. */
   int string_lossage = 0;
   /* Not a real lossage: indicates that we have passed a matching comment
   int string_style = -1;       /* Presumed outside of any string. */
   int string_lossage = 0;
   /* Not a real lossage: indicates that we have passed a matching comment

-     starter plus an non-matching comment-ender, meaning that any matching
+     starter plus a non-matching comment-ender, meaning that any matching

      comment-starter we might see later could be a false positive (hidden
      inside another comment).
      Test case:  { a (* b } c (* d *) */
      comment-starter we might see later could be a false positive (hidden
      inside another comment).
      Test case:  { a (* b } c (* d *) */


@@ -584,7 +587,7 @@ back_comment (from, from_byte, stop, comnested, comstyle, charpos_ptr, bytepos_p
               There's no way to grok this scanning backwards.  */
            string_lossage = 1;
          break;
               There's no way to grok this scanning backwards.  */
            string_lossage = 1;
          break;

-         
+

        case Scomment:
          /* We've already checked that it is the relevant comstyle.  */
          if (string_style != -1 || comment_lossage || string_lossage)
        case Scomment:
          /* We've already checked that it is the relevant comstyle.  */
          if (string_style != -1 || comment_lossage || string_lossage)


@@ -609,7 +612,7 @@ back_comment (from, from_byte, stop, comnested, comstyle, charpos_ptr, bytepos_p
 
        case Sendcomment:
          if (SYNTAX_FLAGS_COMMENT_STYLE (syntax) == comstyle
 
        case Sendcomment:
          if (SYNTAX_FLAGS_COMMENT_STYLE (syntax) == comstyle

-             && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax)
+             && ((com2end && SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax))

                  || SYNTAX_FLAGS_COMMENT_NESTED (syntax)) == comnested)
            /* This is the same style of comment ender as ours. */
            {
                  || SYNTAX_FLAGS_COMMENT_NESTED (syntax)) == comnested)
            /* This is the same style of comment ender as ours. */
            {


@@ -705,7 +708,7 @@ back_comment (from, from_byte, stop, comnested, comstyle, charpos_ptr, bytepos_p
       from_byte = CHAR_TO_BYTE (from);
       UPDATE_SYNTAX_TABLE_FORWARD (from - 1);
     }
       from_byte = CHAR_TO_BYTE (from);
       UPDATE_SYNTAX_TABLE_FORWARD (from - 1);
     }

-    
+

  done:
   *charpos_ptr = from;
   *bytepos_ptr = from_byte;
  done:
   *charpos_ptr = from;
   *bytepos_ptr = from_byte;


@@ -732,7 +735,7 @@ check_syntax_table (obj)
   if (!(CHAR_TABLE_P (obj)
        && EQ (XCHAR_TABLE (obj)->purpose, Qsyntax_table)))
     wrong_type_argument (Qsyntax_table_p, obj);
   if (!(CHAR_TABLE_P (obj)
        && EQ (XCHAR_TABLE (obj)->purpose, Qsyntax_table)))
     wrong_type_argument (Qsyntax_table_p, obj);

-}   
+}

 
 DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 0, 0,
        doc: /* Return the current syntax table.
 
 DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 0, 0,
        doc: /* Return the current syntax table.


@@ -961,7 +964,7 @@ text property.  */)
        val |= 1 << 22;
        break;
       }
        val |= 1 << 22;
        break;
       }

-       
+

   if (val < XVECTOR (Vsyntax_code_object)->size && NILP (match))
     return XVECTOR (Vsyntax_code_object)->contents[val];
   else
   if (val < XVECTOR (Vsyntax_code_object)->size && NILP (match))
     return XVECTOR (Vsyntax_code_object)->contents[val];
   else


@@ -971,7 +974,7 @@ text property.  */)
 
 /* I really don't know why this is interactive
    help-form should at least be made useful whilst reading the second arg.  */
 
 /* I really don't know why this is interactive
    help-form should at least be made useful whilst reading the second arg.  */

-DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3, 
+DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3,

   "cSet syntax for character: \nsSet syntax for %s to: ",
        doc: /* Set syntax for character CHAR according to string NEWENTRY.
 The syntax is changed only for table SYNTAX_TABLE, which defaults to
   "cSet syntax for character: \nsSet syntax for %s to: ",
        doc: /* Set syntax for character CHAR according to string NEWENTRY.
 The syntax is changed only for table SYNTAX_TABLE, which defaults to


@@ -1293,7 +1296,7 @@ and the function returns nil.  Field boundaries are not noticed if
   /* Avoid jumping out of an input field.  */
   val = XFASTINT (Fconstrain_to_field (make_number (val), make_number (PT),
                                       Qt, Qnil, Qnil));
   /* Avoid jumping out of an input field.  */
   val = XFASTINT (Fconstrain_to_field (make_number (val), make_number (PT),
                                       Qt, Qnil, Qnil));

-  
+

   SET_PT (val);
   return val == orig_val ? Qt : Qnil;
 }
   SET_PT (val);
   return val == orig_val ? Qt : Qnil;
 }


@@ -1307,7 +1310,9 @@ except that `]' is never special and `\\' quotes `^', `-' or `\\'
  (but not as the end of a range; quoting is never needed there).
 Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
 With arg "^a-zA-Z", skips nonletters stopping before first letter.
  (but not as the end of a range; quoting is never needed there).
 Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
 With arg "^a-zA-Z", skips nonletters stopping before first letter.

-Returns the distance traveled, either zero or positive.  */)
+Returns the distance traveled, either zero or positive.
+Note that char classes, e.g. `[:alpha:]', are not currently supported;
+they will be treated as literals.  */)

      (string, lim)
      Lisp_Object string, lim;
 {
      (string, lim)
      Lisp_Object string, lim;
 {


@@ -1502,6 +1507,18 @@ skip_chars (forwardp, syntaxp, string, lim)
     int start_point = PT;
     int pos = PT;
     int pos_byte = PT_BYTE;
     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)
 
     immediate_quit = 1;
     if (syntaxp)


@@ -1510,60 +1527,85 @@ skip_chars (forwardp, syntaxp, string, lim)
        if (forwardp)
          {
            if (multibyte)
        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
            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)
          }
        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;
                        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
            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;
                        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
          }
       }
     else


@@ -1571,9 +1613,18 @@ skip_chars (forwardp, syntaxp, string, lim)
        if (forwardp)
          {
            if (multibyte)
        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])
                  if (SINGLE_BYTE_CHAR_P (c))
                    {
                      if (!fastmap[c])


@@ -1596,21 +1647,45 @@ skip_chars (forwardp, syntaxp, string, lim)
                      if (!(negate ^ (i < n_char_ranges)))
                        break;
                    }
                      if (!(negate ^ (i < n_char_ranges)))
                        break;
                    }

-                 INC_BOTH (pos, pos_byte);
+                 p += nbytes, pos++, pos_byte += nbytes;

                }
            else
                }
            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)
          }
        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])
                  if (SINGLE_BYTE_CHAR_P (c))
                    {
                      if (!fastmap[c])


@@ -1625,12 +1700,22 @@ skip_chars (forwardp, syntaxp, string, lim)
                      if (!(negate ^ (i < n_char_ranges)))
                        break;
                    }
                      if (!(negate ^ (i < n_char_ranges)))
                        break;
                    }

-                 pos--;
-                 pos_byte = prev_pos_byte;
+                 pos--, pos_byte -= nbytes;

                }
            else
                }
            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--;
+               }

          }
       }
 
          }
       }
 


@@ -1729,7 +1814,7 @@ forw_comment (from, from_byte, stop, nesting, style, prev_syntax,
        nesting++;
       INC_BOTH (from, from_byte);
       UPDATE_SYNTAX_TABLE_FORWARD (from);
        nesting++;
       INC_BOTH (from, from_byte);
       UPDATE_SYNTAX_TABLE_FORWARD (from);

-      
+

     forw_incomment:
       if (from < stop && SYNTAX_FLAGS_COMEND_FIRST (syntax)
          && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style
     forw_incomment:
       if (from < stop && SYNTAX_FLAGS_COMEND_FIRST (syntax)
          && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style


@@ -1772,10 +1857,11 @@ forw_comment (from, from_byte, stop, nesting, style, prev_syntax,
 }
 
 DEFUN ("forward-comment", Fforward_comment, Sforward_comment, 1, 1, 0,
 }
 
 DEFUN ("forward-comment", Fforward_comment, Sforward_comment, 1, 1, 0,

-       doc: /* Move forward across up to N comments.  If N is negative, move backward.
+       doc: /*
+Move forward across up to COUNT comments.  If COUNT is negative, move backward.

 Stop scanning if we find something other than a comment or whitespace.
 Set point to where scanning stops.
 Stop scanning if we find something other than a comment or whitespace.
 Set point to where scanning stops.

-If N comments are found as expected, with nothing except whitespace
+If COUNT comments are found as expected, with nothing except whitespace

 between them, return t; otherwise return nil.  */)
      (count)
      Lisp_Object count;
 between them, return t; otherwise return nil.  */)
      (count)
      Lisp_Object count;


@@ -1826,7 +1912,7 @@ between them, return t; otherwise return nil.  */)
              && (c1 = FETCH_CHAR (from_byte),
                  SYNTAX_COMSTART_SECOND (c1)))
            {
              && (c1 = FETCH_CHAR (from_byte),
                  SYNTAX_COMSTART_SECOND (c1)))
            {

-             /* We have encountered a comment start sequence and we 
+             /* We have encountered a comment start sequence and we

                 are ignoring all text inside comments.  We must record
                 the comment style this sequence begins so that later,
                 only a comment end of the same style actually ends
                 are ignoring all text inside comments.  We must record
                 the comment style this sequence begins so that later,
                 only a comment end of the same style actually ends


@@ -1907,7 +1993,7 @@ between them, return t; otherwise return nil.  */)
            {
              /* Skip until first preceding unquoted comment_fence.  */
              int found = 0, ini = from, ini_byte = from_byte;
            {
              /* Skip until first preceding unquoted comment_fence.  */
              int found = 0, ini = from, ini_byte = from_byte;

-             
+

              while (1)
                {
                  DEC_BOTH (from, from_byte);
              while (1)
                {
                  DEC_BOTH (from, from_byte);


@@ -1916,9 +2002,9 @@ between them, return t; otherwise return nil.  */)
                  UPDATE_SYNTAX_TABLE_BACKWARD (from);
                  c = FETCH_CHAR (from_byte);
                  if (SYNTAX (c) == Scomment_fence
                  UPDATE_SYNTAX_TABLE_BACKWARD (from);
                  c = FETCH_CHAR (from_byte);
                  if (SYNTAX (c) == Scomment_fence

-                     && !char_quoted (from, from_byte)) 
+                     && !char_quoted (from, from_byte))

                    {
                    {

-                     found = 1; 
+                     found = 1;

                      break;
                    }
                }
                      break;
                    }
                }


@@ -2036,7 +2122,7 @@ scan_lists (from, count, depth, sexpflag)
              && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte))
              && parse_sexp_ignore_comments)
            {
              && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte))
              && parse_sexp_ignore_comments)
            {

-             /* we have encountered a comment start sequence and we 
+             /* we have encountered a comment start sequence and we

                 are ignoring all text inside comments.  We must record
                 the comment style this sequence begins so that later,
                 only a comment end of the same style actually ends
                 are ignoring all text inside comments.  We must record
                 the comment style this sequence begins so that later,
                 only a comment end of the same style actually ends


@@ -2048,7 +2134,7 @@ scan_lists (from, count, depth, sexpflag)
              INC_BOTH (from, from_byte);
              UPDATE_SYNTAX_TABLE_FORWARD (from);
            }
              INC_BOTH (from, from_byte);
              UPDATE_SYNTAX_TABLE_FORWARD (from);
            }

-         
+

          if (prefix)
            continue;
 
          if (prefix)
            continue;
 


@@ -2164,6 +2250,9 @@ scan_lists (from, count, depth, sexpflag)
              INC_BOTH (from, from_byte);
              if (!depth && sexpflag) goto done;
              break;
              INC_BOTH (from, from_byte);
              if (!depth && sexpflag) goto done;
              break;

+           default:
+             /* Ignore whitespace, punctuation, quote, endcomment.  */
+             break;

            }
        }
 
            }
        }
 


@@ -2206,12 +2295,15 @@ scan_lists (from, count, depth, sexpflag)
              comstyle = SYNTAX_COMMENT_STYLE (c1);
              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
            }
              comstyle = SYNTAX_COMMENT_STYLE (c1);
              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
            }

-         
+

          /* Quoting turns anything except a comment-ender
             into a word character.  Note that this cannot be true
             if we decremented FROM in the if-statement above.  */
          if (code != Sendcomment && char_quoted (from, from_byte))
          /* Quoting turns anything except a comment-ender
             into a word character.  Note that this cannot be true
             if we decremented FROM in the if-statement above.  */
          if (code != Sendcomment && char_quoted (from, from_byte))

-           code = Sword;
+           {
+             DEC_BOTH (from, from_byte);
+             code = Sword;
+           }

          else if (SYNTAX_PREFIX (c))
            continue;
 
          else if (SYNTAX_PREFIX (c))
            continue;
 


@@ -2304,14 +2396,14 @@ scan_lists (from, count, depth, sexpflag)
                  DEC_BOTH (from, from_byte);
                  if (from == stop) goto lose;
                  UPDATE_SYNTAX_TABLE_BACKWARD (from);
                  DEC_BOTH (from, from_byte);
                  if (from == stop) goto lose;
                  UPDATE_SYNTAX_TABLE_BACKWARD (from);

-                 if (!char_quoted (from, from_byte) 
+                 if (!char_quoted (from, from_byte)

                      && (c = FETCH_CHAR (from_byte),
                          SYNTAX_WITH_MULTIBYTE_CHECK (c) == code))
                    break;
                }
              if (code == Sstring_fence && !depth && sexpflag) goto done2;
              break;
                      && (c = FETCH_CHAR (from_byte),
                          SYNTAX_WITH_MULTIBYTE_CHECK (c) == code))
                    break;
                }
              if (code == Sstring_fence && !depth && sexpflag) goto done2;
              break;

-             
+

            case Sstring:
              stringterm = FETCH_CHAR (from_byte);
              while (1)
            case Sstring:
              stringterm = FETCH_CHAR (from_byte);
              while (1)


@@ -2332,6 +2424,9 @@ scan_lists (from, count, depth, sexpflag)
              DEC_BOTH (from, from_byte);
              if (!depth && sexpflag) goto done2;
              break;
              DEC_BOTH (from, from_byte);
              if (!depth && sexpflag) goto done2;
              break;

+           default:
+             /* Ignore whitespace, punctuation, quote, endcomment.  */
+             break;

            }
        }
 
            }
        }
 


@@ -2416,7 +2511,7 @@ This includes chars with "quote" or "prefix" syntax (' or p).  */)
   int pos_byte = PT_BYTE;
   int c;
 
   int pos_byte = PT_BYTE;
   int c;
 

-  if (pos <= beg) 
+  if (pos <= beg)

     {
       SET_PT_BOTH (opoint, opoint_byte);
 
     {
       SET_PT_BOTH (opoint, opoint_byte);
 


@@ -2457,7 +2552,7 @@ scan_sexps_forward (stateptr, from, from_byte, end, targetdepth,
                    stopbefore, oldstate, commentstop)
      struct lisp_parse_state *stateptr;
      register int from;
                    stopbefore, oldstate, commentstop)
      struct lisp_parse_state *stateptr;
      register int from;

-     int end, targetdepth, stopbefore;
+     int end, targetdepth, stopbefore, from_byte;

      Lisp_Object oldstate;
      int commentstop;
 {
      Lisp_Object oldstate;
      int commentstop;
 {


@@ -2497,7 +2592,8 @@ do { prev_from = from;                            \
      prev_from_syntax                          \
        = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte)); \
      INC_BOTH (from, from_byte);               \
      prev_from_syntax                          \
        = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte)); \
      INC_BOTH (from, from_byte);               \

-     UPDATE_SYNTAX_TABLE_FORWARD (from);       \
+     if (from < end)                           \
+       UPDATE_SYNTAX_TABLE_FORWARD (from);     \

   } while (0)
 
   immediate_quit = 1;
   } while (0)
 
   immediate_quit = 1;


@@ -2524,8 +2620,8 @@ do { prev_from = from;                            \
       oldstate = Fcdr (oldstate);
       tem = Fcar (oldstate);
       /* Check whether we are inside string_fence-style string: */
       oldstate = Fcdr (oldstate);
       tem = Fcar (oldstate);
       /* Check whether we are inside string_fence-style string: */

-      state.instring = (!NILP (tem) 
-                       ? (INTEGERP (tem) ? XINT (tem) : ST_STRING_STYLE) 
+      state.instring = (!NILP (tem)
+                       ? (INTEGERP (tem) ? XINT (tem) : ST_STRING_STYLE)

                        : -1);
 
       oldstate = Fcdr (oldstate);
                        : -1);
 
       oldstate = Fcdr (oldstate);


@@ -2543,7 +2639,7 @@ do { prev_from = from;                            \
       oldstate = Fcdr (oldstate);
       oldstate = Fcdr (oldstate);
       tem = Fcar (oldstate);
       oldstate = Fcdr (oldstate);
       oldstate = Fcdr (oldstate);
       tem = Fcar (oldstate);

-      state.comstyle = NILP (tem) ? 0 : (EQ (tem, Qsyntax_table) 
+      state.comstyle = NILP (tem) ? 0 : (EQ (tem, Qsyntax_table)

                                         ? ST_COMMENT_STYLE : 1);
 
       oldstate = Fcdr (oldstate);
                                         ? ST_COMMENT_STYLE : 1);
 
       oldstate = Fcdr (oldstate);


@@ -2586,12 +2682,6 @@ do { prev_from = from;                           \
   else if (start_quoted)
     goto startquoted;
 
   else if (start_quoted)
     goto startquoted;
 

-#if 0 /* This seems to be redundant with the identical code above.  */
-  SETUP_SYNTAX_TABLE (prev_from, 1);
-  prev_from_syntax = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte));
-  UPDATE_SYNTAX_TABLE_FORWARD (from);
-#endif
-

   while (from < end)
     {
       INC_FROM;
   while (from < end)
     {
       INC_FROM;


@@ -2624,7 +2714,7 @@ do { prev_from = from;                            \
              /* Record the comment style we have entered so that only
                 the comment-end sequence of the same style actually
                 terminates the comment section.  */
              /* Record the comment style we have entered so that only
                 the comment-end sequence of the same style actually
                 terminates the comment section.  */

-             state.comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte));
+             state.comstyle = SYNTAX_COMMENT_STYLE (c1);

              comnested = SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax);
              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
              state.incomment = comnested ? 1 : -1;
              comnested = SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax);
              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
              state.incomment = comnested ? 1 : -1;


@@ -2675,6 +2765,7 @@ do { prev_from = from;                            \
          curlevel->prev = curlevel->last;
          break;
 
          curlevel->prev = curlevel->last;
          break;
 

+       case Scomment_fence: /* Can't happen because it's handled above.  */

        case Scomment:
          if (commentstop || boundary_stop) goto done;
        startincomment:
        case Scomment:
          if (commentstop || boundary_stop) goto done;
        startincomment:


@@ -2725,14 +2816,14 @@ do { prev_from = from;                          \
          state.comstr_start = from - 1;
          if (stopbefore) goto stop;  /* this arg means stop at sexp start */
          curlevel->last = prev_from;
          state.comstr_start = from - 1;
          if (stopbefore) goto stop;  /* this arg means stop at sexp start */
          curlevel->last = prev_from;

-         state.instring = (code == Sstring 
+         state.instring = (code == Sstring

                            ? (FETCH_CHAR (prev_from_byte))
                            : ST_STRING_STYLE);
          if (boundary_stop) goto done;
        startinstring:
          {
            nofence = state.instring != ST_STRING_STYLE;
                            ? (FETCH_CHAR (prev_from_byte))
                            : ST_STRING_STYLE);
          if (boundary_stop) goto done;
        startinstring:
          {
            nofence = state.instring != ST_STRING_STYLE;

-           
+

            while (1)
              {
                int c;
            while (1)
              {
                int c;


@@ -2770,6 +2861,10 @@ do { prev_from = from;                           \
          break;
 
        case Smath:
          break;
 
        case Smath:

+         /* FIXME: We should do something with it.  */
+         break;
+       default:
+         /* Ignore whitespace, punctuation, quote, endcomment.  */

          break;
        }
     }
          break;
        }
     }


@@ -2810,7 +2905,7 @@ Value is a list of ten elements describing final state of parsing:
  3. non-nil if inside a string.
     (it is the character that will terminate the string,
      or t if the string should be terminated by a generic string delimiter.)
  3. non-nil if inside a string.
     (it is the character that will terminate the string,
      or t if the string should be terminated by a generic string delimiter.)

- 4. nil if outside a comment, t if inside a non-nestable comment, 
+ 4. nil if outside a comment, t if inside a non-nestable comment,

     else an integer (the current comment nesting).
  5. t if following a quote character.
  6. the minimum paren-depth encountered during this scan.
     else an integer (the current comment nesting).
  5. t if following a quote character.
  6. the minimum paren-depth encountered during this scan.


@@ -2846,23 +2941,23 @@ Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
   scan_sexps_forward (&state, XINT (from), CHAR_TO_BYTE (XINT (from)),
                      XINT (to),
                      target, !NILP (stopbefore), oldstate,
   scan_sexps_forward (&state, XINT (from), CHAR_TO_BYTE (XINT (from)),
                      XINT (to),
                      target, !NILP (stopbefore), oldstate,

-                     (NILP (commentstop) 
+                     (NILP (commentstop)

                       ? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)));
 
   SET_PT (state.location);
                       ? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)));
 
   SET_PT (state.location);

-  
+

   return Fcons (make_number (state.depth),
           Fcons (state.prevlevelstart < 0 ? Qnil : make_number (state.prevlevelstart),
             Fcons (state.thislevelstart < 0 ? Qnil : make_number (state.thislevelstart),
   return Fcons (make_number (state.depth),
           Fcons (state.prevlevelstart < 0 ? Qnil : make_number (state.prevlevelstart),
             Fcons (state.thislevelstart < 0 ? Qnil : make_number (state.thislevelstart),

-              Fcons (state.instring >= 0 
-                     ? (state.instring == ST_STRING_STYLE 
+              Fcons (state.instring >= 0
+                     ? (state.instring == ST_STRING_STYLE

                         ? Qt : make_number (state.instring)) : Qnil,
                 Fcons (state.incomment < 0 ? Qt :
                        (state.incomment == 0 ? Qnil :
                         make_number (state.incomment)),
                   Fcons (state.quoted ? Qt : Qnil,
                     Fcons (make_number (state.mindepth),
                         ? Qt : make_number (state.instring)) : Qnil,
                 Fcons (state.incomment < 0 ? Qt :
                        (state.incomment == 0 ? Qnil :
                         make_number (state.incomment)),
                   Fcons (state.quoted ? Qt : Qnil,
                     Fcons (make_number (state.mindepth),

-                      Fcons ((state.comstyle 
+                      Fcons ((state.comstyle

                               ? (state.comstyle == ST_COMMENT_STYLE
                                  ? Qsyntax_table : Qt) :
                               Qnil),
                               ? (state.comstyle == ST_COMMENT_STYLE
                                  ? Qsyntax_table : Qt) :
                               Qnil),


@@ -2984,7 +3079,7 @@ See the info node `(elisp)Syntax Properties' for a description of the
 
   DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
               &open_paren_in_column_0_is_defun_start,
 
   DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
               &open_paren_in_column_0_is_defun_start,

-              doc: /* Non-nil means an open paren in column 0 denotes the start of a defun.  */);
+              doc: /* *Non-nil means an open paren in column 0 denotes the start of a defun.  */);

   open_paren_in_column_0_is_defun_start = 1;
 
   defsubr (&Ssyntax_table_p);
   open_paren_in_column_0_is_defun_start = 1;
 
   defsubr (&Ssyntax_table_p);