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
);
512 /* Ignore escaped characters, except comment-enders. */
513 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
516 /* Track parity of quotes. */
520 if (my_stringend
== 0)
522 /* If we have two kinds of string delimiters.
523 There's no way to grok this scanning backwards. */
524 else if (my_stringend
!= c
)
528 if (code
== Sstring_fence
|| code
== Scomment_fence
)
531 if (my_stringend
== 0)
533 = code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
;
534 /* If we have two kinds of string delimiters.
535 There's no way to grok this scanning backwards. */
536 else if (my_stringend
!= (code
== Sstring_fence
537 ? ST_STRING_STYLE
: ST_COMMENT_STYLE
))
541 if (code
== Scomment
)
542 /* FIXME: we should also check that the comstyle is correct
543 if the Scomment is a single-char. */
545 if (comnested
&& --nesting
<= 0 && parity
== 0 && !string_lossage
)
546 /* nested comments have to be balanced, so we don't need to
547 keep looking for earlier ones. We use here the same (slightly
548 incorrect) reasoning as below: since it is followed by uniform
549 paired string quotes, this comment-start has to be outside of
550 strings, else the comment-end itself would be inside a string. */
553 /* Record comment-starters according to that
554 quote-parity to the comment-end. */
555 comstart_parity
= parity
;
557 comstart_byte
= from_byte
;
560 /* If we find another earlier comment-ender,
561 any comment-starts earlier than that don't count
562 (because they go with the earlier comment-ender). */
563 if (code
== Sendcomment
564 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte
)) == comstyle
)
572 /* Assume a defun-start point is outside of strings. */
575 || (temp_byte
= dec_bytepos (from_byte
),
576 FETCH_CHAR (temp_byte
) == '\n')))
579 defun_start_byte
= from_byte
;
584 if (comstart_pos
== 0)
587 from_byte
= comment_end_byte
;
588 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
590 /* If the earliest comment starter
591 is followed by uniform paired string quotes or none,
592 we know it can't be inside a string
593 since if it were then the comment ender would be inside one.
594 So it does start a comment. Skip back to it. */
595 else if (!comnested
&& comstart_parity
== 0 && !string_lossage
)
598 from_byte
= comstart_byte
;
599 /* Globals are correct now. */
603 /* We had two kinds of string delimiters mixed up
604 together. Decode this going forwards.
605 Scan fwd from the previous comment ender
606 to the one in question; this records where we
607 last passed a comment starter. */
608 struct lisp_parse_state state
;
609 /* If we did not already find the defun start, find it now. */
610 if (defun_start
== 0)
612 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
613 defun_start_byte
= find_start_value_byte
;
615 scan_sexps_forward (&state
,
616 defun_start
, defun_start_byte
,
617 comment_end
- 1, -10000, 0, Qnil
, 0);
620 /* scan_sexps_forward changed the direction of search in
621 global variables, so we need to update it completely. */
623 from
= state
.comstr_start
;
629 from_byte
= CHAR_TO_BYTE (from
);
630 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
635 *bytepos_ptr
= from_byte
;
640 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
641 "Return t if OBJECT is a syntax table.\n\
642 Currently, any char-table counts as a syntax table.")
646 if (CHAR_TABLE_P (object
)
647 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
653 check_syntax_table (obj
)
656 if (!(CHAR_TABLE_P (obj
)
657 && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
)))
658 wrong_type_argument (Qsyntax_table_p
, obj
);
661 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
662 "Return the current syntax table.\n\
663 This is the one specified by the current buffer.")
666 return current_buffer
->syntax_table
;
669 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
670 Sstandard_syntax_table
, 0, 0, 0,
671 "Return the standard syntax table.\n\
672 This is the one used for new buffers.")
675 return Vstandard_syntax_table
;
678 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
679 "Construct a new syntax table and return it.\n\
680 It is a copy of the TABLE, which defaults to the standard syntax table.")
687 check_syntax_table (table
);
689 table
= Vstandard_syntax_table
;
691 copy
= Fcopy_sequence (table
);
693 /* Only the standard syntax table should have a default element.
694 Other syntax tables should inherit from parents instead. */
695 XCHAR_TABLE (copy
)->defalt
= Qnil
;
697 /* Copied syntax tables should all have parents.
698 If we copied one with no parent, such as the standard syntax table,
699 use the standard syntax table as the copy's parent. */
700 if (NILP (XCHAR_TABLE (copy
)->parent
))
701 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
705 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
706 "Select a new syntax table for the current buffer.\n\
707 One argument, a syntax table.")
711 check_syntax_table (table
);
712 current_buffer
->syntax_table
= table
;
713 /* Indicate that this buffer now has a specified syntax table. */
714 current_buffer
->local_var_flags
715 |= XFASTINT (buffer_local_flags
.syntax_table
);
719 /* Convert a letter which signifies a syntax code
720 into the code it signifies.
721 This is used by modify-syntax-entry, and other things. */
723 unsigned char syntax_spec_code
[0400] =
724 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
725 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
726 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
727 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
728 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
729 (char) Smath
, 0377, 0377, (char) Squote
,
730 (char) Sopen
, (char) Sclose
, 0377, 0377,
731 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
732 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
733 0377, 0377, 0377, 0377,
734 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
735 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
736 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
737 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
738 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
739 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
740 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
741 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
742 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
745 /* Indexed by syntax code, give the letter that describes it. */
747 char syntax_code_spec
[16] =
749 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
753 /* Indexed by syntax code, give the object (cons of syntax code and
754 nil) to be stored in syntax table. Since these objects can be
755 shared among syntax tables, we generate them in advance. By
756 sharing objects, the function `describe-syntax' can give a more
758 static Lisp_Object Vsyntax_code_object
;
761 /* Look up the value for CHARACTER in syntax table TABLE's parent
762 and its parents. SYNTAX_ENTRY calls this, when TABLE itself has nil
763 for CHARACTER. It's actually used only when not compiled with GCC. */
766 syntax_parent_lookup (table
, character
)
774 table
= XCHAR_TABLE (table
)->parent
;
778 value
= XCHAR_TABLE (table
)->contents
[character
];
784 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
785 "Return the syntax code of CHARACTER, described by a character.\n\
786 For example, if CHARACTER is a word constituent,\n\
787 the character `w' is returned.\n\
788 The characters that correspond to various syntax codes\n\
789 are listed in the documentation of `modify-syntax-entry'.")
791 Lisp_Object character
;
794 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
796 gl_state
.use_global
= 0;
797 CHECK_NUMBER (character
, 0);
798 char_int
= XINT (character
);
799 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
802 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
803 "Return the matching parenthesis of CHARACTER, or nil if none.")
805 Lisp_Object character
;
808 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
809 gl_state
.use_global
= 0;
810 CHECK_NUMBER (character
, 0);
811 char_int
= XINT (character
);
812 code
= SYNTAX (char_int
);
813 if (code
== Sopen
|| code
== Sclose
)
814 return SYNTAX_MATCH (char_int
);
818 /* This comment supplies the doc string for modify-syntax-entry,
819 for make-docfile to see. We cannot put this in the real DEFUN
820 due to limits in the Unix cpp.
822 DEFUN ("modify-syntax-entry", foo, bar, 2, 3, 0,
823 "Set syntax for character CHAR according to string S.\n\
824 The syntax is changed only for table TABLE, which defaults to\n\
825 the current buffer's syntax table.\n\
826 The first character of S should be one of the following:\n\
827 Space or - whitespace syntax. w word constituent.\n\
828 _ symbol constituent. . punctuation.\n\
829 ( open-parenthesis. ) close-parenthesis.\n\
830 \" string quote. \\ escape.\n\
831 $ paired delimiter. ' expression quote or prefix operator.\n\
832 < comment starter. > comment ender.\n\
833 / character-quote. @ inherit from `standard-syntax-table'.\n\
835 Only single-character comment start and end sequences are represented thus.\n\
836 Two-character sequences are represented as described below.\n\
837 The second character of S is the matching parenthesis,\n\
838 used only if the first character is `(' or `)'.\n\
839 Any additional characters are flags.\n\
840 Defined flags are the characters 1, 2, 3, 4, b, p, and n.\n\
841 1 means CHAR is the start of a two-char comment start sequence.\n\
842 2 means CHAR is the second character of such a sequence.\n\
843 3 means CHAR is the start of a two-char comment end sequence.\n\
844 4 means CHAR is the second character of such a sequence.\n\
846 There can be up to two orthogonal comment sequences. This is to support\n\
847 language modes such as C++. By default, all comment sequences are of style\n\
848 a, but you can set the comment sequence style to b (on the second character\n\
849 of a comment-start, or the first character of a comment-end sequence) using\n\
851 b means CHAR is part of comment sequence b.\n\
852 n means CHAR is part of a nestable comment sequence.\n\
854 p means CHAR is a prefix character for `backward-prefix-chars';\n\
855 such characters are treated as whitespace when they occur\n\
856 between expressions.")
860 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
861 /* I really don't know why this is interactive
862 help-form should at least be made useful whilst reading the second arg
864 "cSet syntax for character: \nsSet syntax for %s to: ",
865 0 /* See immediately above */)
866 (c
, newentry
, syntax_table
)
867 Lisp_Object c
, newentry
, syntax_table
;
869 register unsigned char *p
;
870 register enum syntaxcode code
;
875 CHECK_STRING (newentry
, 1);
877 if (NILP (syntax_table
))
878 syntax_table
= current_buffer
->syntax_table
;
880 check_syntax_table (syntax_table
);
882 p
= XSTRING (newentry
)->data
;
883 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
884 if (((int) code
& 0377) == 0377)
885 error ("invalid syntax description letter: %c", p
[-1]);
887 if (code
== Sinherit
)
889 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), Qnil
);
896 int character
= (STRING_CHAR_AND_LENGTH
897 (p
, STRING_BYTES (XSTRING (newentry
)) - 1, len
));
898 XSETINT (match
, character
);
899 if (XFASTINT (match
) == ' ')
939 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
940 newentry
= XVECTOR (Vsyntax_code_object
)->contents
[val
];
942 /* Since we can't use a shared object, let's make a new one. */
943 newentry
= Fcons (make_number (val
), match
);
945 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), newentry
);
950 /* Dump syntax table to buffer in human-readable format */
953 describe_syntax (value
)
956 register enum syntaxcode code
;
957 char desc
, start1
, start2
, end1
, end2
, prefix
, comstyle
;
959 Lisp_Object first
, match_lisp
;
961 Findent_to (make_number (16), make_number (1));
965 insert_string ("default\n");
969 if (CHAR_TABLE_P (value
))
971 insert_string ("deeper char-table ...\n");
977 insert_string ("invalid\n");
981 first
= XCAR (value
);
982 match_lisp
= XCDR (value
);
984 if (!INTEGERP (first
) || !(NILP (match_lisp
) || INTEGERP (match_lisp
)))
986 insert_string ("invalid\n");
990 code
= (enum syntaxcode
) (XINT (first
) & 0377);
991 start1
= (XINT (first
) >> 16) & 1;
992 start2
= (XINT (first
) >> 17) & 1;
993 end1
= (XINT (first
) >> 18) & 1;
994 end2
= (XINT (first
) >> 19) & 1;
995 prefix
= (XINT (first
) >> 20) & 1;
996 comstyle
= (XINT (first
) >> 21) & 1;
998 if ((int) code
< 0 || (int) code
>= (int) Smax
)
1000 insert_string ("invalid");
1003 desc
= syntax_code_spec
[(int) code
];
1005 str
[0] = desc
, str
[1] = 0;
1008 if (NILP (match_lisp
))
1011 insert_char (XINT (match_lisp
));
1028 insert_string ("\twhich means: ");
1030 switch (SWITCH_ENUM_CAST (code
))
1033 insert_string ("whitespace"); break;
1035 insert_string ("punctuation"); break;
1037 insert_string ("word"); break;
1039 insert_string ("symbol"); break;
1041 insert_string ("open"); break;
1043 insert_string ("close"); break;
1045 insert_string ("quote"); break;
1047 insert_string ("string"); break;
1049 insert_string ("math"); break;
1051 insert_string ("escape"); break;
1053 insert_string ("charquote"); break;
1055 insert_string ("comment"); break;
1057 insert_string ("endcomment"); break;
1059 insert_string ("invalid");
1063 if (!NILP (match_lisp
))
1065 insert_string (", matches ");
1066 insert_char (XINT (match_lisp
));
1070 insert_string (",\n\t is the first character of a comment-start sequence");
1072 insert_string (",\n\t is the second character of a comment-start sequence");
1075 insert_string (",\n\t is the first character of a comment-end sequence");
1077 insert_string (",\n\t is the second character of a comment-end sequence");
1079 insert_string (" (comment style b)");
1082 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
1084 insert_string ("\n");
1088 describe_syntax_1 (vector
)
1091 struct buffer
*old
= current_buffer
;
1092 set_buffer_internal (XBUFFER (Vstandard_output
));
1093 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
, (int *) 0, 0);
1094 while (! NILP (XCHAR_TABLE (vector
)->parent
))
1096 vector
= XCHAR_TABLE (vector
)->parent
;
1097 insert_string ("\nThe parent syntax table is:");
1098 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
,
1102 call0 (intern ("help-mode"));
1103 set_buffer_internal (old
);
1107 DEFUN ("describe-syntax", Fdescribe_syntax
, Sdescribe_syntax
, 0, 0, "",
1108 "Describe the syntax specifications in the syntax table.\n\
1109 The descriptions are inserted in a buffer, which is then displayed.")
1112 internal_with_output_to_temp_buffer
1113 ("*Help*", describe_syntax_1
, current_buffer
->syntax_table
);
1118 int parse_sexp_ignore_comments
;
1120 /* Return the position across COUNT words from FROM.
1121 If that many words cannot be found before the end of the buffer, return 0.
1122 COUNT negative means scan backward and stop at word beginning. */
1125 scan_words (from
, count
)
1126 register int from
, count
;
1128 register int beg
= BEGV
;
1129 register int end
= ZV
;
1130 register int from_byte
= CHAR_TO_BYTE (from
);
1131 register enum syntaxcode code
;
1137 SETUP_SYNTAX_TABLE (from
, count
);
1148 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1149 ch0
= FETCH_CHAR (from_byte
);
1150 code
= SYNTAX (ch0
);
1151 INC_BOTH (from
, from_byte
);
1152 if (words_include_escapes
1153 && (code
== Sescape
|| code
== Scharquote
))
1158 /* Now CH0 is a character which begins a word and FROM is the
1159 position of the next character. */
1162 if (from
== end
) break;
1163 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1164 ch1
= FETCH_CHAR (from_byte
);
1165 code
= SYNTAX (ch1
);
1166 if (!(words_include_escapes
1167 && (code
== Sescape
|| code
== Scharquote
)))
1168 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1170 INC_BOTH (from
, from_byte
);
1184 DEC_BOTH (from
, from_byte
);
1185 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1186 ch1
= FETCH_CHAR (from_byte
);
1187 code
= SYNTAX (ch1
);
1188 if (words_include_escapes
1189 && (code
== Sescape
|| code
== Scharquote
))
1194 /* Now CH1 is a character which ends a word and FROM is the
1202 temp_byte
= dec_bytepos (from_byte
);
1203 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1204 ch0
= FETCH_CHAR (temp_byte
);
1205 code
= SYNTAX (ch0
);
1206 if (!(words_include_escapes
1207 && (code
== Sescape
|| code
== Scharquote
)))
1208 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1210 DEC_BOTH (from
, from_byte
);
1221 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 1, 1, "p",
1222 "Move point forward ARG words (backward if ARG is negative).\n\
1223 Normally returns t.\n\
1224 If an edge of the buffer or a field boundary is reached, point is left there\n\
1225 and the function returns nil. Field boundaries are not noticed if\n\
1226 `inhibit-field-text-motion' is non-nil.")
1231 CHECK_NUMBER (count
, 0);
1233 val
= orig_val
= scan_words (PT
, XINT (count
));
1235 val
= XINT (count
) > 0 ? ZV
: BEGV
;
1237 /* Avoid jumping out of an input field. */
1238 val
= XFASTINT (Fconstrain_to_field (make_number (val
), make_number (PT
),
1242 return val
== orig_val
? Qt
: Qnil
;
1245 Lisp_Object
skip_chars ();
1247 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1248 "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
1249 STRING is like the inside of a `[...]' in a regular expression\n\
1250 except that `]' is never special and `\\' quotes `^', `-' or `\\'\n\
1251 (but not as the end of a range; quoting is never needed there).\n\
1252 Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
1253 With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
1254 Returns the distance traveled, either zero or positive.")
1256 Lisp_Object string
, lim
;
1258 return skip_chars (1, 0, string
, lim
);
1261 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1262 "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
1263 See `skip-chars-forward' for details.\n\
1264 Returns the distance traveled, either zero or negative.")
1266 Lisp_Object string
, lim
;
1268 return skip_chars (0, 0, string
, lim
);
1271 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1272 "Move point forward across chars in specified syntax classes.\n\
1273 SYNTAX is a string of syntax code characters.\n\
1274 Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
1275 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1276 This function returns the distance traveled, either zero or positive.")
1278 Lisp_Object syntax
, lim
;
1280 return skip_chars (1, 1, syntax
, lim
);
1283 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1284 "Move point backward across chars in specified syntax classes.\n\
1285 SYNTAX is a string of syntax code characters.\n\
1286 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
1287 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1288 This function returns the distance traveled, either zero or negative.")
1290 Lisp_Object syntax
, lim
;
1292 return skip_chars (0, 1, syntax
, lim
);
1296 skip_chars (forwardp
, syntaxp
, string
, lim
)
1297 int forwardp
, syntaxp
;
1298 Lisp_Object string
, lim
;
1300 register unsigned int c
;
1302 unsigned char fastmap
[0400];
1303 /* If SYNTAXP is 0, STRING may contain multi-byte form of characters
1304 of which codes don't fit in FASTMAP. In that case, we set the
1305 first byte of multibyte form (i.e. base leading-code) in FASTMAP
1306 and set the actual ranges of characters in CHAR_RANGES. In the
1307 form "X-Y" of STRING, both X and Y must belong to the same
1308 character set because a range striding across character sets is
1311 int n_char_ranges
= 0;
1313 register int i
, i_byte
;
1314 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1315 int string_multibyte
;
1318 CHECK_STRING (string
, 0);
1319 char_ranges
= (int *) alloca (XSTRING (string
)->size
* (sizeof (int)) * 2);
1320 string_multibyte
= STRING_MULTIBYTE (string
);
1321 size_byte
= STRING_BYTES (XSTRING (string
));
1324 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1326 CHECK_NUMBER_COERCE_MARKER (lim
, 0);
1328 /* In any case, don't allow scan outside bounds of buffer. */
1329 if (XINT (lim
) > ZV
)
1330 XSETFASTINT (lim
, ZV
);
1331 if (XINT (lim
) < BEGV
)
1332 XSETFASTINT (lim
, BEGV
);
1334 bzero (fastmap
, sizeof fastmap
);
1338 if (i_byte
< size_byte
1339 && XSTRING (string
)->data
[0] == '^')
1341 negate
= 1; i
++, i_byte
++;
1344 /* Find the characters specified and set their elements of fastmap.
1345 If syntaxp, each character counts as itself.
1346 Otherwise, handle backslashes and ranges specially. */
1348 while (i_byte
< size_byte
)
1352 if (string_multibyte
)
1354 c_leading_code
= XSTRING (string
)->data
[i_byte
];
1355 FETCH_STRING_CHAR_ADVANCE (c
, string
, i
, i_byte
);
1358 c
= c_leading_code
= XSTRING (string
)->data
[i_byte
++];
1360 /* Convert multibyteness between what the string has
1361 and what the buffer has. */
1363 c
= unibyte_char_to_multibyte (c
);
1368 fastmap
[syntax_spec_code
[c
& 0377]] = 1;
1373 if (i_byte
== size_byte
)
1376 if (string_multibyte
)
1378 c_leading_code
= XSTRING (string
)->data
[i_byte
];
1379 FETCH_STRING_CHAR_ADVANCE (c
, string
, i
, i_byte
);
1382 c
= c_leading_code
= XSTRING (string
)->data
[i_byte
++];
1384 if (i_byte
< size_byte
1385 && XSTRING (string
)->data
[i_byte
] == '-')
1387 unsigned int c2
, c2_leading_code
;
1389 /* Skip over the dash. */
1392 if (i_byte
== size_byte
)
1395 /* Get the end of the range. */
1396 if (string_multibyte
)
1398 c2_leading_code
= XSTRING (string
)->data
[i_byte
];
1399 FETCH_STRING_CHAR_ADVANCE (c2
, string
, i
, i_byte
);
1402 c2
= XSTRING (string
)->data
[i_byte
++];
1404 if (SINGLE_BYTE_CHAR_P (c
))
1406 if (! SINGLE_BYTE_CHAR_P (c2
))
1407 error ("Invalid charcter range: %s",
1408 XSTRING (string
)->data
);
1417 if (c_leading_code
!= c2_leading_code
)
1418 error ("Invalid charcter range: %s",
1419 XSTRING (string
)->data
);
1420 fastmap
[c_leading_code
] = 1;
1423 char_ranges
[n_char_ranges
++] = c
;
1424 char_ranges
[n_char_ranges
++] = c2
;
1430 fastmap
[c_leading_code
] = 1;
1431 if (!SINGLE_BYTE_CHAR_P (c
))
1433 char_ranges
[n_char_ranges
++] = c
;
1434 char_ranges
[n_char_ranges
++] = c
;
1440 /* If ^ was the first character, complement the fastmap. In
1441 addition, as all multibyte characters have possibility of
1442 matching, set all entries for base leading codes, which is
1443 harmless even if SYNTAXP is 1. */
1446 for (i
= 0; i
< sizeof fastmap
; i
++)
1448 if (!multibyte
|| !BASE_LEADING_CODE_P (i
))
1455 int start_point
= PT
;
1457 int pos_byte
= PT_BYTE
;
1462 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1467 if (pos
< XINT (lim
))
1468 while (fastmap
[(int) SYNTAX (FETCH_CHAR (pos_byte
))])
1470 /* Since we already checked for multibyteness,
1471 avoid using INC_BOTH which checks again. */
1474 if (pos
>= XINT (lim
))
1476 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1481 while (pos
< XINT (lim
)
1482 && fastmap
[(int) SYNTAX (FETCH_BYTE (pos
))])
1485 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1493 while (pos
> XINT (lim
))
1495 int savepos
= pos_byte
;
1496 /* Since we already checked for multibyteness,
1497 avoid using DEC_BOTH which checks again. */
1500 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
1501 if (!fastmap
[(int) SYNTAX (FETCH_CHAR (pos_byte
))])
1511 if (pos
> XINT (lim
))
1512 while (fastmap
[(int) SYNTAX (FETCH_BYTE (pos
- 1))])
1515 if (pos
<= XINT (lim
))
1517 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
1527 while (pos
< XINT (lim
) && fastmap
[(c
= FETCH_BYTE (pos_byte
))])
1529 if (!BASE_LEADING_CODE_P (c
))
1530 INC_BOTH (pos
, pos_byte
);
1531 else if (n_char_ranges
)
1533 /* We much check CHAR_RANGES for a multibyte
1535 ch
= FETCH_MULTIBYTE_CHAR (pos_byte
);
1536 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1537 if ((ch
>= char_ranges
[i
] && ch
<= char_ranges
[i
+ 1]))
1539 if (!(negate
^ (i
< n_char_ranges
)))
1542 INC_BOTH (pos
, pos_byte
);
1547 INC_BOTH (pos
, pos_byte
);
1551 while (pos
< XINT (lim
) && fastmap
[FETCH_BYTE (pos
)])
1557 while (pos
> XINT (lim
))
1559 int savepos
= pos_byte
;
1560 DEC_BOTH (pos
, pos_byte
);
1561 if (fastmap
[(c
= FETCH_BYTE (pos_byte
))])
1563 if (!BASE_LEADING_CODE_P (c
))
1565 else if (n_char_ranges
)
1567 /* We much check CHAR_RANGES for a multibyte
1569 ch
= FETCH_MULTIBYTE_CHAR (pos_byte
);
1570 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1571 if (ch
>= char_ranges
[i
] && ch
<= char_ranges
[i
+ 1])
1573 if (!(negate
^ (i
< n_char_ranges
)))
1596 while (pos
> XINT (lim
) && fastmap
[FETCH_BYTE (pos
- 1)])
1601 #if 0 /* Not needed now that a position in mid-character
1602 cannot be specified in Lisp. */
1604 /* INC_POS or DEC_POS might have moved POS over LIM. */
1605 && (forwardp
? (pos
> XINT (lim
)) : (pos
< XINT (lim
))))
1612 SET_PT_BOTH (pos
, pos_byte
);
1615 return make_number (PT
- start_point
);
1619 /* Jump over a comment, assuming we are at the beginning of one.
1620 FROM is the current position.
1621 FROM_BYTE is the bytepos corresponding to FROM.
1622 Do not move past STOP (a charpos).
1623 The comment over which we have to jump is of style STYLE
1624 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
1625 NESTING should be positive to indicate the nesting at the beginning
1626 for nested comments and should be zero or negative else.
1627 ST_COMMENT_STYLE cannot be nested.
1628 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
1629 (or 0 If the search cannot start in the middle of a two-character).
1631 If successful, return 1 and store the charpos of the comment's end
1632 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
1633 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
1634 corresponding bytepos into *BYTEPOS_PTR and the current nesting
1635 (as defined for state.incomment) in *INCOMMENT_PTR.
1637 The comment end is the last character of the comment rather than the
1638 character just after the comment.
1640 Global syntax data is assumed to initially be valid for FROM and
1641 remains valid for forward search starting at the returned position. */
1644 forw_comment (from
, from_byte
, stop
, nesting
, style
, prev_syntax
,
1645 charpos_ptr
, bytepos_ptr
, incomment_ptr
)
1646 int from
, from_byte
, stop
;
1647 int nesting
, style
, prev_syntax
;
1648 int *charpos_ptr
, *bytepos_ptr
, *incomment_ptr
;
1651 register enum syntaxcode code
;
1652 register int syntax
;
1654 if (nesting
<= 0) nesting
= -1;
1656 /* Enter the loop in the middle so that we find
1657 a 2-char comment ender if we start in the middle of it. */
1658 syntax
= prev_syntax
;
1659 if (syntax
!= 0) goto forw_incomment
;
1665 *incomment_ptr
= nesting
;
1666 *charpos_ptr
= from
;
1667 *bytepos_ptr
= from_byte
;
1670 c
= FETCH_CHAR (from_byte
);
1671 syntax
= SYNTAX_WITH_FLAGS (c
);
1672 code
= syntax
& 0xff;
1673 if (code
== Sendcomment
1674 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1676 /* we have encountered a comment end of the same style
1677 as the comment sequence which began this comment
1680 if (code
== Scomment_fence
1681 && style
== ST_COMMENT_STYLE
)
1682 /* we have encountered a comment end of the same style
1683 as the comment sequence which began this comment
1688 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
)
1689 /* we have encountered a nested comment of the same style
1690 as the comment sequence which began this comment section */
1692 INC_BOTH (from
, from_byte
);
1693 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1696 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
1697 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1698 && (c1
= FETCH_CHAR (from_byte
),
1699 SYNTAX_COMEND_SECOND (c1
)))
1702 /* we have encountered a comment end of the same style
1703 as the comment sequence which began this comment
1708 INC_BOTH (from
, from_byte
);
1709 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1714 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
1715 && (c1
= FETCH_CHAR (from_byte
),
1716 SYNTAX_COMMENT_STYLE (c1
) == style
1717 && SYNTAX_COMSTART_SECOND (c1
)))
1718 /* we have encountered a nested comment of the same style
1719 as the comment sequence which began this comment
1722 INC_BOTH (from
, from_byte
);
1723 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1727 *charpos_ptr
= from
;
1728 *bytepos_ptr
= from_byte
;
1732 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
1733 "Move forward across up to N comments. If N is negative, move backward.\n\
1734 Stop scanning if we find something other than a comment or whitespace.\n\
1735 Set point to where scanning stops.\n\
1736 If N comments are found as expected, with nothing except whitespace\n\
1737 between them, return t; otherwise return nil.")
1745 register enum syntaxcode code
;
1746 int comstyle
= 0; /* style of comment encountered */
1747 int comnested
= 0; /* whether the comment is nestable or not */
1750 int out_charpos
, out_bytepos
;
1753 CHECK_NUMBER (count
, 0);
1754 count1
= XINT (count
);
1755 stop
= count1
> 0 ? ZV
: BEGV
;
1761 from_byte
= PT_BYTE
;
1763 SETUP_SYNTAX_TABLE (from
, count1
);
1772 SET_PT_BOTH (from
, from_byte
);
1776 c
= FETCH_CHAR (from_byte
);
1778 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
1779 comnested
= SYNTAX_COMMENT_NESTED (c
);
1780 INC_BOTH (from
, from_byte
);
1781 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1783 if (from
< stop
&& comstart_first
1784 && (c1
= FETCH_CHAR (from_byte
),
1785 SYNTAX_COMSTART_SECOND (c1
)))
1787 /* We have encountered a comment start sequence and we
1788 are ignoring all text inside comments. We must record
1789 the comment style this sequence begins so that later,
1790 only a comment end of the same style actually ends
1791 the comment section. */
1793 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1794 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1795 INC_BOTH (from
, from_byte
);
1796 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1799 while (code
== Swhitespace
|| code
== Sendcomment
);
1801 if (code
== Scomment_fence
)
1802 comstyle
= ST_COMMENT_STYLE
;
1803 else if (code
!= Scomment
)
1806 DEC_BOTH (from
, from_byte
);
1807 SET_PT_BOTH (from
, from_byte
);
1810 /* We're at the start of a comment. */
1811 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
1812 &out_charpos
, &out_bytepos
, &dummy
);
1813 from
= out_charpos
; from_byte
= out_bytepos
;
1817 SET_PT_BOTH (from
, from_byte
);
1820 INC_BOTH (from
, from_byte
);
1821 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1822 /* We have skipped one comment. */
1830 int quoted
, comstart_second
;
1834 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
1839 DEC_BOTH (from
, from_byte
);
1840 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
1841 quoted
= char_quoted (from
, from_byte
);
1844 DEC_BOTH (from
, from_byte
);
1847 c
= FETCH_CHAR (from_byte
);
1850 comnested
= SYNTAX_COMMENT_NESTED (c
);
1851 if (code
== Sendcomment
)
1852 comstyle
= SYNTAX_COMMENT_STYLE (c
);
1853 comstart_second
= SYNTAX_COMSTART_SECOND (c
);
1854 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1855 && prev_char_comend_first (from
, from_byte
)
1856 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
1858 /* We must record the comment style encountered so that
1859 later, we can match only the proper comment begin
1860 sequence of the same style. */
1861 DEC_BOTH (from
, from_byte
);
1863 /* Calling char_quoted, above, set up global syntax position
1864 at the new value of FROM. */
1865 c1
= FETCH_CHAR (from_byte
);
1866 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1867 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1869 if (from
> stop
&& comstart_second
1870 && prev_char_comstart_first (from
, from_byte
)
1871 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
1874 DEC_BOTH (from
, from_byte
);
1877 if (code
== Scomment_fence
)
1879 /* Skip until first preceding unquoted comment_fence. */
1880 int found
= 0, ini
= from
, ini_byte
= from_byte
;
1884 DEC_BOTH (from
, from_byte
);
1887 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1888 c
= FETCH_CHAR (from_byte
);
1889 if (SYNTAX (c
) == Scomment_fence
1890 && !char_quoted (from
, from_byte
))
1898 from
= ini
; /* Set point to ini + 1. */
1899 from_byte
= ini_byte
;
1903 else if (code
== Sendcomment
)
1905 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
1906 &out_charpos
, &out_bytepos
);
1908 from
= out_charpos
, from_byte
= out_bytepos
;
1909 /* We have skipped one comment. */
1912 else if (code
!= Swhitespace
&& code
!= Scomment
)
1916 INC_BOTH (from
, from_byte
);
1917 SET_PT_BOTH (from
, from_byte
);
1925 SET_PT_BOTH (from
, from_byte
);
1931 scan_lists (from
, count
, depth
, sexpflag
)
1933 int count
, depth
, sexpflag
;
1936 register int stop
= count
> 0 ? ZV
: BEGV
;
1941 register enum syntaxcode code
, temp_code
;
1942 int min_depth
= depth
; /* Err out if depth gets less than this. */
1943 int comstyle
= 0; /* style of comment encountered */
1944 int comnested
= 0; /* whether the comment is nestable or not */
1946 int last_good
= from
;
1949 int out_bytepos
, out_charpos
;
1952 if (depth
> 0) min_depth
= 0;
1954 if (from
> ZV
) from
= ZV
;
1955 if (from
< BEGV
) from
= BEGV
;
1957 from_byte
= CHAR_TO_BYTE (from
);
1962 SETUP_SYNTAX_TABLE (from
, count
);
1967 int comstart_first
, prefix
;
1968 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1969 c
= FETCH_CHAR (from_byte
);
1971 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
1972 comnested
= SYNTAX_COMMENT_NESTED (c
);
1973 prefix
= SYNTAX_PREFIX (c
);
1974 if (depth
== min_depth
)
1976 INC_BOTH (from
, from_byte
);
1977 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1978 if (from
< stop
&& comstart_first
1979 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte
))
1980 && parse_sexp_ignore_comments
)
1982 /* we have encountered a comment start sequence and we
1983 are ignoring all text inside comments. We must record
1984 the comment style this sequence begins so that later,
1985 only a comment end of the same style actually ends
1986 the comment section */
1988 c1
= FETCH_CHAR (from_byte
);
1989 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1990 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1991 INC_BOTH (from
, from_byte
);
1992 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1998 switch (SWITCH_ENUM_CAST (code
))
2002 if (from
== stop
) goto lose
;
2003 INC_BOTH (from
, from_byte
);
2004 /* treat following character as a word constituent */
2007 if (depth
|| !sexpflag
) break;
2008 /* This word counts as a sexp; return at end of it. */
2011 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2013 /* Some compilers can't handle this inside the switch. */
2014 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2019 INC_BOTH (from
, from_byte
);
2020 if (from
== stop
) goto lose
;
2029 INC_BOTH (from
, from_byte
);
2033 case Scomment_fence
:
2034 comstyle
= ST_COMMENT_STYLE
;
2037 if (!parse_sexp_ignore_comments
) break;
2038 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2039 found
= forw_comment (from
, from_byte
, stop
,
2040 comnested
, comstyle
, 0,
2041 &out_charpos
, &out_bytepos
, &dummy
);
2042 from
= out_charpos
, from_byte
= out_bytepos
;
2049 INC_BOTH (from
, from_byte
);
2050 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2056 if (from
!= stop
&& c
== FETCH_CHAR (from_byte
))
2058 INC_BOTH (from
, from_byte
);
2068 if (!++depth
) goto done
;
2073 if (!--depth
) goto done
;
2074 if (depth
< min_depth
)
2075 Fsignal (Qscan_error
,
2076 Fcons (build_string ("Containing expression ends prematurely"),
2077 Fcons (make_number (last_good
),
2078 Fcons (make_number (from
), Qnil
))));
2083 temp_pos
= dec_bytepos (from_byte
);
2084 stringterm
= FETCH_CHAR (temp_pos
);
2087 if (from
>= stop
) goto lose
;
2088 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2090 ? (FETCH_CHAR (from_byte
) == stringterm
)
2091 : SYNTAX (FETCH_CHAR (from_byte
)) == Sstring_fence
)
2094 /* Some compilers can't handle this inside the switch. */
2095 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2100 INC_BOTH (from
, from_byte
);
2102 INC_BOTH (from
, from_byte
);
2104 INC_BOTH (from
, from_byte
);
2105 if (!depth
&& sexpflag
) goto done
;
2110 /* Reached end of buffer. Error if within object, return nil if between */
2111 if (depth
) goto lose
;
2116 /* End of object reached */
2125 DEC_BOTH (from
, from_byte
);
2126 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2127 c
= FETCH_CHAR (from_byte
);
2129 if (depth
== min_depth
)
2132 comnested
= SYNTAX_COMMENT_NESTED (c
);
2133 if (code
== Sendcomment
)
2134 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2135 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2136 && prev_char_comend_first (from
, from_byte
)
2137 && parse_sexp_ignore_comments
)
2139 /* We must record the comment style encountered so that
2140 later, we can match only the proper comment begin
2141 sequence of the same style. */
2142 DEC_BOTH (from
, from_byte
);
2143 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2145 c1
= FETCH_CHAR (from_byte
);
2146 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2147 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2150 /* Quoting turns anything except a comment-ender
2151 into a word character. Note that this if cannot be true
2152 if we decremented FROM in the if-statement above. */
2153 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2155 else if (SYNTAX_PREFIX (c
))
2158 switch (SWITCH_ENUM_CAST (code
))
2164 if (depth
|| !sexpflag
) break;
2165 /* This word counts as a sexp; count object finished
2166 after passing it. */
2169 temp_pos
= from_byte
;
2170 if (! NILP (current_buffer
->enable_multibyte_characters
))
2174 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2175 c1
= FETCH_CHAR (temp_pos
);
2176 temp_code
= SYNTAX (c1
);
2177 /* Don't allow comment-end to be quoted. */
2178 if (temp_code
== Sendcomment
)
2180 quoted
= char_quoted (from
- 1, temp_pos
);
2183 DEC_BOTH (from
, from_byte
);
2184 temp_pos
= dec_bytepos (temp_pos
);
2185 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2187 c1
= FETCH_CHAR (temp_pos
);
2188 temp_code
= SYNTAX (c1
);
2189 if (! (quoted
|| temp_code
== Sword
2190 || temp_code
== Ssymbol
2191 || temp_code
== Squote
))
2193 DEC_BOTH (from
, from_byte
);
2200 temp_pos
= dec_bytepos (from_byte
);
2201 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2202 if (from
!= stop
&& c
== FETCH_CHAR (temp_pos
))
2203 DEC_BOTH (from
, from_byte
);
2212 if (!++depth
) goto done2
;
2217 if (!--depth
) goto done2
;
2218 if (depth
< min_depth
)
2219 Fsignal (Qscan_error
,
2220 Fcons (build_string ("Containing expression ends prematurely"),
2221 Fcons (make_number (last_good
),
2222 Fcons (make_number (from
), Qnil
))));
2226 if (!parse_sexp_ignore_comments
)
2228 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2229 &out_charpos
, &out_bytepos
);
2231 from
= out_charpos
, from_byte
= out_bytepos
;
2234 case Scomment_fence
:
2238 DEC_BOTH (from
, from_byte
);
2239 if (from
== stop
) goto lose
;
2240 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2241 if (!char_quoted (from
, from_byte
)
2242 && SYNTAX (FETCH_CHAR (from_byte
)) == code
)
2245 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2249 stringterm
= FETCH_CHAR (from_byte
);
2252 if (from
== stop
) goto lose
;
2253 temp_pos
= from_byte
;
2254 if (! NILP (current_buffer
->enable_multibyte_characters
))
2258 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2259 if (!char_quoted (from
- 1, temp_pos
)
2260 && stringterm
== FETCH_CHAR (temp_pos
))
2262 DEC_BOTH (from
, from_byte
);
2264 DEC_BOTH (from
, from_byte
);
2265 if (!depth
&& sexpflag
) goto done2
;
2270 /* Reached start of buffer. Error if within object, return nil if between */
2271 if (depth
) goto lose
;
2282 XSETFASTINT (val
, from
);
2286 Fsignal (Qscan_error
,
2287 Fcons (build_string ("Unbalanced parentheses"),
2288 Fcons (make_number (last_good
),
2289 Fcons (make_number (from
), Qnil
))));
2294 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2295 "Scan from character number FROM by COUNT lists.\n\
2296 Returns the character number of the position thus found.\n\
2298 If DEPTH is nonzero, paren depth begins counting from that value,\n\
2299 only places where the depth in parentheses becomes zero\n\
2300 are candidates for stopping; COUNT such places are counted.\n\
2301 Thus, a positive value for DEPTH means go out levels.\n\
2303 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2305 If the beginning or end of (the accessible part of) the buffer is reached\n\
2306 and the depth is wrong, an error is signaled.\n\
2307 If the depth is right but the count is not used up, nil is returned.")
2308 (from
, count
, depth
)
2309 Lisp_Object from
, count
, depth
;
2311 CHECK_NUMBER (from
, 0);
2312 CHECK_NUMBER (count
, 1);
2313 CHECK_NUMBER (depth
, 2);
2315 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2318 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2319 "Scan from character number FROM by COUNT balanced expressions.\n\
2320 If COUNT is negative, scan backwards.\n\
2321 Returns the character number of the position thus found.\n\
2323 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2325 If the beginning or end of (the accessible part of) the buffer is reached\n\
2326 in the middle of a parenthetical grouping, an error is signaled.\n\
2327 If the beginning or end is reached between groupings\n\
2328 but before count is used up, nil is returned.")
2330 Lisp_Object from
, count
;
2332 CHECK_NUMBER (from
, 0);
2333 CHECK_NUMBER (count
, 1);
2335 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2338 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2340 "Move point backward over any number of chars with prefix syntax.\n\
2341 This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
2346 int opoint_byte
= PT_BYTE
;
2348 int pos_byte
= PT_BYTE
;
2353 SET_PT_BOTH (opoint
, opoint_byte
);
2358 SETUP_SYNTAX_TABLE (pos
, -1);
2360 DEC_BOTH (pos
, pos_byte
);
2362 while (!char_quoted (pos
, pos_byte
)
2363 /* Previous statement updates syntax table. */
2364 && ((c
= FETCH_CHAR (pos_byte
), SYNTAX (c
) == Squote
)
2365 || SYNTAX_PREFIX (c
)))
2368 opoint_byte
= pos_byte
;
2371 DEC_BOTH (pos
, pos_byte
);
2374 SET_PT_BOTH (opoint
, opoint_byte
);
2379 /* Parse forward from FROM / FROM_BYTE to END,
2380 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2381 and return a description of the state of the parse at END.
2382 If STOPBEFORE is nonzero, stop at the start of an atom.
2383 If COMMENTSTOP is 1, stop at the start of a comment.
2384 If COMMENTSTOP is -1, stop at the start or end of a comment,
2385 after the beginning of a string, or after the end of a string. */
2388 scan_sexps_forward (stateptr
, from
, from_byte
, end
, targetdepth
,
2389 stopbefore
, oldstate
, commentstop
)
2390 struct lisp_parse_state
*stateptr
;
2392 int end
, targetdepth
, stopbefore
;
2393 Lisp_Object oldstate
;
2396 struct lisp_parse_state state
;
2398 register enum syntaxcode code
;
2401 struct level
{ int last
, prev
; };
2402 struct level levelstart
[100];
2403 register struct level
*curlevel
= levelstart
;
2404 struct level
*endlevel
= levelstart
+ 100;
2405 register int depth
; /* Paren depth of current scanning location.
2406 level - levelstart equals this except
2407 when the depth becomes negative. */
2408 int mindepth
; /* Lowest DEPTH value seen. */
2409 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2411 int prev_from
; /* Keep one character before FROM. */
2413 int prev_from_syntax
;
2414 int boundary_stop
= commentstop
== -1;
2417 int out_bytepos
, out_charpos
;
2421 prev_from_byte
= from_byte
;
2423 DEC_BOTH (prev_from
, prev_from_byte
);
2425 /* Use this macro instead of `from++'. */
2427 do { prev_from = from; \
2428 prev_from_byte = from_byte; \
2430 = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte)); \
2431 INC_BOTH (from, from_byte); \
2432 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2438 if (NILP (oldstate
))
2441 state
.instring
= -1;
2442 state
.incomment
= 0;
2443 state
.comstyle
= 0; /* comment style a by default. */
2444 state
.comstr_start
= -1; /* no comment/string seen. */
2448 tem
= Fcar (oldstate
);
2454 oldstate
= Fcdr (oldstate
);
2455 oldstate
= Fcdr (oldstate
);
2456 oldstate
= Fcdr (oldstate
);
2457 tem
= Fcar (oldstate
);
2458 /* Check whether we are inside string_fence-style string: */
2459 state
.instring
= (!NILP (tem
)
2460 ? (INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2463 oldstate
= Fcdr (oldstate
);
2464 tem
= Fcar (oldstate
);
2465 state
.incomment
= (!NILP (tem
)
2466 ? (INTEGERP (tem
) ? XINT (tem
) : -1)
2469 oldstate
= Fcdr (oldstate
);
2470 tem
= Fcar (oldstate
);
2471 start_quoted
= !NILP (tem
);
2473 /* if the eighth element of the list is nil, we are in comment
2474 style a. If it is non-nil, we are in comment style b */
2475 oldstate
= Fcdr (oldstate
);
2476 oldstate
= Fcdr (oldstate
);
2477 tem
= Fcar (oldstate
);
2478 state
.comstyle
= NILP (tem
) ? 0 : (EQ (tem
, Qsyntax_table
)
2479 ? ST_COMMENT_STYLE
: 1);
2481 oldstate
= Fcdr (oldstate
);
2482 tem
= Fcar (oldstate
);
2483 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2484 oldstate
= Fcdr (oldstate
);
2485 tem
= Fcar (oldstate
);
2486 while (!NILP (tem
)) /* >= second enclosing sexps. */
2488 /* curlevel++->last ran into compiler bug on Apollo */
2489 curlevel
->last
= XINT (Fcar (tem
));
2490 if (++curlevel
== endlevel
)
2491 error ("Nesting too deep for parser");
2492 curlevel
->prev
= -1;
2493 curlevel
->last
= -1;
2500 curlevel
->prev
= -1;
2501 curlevel
->last
= -1;
2503 SETUP_SYNTAX_TABLE (prev_from
, 1);
2504 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2505 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2507 /* Enter the loop at a place appropriate for initial state. */
2509 if (state
.incomment
)
2510 goto startincomment
;
2511 if (state
.instring
>= 0)
2513 nofence
= state
.instring
!= ST_STRING_STYLE
;
2515 goto startquotedinstring
;
2518 else if (start_quoted
)
2521 #if 0 /* This seems to be redundant with the identical code above. */
2522 SETUP_SYNTAX_TABLE (prev_from
, 1);
2523 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2524 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2530 code
= prev_from_syntax
& 0xff;
2532 if (code
== Scomment
)
2534 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
2536 state
.comstr_start
= prev_from
;
2538 else if (code
== Scomment_fence
)
2540 /* Record the comment style we have entered so that only
2541 the comment-end sequence of the same style actually
2542 terminates the comment section. */
2543 state
.comstyle
= ST_COMMENT_STYLE
;
2544 state
.incomment
= -1;
2545 state
.comstr_start
= prev_from
;
2548 else if (from
< end
)
2549 if (SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
))
2550 if (c1
= FETCH_CHAR (from_byte
),
2551 SYNTAX_COMSTART_SECOND (c1
))
2552 /* Duplicate code to avoid a complex if-expression
2553 which causes trouble for the SGI compiler. */
2555 /* Record the comment style we have entered so that only
2556 the comment-end sequence of the same style actually
2557 terminates the comment section. */
2558 state
.comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte
));
2559 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
);
2560 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2561 state
.incomment
= comnested
? 1 : -1;
2562 state
.comstr_start
= prev_from
;
2567 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
2569 switch (SWITCH_ENUM_CAST (code
))
2573 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2574 curlevel
->last
= prev_from
;
2576 if (from
== end
) goto endquoted
;
2579 /* treat following character as a word constituent */
2582 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2583 curlevel
->last
= prev_from
;
2587 /* Some compilers can't handle this inside the switch. */
2588 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2594 if (from
== end
) goto endquoted
;
2606 curlevel
->prev
= curlevel
->last
;
2610 if (commentstop
== 1)
2615 if (! state
.incomment
)
2617 if (commentstop
|| boundary_stop
) goto done
;
2619 /* The (from == BEGV) test is to enter the loop in the middle so
2620 that we find a 2-char comment ender even if we start in the
2622 found
= forw_comment (from
, from_byte
, end
,
2623 state
.incomment
, state
.comstyle
,
2624 (from
== BEGV
) ? 0 : prev_from_syntax
,
2625 &out_charpos
, &out_bytepos
, &state
.incomment
);
2626 from
= out_charpos
; from_byte
= out_bytepos
;
2627 /* Beware! prev_from and friends are invalid now.
2628 Luckily, the `done' doesn't use them and the INC_FROM
2629 sets them to a sane value without looking at them. */
2630 if (!found
) goto done
;
2632 state
.incomment
= 0;
2633 state
.comstyle
= 0; /* reset the comment style */
2634 if (boundary_stop
) goto done
;
2638 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2640 /* curlevel++->last ran into compiler bug on Apollo */
2641 curlevel
->last
= prev_from
;
2642 if (++curlevel
== endlevel
)
2643 error ("Nesting too deep for parser");
2644 curlevel
->prev
= -1;
2645 curlevel
->last
= -1;
2646 if (targetdepth
== depth
) goto done
;
2651 if (depth
< mindepth
)
2653 if (curlevel
!= levelstart
)
2655 curlevel
->prev
= curlevel
->last
;
2656 if (targetdepth
== depth
) goto done
;
2661 state
.comstr_start
= from
- 1;
2662 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2663 curlevel
->last
= prev_from
;
2664 state
.instring
= (code
== Sstring
2665 ? (FETCH_CHAR (prev_from_byte
))
2667 if (boundary_stop
) goto done
;
2670 nofence
= state
.instring
!= ST_STRING_STYLE
;
2676 if (from
>= end
) goto done
;
2677 c
= FETCH_CHAR (from_byte
);
2678 /* Some compilers can't handle this inside the switch. */
2681 /* Check TEMP here so that if the char has
2682 a syntax-table property which says it is NOT
2683 a string character, it does not end the string. */
2684 if (nofence
&& c
== state
.instring
&& temp
== Sstring
)
2690 if (!nofence
) goto string_end
;
2695 startquotedinstring
:
2696 if (from
>= end
) goto endquoted
;
2702 state
.instring
= -1;
2703 curlevel
->prev
= curlevel
->last
;
2705 if (boundary_stop
) goto done
;
2714 stop
: /* Here if stopping before start of sexp. */
2715 from
= prev_from
; /* We have just fetched the char that starts it; */
2716 goto done
; /* but return the position before it. */
2721 state
.depth
= depth
;
2722 state
.mindepth
= mindepth
;
2723 state
.thislevelstart
= curlevel
->prev
;
2724 state
.prevlevelstart
2725 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
2726 state
.location
= from
;
2727 state
.levelstarts
= Qnil
;
2728 while (--curlevel
>= levelstart
)
2729 state
.levelstarts
= Fcons (make_number (curlevel
->last
),
2736 /* This comment supplies the doc string for parse-partial-sexp,
2737 for make-docfile to see. We cannot put this in the real DEFUN
2738 due to limits in the Unix cpp.
2740 DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 6, 0,
2741 "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
2742 Parsing stops at TO or when certain criteria are met;\n\
2743 point is set to where parsing stops.\n\
2744 If fifth arg STATE is omitted or nil,\n\
2745 parsing assumes that FROM is the beginning of a function.\n\
2746 Value is a list of ten elements describing final state of parsing:\n\
2747 0. depth in parens.\n\
2748 1. character address of start of innermost containing list; nil if none.\n\
2749 2. character address of start of last complete sexp terminated.\n\
2750 3. non-nil if inside a string.\n\
2751 (it is the character that will terminate the string,\n\
2752 or t if the string should be terminated by a generic string delimiter.)\n\
2753 4. nil if outside a comment, t if inside a non-nestable comment, \n\
2754 else an integer (the current comment nesting).\n\
2755 5. t if following a quote character.\n\
2756 6. the minimum paren-depth encountered during this scan.\n\
2757 7. t if in a comment of style b; `syntax-table' if the comment\n\
2758 should be terminated by a generic comment delimiter.\n\
2759 8. character address of start of comment or string; nil if not in one.\n\
2760 9. Intermediate data for continuation of parsing (subject to change).\n\
2761 If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
2762 in parentheses becomes equal to TARGETDEPTH.\n\
2763 Fourth arg STOPBEFORE non-nil means stop when come to\n\
2764 any character that starts a sexp.\n\
2765 Fifth arg STATE is a nine-element list like what this function returns.\n\
2766 It is used to initialize the state of the parse. Elements number 1, 2, 6\n\
2767 and 8 are ignored; you can leave off element 8 (the last) entirely.\n\
2768 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.\n\
2769 If it is `syntax-table', stop after the start of a comment or a string,\n\
2770 or after end of a comment or a string.")
2771 (from, to, targetdepth, stopbefore, state, commentstop)
2774 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
2775 0 /* See immediately above */)
2776 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
2777 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
2779 struct lisp_parse_state state
;
2782 if (!NILP (targetdepth
))
2784 CHECK_NUMBER (targetdepth
, 3);
2785 target
= XINT (targetdepth
);
2788 target
= -100000; /* We won't reach this depth */
2790 validate_region (&from
, &to
);
2791 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
2793 target
, !NILP (stopbefore
), oldstate
,
2795 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
2797 SET_PT (state
.location
);
2799 return Fcons (make_number (state
.depth
),
2800 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
2801 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
2802 Fcons (state
.instring
>= 0
2803 ? (state
.instring
== ST_STRING_STYLE
2804 ? Qt
: make_number (state
.instring
)) : Qnil
,
2805 Fcons (state
.incomment
< 0 ? Qt
:
2806 (state
.incomment
== 0 ? Qnil
:
2807 make_number (state
.incomment
)),
2808 Fcons (state
.quoted
? Qt
: Qnil
,
2809 Fcons (make_number (state
.mindepth
),
2810 Fcons ((state
.comstyle
2811 ? (state
.comstyle
== ST_COMMENT_STYLE
2812 ? Qsyntax_table
: Qt
) :
2814 Fcons (((state
.incomment
2815 || (state
.instring
>= 0))
2816 ? make_number (state
.comstr_start
)
2818 Fcons (state
.levelstarts
, Qnil
))))))))));
2827 /* This has to be done here, before we call Fmake_char_table. */
2828 Qsyntax_table
= intern ("syntax-table");
2829 staticpro (&Qsyntax_table
);
2831 /* Intern this now in case it isn't already done.
2832 Setting this variable twice is harmless.
2833 But don't staticpro it here--that is done in alloc.c. */
2834 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
2836 /* Create objects which can be shared among syntax tables. */
2837 Vsyntax_code_object
= Fmake_vector (make_number (13), Qnil
);
2838 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
2839 XVECTOR (Vsyntax_code_object
)->contents
[i
]
2840 = Fcons (make_number (i
), Qnil
);
2842 /* Now we are ready to set up this property, so we can
2843 create syntax tables. */
2844 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
2846 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
2848 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
2850 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
2851 for (i
= 'a'; i
<= 'z'; i
++)
2852 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2853 for (i
= 'A'; i
<= 'Z'; i
++)
2854 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2855 for (i
= '0'; i
<= '9'; i
++)
2856 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2858 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
2859 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
2861 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
2862 Fcons (make_number (Sopen
), make_number (')')));
2863 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
2864 Fcons (make_number (Sclose
), make_number ('(')));
2865 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
2866 Fcons (make_number (Sopen
), make_number (']')));
2867 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
2868 Fcons (make_number (Sclose
), make_number ('[')));
2869 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
2870 Fcons (make_number (Sopen
), make_number ('}')));
2871 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
2872 Fcons (make_number (Sclose
), make_number ('{')));
2873 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
2874 Fcons (make_number ((int) Sstring
), Qnil
));
2875 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
2876 Fcons (make_number ((int) Sescape
), Qnil
));
2878 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
2879 for (i
= 0; i
< 10; i
++)
2881 c
= "_-+*/&|<>="[i
];
2882 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2885 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
2886 for (i
= 0; i
< 12; i
++)
2888 c
= ".,;:?!#@~^'`"[i
];
2889 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2896 Qsyntax_table_p
= intern ("syntax-table-p");
2897 staticpro (&Qsyntax_table_p
);
2899 staticpro (&Vsyntax_code_object
);
2901 Qscan_error
= intern ("scan-error");
2902 staticpro (&Qscan_error
);
2903 Fput (Qscan_error
, Qerror_conditions
,
2904 Fcons (Qscan_error
, Fcons (Qerror
, Qnil
)));
2905 Fput (Qscan_error
, Qerror_message
,
2906 build_string ("Scan error"));
2908 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
2909 "Non-nil means `forward-sexp', etc., should treat comments as whitespace.");
2911 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
2912 "Non-nil means `forward-sexp', etc., grant `syntax-table' property.\n\
2913 The value of this property should be either a syntax table, or a cons\n\
2914 of the form (SYNTAXCODE . MATCHCHAR), SYNTAXCODE being the numeric\n\
2915 syntax code, MATCHCHAR being nil or the character to match (which is\n\
2916 relevant only for open/close type.");
2918 words_include_escapes
= 0;
2919 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
2920 "Non-nil means `forward-word', etc., should treat escape chars part of words.");
2922 defsubr (&Ssyntax_table_p
);
2923 defsubr (&Ssyntax_table
);
2924 defsubr (&Sstandard_syntax_table
);
2925 defsubr (&Scopy_syntax_table
);
2926 defsubr (&Sset_syntax_table
);
2927 defsubr (&Schar_syntax
);
2928 defsubr (&Smatching_paren
);
2929 defsubr (&Smodify_syntax_entry
);
2930 defsubr (&Sdescribe_syntax
);
2932 defsubr (&Sforward_word
);
2934 defsubr (&Sskip_chars_forward
);
2935 defsubr (&Sskip_chars_backward
);
2936 defsubr (&Sskip_syntax_forward
);
2937 defsubr (&Sskip_syntax_backward
);
2939 defsubr (&Sforward_comment
);
2940 defsubr (&Sscan_lists
);
2941 defsubr (&Sscan_sexps
);
2942 defsubr (&Sbackward_prefix_chars
);
2943 defsubr (&Sparse_partial_sexp
);