/* XEmacs routines to deal with syntax tables; also word and list parsing.
Copyright (C) 1985-1994 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
+ Copyright (C) 2001 MORIOKA Tomohiko
This file is part of XEmacs.
and the like. */
struct buffer *regex_emacs_buffer;
+/* Tell the regex routines whether buffer is used or not. */
+int regex_emacs_buffer_p;
+
Lisp_Object Vstandard_syntax_table;
Lisp_Object Vsyntax_designator_chars_string;
find_defun_start (struct buffer *buf, Bufpos pos)
{
Bufpos tem;
- struct Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
/* Use previous finding, if it's valid and applies to this inquiry. */
if (buf == find_start_buffer
}
\f
DEFUN ("syntax-table-p", Fsyntax_table_p, 1, 1, 0, /*
-Return t if ARG is a syntax table.
+Return t if OBJECT is a syntax table.
Any vector of 256 elements will do.
*/
- (obj))
+ (object))
{
- return CHAR_TABLEP (obj) && XCHAR_TABLE_TYPE (obj) == CHAR_TABLE_TYPE_SYNTAX
+ return (CHAR_TABLEP (object)
+ && XCHAR_TABLE_TYPE (object) == CHAR_TABLE_TYPE_SYNTAX)
? Qt : Qnil;
}
}
DEFUN ("copy-syntax-table", Fcopy_syntax_table, 0, 1, 0, /*
-Construct a new syntax table and return it.
-It is a copy of the TABLE, which defaults to the standard syntax table.
+Return a new syntax table which is a copy of SYNTAX-TABLE.
+SYNTAX-TABLE defaults to the standard syntax table.
*/
- (table))
+ (syntax_table))
{
if (NILP (Vstandard_syntax_table))
return Fmake_char_table (Qsyntax);
- table = check_syntax_table (table, Vstandard_syntax_table);
- return Fcopy_char_table (table);
+ syntax_table = check_syntax_table (syntax_table, Vstandard_syntax_table);
+ return Fcopy_char_table (syntax_table);
}
DEFUN ("set-syntax-table", Fset_syntax_table, 1, 2, 0, /*
-Select a new syntax table for BUFFER.
-One argument, a syntax table.
+Select SYNTAX-TABLE as the new syntax table for BUFFER.
BUFFER defaults to the current buffer if omitted.
*/
- (table, buffer))
+ (syntax_table, buffer))
{
struct buffer *buf = decode_buffer (buffer, 0);
- table = check_syntax_table (table, Qnil);
- buf->syntax_table = table;
- buf->mirror_syntax_table = XCHAR_TABLE (table)->mirror_table;
+ syntax_table = check_syntax_table (syntax_table, Qnil);
+ buf->syntax_table = syntax_table;
+#ifndef UTF2000
+ buf->mirror_syntax_table = XCHAR_TABLE (syntax_table)->mirror_table;
+#endif
/* Indicate that this buffer now has a specified syntax table. */
buf->local_var_flags |= XINT (buffer_local_flags.syntax_table);
- return table;
+ return syntax_table;
}
\f
/* Convert a letter which signifies a syntax code
into the code it signifies.
This is used by modify-syntax-entry, and other things. */
-CONST unsigned char syntax_spec_code[0400] =
+const unsigned char syntax_spec_code[0400] =
{ 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377
};
-CONST unsigned char syntax_code_spec[] = " .w_()'\"$\\/<>@";
+const unsigned char syntax_code_spec[] = " .w_()'\"$\\/<>@";
DEFUN ("syntax-designator-chars", Fsyntax_designator_chars, 0, 0, 0, /*
Return a string of the recognized syntax designator chars.
}
DEFUN ("char-syntax", Fchar_syntax, 1, 2, 0, /*
-Return the syntax code of CHAR, described by a character.
-For example, if CHAR is a word constituent, the character `?w' is returned.
+Return the syntax code of CHARACTER, described by a character.
+For example, if CHARACTER is a word constituent,
+the character `?w' is returned.
The characters that correspond to various syntax codes
are listed in the documentation of `modify-syntax-entry'.
-Optional second argument TABLE defaults to the current buffer's
+Optional second argument SYNTAX-TABLE defaults to the current buffer's
syntax table.
*/
- (ch, table))
+ (character, syntax_table))
{
- struct Lisp_Char_Table *mirrortab;
+#ifndef UTF2000
+ Lisp_Char_Table *mirrortab;
+#endif
- if (NILP(ch))
+ if (NILP (character))
{
- ch = make_char('\000');
+ character = make_char ('\000');
}
- CHECK_CHAR_COERCE_INT (ch);
- table = check_syntax_table (table, current_buffer->syntax_table);
- mirrortab = XCHAR_TABLE (XCHAR_TABLE (table)->mirror_table);
- return make_char (syntax_code_spec[(int) SYNTAX (mirrortab, XCHAR (ch))]);
+ CHECK_CHAR_COERCE_INT (character);
+ syntax_table = check_syntax_table (syntax_table, current_buffer->syntax_table);
+#ifdef UTF2000
+ return make_char (syntax_code_spec[(int) SYNTAX (XCHAR_TABLE(syntax_table),
+ XCHAR (character))]);
+#else
+ mirrortab = XCHAR_TABLE (XCHAR_TABLE (syntax_table)->mirror_table);
+ return make_char (syntax_code_spec[(int) SYNTAX (mirrortab, XCHAR (character))]);
+#endif
}
#ifdef MULE
#endif
Lisp_Object
-syntax_match (Lisp_Object table, Emchar ch)
+syntax_match (Lisp_Object syntax_table, Emchar ch)
{
- Lisp_Object code = CHAR_TABLE_VALUE_UNSAFE (XCHAR_TABLE (table), ch);
+ Lisp_Object code = XCHAR_TABLE_VALUE_UNSAFE (syntax_table, ch);
Lisp_Object code2 = code;
if (CONSP (code))
code2 = XCAR (code);
if (SYNTAX_FROM_CODE (XINT (code2)) == Sinherit)
- code = CHAR_TABLE_VALUE_UNSAFE (XCHAR_TABLE (Vstandard_syntax_table),
- ch);
+ code = XCHAR_TABLE_VALUE_UNSAFE (Vstandard_syntax_table, ch);
return CONSP (code) ? XCDR (code) : Qnil;
}
DEFUN ("matching-paren", Fmatching_paren, 1, 2, 0, /*
-Return the matching parenthesis of CHAR, or nil if none.
-Optional second argument TABLE defaults to the current buffer's
+Return the matching parenthesis of CHARACTER, or nil if none.
+Optional second argument SYNTAX-TABLE defaults to the current buffer's
syntax table.
*/
- (ch, table))
+ (character, syntax_table))
{
- struct Lisp_Char_Table *mirrortab;
+#ifndef UTF2000
+ Lisp_Char_Table *mirrortab;
+#endif
int code;
- CHECK_CHAR_COERCE_INT (ch);
- table = check_syntax_table (table, current_buffer->syntax_table);
- mirrortab = XCHAR_TABLE (XCHAR_TABLE (table)->mirror_table);
- code = SYNTAX (mirrortab, XCHAR (ch));
+ CHECK_CHAR_COERCE_INT (character);
+ syntax_table = check_syntax_table (syntax_table, current_buffer->syntax_table);
+#ifdef UTF2000
+ code = SYNTAX (XCHAR_TABLE (syntax_table), XCHAR (character));
+#else
+ mirrortab = XCHAR_TABLE (XCHAR_TABLE (syntax_table)->mirror_table);
+ code = SYNTAX (mirrortab, XCHAR (character));
+#endif
if (code == Sopen || code == Sclose || code == Sstring)
- return syntax_match (table, XCHAR (ch));
+ return syntax_match (syntax_table, XCHAR (character));
return Qnil;
}
scan_words (struct buffer *buf, Bufpos from, int count)
{
Bufpos limit = count > 0 ? BUF_ZV (buf) : BUF_BEGV (buf);
- struct Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
Emchar ch0, ch1;
enum syntaxcode code;
ch0 = BUF_FETCH_CHAR (buf, from);
code = SYNTAX_UNSAFE (mirrortab, ch0);
+ from++;
if (words_include_escapes
&& (code == Sescape || code == Scharquote))
break;
if (code == Sword)
break;
-
- from++;
}
QUIT;
if (code != Sword
#ifdef MULE
|| WORD_BOUNDARY_P (ch0, ch1)
-#endif
+#endif
)
break;
#ifdef MULE
ch0 = ch1;
-#endif
+#endif
from++;
}
count--;
ch1 = BUF_FETCH_CHAR (buf, from - 1);
code = SYNTAX_UNSAFE (mirrortab, ch1);
+
+ from--;
if (words_include_escapes
&& (code == Sescape || code == Scharquote))
break;
if (code == Sword)
break;
-
- from--;
}
QUIT;
return from;
}
-DEFUN ("forward-word", Fforward_word, 1, 2, "_p", /*
+DEFUN ("forward-word", Fforward_word, 0, 2, "_p", /*
Move point forward COUNT words (backward if COUNT is negative).
-Normally returns t.
-If an edge of the buffer is reached, point is left there
-and nil is returned.
+Normally t is returned, but if an edge of the buffer is reached,
+point is left there and nil is returned.
-Optional argument BUFFER defaults to the current buffer.
+COUNT defaults to 1, and BUFFER defaults to the current buffer.
*/
(count, buffer))
{
Bufpos val;
struct buffer *buf = decode_buffer (buffer, 0);
- CHECK_INT (count);
+ EMACS_INT n;
+
+ if (NILP (count))
+ n = 1;
+ else
+ {
+ CHECK_INT (count);
+ n = XINT (count);
+ }
- if (!(val = scan_words (buf, BUF_PT (buf), XINT (count))))
+ val = scan_words (buf, BUF_PT (buf), n);
+ if (val)
{
- BUF_SET_PT (buf, XINT (count) > 0 ? BUF_ZV (buf) : BUF_BEGV (buf));
+ BUF_SET_PT (buf, val);
+ return Qt;
+ }
+ else
+ {
+ BUF_SET_PT (buf, n > 0 ? BUF_ZV (buf) : BUF_BEGV (buf));
return Qnil;
}
- BUF_SET_PT (buf, val);
- return Qt;
}
\f
static void scan_sexps_forward (struct buffer *buf,
{
Emchar c;
enum syntaxcode code;
- struct Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
/* Look back, counting the parity of string-quotes,
and recording the comment-starters seen.
find_end_of_comment (struct buffer *buf, Bufpos from, Bufpos stop, int mask)
{
int c;
- struct Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
while (1)
{
ever complains about this function not working properly, take a look
at those changes. --ben */
-DEFUN ("forward-comment", Fforward_comment, 1, 2, 0, /*
-Move forward across up to N comments. If N is negative, move backward.
+DEFUN ("forward-comment", Fforward_comment, 0, 2, 0, /*
+Move forward across up to COUNT comments, or backwards if COUNT is negative.
Stop scanning if we find something other than a comment or whitespace.
Set point to where scanning stops.
-If N comments are found as expected, with nothing except whitespace
+If COUNT comments are found as expected, with nothing except whitespace
between them, return t; otherwise return nil.
Point is set in either case.
-Optional argument BUFFER defaults to the current buffer.
+COUNT defaults to 1, and BUFFER defaults to the current buffer.
*/
- (n, buffer))
+ (count, buffer))
{
Bufpos from;
Bufpos stop;
Emchar c;
enum syntaxcode code;
- EMACS_INT count;
+ EMACS_INT n;
struct buffer *buf = decode_buffer (buffer, 0);
- struct Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
- CHECK_INT (n);
- count = XINT (n);
+ if (NILP (count))
+ n = 1;
+ else
+ {
+ CHECK_INT (count);
+ n = XINT (count);
+ }
from = BUF_PT (buf);
- while (count > 0)
+ while (n > 0)
{
QUIT;
}
/* End of comment reached */
- count--;
+ n--;
}
- while (count < 0)
+ while (n < 0)
{
QUIT;
}
}
- count++;
+ n++;
}
BUF_SET_PT (buf, from);
\f
Lisp_Object
scan_lists (struct buffer *buf, Bufpos from, int count, int depth,
- int sexpflag, int no_error)
+ int sexpflag, int noerror)
{
Bufpos stop;
Emchar c;
enum syntaxcode code;
int min_depth = depth; /* Err out if depth gets less than this. */
Lisp_Object syntaxtab = buf->syntax_table;
- struct Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
if (depth > 0) min_depth = 0;
if (!--depth) goto done;
if (depth < min_depth)
{
- if (no_error)
+ if (noerror)
return Qnil;
error ("Containing expression ends prematurely");
}
if (SYNTAX_PREFIX_UNSAFE (mirrortab, c))
continue;
- switch (((quoted) ? Sword : code))
+ switch (quoted ? Sword : code)
{
case Sword:
case Ssymbol:
if (!--depth) goto done2;
if (depth < min_depth)
{
- if (no_error)
+ if (noerror)
return Qnil;
error ("Containing expression ends prematurely");
}
return (make_int (from));
lose:
- if (!no_error)
+ if (!noerror)
error ("Unbalanced parentheses");
return Qnil;
}
enum syntaxcode code;
Bufpos beg = BUF_BEGV (buf);
int quoted = 0;
- struct Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
while (pos > beg
&& ((code = SYNTAX (mirrortab, BUF_FETCH_CHAR (buf, pos - 1)))
If optional arg NOERROR is non-nil, scan-lists will return nil instead of
signalling an error.
*/
- (from, count, depth, buffer, no_error))
+ (from, count, depth, buffer, noerror))
{
struct buffer *buf;
buf = decode_buffer (buffer, 0);
return scan_lists (buf, XINT (from), XINT (count), XINT (depth), 0,
- !NILP (no_error));
+ !NILP (noerror));
}
DEFUN ("scan-sexps", Fscan_sexps, 2, 4, 0, /*
If optional arg NOERROR is non-nil, scan-sexps will return nil instead of
signalling an error.
*/
- (from, count, buffer, no_error))
+ (from, count, buffer, noerror))
{
struct buffer *buf = decode_buffer (buffer, 0);
CHECK_INT (from);
CHECK_INT (count);
- return scan_lists (buf, XINT (from), XINT (count), 0, 1, !NILP (no_error));
+ return scan_lists (buf, XINT (from), XINT (count), 0, 1, !NILP (noerror));
}
DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, 0, 1, 0, /*
struct buffer *buf = decode_buffer (buffer, 0);
Bufpos beg = BUF_BEGV (buf);
Bufpos pos = BUF_PT (buf);
- struct Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
while (pos > beg && !char_quoted (buf, pos - 1)
&& (SYNTAX (mirrortab, BUF_FETCH_CHAR (buf, pos - 1)) == Squote
Lisp_Object tem;
int mask; /* comment mask */
Lisp_Object syntaxtab = buf->syntax_table;
- struct Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
if (NILP (oldstate))
{
Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
Parsing stops at TO or when certain criteria are met;
point is set to where parsing stops.
-If fifth arg STATE is omitted or nil,
+If fifth arg OLDSTATE is omitted or nil,
parsing assumes that FROM is the beginning of a function.
Value is a list of eight elements describing final state of parsing:
0. depth in parens.
in parentheses becomes equal to TARGETDEPTH.
Fourth arg STOPBEFORE non-nil means stop when come to
any character that starts a sexp.
-Fifth arg STATE is an eight-element list like what this function returns.
+Fifth arg OLDSTATE is an eight-element list like what this function returns.
It is used to initialize the state of the parse. Its second and third
elements are ignored.
Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
return 0;
}
+#ifndef UTF2000
static void
-update_just_this_syntax_table (struct Lisp_Char_Table *ct)
+update_just_this_syntax_table (Lisp_Char_Table *ct)
{
struct chartab_range range;
struct cmst_arg arg;
one. */
void
-update_syntax_table (struct Lisp_Char_Table *ct)
+update_syntax_table (Lisp_Char_Table *ct)
{
/* Don't be stymied at startup. */
if (CHAR_TABLEP (Vstandard_syntax_table)
else
update_just_this_syntax_table (ct);
}
+#endif
\f
/************************************************************************/
DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments /*
Non-nil means `forward-sexp', etc., should treat comments as whitespace.
*/ );
+ parse_sexp_ignore_comments = 0;
- words_include_escapes = 0;
DEFVAR_BOOL ("words-include-escapes", &words_include_escapes /*
Non-nil means `forward-word', etc., should treat escape chars part of words.
*/ );
+ words_include_escapes = 0;
no_quit_in_re_search = 0;
}
static void
-define_standard_syntax (CONST char *p, enum syntaxcode syn)
+define_standard_syntax (const char *p, enum syntaxcode syn)
{
for (; *p; p++)
Fput_char_table (make_char (*p), make_int (syn), Vstandard_syntax_table);
complex_vars_of_syntax (void)
{
Emchar i;
- CONST char *p;
+ const char *p;
/* 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 */
projects / chise / xemacs-chise.git / blobdiff