1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 1987, 1993, 1994 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 static void scan_sexps_forward ();
31 static int char_quoted ();
33 int words_include_escapes
;
35 /* This is the internal form of the parse state used in parse-partial-sexp. */
37 struct lisp_parse_state
39 int depth
; /* Depth at end of parsing */
40 int instring
; /* -1 if not within string, else desired terminator. */
41 int incomment
; /* Nonzero if within a comment at end of parsing */
42 int comstyle
; /* comment style a=0, or b=1 */
43 int quoted
; /* Nonzero if just after an escape char at end of parsing */
44 int thislevelstart
; /* Char number of most recent start-of-expression at current level */
45 int prevlevelstart
; /* Char number of start of containing expression */
46 int location
; /* Char number at which parsing stopped. */
47 int mindepth
; /* Minimum depth seen while scanning. */
48 int comstart
; /* Position just after last comment starter. */
51 /* These variables are a cache for finding the start of a defun.
52 find_start_pos is the place for which the defun start was found.
53 find_start_value is the defun start position found for it.
54 find_start_buffer is the buffer it was found in.
55 find_start_begv is the BEGV value when it was found.
56 find_start_modiff is the value of MODIFF when it was found. */
58 static int find_start_pos
;
59 static int find_start_value
;
60 static struct buffer
*find_start_buffer
;
61 static int find_start_begv
;
62 static int find_start_modiff
;
64 /* Find a defun-start that is the last one before POS (or nearly the last).
65 We record what we find, so that another call in the same area
66 can return the same value right away. */
69 find_defun_start (pos
)
75 /* Use previous finding, if it's valid and applies to this inquiry. */
76 if (current_buffer
== find_start_buffer
77 /* Reuse the defun-start even if POS is a little farther on.
78 POS might be in the next defun, but that's ok.
79 Our value may not be the best possible, but will still be usable. */
80 && pos
<= find_start_pos
+ 1000
81 && pos
>= find_start_value
82 && BEGV
== find_start_begv
83 && MODIFF
== find_start_modiff
)
84 return find_start_value
;
86 /* Back up to start of line. */
87 tem
= scan_buffer ('\n', pos
, BEGV
, -1, &shortage
, 1);
91 /* Open-paren at start of line means we found our defun-start. */
92 if (SYNTAX (FETCH_CHAR (tem
)) == Sopen
)
94 /* Move to beg of previous line. */
95 tem
= scan_buffer ('\n', tem
, BEGV
, -2, &shortage
, 1);
98 /* Record what we found, for the next try. */
99 find_start_value
= tem
;
100 find_start_buffer
= current_buffer
;
101 find_start_modiff
= MODIFF
;
102 find_start_begv
= BEGV
;
103 find_start_pos
= pos
;
105 return find_start_value
;
108 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
109 "Return t if ARG is a syntax table.\n\
110 Any vector of 256 elements will do.")
114 if (VECTORP (obj
) && XVECTOR (obj
)->size
== 0400)
120 check_syntax_table (obj
)
123 register Lisp_Object tem
;
124 while (tem
= Fsyntax_table_p (obj
),
126 obj
= wrong_type_argument (Qsyntax_table_p
, obj
);
131 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
132 "Return the current syntax table.\n\
133 This is the one specified by the current buffer.")
136 return current_buffer
->syntax_table
;
139 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
140 Sstandard_syntax_table
, 0, 0, 0,
141 "Return the standard syntax table.\n\
142 This is the one used for new buffers.")
145 return Vstandard_syntax_table
;
148 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
149 "Construct a new syntax table and return it.\n\
150 It is a copy of the TABLE, which defaults to the standard syntax table.")
154 Lisp_Object size
, val
;
155 XSETFASTINT (size
, 0400);
156 XSETFASTINT (val
, 0);
157 val
= Fmake_vector (size
, val
);
159 table
= check_syntax_table (table
);
160 else if (NILP (Vstandard_syntax_table
))
161 /* Can only be null during initialization */
163 else table
= Vstandard_syntax_table
;
165 bcopy (XVECTOR (table
)->contents
,
166 XVECTOR (val
)->contents
, 0400 * sizeof (Lisp_Object
));
170 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
171 "Select a new syntax table for the current buffer.\n\
172 One argument, a syntax table.")
176 table
= check_syntax_table (table
);
177 current_buffer
->syntax_table
= table
;
178 /* Indicate that this buffer now has a specified syntax table. */
179 current_buffer
->local_var_flags
180 |= XFASTINT (buffer_local_flags
.syntax_table
);
184 /* Convert a letter which signifies a syntax code
185 into the code it signifies.
186 This is used by modify-syntax-entry, and other things. */
188 unsigned char syntax_spec_code
[0400] =
189 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
190 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
191 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
192 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
193 (char) Swhitespace
, 0377, (char) Sstring
, 0377,
194 (char) Smath
, 0377, 0377, (char) Squote
,
195 (char) Sopen
, (char) Sclose
, 0377, 0377,
196 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
197 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
198 0377, 0377, 0377, 0377,
199 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
200 (char) Sinherit
, 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, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
204 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
205 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
206 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
207 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377
210 /* Indexed by syntax code, give the letter that describes it. */
212 char syntax_code_spec
[14] =
214 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@'
217 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
218 "Return the syntax code of CHAR, described by a character.\n\
219 For example, if CHAR is a word constituent, the character `?w' is returned.\n\
220 The characters that correspond to various syntax codes\n\
221 are listed in the documentation of `modify-syntax-entry'.")
225 CHECK_NUMBER (ch
, 0);
226 return make_number (syntax_code_spec
[(int) SYNTAX (XINT (ch
))]);
229 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
230 "Return the matching parenthesis of CHAR, or nil if none.")
235 CHECK_NUMBER (ch
, 0);
236 code
= SYNTAX (XINT (ch
));
237 if (code
== Sopen
|| code
== Sclose
)
238 return make_number (SYNTAX_MATCH (XINT (ch
)));
242 /* This comment supplies the doc string for modify-syntax-entry,
243 for make-docfile to see. We cannot put this in the real DEFUN
244 due to limits in the Unix cpp.
246 DEFUN ("modify-syntax-entry", foo, bar, 2, 3, 0,
247 "Set syntax for character CHAR according to string S.\n\
248 The syntax is changed only for table TABLE, which defaults to\n\
249 the current buffer's syntax table.\n\
250 The first character of S should be one of the following:\n\
251 Space or - whitespace syntax. w word constituent.\n\
252 _ symbol constituent. . punctuation.\n\
253 ( open-parenthesis. ) close-parenthesis.\n\
254 \" string quote. \\ escape.\n\
255 $ paired delimiter. ' expression quote or prefix operator.\n\
256 < comment starter. > comment ender.\n\
257 / character-quote. @ inherit from `standard-syntax-table'.\n\
259 Only single-character comment start and end sequences are represented thus.\n\
260 Two-character sequences are represented as described below.\n\
261 The second character of S is the matching parenthesis,\n\
262 used only if the first character is `(' or `)'.\n\
263 Any additional characters are flags.\n\
264 Defined flags are the characters 1, 2, 3, 4, b, and p.\n\
265 1 means C is the start of a two-char comment start sequence.\n\
266 2 means C is the second character of such a sequence.\n\
267 3 means C is the start of a two-char comment end sequence.\n\
268 4 means C is the second character of such a sequence.\n\
270 There can be up to two orthogonal comment sequences. This is to support\n\
271 language modes such as C++. By default, all comment sequences are of style\n\
272 a, but you can set the comment sequence style to b (on the second character\n\
273 of a comment-start, or the first character of a comment-end sequence) using\n\
275 b means C is part of comment sequence b.\n\
277 p means C is a prefix character for `backward-prefix-chars';\n\
278 such characters are treated as whitespace when they occur\n\
279 between expressions.")
283 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
284 /* I really don't know why this is interactive
285 help-form should at least be made useful whilst reading the second arg
287 "cSet syntax for character: \nsSet syntax for %s to: ",
288 0 /* See immediately above */)
289 (c
, newentry
, syntax_table
)
290 Lisp_Object c
, newentry
, syntax_table
;
292 register unsigned char *p
, match
;
293 register enum syntaxcode code
;
297 CHECK_STRING (newentry
, 1);
298 if (NILP (syntax_table
))
299 syntax_table
= current_buffer
->syntax_table
;
301 syntax_table
= check_syntax_table (syntax_table
);
303 p
= XSTRING (newentry
)->data
;
304 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
305 if (((int) code
& 0377) == 0377)
306 error ("invalid syntax description letter: %c", c
);
310 if (match
== ' ') match
= 0;
312 val
= (match
<< 8) + (int) code
;
341 XSETFASTINT (XVECTOR (syntax_table
)->contents
[0xFF & XINT (c
)], val
);
346 /* Dump syntax table to buffer in human-readable format */
349 describe_syntax (value
)
352 register enum syntaxcode code
;
353 char desc
, match
, start1
, start2
, end1
, end2
, prefix
, comstyle
;
356 Findent_to (make_number (16), make_number (1));
358 if (!INTEGERP (value
))
360 insert_string ("invalid");
364 code
= (enum syntaxcode
) (XINT (value
) & 0377);
365 match
= (XINT (value
) >> 8) & 0377;
366 start1
= (XINT (value
) >> 16) & 1;
367 start2
= (XINT (value
) >> 17) & 1;
368 end1
= (XINT (value
) >> 18) & 1;
369 end2
= (XINT (value
) >> 19) & 1;
370 prefix
= (XINT (value
) >> 20) & 1;
371 comstyle
= (XINT (value
) >> 21) & 1;
373 if ((int) code
< 0 || (int) code
>= (int) Smax
)
375 insert_string ("invalid");
378 desc
= syntax_code_spec
[(int) code
];
380 str
[0] = desc
, str
[1] = 0;
383 str
[0] = match
? match
: ' ';
402 insert_string ("\twhich means: ");
404 #ifdef SWITCH_ENUM_BUG
411 insert_string ("whitespace"); break;
413 insert_string ("punctuation"); break;
415 insert_string ("word"); break;
417 insert_string ("symbol"); break;
419 insert_string ("open"); break;
421 insert_string ("close"); break;
423 insert_string ("quote"); break;
425 insert_string ("string"); break;
427 insert_string ("math"); break;
429 insert_string ("escape"); break;
431 insert_string ("charquote"); break;
433 insert_string ("comment"); break;
435 insert_string ("endcomment"); break;
437 insert_string ("inherit"); break;
439 insert_string ("invalid");
445 insert_string (", matches ");
450 insert_string (",\n\t is the first character of a comment-start sequence");
452 insert_string (",\n\t is the second character of a comment-start sequence");
455 insert_string (",\n\t is the first character of a comment-end sequence");
457 insert_string (",\n\t is the second character of a comment-end sequence");
459 insert_string (" (comment style b)");
462 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
464 insert_string ("\n");
468 describe_syntax_1 (vector
)
471 struct buffer
*old
= current_buffer
;
472 set_buffer_internal (XBUFFER (Vstandard_output
));
473 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
);
474 set_buffer_internal (old
);
478 DEFUN ("describe-syntax", Fdescribe_syntax
, Sdescribe_syntax
, 0, 0, "",
479 "Describe the syntax specifications in the syntax table.\n\
480 The descriptions are inserted in a buffer, which is then displayed.")
483 internal_with_output_to_temp_buffer
484 ("*Help*", describe_syntax_1
, current_buffer
->syntax_table
);
489 /* Return the position across COUNT words from FROM.
490 If that many words cannot be found before the end of the buffer, return 0.
491 COUNT negative means scan backward and stop at word beginning. */
493 scan_words (from
, count
)
494 register int from
, count
;
496 register int beg
= BEGV
;
497 register int end
= ZV
;
512 code
= SYNTAX (FETCH_CHAR (from
));
513 if (words_include_escapes
514 && (code
== Sescape
|| code
== Scharquote
))
522 if (from
== end
) break;
523 code
= SYNTAX (FETCH_CHAR (from
));
524 if (!(words_include_escapes
525 && (code
== Sescape
|| code
== Scharquote
)))
541 code
= SYNTAX (FETCH_CHAR (from
- 1));
542 if (words_include_escapes
543 && (code
== Sescape
|| code
== Scharquote
))
551 if (from
== beg
) break;
552 code
= SYNTAX (FETCH_CHAR (from
- 1));
553 if (!(words_include_escapes
554 && (code
== Sescape
|| code
== Scharquote
)))
567 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 1, 1, "p",
568 "Move point forward ARG words (backward if ARG is negative).\n\
569 Normally returns t.\n\
570 If an edge of the buffer is reached, point is left there\n\
571 and nil is returned.")
576 CHECK_NUMBER (count
, 0);
578 if (!(val
= scan_words (point
, XINT (count
))))
580 SET_PT (XINT (count
) > 0 ? ZV
: BEGV
);
587 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
588 "Move forward across up to N comments. If N is negative, move backward.\n\
589 Stop scanning if we find something other than a comment or whitespace.\n\
590 Set point to where scanning stops.\n\
591 If N comments are found as expected, with nothing except whitespace\n\
592 between them, return t; otherwise return nil.")
599 register enum syntaxcode code
;
600 int comstyle
= 0; /* style of comment encountered */
604 CHECK_NUMBER (count
, 0);
605 count1
= XINT (count
);
622 c
= FETCH_CHAR (from
);
626 if (from
< stop
&& SYNTAX_COMSTART_FIRST (c
)
627 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
)))
629 /* We have encountered a comment start sequence and we
630 are ignoring all text inside comments. We must record
631 the comment style this sequence begins so that later,
632 only a comment end of the same style actually ends
633 the comment section. */
635 comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
));
639 while (code
== Swhitespace
|| code
== Sendcomment
);
640 if (code
!= Scomment
)
646 /* We're at the start of a comment. */
655 c
= FETCH_CHAR (from
);
657 if (SYNTAX (c
) == Sendcomment
658 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
659 /* we have encountered a comment end of the same style
660 as the comment sequence which began this comment
663 if (from
< stop
&& SYNTAX_COMEND_FIRST (c
)
664 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from
))
665 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
666 /* we have encountered a comment end of the same style
667 as the comment sequence which began this comment
671 /* We have skipped one comment. */
683 quoted
= char_quoted (from
);
686 c
= FETCH_CHAR (from
);
689 if (code
== Sendcomment
)
690 comstyle
= SYNTAX_COMMENT_STYLE (c
);
691 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
692 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from
- 1))
693 && !char_quoted (from
- 1))
695 /* We must record the comment style encountered so that
696 later, we can match only the proper comment begin
697 sequence of the same style. */
699 comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
- 1));
703 if (code
== Sendcomment
&& !quoted
)
706 if (code
!= SYNTAX (c
))
707 /* For a two-char comment ender, we can assume
708 it does end a comment. So scan back in a simple way. */
710 if (from
!= stop
) from
--;
713 if (SYNTAX (c
= FETCH_CHAR (from
)) == Scomment
714 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
723 if (SYNTAX_COMSTART_SECOND (c
)
724 && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from
))
725 && SYNTAX_COMMENT_STYLE (c
) == comstyle
726 && !char_quoted (from
))
733 /* Look back, counting the parity of string-quotes,
734 and recording the comment-starters seen.
735 When we reach a safe place, assume that's not in a string;
736 then step the main scan to the earliest comment-starter seen
737 an even number of string quotes away from the safe place.
739 OFROM[I] is position of the earliest comment-starter seen
740 which is I+2X quotes from the comment-end.
741 PARITY is current parity of quotes from the comment end. */
744 char my_stringend
= 0;
745 int string_lossage
= 0;
746 int comment_end
= from
;
747 int comstart_pos
= 0;
748 int comstart_parity
= 0;
749 int scanstart
= from
- 1;
751 /* At beginning of range to scan, we're outside of strings;
752 that determines quote parity to the comment-end. */
755 /* Move back and examine a character. */
758 c
= FETCH_CHAR (from
);
761 /* If this char is the second of a 2-char comment sequence,
762 back up and give the pair the appropriate syntax. */
763 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
764 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from
- 1)))
768 c
= FETCH_CHAR (from
);
771 /* If this char starts a 2-char comment start sequence,
772 treat it like a 1-char comment starter. */
773 if (from
< scanstart
&& SYNTAX_COMSTART_FIRST (c
)
774 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
+ 1))
775 && comstyle
== SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
+ 1)))
778 /* Ignore escaped characters. */
779 if (char_quoted (from
))
782 /* Track parity of quotes. */
786 if (my_stringend
== 0)
788 /* If we have two kinds of string delimiters.
789 There's no way to grok this scanning backwards. */
790 else if (my_stringend
!= c
)
794 /* Record comment-starters according to that
795 quote-parity to the comment-end. */
796 if (code
== Scomment
)
798 comstart_parity
= parity
;
802 /* If we find another earlier comment-ender,
803 any comment-starts earlier than that don't count
804 (because they go with the earlier comment-ender). */
805 if (code
== Sendcomment
806 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
)) == comstyle
)
809 /* Assume a defun-start point is outside of strings. */
811 && (from
== stop
|| FETCH_CHAR (from
- 1) == '\n'))
815 if (comstart_pos
== 0)
817 /* If the earliest comment starter
818 is followed by uniform paired string quotes or none,
819 we know it can't be inside a string
820 since if it were then the comment ender would be inside one.
821 So it does start a comment. Skip back to it. */
822 else if (comstart_parity
== 0 && !string_lossage
)
826 /* We had two kinds of string delimiters mixed up
827 together. Decode this going forwards.
828 Scan fwd from the previous comment ender
829 to the one in question; this records where we
830 last passed a comment starter. */
831 struct lisp_parse_state state
;
832 scan_sexps_forward (&state
, find_defun_start (comment_end
),
833 comment_end
- 1, -10000, 0, Qnil
, 0);
835 from
= state
.comstart
;
837 /* We can't grok this as a comment; scan it normally. */
841 /* We have skipped one comment. */
844 else if ((code
!= Swhitespace
&& code
!= Scomment
) || quoted
)
860 int parse_sexp_ignore_comments
;
863 scan_lists (from
, count
, depth
, sexpflag
)
865 int count
, depth
, sexpflag
;
873 register enum syntaxcode code
;
874 int min_depth
= depth
; /* Err out if depth gets less than this. */
875 int comstyle
= 0; /* style of comment encountered */
877 if (depth
> 0) min_depth
= 0;
887 c
= FETCH_CHAR (from
);
890 if (from
< stop
&& SYNTAX_COMSTART_FIRST (c
)
891 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
))
892 && parse_sexp_ignore_comments
)
894 /* we have encountered a comment start sequence and we
895 are ignoring all text inside comments. we must record
896 the comment style this sequence begins so that later,
897 only a comment end of the same style actually ends
898 the comment section */
900 comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
));
904 if (SYNTAX_PREFIX (c
))
907 #ifdef SWITCH_ENUM_BUG
915 if (from
== stop
) goto lose
;
917 /* treat following character as a word constituent */
920 if (depth
|| !sexpflag
) break;
921 /* This word counts as a sexp; return at end of it. */
924 #ifdef SWITCH_ENUM_BUG
925 switch ((int) SYNTAX (FETCH_CHAR (from
)))
927 switch (SYNTAX (FETCH_CHAR (from
)))
933 if (from
== stop
) goto lose
;
947 if (!parse_sexp_ignore_comments
) break;
956 c
= FETCH_CHAR (from
);
957 if (SYNTAX (c
) == Sendcomment
958 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
959 /* we have encountered a comment end of the same style
960 as the comment sequence which began this comment
964 if (from
< stop
&& SYNTAX_COMEND_FIRST (c
)
965 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from
))
966 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
967 /* we have encountered a comment end of the same style
968 as the comment sequence which began this comment
977 if (from
!= stop
&& c
== FETCH_CHAR (from
))
987 if (!++depth
) goto done
;
992 if (!--depth
) goto done
;
993 if (depth
< min_depth
)
994 error ("Containing expression ends prematurely");
998 stringterm
= FETCH_CHAR (from
- 1);
1001 if (from
>= stop
) goto lose
;
1002 if (FETCH_CHAR (from
) == stringterm
) break;
1003 #ifdef SWITCH_ENUM_BUG
1004 switch ((int) SYNTAX (FETCH_CHAR (from
)))
1006 switch (SYNTAX (FETCH_CHAR (from
)))
1016 if (!depth
&& sexpflag
) goto done
;
1021 /* Reached end of buffer. Error if within object, return nil if between */
1022 if (depth
) goto lose
;
1027 /* End of object reached */
1038 if (quoted
= char_quoted (from
))
1040 c
= FETCH_CHAR (from
);
1043 if (code
== Sendcomment
)
1044 comstyle
= SYNTAX_COMMENT_STYLE (c
);
1045 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1046 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from
- 1))
1047 && !char_quoted (from
- 1)
1048 && parse_sexp_ignore_comments
)
1050 /* we must record the comment style encountered so that
1051 later, we can match only the proper comment begin
1052 sequence of the same style */
1054 comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
- 1));
1058 if (SYNTAX_PREFIX (c
))
1061 #ifdef SWITCH_ENUM_BUG
1062 switch ((int) (quoted
? Sword
: code
))
1064 switch (quoted
? Sword
: code
)
1069 if (depth
|| !sexpflag
) break;
1070 /* This word counts as a sexp; count object finished after passing it. */
1073 quoted
= char_quoted (from
- 1);
1076 if (! (quoted
|| SYNTAX (FETCH_CHAR (from
- 1)) == Sword
1077 || SYNTAX (FETCH_CHAR (from
- 1)) == Ssymbol
1078 || SYNTAX (FETCH_CHAR (from
- 1)) == Squote
))
1087 if (from
!= stop
&& c
== FETCH_CHAR (from
- 1))
1097 if (!++depth
) goto done2
;
1102 if (!--depth
) goto done2
;
1103 if (depth
< min_depth
)
1104 error ("Containing expression ends prematurely");
1108 if (!parse_sexp_ignore_comments
)
1111 if (code
!= SYNTAX (c
))
1112 /* For a two-char comment ender, we can assume
1113 it does end a comment. So scan back in a simple way. */
1115 if (from
!= stop
) from
--;
1118 if (SYNTAX (c
= FETCH_CHAR (from
)) == Scomment
1119 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
1128 if (SYNTAX_COMSTART_SECOND (c
)
1129 && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from
))
1130 && SYNTAX_COMMENT_STYLE (c
) == comstyle
1131 && !char_quoted (from
))
1138 /* Look back, counting the parity of string-quotes,
1139 and recording the comment-starters seen.
1140 When we reach a safe place, assume that's not in a string;
1141 then step the main scan to the earliest comment-starter seen
1142 an even number of string quotes away from the safe place.
1144 OFROM[I] is position of the earliest comment-starter seen
1145 which is I+2X quotes from the comment-end.
1146 PARITY is current parity of quotes from the comment end. */
1149 char my_stringend
= 0;
1150 int string_lossage
= 0;
1151 int comment_end
= from
;
1152 int comstart_pos
= 0;
1153 int comstart_parity
= 0;
1154 int scanstart
= from
- 1;
1156 /* At beginning of range to scan, we're outside of strings;
1157 that determines quote parity to the comment-end. */
1158 while (from
!= stop
)
1160 /* Move back and examine a character. */
1163 c
= FETCH_CHAR (from
);
1166 /* If this char is the second of a 2-char comment sequence,
1167 back up and give the pair the appropriate syntax. */
1168 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1169 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from
- 1)))
1173 c
= FETCH_CHAR (from
);
1176 /* If this char starts a 2-char comment start sequence,
1177 treat it like a 1-char comment starter. */
1178 if (from
< scanstart
&& SYNTAX_COMSTART_FIRST (c
)
1179 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
+ 1))
1180 && comstyle
== SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
+ 1)))
1183 /* Ignore escaped characters. */
1184 if (char_quoted (from
))
1187 /* Track parity of quotes. */
1188 if (code
== Sstring
)
1191 if (my_stringend
== 0)
1193 /* If we have two kinds of string delimiters.
1194 There's no way to grok this scanning backwards. */
1195 else if (my_stringend
!= c
)
1199 /* Record comment-starters according to that
1200 quote-parity to the comment-end. */
1201 if (code
== Scomment
)
1203 comstart_parity
= parity
;
1204 comstart_pos
= from
;
1207 /* If we find another earlier comment-ender,
1208 any comment-starts earlier than that don't count
1209 (because they go with the earlier comment-ender). */
1210 if (code
== Sendcomment
1211 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
)) == comstyle
)
1214 /* Assume a defun-start point is outside of strings. */
1216 && (from
== stop
|| FETCH_CHAR (from
- 1) == '\n'))
1220 if (comstart_pos
== 0)
1222 /* If the earliest comment starter
1223 is followed by uniform paired string quotes or none,
1224 we know it can't be inside a string
1225 since if it were then the comment ender would be inside one.
1226 So it does start a comment. Skip back to it. */
1227 else if (comstart_parity
== 0 && !string_lossage
)
1228 from
= comstart_pos
;
1231 /* We had two kinds of string delimiters mixed up
1232 together. Decode this going forwards.
1233 Scan fwd from the previous comment ender
1234 to the one in question; this records where we
1235 last passed a comment starter. */
1236 struct lisp_parse_state state
;
1237 scan_sexps_forward (&state
, find_defun_start (comment_end
),
1238 comment_end
- 1, -10000, 0, Qnil
, 0);
1239 if (state
.incomment
)
1240 from
= state
.comstart
;
1242 /* We can't grok this as a comment; scan it normally. */
1249 stringterm
= FETCH_CHAR (from
);
1252 if (from
== stop
) goto lose
;
1253 if (!char_quoted (from
- 1)
1254 && stringterm
== FETCH_CHAR (from
- 1))
1259 if (!depth
&& sexpflag
) goto done2
;
1264 /* Reached start of buffer. Error if within object, return nil if between */
1265 if (depth
) goto lose
;
1276 XSETFASTINT (val
, from
);
1280 error ("Unbalanced parentheses");
1288 register enum syntaxcode code
;
1289 register int beg
= BEGV
;
1290 register int quoted
= 0;
1293 && ((code
= SYNTAX (FETCH_CHAR (pos
- 1))) == Scharquote
1294 || code
== Sescape
))
1295 pos
--, quoted
= !quoted
;
1299 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
1300 "Scan from character number FROM by COUNT lists.\n\
1301 Returns the character number of the position thus found.\n\
1303 If DEPTH is nonzero, paren depth begins counting from that value,\n\
1304 only places where the depth in parentheses becomes zero\n\
1305 are candidates for stopping; COUNT such places are counted.\n\
1306 Thus, a positive value for DEPTH means go out levels.\n\
1308 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
1310 If the beginning or end of (the accessible part of) the buffer is reached\n\
1311 and the depth is wrong, an error is signaled.\n\
1312 If the depth is right but the count is not used up, nil is returned.")
1313 (from
, count
, depth
)
1314 Lisp_Object from
, count
, depth
;
1316 CHECK_NUMBER (from
, 0);
1317 CHECK_NUMBER (count
, 1);
1318 CHECK_NUMBER (depth
, 2);
1320 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
1323 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
1324 "Scan from character number FROM by COUNT balanced expressions.\n\
1325 If COUNT is negative, scan backwards.\n\
1326 Returns the character number of the position thus found.\n\
1328 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
1330 If the beginning or end of (the accessible part of) the buffer is reached\n\
1331 in the middle of a parenthetical grouping, an error is signaled.\n\
1332 If the beginning or end is reached between groupings\n\
1333 but before count is used up, nil is returned.")
1335 Lisp_Object from
, count
;
1337 CHECK_NUMBER (from
, 0);
1338 CHECK_NUMBER (count
, 1);
1340 return scan_lists (XINT (from
), XINT (count
), 0, 1);
1343 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
1345 "Move point backward over any number of chars with prefix syntax.\n\
1346 This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
1352 while (pos
> beg
&& !char_quoted (pos
- 1)
1353 && (SYNTAX (FETCH_CHAR (pos
- 1)) == Squote
1354 || SYNTAX_PREFIX (FETCH_CHAR (pos
- 1))))
1362 /* Parse forward from FROM to END,
1363 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
1364 and return a description of the state of the parse at END.
1365 If STOPBEFORE is nonzero, stop at the start of an atom.
1366 If COMMENTSTOP is nonzero, stop at the start of a comment. */
1369 scan_sexps_forward (stateptr
, from
, end
, targetdepth
,
1370 stopbefore
, oldstate
, commentstop
)
1371 struct lisp_parse_state
*stateptr
;
1373 int end
, targetdepth
, stopbefore
;
1374 Lisp_Object oldstate
;
1377 struct lisp_parse_state state
;
1379 register enum syntaxcode code
;
1380 struct level
{ int last
, prev
; };
1381 struct level levelstart
[100];
1382 register struct level
*curlevel
= levelstart
;
1383 struct level
*endlevel
= levelstart
+ 100;
1385 register int depth
; /* Paren depth of current scanning location.
1386 level - levelstart equals this except
1387 when the depth becomes negative. */
1388 int mindepth
; /* Lowest DEPTH value seen. */
1389 int start_quoted
= 0; /* Nonzero means starting after a char quote */
1395 if (NILP (oldstate
))
1398 state
.instring
= -1;
1399 state
.incomment
= 0;
1400 state
.comstyle
= 0; /* comment style a by default */
1404 tem
= Fcar (oldstate
);
1410 oldstate
= Fcdr (oldstate
);
1411 oldstate
= Fcdr (oldstate
);
1412 oldstate
= Fcdr (oldstate
);
1413 tem
= Fcar (oldstate
);
1414 state
.instring
= !NILP (tem
) ? XINT (tem
) : -1;
1416 oldstate
= Fcdr (oldstate
);
1417 tem
= Fcar (oldstate
);
1418 state
.incomment
= !NILP (tem
);
1420 oldstate
= Fcdr (oldstate
);
1421 tem
= Fcar (oldstate
);
1422 start_quoted
= !NILP (tem
);
1424 /* if the eight element of the list is nil, we are in comment
1425 style a. if it is non-nil, we are in comment style b */
1426 oldstate
= Fcdr (oldstate
);
1427 oldstate
= Fcdr (oldstate
);
1428 tem
= Fcar (oldstate
);
1429 state
.comstyle
= !NILP (tem
);
1434 curlevel
->prev
= -1;
1435 curlevel
->last
= -1;
1437 /* Enter the loop at a place appropriate for initial state. */
1439 if (state
.incomment
) goto startincomment
;
1440 if (state
.instring
>= 0)
1442 if (start_quoted
) goto startquotedinstring
;
1445 if (start_quoted
) goto startquoted
;
1449 code
= SYNTAX (FETCH_CHAR (from
));
1451 if (code
== Scomment
)
1452 state
.comstart
= from
-1;
1454 else if (from
< end
&& SYNTAX_COMSTART_FIRST (FETCH_CHAR (from
- 1))
1455 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
)))
1457 /* Record the comment style we have entered so that only
1458 the comment-end sequence of the same style actually
1459 terminates the comment section. */
1461 state
.comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
));
1462 state
.comstart
= from
-1;
1466 if (SYNTAX_PREFIX (FETCH_CHAR (from
- 1)))
1468 #ifdef SWITCH_ENUM_BUG
1476 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
1477 curlevel
->last
= from
- 1;
1479 if (from
== end
) goto endquoted
;
1482 /* treat following character as a word constituent */
1485 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
1486 curlevel
->last
= from
- 1;
1490 #ifdef SWITCH_ENUM_BUG
1491 switch ((int) SYNTAX (FETCH_CHAR (from
)))
1493 switch (SYNTAX (FETCH_CHAR (from
)))
1499 if (from
== end
) goto endquoted
;
1511 curlevel
->prev
= curlevel
->last
;
1519 /* Enter the loop in the middle so that we find
1520 a 2-char comment ender if we start in the middle of it. */
1521 prev
= FETCH_CHAR (from
- 1);
1522 goto startincomment_1
;
1524 /* At beginning of buffer, enter the loop the ordinary way. */
1527 state
.incomment
= 1;
1532 if (from
== end
) goto done
;
1533 prev
= FETCH_CHAR (from
);
1534 if (SYNTAX (prev
) == Sendcomment
1535 && SYNTAX_COMMENT_STYLE (prev
) == state
.comstyle
)
1536 /* Only terminate the comment section if the endcomment
1537 of the same style as the start sequence has been
1542 if (from
< end
&& SYNTAX_COMEND_FIRST (prev
)
1543 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from
))
1544 && SYNTAX_COMMENT_STYLE (prev
) == state
.comstyle
)
1545 /* Only terminate the comment section if the end-comment
1546 sequence of the same style as the start sequence has
1547 been encountered. */
1550 state
.incomment
= 0;
1551 state
.comstyle
= 0; /* reset the comment style */
1555 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
1557 /* curlevel++->last ran into compiler bug on Apollo */
1558 curlevel
->last
= from
- 1;
1559 if (++curlevel
== endlevel
)
1560 error ("Nesting too deep for parser");
1561 curlevel
->prev
= -1;
1562 curlevel
->last
= -1;
1563 if (!--targetdepth
) goto done
;
1568 if (depth
< mindepth
)
1570 if (curlevel
!= levelstart
)
1572 curlevel
->prev
= curlevel
->last
;
1573 if (!++targetdepth
) goto done
;
1577 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
1578 curlevel
->last
= from
- 1;
1579 state
.instring
= FETCH_CHAR (from
- 1);
1583 if (from
>= end
) goto done
;
1584 if (FETCH_CHAR (from
) == state
.instring
) break;
1585 #ifdef SWITCH_ENUM_BUG
1586 switch ((int) SYNTAX (FETCH_CHAR (from
)))
1588 switch (SYNTAX (FETCH_CHAR (from
)))
1594 startquotedinstring
:
1595 if (from
>= end
) goto endquoted
;
1599 state
.instring
= -1;
1600 curlevel
->prev
= curlevel
->last
;
1610 stop
: /* Here if stopping before start of sexp. */
1611 from
--; /* We have just fetched the char that starts it; */
1612 goto done
; /* but return the position before it. */
1617 state
.depth
= depth
;
1618 state
.mindepth
= mindepth
;
1619 state
.thislevelstart
= curlevel
->prev
;
1620 state
.prevlevelstart
1621 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
1622 state
.location
= from
;
1628 /* This comment supplies the doc string for parse-partial-sexp,
1629 for make-docfile to see. We cannot put this in the real DEFUN
1630 due to limits in the Unix cpp.
1632 DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 6, 0,
1633 "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
1634 Parsing stops at TO or when certain criteria are met;\n\
1635 point is set to where parsing stops.\n\
1636 If fifth arg STATE is omitted or nil,\n\
1637 parsing assumes that FROM is the beginning of a function.\n\
1638 Value is a list of eight elements describing final state of parsing:\n\
1639 0. depth in parens.\n\
1640 1. character address of start of innermost containing list; nil if none.\n\
1641 2. character address of start of last complete sexp terminated.\n\
1642 3. non-nil if inside a string.\n\
1643 (it is the character that will terminate the string.)\n\
1644 4. t if inside a comment.\n\
1645 5. t if following a quote character.\n\
1646 6. the minimum paren-depth encountered during this scan.\n\
1647 7. t if in a comment of style `b'.\n\
1648 If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
1649 in parentheses becomes equal to TARGETDEPTH.\n\
1650 Fourth arg STOPBEFORE non-nil means stop when come to\n\
1651 any character that starts a sexp.\n\
1652 Fifth arg STATE is an eight-list like what this function returns.\n\
1653 It is used to initialize the state of the parse. Its second and third
1654 elements are ignored.
1655 Sixth args COMMENTSTOP non-nil means stop at the start of a comment.")
1656 (from, to, targetdepth, stopbefore, state, commentstop)
1659 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
1660 0 /* See immediately above */)
1661 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
1662 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
1664 struct lisp_parse_state state
;
1667 if (!NILP (targetdepth
))
1669 CHECK_NUMBER (targetdepth
, 3);
1670 target
= XINT (targetdepth
);
1673 target
= -100000; /* We won't reach this depth */
1675 validate_region (&from
, &to
);
1676 scan_sexps_forward (&state
, XINT (from
), XINT (to
),
1677 target
, !NILP (stopbefore
), oldstate
,
1678 !NILP (commentstop
));
1680 SET_PT (state
.location
);
1682 return Fcons (make_number (state
.depth
),
1683 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
1684 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
1685 Fcons (state
.instring
>= 0 ? make_number (state
.instring
) : Qnil
,
1686 Fcons (state
.incomment
? Qt
: Qnil
,
1687 Fcons (state
.quoted
? Qt
: Qnil
,
1688 Fcons (make_number (state
.mindepth
),
1689 Fcons (state
.comstyle
? Qt
: Qnil
,
1696 register struct Lisp_Vector
*v
;
1698 /* Set this now, so first buffer creation can refer to it. */
1699 /* Make it nil before calling copy-syntax-table
1700 so that copy-syntax-table will know not to try to copy from garbage */
1701 Vstandard_syntax_table
= Qnil
;
1702 Vstandard_syntax_table
= Fcopy_syntax_table (Qnil
);
1704 v
= XVECTOR (Vstandard_syntax_table
);
1706 for (i
= 'a'; i
<= 'z'; i
++)
1707 XSETFASTINT (v
->contents
[i
], (int) Sword
);
1708 for (i
= 'A'; i
<= 'Z'; i
++)
1709 XSETFASTINT (v
->contents
[i
], (int) Sword
);
1710 for (i
= '0'; i
<= '9'; i
++)
1711 XSETFASTINT (v
->contents
[i
], (int) Sword
);
1712 XSETFASTINT (v
->contents
['$'], (int) Sword
);
1713 XSETFASTINT (v
->contents
['%'], (int) Sword
);
1715 XSETFASTINT (v
->contents
['('], (int) Sopen
+ (')' << 8));
1716 XSETFASTINT (v
->contents
[')'], (int) Sclose
+ ('(' << 8));
1717 XSETFASTINT (v
->contents
['['], (int) Sopen
+ (']' << 8));
1718 XSETFASTINT (v
->contents
[']'], (int) Sclose
+ ('[' << 8));
1719 XSETFASTINT (v
->contents
['{'], (int) Sopen
+ ('}' << 8));
1720 XSETFASTINT (v
->contents
['}'], (int) Sclose
+ ('{' << 8));
1721 XSETFASTINT (v
->contents
['"'], (int) Sstring
);
1722 XSETFASTINT (v
->contents
['\\'], (int) Sescape
);
1724 for (i
= 0; i
< 10; i
++)
1725 XSETFASTINT (v
->contents
["_-+*/&|<>="[i
]], (int) Ssymbol
);
1727 for (i
= 0; i
< 12; i
++)
1728 XSETFASTINT (v
->contents
[".,;:?!#@~^'`"[i
]], (int) Spunct
);
1733 Qsyntax_table_p
= intern ("syntax-table-p");
1734 staticpro (&Qsyntax_table_p
);
1736 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
1737 "Non-nil means `forward-sexp', etc., should treat comments as whitespace.");
1739 words_include_escapes
= 0;
1740 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
1741 "Non-nil means `forward-word', etc., should treat escape chars part of words.");
1743 defsubr (&Ssyntax_table_p
);
1744 defsubr (&Ssyntax_table
);
1745 defsubr (&Sstandard_syntax_table
);
1746 defsubr (&Scopy_syntax_table
);
1747 defsubr (&Sset_syntax_table
);
1748 defsubr (&Schar_syntax
);
1749 defsubr (&Smatching_paren
);
1750 defsubr (&Smodify_syntax_entry
);
1751 defsubr (&Sdescribe_syntax
);
1753 defsubr (&Sforward_word
);
1755 defsubr (&Sforward_comment
);
1756 defsubr (&Sscan_lists
);
1757 defsubr (&Sscan_sexps
);
1758 defsubr (&Sbackward_prefix_chars
);
1759 defsubr (&Sparse_partial_sexp
);