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 "lisp.h"
#include "commands.h"
#include "buffer.h"
+#include "charset.h"
#include "syntax.h"
+#include "category.h"
-Lisp_Object Qsyntax_table_p;
+Lisp_Object Qsyntax_table_p, Qsyntax_table, Qscan_error;
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
}
\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 (VECTORP (obj) && 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),
- NILP (tem))
- obj = wrong_type_argument (Qsyntax_table_p, obj);
- 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;
- XSETFASTINT (size, 0400);
- XSETFASTINT (val, 0);
- val = Fmake_vector (size, val);
+ Lisp_Object copy;
+
if (!NILP (table))
- table = check_syntax_table (table);
- else if (NILP (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;
+ 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
{
' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@'
};
+
+/* Indexed by syntax code, give the object (cons of syntax code and
+ nil) to be stored in syntax table. Since these objects can be
+ shared among syntax tables, we generate them in advance. By
+ sharing objects, the function `describe-syntax' can give a more
+ compact listing. */
+static Lisp_Object Vsyntax_code_object;
+
\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;
{
- CHECK_NUMBER (ch, 0);
- return make_number (syntax_code_spec[(int) SYNTAX (XINT (ch))]);
+ 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 CHAR, or nil if none.")
- (ch)
- Lisp_Object ch;
+ "Return the matching parenthesis of CHARACTER, or nil if none.")
+ (character)
+ Lisp_Object character;
{
- int code;
- CHECK_NUMBER (ch, 0);
- code = SYNTAX (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 (XINT (ch)));
+ return make_number (SYNTAX_MATCH (char_int));
return Qnil;
}
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\
- 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\
+ 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 C is part of comment sequence b.\n\
+ b means CHAR is part of comment sequence b.\n\
\n\
- p means C is a prefix character for `backward-prefix-chars';\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)
(c, newentry, syntax_table)
Lisp_Object c, newentry, syntax_table;
{
- register unsigned char *p, match;
+ register unsigned char *p;
register enum syntaxcode code;
int val;
+ Lisp_Object match;
CHECK_NUMBER (c, 0);
CHECK_STRING (newentry, 1);
+
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;
+ }
+
+ if (*p)
+ {
+ int len;
+ int character = STRING_CHAR_AND_LENGTH (p, XSTRING (newentry)->size - 1,
+ len);
+ XSETINT (match, character);
+ if (XFASTINT (match) == ' ')
+ match = Qnil;
+ p += len;
+ }
+ else
+ match = Qnil;
- val = (match << 8) + (int) code;
+ val = (int) code;
while (*p)
switch (*p++)
{
break;
}
- XSETFASTINT (XVECTOR (syntax_table)->contents[0xFF & XINT (c)], val);
+ if (val < XVECTOR (Vsyntax_code_object)->size && NILP (match))
+ newentry = XVECTOR (Vsyntax_code_object)->contents[val];
+ else
+ /* Since we can't use a shared object, let's make a new one. */
+ newentry = Fcons (make_number (val), match);
+
+ SET_RAW_SYNTAX_ENTRY (syntax_table, c, newentry);
return Qnil;
}
register enum syntaxcode code;
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 (!INTEGERP (value))
+ if (NILP (value))
{
- insert_string ("invalid");
+ insert_string ("default\n");
+ return;
+ }
+
+ if (CHAR_TABLE_P (value))
+ {
+ insert_string ("deeper char-table ...\n");
+ return;
+ }
+
+ if (!CONSP (value))
+ {
+ insert_string ("invalid\n");
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;
- comstyle = (XINT (value) >> 21) & 1;
+ first = XCONS (value)->car;
+ match_lisp = XCONS (value)->cdr;
+
+ if (!INTEGERP (first) || !(NILP (match_lisp) || INTEGERP (match_lisp)))
+ {
+ insert_string ("invalid\n");
+ return;
+ }
+
+ 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 : ' ';
- insert (str, 1);
-
+ if (NILP (match_lisp))
+ insert (" ", 1);
+ else
+ insert_char (XINT (match_lisp));
if (start1)
insert ("1", 1);
insert_string ("comment"); break;
case Sendcomment:
insert_string ("endcomment"); break;
- case Sinherit:
- insert_string ("inherit"); break;
default:
insert_string ("invalid");
return;
}
- if (match)
+ if (!NILP (match_lisp))
{
insert_string (", matches ");
- insert_char (match);
+ insert_char (XINT (match_lisp));
}
if (start1)
struct buffer *old = current_buffer;
set_buffer_internal (XBUFFER (Vstandard_output));
describe_vector (vector, Qnil, describe_syntax, 0, Qnil, Qnil);
+ while (! NILP (XCHAR_TABLE (vector)->parent))
+ {
+ vector = XCHAR_TABLE (vector)->parent;
+ insert_string ("\nThe parent syntax table is:");
+ 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;
+ register enum syntaxcode code;
+ int ch0, ch1;
+ int temp_pos;
immediate_quit = 1;
QUIT;
immediate_quit = 0;
return 0;
}
- code = SYNTAX (FETCH_CHAR (from));
+ ch0 = FETCH_CHAR (from);
+ code = SYNTAX (ch0);
+ INC_POS (from);
if (words_include_escapes
&& (code == Sescape || code == Scharquote))
break;
if (code == Sword)
break;
- from++;
}
+ /* Now CH0 is a character which begins a word and FROM is the
+ position of the next character. */
while (1)
{
if (from == end) break;
- code = SYNTAX (FETCH_CHAR (from));
+ ch1 = FETCH_CHAR (from);
+ code = SYNTAX (ch1);
if (!(words_include_escapes
&& (code == Sescape || code == Scharquote)))
- if (code != Sword)
+ if (code != Sword || WORD_BOUNDARY_P (ch0, ch1))
break;
- from++;
+ INC_POS (from);
+ ch0 = ch1;
}
count--;
}
immediate_quit = 0;
return 0;
}
- code = SYNTAX (FETCH_CHAR (from - 1));
+ DEC_POS (from);
+ ch1 = FETCH_CHAR (from);
+ code = SYNTAX (ch1);
if (words_include_escapes
&& (code == Sescape || code == Scharquote))
break;
if (code == Sword)
break;
- from--;
}
+ /* Now CH1 is a character which ends a word and FROM is the
+ position of it. */
while (1)
{
if (from == beg) break;
- code = SYNTAX (FETCH_CHAR (from - 1));
+ temp_pos = from;
+ DEC_POS (temp_pos);
+ ch0 = FETCH_CHAR (temp_pos);
+ code = SYNTAX (ch0);
if (!(words_include_escapes
&& (code == Sescape || code == Scharquote)))
- if (code != Sword)
+ if (code != Sword || WORD_BOUNDARY_P (ch0, ch1))
break;
- from--;
+ from = temp_pos;
+ ch1 = ch0;
}
count++;
}
int val;
CHECK_NUMBER (count, 0);
- if (!(val = scan_words (point, XINT (count))))
+ if (!(val = scan_words (PT, XINT (count))))
{
SET_PT (XINT (count) > 0 ? ZV : BEGV);
return Qnil;
{
register int from;
register int stop;
- register int c;
+ register int c, c1;
register enum syntaxcode code;
int comstyle = 0; /* style of comment encountered */
int found;
int count1;
+ int temp_pos;
CHECK_NUMBER (count, 0);
count1 = XINT (count);
}
c = FETCH_CHAR (from);
code = SYNTAX (c);
- from++;
+ INC_POS (from);
comstyle = 0;
if (from < stop && SYNTAX_COMSTART_FIRST (c)
- && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from)))
+ && (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
only a comment end of the same style actually ends
the comment section. */
code = Scomment;
- comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from));
- from++;
+ comstyle = SYNTAX_COMMENT_STYLE (c1);
+ INC_POS (from);
}
}
while (code == Swhitespace || code == Sendcomment);
if (code != Scomment)
{
immediate_quit = 0;
- SET_PT (from - 1);
+ DEC_POS (from);
+ SET_PT (from);
return Qnil;
}
/* We're at the start of a comment. */
return Qnil;
}
c = FETCH_CHAR (from);
- from++;
+ INC_POS (from);
if (SYNTAX (c) == Sendcomment
&& SYNTAX_COMMENT_STYLE (c) == comstyle)
/* we have encountered a comment end of the same style
section */
break;
if (from < stop && SYNTAX_COMEND_FIRST (c)
- && SYNTAX_COMEND_SECOND (FETCH_CHAR (from))
+ && (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; }
+ { INC_POS (from); break; }
}
/* We have skipped one comment. */
count1--;
{
int quoted;
- from--;
+ DEC_POS (from);
quoted = char_quoted (from);
if (quoted)
- from--;
+ DEC_POS (from);
c = FETCH_CHAR (from);
code = SYNTAX (c);
comstyle = 0;
if (code == Sendcomment)
comstyle = SYNTAX_COMMENT_STYLE (c);
+ temp_pos = from;
+ DEC_POS (temp_pos);
if (from > stop && SYNTAX_COMEND_SECOND (c)
- && SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1))
- && !char_quoted (from - 1))
+ && (c1 = FETCH_CHAR (temp_pos),
+ SYNTAX_COMEND_FIRST (c1))
+ && !char_quoted (temp_pos))
{
/* 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--;
+ comstyle = SYNTAX_COMMENT_STYLE (c1);
+ from = temp_pos;
}
if (code == Sendcomment && !quoted)
/* 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--;
+ if (from != stop) DEC_POS (from);
while (1)
{
- if (SYNTAX (c = FETCH_CHAR (from)) == Scomment
+ if ((c = FETCH_CHAR (from),
+ SYNTAX (c) == Scomment)
&& SYNTAX_COMMENT_STYLE (c) == comstyle)
break;
if (from == stop)
SET_PT (from);
return Qnil;
}
- from--;
+ DEC_POS (from);
if (SYNTAX_COMSTART_SECOND (c)
- && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from))
+ && (c1 = FETCH_CHAR (from),
+ SYNTAX_COMSTART_FIRST (c1))
&& SYNTAX_COMMENT_STYLE (c) == comstyle
&& !char_quoted (from))
break;
int comment_end = from;
int comstart_pos = 0;
int comstart_parity = 0;
- int scanstart = from - 1;
+ int scanstart = from;
+ DEC_POS (scanstart);
/* 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--;
+ DEC_POS (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. */
+ temp_pos = from;
+ DEC_POS (temp_pos);
if (from > stop && SYNTAX_COMEND_SECOND (c)
- && SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1)))
+ && (c1 = FETCH_CHAR (temp_pos),
+ SYNTAX_COMEND_FIRST (c1)))
{
code = Sendcomment;
- from--;
- c = FETCH_CHAR (from);
+ from = temp_pos;
+ c = c1;
}
+ temp_pos = from;
+ INC_POS (temp_pos);
/* 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)))
+ && (c1 = FETCH_CHAR (temp_pos),
+ SYNTAX_COMSTART_SECOND (c1))
+ && comstyle == SYNTAX_COMMENT_STYLE (c1))
code = Scomment;
/* Ignore escaped characters. */
/* Assume a defun-start point is outside of strings. */
if (code == Sopen
- && (from == stop || FETCH_CHAR (from - 1) == '\n'))
+ && (from == stop || FETCH_BYTE (from - 1) == '\n'))
break;
}
else if ((code != Swhitespace && code != Scomment) || quoted)
{
immediate_quit = 0;
- SET_PT (from + 1);
+ INC_POS (from);
+ SET_PT (from);
return Qnil;
}
}
{
Lisp_Object val;
register int stop;
- register int c;
- unsigned char stringterm;
+ register int c, c1;
+ int stringterm;
int quoted;
int mathexit = 0;
- register enum syntaxcode code;
+ 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 temp_pos;
+ int last_good = from;
if (depth > 0) min_depth = 0;
{
c = FETCH_CHAR (from);
code = SYNTAX (c);
- from++;
+ if (depth == min_depth)
+ last_good = from;
+ INC_POS (from);
if (from < stop && SYNTAX_COMSTART_FIRST (c)
&& SYNTAX_COMSTART_SECOND (FETCH_CHAR (from))
&& parse_sexp_ignore_comments)
the comment section */
code = Scomment;
comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from));
- from++;
+ INC_POS (from);
}
if (SYNTAX_PREFIX (c))
case Sescape:
case Scharquote:
if (from == stop) goto lose;
- from++;
+ INC_POS (from);
/* treat following character as a word constituent */
case Sword:
case Ssymbol:
{
case Scharquote:
case Sescape:
- from++;
+ INC_POS (from);
if (from == stop) goto lose;
break;
case Sword:
default:
goto done;
}
- from++;
+ INC_POS (from);
}
goto done;
as the comment sequence which began this comment
section */
break;
- from++;
+ INC_POS (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; }
+ { INC_POS (from); break; }
}
break;
if (!sexpflag)
break;
if (from != stop && c == FETCH_CHAR (from))
- from++;
+ INC_POS (from);
if (mathexit)
{
mathexit = 0;
close1:
if (!--depth) goto done;
if (depth < min_depth)
- error ("Containing expression ends prematurely");
+ Fsignal (Qscan_error,
+ Fcons (build_string ("Containing expression ends prematurely"),
+ Fcons (make_number (last_good),
+ Fcons (make_number (from), Qnil))));
break;
case Sstring:
- stringterm = FETCH_CHAR (from - 1);
+ temp_pos = from;
+ DEC_POS (temp_pos);
+ stringterm = FETCH_CHAR (temp_pos);
while (1)
{
if (from >= stop) goto lose;
{
case Scharquote:
case Sescape:
- from++;
+ INC_POS (from);
}
- from++;
+ INC_POS (from);
}
- from++;
+ INC_POS (from);
if (!depth && sexpflag) goto done;
break;
}
stop = BEGV;
while (from > stop)
{
- from--;
+ DEC_POS (from);
if (quoted = char_quoted (from))
- from--;
+ DEC_POS (from);
c = FETCH_CHAR (from);
code = SYNTAX (c);
+ if (depth == min_depth)
+ last_good = from;
comstyle = 0;
if (code == Sendcomment)
comstyle = SYNTAX_COMMENT_STYLE (c);
+ temp_pos = from;
+ DEC_POS (temp_pos);
if (from > stop && SYNTAX_COMEND_SECOND (c)
- && SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1))
- && !char_quoted (from - 1)
+ && (c1 = FETCH_CHAR (temp_pos), SYNTAX_COMEND_FIRST (c1))
+ && !char_quoted (temp_pos)
&& parse_sexp_ignore_comments)
{
/* 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--;
+ comstyle = SYNTAX_COMMENT_STYLE (c1);
+ from = temp_pos;
}
if (SYNTAX_PREFIX (c))
/* This word counts as a sexp; count object finished after passing it. */
while (from > stop)
{
- quoted = char_quoted (from - 1);
+ temp_pos = from;
+ DEC_POS (temp_pos);
+ quoted = char_quoted (temp_pos);
if (quoted)
- from--;
- if (! (quoted || SYNTAX (FETCH_CHAR (from - 1)) == Sword
- || SYNTAX (FETCH_CHAR (from - 1)) == Ssymbol
- || SYNTAX (FETCH_CHAR (from - 1)) == Squote))
+ {
+ from = temp_pos;
+ DEC_POS (temp_pos);
+ }
+ c1 = FETCH_CHAR (temp_pos);
+ temp_code = SYNTAX (c1);
+ if (! (quoted || temp_code == Sword
+ || temp_code == Ssymbol
+ || temp_code == Squote))
goto done2;
- from--;
+ from = temp_pos;
}
goto done2;
case Smath:
if (!sexpflag)
break;
- if (from != stop && c == FETCH_CHAR (from - 1))
- from--;
+ temp_pos = from;
+ DEC_POS (temp_pos);
+ if (from != stop && c == FETCH_CHAR (temp_pos))
+ from = temp_pos;
if (mathexit)
{
mathexit = 0;
open2:
if (!--depth) goto done2;
if (depth < min_depth)
- error ("Containing expression ends prematurely");
+ Fsignal (Qscan_error,
+ Fcons (build_string ("Containing expression ends prematurely"),
+ Fcons (make_number (last_good),
+ Fcons (make_number (from), Qnil))));
break;
case Sendcomment:
/* 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--;
+ if (from != stop) DEC_POS (from);
while (1)
{
if (SYNTAX (c = FETCH_CHAR (from)) == Scomment
goto done2;
goto lose;
}
- from--;
+ DEC_POS (from);
if (SYNTAX_COMSTART_SECOND (c)
&& SYNTAX_COMSTART_FIRST (FETCH_CHAR (from))
&& SYNTAX_COMMENT_STYLE (c) == comstyle
int comment_end = from;
int comstart_pos = 0;
int comstart_parity = 0;
- int scanstart = from - 1;
+ int scanstart = from;
+
+ DEC_POS (scanstart);
/* 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--;
+ DEC_POS (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. */
+ temp_pos = from;
+ DEC_POS (temp_pos);
if (from > stop && SYNTAX_COMEND_SECOND (c)
- && SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1)))
+ && (c1 = FETCH_CHAR (temp_pos),
+ SYNTAX_COMEND_FIRST (c1)))
{
code = Sendcomment;
- from--;
- c = FETCH_CHAR (from);
+ from = temp_pos;
+ c = c1;
}
/* If this char starts a 2-char comment start sequence,
treat it like a 1-char comment starter. */
+ temp_pos = from;
+ INC_POS (temp_pos);
if (from < scanstart && SYNTAX_COMSTART_FIRST (c)
- && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from + 1))
- && comstyle == SYNTAX_COMMENT_STYLE (FETCH_CHAR (from + 1)))
+ && (c1 = FETCH_CHAR (temp_pos),
+ SYNTAX_COMSTART_SECOND (c1))
+ && comstyle == SYNTAX_COMMENT_STYLE (c1))
code = Scomment;
/* Ignore escaped characters. */
/* Assume a defun-start point is outside of strings. */
if (code == Sopen
- && (from == stop || FETCH_CHAR (from - 1) == '\n'))
+ && (from == stop || FETCH_BYTE (from - 1) == '\n'))
break;
}
while (1)
{
if (from == stop) goto lose;
- if (!char_quoted (from - 1)
- && stringterm == FETCH_CHAR (from - 1))
+ temp_pos = from;
+ DEC_POS (temp_pos);
+ if (!char_quoted (temp_pos)
+ && stringterm == FETCH_CHAR (temp_pos))
break;
- from--;
+ from = temp_pos;
}
- from--;
+ DEC_POS (from);
if (!depth && sexpflag) goto done2;
break;
}
return val;
lose:
- error ("Unbalanced parentheses");
+ Fsignal (Qscan_error,
+ Fcons (build_string ("Unbalanced parentheses"),
+ Fcons (make_number (last_good),
+ Fcons (make_number (from), Qnil))));
+
/* NOTREACHED */
}
register enum syntaxcode code;
register int beg = BEGV;
register int quoted = 0;
+ int temp_pos = pos;
+ DEC_POS (temp_pos);
while (pos > beg
- && ((code = SYNTAX (FETCH_CHAR (pos - 1))) == Scharquote
+ && ((code = SYNTAX (FETCH_CHAR (temp_pos))) == Scharquote
|| code == Sescape))
- pos--, quoted = !quoted;
+ {
+ pos = temp_pos;
+ quoted = !quoted;
+ DEC_POS (temp_pos);
+ }
return quoted;
}
()
{
int beg = BEGV;
- int pos = point;
+ int pos = PT;
+ int c;
+ int temp_pos = pos;
+
+ DEC_POS (temp_pos);
- while (pos > beg && !char_quoted (pos - 1)
- && (SYNTAX (FETCH_CHAR (pos - 1)) == Squote
- || SYNTAX_PREFIX (FETCH_CHAR (pos - 1))))
- pos--;
+ while (pos > beg && !char_quoted (temp_pos)
+ && ((c = FETCH_CHAR (temp_pos), SYNTAX (c) == Squote)
+ || SYNTAX_PREFIX (c)))
+ {
+ pos = temp_pos;
+ DEC_POS (temp_pos);
+ }
SET_PT (pos);
struct level levelstart[100];
register struct level *curlevel = levelstart;
struct level *endlevel = levelstart + 100;
- char prev;
+ 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 */
Lisp_Object tem;
+ int prev_from; /* Keep one character before FROM. */
+
+ prev_from = from;
+ DEC_POS (prev_from);
+
+ /* Use this macro instead of `from++'. */
+#define INC_FROM do { prev_from = from; INC_POS (from); } while (0)
immediate_quit = 1;
QUIT;
while (from < end)
{
code = SYNTAX (FETCH_CHAR (from));
- from++;
+ INC_FROM;
if (code == Scomment)
- state.comstart = from-1;
+ state.comstart = prev_from;
- else if (from < end && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from - 1))
+ else if (from < end && SYNTAX_COMSTART_FIRST (FETCH_CHAR (prev_from))
&& SYNTAX_COMSTART_SECOND (FETCH_CHAR (from)))
{
/* Record the comment style we have entered so that only
terminates the comment section. */
code = Scomment;
state.comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from));
- state.comstart = from-1;
- from++;
+ state.comstart = prev_from;
+ INC_FROM;
}
- if (SYNTAX_PREFIX (FETCH_CHAR (from - 1)))
+ if (SYNTAX_PREFIX (FETCH_CHAR (prev_from)))
continue;
switch (SWITCH_ENUM_CAST (code))
{
case Sescape:
case Scharquote:
if (stopbefore) goto stop; /* this arg means stop at sexp start */
- curlevel->last = from - 1;
+ curlevel->last = prev_from;
startquoted:
if (from == end) goto endquoted;
- from++;
+ INC_FROM;
goto symstarted;
/* treat following character as a word constituent */
case Sword:
case Ssymbol:
if (stopbefore) goto stop; /* this arg means stop at sexp start */
- curlevel->last = from - 1;
+ curlevel->last = prev_from;
symstarted:
while (from < end)
{
{
case Scharquote:
case Sescape:
- from++;
+ INC_FROM;
if (from == end) goto endquoted;
break;
case Sword:
default:
goto symdone;
}
- from++;
+ INC_FROM;
}
symdone:
curlevel->prev = curlevel->last;
{
/* 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);
+ prev = FETCH_CHAR (prev_from);
goto startincomment_1;
}
/* At beginning of buffer, enter the loop the ordinary way. */
of the same style as the start sequence has been
encountered. */
break;
- from++;
+ INC_FROM;
startincomment_1:
if (from < end && SYNTAX_COMEND_FIRST (prev)
&& SYNTAX_COMEND_SECOND (FETCH_CHAR (from))
/* Only terminate the comment section if the end-comment
sequence of the same style as the start sequence has
been encountered. */
- { from++; break; }
+ { INC_FROM; break; }
}
state.incomment = 0;
state.comstyle = 0; /* reset the comment style */
if (stopbefore) goto stop; /* this arg means stop at sexp start */
depth++;
/* curlevel++->last ran into compiler bug on Apollo */
- curlevel->last = from - 1;
+ curlevel->last = prev_from;
if (++curlevel == endlevel)
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 (stopbefore) goto stop; /* this arg means stop at sexp start */
- curlevel->last = from - 1;
- state.instring = FETCH_CHAR (from - 1);
+ curlevel->last = prev_from;
+ state.instring = FETCH_CHAR (prev_from);
startinstring:
while (1)
{
+ int c;
+
if (from >= end) goto done;
- if (FETCH_CHAR (from) == state.instring) break;
- switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from))))
+ c = FETCH_CHAR (from);
+ if (c == state.instring) break;
+ switch (SWITCH_ENUM_CAST (SYNTAX (c)))
{
case Scharquote:
case Sescape:
- from++;
+ INC_FROM;
startquotedinstring:
if (from >= end) goto endquoted;
}
- from++;
+ INC_FROM;
}
state.instring = -1;
curlevel->prev = curlevel->last;
- from++;
+ INC_FROM;
break;
case Smath:
goto done;
stop: /* Here if stopping before start of sexp. */
- from--; /* We have just fetched the char that starts it; */
+ from = prev_from; /* We have just fetched the char that starts it; */
goto done; /* but return the position before it. */
endquoted:
\f
init_syntax_once ()
{
- register int i;
- register struct Lisp_Vector *v;
+ register int i, c;
+ 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);
+ /* Create objects which can be shared among syntax tables. */
+ Vsyntax_code_object = Fmake_vector (13, Qnil);
+ for (i = 0; i < XVECTOR (Vsyntax_code_object)->size; i++)
+ XVECTOR (Vsyntax_code_object)->contents[i]
+ = Fcons (make_number (i), Qnil);
+ /* 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 = XVECTOR (Vsyntax_code_object)->contents[(int) Swhitespace];
+
+ Vstandard_syntax_table = Fmake_char_table (Qsyntax_table, temp);
+
+ temp = XVECTOR (Vsyntax_code_object)->contents[(int) Sword];
for (i = 'a'; i <= 'z'; i++)
- XSETFASTINT (v->contents[i], (int) Sword);
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
for (i = 'A'; i <= 'Z'; i++)
- XSETFASTINT (v->contents[i], (int) Sword);
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
for (i = '0'; i <= '9'; i++)
- XSETFASTINT (v->contents[i], (int) Sword);
- XSETFASTINT (v->contents['$'], (int) Sword);
- XSETFASTINT (v->contents['%'], (int) Sword);
-
- XSETFASTINT (v->contents['('], (int) Sopen + (')' << 8));
- XSETFASTINT (v->contents[')'], (int) Sclose + ('(' << 8));
- XSETFASTINT (v->contents['['], (int) Sopen + (']' << 8));
- XSETFASTINT (v->contents[']'], (int) Sclose + ('[' << 8));
- XSETFASTINT (v->contents['{'], (int) Sopen + ('}' << 8));
- XSETFASTINT (v->contents['}'], (int) Sclose + ('{' << 8));
- XSETFASTINT (v->contents['"'], (int) Sstring);
- XSETFASTINT (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 = XVECTOR (Vsyntax_code_object)->contents[(int) Ssymbol];
for (i = 0; i < 10; i++)
- XSETFASTINT (v->contents["_-+*/&|<>="[i]], (int) Ssymbol);
+ {
+ c = "_-+*/&|<>="[i];
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, c, temp);
+ }
+ temp = XVECTOR (Vsyntax_code_object)->contents[(int) Spunct];
for (i = 0; i < 12; i++)
- XSETFASTINT (v->contents[".,;:?!#@~^'`"[i]], (int) Spunct);
+ {
+ c = ".,;:?!#@~^'`"[i];
+ SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, c, temp);
+ }
}
syms_of_syntax ()
Qsyntax_table_p = intern ("syntax-table-p");
staticpro (&Qsyntax_table_p);
+ staticpro (&Vsyntax_code_object);
+
+ Qscan_error = intern ("scan-error");
+ staticpro (&Qscan_error);
+ Fput (Qscan_error, Qerror_conditions,
+ Fcons (Qerror, Qnil));
+ Fput (Qscan_error, Qerror_message,
+ build_string ("Scan error"));
+
DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments,
"Non-nil means `forward-sexp', etc., should treat comments as whitespace.");