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
, -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
, -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 XFASTINT (size
) = 0400;
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 XFASTINT (val
) = (match
<< 8) + (int) code
;
317 XFASTINT (val
) |= 1 << 16;
321 XFASTINT (val
) |= 1 << 17;
325 XFASTINT (val
) |= 1 << 18;
329 XFASTINT (val
) |= 1 << 19;
333 XFASTINT (val
) |= 1 << 20;
337 XFASTINT (val
) |= 1 << 21;
341 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 XFASTINT (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
;
1515 state
.incomment
= 1;
1521 if (from
== end
) goto done
;
1522 prev
= FETCH_CHAR (from
);
1523 if (SYNTAX (prev
) == Sendcomment
1524 && SYNTAX_COMMENT_STYLE (prev
) == state
.comstyle
)
1525 /* Only terminate the comment section if the endcomment
1526 of the same style as the start sequence has been
1530 if (from
< end
&& SYNTAX_COMEND_FIRST (prev
)
1531 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from
))
1532 && SYNTAX_COMMENT_STYLE (prev
) == state
.comstyle
)
1533 /* Only terminate the comment section if the end-comment
1534 sequence of the same style as the start sequence has
1535 been encountered. */
1538 state
.incomment
= 0;
1539 state
.comstyle
= 0; /* reset the comment style */
1543 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
1545 /* curlevel++->last ran into compiler bug on Apollo */
1546 curlevel
->last
= from
- 1;
1547 if (++curlevel
== endlevel
)
1548 error ("Nesting too deep for parser");
1549 curlevel
->prev
= -1;
1550 curlevel
->last
= -1;
1551 if (!--targetdepth
) goto done
;
1556 if (depth
< mindepth
)
1558 if (curlevel
!= levelstart
)
1560 curlevel
->prev
= curlevel
->last
;
1561 if (!++targetdepth
) goto done
;
1565 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
1566 curlevel
->last
= from
- 1;
1567 state
.instring
= FETCH_CHAR (from
- 1);
1571 if (from
>= end
) goto done
;
1572 if (FETCH_CHAR (from
) == state
.instring
) break;
1573 #ifdef SWITCH_ENUM_BUG
1574 switch ((int) SYNTAX (FETCH_CHAR (from
)))
1576 switch (SYNTAX (FETCH_CHAR (from
)))
1582 startquotedinstring
:
1583 if (from
>= end
) goto endquoted
;
1587 state
.instring
= -1;
1588 curlevel
->prev
= curlevel
->last
;
1598 stop
: /* Here if stopping before start of sexp. */
1599 from
--; /* We have just fetched the char that starts it; */
1600 goto done
; /* but return the position before it. */
1605 state
.depth
= depth
;
1606 state
.mindepth
= mindepth
;
1607 state
.thislevelstart
= curlevel
->prev
;
1608 state
.prevlevelstart
1609 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
1610 state
.location
= from
;
1616 /* This comment supplies the doc string for parse-partial-sexp,
1617 for make-docfile to see. We cannot put this in the real DEFUN
1618 due to limits in the Unix cpp.
1620 DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 6, 0,
1621 "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
1622 Parsing stops at TO or when certain criteria are met;\n\
1623 point is set to where parsing stops.\n\
1624 If fifth arg STATE is omitted or nil,\n\
1625 parsing assumes that FROM is the beginning of a function.\n\
1626 Value is a list of eight elements describing final state of parsing:\n\
1627 0. depth in parens.\n\
1628 1. character address of start of innermost containing list; nil if none.\n\
1629 2. character address of start of last complete sexp terminated.\n\
1630 3. non-nil if inside a string.\n\
1631 (it is the character that will terminate the string.)\n\
1632 4. t if inside a comment.\n\
1633 5. t if following a quote character.\n\
1634 6. the minimum paren-depth encountered during this scan.\n\
1635 7. t if in a comment of style `b'.\n\
1636 If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
1637 in parentheses becomes equal to TARGETDEPTH.\n\
1638 Fourth arg STOPBEFORE non-nil means stop when come to\n\
1639 any character that starts a sexp.\n\
1640 Fifth arg STATE is an eight-list like what this function returns.\n\
1641 It is used to initialize the state of the parse. Its second and third
1642 elements are ignored.
1643 Sixth args COMMENTSTOP non-nil means stop at the start of a comment.")
1644 (from, to, targetdepth, stopbefore, state, commentstop)
1647 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
1648 0 /* See immediately above */)
1649 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
1650 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
1652 struct lisp_parse_state state
;
1655 if (!NILP (targetdepth
))
1657 CHECK_NUMBER (targetdepth
, 3);
1658 target
= XINT (targetdepth
);
1661 target
= -100000; /* We won't reach this depth */
1663 validate_region (&from
, &to
);
1664 scan_sexps_forward (&state
, XINT (from
), XINT (to
),
1665 target
, !NILP (stopbefore
), oldstate
,
1666 !NILP (commentstop
));
1668 SET_PT (state
.location
);
1670 return Fcons (make_number (state
.depth
),
1671 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
1672 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
1673 Fcons (state
.instring
>= 0 ? make_number (state
.instring
) : Qnil
,
1674 Fcons (state
.incomment
? Qt
: Qnil
,
1675 Fcons (state
.quoted
? Qt
: Qnil
,
1676 Fcons (make_number (state
.mindepth
),
1677 Fcons (state
.comstyle
? Qt
: Qnil
,
1684 register struct Lisp_Vector
*v
;
1686 /* Set this now, so first buffer creation can refer to it. */
1687 /* Make it nil before calling copy-syntax-table
1688 so that copy-syntax-table will know not to try to copy from garbage */
1689 Vstandard_syntax_table
= Qnil
;
1690 Vstandard_syntax_table
= Fcopy_syntax_table (Qnil
);
1692 v
= XVECTOR (Vstandard_syntax_table
);
1694 for (i
= 'a'; i
<= 'z'; i
++)
1695 XFASTINT (v
->contents
[i
]) = (int) Sword
;
1696 for (i
= 'A'; i
<= 'Z'; i
++)
1697 XFASTINT (v
->contents
[i
]) = (int) Sword
;
1698 for (i
= '0'; i
<= '9'; i
++)
1699 XFASTINT (v
->contents
[i
]) = (int) Sword
;
1700 XFASTINT (v
->contents
['$']) = (int) Sword
;
1701 XFASTINT (v
->contents
['%']) = (int) Sword
;
1703 XFASTINT (v
->contents
['(']) = (int) Sopen
+ (')' << 8);
1704 XFASTINT (v
->contents
[')']) = (int) Sclose
+ ('(' << 8);
1705 XFASTINT (v
->contents
['[']) = (int) Sopen
+ (']' << 8);
1706 XFASTINT (v
->contents
[']']) = (int) Sclose
+ ('[' << 8);
1707 XFASTINT (v
->contents
['{']) = (int) Sopen
+ ('}' << 8);
1708 XFASTINT (v
->contents
['}']) = (int) Sclose
+ ('{' << 8);
1709 XFASTINT (v
->contents
['"']) = (int) Sstring
;
1710 XFASTINT (v
->contents
['\\']) = (int) Sescape
;
1712 for (i
= 0; i
< 10; i
++)
1713 XFASTINT (v
->contents
["_-+*/&|<>="[i
]]) = (int) Ssymbol
;
1715 for (i
= 0; i
< 12; i
++)
1716 XFASTINT (v
->contents
[".,;:?!#@~^'`"[i
]]) = (int) Spunct
;
1721 Qsyntax_table_p
= intern ("syntax-table-p");
1722 staticpro (&Qsyntax_table_p
);
1724 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
1725 "Non-nil means `forward-sexp', etc., should treat comments as whitespace.");
1727 words_include_escapes
= 0;
1728 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
1729 "Non-nil means `forward-word', etc., should treat escape chars part of words.");
1731 defsubr (&Ssyntax_table_p
);
1732 defsubr (&Ssyntax_table
);
1733 defsubr (&Sstandard_syntax_table
);
1734 defsubr (&Scopy_syntax_table
);
1735 defsubr (&Sset_syntax_table
);
1736 defsubr (&Schar_syntax
);
1737 defsubr (&Smatching_paren
);
1738 defsubr (&Smodify_syntax_entry
);
1739 defsubr (&Sdescribe_syntax
);
1741 defsubr (&Sforward_word
);
1743 defsubr (&Sforward_comment
);
1744 defsubr (&Sscan_lists
);
1745 defsubr (&Sscan_sexps
);
1746 defsubr (&Sbackward_prefix_chars
);
1747 defsubr (&Sparse_partial_sexp
);