1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 1987, 1993 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
28 Lisp_Object Qsyntax_table_p
;
30 int words_include_escapes
;
32 /* This is the internal form of the parse state used in parse-partial-sexp. */
34 struct lisp_parse_state
36 int depth
; /* Depth at end of parsing */
37 int instring
; /* -1 if not within string, else desired terminator. */
38 int incomment
; /* Nonzero if within a comment at end of parsing */
39 int comstyle
; /* comment style a=0, or b=1 */
40 int quoted
; /* Nonzero if just after an escape char at end of parsing */
41 int thislevelstart
; /* Char number of most recent start-of-expression at current level */
42 int prevlevelstart
; /* Char number of start of containing expression */
43 int location
; /* Char number at which parsing stopped. */
44 int mindepth
; /* Minimum depth seen while scanning. */
45 int comstart
; /* Position just after last comment starter. */
48 /* These variables are a cache for finding the start of a defun.
49 find_start_pos is the place for which the defun start was found.
50 find_start_value is the defun start position found for it.
51 find_start_buffer is the buffer it was found in.
52 find_start_begv is the BEGV value when it was found.
53 find_start_modiff is the value of MODIFF when it was found. */
55 static int find_start_pos
;
56 static int find_start_value
;
57 static struct buffer
*find_start_buffer
;
58 static int find_start_begv
;
59 static int find_start_modiff
;
61 /* Find a defun-start that is the last one before POS (or nearly the last).
62 We record what we find, so that another call in the same area
63 can return the same value right away. */
66 find_defun_start (pos
)
72 /* Use previous finding, if it's valid and applies to this inquiry. */
73 if (current_buffer
== find_start_buffer
74 /* Reuse the defun-start even if POS is a little farther on.
75 POS might be in the next defun, but that's ok.
76 Our value may not be the best possible, but will still be usable. */
77 && pos
<= find_start_pos
+ 1000
78 && pos
>= find_start_value
79 && BEGV
== find_start_begv
80 && MODIFF
== find_start_modiff
)
81 return find_start_value
;
83 /* Back up to start of line. */
84 tem
= scan_buffer ('\n', pos
, -1, &shortage
);
88 /* Open-paren at start of line means we found our defun-start. */
89 if (SYNTAX (FETCH_CHAR (tem
)) == Sopen
)
91 /* Move to beg of previous line. */
92 tem
= scan_buffer ('\n', tem
, -2, &shortage
);
95 /* Record what we found, for the next try. */
96 find_start_value
= tem
;
97 find_start_buffer
= current_buffer
;
98 find_start_modiff
= MODIFF
;
99 find_start_begv
= BEGV
;
100 find_start_pos
= pos
;
102 return find_start_value
;
105 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
106 "Return t if ARG is a syntax table.\n\
107 Any vector of 256 elements will do.")
111 if (XTYPE (obj
) == Lisp_Vector
&& XVECTOR (obj
)->size
== 0400)
117 check_syntax_table (obj
)
120 register Lisp_Object tem
;
121 while (tem
= Fsyntax_table_p (obj
),
123 obj
= wrong_type_argument (Qsyntax_table_p
, obj
);
128 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
129 "Return the current syntax table.\n\
130 This is the one specified by the current buffer.")
133 return current_buffer
->syntax_table
;
136 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
137 Sstandard_syntax_table
, 0, 0, 0,
138 "Return the standard syntax table.\n\
139 This is the one used for new buffers.")
142 return Vstandard_syntax_table
;
145 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
146 "Construct a new syntax table and return it.\n\
147 It is a copy of the TABLE, which defaults to the standard syntax table.")
151 Lisp_Object size
, val
;
152 XFASTINT (size
) = 0400;
154 val
= Fmake_vector (size
, val
);
156 table
= check_syntax_table (table
);
157 else if (NILP (Vstandard_syntax_table
))
158 /* Can only be null during initialization */
160 else table
= Vstandard_syntax_table
;
162 bcopy (XVECTOR (table
)->contents
,
163 XVECTOR (val
)->contents
, 0400 * sizeof (Lisp_Object
));
167 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
168 "Select a new syntax table for the current buffer.\n\
169 One argument, a syntax table.")
173 table
= check_syntax_table (table
);
174 current_buffer
->syntax_table
= table
;
175 /* Indicate that this buffer now has a specified syntax table. */
176 current_buffer
->local_var_flags
|= buffer_local_flags
.syntax_table
;
180 /* Convert a letter which signifies a syntax code
181 into the code it signifies.
182 This is used by modify-syntax-entry, and other things. */
184 unsigned char syntax_spec_code
[0400] =
185 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
186 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
187 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
188 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
189 (char) Swhitespace
, 0377, (char) Sstring
, 0377,
190 (char) Smath
, 0377, 0377, (char) Squote
,
191 (char) Sopen
, (char) Sclose
, 0377, 0377,
192 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
193 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
194 0377, 0377, 0377, 0377,
195 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
196 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A, ... */
197 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
198 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
199 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
200 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
201 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
202 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
203 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377
206 /* Indexed by syntax code, give the letter that describes it. */
208 char syntax_code_spec
[13] =
210 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>'
213 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
214 "Return the syntax code of CHAR, described by a character.\n\
215 For example, if CHAR is a word constituent, the character `?w' is returned.\n\
216 The characters that correspond to various syntax codes\n\
217 are listed in the documentation of `modify-syntax-entry'.")
221 CHECK_NUMBER (ch
, 0);
222 return make_number (syntax_code_spec
[(int) SYNTAX (0xFF & XINT (ch
))]);
225 /* This comment supplies the doc string for modify-syntax-entry,
226 for make-docfile to see. We cannot put this in the real DEFUN
227 due to limits in the Unix cpp.
229 DEFUN ("modify-syntax-entry", foo, bar, 0, 0, 0,
230 "Set syntax for character CHAR according to string S.\n\
231 The syntax is changed only for table TABLE, which defaults to\n\
232 the current buffer's syntax table.\n\
233 The first character of S should be one of the following:\n\
234 Space or - whitespace syntax. w word constituent.\n\
235 _ symbol constituent. . punctuation.\n\
236 ( open-parenthesis. ) close-parenthesis.\n\
237 \" string quote. \\ escape.\n\
238 $ paired delimiter. ' expression quote or prefix operator.\n\
239 < comment starter. > comment ender.\n\
240 / character-quote.\n\
241 Only single-character comment start and end sequences are represented thus.\n\
242 Two-character sequences are represented as described below.\n\
243 The second character of S is the matching parenthesis,\n\
244 used only if the first character is `(' or `)'.\n\
245 Any additional characters are flags.\n\
246 Defined flags are the characters 1, 2, 3, 4, b, and p.\n\
247 1 means C is the start of a two-char comment start sequence.\n\
248 2 means C is the second character of such a sequence.\n\
249 3 means C is the start of a two-char comment end sequence.\n\
250 4 means C is the second character of such a sequence.\n\
252 There can be up to two orthogonal comment sequences. This is to support\n\
253 language modes such as C++. By default, all comment sequences are of style\n\
254 a, but you can set the comment sequence style to b (on the second character of a\n\
255 comment-start, or the first character of a comment-end sequence) by using\n\
257 b means C is part of comment sequence b.\n\
259 p means C is a prefix character for `backward-prefix-chars';\n\
260 such characters are treated as whitespace when they occur\n\
261 between expressions.")
265 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
266 /* I really don't know why this is interactive
267 help-form should at least be made useful whilst reading the second arg
269 "cSet syntax for character: \nsSet syntax for %s to: ",
270 0 /* See immediately above */)
271 (c
, newentry
, syntax_table
)
272 Lisp_Object c
, newentry
, syntax_table
;
274 register unsigned char *p
, match
;
275 register enum syntaxcode code
;
279 CHECK_STRING (newentry
, 1);
280 if (NILP (syntax_table
))
281 syntax_table
= current_buffer
->syntax_table
;
283 syntax_table
= check_syntax_table (syntax_table
);
285 p
= XSTRING (newentry
)->data
;
286 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
287 if (((int) code
& 0377) == 0377)
288 error ("invalid syntax description letter: %c", c
);
292 if (match
== ' ') match
= 0;
294 XFASTINT (val
) = (match
<< 8) + (int) code
;
299 XFASTINT (val
) |= 1 << 16;
303 XFASTINT (val
) |= 1 << 17;
307 XFASTINT (val
) |= 1 << 18;
311 XFASTINT (val
) |= 1 << 19;
315 XFASTINT (val
) |= 1 << 20;
319 XFASTINT (val
) |= 1 << 21;
323 XVECTOR (syntax_table
)->contents
[0xFF & XINT (c
)] = val
;
328 /* Dump syntax table to buffer in human-readable format */
330 describe_syntax (value
)
333 register enum syntaxcode code
;
334 char desc
, match
, start1
, start2
, end1
, end2
, prefix
, comstyle
;
337 Findent_to (make_number (16), make_number (1));
339 if (XTYPE (value
) != Lisp_Int
)
341 insert_string ("invalid");
345 code
= (enum syntaxcode
) (XINT (value
) & 0377);
346 match
= (XINT (value
) >> 8) & 0377;
347 start1
= (XINT (value
) >> 16) & 1;
348 start2
= (XINT (value
) >> 17) & 1;
349 end1
= (XINT (value
) >> 18) & 1;
350 end2
= (XINT (value
) >> 19) & 1;
351 prefix
= (XINT (value
) >> 20) & 1;
352 comstyle
= (XINT (value
) >> 21) & 1;
354 if ((int) code
< 0 || (int) code
>= (int) Smax
)
356 insert_string ("invalid");
359 desc
= syntax_code_spec
[(int) code
];
361 str
[0] = desc
, str
[1] = 0;
364 str
[0] = match
? match
: ' ';
383 insert_string ("\twhich means: ");
385 #ifdef SWITCH_ENUM_BUG
392 insert_string ("whitespace"); break;
394 insert_string ("punctuation"); break;
396 insert_string ("word"); break;
398 insert_string ("symbol"); break;
400 insert_string ("open"); break;
402 insert_string ("close"); break;
404 insert_string ("quote"); break;
406 insert_string ("string"); break;
408 insert_string ("math"); break;
410 insert_string ("escape"); break;
412 insert_string ("charquote"); break;
414 insert_string ("comment"); break;
416 insert_string ("endcomment"); break;
418 insert_string ("invalid");
424 insert_string (", matches ");
429 insert_string (",\n\t is the first character of a comment-start sequence");
431 insert_string (",\n\t is the second character of a comment-start sequence");
434 insert_string (",\n\t is the first character of a comment-end sequence");
436 insert_string (",\n\t is the second character of a comment-end sequence");
438 insert_string (" (comment style b)");
441 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
443 insert_string ("\n");
447 describe_syntax_1 (vector
)
450 struct buffer
*old
= current_buffer
;
451 set_buffer_internal (XBUFFER (Vstandard_output
));
452 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
);
453 set_buffer_internal (old
);
457 DEFUN ("describe-syntax", Fdescribe_syntax
, Sdescribe_syntax
, 0, 0, "",
458 "Describe the syntax specifications in the syntax table.\n\
459 The descriptions are inserted in a buffer, which is then displayed.")
462 internal_with_output_to_temp_buffer
463 ("*Help*", describe_syntax_1
, current_buffer
->syntax_table
);
468 /* Return the position across COUNT words from FROM.
469 If that many words cannot be found before the end of the buffer, return 0.
470 COUNT negative means scan backward and stop at word beginning. */
472 scan_words (from
, count
)
473 register int from
, count
;
475 register int beg
= BEGV
;
476 register int end
= ZV
;
491 code
= SYNTAX (FETCH_CHAR (from
));
492 if (words_include_escapes
493 && (code
== Sescape
|| code
== Scharquote
))
501 if (from
== end
) break;
502 code
= SYNTAX (FETCH_CHAR (from
));
503 if (!(words_include_escapes
504 && (code
== Sescape
|| code
== Scharquote
)))
520 code
= SYNTAX (FETCH_CHAR (from
- 1));
521 if (words_include_escapes
522 && (code
== Sescape
|| code
== Scharquote
))
530 if (from
== beg
) break;
531 code
= SYNTAX (FETCH_CHAR (from
- 1));
532 if (!(words_include_escapes
533 && (code
== Sescape
|| code
== Scharquote
)))
546 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 1, 1, "p",
547 "Move point forward ARG words (backward if ARG is negative).\n\
548 Normally returns t.\n\
549 If an edge of the buffer is reached, point is left there\n\
550 and nil is returned.")
555 CHECK_NUMBER (count
, 0);
557 if (!(val
= scan_words (point
, XINT (count
))))
559 SET_PT (XINT (count
) > 0 ? ZV
: BEGV
);
566 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
567 "Move forward across up to N comments. If N is negative, move backward.\n\
568 Set point to the far end of the last comment found.\n\
569 Stop scanning if we find something other than a comment or whitespace.\n\
570 If N comments are found as expected, with nothing except whitespace\n\
571 between them, return t; otherwise return nil.")
578 register enum syntaxcode code
;
579 int comstyle
= 0; /* style of comment encountered */
594 c
= FETCH_CHAR (from
);
598 if (from
< stop
&& SYNTAX_COMSTART_FIRST (c
)
599 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
)))
601 /* we have encountered a comment start sequence and we
602 are ignoring all text inside comments. we must record
603 the comment style this sequence begins so that later,
604 only a comment end of the same style actually ends
605 the comment section */
607 comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
));
611 if (code
== Scomment
)
621 c
= FETCH_CHAR (from
);
622 if (SYNTAX (c
) == Sendcomment
623 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
624 /* we have encountered a comment end of the same style
625 as the comment sequence which began this comment
629 if (from
< stop
&& SYNTAX_COMEND_FIRST (c
)
630 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from
))
631 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
632 /* we have encountered a comment end of the same style
633 as the comment sequence which began this comment
637 /* We have skipped one comment. */
640 else if (code
!= Swhitespace
)
648 /* End of comment reached */
662 quoted
= char_quoted (from
);
665 c
= FETCH_CHAR (from
);
668 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
669 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from
- 1))
670 && !char_quoted (from
- 1))
672 /* we must record the comment style encountered so that
673 later, we can match only the proper comment begin
674 sequence of the same style */
676 comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
- 1));
680 if (code
== Sendcomment
&& !quoted
)
682 if (code
!= SYNTAX (c
))
683 /* For a two-char comment ender, we can assume
684 it does end a comment. So scan back in a simple way. */
686 if (from
!= stop
) from
--;
689 if (SYNTAX (c
= FETCH_CHAR (from
)) == Scomment
690 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
699 if (SYNTAX_COMSTART_SECOND (c
)
700 && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from
))
701 && SYNTAX_COMMENT_STYLE (c
) == comstyle
702 && !char_quoted (from
))
708 /* Look back, counting the parity of string-quotes,
709 and recording the comment-starters seen.
710 When we reach a safe place, assume that's not in a string;
711 then step the main scan to the earliest comment-starter seen
712 an even number of string quotes away from the safe place.
714 OFROM[I] is position of the earliest comment-starter seen
715 which is I+2X quotes from the comment-end.
716 PARITY is current parity of quotes from the comment end. */
719 char my_stringend
= 0;
720 int string_lossage
= 0;
721 int comment_end
= from
;
722 int comstart_pos
= 0;
723 int comstart_parity
= 0;
725 /* At beginning of range to scan, we're outside of strings;
726 that determines quote parity to the comment-end. */
729 /* Move back and examine a character. */
732 c
= FETCH_CHAR (from
);
735 /* If this char is the second of a 2-char comment sequence,
736 back up and give the pair the appropriate syntax. */
737 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
738 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from
- 1)))
744 else if (from
> stop
&& SYNTAX_COMSTART_SECOND (c
)
745 && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from
- 1))
746 && comstyle
== SYNTAX_COMMENT_STYLE (c
))
752 /* Ignore escaped characters. */
753 if (char_quoted (from
))
756 /* Track parity of quotes. */
760 if (my_stringend
== 0)
762 /* If we have two kinds of string delimiters.
763 There's no way to grok this scanning backwards. */
764 else if (my_stringend
!= c
)
768 /* Record comment-starters according to that
769 quote-parity to the comment-end. */
770 if (code
== Scomment
)
772 comstart_parity
= parity
;
776 /* If we find another earlier comment-ender,
777 any comment-starts earier than that don't count
778 (because they go with the earlier comment-ender). */
779 if (code
== Sendcomment
780 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
)) == comstyle
)
783 /* Assume a defun-start point is outside of strings. */
785 && (from
== stop
|| FETCH_CHAR (from
- 1) == '\n'))
789 if (comstart_pos
== 0)
791 /* If the earliest comment starter
792 is followed by uniform paired string quotes or none,
793 we know it can't be inside a string
794 since if it were then the comment ender would be inside one.
795 So it does start a comment. Skip back to it. */
796 else if (comstart_parity
== 0 && !string_lossage
)
800 /* We had two kinds of string delimiters mixed up
801 together. Decode this going forwards.
802 Scan fwd from the previous comment ender
803 to the one in question; this records where we
804 last passed a comment starter. */
805 struct lisp_parse_state state
;
806 scan_sexps_forward (&state
, find_defun_start (comment_end
),
807 comment_end
- 1, -10000, 0, Qnil
);
809 from
= state
.comstart
;
811 /* We can't grok this as a comment; scan it normally. */
816 else if (code
!= Swhitespace
|| quoted
)
832 int parse_sexp_ignore_comments
;
835 scan_lists (from
, count
, depth
, sexpflag
)
837 int count
, depth
, sexpflag
;
845 register enum syntaxcode code
;
846 int min_depth
= depth
; /* Err out if depth gets less than this. */
847 int comstyle
= 0; /* style of comment encountered */
849 if (depth
> 0) min_depth
= 0;
859 c
= FETCH_CHAR (from
);
862 if (from
< stop
&& SYNTAX_COMSTART_FIRST (c
)
863 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
))
864 && parse_sexp_ignore_comments
)
866 /* we have encountered a comment start sequence and we
867 are ignoring all text inside comments. we must record
868 the comment style this sequence begins so that later,
869 only a comment end of the same style actually ends
870 the comment section */
872 comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
));
876 if (SYNTAX_PREFIX (c
))
879 #ifdef SWITCH_ENUM_BUG
887 if (from
== stop
) goto lose
;
889 /* treat following character as a word constituent */
892 if (depth
|| !sexpflag
) break;
893 /* This word counts as a sexp; return at end of it. */
896 #ifdef SWITCH_ENUM_BUG
897 switch ((int) SYNTAX (FETCH_CHAR (from
)))
899 switch (SYNTAX (FETCH_CHAR (from
)))
905 if (from
== stop
) goto lose
;
919 if (!parse_sexp_ignore_comments
) break;
922 if (from
== stop
) goto done
;
923 c
= FETCH_CHAR (from
);
924 if (SYNTAX (c
) == Sendcomment
925 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
926 /* we have encountered a comment end of the same style
927 as the comment sequence which began this comment
931 if (from
< stop
&& SYNTAX_COMEND_FIRST (c
)
932 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from
))
933 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
934 /* we have encountered a comment end of the same style
935 as the comment sequence which began this comment
944 if (from
!= stop
&& c
== FETCH_CHAR (from
))
954 if (!++depth
) goto done
;
959 if (!--depth
) goto done
;
960 if (depth
< min_depth
)
961 error ("Containing expression ends prematurely");
965 stringterm
= FETCH_CHAR (from
- 1);
968 if (from
>= stop
) goto lose
;
969 if (FETCH_CHAR (from
) == stringterm
) break;
970 #ifdef SWITCH_ENUM_BUG
971 switch ((int) SYNTAX (FETCH_CHAR (from
)))
973 switch (SYNTAX (FETCH_CHAR (from
)))
983 if (!depth
&& sexpflag
) goto done
;
988 /* Reached end of buffer. Error if within object, return nil if between */
989 if (depth
) goto lose
;
994 /* End of object reached */
1005 if (quoted
= char_quoted (from
))
1007 c
= FETCH_CHAR (from
);
1009 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1010 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from
- 1))
1011 && !char_quoted (from
- 1)
1012 && parse_sexp_ignore_comments
)
1014 /* we must record the comment style encountered so that
1015 later, we can match only the proper comment begin
1016 sequence of the same style */
1018 comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
- 1));
1022 if (SYNTAX_PREFIX (c
))
1025 #ifdef SWITCH_ENUM_BUG
1026 switch ((int) (quoted
? Sword
: code
))
1028 switch (quoted
? Sword
: code
)
1033 if (depth
|| !sexpflag
) break;
1034 /* This word counts as a sexp; count object finished after passing it. */
1037 quoted
= char_quoted (from
- 1);
1040 if (! (quoted
|| SYNTAX (FETCH_CHAR (from
- 1)) == Sword
1041 || SYNTAX (FETCH_CHAR (from
- 1)) == Ssymbol
1042 || SYNTAX (FETCH_CHAR (from
- 1)) == Squote
))
1051 if (from
!= stop
&& c
== FETCH_CHAR (from
- 1))
1061 if (!++depth
) goto done2
;
1066 if (!--depth
) goto done2
;
1067 if (depth
< min_depth
)
1068 error ("Containing expression ends prematurely");
1072 if (!parse_sexp_ignore_comments
)
1074 if (code
!= SYNTAX (c
))
1075 /* For a two-char comment ender, we can assume
1076 it does end a comment. So scan back in a simple way. */
1078 if (from
!= stop
) from
--;
1081 if (SYNTAX (c
= FETCH_CHAR (from
)) == Scomment
1082 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
1084 if (from
== stop
) goto done
;
1086 if (SYNTAX_COMSTART_SECOND (c
)
1087 && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from
))
1088 && SYNTAX_COMMENT_STYLE (c
) == comstyle
1089 && !char_quoted (from
))
1095 /* Look back, counting the parity of string-quotes,
1096 and recording the comment-starters seen.
1097 When we reach a safe place, assume that's not in a string;
1098 then step the main scan to the earliest comment-starter seen
1099 an even number of string quotes away from the safe place.
1101 OFROM[I] is position of the earliest comment-starter seen
1102 which is I+2X quotes from the comment-end.
1103 PARITY is current parity of quotes from the comment end. */
1106 char my_stringend
= 0;
1107 int string_lossage
= 0;
1108 int comment_end
= from
;
1109 int comstart_pos
= 0;
1110 int comstart_parity
= 0;
1112 /* At beginning of range to scan, we're outside of strings;
1113 that determines quote parity to the comment-end. */
1114 while (from
!= stop
)
1116 /* Move back and examine a character. */
1119 c
= FETCH_CHAR (from
);
1122 /* If this char is the second of a 2-char comment sequence,
1123 back up and give the pair the appropriate syntax. */
1124 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1125 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from
- 1)))
1131 else if (from
> stop
&& SYNTAX_COMSTART_SECOND (c
)
1132 && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from
- 1))
1133 && comstyle
== SYNTAX_COMMENT_STYLE (c
))
1139 /* Ignore escaped characters. */
1140 if (char_quoted (from
))
1143 /* Track parity of quotes. */
1144 if (code
== Sstring
)
1147 if (my_stringend
== 0)
1149 /* If we have two kinds of string delimiters.
1150 There's no way to grok this scanning backwards. */
1151 else if (my_stringend
!= c
)
1155 /* Record comment-starters according to that
1156 quote-parity to the comment-end. */
1157 if (code
== Scomment
)
1159 comstart_parity
= parity
;
1160 comstart_pos
= from
;
1163 /* If we find another earlier comment-ender,
1164 any comment-starts earier than that don't count
1165 (because they go with the earlier comment-ender). */
1166 if (code
== Sendcomment
1167 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
)) == comstyle
)
1170 /* Assume a defun-start point is outside of strings. */
1172 && (from
== stop
|| FETCH_CHAR (from
- 1) == '\n'))
1176 if (comstart_pos
== 0)
1178 /* If the earliest comment starter
1179 is followed by uniform paired string quotes or none,
1180 we know it can't be inside a string
1181 since if it were then the comment ender would be inside one.
1182 So it does start a comment. Skip back to it. */
1183 else if (comstart_parity
== 0 && !string_lossage
)
1184 from
= comstart_pos
;
1187 /* We had two kinds of string delimiters mixed up
1188 together. Decode this going forwards.
1189 Scan fwd from the previous comment ender
1190 to the one in question; this records where we
1191 last passed a comment starter. */
1192 struct lisp_parse_state state
;
1193 scan_sexps_forward (&state
, find_defun_start (comment_end
),
1194 comment_end
- 1, -10000, 0, Qnil
);
1195 if (state
.incomment
)
1196 from
= state
.comstart
;
1198 /* We can't grok this as a comment; scan it normally. */
1205 stringterm
= FETCH_CHAR (from
);
1208 if (from
== stop
) goto lose
;
1209 if (!char_quoted (from
- 1)
1210 && stringterm
== FETCH_CHAR (from
- 1))
1215 if (!depth
&& sexpflag
) goto done2
;
1220 /* Reached start of buffer. Error if within object, return nil if between */
1221 if (depth
) goto lose
;
1232 XFASTINT (val
) = from
;
1236 error ("Unbalanced parentheses");
1243 register enum syntaxcode code
;
1244 register int beg
= BEGV
;
1245 register int quoted
= 0;
1248 && ((code
= SYNTAX (FETCH_CHAR (pos
- 1))) == Scharquote
1249 || code
== Sescape
))
1250 pos
--, quoted
= !quoted
;
1254 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
1255 "Scan from character number FROM by COUNT lists.\n\
1256 Returns the character number of the position thus found.\n\
1258 If DEPTH is nonzero, paren depth begins counting from that value,\n\
1259 only places where the depth in parentheses becomes zero\n\
1260 are candidates for stopping; COUNT such places are counted.\n\
1261 Thus, a positive value for DEPTH means go out levels.\n\
1263 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
1265 If the beginning or end of (the accessible part of) the buffer is reached\n\
1266 and the depth is wrong, an error is signaled.\n\
1267 If the depth is right but the count is not used up, nil is returned.")
1268 (from
, count
, depth
)
1269 Lisp_Object from
, count
, depth
;
1271 CHECK_NUMBER (from
, 0);
1272 CHECK_NUMBER (count
, 1);
1273 CHECK_NUMBER (depth
, 2);
1275 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
1278 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
1279 "Scan from character number FROM by COUNT balanced expressions.\n\
1280 If COUNT is negative, scan backwards.\n\
1281 Returns the character number of the position thus found.\n\
1283 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
1285 If the beginning or end of (the accessible part of) the buffer is reached\n\
1286 in the middle of a parenthetical grouping, an error is signaled.\n\
1287 If the beginning or end is reached between groupings\n\
1288 but before count is used up, nil is returned.")
1290 Lisp_Object from
, count
;
1292 CHECK_NUMBER (from
, 0);
1293 CHECK_NUMBER (count
, 1);
1295 return scan_lists (XINT (from
), XINT (count
), 0, 1);
1298 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
1300 "Move point backward over any number of chars with prefix syntax.\n\
1301 This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
1307 while (pos
> beg
&& !char_quoted (pos
- 1)
1308 && (SYNTAX (FETCH_CHAR (pos
- 1)) == Squote
1309 || SYNTAX_PREFIX (FETCH_CHAR (pos
- 1))))
1317 /* Parse forward from FROM to END,
1318 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
1319 and return a description of the state of the parse at END.
1320 If STOPBEFORE is nonzero, stop at the start of an atom. */
1322 scan_sexps_forward (stateptr
, from
, end
, targetdepth
, stopbefore
, oldstate
)
1323 struct lisp_parse_state
*stateptr
;
1325 int end
, targetdepth
, stopbefore
;
1326 Lisp_Object oldstate
;
1328 struct lisp_parse_state state
;
1330 register enum syntaxcode code
;
1331 struct level
{ int last
, prev
; };
1332 struct level levelstart
[100];
1333 register struct level
*curlevel
= levelstart
;
1334 struct level
*endlevel
= levelstart
+ 100;
1336 register int depth
; /* Paren depth of current scanning location.
1337 level - levelstart equals this except
1338 when the depth becomes negative. */
1339 int mindepth
; /* Lowest DEPTH value seen. */
1340 int start_quoted
= 0; /* Nonzero means starting after a char quote */
1346 if (NILP (oldstate
))
1349 state
.instring
= -1;
1350 state
.incomment
= 0;
1351 state
.comstyle
= 0; /* comment style a by default */
1355 tem
= Fcar (oldstate
);
1361 oldstate
= Fcdr (oldstate
);
1362 oldstate
= Fcdr (oldstate
);
1363 oldstate
= Fcdr (oldstate
);
1364 tem
= Fcar (oldstate
);
1365 state
.instring
= !NILP (tem
) ? XINT (tem
) : -1;
1367 oldstate
= Fcdr (oldstate
);
1368 tem
= Fcar (oldstate
);
1369 state
.incomment
= !NILP (tem
);
1371 oldstate
= Fcdr (oldstate
);
1372 tem
= Fcar (oldstate
);
1373 start_quoted
= !NILP (tem
);
1375 /* if the eight element of the list is nil, we are in comment
1376 style a. if it is non-nil, we are in comment style b */
1377 oldstate
= Fcdr (oldstate
);
1378 oldstate
= Fcdr (oldstate
);
1379 oldstate
= Fcdr (oldstate
);
1380 tem
= Fcar (oldstate
);
1381 state
.comstyle
= !NILP (tem
);
1386 curlevel
->prev
= -1;
1387 curlevel
->last
= -1;
1389 /* Enter the loop at a place appropriate for initial state. */
1391 if (state
.incomment
) goto startincomment
;
1392 if (state
.instring
>= 0)
1394 if (start_quoted
) goto startquotedinstring
;
1397 if (start_quoted
) goto startquoted
;
1401 code
= SYNTAX (FETCH_CHAR (from
));
1403 if (from
< end
&& SYNTAX_COMSTART_FIRST (FETCH_CHAR (from
- 1))
1404 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
)))
1406 /* Record the comment style we have entered so that only
1407 the comment-end sequence of the same style actually
1408 terminates the comment section. */
1410 state
.comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
));
1414 if (SYNTAX_PREFIX (FETCH_CHAR (from
- 1)))
1416 #ifdef SWITCH_ENUM_BUG
1424 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
1425 curlevel
->last
= from
- 1;
1427 if (from
== end
) goto endquoted
;
1430 /* treat following character as a word constituent */
1433 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
1434 curlevel
->last
= from
- 1;
1438 #ifdef SWITCH_ENUM_BUG
1439 switch ((int) SYNTAX (FETCH_CHAR (from
)))
1441 switch (SYNTAX (FETCH_CHAR (from
)))
1447 if (from
== end
) goto endquoted
;
1459 curlevel
->prev
= curlevel
->last
;
1463 state
.incomment
= 1;
1464 state
.comstart
= from
;
1468 if (from
== end
) goto done
;
1469 prev
= FETCH_CHAR (from
);
1470 if (SYNTAX (prev
) == Sendcomment
1471 && SYNTAX_COMMENT_STYLE (prev
) == state
.comstyle
)
1472 /* Only terminate the comment section if the endcomment
1473 of the same style as the start sequence has been
1477 if (from
< end
&& SYNTAX_COMEND_FIRST (prev
)
1478 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from
))
1479 && SYNTAX_COMMENT_STYLE (prev
) == state
.comstyle
)
1480 /* Only terminate the comment section if the end-comment
1481 sequence of the same style as the start sequence has
1482 been encountered. */
1485 state
.incomment
= 0;
1486 state
.comstyle
= 0; /* reset the comment style */
1490 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
1492 /* curlevel++->last ran into compiler bug on Apollo */
1493 curlevel
->last
= from
- 1;
1494 if (++curlevel
== endlevel
)
1495 error ("Nesting too deep for parser");
1496 curlevel
->prev
= -1;
1497 curlevel
->last
= -1;
1498 if (!--targetdepth
) goto done
;
1503 if (depth
< mindepth
)
1505 if (curlevel
!= levelstart
)
1507 curlevel
->prev
= curlevel
->last
;
1508 if (!++targetdepth
) goto done
;
1512 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
1513 curlevel
->last
= from
- 1;
1514 state
.instring
= FETCH_CHAR (from
- 1);
1518 if (from
>= end
) goto done
;
1519 if (FETCH_CHAR (from
) == state
.instring
) break;
1520 #ifdef SWITCH_ENUM_BUG
1521 switch ((int) SYNTAX (FETCH_CHAR (from
)))
1523 switch (SYNTAX (FETCH_CHAR (from
)))
1529 startquotedinstring
:
1530 if (from
>= end
) goto endquoted
;
1534 state
.instring
= -1;
1535 curlevel
->prev
= curlevel
->last
;
1545 stop
: /* Here if stopping before start of sexp. */
1546 from
--; /* We have just fetched the char that starts it; */
1547 goto done
; /* but return the position before it. */
1552 state
.depth
= depth
;
1553 state
.mindepth
= mindepth
;
1554 state
.thislevelstart
= curlevel
->prev
;
1555 state
.prevlevelstart
1556 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
1557 state
.location
= from
;
1563 /* This comment supplies the doc string for parse-partial-sexp,
1564 for make-docfile to see. We cannot put this in the real DEFUN
1565 due to limits in the Unix cpp.
1567 DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 5, 0,
1568 "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
1569 Parsing stops at TO or when certain criteria are met;\n\
1570 point is set to where parsing stops.\n\
1571 If fifth arg STATE is omitted or nil,\n\
1572 parsing assumes that FROM is the beginning of a function.\n\
1573 Value is a list of eight elements describing final state of parsing:\n\
1574 1. depth in parens.\n\
1575 2. character address of start of innermost containing list; nil if none.\n\
1576 3. character address of start of last complete sexp terminated.\n\
1577 4. non-nil if inside a string.\n\
1578 (it is the character that will terminate the string.)\n\
1579 5. t if inside a comment.\n\
1580 6. t if following a quote character.\n\
1581 7. the minimum paren-depth encountered during this scan.\n\
1582 8. t if in a comment of style `b'.\n\
1583 If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
1584 in parentheses becomes equal to TARGETDEPTH.\n\
1585 Fourth arg STOPBEFORE non-nil means stop when come to\n\
1586 any character that starts a sexp.\n\
1587 Fifth arg STATE is a seven-list like what this function returns.\n\
1588 It is used to initialize the state of the parse. Its second and third
1589 elements are ignored.")
1590 (from, to, targetdepth, stopbefore, state)
1593 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 5, 0,
1594 0 /* See immediately above */)
1595 (from
, to
, targetdepth
, stopbefore
, oldstate
)
1596 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
;
1598 struct lisp_parse_state state
;
1601 if (!NILP (targetdepth
))
1603 CHECK_NUMBER (targetdepth
, 3);
1604 target
= XINT (targetdepth
);
1607 target
= -100000; /* We won't reach this depth */
1609 validate_region (&from
, &to
);
1610 scan_sexps_forward (&state
, XINT (from
), XINT (to
),
1611 target
, !NILP (stopbefore
), oldstate
);
1613 SET_PT (state
.location
);
1615 return Fcons (make_number (state
.depth
),
1616 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
1617 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
1618 Fcons (state
.instring
>= 0 ? make_number (state
.instring
) : Qnil
,
1619 Fcons (state
.incomment
? Qt
: Qnil
,
1620 Fcons (state
.quoted
? Qt
: Qnil
,
1621 Fcons (make_number (state
.mindepth
),
1622 Fcons (state
.comstyle
? Qt
: Qnil
,
1629 register struct Lisp_Vector
*v
;
1631 /* Set this now, so first buffer creation can refer to it. */
1632 /* Make it nil before calling copy-syntax-table
1633 so that copy-syntax-table will know not to try to copy from garbage */
1634 Vstandard_syntax_table
= Qnil
;
1635 Vstandard_syntax_table
= Fcopy_syntax_table (Qnil
);
1637 v
= XVECTOR (Vstandard_syntax_table
);
1639 for (i
= 'a'; i
<= 'z'; i
++)
1640 XFASTINT (v
->contents
[i
]) = (int) Sword
;
1641 for (i
= 'A'; i
<= 'Z'; i
++)
1642 XFASTINT (v
->contents
[i
]) = (int) Sword
;
1643 for (i
= '0'; i
<= '9'; i
++)
1644 XFASTINT (v
->contents
[i
]) = (int) Sword
;
1645 XFASTINT (v
->contents
['$']) = (int) Sword
;
1646 XFASTINT (v
->contents
['%']) = (int) Sword
;
1648 XFASTINT (v
->contents
['(']) = (int) Sopen
+ (')' << 8);
1649 XFASTINT (v
->contents
[')']) = (int) Sclose
+ ('(' << 8);
1650 XFASTINT (v
->contents
['[']) = (int) Sopen
+ (']' << 8);
1651 XFASTINT (v
->contents
[']']) = (int) Sclose
+ ('[' << 8);
1652 XFASTINT (v
->contents
['{']) = (int) Sopen
+ ('}' << 8);
1653 XFASTINT (v
->contents
['}']) = (int) Sclose
+ ('{' << 8);
1654 XFASTINT (v
->contents
['"']) = (int) Sstring
;
1655 XFASTINT (v
->contents
['\\']) = (int) Sescape
;
1657 for (i
= 0; i
< 10; i
++)
1658 XFASTINT (v
->contents
["_-+*/&|<>="[i
]]) = (int) Ssymbol
;
1660 for (i
= 0; i
< 12; i
++)
1661 XFASTINT (v
->contents
[".,;:?!#@~^'`"[i
]]) = (int) Spunct
;
1666 Qsyntax_table_p
= intern ("syntax-table-p");
1667 staticpro (&Qsyntax_table_p
);
1669 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
1670 "Non-nil means `forward-sexp', etc., should treat comments as whitespace.");
1672 words_include_escapes
= 0;
1673 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
1674 "Non-nil means `forward-word', etc., should treat escape chars part of words.");
1676 defsubr (&Ssyntax_table_p
);
1677 defsubr (&Ssyntax_table
);
1678 defsubr (&Sstandard_syntax_table
);
1679 defsubr (&Scopy_syntax_table
);
1680 defsubr (&Sset_syntax_table
);
1681 defsubr (&Schar_syntax
);
1682 defsubr (&Smodify_syntax_entry
);
1683 defsubr (&Sdescribe_syntax
);
1685 defsubr (&Sforward_word
);
1687 defsubr (&Sforward_comment
);
1688 defsubr (&Sscan_lists
);
1689 defsubr (&Sscan_sexps
);
1690 defsubr (&Sbackward_prefix_chars
);
1691 defsubr (&Sparse_partial_sexp
);