X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fsyntax.c;h=6b580a0f4e02bf7d24ad34c82dc52abaa5645764;hb=ac155f65fdad732a944b5217c90d8340818e0c0a;hp=2e0dde9f9e9b5aeb68fc70b1738e65daacc5db1b;hpb=afa9772e3fcbb4e80e3e4cfd1a40b4fccc6d08b8;p=chise%2Fxemacs-chise.git- diff --git a/src/syntax.c b/src/syntax.c index 2e0dde9..6b580a0 100644 --- a/src/syntax.c +++ b/src/syntax.c @@ -1,6 +1,7 @@ /* 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. @@ -74,6 +75,9 @@ int no_quit_in_re_search; 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; @@ -117,7 +121,11 @@ static Bufpos 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 @@ -153,12 +161,13 @@ find_defun_start (struct buffer *buf, Bufpos pos) } 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; } @@ -192,39 +201,40 @@ This is the one used for new buffers. } 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; } /* 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, @@ -246,7 +256,7 @@ CONST unsigned char syntax_spec_code[0400] = 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. @@ -259,25 +269,33 @@ numbered starting at 0. } 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 @@ -293,36 +311,41 @@ charset_syntax (struct buffer *buf, Lisp_Object charset, int *multi_p_out) #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; } @@ -348,7 +371,11 @@ Bufpos 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; @@ -365,13 +392,12 @@ scan_words (struct buffer *buf, Bufpos from, int count) 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; @@ -385,12 +411,12 @@ scan_words (struct buffer *buf, Bufpos from, int count) if (code != Sword #ifdef MULE || WORD_BOUNDARY_P (ch0, ch1) -#endif +#endif ) break; #ifdef MULE ch0 = ch1; -#endif +#endif from++; } count--; @@ -407,13 +433,13 @@ scan_words (struct buffer *buf, Bufpos from, int 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; @@ -441,27 +467,38 @@ scan_words (struct buffer *buf, Bufpos from, int count) 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; } static void scan_sexps_forward (struct buffer *buf, @@ -476,7 +513,11 @@ find_start_of_comment (struct buffer *buf, Bufpos from, Bufpos stop, int mask) { 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. @@ -610,7 +651,11 @@ static Bufpos 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) { @@ -646,31 +691,40 @@ find_end_of_comment (struct buffer *buf, Bufpos from, Bufpos stop, int mask) 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; @@ -739,10 +793,10 @@ Optional argument BUFFER defaults to the current buffer. } /* End of comment reached */ - count--; + n--; } - while (count < 0) + while (n < 0) { QUIT; @@ -798,7 +852,7 @@ Optional argument BUFFER defaults to the current buffer. } } - count++; + n++; } BUF_SET_PT (buf, from); @@ -808,7 +862,7 @@ Optional argument BUFFER defaults to the current buffer. 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; @@ -817,7 +871,11 @@ scan_lists (struct buffer *buf, Bufpos from, int count, int depth, 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; @@ -928,7 +986,7 @@ scan_lists (struct buffer *buf, Bufpos from, int count, int depth, if (!--depth) goto done; if (depth < min_depth) { - if (no_error) + if (noerror) return Qnil; error ("Containing expression ends prematurely"); } @@ -1027,7 +1085,7 @@ scan_lists (struct buffer *buf, Bufpos from, int count, int depth, if (SYNTAX_PREFIX_UNSAFE (mirrortab, c)) continue; - switch (((quoted) ? Sword : code)) + switch (quoted ? Sword : code) { case Sword: case Ssymbol: @@ -1073,7 +1131,7 @@ scan_lists (struct buffer *buf, Bufpos from, int count, int depth, if (!--depth) goto done2; if (depth < min_depth) { - if (no_error) + if (noerror) return Qnil; error ("Containing expression ends prematurely"); } @@ -1125,7 +1183,7 @@ scan_lists (struct buffer *buf, Bufpos from, int count, int depth, return (make_int (from)); lose: - if (!no_error) + if (!noerror) error ("Unbalanced parentheses"); return Qnil; } @@ -1136,7 +1194,11 @@ char_quoted (struct buffer *buf, Bufpos pos) 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))) @@ -1167,7 +1229,7 @@ of in the current buffer. 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; @@ -1177,7 +1239,7 @@ signalling an error. 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, /* @@ -1198,13 +1260,13 @@ of in the current buffer. 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, /* @@ -1218,7 +1280,11 @@ Optional arg BUFFER defaults to the current buffer. 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 @@ -1258,7 +1324,11 @@ scan_sexps_forward (struct buffer *buf, struct lisp_parse_state *stateptr, 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)) { @@ -1507,7 +1577,7 @@ DEFUN ("parse-partial-sexp", Fparse_partial_sexp, 2, 7, 0, /* 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. @@ -1523,7 +1593,7 @@ If third arg TARGETDEPTH is non-nil, parsing stops if the depth 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. @@ -1610,8 +1680,9 @@ cmst_mapfun (struct chartab_range *range, Lisp_Object val, void *arg) 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; @@ -1629,7 +1700,7 @@ update_just_this_syntax_table (struct Lisp_Char_Table *ct) 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) @@ -1644,6 +1715,7 @@ update_syntax_table (struct Lisp_Char_Table *ct) else update_just_this_syntax_table (ct); } +#endif /************************************************************************/ @@ -1681,17 +1753,18 @@ vars_of_syntax (void) 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); @@ -1701,7 +1774,7 @@ void 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 */