/* GNU Emacs routines to deal with syntax tables; also word and list parsing.
- Copyright (C) 1985, 1987, 1992 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1987, 1993 Free Software Foundation, Inc.
This file is part of GNU Emacs.
Lisp_Object Qsyntax_table_p;
+static void scan_sexps_forward ();
+static int char_quoted ();
+
int words_include_escapes;
/* This is the internal form of the parse state used in parse-partial-sexp. */
int comstart; /* Position just after last comment starter. */
};
\f
+/* These variables are a cache for finding the start of a defun.
+ find_start_pos is the place for which the defun start was found.
+ find_start_value is the defun start position found for it.
+ find_start_buffer is the buffer it was found in.
+ find_start_begv is the BEGV value when it was found.
+ find_start_modiff is the value of MODIFF when it was found. */
+
+static int find_start_pos;
+static int find_start_value;
+static struct buffer *find_start_buffer;
+static int find_start_begv;
+static int find_start_modiff;
+
+/* Find a defun-start that is the last one before POS (or nearly the last).
+ We record what we find, so that another call in the same area
+ can return the same value right away. */
+
+static int
+find_defun_start (pos)
+ int pos;
+{
+ int tem;
+ int shortage;
+
+ /* 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.
+ POS might be in the next defun, but that's ok.
+ Our value may not be the best possible, but will still be usable. */
+ && pos <= find_start_pos + 1000
+ && pos >= find_start_value
+ && BEGV == find_start_begv
+ && MODIFF == find_start_modiff)
+ return find_start_value;
+
+ /* Back up to start of line. */
+ tem = scan_buffer ('\n', pos, -1, &shortage);
+
+ while (tem > BEGV)
+ {
+ /* Open-paren at start of line means we found our defun-start. */
+ if (SYNTAX (FETCH_CHAR (tem)) == Sopen)
+ break;
+ /* Move to beg of previous line. */
+ tem = scan_buffer ('\n', tem, -2, &shortage);
+ }
+
+ /* Record what we found, for the next try. */
+ find_start_value = tem;
+ find_start_buffer = current_buffer;
+ find_start_modiff = MODIFF;
+ find_start_begv = BEGV;
+ find_start_pos = pos;
+
+ return find_start_value;
+}
+\f
DEFUN ("syntax-table-p", Fsyntax_table_p, Ssyntax_table_p, 1, 1, 0,
"Return t if ARG is a syntax table.\n\
Any vector of 256 elements will do.")
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;
}
table = check_syntax_table (table);
current_buffer->syntax_table = table;
/* Indicate that this buffer now has a specified syntax table. */
- current_buffer->local_var_flags |= buffer_local_flags.syntax_table;
+ current_buffer->local_var_flags
+ |= XFASTINT (buffer_local_flags.syntax_table);
return table;
}
\f
for make-docfile to see. We cannot put this in the real DEFUN
due to limits in the Unix cpp.
-DEFUN ("modify-syntax-entry", foo, bar, 0, 0, 0,
+DEFUN ("modify-syntax-entry", foo, bar, 2, 3, 0,
"Set syntax for character CHAR according to string S.\n\
The syntax is changed only for table TABLE, which defaults to\n\
the current buffer's syntax table.\n\
p means C is a prefix character for `backward-prefix-chars';\n\
such characters are treated as whitespace when they occur\n\
between expressions.")
-
+ (char, s, table)
*/
DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3,
\f
/* Dump syntax table to buffer in human-readable format */
+static void
describe_syntax (value)
Lisp_Object value;
{
if (match)
{
insert_string (", matches ");
-
- str[0] = match, str[1] = 0;
- insert (str, 1);
+ insert_char (match);
}
if (start1)
insert_string ("\n");
}
-Lisp_Object
+static Lisp_Object
describe_syntax_1 (vector)
Lisp_Object 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;
}
return Qt;
}
\f
+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\
+between them, return t; otherwise return nil.")
+ (count)
+ Lisp_Object count;
+{
+ register int from;
+ register int stop;
+ register int c;
+ register enum syntaxcode code;
+ int comstyle = 0; /* style of comment encountered */
+ int found;
+ int count1;
+
+ CHECK_NUMBER (count, 0);
+ count1 = XINT (count);
+
+ immediate_quit = 1;
+ QUIT;
+
+ from = PT;
+
+ while (count1 > 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;
+ SET_PT (from);
+ 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 && code != Sendcomment)
+ {
+ immediate_quit = 0;
+ SET_PT (from - 1);
+ return Qnil;
+ }
+ }
+
+ /* End of comment reached */
+ count1--;
+ }
+
+ while (count1 < 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 0
+ 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;
+ SET_PT (from);
+ return Qnil;
+ }
+ from--;
+ if (SYNTAX_COMSTART_SECOND (c)
+ && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from))
+ && SYNTAX_COMMENT_STYLE (c) == comstyle
+ && !char_quoted (from))
+ break;
+ }
+ break;
+ }
+#endif /* 0 */
+
+ /* 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 earlier 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, 0);
+ 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 && code != Scomment) || quoted)
+ {
+ immediate_quit = 0;
+ SET_PT (from + 1);
+ return Qnil;
+ }
+ }
+
+ count1++;
+ }
+
+ SET_PT (from);
+ immediate_quit = 0;
+ return Qt;
+}
+\f
int parse_sexp_ignore_comments;
Lisp_Object
case Sendcomment:
if (!parse_sexp_ignore_comments)
break;
+#if 0
+ 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) goto done;
+ from--;
+ if (SYNTAX_COMSTART_SECOND (c)
+ && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from))
+ && SYNTAX_COMMENT_STYLE (c) == comstyle
+ && !char_quoted (from))
+ break;
+ }
+ break;
+ }
+#endif /* 0 */
+
/* 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;
which is I+2X quotes from the comment-end.
PARITY is current parity of quotes from the comment end. */
{
- int ofrom[2];
int parity = 0;
char my_stringend = 0;
int string_lossage = 0;
int comment_end = from;
-
- ofrom[0] = ofrom[1] = 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. */
if (char_quoted (from))
continue;
- /* Track parity of quotes between here and comment-end. */
+ /* Track parity of quotes. */
if (code == Sstring)
{
parity ^= 1;
if (my_stringend == 0)
my_stringend = c;
- /* We have two kinds of string delimiters.
+ /* 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)
- ofrom[parity] = from;
+ {
+ comstart_parity = parity;
+ comstart_pos = from;
+ }
- /* If we come to another comment-end,
- assume it's not inside a string.
- That determines the quote parity to the comment-end.
- Note that the comment style this character ends must
- match the style that we have begun */
+ /* 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)) == comstyle)
break;
+
+ /* Assume a defun-start point is outside of strings. */
+ if (code == Sopen
+ && (from == stop || FETCH_CHAR (from - 1) == '\n'))
+ break;
}
- if (string_lossage)
+
+ 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.
to the one in question; this records where we
last passed a comment starter. */
struct lisp_parse_state state;
- scan_sexps_forward (&state, from + 1, comment_end - 1,
- -10000, 0, Qnil);
+ scan_sexps_forward (&state, find_defun_start (comment_end),
+ comment_end - 1, -10000, 0, Qnil, 0);
if (state.incomment)
from = state.comstart;
else
/* We can't grok this as a comment; scan it normally. */
from = comment_end;
}
- else
- from = ofrom[parity];
}
break;
/* NOTREACHED */
}
+static int
char_quoted (pos)
register int pos;
{
/* Parse forward from FROM to END,
assuming that FROM has state OLDSTATE (nil means FROM is start of function),
and return a description of the state of the parse at END.
- If STOPBEFORE is nonzero, stop at the start of an atom. */
+ If STOPBEFORE is nonzero, stop at the start of an atom.
+ If COMMENTSTOP is nonzero, stop at the start of a comment. */
-scan_sexps_forward (stateptr, from, end, targetdepth, stopbefore, oldstate)
+static void
+scan_sexps_forward (stateptr, from, end, targetdepth,
+ stopbefore, oldstate, commentstop)
struct lisp_parse_state *stateptr;
register int from;
int end, targetdepth, stopbefore;
Lisp_Object oldstate;
+ int commentstop;
{
struct lisp_parse_state state;
{
code = SYNTAX (FETCH_CHAR (from));
from++;
- if (from < end && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from - 1))
- && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from)))
+ if (code == Scomment)
+ state.comstart = from-1;
+
+ else if (from < end && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from - 1))
+ && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from)))
{
/* Record the comment style we have entered so that only
the comment-end sequence of the same style actually
terminates the comment section. */
code = Scomment;
state.comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from));
+ state.comstart = from-1;
from++;
}
case Scomment:
state.incomment = 1;
- state.comstart = from;
startincomment:
+ if (commentstop)
+ goto done;
while (1)
{
if (from == end) goto done;
for make-docfile to see. We cannot put this in the real DEFUN
due to limits in the Unix cpp.
-DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 5, 0,
+DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 6, 0,
"Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
Parsing stops at TO or when certain criteria are met;\n\
point is set to where parsing stops.\n\
any character that starts a sexp.\n\
Fifth arg STATE is a seven-list like what this function returns.\n\
It is used to initialize the state of the parse. Its second and third
-elements are ignored.")
- (from, to, targetdepth, stopbefore, state)
+elements are ignored.
+Sixth args COMMENTSTOP non-nil means stop at the start of a comment.")
+ (from, to, targetdepth, stopbefore, state, commentstop)
*/
-DEFUN ("parse-partial-sexp", Fparse_partial_sexp, Sparse_partial_sexp, 2, 5, 0,
+DEFUN ("parse-partial-sexp", Fparse_partial_sexp, Sparse_partial_sexp, 2, 6, 0,
0 /* See immediately above */)
- (from, to, targetdepth, stopbefore, oldstate)
- Lisp_Object from, to, targetdepth, stopbefore, oldstate;
+ (from, to, targetdepth, stopbefore, oldstate, commentstop)
+ Lisp_Object from, to, targetdepth, stopbefore, oldstate, commentstop;
{
struct lisp_parse_state state;
int target;
validate_region (&from, &to);
scan_sexps_forward (&state, XINT (from), XINT (to),
- target, !NILP (stopbefore), oldstate);
+ target, !NILP (stopbefore), oldstate,
+ !NILP (commentstop));
SET_PT (state.location);
defsubr (&Sforward_word);
+ defsubr (&Sforward_comment);
defsubr (&Sscan_lists);
defsubr (&Sscan_sexps);
defsubr (&Sbackward_prefix_chars);