/* GNU Emacs routines to deal with syntax tables; also word and list parsing.
- Copyright (C) 1985, 1987 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1987, 1993, 1994, 1995 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
-#include "config.h"
+#include <config.h>
#include <ctype.h>
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
#include "syntax.h"
-Lisp_Object Qsyntax_table_p;
+Lisp_Object Qsyntax_table_p, Qsyntax_table;
+
+static void scan_sexps_forward ();
+static int char_quoted ();
int words_include_escapes;
+/* Used as a temporary in SYNTAX_ENTRY and other macros in syntax.h,
+ if not compiled with GCC. No need to mark it, since it is used
+ only very temporarily. */
+Lisp_Object syntax_temp;
+
+/* This is the internal form of the parse state used in parse-partial-sexp. */
+
+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 comstyle; /* comment style a=0, or b=1 */
+ 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. */
+ int mindepth; /* Minimum depth seen while scanning. */
+ 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, BEGV, -1, &shortage, 1);
+
+ 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, BEGV, -2, &shortage, 1);
+ }
+
+ /* 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.")
- (obj)
- Lisp_Object obj;
+ "Return t if OBJECT is a syntax table.\n\
+Currently, any char-table counts as a syntax table.")
+ (object)
+ Lisp_Object object;
{
- if (XTYPE (obj) == Lisp_Vector && XVECTOR (obj)->size == 0400)
+ if (CHAR_TABLE_P (object)
+ && XCHAR_TABLE (object)->purpose == Qsyntax_table)
return Qt;
return Qnil;
}
-Lisp_Object
+static void
check_syntax_table (obj)
Lisp_Object obj;
{
- register Lisp_Object tem;
- while (tem = Fsyntax_table_p (obj),
- NULL (tem))
- obj = wrong_type_argument (Qsyntax_table_p, obj, 0);
- return obj;
+ if (!(CHAR_TABLE_P (obj)
+ && XCHAR_TABLE (obj)->purpose == Qsyntax_table))
+ wrong_type_argument (Qsyntax_table_p, obj);
}
-
DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 0, 0,
"Return the current syntax table.\n\
This is the one specified by the current buffer.")
(table)
Lisp_Object table;
{
- Lisp_Object size, val;
- XFASTINT (size) = 0400;
- XFASTINT (val) = 0;
- val = Fmake_vector (size, val);
- if (!NULL (table))
- table = check_syntax_table (table);
- else if (NULL (Vstandard_syntax_table))
- /* Can only be null during initialization */
- return val;
- else table = Vstandard_syntax_table;
-
- bcopy (XVECTOR (table)->contents,
- XVECTOR (val)->contents, 0400 * sizeof (Lisp_Object));
- return val;
+ Lisp_Object copy;
+
+ if (!NILP (table))
+ check_syntax_table (table);
+ else
+ table = Vstandard_syntax_table;
+
+ copy = Fcopy_sequence (table);
+
+ /* Only the standard syntax table should have a default element.
+ Other syntax tables should inherit from parents instead. */
+ XCHAR_TABLE (copy)->defalt = Qnil;
+
+ /* Copied syntax tables should all have parents.
+ If we copied one with no parent, such as the standard syntax table,
+ use the standard syntax table as the copy's parent. */
+ if (NILP (XCHAR_TABLE (copy)->parent))
+ Fset_char_table_parent (copy, Vstandard_syntax_table);
+ return copy;
}
DEFUN ("set-syntax-table", Fset_syntax_table, Sset_syntax_table, 1, 1, 0,
(table)
Lisp_Object table;
{
- table = check_syntax_table (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
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
0377, 0377, 0377, 0377,
(char) Scomment, 0377, (char) Sendcomment, 0377,
- 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A, ... */
+ (char) Sinherit, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword,
0377, 0377, 0377, 0377, (char) Sescape, 0377, 0377, (char) Ssymbol,
/* Indexed by syntax code, give the letter that describes it. */
-char syntax_code_spec[13] =
+char syntax_code_spec[14] =
{
- ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>'
+ ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@'
};
\f
+/* Look up the value for CHARACTER in syntax table TABLE's parent
+ and its parents. SYNTAX_ENTRY calls this, when TABLE itself has nil
+ for CHARACTER. It's actually used only when not compiled with GCC. */
+
+Lisp_Object
+syntax_parent_lookup (table, character)
+ Lisp_Object table;
+ int character;
+{
+ Lisp_Object value;
+
+ while (1)
+ {
+ table = XCHAR_TABLE (table)->parent;
+ if (NILP (table))
+ return Qnil;
+
+ value = XCHAR_TABLE (table)->contents[character];
+ if (!NILP (value))
+ return value;
+ }
+}
+
DEFUN ("char-syntax", Fchar_syntax, Schar_syntax, 1, 1, 0,
- "Return the syntax code of CHAR, described by a character.\n\
-For example, if CHAR is a word constituent, the character `?w' is returned.\n\
+ "Return the syntax code of CHARACTER, described by a character.\n\
+For example, if CHARACTER is a word constituent,\n\
+the character `w' is returned.\n\
The characters that correspond to various syntax codes\n\
are listed in the documentation of `modify-syntax-entry'.")
- (ch)
- Lisp_Object ch;
+ (character)
+ Lisp_Object character;
+{
+ int char_int;
+ CHECK_NUMBER (character, 0);
+ char_int = XINT (character);
+ return make_number (syntax_code_spec[(int) SYNTAX (char_int)]);
+}
+
+DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 1, 0,
+ "Return the matching parenthesis of CHARACTER, or nil if none.")
+ (character)
+ Lisp_Object character;
{
- CHECK_NUMBER (ch, 0);
- return make_number (syntax_code_spec[(int) SYNTAX (0xFF & XINT (ch))]);
+ int char_int, code;
+ CHECK_NUMBER (character, 0);
+ char_int = XINT (character);
+ code = SYNTAX (char_int);
+ if (code == Sopen || code == Sclose)
+ return make_number (SYNTAX_MATCH (char_int));
+ return Qnil;
}
/* This comment supplies the doc string for modify-syntax-entry,
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\
The first character of S should be one of the following:\n\
- Space whitespace syntax. w word constituent.\n\
- _ symbol constituent. . punctuation.\n\
- ( open-parenthesis. ) close-parenthesis.\n\
- \" string quote. \\ character-quote.\n\
- $ paired delimiter. ' expression quote or prefix operator.\n\
- < comment starter. > comment ender.\n\
+ Space or - whitespace syntax. w word constituent.\n\
+ _ symbol constituent. . punctuation.\n\
+ ( open-parenthesis. ) close-parenthesis.\n\
+ \" string quote. \\ escape.\n\
+ $ paired delimiter. ' expression quote or prefix operator.\n\
+ < comment starter. > comment ender.\n\
+ / character-quote. @ inherit from `standard-syntax-table'.\n\
+\n\
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, and p.\n\
- 1 means C is the start of a two-char comment start sequence.\n\
- 2 means C is the second character of such a sequence.\n\
- 3 means C is the start of a two-char comment end sequence.\n\
- 4 means C is the second character of such a sequence.\n\
- p means C is a prefix character for `backward-prefix-chars';
- such characters are treated as whitespace when they occur
+Defined flags are the characters 1, 2, 3, 4, b, and p.\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\
+There can be up to two orthogonal comment sequences. This is to support\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\
+ 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)
*/
DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3,
(c, newentry, syntax_table)
Lisp_Object c, newentry, syntax_table;
{
- register unsigned char *p, match;
+ register unsigned char *p;
register enum syntaxcode code;
- Lisp_Object val;
+ int val;
+ Lisp_Object match;
CHECK_NUMBER (c, 0);
CHECK_STRING (newentry, 1);
- if (NULL (syntax_table))
+
+ if (NILP (syntax_table))
syntax_table = current_buffer->syntax_table;
else
- syntax_table = check_syntax_table (syntax_table);
+ check_syntax_table (syntax_table);
p = XSTRING (newentry)->data;
code = (enum syntaxcode) syntax_spec_code[*p++];
if (((int) code & 0377) == 0377)
error ("invalid syntax description letter: %c", c);
- match = *p;
- if (match) p++;
- if (match == ' ') match = 0;
+ if (code == Sinherit)
+ {
+ SET_RAW_SYNTAX_ENTRY (syntax_table, c, Qnil);
+ return Qnil;
+ }
- XFASTINT (val) = (match << 8) + (int) code;
+ if (*p)
+ {
+ XSETINT (match, *p++);
+ if (XFASTINT (match) == ' ')
+ match = Qnil;
+ }
+ else
+ match = Qnil;
+
+ val = (int) code;
while (*p)
switch (*p++)
{
case '1':
- XFASTINT (val) |= 1 << 16;
+ val |= 1 << 16;
break;
case '2':
- XFASTINT (val) |= 1 << 17;
+ val |= 1 << 17;
break;
case '3':
- XFASTINT (val) |= 1 << 18;
+ val |= 1 << 18;
break;
case '4':
- XFASTINT (val) |= 1 << 19;
+ val |= 1 << 19;
break;
case 'p':
- XFASTINT (val) |= 1 << 20;
+ val |= 1 << 20;
+ break;
+
+ case 'b':
+ val |= 1 << 21;
break;
}
- XVECTOR (syntax_table)->contents[0xFF & XINT (c)] = val;
+ SET_RAW_SYNTAX_ENTRY (syntax_table, c,
+ Fcons (make_number (val), match));
return Qnil;
}
\f
/* Dump syntax table to buffer in human-readable format */
+static void
describe_syntax (value)
Lisp_Object value;
{
register enum syntaxcode code;
- char desc, match, start1, start2, end1, end2, prefix;
+ char desc, match, start1, start2, end1, end2, prefix, comstyle;
char str[2];
+ Lisp_Object first, match_lisp;
Findent_to (make_number (16), make_number (1));
- if (XTYPE (value) != Lisp_Int)
+ if (NILP (value))
+ {
+ insert_string ("inherit");
+ return;
+ }
+
+ if (!CONSP (value))
+ {
+ insert_string ("invalid");
+ return;
+ }
+
+ first = XCONS (value)->car;
+ match_lisp = XCONS (value)->cdr;
+
+ if (!INTEGERP (first) || !(NILP (match_lisp) || INTEGERP (match_lisp)))
{
insert_string ("invalid");
return;
}
- code = (enum syntaxcode) (XINT (value) & 0377);
- match = (XINT (value) >> 8) & 0377;
- start1 = (XINT (value) >> 16) & 1;
- start2 = (XINT (value) >> 17) & 1;
- end1 = (XINT (value) >> 18) & 1;
- end2 = (XINT (value) >> 19) & 1;
- prefix = (XINT (value) >> 20) & 1;
+ code = (enum syntaxcode) (first & 0377);
+ start1 = (XINT (first) >> 16) & 1;
+ start2 = (XINT (first) >> 17) & 1;
+ end1 = (XINT (first) >> 18) & 1;
+ end2 = (XINT (first) >> 19) & 1;
+ prefix = (XINT (first) >> 20) & 1;
+ comstyle = (XINT (first) >> 21) & 1;
if ((int) code < 0 || (int) code >= (int) Smax)
{
str[0] = desc, str[1] = 0;
insert (str, 1);
- str[0] = match ? match : ' ';
+ str[0] = !NILP (match_lisp) ? XINT (match_lisp) : ' ';
insert (str, 1);
-
if (start1)
insert ("1", 1);
if (start2)
if (prefix)
insert ("p", 1);
+ if (comstyle)
+ insert ("b", 1);
insert_string ("\twhich means: ");
-#ifdef SWITCH_ENUM_BUG
- switch ((int) code)
-#else
- switch (code)
-#endif
+ switch (SWITCH_ENUM_CAST (code))
{
case Swhitespace:
insert_string ("whitespace"); break;
return;
}
- if (match)
+ if (!NILP (match_lisp))
{
insert_string (", matches ");
-
- str[0] = match, str[1] = 0;
- insert (str, 1);
+ insert_char (XINT (match_lisp));
}
if (start1)
insert_string (",\n\t is the first character of a comment-end sequence");
if (end2)
insert_string (",\n\t is the second character of a comment-end sequence");
+ if (comstyle)
+ insert_string (" (comment style b)");
+
if (prefix)
insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
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);
+ call0 (intern ("help-mode"));
set_buffer_internal (old);
return Qnil;
}
register int beg = BEGV;
register int end = ZV;
register int code;
+ int charcode;
immediate_quit = 1;
QUIT;
immediate_quit = 0;
return 0;
}
- code = SYNTAX (FETCH_CHAR (from));
+ charcode = FETCH_CHAR (from);
+ code = SYNTAX (charcode);
if (words_include_escapes
&& (code == Sescape || code == Scharquote))
break;
while (1)
{
if (from == end) break;
- code = SYNTAX (FETCH_CHAR (from));
+ charcode = FETCH_CHAR (from);
+ code = SYNTAX (charcode);
if (!(words_include_escapes
&& (code == Sescape || code == Scharquote)))
if (code != Sword)
immediate_quit = 0;
return 0;
}
- code = SYNTAX (FETCH_CHAR (from - 1));
+ charcode = FETCH_CHAR (from - 1);
+ code = SYNTAX (charcode);
if (words_include_escapes
&& (code == Sescape || code == Scharquote))
break;
while (1)
{
if (from == beg) break;
- code = SYNTAX (FETCH_CHAR (from - 1));
+ charcode = FETCH_CHAR (from - 1);
+ code = SYNTAX (charcode);
if (!(words_include_escapes
&& (code == Sescape || code == Scharquote)))
if (code != Sword)
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, c1;
+ 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;
+ do
+ {
+ if (from == stop)
+ {
+ SET_PT (from);
+ immediate_quit = 0;
+ return Qnil;
+ }
+ c = FETCH_CHAR (from);
+ code = SYNTAX (c);
+ from++;
+ comstyle = 0;
+ if (from < stop && SYNTAX_COMSTART_FIRST (c)
+ && (c1 = FETCH_CHAR (from),
+ SYNTAX_COMSTART_SECOND (c1)))
+ {
+ /* 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 (c1);
+ from++;
+ }
+ }
+ while (code == Swhitespace || code == Sendcomment);
+ if (code != Scomment)
+ {
+ immediate_quit = 0;
+ SET_PT (from - 1);
+ return Qnil;
+ }
+ /* We're at the start of a comment. */
+ while (1)
+ {
+ if (from == stop)
+ {
+ immediate_quit = 0;
+ SET_PT (from);
+ return Qnil;
+ }
+ c = FETCH_CHAR (from);
+ 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 (from < stop && SYNTAX_COMEND_FIRST (c)
+ && (c1 = FETCH_CHAR (from),
+ SYNTAX_COMEND_SECOND (c1))
+ && 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. */
+ 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 (code == Sendcomment)
+ comstyle = SYNTAX_COMMENT_STYLE (c);
+ if (from > stop && SYNTAX_COMEND_SECOND (c)
+ && (c1 = FETCH_CHAR (from - 1),
+ SYNTAX_COMEND_FIRST (c1))
+ && !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 (c1);
+ 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 ((c = FETCH_CHAR (from),
+ SYNTAX (c) == Scomment)
+ && SYNTAX_COMMENT_STYLE (c) == comstyle)
+ break;
+ if (from == stop)
+ {
+ immediate_quit = 0;
+ SET_PT (from);
+ return Qnil;
+ }
+ from--;
+ if (SYNTAX_COMSTART_SECOND (c)
+ && (c1 = FETCH_CHAR (from),
+ SYNTAX_COMSTART_FIRST (c1))
+ && 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;
+ int scanstart = from - 1;
+
+ /* 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--;
+ c = FETCH_CHAR (from);
+ }
+
+ /* If this char starts a 2-char comment start sequence,
+ treat it like a 1-char comment starter. */
+ if (from < scanstart && SYNTAX_COMSTART_FIRST (c)
+ && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from + 1))
+ && comstyle == SYNTAX_COMMENT_STYLE (FETCH_CHAR (from + 1)))
+ code = Scomment;
+
+ /* 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;
+ }
+ }
+ /* We have skipped one comment. */
+ break;
+ }
+ 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
Lisp_Object val;
register int stop;
register int c;
- char stringterm;
+ unsigned char stringterm;
int quoted;
int mathexit = 0;
register enum syntaxcode code;
int min_depth = depth; /* Err out if depth gets less than this. */
+ int comstyle = 0; /* style of comment encountered */
if (depth > 0) min_depth = 0;
while (from < stop)
{
c = FETCH_CHAR (from);
- code = SYNTAX(c);
+ code = SYNTAX (c);
from++;
if (from < stop && SYNTAX_COMSTART_FIRST (c)
&& SYNTAX_COMSTART_SECOND (FETCH_CHAR (from))
&& parse_sexp_ignore_comments)
- code = Scomment, 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 (SYNTAX_PREFIX (c))
continue;
-#ifdef SWITCH_ENUM_BUG
- switch ((int) code)
-#else
- switch (code)
-#endif
+ switch (SWITCH_ENUM_CAST (code))
{
case Sescape:
case Scharquote:
/* This word counts as a sexp; return at end of it. */
while (from < stop)
{
-#ifdef SWITCH_ENUM_BUG
- switch ((int) SYNTAX(FETCH_CHAR (from)))
-#else
- switch (SYNTAX(FETCH_CHAR (from)))
-#endif
+ switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from))))
{
case Scharquote:
case Sescape:
if (!parse_sexp_ignore_comments) break;
while (1)
{
- if (from == stop) goto done;
- if (SYNTAX (c = FETCH_CHAR (from)) == Sendcomment)
+ if (from == stop)
+ {
+ if (depth == 0)
+ goto done;
+ goto lose;
+ }
+ 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_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; }
}
break;
{
if (from >= stop) goto lose;
if (FETCH_CHAR (from) == stringterm) break;
-#ifdef SWITCH_ENUM_BUG
- switch ((int) SYNTAX(FETCH_CHAR (from)))
-#else
- switch (SYNTAX(FETCH_CHAR (from)))
-#endif
+ switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from))))
{
case Scharquote:
case Sescape:
from--;
c = FETCH_CHAR (from);
code = SYNTAX (c);
+ comstyle = 0;
+ if (code == Sendcomment)
+ comstyle = SYNTAX_COMMENT_STYLE (c);
if (from > stop && SYNTAX_COMEND_SECOND (c)
&& SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1))
&& !char_quoted (from - 1)
&& parse_sexp_ignore_comments)
- code = Sendcomment, from--;
+ {
+ /* 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 (SYNTAX_PREFIX (c))
continue;
-#ifdef SWITCH_ENUM_BUG
- switch ((int) (quoted ? Sword : code))
-#else
- switch (quoted ? Sword : code)
-#endif
+ switch (SWITCH_ENUM_CAST (quoted ? Sword : code))
{
case Sword:
case Ssymbol:
quoted = char_quoted (from - 1);
if (quoted)
from--;
- if (! (quoted || SYNTAX(FETCH_CHAR (from - 1)) == Sword
- || SYNTAX(FETCH_CHAR (from - 1)) == Ssymbol
- || SYNTAX(FETCH_CHAR (from - 1)) == Squote))
+ if (! (quoted || SYNTAX (FETCH_CHAR (from - 1)) == Sword
+ || SYNTAX (FETCH_CHAR (from - 1)) == Ssymbol
+ || SYNTAX (FETCH_CHAR (from - 1)) == Squote))
goto done2;
from--;
}
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)
+ {
+ if (depth == 0)
+ goto done2;
+ goto lose;
+ }
+ 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;
-
- ofrom[0] = ofrom[1] = from;
+ char my_stringend = 0;
+ int string_lossage = 0;
+ int comment_end = from;
+ int comstart_pos = 0;
+ int comstart_parity = 0;
+ int scanstart = from - 1;
/* At beginning of range to scan, we're outside of strings;
that determines quote parity to the comment-end. */
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)))
- code = Scomment, from--;
+ {
+ code = Sendcomment;
+ from--;
+ c = FETCH_CHAR (from);
+ }
+
+ /* If this char starts a 2-char comment start sequence,
+ treat it like a 1-char comment starter. */
+ if (from < scanstart && SYNTAX_COMSTART_FIRST (c)
+ && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from + 1))
+ && comstyle == SYNTAX_COMMENT_STYLE (FETCH_CHAR (from + 1)))
+ code = Scomment;
/* Ignore escaped characters. */
if (char_quoted (from))
continue;
- /* Track parity of quotes between here and comment-end. */
+ /* Track parity of quotes. */
if (code == Sstring)
- parity ^= 1;
+ {
+ 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)
- ofrom[parity] = from;
+ {
+ 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;
- /* If we come to another comment-end,
- assume it's not inside a string.
- That determines the quote parity to the comment-end. */
- if (code == Sendcomment)
+ /* Assume a defun-start point is outside of strings. */
+ if (code == Sopen
+ && (from == stop || FETCH_CHAR (from - 1) == '\n'))
break;
}
- from = ofrom[parity];
+
+ 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;
+ }
}
break;
immediate_quit = 0;
- XFASTINT (val) = from;
+ XSETFASTINT (val, from);
return val;
lose:
/* NOTREACHED */
}
+static int
char_quoted (pos)
register int pos;
{
return Qnil;
}
\f
-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 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. */
- int mindepth; /* Minimum depth seen while scanning. */
- };
-
/* Parse forward from FROM to END,
- assuming that FROM is the start of a function,
- and return a description of the state of the parse at END. */
-
-struct lisp_parse_state val_scan_sexps_forward;
-
-struct lisp_parse_state *
-scan_sexps_forward (from, end, targetdepth, stopbefore, oldstate)
+ 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 COMMENTSTOP is nonzero, stop at the start of a comment. */
+
+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;
immediate_quit = 1;
QUIT;
- if (NULL (oldstate))
+ if (NILP (oldstate))
{
depth = 0;
state.instring = -1;
state.incomment = 0;
+ state.comstyle = 0; /* comment style a by default */
}
else
{
tem = Fcar (oldstate);
- if (!NULL (tem))
+ if (!NILP (tem))
depth = XINT (tem);
else
depth = 0;
oldstate = Fcdr (oldstate);
oldstate = Fcdr (oldstate);
tem = Fcar (oldstate);
- state.instring = !NULL (tem) ? XINT (tem) : -1;
+ state.instring = !NILP (tem) ? XINT (tem) : -1;
oldstate = Fcdr (oldstate);
tem = Fcar (oldstate);
- state.incomment = !NULL (tem);
+ state.incomment = !NILP (tem);
oldstate = Fcdr (oldstate);
tem = Fcar (oldstate);
- start_quoted = !NULL (tem);
+ start_quoted = !NILP (tem);
+
+ /* if the eight 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);
}
state.quoted = 0;
mindepth = depth;
while (from < end)
{
- code = SYNTAX(FETCH_CHAR (from));
+ code = SYNTAX (FETCH_CHAR (from));
from++;
- if (from < end && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from - 1))
- && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from)))
- code = Scomment, 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++;
+ }
+
if (SYNTAX_PREFIX (FETCH_CHAR (from - 1)))
continue;
-#ifdef SWITCH_ENUM_BUG
- switch ((int) code)
-#else
- switch (code)
-#endif
+ switch (SWITCH_ENUM_CAST (code))
{
case Sescape:
case Scharquote:
symstarted:
while (from < end)
{
-#ifdef SWITCH_ENUM_BUG
- switch ((int) SYNTAX(FETCH_CHAR (from)))
-#else
- switch (SYNTAX(FETCH_CHAR (from)))
-#endif
+ switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from))))
{
case Scharquote:
case Sescape:
curlevel->prev = curlevel->last;
break;
+ startincomment:
+ if (commentstop)
+ 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. */
+ prev = FETCH_CHAR (from - 1);
+ goto startincomment_1;
+ }
+ /* At beginning of buffer, enter the loop the ordinary way. */
+
case Scomment:
state.incomment = 1;
- startincomment:
+ if (commentstop)
+ goto done;
while (1)
{
if (from == end) goto done;
- if (SYNTAX (prev = FETCH_CHAR (from)) == Sendcomment)
+ prev = FETCH_CHAR (from);
+ if (SYNTAX (prev) == Sendcomment
+ && SYNTAX_COMMENT_STYLE (prev) == state.comstyle)
+ /* Only terminate the comment section if the endcomment
+ of the same style as the start sequence has been
+ encountered. */
break;
from++;
+ startincomment_1:
if (from < end && SYNTAX_COMEND_FIRST (prev)
- && SYNTAX_COMEND_SECOND (FETCH_CHAR (from)))
+ && SYNTAX_COMEND_SECOND (FETCH_CHAR (from))
+ && SYNTAX_COMMENT_STYLE (prev) == state.comstyle)
+ /* Only terminate the comment section if the end-comment
+ sequence of the same style as the start sequence has
+ been encountered. */
{ from++; break; }
}
state.incomment = 0;
+ state.comstyle = 0; /* reset the comment style */
break;
case Sopen:
error ("Nesting too deep for parser");
curlevel->prev = -1;
curlevel->last = -1;
- if (!--targetdepth) goto done;
+ if (targetdepth == depth) goto done;
break;
case Sclose:
if (curlevel != levelstart)
curlevel--;
curlevel->prev = curlevel->last;
- if (!++targetdepth) goto done;
+ if (targetdepth == depth) goto done;
break;
case Sstring:
{
if (from >= end) goto done;
if (FETCH_CHAR (from) == state.instring) break;
-#ifdef SWITCH_ENUM_BUG
- switch ((int) SYNTAX(FETCH_CHAR (from)))
-#else
- switch (SYNTAX(FETCH_CHAR (from)))
-#endif
+ switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from))))
{
case Scharquote:
case Sescape:
state.location = from;
immediate_quit = 0;
- val_scan_sexps_forward = state;
- return &val_scan_sexps_forward;
+ *stateptr = state;
}
/* This comment supplies the doc string for parse-partial-sexp,
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, 0, 0, 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\
If fifth arg STATE is omitted or nil,\n\
parsing assumes that FROM is the beginning of a function.\n\
-Value is a list of seven elements describing final state of parsing:\n\
- 1. depth in parens.\n\
- 2. character address of start of innermost containing list; nil if none.\n\
- 3. character address of start of last complete sexp terminated.\n\
- 4. non-nil if inside a string.\n\
+Value is a list of eight elements describing final state of parsing:\n\
+ 0. depth in parens.\n\
+ 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\
- 5. t if inside a comment.\n\
- 6. t if following a quote character.\n\
- 7. the minimum paren-depth encountered during this scan.\n\
+ 4. t if inside a comment.\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'.\n\
If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
in parentheses becomes equal to TARGETDEPTH.\n\
Fourth arg STOPBEFORE non-nil means stop when come to\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.")
-
+Fifth arg STATE is an eight-list like what this function returns.\n\
+It is used to initialize the state of the parse. Its second and third
+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;
- if (!NULL (targetdepth))
+ if (!NILP (targetdepth))
{
CHECK_NUMBER (targetdepth, 3);
target = XINT (targetdepth);
target = -100000; /* We won't reach this depth */
validate_region (&from, &to);
- state = *scan_sexps_forward (XINT (from), XINT (to),
- target, !NULL (stopbefore), oldstate);
+ scan_sexps_forward (&state, XINT (from), XINT (to),
+ target, !NILP (stopbefore), oldstate,
+ !NILP (commentstop));
SET_PT (state.location);
Fcons (state.instring >= 0 ? make_number (state.instring) : Qnil,
Fcons (state.incomment ? Qt : Qnil,
Fcons (state.quoted ? Qt : Qnil,
- Fcons (make_number (state.mindepth), Qnil)))))));
+ Fcons (make_number (state.mindepth),
+ Fcons (state.comstyle ? Qt : Qnil,
+ Qnil))))))));
}
\f
init_syntax_once ()
{
register int i;
- register struct Lisp_Vector *v;
+ Lisp_Object temp;
+
+ /* This has to be done here, before we call Fmake_char_table. */
+ Qsyntax_table = intern ("syntax-table");
+ staticpro (&Qsyntax_table);
- /* Set this now, so first buffer creation can refer to it. */
- /* Make it nil before calling copy-syntax-table
- so that copy-syntax-table will know not to try to copy from garbage */
- Vstandard_syntax_table = Qnil;
- Vstandard_syntax_table = Fcopy_syntax_table (Qnil);
+ /* Intern this now in case it isn't already done.
+ Setting this variable twice is harmless.
+ But don't staticpro it here--that is done in alloc.c. */
+ Qchar_table_extra_slots = intern ("char-table-extra-slots");
- v = XVECTOR (Vstandard_syntax_table);
+ /* Now we are ready to set up this property, so we can
+ create syntax tables. */
+ Fput (Qsyntax_table, Qchar_table_extra_slots, make_number (0));
+ temp = Fcons (make_number ((int) Swhitespace), Qnil);
+
+ Vstandard_syntax_table = Fmake_char_table (Qsyntax_table, temp);
+
+ temp = Fcons (make_number ((int) Sword), Qnil);
for (i = 'a'; i <= 'z'; i++)
- XFASTINT (v->contents[i]) = (int) Sword;
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
for (i = 'A'; i <= 'Z'; i++)
- XFASTINT (v->contents[i]) = (int) Sword;
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
for (i = '0'; i <= '9'; i++)
- XFASTINT (v->contents[i]) = (int) Sword;
- XFASTINT (v->contents['$']) = (int) Sword;
- XFASTINT (v->contents['%']) = (int) Sword;
-
- XFASTINT (v->contents['(']) = (int) Sopen + (')' << 8);
- XFASTINT (v->contents[')']) = (int) Sclose + ('(' << 8);
- XFASTINT (v->contents['[']) = (int) Sopen + (']' << 8);
- XFASTINT (v->contents[']']) = (int) Sclose + ('[' << 8);
- XFASTINT (v->contents['{']) = (int) Sopen + ('}' << 8);
- XFASTINT (v->contents['}']) = (int) Sclose + ('{' << 8);
- XFASTINT (v->contents['"']) = (int) Sstring;
- XFASTINT (v->contents['\\']) = (int) Sescape;
-
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
+
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '$', temp);
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '%', temp);
+
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '(',
+ Fcons (make_number (Sopen), make_number (')')));
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, ')',
+ Fcons (make_number (Sclose), make_number ('(')));
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '[',
+ Fcons (make_number (Sopen), make_number (']')));
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, ']',
+ Fcons (make_number (Sclose), make_number ('[')));
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '{',
+ Fcons (make_number (Sopen), make_number ('}')));
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '}',
+ Fcons (make_number (Sclose), make_number ('{')));
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '"',
+ Fcons (make_number ((int) Sstring), Qnil));
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '\\',
+ Fcons (make_number ((int) Sescape), Qnil));
+
+ temp = Fcons (make_number ((int) Ssymbol), Qnil);
for (i = 0; i < 10; i++)
- XFASTINT (v->contents["_-+*/&|<>="[i]]) = (int) Ssymbol;
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, "_-+*/&|<>="[i], temp);
+ temp = Fcons (make_number ((int) Spunct), Qnil);
for (i = 0; i < 12; i++)
- XFASTINT (v->contents[".,;:?!#@~^'`"[i]]) = (int) Spunct;
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, ".,;:?!#@~^'`"[i], temp);
}
syms_of_syntax ()
defsubr (&Scopy_syntax_table);
defsubr (&Sset_syntax_table);
defsubr (&Schar_syntax);
+ defsubr (&Smatching_paren);
defsubr (&Smodify_syntax_entry);
defsubr (&Sdescribe_syntax);
defsubr (&Sforward_word);
+ defsubr (&Sforward_comment);
defsubr (&Sscan_lists);
defsubr (&Sscan_sexps);
defsubr (&Sbackward_prefix_chars);
HCoop / bpt / emacs.git / blobdiff