(describe_syntax_1): Delete excess arg to describe_vector.

(check_syntax_table): Delete excess arg to wrong_type_argument.

(Fforward_comment): New function.

1 files changed, 260 insertions, 2 deletions

diff --git a/src/syntax.c b/src/syntax.c
index 3bb9e2956cc..2af69a3d52b 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -120,7 +120,7 @@ check_syntax_table (obj)
   register Lisp_Object tem;
   while (tem = Fsyntax_table_p (obj),
 	 NILP (tem))
-    obj = wrong_type_argument (Qsyntax_table_p, obj, 0);
+    obj = wrong_type_argument (Qsyntax_table_p, obj);
   return obj;
 }   
 
@@ -449,7 +449,7 @@ describe_syntax_1 (vector)
 {
   struct buffer *old = current_buffer;
   set_buffer_internal (XBUFFER (Vstandard_output));
-  describe_vector (vector, Qnil, describe_syntax, 0, Qnil, Qnil);
+  describe_vector (vector, Qnil, describe_syntax, 0, Qnil);
   set_buffer_internal (old);
   return Qnil;
 }
@@ -563,6 +563,263 @@ and nil is returned.")
   return Qt;
 }
 
+DEFUN ("forward-comment", Fforward_comment, Sforward_comment, 1, 1, 0,
+  "Move forward across up to N comments.  If N is negative, move backward.\n\
+Set point to the far end of the last comment found.\n\
+Stop scanning if we find something other than a comment or whitespace.\n\
+If N comments are found as expected, with nothing except whitespace\n\
+between them, return t; otherwise return nil.")
+  (count)
+     int count;
+{
+  register int from;
+  register int stop;
+  register int c;
+  register enum syntaxcode code;
+  int comstyle = 0;	    /* style of comment encountered */
+
+  immediate_quit = 1;
+  QUIT;
+
+  from = PT;
+
+  while (count > 0)
+    {
+      stop = ZV;
+      while (from < stop)
+	{
+	  c = FETCH_CHAR (from);
+	  code = SYNTAX (c);
+	  from++;
+	  comstyle = 0;
+	  if (from < stop && SYNTAX_COMSTART_FIRST (c)
+	      && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from)))
+	    {
+	      /* 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
+		 the comment section */
+	      code = Scomment;
+	      comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from));
+	      from++;
+	    }
+
+	  if (code == Scomment)
+	    {
+	      while (1)
+		{
+		  if (from == stop)
+		    {
+		      immediate_quit = 0;
+		      return Qnil;
+		    }
+		  c = FETCH_CHAR (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;
+		  from++;
+		  if (from < stop && SYNTAX_COMEND_FIRST (c)
+		      && SYNTAX_COMEND_SECOND (FETCH_CHAR (from))
+		      && SYNTAX_COMMENT_STYLE (c) == comstyle)
+		    /* we have encountered a comment end of the same style
+		       as the comment sequence which began this comment
+		       section */
+		    { from++; break; }
+		}
+	      /* We have skipped one comment.  */
+	      break;
+	    }
+	  else if (code != Swhitespace)
+	    {
+	      immediate_quit = 0;
+	      return Qnil;
+	    }
+	}
+
+      /* End of comment reached */
+      count--;
+    }
+
+  while (count < 0)
+    {
+      stop = BEGV;
+      while (from > stop)
+	{
+	  int quoted;
+
+	  from--;
+	  quoted = char_quoted (from);
+	  if (quoted)
+	    from--;
+	  c = FETCH_CHAR (from);
+	  code = SYNTAX (c);
+	  comstyle = 0;
+	  if (from > stop && SYNTAX_COMEND_SECOND (c)
+	      && SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1))
+	      && !char_quoted (from - 1))
+	    {
+	      /* we must record the comment style encountered so that
+		 later, we can match only the proper comment begin
+		 sequence of the same style */
+	      code = Sendcomment;
+	      comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from - 1));
+	      from--;
+	    }
+
+	  if (code == Sendcomment && !quoted)
+	    {
+	      if (code != SYNTAX (c))
+		/* For a two-char comment ender, we can assume
+		   it does end a comment.  So scan back in a simple way.  */
+		{
+		  if (from != stop) from--;
+		  while (1)
+		    {
+		      if (SYNTAX (c = FETCH_CHAR (from)) == Scomment
+			  && SYNTAX_COMMENT_STYLE (c) == comstyle)
+			break;
+		      if (from == stop)
+			{
+			  immediate_quit = 0;
+			  return Qnil;
+			}
+		      from--;
+		      if (SYNTAX_COMSTART_SECOND (c)
+			  && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from))
+			  && SYNTAX_COMMENT_STYLE (c) == comstyle
+			  && !char_quoted (from))
+			break;
+		    }
+		  break;
+		}
+
+	      /* 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;
+		 then step the main scan to the earliest comment-starter seen
+		 an even number of string quotes away from the safe place.
+
+		 OFROM[I] is position of the earliest comment-starter seen
+		 which is I+2X quotes from the comment-end.
+		 PARITY is current parity of quotes from the comment end.  */
+	      {
+		int parity = 0;
+		char my_stringend = 0;
+		int string_lossage = 0;
+		int comment_end = from;
+		int comstart_pos = 0;
+		int comstart_parity = 0;
+
+		/* At beginning of range to scan, we're outside of strings;
+		   that determines quote parity to the comment-end.  */
+		while (from != stop)
+		  {
+		    /* Move back and examine a character.  */
+		    from--;
+
+		    c = FETCH_CHAR (from);
+		    code = SYNTAX (c);
+
+		    /* If this char is the second of a 2-char comment sequence,
+		       back up and give the pair the appropriate syntax.  */
+		    if (from > stop && SYNTAX_COMEND_SECOND (c)
+			&& SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1)))
+		      {
+			code = Sendcomment;
+			from--;
+		      }
+			
+		    else if (from > stop && SYNTAX_COMSTART_SECOND (c)
+			     && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from - 1))
+			     && comstyle == SYNTAX_COMMENT_STYLE (c))
+		      {
+			code = Scomment;
+			from--;
+		      }
+
+		    /* Ignore escaped characters.  */
+		    if (char_quoted (from))
+		      continue;
+
+		    /* Track parity of quotes.  */
+		    if (code == Sstring)
+		      {
+			parity ^= 1;
+			if (my_stringend == 0)
+			  my_stringend = c;
+			/* If we have two kinds of string delimiters.
+			   There's no way to grok this scanning backwards.  */
+			else if (my_stringend != c)
+			  string_lossage = 1;
+		      }
+
+		    /* Record comment-starters according to that
+		       quote-parity to the comment-end.  */
+		    if (code == Scomment)
+		      {
+			comstart_parity = parity;
+			comstart_pos = from;
+		      }
+
+		    /* If we find another earlier comment-ender,
+		       any comment-starts earier than that don't count
+		       (because they go with the earlier comment-ender).  */
+		    if (code == Sendcomment
+			&& SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)) == comstyle)
+		      break;
+
+		    /* Assume a defun-start point is outside of strings.  */
+		    if (code == Sopen
+			&& (from == stop || FETCH_CHAR (from - 1) == '\n'))
+		      break;
+		  }
+
+		if (comstart_pos == 0)
+		  from = comment_end;
+		/* 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)
+		  from = comstart_pos;
+		else
+		  {
+		    /* We had two kinds of string delimiters mixed up
+		       together.  Decode this going forwards.
+		       Scan fwd from the previous comment ender
+		       to the one in question; this records where we
+		       last passed a comment starter.  */
+		    struct lisp_parse_state state;
+		    scan_sexps_forward (&state, find_defun_start (comment_end),
+					comment_end - 1, -10000, 0, Qnil);
+		    if (state.incomment)
+		      from = state.comstart;
+		    else
+		      /* We can't grok this as a comment; scan it normally.  */
+		      from = comment_end;
+		  }
+	      }
+	    }
+	  else if (code != Swhitespace || quoted)
+	    {
+	      immediate_quit = 0;
+	      return Qnil;
+	    }
+	}
+
+      count++;
+    }
+
+  SET_PT (from);
+  immediate_quit = 0;
+  return Qt;
+}
+
 int parse_sexp_ignore_comments;
 
 Lisp_Object
@@ -1418,6 +1675,7 @@ syms_of_syntax ()
 
   defsubr (&Sforward_word);
 
+  defsubr (&Sforward_comment);
   defsubr (&Sscan_lists);
   defsubr (&Sscan_sexps);
   defsubr (&Sbackward_prefix_chars);