emacs: src/syntax.c comparison

comparison src/syntax.c @ 25445:d678b229c05a

(lisp_parse_state, back_comment, Fmodify_syntax_entry) (Fforward_comment, scan_lists, scan_sexps_forward) (Fparse_partial_sexp): Add support for nested comments. (forw_comment): New subroutine used in them.

author	Richard M. Stallman <rms@gnu.org>
date	Sun, 29 Aug 1999 21:32:52 +0000
parents	3f78f1fed4e0
children	863b49f711d6

comparison

equal deleted inserted replaced

-:37b1636d73d5
+:d678b229c05a
 #include <ctype.h>
 #include "lisp.h"
 #include "commands.h"
 #include "buffer.h"
 #include "charset.h"
+#include <assert.h>
 /* Make syntax table lookup grant data in gl_state.  */
 #define SYNTAX_ENTRY_VIA_PROPERTY
 #include "syntax.h"
 struct lisp_parse_state
 {
 int depth;		/* Depth at end of parsing.  */
 int instring;	/* -1 if not within string, else desired terminator.  */
-int incomment;	/* Nonzero if within a comment at end of parsing.  */
+int incomment;	/* -1 if in unnestable comment else comment nesting */
 int comstyle;	/* comment style a=0, or b=1, or ST_COMMENT_STYLE.  */
 int quoted;		/* Nonzero if just after an escape char at end of parsing */
 int thislevelstart;	/* Char number of most recent start-of-expression at current level */
 int prevlevelstart; /* Char number of start of containing expression */
 int location;	/* Char number at which parsing stopped.  */
 static int find_start_begv;
 static int find_start_modiff;
 static int find_defun_start P_ ((int, int));
-static int back_comment P_ ((int, int, int, int, int *, int *));
+static int back_comment P_ ((int, int, int, int, int, int *, int *));
 static int char_quoted P_ ((int, int));
 static Lisp_Object skip_chars P_ ((int, int, Lisp_Object, Lisp_Object));
 static Lisp_Object scan_lists P_ ((int, int, int, int));
 static void scan_sexps_forward P_ ((struct lisp_parse_state *,
 				    int, int, int, int,
 Global syntax data remains valid for backward search starting at
 the returned value (or at FROM, if the search was not successful).  */
 static int
-back_comment (from, from_byte, stop, comstyle, charpos_ptr, bytepos_ptr)
+back_comment (from, from_byte, stop, comnested, comstyle, charpos_ptr, bytepos_ptr)
 int from, from_byte, stop;
-int comstyle;
+int comnested, comstyle;
 int *charpos_ptr, *bytepos_ptr;
 {
 /* Look back, counting the parity of string-quotes,
 and recording the comment-starters seen.
 When we reach a safe place, assume that's not in a string;
 /* Place where the containing defun starts,
 or 0 if we didn't come across it yet.  */
 int defun_start = 0;
 int defun_start_byte = 0;
 register enum syntaxcode code;
+int nesting = 1;		/* current comment nesting */
 int c;
 /* At beginning of range to scan, we're outside of strings;
 that determines quote parity to the comment-end.  */
 while (from != stop)
 	  else if (my_stringend != (code == Sstring_fence
 				    ? ST_STRING_STYLE : ST_COMMENT_STYLE))
 	    string_lossage = 1;
 	}
-/* Record comment-starters according to that
-	 quote-parity to the comment-end.  */
 if (code == Scomment)
-	{
+	/* FIXME: we should also check that the comstyle is correct
+	   if the Scomment is a single-char. */
+	{
+	  if (comnested && --nesting <= 0 && parity == 0 && !string_lossage)
+	    /* nested comments have to be balanced, so we don't need to
+	       keep looking for earlier ones.  We use here the same (slightly
+	       incorrect) reasoning as below:  since it is followed by uniform
+	       paired string quotes, this comment-start has to be outside of
+	       strings, else the comment-end itself would be inside a string. */
+	    goto done;
+	  /* Record comment-starters according to that
+	     quote-parity to the comment-end.  */
 	  comstart_parity = parity;
 	  comstart_pos = from;
 	  comstart_byte = from_byte;
 	}
 /* If we find another earlier comment-ender,
 	 any comment-starts earlier than that don't count
 	 (because they go with the earlier comment-ender).  */
 if (code == Sendcomment
 	  && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte)) == comstyle)
-	break;
+	if (comnested)
+	  nesting++;
+	else
+	  break;
 /* Assume a defun-start point is outside of strings.  */
 if (code == Sopen
 	  && (from == stop
 	      || (temp_byte = dec_bytepos (from_byte),
 /* If the earliest comment starter
 is followed by uniform paired string quotes or none,
 we know it can't be inside a string
 since if it were then the comment ender would be inside one.
 So it does start a comment.  Skip back to it.  */
-else if (comstart_parity == 0 && !string_lossage)
+else if (!comnested && comstart_parity == 0 && !string_lossage)
 {
 from = comstart_pos;
 from_byte = comstart_byte;
 /* Globals are correct now.  */
 }
 	}
 from_byte = CHAR_TO_BYTE (from);
 UPDATE_SYNTAX_TABLE_FORWARD (from - 1);
 }
+done:
 *charpos_ptr = from;
 *bytepos_ptr = from_byte;
 return from;
 }
 Only single-character comment start and end sequences are represented thus.\n\
 Two-character sequences are represented as described below.\n\
 The second character of S is the matching parenthesis,\n\
 used only if the first character is `(' or `)'.\n\
 Any additional characters are flags.\n\
-Defined flags are the characters 1, 2, 3, 4, b, and p.\n\
+Defined flags are the characters 1, 2, 3, 4, b, p, and n.\n\
 1 means CHAR is the start of a two-char comment start sequence.\n\
 2 means CHAR is the second character of such a sequence.\n\
 3 means CHAR is the start of a two-char comment end sequence.\n\
 4 means CHAR is the second character of such a sequence.\n\
 \n\
 language modes such as C++.  By default, all comment sequences are of style\n\
 a, but you can set the comment sequence style to b (on the second character\n\
 of a comment-start, or the first character of a comment-end sequence) using\n\
 this flag:\n\
 b means CHAR is part of comment sequence b.\n\
+n means CHAR is part of a nestable comment sequence.\n\
 \n\
 p means CHAR is a prefix character for `backward-prefix-chars';\n\
 such characters are treated as whitespace when they occur\n\
 between expressions.")
 (char, s, table)
 	val |= 1 << 20;
 	break;
 case 'b':
 	val |= 1 << 21;
+	break;
+case 'n':
+	val |= 1 << 22;
 	break;
 }
 if (val < XVECTOR (Vsyntax_code_object)->size && NILP (match))
 newentry = XVECTOR (Vsyntax_code_object)->contents[val];
 return make_number (PT - start_point);
 }
 }
+/* Jump over a comment, assuming we are at the beginning of one.
+FROM is the current position.
+FROM_BYTE is the bytepos corresponding to FROM.
+Do not move past STOP (a charpos).
+The comment over which we have to jump is of style STYLE
+(either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
+NESTING should be positive to indicate the nesting at the beginning
+for nested comments and should be zero or negative else.
+ST_COMMENT_STYLE cannot be nested.
+PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
+(or 0 If the search cannot start in the middle of a two-character).
+If successful, return 1 and store the charpos of the comment's end
+into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
+Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
+corresponding bytepos into *BYTEPOS_PTR and the current nesting
+(as defined for state.incomment) in *INCOMMENT_PTR.
+The comment end is the last character of the comment rather than the
+character just after the comment.
+Global syntax data is assumed to initially be valid for FROM and
+remains valid for forward search starting at the returned position. */
+static int
+forw_comment (from, from_byte, stop, nesting, style, prev_syntax,
+	      charpos_ptr, bytepos_ptr, incomment_ptr)
+int from, from_byte, stop;
+int nesting, style, prev_syntax;
+int *charpos_ptr, *bytepos_ptr, *incomment_ptr;
+{
+register int c, c1;
+register enum syntaxcode code;
+register int syntax;
+if (nesting <= 0) nesting = -1;
+/* Enter the loop in the middle so that we find
+a 2-char comment ender if we start in the middle of it.  */
+syntax = prev_syntax;
+if (syntax != 0) goto forw_incomment;
+while (1)
+{
+if (from == stop)
+	{
+	  *incomment_ptr = nesting;
+	  *charpos_ptr = from;
+	  *bytepos_ptr = from_byte;
+	  return 0;
+	}
+c = FETCH_CHAR (from_byte);
+syntax = SYNTAX_WITH_FLAGS (c);
+code = syntax & 0xff;
+if (code == Sendcomment
+	  && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style
+	  && --nesting <= 0)
+	/* we have encountered a comment end of the same style
+	   as the comment sequence which began this comment
+	   section */
+	break;
+if (code == Scomment_fence
+	  && style == ST_COMMENT_STYLE)
+	/* we have encountered a comment end of the same style
+	   as the comment sequence which began this comment
+	   section.  */
+	break;
+if (nesting > 0
+	  && code == Scomment
+	  && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style)
+	/* we have encountered a nested comment of the same style
+	   as the comment sequence which began this comment section */
+	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
+	  && (c1 = FETCH_CHAR (from_byte),
+	      SYNTAX_COMEND_SECOND (c1)))
+	if (--nesting <= 0)
+	  /* we have encountered a comment end of the same style
+	     as the comment sequence which began this comment
+	     section */
+	  break;
+	else
+	  {
+	    INC_BOTH (from, from_byte);
+	    UPDATE_SYNTAX_TABLE_FORWARD (from);
+	  }
+if (nesting > 0
+	  && from < stop
+	  && SYNTAX_FLAGS_COMSTART_FIRST (syntax)
+	  && (c1 = FETCH_CHAR (from_byte),
+	      SYNTAX_COMMENT_STYLE (c1) == style
+	      && SYNTAX_COMSTART_SECOND (c1)))
+	/* we have encountered a nested comment of the same style
+	   as the comment sequence which began this comment
+	   section */
+	{
+	  INC_BOTH (from, from_byte);
+	  UPDATE_SYNTAX_TABLE_FORWARD (from);
+	  nesting++;
+	}
+}
+*charpos_ptr = from;
+*bytepos_ptr = from_byte;
+return 1;
+}
 DEFUN ("forward-comment", Fforward_comment, Sforward_comment, 1, 1, 0,
 "Move forward across up to N comments.  If N is negative, move backward.\n\
 Stop scanning if we find something other than a comment or whitespace.\n\
 Set point to where scanning stops.\n\
 If N comments are found as expected, with nothing except whitespace\n\
 int from_byte;
 register int stop;
 register int c, c1;
 register enum syntaxcode code;
 int comstyle = 0;	    /* style of comment encountered */
+int comnested = 0;	    /* whether the comment is nestable or not */
 int found;
 int count1;
 int out_charpos, out_bytepos;
+int dummy;
 CHECK_NUMBER (count, 0);
 count1 = XINT (count);
 stop = count1 > 0 ? ZV : BEGV;
 	    {
 	      SET_PT_BOTH (from, from_byte);
 	      immediate_quit = 0;
 	      return Qnil;
 	    }
-	  UPDATE_SYNTAX_TABLE_FORWARD (from);
 	  c = FETCH_CHAR (from_byte);
 	  code = SYNTAX (c);
 	  comstart_first = SYNTAX_COMSTART_FIRST (c);
+	  comnested = SYNTAX_COMMENT_NESTED (c);
 	  INC_BOTH (from, from_byte);
 	  UPDATE_SYNTAX_TABLE_FORWARD (from);
 	  comstyle = 0;
 	  if (from < stop && comstart_first
 	      && (c1 = FETCH_CHAR (from_byte),
 		 the comment style this sequence begins so that later,
 		 only a comment end of the same style actually ends
 		 the comment section.  */
 	      code = Scomment;
 	      comstyle = SYNTAX_COMMENT_STYLE (c1);
+	      comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
 	      INC_BOTH (from, from_byte);
+	      UPDATE_SYNTAX_TABLE_FORWARD (from);
 	    }
 	}
 while (code == Swhitespace || code == Sendcomment);
 if (code == Scomment_fence)
 	  DEC_BOTH (from, from_byte);
 	  SET_PT_BOTH (from, from_byte);
 	  return Qnil;
 	}
 /* We're at the start of a comment.  */
-while (1)
+found = forw_comment (from, from_byte, stop, comnested, comstyle, 0,
-	{
+			    &out_charpos, &out_bytepos, &dummy);
-	  if (from == stop)
+from = out_charpos; from_byte = out_bytepos;
-	    {
+if (!found)
-	      immediate_quit = 0;
+	{
-	      SET_PT_BOTH (from, from_byte);
+	  immediate_quit = 0;
-	      return Qnil;
+	  SET_PT_BOTH (from, from_byte);
-	    }
+	  return Qnil;
-	  UPDATE_SYNTAX_TABLE_FORWARD (from);
+	}
-	  c = FETCH_CHAR (from_byte);
+INC_BOTH (from, from_byte);
-	  INC_BOTH (from, from_byte);
+UPDATE_SYNTAX_TABLE_FORWARD (from);
-	  if (SYNTAX (c) == Sendcomment
-	      && SYNTAX_COMMENT_STYLE (c) == comstyle)
-	    /* we have encountered a comment end of the same style
-	       as the comment sequence which began this comment
-	       section */
-	    break;
-	  if (SYNTAX (c) == Scomment_fence
-	      && comstyle == ST_COMMENT_STYLE)
-	    /* we have encountered a comment end of the same style
-	       as the comment sequence which began this comment
-	       section.  */
-	    break;
-	  if (from < stop && SYNTAX_COMEND_FIRST (c)
-	      && SYNTAX_COMMENT_STYLE (c) == comstyle
-	      && (c1 = FETCH_CHAR (from_byte),
-		  UPDATE_SYNTAX_TABLE_FORWARD (from),
-		  SYNTAX_COMEND_SECOND (c1)))
-	    /* we have encountered a comment end of the same style
-	       as the comment sequence which began this comment
-	       section */
-	    {
-	      INC_BOTH (from, from_byte);
-	      break;
-	    }
-	}
 /* We have skipped one comment.  */
 count1--;
 }
 while (count1 < 0)
 	      goto leave;
 	    }
 	  c = FETCH_CHAR (from_byte);
 	  code = SYNTAX (c);
 	  comstyle = 0;
+	  comnested = SYNTAX_COMMENT_NESTED (c);
 	  if (code == Sendcomment)
 	    comstyle = SYNTAX_COMMENT_STYLE (c);
 	  comstart_second = SYNTAX_COMSTART_SECOND (c);
 	  if (from > stop && SYNTAX_COMEND_SECOND (c)
 	      && prev_char_comend_first (from, from_byte)
 		 sequence of the same style.  */
 	      DEC_BOTH (from, from_byte);
 	      code = Sendcomment;
 	      /* Calling char_quoted, above, set up global syntax position
 		 at the new value of FROM.  */
-	      comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte));
+	      c1 = FETCH_CHAR (from_byte);
+	      comstyle = SYNTAX_COMMENT_STYLE (c1);
+	      comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
 	    }
 	  if (from > stop && comstart_second
 	      && prev_char_comstart_first (from, from_byte)
 	      && !char_quoted (from - 1, dec_bytepos (from_byte)))
 	    {
-	      /* We must record the comment style encountered so that
-		 later, we can match only the proper comment begin
-		 sequence of the same style.  */
 	      code = Scomment;
 	      DEC_BOTH (from, from_byte);
 	    }
 	  if (code == Scomment_fence)
 		  goto leave;
 		}
 	    }
 	  else if (code == Sendcomment)
 	    {
-	      found = back_comment (from, from_byte, stop, comstyle,
+	      found = back_comment (from, from_byte, stop, comnested, comstyle,
 				    &out_charpos, &out_bytepos);
 	      if (found != -1)
 		from = out_charpos, from_byte = out_bytepos;
 	      /* We have skipped one comment.  */
 	      break;
 int quoted;
 int mathexit = 0;
 register enum syntaxcode code, temp_code;
 int min_depth = depth;    /* Err out if depth gets less than this.  */
 int comstyle = 0;	    /* style of comment encountered */
+int comnested = 0;	    /* whether the comment is nestable or not */
 int temp_pos;
 int last_good = from;
 int found;
 int from_byte;
 int out_bytepos, out_charpos;
-int temp;
+int temp, dummy;
 if (depth > 0) min_depth = 0;
 if (from > ZV) from = ZV;
 if (from < BEGV) from = BEGV;
 	  int comstart_first, prefix;
 	  UPDATE_SYNTAX_TABLE_FORWARD (from);
 	  c = FETCH_CHAR (from_byte);
 	  code = SYNTAX (c);
 	  comstart_first = SYNTAX_COMSTART_FIRST (c);
+	  comnested = SYNTAX_COMMENT_NESTED (c);
 	  prefix = SYNTAX_PREFIX (c);
 	  if (depth == min_depth)
 	    last_good = from;
 	  INC_BOTH (from, from_byte);
 	  UPDATE_SYNTAX_TABLE_FORWARD (from);
 		 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
 		 the comment section */
 	      code = Scomment;
-	      comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte));
+	      c1 = FETCH_CHAR (from_byte);
+	      comstyle = SYNTAX_COMMENT_STYLE (c1);
+	      comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
 	      INC_BOTH (from, from_byte);
 	      UPDATE_SYNTAX_TABLE_FORWARD (from);
 	    }
 	  if (prefix)
 		    }
 		  INC_BOTH (from, from_byte);
 		}
 	      goto done;
+	    case Scomment_fence:
+	      comstyle = ST_COMMENT_STYLE;
+	      /* FALLTHROUGH */
 	    case Scomment:
-	    case Scomment_fence:
 	      if (!parse_sexp_ignore_comments) break;
-	      while (1)
+	      UPDATE_SYNTAX_TABLE_FORWARD (from);
+	      found = forw_comment (from, from_byte, stop,
+				    comnested, comstyle, 0,
+				    &out_charpos, &out_bytepos, &dummy);
+	      from = out_charpos, from_byte = out_bytepos;
+	      if (!found)
 		{
-		  if (from == stop)
+		  if (depth == 0)
-		    {
+		    goto done;
-		      if (depth == 0)
+		  goto lose;
-			goto done;
-		      goto lose;
-		    }
-		  UPDATE_SYNTAX_TABLE_FORWARD (from);
-		  c = FETCH_CHAR (from_byte);
-		  INC_BOTH (from, from_byte);
-		  if (code == Scomment
-		      ? (SYNTAX (c) == Sendcomment
-			 && SYNTAX_COMMENT_STYLE (c) == comstyle)
-		      : (SYNTAX (c) == Scomment_fence))
-		    /* we have encountered a comment end of the same style
-		       as the comment sequence which began this comment
-		       section */
-		    break;
-		  if (from < stop && SYNTAX_COMEND_FIRST (c)
-		      && SYNTAX_COMMENT_STYLE (c) == comstyle
-		      && (UPDATE_SYNTAX_TABLE_FORWARD (from),
-			  SYNTAX_COMEND_SECOND (FETCH_CHAR (from_byte)))
-		      && code == Scomment)
-		    /* we have encountered a comment end of the same style
-		       as the comment sequence which began this comment
-		       section */
-		    {
-		      INC_BOTH (from, from_byte);
-		      break;
-		    }
 		}
+	      INC_BOTH (from, from_byte);
+	      UPDATE_SYNTAX_TABLE_FORWARD (from);
 	      break;
 	    case Smath:
 	      if (!sexpflag)
 		break;
 	  c = FETCH_CHAR (from_byte);
 	  code = SYNTAX (c);
 	  if (depth == min_depth)
 	    last_good = from;
 	  comstyle = 0;
+	  comnested = SYNTAX_COMMENT_NESTED (c);
 	  if (code == Sendcomment)
 	    comstyle = SYNTAX_COMMENT_STYLE (c);
 	  if (from > stop && SYNTAX_COMEND_SECOND (c)
 	      && prev_char_comend_first (from, from_byte)
 	      && parse_sexp_ignore_comments)
 		 later, we can match only the proper comment begin
 		 sequence of the same style.  */
 	      DEC_BOTH (from, from_byte);
 	      UPDATE_SYNTAX_TABLE_BACKWARD (from);
 	      code = Sendcomment;
-	      comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte));
+	      c1 = FETCH_CHAR (from_byte);
+	      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 if cannot be true
 	     if we decremented FROM in the if-statement above.  */
 	      break;
 	    case Sendcomment:
 	      if (!parse_sexp_ignore_comments)
 		break;
-	      found = back_comment (from, from_byte, stop, comstyle,
+	      found = back_comment (from, from_byte, stop, comnested, comstyle,
 				    &out_charpos, &out_bytepos);
 	      if (found != -1)
 		from = out_charpos, from_byte = out_bytepos;
 	      break;
 int commentstop;
 {
 struct lisp_parse_state state;
 register enum syntaxcode code;
+int c1;
+int comnested;
 struct level { int last, prev; };
 struct level levelstart[100];
 register struct level *curlevel = levelstart;
 struct level *endlevel = levelstart + 100;
-int prev;
 register int depth;	/* Paren depth of current scanning location.
 			   level - levelstart equals this except
 			   when the depth becomes negative.  */
 int mindepth;		/* Lowest DEPTH value seen.  */
 int start_quoted = 0;		/* Nonzero means starting after a char quote */
 int prev_from;		/* Keep one character before FROM.  */
 int prev_from_byte;
 int prev_from_syntax;
 int boundary_stop = commentstop == -1;
 int nofence;
+int found;
+int out_bytepos, out_charpos;
 int temp;
 prev_from = from;
 prev_from_byte = from_byte;
 if (from != BEGV)
 			 ? ( INTEGERP (tem) ? XINT (tem) : ST_STRING_STYLE)
 			 : -1);
 oldstate = Fcdr (oldstate);
 tem = Fcar (oldstate);
-state.incomment = !NILP (tem);
+state.incomment = ( !NILP (tem)
+			 ? ( INTEGERP (tem) ? XINT (tem) : -1)
+			 : 0);
 oldstate = Fcdr (oldstate);
 tem = Fcar (oldstate);
 start_quoted = !NILP (tem);
-/* if the eight element of the list is nil, we are in comment
+/* if the eighth element of the list is nil, we are in comment
 	 style a.  If it is non-nil, we are in comment style b */
 oldstate = Fcdr (oldstate);
 oldstate = Fcdr (oldstate);
 tem = Fcar (oldstate);
 state.comstyle = NILP (tem) ? 0 : ( EQ (tem, Qsyntax_table)
 {
 INC_FROM;
 code = prev_from_syntax & 0xff;
 if (code == Scomment)
-	state.comstr_start = prev_from;
+	{
+	  state.incomment = (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax) ?
+			     1 : -1);
+	  state.comstr_start = prev_from;
+	}
 else if (code == Scomment_fence)
 	{
 	  /* 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 = ( code == Scomment_fence
+	  state.comstyle = ST_COMMENT_STYLE;
-			     ? ST_COMMENT_STYLE
+	  state.incomment = -1;
-			     : SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte)));
 	  state.comstr_start = prev_from;
-	  if (code != Scomment_fence)
-	    INC_FROM;
 	  code = Scomment;
 	}
 else if (from < end)
 	if (SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax))
-	  if (SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte)))
+	  if (c1 = FETCH_CHAR (from_byte),
+	      SYNTAX_COMSTART_SECOND (c1))
 	    /* Duplicate code to avoid a complex if-expression
 	       which causes trouble for the SGI compiler.  */
 	    {
 	      /* 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 = ( code == Scomment_fence
+	      state.comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte));
-				 ? ST_COMMENT_STYLE
+	      comnested = SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax);
-				 : SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte)));
+	      comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+	      state.incomment = comnested ? 1 : -1;
 	      state.comstr_start = prev_from;
-	      if (code != Scomment_fence)
+	      INC_FROM;
-		INC_FROM;
 	      code = Scomment;
 	    }
 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax))
 	continue;
 	  break;
 	startincomment:
 	  if (commentstop == 1)
 	    goto done;
-	  if (from != BEGV)
-	    {
-	      /* Enter the loop in the middle so that we find
-		 a 2-char comment ender if we start in the middle of it.  */
-	      goto startincomment_1;
-	    }
-	  /* At beginning of buffer, enter the loop the ordinary way.  */
-	  state.incomment = 1;
 	  goto commentloop;
 	case Scomment:
-	  state.incomment = 1;
+	  assert (state.incomment != 0); /* state.incomment = -1; */
 	  if (commentstop || boundary_stop) goto done;
 	commentloop:
-	  while (1)
+	  /* The (from == BEGV) test is to enter the loop in the middle so
-	    {
+	     that we find a 2-char comment ender even if we start in the
-	      if (from == end) goto done;
+	     middle of it.  */
-	      prev = FETCH_CHAR (from_byte);
+	  found = forw_comment (from, from_byte, end,
-	      if (SYNTAX (prev) == Sendcomment
+				state.incomment, state.comstyle,
-		  && SYNTAX_COMMENT_STYLE (prev) == state.comstyle)
+				(from == BEGV) ? 0 : prev_from_syntax,
-		/* Only terminate the comment section if the endcomment
+				&out_charpos, &out_bytepos, &state.incomment);
-		   of the same style as the start sequence has been
+	  from = out_charpos; from_byte = out_bytepos;
-		   encountered.  */
+	  /* Beware!  prev_from and friends are invalid now.
-		break;
+	     Luckily, the `done' doesn't use them and the INC_FROM
-	      if (state.comstyle == ST_COMMENT_STYLE
+	     sets them to a sane value without looking at them. */
-		  && SYNTAX (prev) == Scomment_fence)
+	  if (!found) goto done;
-		break;
-	      INC_FROM;
-	    startincomment_1:
-	      if (from < end && SYNTAX_FLAGS_COMEND_FIRST (prev_from_syntax)
-		  && SYNTAX_COMEND_SECOND (FETCH_CHAR (from_byte))
-		  && (SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax)
-		      == state.comstyle))
-		/* Only terminate the comment section if the end-comment
-		   sequence of the same style as the start sequence has
-		   been encountered.  */
-		break;
-	    }
 	  INC_FROM;
 	  state.incomment = 0;
 	  state.comstyle = 0;	/* reset the comment style */
 	  if (boundary_stop) goto done;
 	  break;
 1. character address of start of innermost containing list; nil if none.\n\
 2. character address of start of last complete sexp terminated.\n\
 3. non-nil if inside a string.\n\
 (it is the character that will terminate the string,\n\
 or t if the string should be terminated by a generic string delimiter.)\n\
-4. t if inside a comment.\n\
+4. nil if outside a comment, t if inside a non-nestable comment, \n\
+else an integer (the current comment nesting).\n\
 5. t if following a quote character.\n\
 6. the minimum paren-depth encountered during this scan.\n\
 7. t if in a comment of style b; `syntax-table' if the comment\n\
 should be terminated by a generic comment delimiter.\n\
 8. character address of start of comment or string; nil if not in one.\n\
 	   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
 			 ? Qt : make_number (state.instring)) : Qnil,
-		 Fcons (state.incomment ? Qt : 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
 			       ? (state.comstyle == ST_COMMENT_STYLE
 				  ? Qsyntax_table : Qt) :

Mercurial > emacs

comparison src/syntax.c @ 25445:d678b229c05a