1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 87, 93, 94, 95, 97, 1998, 1999 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, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
29 /* Make syntax table lookup grant data in gl_state. */
30 #define SYNTAX_ENTRY_VIA_PROPERTY
33 #include "intervals.h"
35 /* We use these constants in place for comment-style and
36 string-ender-char to distinguish comments/strings started by
37 comment_fence and string_fence codes. */
39 #define ST_COMMENT_STYLE (256 + 1)
40 #define ST_STRING_STYLE (256 + 2)
43 Lisp_Object Qsyntax_table_p
, Qsyntax_table
, Qscan_error
;
45 int words_include_escapes
;
46 int parse_sexp_lookup_properties
;
48 /* Used as a temporary in SYNTAX_ENTRY and other macros in syntax.h,
49 if not compiled with GCC. No need to mark it, since it is used
50 only very temporarily. */
51 Lisp_Object syntax_temp
;
53 /* This is the internal form of the parse state used in parse-partial-sexp. */
55 struct lisp_parse_state
57 int depth
; /* Depth at end of parsing. */
58 int instring
; /* -1 if not within string, else desired terminator. */
59 int incomment
; /* -1 if in unnestable comment else comment nesting */
60 int comstyle
; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
61 int quoted
; /* Nonzero if just after an escape char at end of parsing */
62 int thislevelstart
; /* Char number of most recent start-of-expression at current level */
63 int prevlevelstart
; /* Char number of start of containing expression */
64 int location
; /* Char number at which parsing stopped. */
65 int mindepth
; /* Minimum depth seen while scanning. */
66 int comstr_start
; /* Position just after last comment/string starter. */
67 Lisp_Object levelstarts
; /* Char numbers of starts-of-expression
68 of levels (starting from outermost). */
71 /* These variables are a cache for finding the start of a defun.
72 find_start_pos is the place for which the defun start was found.
73 find_start_value is the defun start position found for it.
74 find_start_value_byte is the corresponding byte position.
75 find_start_buffer is the buffer it was found in.
76 find_start_begv is the BEGV value when it was found.
77 find_start_modiff is the value of MODIFF when it was found. */
79 static int find_start_pos
;
80 static int find_start_value
;
81 static int find_start_value_byte
;
82 static struct buffer
*find_start_buffer
;
83 static int find_start_begv
;
84 static int find_start_modiff
;
87 static int find_defun_start
P_ ((int, int));
88 static int back_comment
P_ ((int, int, int, int, int, int *, int *));
89 static int char_quoted
P_ ((int, int));
90 static Lisp_Object skip_chars
P_ ((int, int, Lisp_Object
, Lisp_Object
));
91 static Lisp_Object scan_lists
P_ ((int, int, int, int));
92 static void scan_sexps_forward
P_ ((struct lisp_parse_state
*,
94 int, Lisp_Object
, int));
97 struct gl_state_s gl_state
; /* Global state of syntax parser. */
99 INTERVAL
interval_of ();
100 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
101 to scan to property-change. */
103 /* Update gl_state to an appropriate interval which contains CHARPOS. The
104 sign of COUNT give the relative position of CHARPOS wrt the previously
105 valid interval. If INIT, only [be]_property fields of gl_state are
106 valid at start, the rest is filled basing on OBJECT.
108 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
109 direction than the intervals - or in an interval. We update the
110 current syntax-table basing on the property of this interval, and
111 update the interval to start further than CHARPOS - or be
112 NULL_INTERVAL. We also update lim_property to be the next value of
113 charpos to call this subroutine again - or be before/after the
114 start/end of OBJECT. */
117 update_syntax_table (charpos
, count
, init
, object
)
118 int charpos
, count
, init
;
121 Lisp_Object tmp_table
;
122 int cnt
= 0, invalidate
= 1;
127 gl_state
.start
= gl_state
.b_property
;
128 gl_state
.stop
= gl_state
.e_property
;
129 gl_state
.forward_i
= interval_of (charpos
, object
);
130 i
= gl_state
.backward_i
= gl_state
.forward_i
;
131 gl_state
.left_ok
= gl_state
.right_ok
= 1;
133 if (NULL_INTERVAL_P (i
))
135 /* interval_of updates only ->position of the return value, so
136 update the parents manually to speed up update_interval. */
137 while (!NULL_PARENT (i
))
139 if (AM_RIGHT_CHILD (i
))
140 i
->parent
->position
= i
->position
141 - LEFT_TOTAL_LENGTH (i
) + TOTAL_LENGTH (i
) /* right end */
142 - TOTAL_LENGTH (i
->parent
)
143 + LEFT_TOTAL_LENGTH (i
->parent
);
145 i
->parent
->position
= i
->position
- LEFT_TOTAL_LENGTH (i
)
149 i
= gl_state
.forward_i
;
150 gl_state
.b_property
= i
->position
- 1 - gl_state
.offset
;
151 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
154 oldi
= i
= count
> 0 ? gl_state
.forward_i
: gl_state
.backward_i
;
156 /* We are guarantied to be called with CHARPOS either in i,
158 if (NULL_INTERVAL_P (i
))
159 error ("Error in syntax_table logic for to-the-end intervals");
160 else if (charpos
< i
->position
) /* Move left. */
163 error ("Error in syntax_table logic for intervals <-");
164 /* Update the interval. */
165 i
= update_interval (i
, charpos
);
166 if (oldi
->position
!= INTERVAL_LAST_POS (i
))
169 gl_state
.right_ok
= 1; /* Invalidate the other end. */
170 gl_state
.forward_i
= i
;
171 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
174 else if (charpos
>= INTERVAL_LAST_POS (i
)) /* Move right. */
177 error ("Error in syntax_table logic for intervals ->");
178 /* Update the interval. */
179 i
= update_interval (i
, charpos
);
180 if (i
->position
!= INTERVAL_LAST_POS (oldi
))
183 gl_state
.left_ok
= 1; /* Invalidate the other end. */
184 gl_state
.backward_i
= i
;
185 gl_state
.b_property
= i
->position
- 1 - gl_state
.offset
;
188 else if (count
> 0 ? gl_state
.right_ok
: gl_state
.left_ok
)
190 /* We do not need to recalculate tmp_table. */
191 tmp_table
= gl_state
.old_prop
;
195 tmp_table
= textget (i
->plist
, Qsyntax_table
);
198 invalidate
= !EQ (tmp_table
, gl_state
.old_prop
); /* Need to invalidate? */
200 if (invalidate
) /* Did not get to adjacent interval. */
201 { /* with the same table => */
202 /* invalidate the old range. */
205 gl_state
.backward_i
= i
;
206 gl_state
.left_ok
= 1; /* Invalidate the other end. */
207 gl_state
.b_property
= i
->position
- 1 - gl_state
.offset
;
211 gl_state
.forward_i
= i
;
212 gl_state
.right_ok
= 1; /* Invalidate the other end. */
213 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
217 gl_state
.current_syntax_table
= tmp_table
;
218 gl_state
.old_prop
= tmp_table
;
219 if (EQ (Fsyntax_table_p (tmp_table
), Qt
))
221 gl_state
.use_global
= 0;
223 else if (CONSP (tmp_table
))
225 gl_state
.use_global
= 1;
226 gl_state
.global_code
= tmp_table
;
230 gl_state
.use_global
= 0;
231 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
234 while (!NULL_INTERVAL_P (i
))
236 if (cnt
&& !EQ (tmp_table
, textget (i
->plist
, Qsyntax_table
)))
239 gl_state
.right_ok
= 0;
241 gl_state
.left_ok
= 0;
244 else if (cnt
== INTERVALS_AT_ONCE
)
247 gl_state
.right_ok
= 1;
249 gl_state
.left_ok
= 1;
253 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
255 if (NULL_INTERVAL_P (i
))
256 { /* This property goes to the end. */
258 gl_state
.e_property
= gl_state
.stop
;
260 gl_state
.b_property
= gl_state
.start
;
266 gl_state
.e_property
= i
->position
- gl_state
.offset
;
267 gl_state
.forward_i
= i
;
271 gl_state
.b_property
= i
->position
+ LENGTH (i
) - 1 - gl_state
.offset
;
272 gl_state
.backward_i
= i
;
277 /* Returns TRUE if char at CHARPOS is quoted.
278 Global syntax-table data should be set up already to be good at CHARPOS
279 or after. On return global syntax data is good for lookup at CHARPOS. */
282 char_quoted (charpos
, bytepos
)
283 register int charpos
, bytepos
;
285 register enum syntaxcode code
;
286 register int beg
= BEGV
;
287 register int quoted
= 0;
290 DEC_BOTH (charpos
, bytepos
);
292 while (bytepos
>= beg
)
294 UPDATE_SYNTAX_TABLE_BACKWARD (charpos
);
295 code
= SYNTAX (FETCH_CHAR (bytepos
));
296 if (! (code
== Scharquote
|| code
== Sescape
))
299 DEC_BOTH (charpos
, bytepos
);
303 UPDATE_SYNTAX_TABLE (orig
);
307 /* Return the bytepos one character after BYTEPOS.
308 We assume that BYTEPOS is not at the end of the buffer. */
311 inc_bytepos (bytepos
)
314 if (NILP (current_buffer
->enable_multibyte_characters
))
321 /* Return the bytepos one character before BYTEPOS.
322 We assume that BYTEPOS is not at the start of the buffer. */
325 dec_bytepos (bytepos
)
328 if (NILP (current_buffer
->enable_multibyte_characters
))
335 /* Find a defun-start that is the last one before POS (or nearly the last).
336 We record what we find, so that another call in the same area
337 can return the same value right away.
339 There is no promise at which position the global syntax data is
340 valid on return from the subroutine, so the caller should explicitly
341 update the global data. */
344 find_defun_start (pos
, pos_byte
)
347 int opoint
= PT
, opoint_byte
= PT_BYTE
;
349 /* Use previous finding, if it's valid and applies to this inquiry. */
350 if (current_buffer
== find_start_buffer
351 /* Reuse the defun-start even if POS is a little farther on.
352 POS might be in the next defun, but that's ok.
353 Our value may not be the best possible, but will still be usable. */
354 && pos
<= find_start_pos
+ 1000
355 && pos
>= find_start_value
356 && BEGV
== find_start_begv
357 && MODIFF
== find_start_modiff
)
358 return find_start_value
;
360 /* Back up to start of line. */
361 scan_newline (pos
, pos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
363 /* We optimize syntax-table lookup for rare updates. Thus we accept
364 only those `^\s(' which are good in global _and_ text-property
366 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
367 gl_state
.use_global
= 0;
370 /* Open-paren at start of line means we found our defun-start. */
371 if (SYNTAX (FETCH_CHAR (PT_BYTE
)) == Sopen
)
373 SETUP_SYNTAX_TABLE (PT
+ 1, -1); /* Try again... */
374 if (SYNTAX (FETCH_CHAR (PT_BYTE
)) == Sopen
)
376 /* Now fallback to the default value. */
377 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
378 gl_state
.use_global
= 0;
380 /* Move to beg of previous line. */
381 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -2, 1);
384 /* Record what we found, for the next try. */
385 find_start_value
= PT
;
386 find_start_value_byte
= PT_BYTE
;
387 find_start_buffer
= current_buffer
;
388 find_start_modiff
= MODIFF
;
389 find_start_begv
= BEGV
;
390 find_start_pos
= pos
;
392 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
394 return find_start_value
;
397 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
400 prev_char_comend_first (pos
, pos_byte
)
405 DEC_BOTH (pos
, pos_byte
);
406 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
407 c
= FETCH_CHAR (pos_byte
);
408 val
= SYNTAX_COMEND_FIRST (c
);
409 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
413 /* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
416 prev_char_comstart_first (pos
, pos_byte
)
421 DEC_BOTH (pos
, pos_byte
);
422 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
423 c
= FETCH_CHAR (pos_byte
);
424 val
= SYNTAX_COMSTART_FIRST (c
);
425 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
429 /* Checks whether charpos FROM is at the end of a comment.
430 FROM_BYTE is the bytepos corresponding to FROM.
431 Do not move back before STOP.
433 Return a positive value if we find a comment ending at FROM/FROM_BYTE;
436 If successful, store the charpos of the comment's beginning
437 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
439 Global syntax data remains valid for backward search starting at
440 the returned value (or at FROM, if the search was not successful). */
443 back_comment (from
, from_byte
, stop
, comnested
, comstyle
, charpos_ptr
, bytepos_ptr
)
444 int from
, from_byte
, stop
;
445 int comnested
, comstyle
;
446 int *charpos_ptr
, *bytepos_ptr
;
448 /* Look back, counting the parity of string-quotes,
449 and recording the comment-starters seen.
450 When we reach a safe place, assume that's not in a string;
451 then step the main scan to the earliest comment-starter seen
452 an even number of string quotes away from the safe place.
454 OFROM[I] is position of the earliest comment-starter seen
455 which is I+2X quotes from the comment-end.
456 PARITY is current parity of quotes from the comment end. */
458 int my_stringend
= 0;
459 int string_lossage
= 0;
460 int comment_end
= from
;
461 int comment_end_byte
= from_byte
;
462 int comstart_pos
= 0;
464 /* Value that PARITY had, when we reached the position
466 int comstart_parity
= 0;
467 int scanstart
= from
- 1;
468 /* Place where the containing defun starts,
469 or 0 if we didn't come across it yet. */
471 int defun_start_byte
= 0;
472 register enum syntaxcode code
;
473 int nesting
= 1; /* current comment nesting */
476 /* At beginning of range to scan, we're outside of strings;
477 that determines quote parity to the comment-end. */
482 /* Move back and examine a character. */
483 DEC_BOTH (from
, from_byte
);
484 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
486 c
= FETCH_CHAR (from_byte
);
489 /* If this char is the second of a 2-char comment end sequence,
490 back up and give the pair the appropriate syntax. */
491 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
492 && prev_char_comend_first (from
, from_byte
))
495 DEC_BOTH (from
, from_byte
);
496 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
497 c
= FETCH_CHAR (from_byte
);
500 /* If this char starts a 2-char comment start sequence,
501 treat it like a 1-char comment starter. */
502 if (from
< scanstart
&& SYNTAX_COMSTART_FIRST (c
))
504 temp_byte
= inc_bytepos (from_byte
);
505 UPDATE_SYNTAX_TABLE_FORWARD (from
+ 1);
506 if (SYNTAX_COMSTART_SECOND (FETCH_CHAR (temp_byte
))
507 && comstyle
== SYNTAX_COMMENT_STYLE (FETCH_CHAR (temp_byte
)))
509 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
511 else if (code
== Scomment
&& comstyle
!= SYNTAX_COMMENT_STYLE (c
))
512 /* Ignore comment starters of a different style. */
515 /* Ignore escaped characters, except comment-enders. */
516 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
519 /* Track parity of quotes. */
523 if (my_stringend
== 0)
525 /* If we have two kinds of string delimiters.
526 There's no way to grok this scanning backwards. */
527 else if (my_stringend
!= c
)
531 if (code
== Sstring_fence
|| code
== Scomment_fence
)
534 if (my_stringend
== 0)
536 = code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
;
537 /* If we have two kinds of string delimiters.
538 There's no way to grok this scanning backwards. */
539 else if (my_stringend
!= (code
== Sstring_fence
540 ? ST_STRING_STYLE
: ST_COMMENT_STYLE
))
544 if (code
== Scomment
)
545 /* We've already checked that it is the relevant comstyle. */
547 if (comnested
&& --nesting
<= 0 && parity
== 0 && !string_lossage
)
548 /* nested comments have to be balanced, so we don't need to
549 keep looking for earlier ones. We use here the same (slightly
550 incorrect) reasoning as below: since it is followed by uniform
551 paired string quotes, this comment-start has to be outside of
552 strings, else the comment-end itself would be inside a string. */
555 /* Record comment-starters according to that
556 quote-parity to the comment-end. */
557 comstart_parity
= parity
;
559 comstart_byte
= from_byte
;
562 /* If we find another earlier comment-ender,
563 any comment-starts earlier than that don't count
564 (because they go with the earlier comment-ender). */
565 if (code
== Sendcomment
566 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte
)) == comstyle
)
574 /* Assume a defun-start point is outside of strings. */
577 || (temp_byte
= dec_bytepos (from_byte
),
578 FETCH_CHAR (temp_byte
) == '\n')))
581 defun_start_byte
= from_byte
;
586 if (comstart_pos
== 0)
589 from_byte
= comment_end_byte
;
590 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
592 /* If the earliest comment starter
593 is followed by uniform paired string quotes or none,
594 we know it can't be inside a string
595 since if it were then the comment ender would be inside one.
596 So it does start a comment. Skip back to it. */
597 else if (!comnested
&& comstart_parity
== 0 && !string_lossage
)
600 from_byte
= comstart_byte
;
601 /* Globals are correct now. */
605 /* We had two kinds of string delimiters mixed up
606 together. Decode this going forwards.
607 Scan fwd from the previous comment ender
608 to the one in question; this records where we
609 last passed a comment starter. */
610 struct lisp_parse_state state
;
611 /* If we did not already find the defun start, find it now. */
612 if (defun_start
== 0)
614 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
615 defun_start_byte
= find_start_value_byte
;
617 scan_sexps_forward (&state
,
618 defun_start
, defun_start_byte
,
619 comment_end
- 1, -10000, 0, Qnil
, 0);
622 /* scan_sexps_forward changed the direction of search in
623 global variables, so we need to update it completely. */
625 from
= state
.comstr_start
;
631 from_byte
= CHAR_TO_BYTE (from
);
632 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
637 *bytepos_ptr
= from_byte
;
639 return (from
== comment_end
) ? -1 : from
;
642 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
643 "Return t if OBJECT is a syntax table.\n\
644 Currently, any char-table counts as a syntax table.")
648 if (CHAR_TABLE_P (object
)
649 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
655 check_syntax_table (obj
)
658 if (!(CHAR_TABLE_P (obj
)
659 && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
)))
660 wrong_type_argument (Qsyntax_table_p
, obj
);
663 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
664 "Return the current syntax table.\n\
665 This is the one specified by the current buffer.")
668 return current_buffer
->syntax_table
;
671 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
672 Sstandard_syntax_table
, 0, 0, 0,
673 "Return the standard syntax table.\n\
674 This is the one used for new buffers.")
677 return Vstandard_syntax_table
;
680 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
681 "Construct a new syntax table and return it.\n\
682 It is a copy of the TABLE, which defaults to the standard syntax table.")
689 check_syntax_table (table
);
691 table
= Vstandard_syntax_table
;
693 copy
= Fcopy_sequence (table
);
695 /* Only the standard syntax table should have a default element.
696 Other syntax tables should inherit from parents instead. */
697 XCHAR_TABLE (copy
)->defalt
= Qnil
;
699 /* Copied syntax tables should all have parents.
700 If we copied one with no parent, such as the standard syntax table,
701 use the standard syntax table as the copy's parent. */
702 if (NILP (XCHAR_TABLE (copy
)->parent
))
703 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
707 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
708 "Select a new syntax table for the current buffer.\n\
709 One argument, a syntax table.")
713 check_syntax_table (table
);
714 current_buffer
->syntax_table
= table
;
715 /* Indicate that this buffer now has a specified syntax table. */
716 current_buffer
->local_var_flags
717 |= XFASTINT (buffer_local_flags
.syntax_table
);
721 /* Convert a letter which signifies a syntax code
722 into the code it signifies.
723 This is used by modify-syntax-entry, and other things. */
725 unsigned char syntax_spec_code
[0400] =
726 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
727 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
728 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
729 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
730 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
731 (char) Smath
, 0377, 0377, (char) Squote
,
732 (char) Sopen
, (char) Sclose
, 0377, 0377,
733 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
734 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
735 0377, 0377, 0377, 0377,
736 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
737 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
738 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
739 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
740 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
741 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
742 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
743 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
744 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
747 /* Indexed by syntax code, give the letter that describes it. */
749 char syntax_code_spec
[16] =
751 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
755 /* Indexed by syntax code, give the object (cons of syntax code and
756 nil) to be stored in syntax table. Since these objects can be
757 shared among syntax tables, we generate them in advance. By
758 sharing objects, the function `describe-syntax' can give a more
760 static Lisp_Object Vsyntax_code_object
;
763 /* Look up the value for CHARACTER in syntax table TABLE's parent
764 and its parents. SYNTAX_ENTRY calls this, when TABLE itself has nil
765 for CHARACTER. It's actually used only when not compiled with GCC. */
768 syntax_parent_lookup (table
, character
)
776 table
= XCHAR_TABLE (table
)->parent
;
780 value
= XCHAR_TABLE (table
)->contents
[character
];
786 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
787 "Return the syntax code of CHARACTER, described by a character.\n\
788 For example, if CHARACTER is a word constituent,\n\
789 the character `w' is returned.\n\
790 The characters that correspond to various syntax codes\n\
791 are listed in the documentation of `modify-syntax-entry'.")
793 Lisp_Object character
;
796 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
798 gl_state
.use_global
= 0;
799 CHECK_NUMBER (character
, 0);
800 char_int
= XINT (character
);
801 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
804 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
805 "Return the matching parenthesis of CHARACTER, or nil if none.")
807 Lisp_Object character
;
810 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
811 gl_state
.use_global
= 0;
812 CHECK_NUMBER (character
, 0);
813 char_int
= XINT (character
);
814 code
= SYNTAX (char_int
);
815 if (code
== Sopen
|| code
== Sclose
)
816 return SYNTAX_MATCH (char_int
);
820 /* This comment supplies the doc string for modify-syntax-entry,
821 for make-docfile to see. We cannot put this in the real DEFUN
822 due to limits in the Unix cpp.
824 DEFUN ("modify-syntax-entry", foo, bar, 2, 3, 0,
825 "Set syntax for character CHAR according to string S.\n\
826 The syntax is changed only for table TABLE, which defaults to\n\
827 the current buffer's syntax table.\n\
828 The first character of S should be one of the following:\n\
829 Space or - whitespace syntax. w word constituent.\n\
830 _ symbol constituent. . punctuation.\n\
831 ( open-parenthesis. ) close-parenthesis.\n\
832 \" string quote. \\ escape.\n\
833 $ paired delimiter. ' expression quote or prefix operator.\n\
834 < comment starter. > comment ender.\n\
835 / character-quote. @ inherit from `standard-syntax-table'.\n\
837 Only single-character comment start and end sequences are represented thus.\n\
838 Two-character sequences are represented as described below.\n\
839 The second character of S is the matching parenthesis,\n\
840 used only if the first character is `(' or `)'.\n\
841 Any additional characters are flags.\n\
842 Defined flags are the characters 1, 2, 3, 4, b, p, and n.\n\
843 1 means CHAR is the start of a two-char comment start sequence.\n\
844 2 means CHAR is the second character of such a sequence.\n\
845 3 means CHAR is the start of a two-char comment end sequence.\n\
846 4 means CHAR is the second character of such a sequence.\n\
848 There can be up to two orthogonal comment sequences. This is to support\n\
849 language modes such as C++. By default, all comment sequences are of style\n\
850 a, but you can set the comment sequence style to b (on the second character\n\
851 of a comment-start, or the first character of a comment-end sequence) using\n\
853 b means CHAR is part of comment sequence b.\n\
854 n means CHAR is part of a nestable comment sequence.\n\
856 p means CHAR is a prefix character for `backward-prefix-chars';\n\
857 such characters are treated as whitespace when they occur\n\
858 between expressions.")
862 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
863 /* I really don't know why this is interactive
864 help-form should at least be made useful whilst reading the second arg
866 "cSet syntax for character: \nsSet syntax for %s to: ",
867 0 /* See immediately above */)
868 (c
, newentry
, syntax_table
)
869 Lisp_Object c
, newentry
, syntax_table
;
871 register unsigned char *p
;
872 register enum syntaxcode code
;
877 CHECK_STRING (newentry
, 1);
879 if (NILP (syntax_table
))
880 syntax_table
= current_buffer
->syntax_table
;
882 check_syntax_table (syntax_table
);
884 p
= XSTRING (newentry
)->data
;
885 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
886 if (((int) code
& 0377) == 0377)
887 error ("invalid syntax description letter: %c", p
[-1]);
889 if (code
== Sinherit
)
891 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), Qnil
);
898 int character
= (STRING_CHAR_AND_LENGTH
899 (p
, STRING_BYTES (XSTRING (newentry
)) - 1, len
));
900 XSETINT (match
, character
);
901 if (XFASTINT (match
) == ' ')
941 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
942 newentry
= XVECTOR (Vsyntax_code_object
)->contents
[val
];
944 /* Since we can't use a shared object, let's make a new one. */
945 newentry
= Fcons (make_number (val
), match
);
947 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), newentry
);
952 /* Dump syntax table to buffer in human-readable format */
955 describe_syntax (value
)
958 register enum syntaxcode code
;
959 char desc
, start1
, start2
, end1
, end2
, prefix
, comstyle
;
961 Lisp_Object first
, match_lisp
;
963 Findent_to (make_number (16), make_number (1));
967 insert_string ("default\n");
971 if (CHAR_TABLE_P (value
))
973 insert_string ("deeper char-table ...\n");
979 insert_string ("invalid\n");
983 first
= XCAR (value
);
984 match_lisp
= XCDR (value
);
986 if (!INTEGERP (first
) || !(NILP (match_lisp
) || INTEGERP (match_lisp
)))
988 insert_string ("invalid\n");
992 code
= (enum syntaxcode
) (XINT (first
) & 0377);
993 start1
= (XINT (first
) >> 16) & 1;
994 start2
= (XINT (first
) >> 17) & 1;
995 end1
= (XINT (first
) >> 18) & 1;
996 end2
= (XINT (first
) >> 19) & 1;
997 prefix
= (XINT (first
) >> 20) & 1;
998 comstyle
= (XINT (first
) >> 21) & 1;
1000 if ((int) code
< 0 || (int) code
>= (int) Smax
)
1002 insert_string ("invalid");
1005 desc
= syntax_code_spec
[(int) code
];
1007 str
[0] = desc
, str
[1] = 0;
1010 if (NILP (match_lisp
))
1013 insert_char (XINT (match_lisp
));
1030 insert_string ("\twhich means: ");
1032 switch (SWITCH_ENUM_CAST (code
))
1035 insert_string ("whitespace"); break;
1037 insert_string ("punctuation"); break;
1039 insert_string ("word"); break;
1041 insert_string ("symbol"); break;
1043 insert_string ("open"); break;
1045 insert_string ("close"); break;
1047 insert_string ("quote"); break;
1049 insert_string ("string"); break;
1051 insert_string ("math"); break;
1053 insert_string ("escape"); break;
1055 insert_string ("charquote"); break;
1057 insert_string ("comment"); break;
1059 insert_string ("endcomment"); break;
1061 insert_string ("invalid");
1065 if (!NILP (match_lisp
))
1067 insert_string (", matches ");
1068 insert_char (XINT (match_lisp
));
1072 insert_string (",\n\t is the first character of a comment-start sequence");
1074 insert_string (",\n\t is the second character of a comment-start sequence");
1077 insert_string (",\n\t is the first character of a comment-end sequence");
1079 insert_string (",\n\t is the second character of a comment-end sequence");
1081 insert_string (" (comment style b)");
1084 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
1086 insert_string ("\n");
1090 describe_syntax_1 (vector
)
1093 struct buffer
*old
= current_buffer
;
1094 set_buffer_internal (XBUFFER (Vstandard_output
));
1095 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
, (int *) 0, 0);
1096 while (! NILP (XCHAR_TABLE (vector
)->parent
))
1098 vector
= XCHAR_TABLE (vector
)->parent
;
1099 insert_string ("\nThe parent syntax table is:");
1100 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
,
1104 call0 (intern ("help-mode"));
1105 set_buffer_internal (old
);
1109 DEFUN ("describe-syntax", Fdescribe_syntax
, Sdescribe_syntax
, 0, 0, "",
1110 "Describe the syntax specifications in the syntax table.\n\
1111 The descriptions are inserted in a buffer, which is then displayed.")
1114 internal_with_output_to_temp_buffer
1115 ("*Help*", describe_syntax_1
, current_buffer
->syntax_table
);
1120 int parse_sexp_ignore_comments
;
1122 /* Return the position across COUNT words from FROM.
1123 If that many words cannot be found before the end of the buffer, return 0.
1124 COUNT negative means scan backward and stop at word beginning. */
1127 scan_words (from
, count
)
1128 register int from
, count
;
1130 register int beg
= BEGV
;
1131 register int end
= ZV
;
1132 register int from_byte
= CHAR_TO_BYTE (from
);
1133 register enum syntaxcode code
;
1139 SETUP_SYNTAX_TABLE (from
, count
);
1150 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1151 ch0
= FETCH_CHAR (from_byte
);
1152 code
= SYNTAX (ch0
);
1153 INC_BOTH (from
, from_byte
);
1154 if (words_include_escapes
1155 && (code
== Sescape
|| code
== Scharquote
))
1160 /* Now CH0 is a character which begins a word and FROM is the
1161 position of the next character. */
1164 if (from
== end
) break;
1165 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1166 ch1
= FETCH_CHAR (from_byte
);
1167 code
= SYNTAX (ch1
);
1168 if (!(words_include_escapes
1169 && (code
== Sescape
|| code
== Scharquote
)))
1170 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1172 INC_BOTH (from
, from_byte
);
1186 DEC_BOTH (from
, from_byte
);
1187 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1188 ch1
= FETCH_CHAR (from_byte
);
1189 code
= SYNTAX (ch1
);
1190 if (words_include_escapes
1191 && (code
== Sescape
|| code
== Scharquote
))
1196 /* Now CH1 is a character which ends a word and FROM is the
1204 temp_byte
= dec_bytepos (from_byte
);
1205 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1206 ch0
= FETCH_CHAR (temp_byte
);
1207 code
= SYNTAX (ch0
);
1208 if (!(words_include_escapes
1209 && (code
== Sescape
|| code
== Scharquote
)))
1210 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1212 DEC_BOTH (from
, from_byte
);
1223 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 1, 1, "p",
1224 "Move point forward ARG words (backward if ARG is negative).\n\
1225 Normally returns t.\n\
1226 If an edge of the buffer or a field boundary is reached, point is left there\n\
1227 and the function returns nil. Field boundaries are not noticed if\n\
1228 `inhibit-field-text-motion' is non-nil.")
1233 CHECK_NUMBER (count
, 0);
1235 val
= orig_val
= scan_words (PT
, XINT (count
));
1237 val
= XINT (count
) > 0 ? ZV
: BEGV
;
1239 /* Avoid jumping out of an input field. */
1240 val
= XFASTINT (Fconstrain_to_field (make_number (val
), make_number (PT
),
1244 return val
== orig_val
? Qt
: Qnil
;
1247 Lisp_Object
skip_chars ();
1249 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1250 "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
1251 STRING is like the inside of a `[...]' in a regular expression\n\
1252 except that `]' is never special and `\\' quotes `^', `-' or `\\'\n\
1253 (but not as the end of a range; quoting is never needed there).\n\
1254 Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
1255 With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
1256 Returns the distance traveled, either zero or positive.")
1258 Lisp_Object string
, lim
;
1260 return skip_chars (1, 0, string
, lim
);
1263 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1264 "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
1265 See `skip-chars-forward' for details.\n\
1266 Returns the distance traveled, either zero or negative.")
1268 Lisp_Object string
, lim
;
1270 return skip_chars (0, 0, string
, lim
);
1273 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1274 "Move point forward across chars in specified syntax classes.\n\
1275 SYNTAX is a string of syntax code characters.\n\
1276 Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
1277 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1278 This function returns the distance traveled, either zero or positive.")
1280 Lisp_Object syntax
, lim
;
1282 return skip_chars (1, 1, syntax
, lim
);
1285 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1286 "Move point backward across chars in specified syntax classes.\n\
1287 SYNTAX is a string of syntax code characters.\n\
1288 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
1289 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1290 This function returns the distance traveled, either zero or negative.")
1292 Lisp_Object syntax
, lim
;
1294 return skip_chars (0, 1, syntax
, lim
);
1298 skip_chars (forwardp
, syntaxp
, string
, lim
)
1299 int forwardp
, syntaxp
;
1300 Lisp_Object string
, lim
;
1302 register unsigned int c
;
1304 unsigned char fastmap
[0400];
1305 /* If SYNTAXP is 0, STRING may contain multi-byte form of characters
1306 of which codes don't fit in FASTMAP. In that case, we set the
1307 first byte of multibyte form (i.e. base leading-code) in FASTMAP
1308 and set the actual ranges of characters in CHAR_RANGES. In the
1309 form "X-Y" of STRING, both X and Y must belong to the same
1310 character set because a range striding across character sets is
1313 int n_char_ranges
= 0;
1315 register int i
, i_byte
;
1316 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1317 int string_multibyte
;
1320 CHECK_STRING (string
, 0);
1321 char_ranges
= (int *) alloca (XSTRING (string
)->size
* (sizeof (int)) * 2);
1322 string_multibyte
= STRING_MULTIBYTE (string
);
1323 size_byte
= STRING_BYTES (XSTRING (string
));
1326 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1328 CHECK_NUMBER_COERCE_MARKER (lim
, 0);
1330 /* In any case, don't allow scan outside bounds of buffer. */
1331 if (XINT (lim
) > ZV
)
1332 XSETFASTINT (lim
, ZV
);
1333 if (XINT (lim
) < BEGV
)
1334 XSETFASTINT (lim
, BEGV
);
1336 bzero (fastmap
, sizeof fastmap
);
1340 if (i_byte
< size_byte
1341 && XSTRING (string
)->data
[0] == '^')
1343 negate
= 1; i
++, i_byte
++;
1346 /* Find the characters specified and set their elements of fastmap.
1347 If syntaxp, each character counts as itself.
1348 Otherwise, handle backslashes and ranges specially. */
1350 while (i_byte
< size_byte
)
1354 if (string_multibyte
)
1356 c_leading_code
= XSTRING (string
)->data
[i_byte
];
1357 FETCH_STRING_CHAR_ADVANCE (c
, string
, i
, i_byte
);
1360 c
= c_leading_code
= XSTRING (string
)->data
[i_byte
++];
1362 /* Convert multibyteness between what the string has
1363 and what the buffer has. */
1365 c
= unibyte_char_to_multibyte (c
);
1370 fastmap
[syntax_spec_code
[c
& 0377]] = 1;
1375 if (i_byte
== size_byte
)
1378 if (string_multibyte
)
1380 c_leading_code
= XSTRING (string
)->data
[i_byte
];
1381 FETCH_STRING_CHAR_ADVANCE (c
, string
, i
, i_byte
);
1384 c
= c_leading_code
= XSTRING (string
)->data
[i_byte
++];
1386 if (i_byte
< size_byte
1387 && XSTRING (string
)->data
[i_byte
] == '-')
1389 unsigned int c2
, c2_leading_code
;
1391 /* Skip over the dash. */
1394 if (i_byte
== size_byte
)
1397 /* Get the end of the range. */
1398 if (string_multibyte
)
1400 c2_leading_code
= XSTRING (string
)->data
[i_byte
];
1401 FETCH_STRING_CHAR_ADVANCE (c2
, string
, i
, i_byte
);
1404 c2
= XSTRING (string
)->data
[i_byte
++];
1406 if (SINGLE_BYTE_CHAR_P (c
))
1408 if (! SINGLE_BYTE_CHAR_P (c2
))
1409 error ("Invalid charcter range: %s",
1410 XSTRING (string
)->data
);
1419 if (c_leading_code
!= c2_leading_code
)
1420 error ("Invalid charcter range: %s",
1421 XSTRING (string
)->data
);
1422 fastmap
[c_leading_code
] = 1;
1425 char_ranges
[n_char_ranges
++] = c
;
1426 char_ranges
[n_char_ranges
++] = c2
;
1432 fastmap
[c_leading_code
] = 1;
1433 if (!SINGLE_BYTE_CHAR_P (c
))
1435 char_ranges
[n_char_ranges
++] = c
;
1436 char_ranges
[n_char_ranges
++] = c
;
1442 /* If ^ was the first character, complement the fastmap. In
1443 addition, as all multibyte characters have possibility of
1444 matching, set all entries for base leading codes, which is
1445 harmless even if SYNTAXP is 1. */
1448 for (i
= 0; i
< sizeof fastmap
; i
++)
1450 if (!multibyte
|| !BASE_LEADING_CODE_P (i
))
1457 int start_point
= PT
;
1459 int pos_byte
= PT_BYTE
;
1464 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1469 if (pos
< XINT (lim
))
1470 while (fastmap
[(int) SYNTAX (FETCH_CHAR (pos_byte
))])
1472 /* Since we already checked for multibyteness,
1473 avoid using INC_BOTH which checks again. */
1476 if (pos
>= XINT (lim
))
1478 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1483 while (pos
< XINT (lim
)
1484 && fastmap
[(int) SYNTAX (FETCH_BYTE (pos
))])
1487 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1495 while (pos
> XINT (lim
))
1497 int savepos
= pos_byte
;
1498 /* Since we already checked for multibyteness,
1499 avoid using DEC_BOTH which checks again. */
1502 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
1503 if (!fastmap
[(int) SYNTAX (FETCH_CHAR (pos_byte
))])
1513 if (pos
> XINT (lim
))
1514 while (fastmap
[(int) SYNTAX (FETCH_BYTE (pos
- 1))])
1517 if (pos
<= XINT (lim
))
1519 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
1529 while (pos
< XINT (lim
) && fastmap
[(c
= FETCH_BYTE (pos_byte
))])
1531 if (!BASE_LEADING_CODE_P (c
))
1532 INC_BOTH (pos
, pos_byte
);
1533 else if (n_char_ranges
)
1535 /* We much check CHAR_RANGES for a multibyte
1537 ch
= FETCH_MULTIBYTE_CHAR (pos_byte
);
1538 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1539 if ((ch
>= char_ranges
[i
] && ch
<= char_ranges
[i
+ 1]))
1541 if (!(negate
^ (i
< n_char_ranges
)))
1544 INC_BOTH (pos
, pos_byte
);
1549 INC_BOTH (pos
, pos_byte
);
1553 while (pos
< XINT (lim
) && fastmap
[FETCH_BYTE (pos
)])
1559 while (pos
> XINT (lim
))
1561 int savepos
= pos_byte
;
1562 DEC_BOTH (pos
, pos_byte
);
1563 if (fastmap
[(c
= FETCH_BYTE (pos_byte
))])
1565 if (!BASE_LEADING_CODE_P (c
))
1567 else if (n_char_ranges
)
1569 /* We much check CHAR_RANGES for a multibyte
1571 ch
= FETCH_MULTIBYTE_CHAR (pos_byte
);
1572 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1573 if (ch
>= char_ranges
[i
] && ch
<= char_ranges
[i
+ 1])
1575 if (!(negate
^ (i
< n_char_ranges
)))
1598 while (pos
> XINT (lim
) && fastmap
[FETCH_BYTE (pos
- 1)])
1603 #if 0 /* Not needed now that a position in mid-character
1604 cannot be specified in Lisp. */
1606 /* INC_POS or DEC_POS might have moved POS over LIM. */
1607 && (forwardp
? (pos
> XINT (lim
)) : (pos
< XINT (lim
))))
1614 SET_PT_BOTH (pos
, pos_byte
);
1617 return make_number (PT
- start_point
);
1621 /* Jump over a comment, assuming we are at the beginning of one.
1622 FROM is the current position.
1623 FROM_BYTE is the bytepos corresponding to FROM.
1624 Do not move past STOP (a charpos).
1625 The comment over which we have to jump is of style STYLE
1626 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
1627 NESTING should be positive to indicate the nesting at the beginning
1628 for nested comments and should be zero or negative else.
1629 ST_COMMENT_STYLE cannot be nested.
1630 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
1631 (or 0 If the search cannot start in the middle of a two-character).
1633 If successful, return 1 and store the charpos of the comment's end
1634 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
1635 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
1636 corresponding bytepos into *BYTEPOS_PTR and the current nesting
1637 (as defined for state.incomment) in *INCOMMENT_PTR.
1639 The comment end is the last character of the comment rather than the
1640 character just after the comment.
1642 Global syntax data is assumed to initially be valid for FROM and
1643 remains valid for forward search starting at the returned position. */
1646 forw_comment (from
, from_byte
, stop
, nesting
, style
, prev_syntax
,
1647 charpos_ptr
, bytepos_ptr
, incomment_ptr
)
1648 int from
, from_byte
, stop
;
1649 int nesting
, style
, prev_syntax
;
1650 int *charpos_ptr
, *bytepos_ptr
, *incomment_ptr
;
1653 register enum syntaxcode code
;
1654 register int syntax
;
1656 if (nesting
<= 0) nesting
= -1;
1658 /* Enter the loop in the middle so that we find
1659 a 2-char comment ender if we start in the middle of it. */
1660 syntax
= prev_syntax
;
1661 if (syntax
!= 0) goto forw_incomment
;
1667 *incomment_ptr
= nesting
;
1668 *charpos_ptr
= from
;
1669 *bytepos_ptr
= from_byte
;
1672 c
= FETCH_CHAR (from_byte
);
1673 syntax
= SYNTAX_WITH_FLAGS (c
);
1674 code
= syntax
& 0xff;
1675 if (code
== Sendcomment
1676 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1678 /* we have encountered a comment end of the same style
1679 as the comment sequence which began this comment
1682 if (code
== Scomment_fence
1683 && style
== ST_COMMENT_STYLE
)
1684 /* we have encountered a comment end of the same style
1685 as the comment sequence which began this comment
1690 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
)
1691 /* we have encountered a nested comment of the same style
1692 as the comment sequence which began this comment section */
1694 INC_BOTH (from
, from_byte
);
1695 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1698 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
1699 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1700 && (c1
= FETCH_CHAR (from_byte
),
1701 SYNTAX_COMEND_SECOND (c1
)))
1704 /* we have encountered a comment end of the same style
1705 as the comment sequence which began this comment
1710 INC_BOTH (from
, from_byte
);
1711 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1716 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
1717 && (c1
= FETCH_CHAR (from_byte
),
1718 SYNTAX_COMMENT_STYLE (c1
) == style
1719 && SYNTAX_COMSTART_SECOND (c1
)))
1720 /* we have encountered a nested comment of the same style
1721 as the comment sequence which began this comment
1724 INC_BOTH (from
, from_byte
);
1725 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1729 *charpos_ptr
= from
;
1730 *bytepos_ptr
= from_byte
;
1734 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
1735 "Move forward across up to N comments. If N is negative, move backward.\n\
1736 Stop scanning if we find something other than a comment or whitespace.\n\
1737 Set point to where scanning stops.\n\
1738 If N comments are found as expected, with nothing except whitespace\n\
1739 between them, return t; otherwise return nil.")
1747 register enum syntaxcode code
;
1748 int comstyle
= 0; /* style of comment encountered */
1749 int comnested
= 0; /* whether the comment is nestable or not */
1752 int out_charpos
, out_bytepos
;
1755 CHECK_NUMBER (count
, 0);
1756 count1
= XINT (count
);
1757 stop
= count1
> 0 ? ZV
: BEGV
;
1763 from_byte
= PT_BYTE
;
1765 SETUP_SYNTAX_TABLE (from
, count1
);
1774 SET_PT_BOTH (from
, from_byte
);
1778 c
= FETCH_CHAR (from_byte
);
1780 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
1781 comnested
= SYNTAX_COMMENT_NESTED (c
);
1782 INC_BOTH (from
, from_byte
);
1783 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1785 if (from
< stop
&& comstart_first
1786 && (c1
= FETCH_CHAR (from_byte
),
1787 SYNTAX_COMSTART_SECOND (c1
)))
1789 /* We have encountered a comment start sequence and we
1790 are ignoring all text inside comments. We must record
1791 the comment style this sequence begins so that later,
1792 only a comment end of the same style actually ends
1793 the comment section. */
1795 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1796 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1797 INC_BOTH (from
, from_byte
);
1798 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1800 /* FIXME: here we ignore 2-char endcomments while we don't
1801 when going backwards. */
1803 while (code
== Swhitespace
|| code
== Sendcomment
);
1805 if (code
== Scomment_fence
)
1806 comstyle
= ST_COMMENT_STYLE
;
1807 else if (code
!= Scomment
)
1810 DEC_BOTH (from
, from_byte
);
1811 SET_PT_BOTH (from
, from_byte
);
1814 /* We're at the start of a comment. */
1815 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
1816 &out_charpos
, &out_bytepos
, &dummy
);
1817 from
= out_charpos
; from_byte
= out_bytepos
;
1821 SET_PT_BOTH (from
, from_byte
);
1824 INC_BOTH (from
, from_byte
);
1825 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1826 /* We have skipped one comment. */
1834 int quoted
, comstart_second
;
1838 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
1843 DEC_BOTH (from
, from_byte
);
1844 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
1845 quoted
= char_quoted (from
, from_byte
);
1848 DEC_BOTH (from
, from_byte
);
1851 c
= FETCH_CHAR (from_byte
);
1854 comnested
= SYNTAX_COMMENT_NESTED (c
);
1855 if (code
== Sendcomment
)
1856 comstyle
= SYNTAX_COMMENT_STYLE (c
);
1857 comstart_second
= SYNTAX_COMSTART_SECOND (c
);
1858 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1859 && prev_char_comend_first (from
, from_byte
)
1860 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
1862 /* We must record the comment style encountered so that
1863 later, we can match only the proper comment begin
1864 sequence of the same style. */
1865 DEC_BOTH (from
, from_byte
);
1867 /* Calling char_quoted, above, set up global syntax position
1868 at the new value of FROM. */
1869 c1
= FETCH_CHAR (from_byte
);
1870 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1871 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1873 if (from
> stop
&& comstart_second
1874 && prev_char_comstart_first (from
, from_byte
)
1875 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
1878 DEC_BOTH (from
, from_byte
);
1881 if (code
== Scomment_fence
)
1883 /* Skip until first preceding unquoted comment_fence. */
1884 int found
= 0, ini
= from
, ini_byte
= from_byte
;
1888 DEC_BOTH (from
, from_byte
);
1891 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1892 c
= FETCH_CHAR (from_byte
);
1893 if (SYNTAX (c
) == Scomment_fence
1894 && !char_quoted (from
, from_byte
))
1902 from
= ini
; /* Set point to ini + 1. */
1903 from_byte
= ini_byte
;
1907 else if (code
== Sendcomment
)
1909 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
1910 &out_charpos
, &out_bytepos
);
1913 #if 0 /* cc-mode (and maybe others) relies on the bogus behavior. */
1914 /* Failure: we should go back to the end of this
1915 not-quite-endcomment. */
1916 if (SYNTAX(c
) != code
)
1917 /* It was a two-char Sendcomment. */
1918 INC_BOTH (from
, from_byte
);
1923 /* We have skipped one comment. */
1924 from
= out_charpos
, from_byte
= out_bytepos
;
1927 else if (code
!= Swhitespace
&& code
!= Scomment
)
1931 INC_BOTH (from
, from_byte
);
1932 SET_PT_BOTH (from
, from_byte
);
1940 SET_PT_BOTH (from
, from_byte
);
1946 scan_lists (from
, count
, depth
, sexpflag
)
1948 int count
, depth
, sexpflag
;
1951 register int stop
= count
> 0 ? ZV
: BEGV
;
1956 register enum syntaxcode code
, temp_code
;
1957 int min_depth
= depth
; /* Err out if depth gets less than this. */
1958 int comstyle
= 0; /* style of comment encountered */
1959 int comnested
= 0; /* whether the comment is nestable or not */
1961 int last_good
= from
;
1964 int out_bytepos
, out_charpos
;
1967 if (depth
> 0) min_depth
= 0;
1969 if (from
> ZV
) from
= ZV
;
1970 if (from
< BEGV
) from
= BEGV
;
1972 from_byte
= CHAR_TO_BYTE (from
);
1977 SETUP_SYNTAX_TABLE (from
, count
);
1982 int comstart_first
, prefix
;
1983 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1984 c
= FETCH_CHAR (from_byte
);
1986 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
1987 comnested
= SYNTAX_COMMENT_NESTED (c
);
1988 prefix
= SYNTAX_PREFIX (c
);
1989 if (depth
== min_depth
)
1991 INC_BOTH (from
, from_byte
);
1992 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1993 if (from
< stop
&& comstart_first
1994 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte
))
1995 && parse_sexp_ignore_comments
)
1997 /* we have encountered a comment start sequence and we
1998 are ignoring all text inside comments. We must record
1999 the comment style this sequence begins so that later,
2000 only a comment end of the same style actually ends
2001 the comment section */
2003 c1
= FETCH_CHAR (from_byte
);
2004 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2005 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2006 INC_BOTH (from
, from_byte
);
2007 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2013 switch (SWITCH_ENUM_CAST (code
))
2017 if (from
== stop
) goto lose
;
2018 INC_BOTH (from
, from_byte
);
2019 /* treat following character as a word constituent */
2022 if (depth
|| !sexpflag
) break;
2023 /* This word counts as a sexp; return at end of it. */
2026 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2028 /* Some compilers can't handle this inside the switch. */
2029 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2034 INC_BOTH (from
, from_byte
);
2035 if (from
== stop
) goto lose
;
2044 INC_BOTH (from
, from_byte
);
2048 case Scomment_fence
:
2049 comstyle
= ST_COMMENT_STYLE
;
2052 if (!parse_sexp_ignore_comments
) break;
2053 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2054 found
= forw_comment (from
, from_byte
, stop
,
2055 comnested
, comstyle
, 0,
2056 &out_charpos
, &out_bytepos
, &dummy
);
2057 from
= out_charpos
, from_byte
= out_bytepos
;
2064 INC_BOTH (from
, from_byte
);
2065 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2071 if (from
!= stop
&& c
== FETCH_CHAR (from_byte
))
2073 INC_BOTH (from
, from_byte
);
2083 if (!++depth
) goto done
;
2088 if (!--depth
) goto done
;
2089 if (depth
< min_depth
)
2090 Fsignal (Qscan_error
,
2091 Fcons (build_string ("Containing expression ends prematurely"),
2092 Fcons (make_number (last_good
),
2093 Fcons (make_number (from
), Qnil
))));
2098 temp_pos
= dec_bytepos (from_byte
);
2099 stringterm
= FETCH_CHAR (temp_pos
);
2102 if (from
>= stop
) goto lose
;
2103 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2105 ? (FETCH_CHAR (from_byte
) == stringterm
)
2106 : SYNTAX (FETCH_CHAR (from_byte
)) == Sstring_fence
)
2109 /* Some compilers can't handle this inside the switch. */
2110 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2115 INC_BOTH (from
, from_byte
);
2117 INC_BOTH (from
, from_byte
);
2119 INC_BOTH (from
, from_byte
);
2120 if (!depth
&& sexpflag
) goto done
;
2125 /* Reached end of buffer. Error if within object, return nil if between */
2126 if (depth
) goto lose
;
2131 /* End of object reached */
2140 DEC_BOTH (from
, from_byte
);
2141 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2142 c
= FETCH_CHAR (from_byte
);
2144 if (depth
== min_depth
)
2147 comnested
= SYNTAX_COMMENT_NESTED (c
);
2148 if (code
== Sendcomment
)
2149 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2150 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2151 && prev_char_comend_first (from
, from_byte
)
2152 && parse_sexp_ignore_comments
)
2154 /* We must record the comment style encountered so that
2155 later, we can match only the proper comment begin
2156 sequence of the same style. */
2157 DEC_BOTH (from
, from_byte
);
2158 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2160 c1
= FETCH_CHAR (from_byte
);
2161 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2162 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2165 /* Quoting turns anything except a comment-ender
2166 into a word character. Note that this if cannot be true
2167 if we decremented FROM in the if-statement above. */
2168 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2170 else if (SYNTAX_PREFIX (c
))
2173 switch (SWITCH_ENUM_CAST (code
))
2179 if (depth
|| !sexpflag
) break;
2180 /* This word counts as a sexp; count object finished
2181 after passing it. */
2184 temp_pos
= from_byte
;
2185 if (! NILP (current_buffer
->enable_multibyte_characters
))
2189 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2190 c1
= FETCH_CHAR (temp_pos
);
2191 temp_code
= SYNTAX (c1
);
2192 /* Don't allow comment-end to be quoted. */
2193 if (temp_code
== Sendcomment
)
2195 quoted
= char_quoted (from
- 1, temp_pos
);
2198 DEC_BOTH (from
, from_byte
);
2199 temp_pos
= dec_bytepos (temp_pos
);
2200 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2202 c1
= FETCH_CHAR (temp_pos
);
2203 temp_code
= SYNTAX (c1
);
2204 if (! (quoted
|| temp_code
== Sword
2205 || temp_code
== Ssymbol
2206 || temp_code
== Squote
))
2208 DEC_BOTH (from
, from_byte
);
2215 temp_pos
= dec_bytepos (from_byte
);
2216 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2217 if (from
!= stop
&& c
== FETCH_CHAR (temp_pos
))
2218 DEC_BOTH (from
, from_byte
);
2227 if (!++depth
) goto done2
;
2232 if (!--depth
) goto done2
;
2233 if (depth
< min_depth
)
2234 Fsignal (Qscan_error
,
2235 Fcons (build_string ("Containing expression ends prematurely"),
2236 Fcons (make_number (last_good
),
2237 Fcons (make_number (from
), Qnil
))));
2241 if (!parse_sexp_ignore_comments
)
2243 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2244 &out_charpos
, &out_bytepos
);
2245 /* FIXME: if found == -1, then it really wasn't a comment-end.
2246 For single-char Sendcomment, we can't do much about it apart
2247 from skipping the char.
2248 For 2-char endcomments, we could try again, taking both
2249 chars as separate entities, but it's a lot of trouble
2250 for very little gain, so we don't bother either. -sm */
2252 from
= out_charpos
, from_byte
= out_bytepos
;
2255 case Scomment_fence
:
2259 DEC_BOTH (from
, from_byte
);
2260 if (from
== stop
) goto lose
;
2261 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2262 if (!char_quoted (from
, from_byte
)
2263 && SYNTAX (FETCH_CHAR (from_byte
)) == code
)
2266 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2270 stringterm
= FETCH_CHAR (from_byte
);
2273 if (from
== stop
) goto lose
;
2274 temp_pos
= from_byte
;
2275 if (! NILP (current_buffer
->enable_multibyte_characters
))
2279 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2280 if (!char_quoted (from
- 1, temp_pos
)
2281 && stringterm
== FETCH_CHAR (temp_pos
))
2283 DEC_BOTH (from
, from_byte
);
2285 DEC_BOTH (from
, from_byte
);
2286 if (!depth
&& sexpflag
) goto done2
;
2291 /* Reached start of buffer. Error if within object, return nil if between */
2292 if (depth
) goto lose
;
2303 XSETFASTINT (val
, from
);
2307 Fsignal (Qscan_error
,
2308 Fcons (build_string ("Unbalanced parentheses"),
2309 Fcons (make_number (last_good
),
2310 Fcons (make_number (from
), Qnil
))));
2315 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2316 "Scan from character number FROM by COUNT lists.\n\
2317 Returns the character number of the position thus found.\n\
2319 If DEPTH is nonzero, paren depth begins counting from that value,\n\
2320 only places where the depth in parentheses becomes zero\n\
2321 are candidates for stopping; COUNT such places are counted.\n\
2322 Thus, a positive value for DEPTH means go out levels.\n\
2324 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2326 If the beginning or end of (the accessible part of) the buffer is reached\n\
2327 and the depth is wrong, an error is signaled.\n\
2328 If the depth is right but the count is not used up, nil is returned.")
2329 (from
, count
, depth
)
2330 Lisp_Object from
, count
, depth
;
2332 CHECK_NUMBER (from
, 0);
2333 CHECK_NUMBER (count
, 1);
2334 CHECK_NUMBER (depth
, 2);
2336 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2339 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2340 "Scan from character number FROM by COUNT balanced expressions.\n\
2341 If COUNT is negative, scan backwards.\n\
2342 Returns the character number of the position thus found.\n\
2344 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2346 If the beginning or end of (the accessible part of) the buffer is reached\n\
2347 in the middle of a parenthetical grouping, an error is signaled.\n\
2348 If the beginning or end is reached between groupings\n\
2349 but before count is used up, nil is returned.")
2351 Lisp_Object from
, count
;
2353 CHECK_NUMBER (from
, 0);
2354 CHECK_NUMBER (count
, 1);
2356 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2359 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2361 "Move point backward over any number of chars with prefix syntax.\n\
2362 This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
2367 int opoint_byte
= PT_BYTE
;
2369 int pos_byte
= PT_BYTE
;
2374 SET_PT_BOTH (opoint
, opoint_byte
);
2379 SETUP_SYNTAX_TABLE (pos
, -1);
2381 DEC_BOTH (pos
, pos_byte
);
2383 while (!char_quoted (pos
, pos_byte
)
2384 /* Previous statement updates syntax table. */
2385 && ((c
= FETCH_CHAR (pos_byte
), SYNTAX (c
) == Squote
)
2386 || SYNTAX_PREFIX (c
)))
2389 opoint_byte
= pos_byte
;
2392 DEC_BOTH (pos
, pos_byte
);
2395 SET_PT_BOTH (opoint
, opoint_byte
);
2400 /* Parse forward from FROM / FROM_BYTE to END,
2401 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2402 and return a description of the state of the parse at END.
2403 If STOPBEFORE is nonzero, stop at the start of an atom.
2404 If COMMENTSTOP is 1, stop at the start of a comment.
2405 If COMMENTSTOP is -1, stop at the start or end of a comment,
2406 after the beginning of a string, or after the end of a string. */
2409 scan_sexps_forward (stateptr
, from
, from_byte
, end
, targetdepth
,
2410 stopbefore
, oldstate
, commentstop
)
2411 struct lisp_parse_state
*stateptr
;
2413 int end
, targetdepth
, stopbefore
;
2414 Lisp_Object oldstate
;
2417 struct lisp_parse_state state
;
2419 register enum syntaxcode code
;
2422 struct level
{ int last
, prev
; };
2423 struct level levelstart
[100];
2424 register struct level
*curlevel
= levelstart
;
2425 struct level
*endlevel
= levelstart
+ 100;
2426 register int depth
; /* Paren depth of current scanning location.
2427 level - levelstart equals this except
2428 when the depth becomes negative. */
2429 int mindepth
; /* Lowest DEPTH value seen. */
2430 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2432 int prev_from
; /* Keep one character before FROM. */
2434 int prev_from_syntax
;
2435 int boundary_stop
= commentstop
== -1;
2438 int out_bytepos
, out_charpos
;
2442 prev_from_byte
= from_byte
;
2444 DEC_BOTH (prev_from
, prev_from_byte
);
2446 /* Use this macro instead of `from++'. */
2448 do { prev_from = from; \
2449 prev_from_byte = from_byte; \
2451 = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte)); \
2452 INC_BOTH (from, from_byte); \
2453 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2459 if (NILP (oldstate
))
2462 state
.instring
= -1;
2463 state
.incomment
= 0;
2464 state
.comstyle
= 0; /* comment style a by default. */
2465 state
.comstr_start
= -1; /* no comment/string seen. */
2469 tem
= Fcar (oldstate
);
2475 oldstate
= Fcdr (oldstate
);
2476 oldstate
= Fcdr (oldstate
);
2477 oldstate
= Fcdr (oldstate
);
2478 tem
= Fcar (oldstate
);
2479 /* Check whether we are inside string_fence-style string: */
2480 state
.instring
= (!NILP (tem
)
2481 ? (INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2484 oldstate
= Fcdr (oldstate
);
2485 tem
= Fcar (oldstate
);
2486 state
.incomment
= (!NILP (tem
)
2487 ? (INTEGERP (tem
) ? XINT (tem
) : -1)
2490 oldstate
= Fcdr (oldstate
);
2491 tem
= Fcar (oldstate
);
2492 start_quoted
= !NILP (tem
);
2494 /* if the eighth element of the list is nil, we are in comment
2495 style a. If it is non-nil, we are in comment style b */
2496 oldstate
= Fcdr (oldstate
);
2497 oldstate
= Fcdr (oldstate
);
2498 tem
= Fcar (oldstate
);
2499 state
.comstyle
= NILP (tem
) ? 0 : (EQ (tem
, Qsyntax_table
)
2500 ? ST_COMMENT_STYLE
: 1);
2502 oldstate
= Fcdr (oldstate
);
2503 tem
= Fcar (oldstate
);
2504 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2505 oldstate
= Fcdr (oldstate
);
2506 tem
= Fcar (oldstate
);
2507 while (!NILP (tem
)) /* >= second enclosing sexps. */
2509 /* curlevel++->last ran into compiler bug on Apollo */
2510 curlevel
->last
= XINT (Fcar (tem
));
2511 if (++curlevel
== endlevel
)
2512 error ("Nesting too deep for parser");
2513 curlevel
->prev
= -1;
2514 curlevel
->last
= -1;
2521 curlevel
->prev
= -1;
2522 curlevel
->last
= -1;
2524 SETUP_SYNTAX_TABLE (prev_from
, 1);
2525 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2526 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2528 /* Enter the loop at a place appropriate for initial state. */
2530 if (state
.incomment
)
2531 goto startincomment
;
2532 if (state
.instring
>= 0)
2534 nofence
= state
.instring
!= ST_STRING_STYLE
;
2536 goto startquotedinstring
;
2539 else if (start_quoted
)
2542 #if 0 /* This seems to be redundant with the identical code above. */
2543 SETUP_SYNTAX_TABLE (prev_from
, 1);
2544 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2545 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2551 code
= prev_from_syntax
& 0xff;
2553 if (code
== Scomment
)
2555 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
2557 state
.comstr_start
= prev_from
;
2559 else if (code
== Scomment_fence
)
2561 /* Record the comment style we have entered so that only
2562 the comment-end sequence of the same style actually
2563 terminates the comment section. */
2564 state
.comstyle
= ST_COMMENT_STYLE
;
2565 state
.incomment
= -1;
2566 state
.comstr_start
= prev_from
;
2569 else if (from
< end
)
2570 if (SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
))
2571 if (c1
= FETCH_CHAR (from_byte
),
2572 SYNTAX_COMSTART_SECOND (c1
))
2573 /* Duplicate code to avoid a complex if-expression
2574 which causes trouble for the SGI compiler. */
2576 /* Record the comment style we have entered so that only
2577 the comment-end sequence of the same style actually
2578 terminates the comment section. */
2579 state
.comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte
));
2580 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
);
2581 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2582 state
.incomment
= comnested
? 1 : -1;
2583 state
.comstr_start
= prev_from
;
2588 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
2590 switch (SWITCH_ENUM_CAST (code
))
2594 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2595 curlevel
->last
= prev_from
;
2597 if (from
== end
) goto endquoted
;
2600 /* treat following character as a word constituent */
2603 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2604 curlevel
->last
= prev_from
;
2608 /* Some compilers can't handle this inside the switch. */
2609 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2615 if (from
== end
) goto endquoted
;
2627 curlevel
->prev
= curlevel
->last
;
2631 if (commentstop
== 1)
2636 if (! state
.incomment
)
2638 if (commentstop
|| boundary_stop
) goto done
;
2640 /* The (from == BEGV) test is to enter the loop in the middle so
2641 that we find a 2-char comment ender even if we start in the
2643 found
= forw_comment (from
, from_byte
, end
,
2644 state
.incomment
, state
.comstyle
,
2645 (from
== BEGV
) ? 0 : prev_from_syntax
,
2646 &out_charpos
, &out_bytepos
, &state
.incomment
);
2647 from
= out_charpos
; from_byte
= out_bytepos
;
2648 /* Beware! prev_from and friends are invalid now.
2649 Luckily, the `done' doesn't use them and the INC_FROM
2650 sets them to a sane value without looking at them. */
2651 if (!found
) goto done
;
2653 state
.incomment
= 0;
2654 state
.comstyle
= 0; /* reset the comment style */
2655 if (boundary_stop
) goto done
;
2659 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2661 /* curlevel++->last ran into compiler bug on Apollo */
2662 curlevel
->last
= prev_from
;
2663 if (++curlevel
== endlevel
)
2664 error ("Nesting too deep for parser");
2665 curlevel
->prev
= -1;
2666 curlevel
->last
= -1;
2667 if (targetdepth
== depth
) goto done
;
2672 if (depth
< mindepth
)
2674 if (curlevel
!= levelstart
)
2676 curlevel
->prev
= curlevel
->last
;
2677 if (targetdepth
== depth
) goto done
;
2682 state
.comstr_start
= from
- 1;
2683 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2684 curlevel
->last
= prev_from
;
2685 state
.instring
= (code
== Sstring
2686 ? (FETCH_CHAR (prev_from_byte
))
2688 if (boundary_stop
) goto done
;
2691 nofence
= state
.instring
!= ST_STRING_STYLE
;
2697 if (from
>= end
) goto done
;
2698 c
= FETCH_CHAR (from_byte
);
2699 /* Some compilers can't handle this inside the switch. */
2702 /* Check TEMP here so that if the char has
2703 a syntax-table property which says it is NOT
2704 a string character, it does not end the string. */
2705 if (nofence
&& c
== state
.instring
&& temp
== Sstring
)
2711 if (!nofence
) goto string_end
;
2716 startquotedinstring
:
2717 if (from
>= end
) goto endquoted
;
2723 state
.instring
= -1;
2724 curlevel
->prev
= curlevel
->last
;
2726 if (boundary_stop
) goto done
;
2735 stop
: /* Here if stopping before start of sexp. */
2736 from
= prev_from
; /* We have just fetched the char that starts it; */
2737 goto done
; /* but return the position before it. */
2742 state
.depth
= depth
;
2743 state
.mindepth
= mindepth
;
2744 state
.thislevelstart
= curlevel
->prev
;
2745 state
.prevlevelstart
2746 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
2747 state
.location
= from
;
2748 state
.levelstarts
= Qnil
;
2749 while (--curlevel
>= levelstart
)
2750 state
.levelstarts
= Fcons (make_number (curlevel
->last
),
2757 /* This comment supplies the doc string for parse-partial-sexp,
2758 for make-docfile to see. We cannot put this in the real DEFUN
2759 due to limits in the Unix cpp.
2761 DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 6, 0,
2762 "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
2763 Parsing stops at TO or when certain criteria are met;\n\
2764 point is set to where parsing stops.\n\
2765 If fifth arg STATE is omitted or nil,\n\
2766 parsing assumes that FROM is the beginning of a function.\n\
2767 Value is a list of ten elements describing final state of parsing:\n\
2768 0. depth in parens.\n\
2769 1. character address of start of innermost containing list; nil if none.\n\
2770 2. character address of start of last complete sexp terminated.\n\
2771 3. non-nil if inside a string.\n\
2772 (it is the character that will terminate the string,\n\
2773 or t if the string should be terminated by a generic string delimiter.)\n\
2774 4. nil if outside a comment, t if inside a non-nestable comment, \n\
2775 else an integer (the current comment nesting).\n\
2776 5. t if following a quote character.\n\
2777 6. the minimum paren-depth encountered during this scan.\n\
2778 7. t if in a comment of style b; `syntax-table' if the comment\n\
2779 should be terminated by a generic comment delimiter.\n\
2780 8. character address of start of comment or string; nil if not in one.\n\
2781 9. Intermediate data for continuation of parsing (subject to change).\n\
2782 If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
2783 in parentheses becomes equal to TARGETDEPTH.\n\
2784 Fourth arg STOPBEFORE non-nil means stop when come to\n\
2785 any character that starts a sexp.\n\
2786 Fifth arg STATE is a nine-element list like what this function returns.\n\
2787 It is used to initialize the state of the parse. Elements number 1, 2, 6\n\
2788 and 8 are ignored; you can leave off element 8 (the last) entirely.\n\
2789 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.\n\
2790 If it is `syntax-table', stop after the start of a comment or a string,\n\
2791 or after end of a comment or a string.")
2792 (from, to, targetdepth, stopbefore, state, commentstop)
2795 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
2796 0 /* See immediately above */)
2797 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
2798 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
2800 struct lisp_parse_state state
;
2803 if (!NILP (targetdepth
))
2805 CHECK_NUMBER (targetdepth
, 3);
2806 target
= XINT (targetdepth
);
2809 target
= -100000; /* We won't reach this depth */
2811 validate_region (&from
, &to
);
2812 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
2814 target
, !NILP (stopbefore
), oldstate
,
2816 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
2818 SET_PT (state
.location
);
2820 return Fcons (make_number (state
.depth
),
2821 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
2822 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
2823 Fcons (state
.instring
>= 0
2824 ? (state
.instring
== ST_STRING_STYLE
2825 ? Qt
: make_number (state
.instring
)) : Qnil
,
2826 Fcons (state
.incomment
< 0 ? Qt
:
2827 (state
.incomment
== 0 ? Qnil
:
2828 make_number (state
.incomment
)),
2829 Fcons (state
.quoted
? Qt
: Qnil
,
2830 Fcons (make_number (state
.mindepth
),
2831 Fcons ((state
.comstyle
2832 ? (state
.comstyle
== ST_COMMENT_STYLE
2833 ? Qsyntax_table
: Qt
) :
2835 Fcons (((state
.incomment
2836 || (state
.instring
>= 0))
2837 ? make_number (state
.comstr_start
)
2839 Fcons (state
.levelstarts
, Qnil
))))))))));
2848 /* This has to be done here, before we call Fmake_char_table. */
2849 Qsyntax_table
= intern ("syntax-table");
2850 staticpro (&Qsyntax_table
);
2852 /* Intern this now in case it isn't already done.
2853 Setting this variable twice is harmless.
2854 But don't staticpro it here--that is done in alloc.c. */
2855 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
2857 /* Create objects which can be shared among syntax tables. */
2858 Vsyntax_code_object
= Fmake_vector (make_number (13), Qnil
);
2859 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
2860 XVECTOR (Vsyntax_code_object
)->contents
[i
]
2861 = Fcons (make_number (i
), Qnil
);
2863 /* Now we are ready to set up this property, so we can
2864 create syntax tables. */
2865 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
2867 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
2869 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
2871 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
2872 for (i
= 'a'; i
<= 'z'; i
++)
2873 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2874 for (i
= 'A'; i
<= 'Z'; i
++)
2875 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2876 for (i
= '0'; i
<= '9'; i
++)
2877 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2879 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
2880 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
2882 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
2883 Fcons (make_number (Sopen
), make_number (')')));
2884 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
2885 Fcons (make_number (Sclose
), make_number ('(')));
2886 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
2887 Fcons (make_number (Sopen
), make_number (']')));
2888 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
2889 Fcons (make_number (Sclose
), make_number ('[')));
2890 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
2891 Fcons (make_number (Sopen
), make_number ('}')));
2892 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
2893 Fcons (make_number (Sclose
), make_number ('{')));
2894 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
2895 Fcons (make_number ((int) Sstring
), Qnil
));
2896 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
2897 Fcons (make_number ((int) Sescape
), Qnil
));
2899 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
2900 for (i
= 0; i
< 10; i
++)
2902 c
= "_-+*/&|<>="[i
];
2903 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2906 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
2907 for (i
= 0; i
< 12; i
++)
2909 c
= ".,;:?!#@~^'`"[i
];
2910 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2917 Qsyntax_table_p
= intern ("syntax-table-p");
2918 staticpro (&Qsyntax_table_p
);
2920 staticpro (&Vsyntax_code_object
);
2922 Qscan_error
= intern ("scan-error");
2923 staticpro (&Qscan_error
);
2924 Fput (Qscan_error
, Qerror_conditions
,
2925 Fcons (Qscan_error
, Fcons (Qerror
, Qnil
)));
2926 Fput (Qscan_error
, Qerror_message
,
2927 build_string ("Scan error"));
2929 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
2930 "Non-nil means `forward-sexp', etc., should treat comments as whitespace.");
2932 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
2933 "Non-nil means `forward-sexp', etc., grant `syntax-table' property.\n\
2934 The value of this property should be either a syntax table, or a cons\n\
2935 of the form (SYNTAXCODE . MATCHCHAR), SYNTAXCODE being the numeric\n\
2936 syntax code, MATCHCHAR being nil or the character to match (which is\n\
2937 relevant only for open/close type.");
2939 words_include_escapes
= 0;
2940 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
2941 "Non-nil means `forward-word', etc., should treat escape chars part of words.");
2943 defsubr (&Ssyntax_table_p
);
2944 defsubr (&Ssyntax_table
);
2945 defsubr (&Sstandard_syntax_table
);
2946 defsubr (&Scopy_syntax_table
);
2947 defsubr (&Sset_syntax_table
);
2948 defsubr (&Schar_syntax
);
2949 defsubr (&Smatching_paren
);
2950 defsubr (&Smodify_syntax_entry
);
2951 defsubr (&Sdescribe_syntax
);
2953 defsubr (&Sforward_word
);
2955 defsubr (&Sskip_chars_forward
);
2956 defsubr (&Sskip_chars_backward
);
2957 defsubr (&Sskip_syntax_forward
);
2958 defsubr (&Sskip_syntax_backward
);
2960 defsubr (&Sforward_comment
);
2961 defsubr (&Sscan_lists
);
2962 defsubr (&Sscan_sexps
);
2963 defsubr (&Sbackward_prefix_chars
);
2964 defsubr (&Sparse_partial_sexp
);