1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 87, 93, 94, 95, 97, 1998 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. */
30 /* Make syntax table lookup grant data in gl_state. */
31 #define SYNTAX_ENTRY_VIA_PROPERTY
34 #include "intervals.h"
36 /* We use these constants in place for comment-style and
37 string-ender-char to distinguish comments/strings started by
38 comment_fence and string_fence codes. */
40 #define ST_COMMENT_STYLE (256 + 1)
41 #define ST_STRING_STYLE (256 + 2)
44 Lisp_Object Qsyntax_table_p
, Qsyntax_table
, Qscan_error
;
46 int words_include_escapes
;
47 int parse_sexp_lookup_properties
;
49 /* Used as a temporary in SYNTAX_ENTRY and other macros in syntax.h,
50 if not compiled with GCC. No need to mark it, since it is used
51 only very temporarily. */
52 Lisp_Object syntax_temp
;
54 /* This is the internal form of the parse state used in parse-partial-sexp. */
56 struct lisp_parse_state
58 int depth
; /* Depth at end of parsing. */
59 int instring
; /* -1 if not within string, else desired terminator. */
60 int incomment
; /* -1 if in unnestable comment else comment nesting */
61 int comstyle
; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
62 int quoted
; /* Nonzero if just after an escape char at end of parsing */
63 int thislevelstart
; /* Char number of most recent start-of-expression at current level */
64 int prevlevelstart
; /* Char number of start of containing expression */
65 int location
; /* Char number at which parsing stopped. */
66 int mindepth
; /* Minimum depth seen while scanning. */
67 int comstr_start
; /* Position just after last comment/string starter. */
68 Lisp_Object levelstarts
; /* Char numbers of starts-of-expression
69 of levels (starting from outermost). */
72 /* These variables are a cache for finding the start of a defun.
73 find_start_pos is the place for which the defun start was found.
74 find_start_value is the defun start position found for it.
75 find_start_value_byte is the corresponding byte position.
76 find_start_buffer is the buffer it was found in.
77 find_start_begv is the BEGV value when it was found.
78 find_start_modiff is the value of MODIFF when it was found. */
80 static int find_start_pos
;
81 static int find_start_value
;
82 static int find_start_value_byte
;
83 static struct buffer
*find_start_buffer
;
84 static int find_start_begv
;
85 static int find_start_modiff
;
88 static int find_defun_start
P_ ((int, int));
89 static int back_comment
P_ ((int, int, int, int, int, int *, int *));
90 static int char_quoted
P_ ((int, int));
91 static Lisp_Object skip_chars
P_ ((int, int, Lisp_Object
, Lisp_Object
));
92 static Lisp_Object scan_lists
P_ ((int, int, int, int));
93 static void scan_sexps_forward
P_ ((struct lisp_parse_state
*,
95 int, Lisp_Object
, int));
98 struct gl_state_s gl_state
; /* Global state of syntax parser. */
100 INTERVAL
interval_of ();
101 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
102 to scan to property-change. */
104 /* Update gl_state to an appropriate interval which contains CHARPOS. The
105 sign of COUNT give the relative position of CHARPOS wrt the previously
106 valid interval. If INIT, only [be]_property fields of gl_state are
107 valid at start, the rest is filled basing on OBJECT.
109 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
110 direction than the intervals - or in an interval. We update the
111 current syntax-table basing on the property of this interval, and
112 update the interval to start further than CHARPOS - or be
113 NULL_INTERVAL. We also update lim_property to be the next value of
114 charpos to call this subroutine again - or be before/after the
115 start/end of OBJECT. */
118 update_syntax_table (charpos
, count
, init
, object
)
119 int charpos
, count
, init
;
122 Lisp_Object tmp_table
;
123 int cnt
= 0, doing_extra
= 0, invalidate
= 1;
128 gl_state
.start
= gl_state
.b_property
;
129 gl_state
.stop
= gl_state
.e_property
;
130 gl_state
.forward_i
= interval_of (charpos
, object
);
131 i
= gl_state
.backward_i
= gl_state
.forward_i
;
132 gl_state
.left_ok
= gl_state
.right_ok
= 1;
134 if (NULL_INTERVAL_P (i
))
136 /* interval_of updates only ->position of the return value, so
137 update the parents manually to speed up update_interval. */
138 while (!NULL_PARENT (i
))
140 if (AM_RIGHT_CHILD (i
))
141 i
->parent
->position
= i
->position
142 - LEFT_TOTAL_LENGTH (i
) + TOTAL_LENGTH (i
) /* right end */
143 - TOTAL_LENGTH (i
->parent
)
144 + LEFT_TOTAL_LENGTH (i
->parent
);
146 i
->parent
->position
= i
->position
- LEFT_TOTAL_LENGTH (i
)
150 i
= gl_state
.forward_i
;
151 gl_state
.b_property
= i
->position
- 1 - gl_state
.offset
;
152 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
155 oldi
= i
= count
> 0 ? gl_state
.forward_i
: gl_state
.backward_i
;
157 /* We are guarantied to be called with CHARPOS either in i,
159 if (NULL_INTERVAL_P (i
))
160 error ("Error in syntax_table logic for to-the-end intervals");
161 else if (charpos
< i
->position
) /* Move left. */
164 error ("Error in syntax_table logic for intervals <-");
165 /* Update the interval. */
166 i
= update_interval (i
, charpos
);
167 if (oldi
->position
!= INTERVAL_LAST_POS (i
))
170 gl_state
.right_ok
= 1; /* Invalidate the other end. */
171 gl_state
.forward_i
= i
;
172 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
175 else if (charpos
>= INTERVAL_LAST_POS (i
)) /* Move right. */
178 error ("Error in syntax_table logic for intervals ->");
179 /* Update the interval. */
180 i
= update_interval (i
, charpos
);
181 if (i
->position
!= INTERVAL_LAST_POS (oldi
))
184 gl_state
.left_ok
= 1; /* Invalidate the other end. */
185 gl_state
.backward_i
= i
;
186 gl_state
.b_property
= i
->position
- 1 - gl_state
.offset
;
189 else if (count
> 0 ? gl_state
.right_ok
: gl_state
.left_ok
)
191 /* We do not need to recalculate tmp_table. */
192 tmp_table
= gl_state
.old_prop
;
196 tmp_table
= textget (i
->plist
, Qsyntax_table
);
199 invalidate
= !EQ (tmp_table
, gl_state
.old_prop
); /* Need to invalidate? */
201 if (invalidate
) /* Did not get to adjacent interval. */
202 { /* with the same table => */
203 /* invalidate the old range. */
206 gl_state
.backward_i
= i
;
207 gl_state
.left_ok
= 1; /* Invalidate the other end. */
208 gl_state
.b_property
= i
->position
- 1 - gl_state
.offset
;
212 gl_state
.forward_i
= i
;
213 gl_state
.right_ok
= 1; /* Invalidate the other end. */
214 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
218 gl_state
.current_syntax_table
= tmp_table
;
219 gl_state
.old_prop
= tmp_table
;
220 if (EQ (Fsyntax_table_p (tmp_table
), Qt
))
222 gl_state
.use_global
= 0;
224 else if (CONSP (tmp_table
))
226 gl_state
.use_global
= 1;
227 gl_state
.global_code
= tmp_table
;
231 gl_state
.use_global
= 0;
232 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
235 while (!NULL_INTERVAL_P (i
))
237 if (cnt
&& !EQ (tmp_table
, textget (i
->plist
, Qsyntax_table
)))
240 gl_state
.right_ok
= 0;
242 gl_state
.left_ok
= 0;
245 else if (cnt
== INTERVALS_AT_ONCE
)
248 gl_state
.right_ok
= 1;
250 gl_state
.left_ok
= 1;
254 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
256 if (NULL_INTERVAL_P (i
))
257 { /* This property goes to the end. */
259 gl_state
.e_property
= gl_state
.stop
;
261 gl_state
.b_property
= gl_state
.start
;
267 gl_state
.e_property
= i
->position
- gl_state
.offset
;
268 gl_state
.forward_i
= i
;
272 gl_state
.b_property
= i
->position
+ LENGTH (i
) - 1 - gl_state
.offset
;
273 gl_state
.backward_i
= i
;
278 /* Returns TRUE if char at CHARPOS is quoted.
279 Global syntax-table data should be set up already to be good at CHARPOS
280 or after. On return global syntax data is good for lookup at CHARPOS. */
283 char_quoted (charpos
, bytepos
)
284 register int charpos
, bytepos
;
286 register enum syntaxcode code
;
287 register int beg
= BEGV
;
288 register int quoted
= 0;
291 DEC_BOTH (charpos
, bytepos
);
293 while (bytepos
>= beg
)
295 UPDATE_SYNTAX_TABLE_BACKWARD (charpos
);
296 code
= SYNTAX (FETCH_CHAR (bytepos
));
297 if (! (code
== Scharquote
|| code
== Sescape
))
300 DEC_BOTH (charpos
, bytepos
);
304 UPDATE_SYNTAX_TABLE (orig
);
308 /* Return the bytepos one character after BYTEPOS.
309 We assume that BYTEPOS is not at the end of the buffer. */
312 inc_bytepos (bytepos
)
315 if (NILP (current_buffer
->enable_multibyte_characters
))
322 /* Return the bytepos one character before BYTEPOS.
323 We assume that BYTEPOS is not at the start of the buffer. */
326 dec_bytepos (bytepos
)
329 if (NILP (current_buffer
->enable_multibyte_characters
))
336 /* Find a defun-start that is the last one before POS (or nearly the last).
337 We record what we find, so that another call in the same area
338 can return the same value right away.
340 There is no promise at which position the global syntax data is
341 valid on return from the subroutine, so the caller should explicitly
342 update the global data. */
345 find_defun_start (pos
, pos_byte
)
350 int opoint
= PT
, opoint_byte
= PT_BYTE
;
352 /* Use previous finding, if it's valid and applies to this inquiry. */
353 if (current_buffer
== find_start_buffer
354 /* Reuse the defun-start even if POS is a little farther on.
355 POS might be in the next defun, but that's ok.
356 Our value may not be the best possible, but will still be usable. */
357 && pos
<= find_start_pos
+ 1000
358 && pos
>= find_start_value
359 && BEGV
== find_start_begv
360 && MODIFF
== find_start_modiff
)
361 return find_start_value
;
363 /* Back up to start of line. */
364 scan_newline (pos
, pos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
366 /* We optimize syntax-table lookup for rare updates. Thus we accept
367 only those `^\s(' which are good in global _and_ text-property
369 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
370 gl_state
.use_global
= 0;
373 /* Open-paren at start of line means we found our defun-start. */
374 if (SYNTAX (FETCH_CHAR (PT_BYTE
)) == Sopen
)
376 SETUP_SYNTAX_TABLE (PT
+ 1, -1); /* Try again... */
377 if (SYNTAX (FETCH_CHAR (PT_BYTE
)) == Sopen
)
379 /* Now fallback to the default value. */
380 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
381 gl_state
.use_global
= 0;
383 /* Move to beg of previous line. */
384 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -2, 1);
387 /* Record what we found, for the next try. */
388 find_start_value
= PT
;
389 find_start_value_byte
= PT_BYTE
;
390 find_start_buffer
= current_buffer
;
391 find_start_modiff
= MODIFF
;
392 find_start_begv
= BEGV
;
393 find_start_pos
= pos
;
395 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
397 return find_start_value
;
400 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
403 prev_char_comend_first (pos
, pos_byte
)
408 DEC_BOTH (pos
, pos_byte
);
409 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
410 c
= FETCH_CHAR (pos_byte
);
411 val
= SYNTAX_COMEND_FIRST (c
);
412 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
416 /* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
419 prev_char_comstart_first (pos
, pos_byte
)
424 DEC_BOTH (pos
, pos_byte
);
425 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
426 c
= FETCH_CHAR (pos_byte
);
427 val
= SYNTAX_COMSTART_FIRST (c
);
428 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
432 /* Checks whether charpos FROM is at the end of a comment.
433 FROM_BYTE is the bytepos corresponding to FROM.
434 Do not move back before STOP.
436 Return a positive value if we find a comment ending at FROM/FROM_BYTE;
439 If successful, store the charpos of the comment's beginning
440 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
442 Global syntax data remains valid for backward search starting at
443 the returned value (or at FROM, if the search was not successful). */
446 back_comment (from
, from_byte
, stop
, comnested
, comstyle
, charpos_ptr
, bytepos_ptr
)
447 int from
, from_byte
, stop
;
448 int comnested
, comstyle
;
449 int *charpos_ptr
, *bytepos_ptr
;
451 /* Look back, counting the parity of string-quotes,
452 and recording the comment-starters seen.
453 When we reach a safe place, assume that's not in a string;
454 then step the main scan to the earliest comment-starter seen
455 an even number of string quotes away from the safe place.
457 OFROM[I] is position of the earliest comment-starter seen
458 which is I+2X quotes from the comment-end.
459 PARITY is current parity of quotes from the comment end. */
461 int my_stringend
= 0;
462 int string_lossage
= 0;
463 int comment_end
= from
;
464 int comment_end_byte
= from_byte
;
465 int comstart_pos
= 0;
467 /* Value that PARITY had, when we reached the position
469 int comstart_parity
= 0;
470 int scanstart
= from
- 1;
471 /* Place where the containing defun starts,
472 or 0 if we didn't come across it yet. */
474 int defun_start_byte
= 0;
475 register enum syntaxcode code
;
476 int nesting
= 1; /* current comment nesting */
479 /* At beginning of range to scan, we're outside of strings;
480 that determines quote parity to the comment-end. */
483 int temp_byte
, prev_comend_second
;
485 /* Move back and examine a character. */
486 DEC_BOTH (from
, from_byte
);
487 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
489 c
= FETCH_CHAR (from_byte
);
492 /* If this char is the second of a 2-char comment end sequence,
493 back up and give the pair the appropriate syntax. */
494 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
495 && prev_char_comend_first (from
, from_byte
))
498 DEC_BOTH (from
, from_byte
);
499 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
500 c
= FETCH_CHAR (from_byte
);
503 /* If this char starts a 2-char comment start sequence,
504 treat it like a 1-char comment starter. */
505 if (from
< scanstart
&& SYNTAX_COMSTART_FIRST (c
))
507 temp_byte
= inc_bytepos (from_byte
);
508 UPDATE_SYNTAX_TABLE_FORWARD (from
+ 1);
509 if (SYNTAX_COMSTART_SECOND (FETCH_CHAR (temp_byte
))
510 && comstyle
== SYNTAX_COMMENT_STYLE (FETCH_CHAR (temp_byte
)))
512 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
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 /* FIXME: we should also check that the comstyle is correct
546 if the Scomment is a single-char. */
548 if (comnested
&& --nesting
<= 0 && parity
== 0 && !string_lossage
)
549 /* nested comments have to be balanced, so we don't need to
550 keep looking for earlier ones. We use here the same (slightly
551 incorrect) reasoning as below: since it is followed by uniform
552 paired string quotes, this comment-start has to be outside of
553 strings, else the comment-end itself would be inside a string. */
556 /* Record comment-starters according to that
557 quote-parity to the comment-end. */
558 comstart_parity
= parity
;
560 comstart_byte
= from_byte
;
563 /* If we find another earlier comment-ender,
564 any comment-starts earlier than that don't count
565 (because they go with the earlier comment-ender). */
566 if (code
== Sendcomment
567 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte
)) == comstyle
)
573 /* Assume a defun-start point is outside of strings. */
576 || (temp_byte
= dec_bytepos (from_byte
),
577 FETCH_CHAR (temp_byte
) == '\n')))
580 defun_start_byte
= from_byte
;
585 if (comstart_pos
== 0)
588 from_byte
= comment_end_byte
;
589 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
591 /* If the earliest comment starter
592 is followed by uniform paired string quotes or none,
593 we know it can't be inside a string
594 since if it were then the comment ender would be inside one.
595 So it does start a comment. Skip back to it. */
596 else if (!comnested
&& comstart_parity
== 0 && !string_lossage
)
599 from_byte
= comstart_byte
;
600 /* Globals are correct now. */
604 /* We had two kinds of string delimiters mixed up
605 together. Decode this going forwards.
606 Scan fwd from the previous comment ender
607 to the one in question; this records where we
608 last passed a comment starter. */
609 struct lisp_parse_state state
;
610 /* If we did not already find the defun start, find it now. */
611 if (defun_start
== 0)
613 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
614 defun_start_byte
= find_start_value_byte
;
616 scan_sexps_forward (&state
,
617 defun_start
, defun_start_byte
,
618 comment_end
- 1, -10000, 0, Qnil
, 0);
621 /* scan_sexps_forward changed the direction of search in
622 global variables, so we need to update it completely. */
624 from
= state
.comstr_start
;
630 from_byte
= CHAR_TO_BYTE (from
);
631 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
636 *bytepos_ptr
= from_byte
;
641 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
642 "Return t if OBJECT is a syntax table.\n\
643 Currently, any char-table counts as a syntax table.")
647 if (CHAR_TABLE_P (object
)
648 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
654 check_syntax_table (obj
)
657 if (!(CHAR_TABLE_P (obj
)
658 && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
)))
659 wrong_type_argument (Qsyntax_table_p
, obj
);
662 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
663 "Return the current syntax table.\n\
664 This is the one specified by the current buffer.")
667 return current_buffer
->syntax_table
;
670 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
671 Sstandard_syntax_table
, 0, 0, 0,
672 "Return the standard syntax table.\n\
673 This is the one used for new buffers.")
676 return Vstandard_syntax_table
;
679 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
680 "Construct a new syntax table and return it.\n\
681 It is a copy of the TABLE, which defaults to the standard syntax table.")
688 check_syntax_table (table
);
690 table
= Vstandard_syntax_table
;
692 copy
= Fcopy_sequence (table
);
694 /* Only the standard syntax table should have a default element.
695 Other syntax tables should inherit from parents instead. */
696 XCHAR_TABLE (copy
)->defalt
= Qnil
;
698 /* Copied syntax tables should all have parents.
699 If we copied one with no parent, such as the standard syntax table,
700 use the standard syntax table as the copy's parent. */
701 if (NILP (XCHAR_TABLE (copy
)->parent
))
702 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
706 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
707 "Select a new syntax table for the current buffer.\n\
708 One argument, a syntax table.")
712 check_syntax_table (table
);
713 current_buffer
->syntax_table
= table
;
714 /* Indicate that this buffer now has a specified syntax table. */
715 current_buffer
->local_var_flags
716 |= XFASTINT (buffer_local_flags
.syntax_table
);
720 /* Convert a letter which signifies a syntax code
721 into the code it signifies.
722 This is used by modify-syntax-entry, and other things. */
724 unsigned char syntax_spec_code
[0400] =
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 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
729 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
730 (char) Smath
, 0377, 0377, (char) Squote
,
731 (char) Sopen
, (char) Sclose
, 0377, 0377,
732 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
733 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
734 0377, 0377, 0377, 0377,
735 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
736 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
737 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
738 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
739 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
740 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
741 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
742 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
743 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
746 /* Indexed by syntax code, give the letter that describes it. */
748 char syntax_code_spec
[16] =
750 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
754 /* Indexed by syntax code, give the object (cons of syntax code and
755 nil) to be stored in syntax table. Since these objects can be
756 shared among syntax tables, we generate them in advance. By
757 sharing objects, the function `describe-syntax' can give a more
759 static Lisp_Object Vsyntax_code_object
;
762 /* Look up the value for CHARACTER in syntax table TABLE's parent
763 and its parents. SYNTAX_ENTRY calls this, when TABLE itself has nil
764 for CHARACTER. It's actually used only when not compiled with GCC. */
767 syntax_parent_lookup (table
, character
)
775 table
= XCHAR_TABLE (table
)->parent
;
779 value
= XCHAR_TABLE (table
)->contents
[character
];
785 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
786 "Return the syntax code of CHARACTER, described by a character.\n\
787 For example, if CHARACTER is a word constituent,\n\
788 the character `w' is returned.\n\
789 The characters that correspond to various syntax codes\n\
790 are listed in the documentation of `modify-syntax-entry'.")
792 Lisp_Object character
;
795 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
797 gl_state
.use_global
= 0;
798 CHECK_NUMBER (character
, 0);
799 char_int
= XINT (character
);
800 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
803 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
804 "Return the matching parenthesis of CHARACTER, or nil if none.")
806 Lisp_Object character
;
809 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
810 gl_state
.use_global
= 0;
811 CHECK_NUMBER (character
, 0);
812 char_int
= XINT (character
);
813 code
= SYNTAX (char_int
);
814 if (code
== Sopen
|| code
== Sclose
)
815 return SYNTAX_MATCH (char_int
);
819 /* This comment supplies the doc string for modify-syntax-entry,
820 for make-docfile to see. We cannot put this in the real DEFUN
821 due to limits in the Unix cpp.
823 DEFUN ("modify-syntax-entry", foo, bar, 2, 3, 0,
824 "Set syntax for character CHAR according to string S.\n\
825 The syntax is changed only for table TABLE, which defaults to\n\
826 the current buffer's syntax table.\n\
827 The first character of S should be one of the following:\n\
828 Space or - whitespace syntax. w word constituent.\n\
829 _ symbol constituent. . punctuation.\n\
830 ( open-parenthesis. ) close-parenthesis.\n\
831 \" string quote. \\ escape.\n\
832 $ paired delimiter. ' expression quote or prefix operator.\n\
833 < comment starter. > comment ender.\n\
834 / character-quote. @ inherit from `standard-syntax-table'.\n\
836 Only single-character comment start and end sequences are represented thus.\n\
837 Two-character sequences are represented as described below.\n\
838 The second character of S is the matching parenthesis,\n\
839 used only if the first character is `(' or `)'.\n\
840 Any additional characters are flags.\n\
841 Defined flags are the characters 1, 2, 3, 4, b, p, and n.\n\
842 1 means CHAR is the start of a two-char comment start sequence.\n\
843 2 means CHAR is the second character of such a sequence.\n\
844 3 means CHAR is the start of a two-char comment end sequence.\n\
845 4 means CHAR is the second character of such a sequence.\n\
847 There can be up to two orthogonal comment sequences. This is to support\n\
848 language modes such as C++. By default, all comment sequences are of style\n\
849 a, but you can set the comment sequence style to b (on the second character\n\
850 of a comment-start, or the first character of a comment-end sequence) using\n\
852 b means CHAR is part of comment sequence b.\n\
853 n means CHAR is part of a nestable comment sequence.\n\
855 p means CHAR is a prefix character for `backward-prefix-chars';\n\
856 such characters are treated as whitespace when they occur\n\
857 between expressions.")
861 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
862 /* I really don't know why this is interactive
863 help-form should at least be made useful whilst reading the second arg
865 "cSet syntax for character: \nsSet syntax for %s to: ",
866 0 /* See immediately above */)
867 (c
, newentry
, syntax_table
)
868 Lisp_Object c
, newentry
, syntax_table
;
870 register unsigned char *p
;
871 register enum syntaxcode code
;
876 CHECK_STRING (newentry
, 1);
878 if (NILP (syntax_table
))
879 syntax_table
= current_buffer
->syntax_table
;
881 check_syntax_table (syntax_table
);
883 p
= XSTRING (newentry
)->data
;
884 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
885 if (((int) code
& 0377) == 0377)
886 error ("invalid syntax description letter: %c", p
[-1]);
888 if (code
== Sinherit
)
890 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), Qnil
);
897 int character
= (STRING_CHAR_AND_LENGTH
898 (p
, STRING_BYTES (XSTRING (newentry
)) - 1, len
));
899 XSETINT (match
, character
);
900 if (XFASTINT (match
) == ' ')
940 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
941 newentry
= XVECTOR (Vsyntax_code_object
)->contents
[val
];
943 /* Since we can't use a shared object, let's make a new one. */
944 newentry
= Fcons (make_number (val
), match
);
946 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), newentry
);
951 /* Dump syntax table to buffer in human-readable format */
954 describe_syntax (value
)
957 register enum syntaxcode code
;
958 char desc
, match
, start1
, start2
, end1
, end2
, prefix
, comstyle
;
960 Lisp_Object first
, match_lisp
;
962 Findent_to (make_number (16), make_number (1));
966 insert_string ("default\n");
970 if (CHAR_TABLE_P (value
))
972 insert_string ("deeper char-table ...\n");
978 insert_string ("invalid\n");
982 first
= XCONS (value
)->car
;
983 match_lisp
= XCONS (value
)->cdr
;
985 if (!INTEGERP (first
) || !(NILP (match_lisp
) || INTEGERP (match_lisp
)))
987 insert_string ("invalid\n");
991 code
= (enum syntaxcode
) (XINT (first
) & 0377);
992 start1
= (XINT (first
) >> 16) & 1;
993 start2
= (XINT (first
) >> 17) & 1;
994 end1
= (XINT (first
) >> 18) & 1;
995 end2
= (XINT (first
) >> 19) & 1;
996 prefix
= (XINT (first
) >> 20) & 1;
997 comstyle
= (XINT (first
) >> 21) & 1;
999 if ((int) code
< 0 || (int) code
>= (int) Smax
)
1001 insert_string ("invalid");
1004 desc
= syntax_code_spec
[(int) code
];
1006 str
[0] = desc
, str
[1] = 0;
1009 if (NILP (match_lisp
))
1012 insert_char (XINT (match_lisp
));
1029 insert_string ("\twhich means: ");
1031 switch (SWITCH_ENUM_CAST (code
))
1034 insert_string ("whitespace"); break;
1036 insert_string ("punctuation"); break;
1038 insert_string ("word"); break;
1040 insert_string ("symbol"); break;
1042 insert_string ("open"); break;
1044 insert_string ("close"); break;
1046 insert_string ("quote"); break;
1048 insert_string ("string"); break;
1050 insert_string ("math"); break;
1052 insert_string ("escape"); break;
1054 insert_string ("charquote"); break;
1056 insert_string ("comment"); break;
1058 insert_string ("endcomment"); break;
1060 insert_string ("invalid");
1064 if (!NILP (match_lisp
))
1066 insert_string (", matches ");
1067 insert_char (XINT (match_lisp
));
1071 insert_string (",\n\t is the first character of a comment-start sequence");
1073 insert_string (",\n\t is the second character of a comment-start sequence");
1076 insert_string (",\n\t is the first character of a comment-end sequence");
1078 insert_string (",\n\t is the second character of a comment-end sequence");
1080 insert_string (" (comment style b)");
1083 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
1085 insert_string ("\n");
1089 describe_syntax_1 (vector
)
1092 struct buffer
*old
= current_buffer
;
1093 set_buffer_internal (XBUFFER (Vstandard_output
));
1094 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
, (int *) 0, 0);
1095 while (! NILP (XCHAR_TABLE (vector
)->parent
))
1097 vector
= XCHAR_TABLE (vector
)->parent
;
1098 insert_string ("\nThe parent syntax table is:");
1099 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
,
1103 call0 (intern ("help-mode"));
1104 set_buffer_internal (old
);
1108 DEFUN ("describe-syntax", Fdescribe_syntax
, Sdescribe_syntax
, 0, 0, "",
1109 "Describe the syntax specifications in the syntax table.\n\
1110 The descriptions are inserted in a buffer, which is then displayed.")
1113 internal_with_output_to_temp_buffer
1114 ("*Help*", describe_syntax_1
, current_buffer
->syntax_table
);
1119 int parse_sexp_ignore_comments
;
1121 /* Return the position across COUNT words from FROM.
1122 If that many words cannot be found before the end of the buffer, return 0.
1123 COUNT negative means scan backward and stop at word beginning. */
1126 scan_words (from
, count
)
1127 register int from
, count
;
1129 register int beg
= BEGV
;
1130 register int end
= ZV
;
1131 register int from_byte
= CHAR_TO_BYTE (from
);
1132 register enum syntaxcode code
;
1138 SETUP_SYNTAX_TABLE (from
, count
);
1149 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1150 ch0
= FETCH_CHAR (from_byte
);
1151 code
= SYNTAX (ch0
);
1152 INC_BOTH (from
, from_byte
);
1153 if (words_include_escapes
1154 && (code
== Sescape
|| code
== Scharquote
))
1159 /* Now CH0 is a character which begins a word and FROM is the
1160 position of the next character. */
1163 if (from
== end
) break;
1164 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1165 ch1
= FETCH_CHAR (from_byte
);
1166 code
= SYNTAX (ch1
);
1167 if (!(words_include_escapes
1168 && (code
== Sescape
|| code
== Scharquote
)))
1169 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1171 INC_BOTH (from
, from_byte
);
1185 DEC_BOTH (from
, from_byte
);
1186 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1187 ch1
= FETCH_CHAR (from_byte
);
1188 code
= SYNTAX (ch1
);
1189 if (words_include_escapes
1190 && (code
== Sescape
|| code
== Scharquote
))
1195 /* Now CH1 is a character which ends a word and FROM is the
1203 temp_byte
= dec_bytepos (from_byte
);
1204 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1205 ch0
= FETCH_CHAR (temp_byte
);
1206 code
= SYNTAX (ch0
);
1207 if (!(words_include_escapes
1208 && (code
== Sescape
|| code
== Scharquote
)))
1209 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1211 DEC_BOTH (from
, from_byte
);
1222 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 1, 1, "p",
1223 "Move point forward ARG words (backward if ARG is negative).\n\
1224 Normally returns t.\n\
1225 If an edge of the buffer is reached, point is left there\n\
1226 and nil is returned.")
1230 int val
, prompt_end
;
1231 CHECK_NUMBER (count
, 0);
1233 if (!(val
= scan_words (PT
, XINT (count
))))
1235 SET_PT (XINT (count
) > 0 ? ZV
: BEGV
);
1239 /* If in a mini-buffer and moving backwards, stop at the end of the
1240 prompt. This prevents accidentially moving into the read-only
1242 if (INTEGERP (current_buffer
->minibuffer_prompt_length
)
1243 && (prompt_end
= XINT (current_buffer
->minibuffer_prompt_length
),
1244 ((PT
> prompt_end
&& val
< prompt_end
)
1245 || (PT
< prompt_end
&& val
> prompt_end
))))
1252 Lisp_Object
skip_chars ();
1254 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1255 "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
1256 STRING is like the inside of a `[...]' in a regular expression\n\
1257 except that `]' is never special and `\\' quotes `^', `-' or `\\'\n\
1258 (but not as the end of a range; quoting is never needed there).\n\
1259 Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
1260 With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
1261 Returns the distance traveled, either zero or positive.")
1263 Lisp_Object string
, lim
;
1265 return skip_chars (1, 0, string
, lim
);
1268 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1269 "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
1270 See `skip-chars-forward' for details.\n\
1271 Returns the distance traveled, either zero or negative.")
1273 Lisp_Object string
, lim
;
1275 return skip_chars (0, 0, string
, lim
);
1278 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1279 "Move point forward across chars in specified syntax classes.\n\
1280 SYNTAX is a string of syntax code characters.\n\
1281 Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
1282 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1283 This function returns the distance traveled, either zero or positive.")
1285 Lisp_Object syntax
, lim
;
1287 return skip_chars (1, 1, syntax
, lim
);
1290 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1291 "Move point backward across chars in specified syntax classes.\n\
1292 SYNTAX is a string of syntax code characters.\n\
1293 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
1294 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1295 This function returns the distance traveled, either zero or negative.")
1297 Lisp_Object syntax
, lim
;
1299 return skip_chars (0, 1, syntax
, lim
);
1303 skip_chars (forwardp
, syntaxp
, string
, lim
)
1304 int forwardp
, syntaxp
;
1305 Lisp_Object string
, lim
;
1307 register unsigned char *p
, *pend
;
1308 register unsigned int c
;
1310 unsigned char fastmap
[0400];
1311 /* If SYNTAXP is 0, STRING may contain multi-byte form of characters
1312 of which codes don't fit in FASTMAP. In that case, we set the
1313 first byte of multibyte form (i.e. base leading-code) in FASTMAP
1314 and set the actual ranges of characters in CHAR_RANGES. In the
1315 form "X-Y" of STRING, both X and Y must belong to the same
1316 character set because a range striding across character sets is
1319 int n_char_ranges
= 0;
1321 register int i
, i_byte
;
1322 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1323 int string_multibyte
;
1326 CHECK_STRING (string
, 0);
1327 char_ranges
= (int *) alloca (XSTRING (string
)->size
* (sizeof (int)) * 2);
1328 string_multibyte
= STRING_MULTIBYTE (string
);
1329 size_byte
= STRING_BYTES (XSTRING (string
));
1332 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1334 CHECK_NUMBER_COERCE_MARKER (lim
, 0);
1336 /* In any case, don't allow scan outside bounds of buffer. */
1337 if (XINT (lim
) > ZV
)
1338 XSETFASTINT (lim
, ZV
);
1339 if (XINT (lim
) < BEGV
)
1340 XSETFASTINT (lim
, BEGV
);
1342 bzero (fastmap
, sizeof fastmap
);
1346 if (i_byte
< size_byte
1347 && XSTRING (string
)->data
[0] == '^')
1349 negate
= 1; i
++, i_byte
++;
1352 /* Find the characters specified and set their elements of fastmap.
1353 If syntaxp, each character counts as itself.
1354 Otherwise, handle backslashes and ranges specially. */
1356 while (i_byte
< size_byte
)
1360 if (string_multibyte
)
1362 c_leading_code
= XSTRING (string
)->data
[i_byte
];
1363 FETCH_STRING_CHAR_ADVANCE (c
, string
, i
, i_byte
);
1366 c
= c_leading_code
= XSTRING (string
)->data
[i_byte
++];
1368 /* Convert multibyteness between what the string has
1369 and what the buffer has. */
1371 c
= unibyte_char_to_multibyte (c
);
1376 fastmap
[syntax_spec_code
[c
& 0377]] = 1;
1381 if (i_byte
== size_byte
)
1384 if (string_multibyte
)
1386 c_leading_code
= XSTRING (string
)->data
[i_byte
];
1387 FETCH_STRING_CHAR_ADVANCE (c
, string
, i
, i_byte
);
1390 c
= c_leading_code
= XSTRING (string
)->data
[i_byte
++];
1392 if (i_byte
< size_byte
1393 && XSTRING (string
)->data
[i_byte
] == '-')
1395 unsigned int c2
, c2_leading_code
;
1397 /* Skip over the dash. */
1400 if (i_byte
== size_byte
)
1403 /* Get the end of the range. */
1404 if (string_multibyte
)
1406 c2_leading_code
= XSTRING (string
)->data
[i_byte
];
1407 FETCH_STRING_CHAR_ADVANCE (c2
, string
, i
, i_byte
);
1410 c2
= XSTRING (string
)->data
[i_byte
++];
1412 if (SINGLE_BYTE_CHAR_P (c
))
1414 if (! SINGLE_BYTE_CHAR_P (c2
))
1415 error ("Invalid charcter range: %s",
1416 XSTRING (string
)->data
);
1425 if (c_leading_code
!= c2_leading_code
)
1426 error ("Invalid charcter range: %s",
1427 XSTRING (string
)->data
);
1428 fastmap
[c_leading_code
] = 1;
1431 char_ranges
[n_char_ranges
++] = c
;
1432 char_ranges
[n_char_ranges
++] = c2
;
1438 fastmap
[c_leading_code
] = 1;
1439 if (!SINGLE_BYTE_CHAR_P (c
))
1441 char_ranges
[n_char_ranges
++] = c
;
1442 char_ranges
[n_char_ranges
++] = c
;
1448 /* If ^ was the first character, complement the fastmap. In
1449 addition, as all multibyte characters have possibility of
1450 matching, set all entries for base leading codes, which is
1451 harmless even if SYNTAXP is 1. */
1454 for (i
= 0; i
< sizeof fastmap
; i
++)
1456 if (!multibyte
|| !BASE_LEADING_CODE_P (i
))
1463 int start_point
= PT
;
1465 int pos_byte
= PT_BYTE
;
1470 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1475 if (pos
< XINT (lim
))
1476 while (fastmap
[(int) SYNTAX (FETCH_CHAR (pos_byte
))])
1478 /* Since we already checked for multibyteness,
1479 avoid using INC_BOTH which checks again. */
1482 if (pos
>= XINT (lim
))
1484 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1489 while (pos
< XINT (lim
)
1490 && fastmap
[(int) SYNTAX (FETCH_BYTE (pos
))])
1493 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1501 while (pos
> XINT (lim
))
1503 int savepos
= pos_byte
;
1504 /* Since we already checked for multibyteness,
1505 avoid using DEC_BOTH which checks again. */
1508 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
1509 if (!fastmap
[(int) SYNTAX (FETCH_CHAR (pos_byte
))])
1519 if (pos
> XINT (lim
))
1520 while (fastmap
[(int) SYNTAX (FETCH_BYTE (pos
- 1))])
1523 if (pos
<= XINT (lim
))
1525 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
1535 while (pos
< XINT (lim
) && fastmap
[(c
= FETCH_BYTE (pos_byte
))])
1537 if (!BASE_LEADING_CODE_P (c
))
1538 INC_BOTH (pos
, pos_byte
);
1539 else if (n_char_ranges
)
1541 /* We much check CHAR_RANGES for a multibyte
1543 ch
= FETCH_MULTIBYTE_CHAR (pos_byte
);
1544 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1545 if ((ch
>= char_ranges
[i
] && ch
<= char_ranges
[i
+ 1]))
1547 if (!(negate
^ (i
< n_char_ranges
)))
1550 INC_BOTH (pos
, pos_byte
);
1555 INC_BOTH (pos
, pos_byte
);
1559 while (pos
< XINT (lim
) && fastmap
[FETCH_BYTE (pos
)])
1565 while (pos
> XINT (lim
))
1567 int savepos
= pos_byte
;
1568 DEC_BOTH (pos
, pos_byte
);
1569 if (fastmap
[(c
= FETCH_BYTE (pos_byte
))])
1571 if (!BASE_LEADING_CODE_P (c
))
1573 else if (n_char_ranges
)
1575 /* We much check CHAR_RANGES for a multibyte
1577 ch
= FETCH_MULTIBYTE_CHAR (pos_byte
);
1578 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1579 if (ch
>= char_ranges
[i
] && ch
<= char_ranges
[i
+ 1])
1581 if (!(negate
^ (i
< n_char_ranges
)))
1604 while (pos
> XINT (lim
) && fastmap
[FETCH_BYTE (pos
- 1)])
1609 #if 0 /* Not needed now that a position in mid-character
1610 cannot be specified in Lisp. */
1612 /* INC_POS or DEC_POS might have moved POS over LIM. */
1613 && (forwardp
? (pos
> XINT (lim
)) : (pos
< XINT (lim
))))
1620 SET_PT_BOTH (pos
, pos_byte
);
1623 return make_number (PT
- start_point
);
1627 /* Jump over a comment, assuming we are at the beginning of one.
1628 FROM is the current position.
1629 FROM_BYTE is the bytepos corresponding to FROM.
1630 Do not move past STOP (a charpos).
1631 The comment over which we have to jump is of style STYLE
1632 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
1633 NESTING should be positive to indicate the nesting at the beginning
1634 for nested comments and should be zero or negative else.
1635 ST_COMMENT_STYLE cannot be nested.
1636 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
1637 (or 0 If the search cannot start in the middle of a two-character).
1639 If successful, return 1 and store the charpos of the comment's end
1640 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
1641 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
1642 corresponding bytepos into *BYTEPOS_PTR and the current nesting
1643 (as defined for state.incomment) in *INCOMMENT_PTR.
1645 The comment end is the last character of the comment rather than the
1646 character just after the comment.
1648 Global syntax data is assumed to initially be valid for FROM and
1649 remains valid for forward search starting at the returned position. */
1652 forw_comment (from
, from_byte
, stop
, nesting
, style
, prev_syntax
,
1653 charpos_ptr
, bytepos_ptr
, incomment_ptr
)
1654 int from
, from_byte
, stop
;
1655 int nesting
, style
, prev_syntax
;
1656 int *charpos_ptr
, *bytepos_ptr
, *incomment_ptr
;
1659 register enum syntaxcode code
;
1660 register int syntax
;
1662 if (nesting
<= 0) nesting
= -1;
1664 /* Enter the loop in the middle so that we find
1665 a 2-char comment ender if we start in the middle of it. */
1666 syntax
= prev_syntax
;
1667 if (syntax
!= 0) goto forw_incomment
;
1673 *incomment_ptr
= nesting
;
1674 *charpos_ptr
= from
;
1675 *bytepos_ptr
= from_byte
;
1678 c
= FETCH_CHAR (from_byte
);
1679 syntax
= SYNTAX_WITH_FLAGS (c
);
1680 code
= syntax
& 0xff;
1681 if (code
== Sendcomment
1682 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1684 /* we have encountered a comment end of the same style
1685 as the comment sequence which began this comment
1688 if (code
== Scomment_fence
1689 && style
== ST_COMMENT_STYLE
)
1690 /* we have encountered a comment end of the same style
1691 as the comment sequence which began this comment
1696 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
)
1697 /* we have encountered a nested comment of the same style
1698 as the comment sequence which began this comment section */
1700 INC_BOTH (from
, from_byte
);
1701 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1704 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
1705 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1706 && (c1
= FETCH_CHAR (from_byte
),
1707 SYNTAX_COMEND_SECOND (c1
)))
1709 /* we have encountered a comment end of the same style
1710 as the comment sequence which began this comment
1715 INC_BOTH (from
, from_byte
);
1716 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1720 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
1721 && (c1
= FETCH_CHAR (from_byte
),
1722 SYNTAX_COMMENT_STYLE (c1
) == style
1723 && SYNTAX_COMSTART_SECOND (c1
)))
1724 /* we have encountered a nested comment of the same style
1725 as the comment sequence which began this comment
1728 INC_BOTH (from
, from_byte
);
1729 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1733 *charpos_ptr
= from
;
1734 *bytepos_ptr
= from_byte
;
1738 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
1739 "Move forward across up to N comments. If N is negative, move backward.\n\
1740 Stop scanning if we find something other than a comment or whitespace.\n\
1741 Set point to where scanning stops.\n\
1742 If N comments are found as expected, with nothing except whitespace\n\
1743 between them, return t; otherwise return nil.")
1751 register enum syntaxcode code
;
1752 int comstyle
= 0; /* style of comment encountered */
1753 int comnested
= 0; /* whether the comment is nestable or not */
1756 int out_charpos
, out_bytepos
;
1759 CHECK_NUMBER (count
, 0);
1760 count1
= XINT (count
);
1761 stop
= count1
> 0 ? ZV
: BEGV
;
1767 from_byte
= PT_BYTE
;
1769 SETUP_SYNTAX_TABLE (from
, count1
);
1778 SET_PT_BOTH (from
, from_byte
);
1782 c
= FETCH_CHAR (from_byte
);
1784 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
1785 comnested
= SYNTAX_COMMENT_NESTED (c
);
1786 INC_BOTH (from
, from_byte
);
1787 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1789 if (from
< stop
&& comstart_first
1790 && (c1
= FETCH_CHAR (from_byte
),
1791 SYNTAX_COMSTART_SECOND (c1
)))
1793 /* We have encountered a comment start sequence and we
1794 are ignoring all text inside comments. We must record
1795 the comment style this sequence begins so that later,
1796 only a comment end of the same style actually ends
1797 the comment section. */
1799 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1800 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1801 INC_BOTH (from
, from_byte
);
1802 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1805 while (code
== Swhitespace
|| code
== Sendcomment
);
1807 if (code
== Scomment_fence
)
1808 comstyle
= ST_COMMENT_STYLE
;
1809 else if (code
!= Scomment
)
1812 DEC_BOTH (from
, from_byte
);
1813 SET_PT_BOTH (from
, from_byte
);
1816 /* We're at the start of a comment. */
1817 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
1818 &out_charpos
, &out_bytepos
, &dummy
);
1819 from
= out_charpos
; from_byte
= out_bytepos
;
1823 SET_PT_BOTH (from
, from_byte
);
1826 INC_BOTH (from
, from_byte
);
1827 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1828 /* We have skipped one comment. */
1836 int quoted
, comstart_second
;
1840 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
1845 DEC_BOTH (from
, from_byte
);
1846 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
1847 quoted
= char_quoted (from
, from_byte
);
1850 DEC_BOTH (from
, from_byte
);
1853 c
= FETCH_CHAR (from_byte
);
1856 comnested
= SYNTAX_COMMENT_NESTED (c
);
1857 if (code
== Sendcomment
)
1858 comstyle
= SYNTAX_COMMENT_STYLE (c
);
1859 comstart_second
= SYNTAX_COMSTART_SECOND (c
);
1860 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1861 && prev_char_comend_first (from
, from_byte
)
1862 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
1864 /* We must record the comment style encountered so that
1865 later, we can match only the proper comment begin
1866 sequence of the same style. */
1867 DEC_BOTH (from
, from_byte
);
1869 /* Calling char_quoted, above, set up global syntax position
1870 at the new value of FROM. */
1871 c1
= FETCH_CHAR (from_byte
);
1872 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1873 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1875 if (from
> stop
&& comstart_second
1876 && prev_char_comstart_first (from
, from_byte
)
1877 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
1880 DEC_BOTH (from
, from_byte
);
1883 if (code
== Scomment_fence
)
1885 /* Skip until first preceding unquoted comment_fence. */
1886 int found
= 0, ini
= from
, ini_byte
= from_byte
;
1890 DEC_BOTH (from
, from_byte
);
1893 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1894 c
= FETCH_CHAR (from_byte
);
1895 if (SYNTAX (c
) == Scomment_fence
1896 && !char_quoted (from
, from_byte
))
1904 from
= ini
; /* Set point to ini + 1. */
1905 from_byte
= ini_byte
;
1909 else if (code
== Sendcomment
)
1911 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
1912 &out_charpos
, &out_bytepos
);
1914 from
= out_charpos
, from_byte
= out_bytepos
;
1915 /* We have skipped one comment. */
1918 else if (code
!= Swhitespace
&& code
!= Scomment
)
1922 INC_BOTH (from
, from_byte
);
1923 SET_PT_BOTH (from
, from_byte
);
1931 SET_PT_BOTH (from
, from_byte
);
1937 scan_lists (from
, count
, depth
, sexpflag
)
1939 int count
, depth
, sexpflag
;
1942 register int stop
= count
> 0 ? ZV
: BEGV
;
1947 register enum syntaxcode code
, temp_code
;
1948 int min_depth
= depth
; /* Err out if depth gets less than this. */
1949 int comstyle
= 0; /* style of comment encountered */
1950 int comnested
= 0; /* whether the comment is nestable or not */
1952 int last_good
= from
;
1955 int out_bytepos
, out_charpos
;
1958 if (depth
> 0) min_depth
= 0;
1960 if (from
> ZV
) from
= ZV
;
1961 if (from
< BEGV
) from
= BEGV
;
1963 from_byte
= CHAR_TO_BYTE (from
);
1968 SETUP_SYNTAX_TABLE (from
, count
);
1973 int comstart_first
, prefix
;
1974 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1975 c
= FETCH_CHAR (from_byte
);
1977 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
1978 comnested
= SYNTAX_COMMENT_NESTED (c
);
1979 prefix
= SYNTAX_PREFIX (c
);
1980 if (depth
== min_depth
)
1982 INC_BOTH (from
, from_byte
);
1983 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1984 if (from
< stop
&& comstart_first
1985 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte
))
1986 && parse_sexp_ignore_comments
)
1988 /* we have encountered a comment start sequence and we
1989 are ignoring all text inside comments. We must record
1990 the comment style this sequence begins so that later,
1991 only a comment end of the same style actually ends
1992 the comment section */
1994 c1
= FETCH_CHAR (from_byte
);
1995 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1996 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1997 INC_BOTH (from
, from_byte
);
1998 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2004 switch (SWITCH_ENUM_CAST (code
))
2008 if (from
== stop
) goto lose
;
2009 INC_BOTH (from
, from_byte
);
2010 /* treat following character as a word constituent */
2013 if (depth
|| !sexpflag
) break;
2014 /* This word counts as a sexp; return at end of it. */
2017 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2019 /* Some compilers can't handle this inside the switch. */
2020 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2025 INC_BOTH (from
, from_byte
);
2026 if (from
== stop
) goto lose
;
2035 INC_BOTH (from
, from_byte
);
2039 case Scomment_fence
:
2040 comstyle
= ST_COMMENT_STYLE
;
2043 if (!parse_sexp_ignore_comments
) break;
2044 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2045 found
= forw_comment (from
, from_byte
, stop
,
2046 comnested
, comstyle
, 0,
2047 &out_charpos
, &out_bytepos
, &dummy
);
2048 from
= out_charpos
, from_byte
= out_bytepos
;
2055 INC_BOTH (from
, from_byte
);
2056 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2062 if (from
!= stop
&& c
== FETCH_CHAR (from_byte
))
2064 INC_BOTH (from
, from_byte
);
2074 if (!++depth
) goto done
;
2079 if (!--depth
) goto done
;
2080 if (depth
< min_depth
)
2081 Fsignal (Qscan_error
,
2082 Fcons (build_string ("Containing expression ends prematurely"),
2083 Fcons (make_number (last_good
),
2084 Fcons (make_number (from
), Qnil
))));
2089 temp_pos
= dec_bytepos (from_byte
);
2090 stringterm
= FETCH_CHAR (temp_pos
);
2093 if (from
>= stop
) goto lose
;
2094 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2096 ? (FETCH_CHAR (from_byte
) == stringterm
)
2097 : SYNTAX (FETCH_CHAR (from_byte
)) == Sstring_fence
)
2100 /* Some compilers can't handle this inside the switch. */
2101 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2106 INC_BOTH (from
, from_byte
);
2108 INC_BOTH (from
, from_byte
);
2110 INC_BOTH (from
, from_byte
);
2111 if (!depth
&& sexpflag
) goto done
;
2116 /* Reached end of buffer. Error if within object, return nil if between */
2117 if (depth
) goto lose
;
2122 /* End of object reached */
2131 DEC_BOTH (from
, from_byte
);
2132 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2133 c
= FETCH_CHAR (from_byte
);
2135 if (depth
== min_depth
)
2138 comnested
= SYNTAX_COMMENT_NESTED (c
);
2139 if (code
== Sendcomment
)
2140 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2141 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2142 && prev_char_comend_first (from
, from_byte
)
2143 && parse_sexp_ignore_comments
)
2145 /* We must record the comment style encountered so that
2146 later, we can match only the proper comment begin
2147 sequence of the same style. */
2148 DEC_BOTH (from
, from_byte
);
2149 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2151 c1
= FETCH_CHAR (from_byte
);
2152 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2153 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2156 /* Quoting turns anything except a comment-ender
2157 into a word character. Note that this if cannot be true
2158 if we decremented FROM in the if-statement above. */
2159 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2161 else if (SYNTAX_PREFIX (c
))
2164 switch (SWITCH_ENUM_CAST (code
))
2170 if (depth
|| !sexpflag
) break;
2171 /* This word counts as a sexp; count object finished
2172 after passing it. */
2175 temp_pos
= from_byte
;
2176 if (! NILP (current_buffer
->enable_multibyte_characters
))
2180 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2181 c1
= FETCH_CHAR (temp_pos
);
2182 temp_code
= SYNTAX (c1
);
2183 /* Don't allow comment-end to be quoted. */
2184 if (temp_code
== Sendcomment
)
2186 quoted
= char_quoted (from
- 1, temp_pos
);
2189 DEC_BOTH (from
, from_byte
);
2190 temp_pos
= dec_bytepos (temp_pos
);
2191 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2193 c1
= FETCH_CHAR (temp_pos
);
2194 temp_code
= SYNTAX (c1
);
2195 if (! (quoted
|| temp_code
== Sword
2196 || temp_code
== Ssymbol
2197 || temp_code
== Squote
))
2199 DEC_BOTH (from
, from_byte
);
2206 temp_pos
= dec_bytepos (from_byte
);
2207 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2208 if (from
!= stop
&& c
== FETCH_CHAR (temp_pos
))
2209 DEC_BOTH (from
, from_byte
);
2218 if (!++depth
) goto done2
;
2223 if (!--depth
) goto done2
;
2224 if (depth
< min_depth
)
2225 Fsignal (Qscan_error
,
2226 Fcons (build_string ("Containing expression ends prematurely"),
2227 Fcons (make_number (last_good
),
2228 Fcons (make_number (from
), Qnil
))));
2232 if (!parse_sexp_ignore_comments
)
2234 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2235 &out_charpos
, &out_bytepos
);
2237 from
= out_charpos
, from_byte
= out_bytepos
;
2240 case Scomment_fence
:
2244 DEC_BOTH (from
, from_byte
);
2245 if (from
== stop
) goto lose
;
2246 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2247 if (!char_quoted (from
, from_byte
)
2248 && SYNTAX (FETCH_CHAR (from_byte
)) == code
)
2251 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2255 stringterm
= FETCH_CHAR (from_byte
);
2258 if (from
== stop
) goto lose
;
2259 temp_pos
= from_byte
;
2260 if (! NILP (current_buffer
->enable_multibyte_characters
))
2264 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2265 if (!char_quoted (from
- 1, temp_pos
)
2266 && stringterm
== FETCH_CHAR (temp_pos
))
2268 DEC_BOTH (from
, from_byte
);
2270 DEC_BOTH (from
, from_byte
);
2271 if (!depth
&& sexpflag
) goto done2
;
2276 /* Reached start of buffer. Error if within object, return nil if between */
2277 if (depth
) goto lose
;
2288 XSETFASTINT (val
, from
);
2292 Fsignal (Qscan_error
,
2293 Fcons (build_string ("Unbalanced parentheses"),
2294 Fcons (make_number (last_good
),
2295 Fcons (make_number (from
), Qnil
))));
2300 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2301 "Scan from character number FROM by COUNT lists.\n\
2302 Returns the character number of the position thus found.\n\
2304 If DEPTH is nonzero, paren depth begins counting from that value,\n\
2305 only places where the depth in parentheses becomes zero\n\
2306 are candidates for stopping; COUNT such places are counted.\n\
2307 Thus, a positive value for DEPTH means go out levels.\n\
2309 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2311 If the beginning or end of (the accessible part of) the buffer is reached\n\
2312 and the depth is wrong, an error is signaled.\n\
2313 If the depth is right but the count is not used up, nil is returned.")
2314 (from
, count
, depth
)
2315 Lisp_Object from
, count
, depth
;
2317 CHECK_NUMBER (from
, 0);
2318 CHECK_NUMBER (count
, 1);
2319 CHECK_NUMBER (depth
, 2);
2321 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2324 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2325 "Scan from character number FROM by COUNT balanced expressions.\n\
2326 If COUNT is negative, scan backwards.\n\
2327 Returns the character number of the position thus found.\n\
2329 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2331 If the beginning or end of (the accessible part of) the buffer is reached\n\
2332 in the middle of a parenthetical grouping, an error is signaled.\n\
2333 If the beginning or end is reached between groupings\n\
2334 but before count is used up, nil is returned.")
2336 Lisp_Object from
, count
;
2338 CHECK_NUMBER (from
, 0);
2339 CHECK_NUMBER (count
, 1);
2341 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2344 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2346 "Move point backward over any number of chars with prefix syntax.\n\
2347 This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
2352 int opoint_byte
= PT_BYTE
;
2354 int pos_byte
= PT_BYTE
;
2359 SET_PT_BOTH (opoint
, opoint_byte
);
2364 SETUP_SYNTAX_TABLE (pos
, -1);
2366 DEC_BOTH (pos
, pos_byte
);
2368 while (!char_quoted (pos
, pos_byte
)
2369 /* Previous statement updates syntax table. */
2370 && ((c
= FETCH_CHAR (pos_byte
), SYNTAX (c
) == Squote
)
2371 || SYNTAX_PREFIX (c
)))
2374 opoint_byte
= pos_byte
;
2377 DEC_BOTH (pos
, pos_byte
);
2380 SET_PT_BOTH (opoint
, opoint_byte
);
2385 /* Parse forward from FROM / FROM_BYTE to END,
2386 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2387 and return a description of the state of the parse at END.
2388 If STOPBEFORE is nonzero, stop at the start of an atom.
2389 If COMMENTSTOP is 1, stop at the start of a comment.
2390 If COMMENTSTOP is -1, stop at the start or end of a comment,
2391 after the beginning of a string, or after the end of a string. */
2394 scan_sexps_forward (stateptr
, from
, from_byte
, end
, targetdepth
,
2395 stopbefore
, oldstate
, commentstop
)
2396 struct lisp_parse_state
*stateptr
;
2398 int end
, targetdepth
, stopbefore
;
2399 Lisp_Object oldstate
;
2402 struct lisp_parse_state state
;
2404 register enum syntaxcode code
;
2407 struct level
{ int last
, prev
; };
2408 struct level levelstart
[100];
2409 register struct level
*curlevel
= levelstart
;
2410 struct level
*endlevel
= levelstart
+ 100;
2411 register int depth
; /* Paren depth of current scanning location.
2412 level - levelstart equals this except
2413 when the depth becomes negative. */
2414 int mindepth
; /* Lowest DEPTH value seen. */
2415 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2417 int prev_from
; /* Keep one character before FROM. */
2419 int prev_from_syntax
;
2420 int boundary_stop
= commentstop
== -1;
2423 int out_bytepos
, out_charpos
;
2427 prev_from_byte
= from_byte
;
2429 DEC_BOTH (prev_from
, prev_from_byte
);
2431 /* Use this macro instead of `from++'. */
2433 do { prev_from = from; \
2434 prev_from_byte = from_byte; \
2436 = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte)); \
2437 INC_BOTH (from, from_byte); \
2438 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2444 if (NILP (oldstate
))
2447 state
.instring
= -1;
2448 state
.incomment
= 0;
2449 state
.comstyle
= 0; /* comment style a by default. */
2450 state
.comstr_start
= -1; /* no comment/string seen. */
2454 tem
= Fcar (oldstate
);
2460 oldstate
= Fcdr (oldstate
);
2461 oldstate
= Fcdr (oldstate
);
2462 oldstate
= Fcdr (oldstate
);
2463 tem
= Fcar (oldstate
);
2464 /* Check whether we are inside string_fence-style string: */
2465 state
.instring
= ( !NILP (tem
)
2466 ? ( INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2469 oldstate
= Fcdr (oldstate
);
2470 tem
= Fcar (oldstate
);
2471 state
.incomment
= ( !NILP (tem
)
2472 ? ( INTEGERP (tem
) ? XINT (tem
) : -1)
2475 oldstate
= Fcdr (oldstate
);
2476 tem
= Fcar (oldstate
);
2477 start_quoted
= !NILP (tem
);
2479 /* if the eighth element of the list is nil, we are in comment
2480 style a. If it is non-nil, we are in comment style b */
2481 oldstate
= Fcdr (oldstate
);
2482 oldstate
= Fcdr (oldstate
);
2483 tem
= Fcar (oldstate
);
2484 state
.comstyle
= NILP (tem
) ? 0 : ( EQ (tem
, Qsyntax_table
)
2485 ? ST_COMMENT_STYLE
: 1 );
2487 oldstate
= Fcdr (oldstate
);
2488 tem
= Fcar (oldstate
);
2489 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2490 oldstate
= Fcdr (oldstate
);
2491 tem
= Fcar (oldstate
);
2492 while (!NILP (tem
)) /* >= second enclosing sexps. */
2494 /* curlevel++->last ran into compiler bug on Apollo */
2495 curlevel
->last
= XINT (Fcar (tem
));
2496 if (++curlevel
== endlevel
)
2497 error ("Nesting too deep for parser");
2498 curlevel
->prev
= -1;
2499 curlevel
->last
= -1;
2506 curlevel
->prev
= -1;
2507 curlevel
->last
= -1;
2509 SETUP_SYNTAX_TABLE (prev_from
, 1);
2510 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2511 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2513 /* Enter the loop at a place appropriate for initial state. */
2515 if (state
.incomment
)
2516 goto startincomment
;
2517 if (state
.instring
>= 0)
2519 nofence
= state
.instring
!= ST_STRING_STYLE
;
2521 goto startquotedinstring
;
2524 else if (start_quoted
)
2527 #if 0 /* This seems to be redundant with the identical code above. */
2528 SETUP_SYNTAX_TABLE (prev_from
, 1);
2529 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2530 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2536 code
= prev_from_syntax
& 0xff;
2538 if (code
== Scomment
)
2540 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
2542 state
.comstr_start
= prev_from
;
2544 else if (code
== Scomment_fence
)
2546 /* Record the comment style we have entered so that only
2547 the comment-end sequence of the same style actually
2548 terminates the comment section. */
2549 state
.comstyle
= ST_COMMENT_STYLE
;
2550 state
.incomment
= -1;
2551 state
.comstr_start
= prev_from
;
2554 else if (from
< end
)
2555 if (SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
))
2556 if (c1
= FETCH_CHAR (from_byte
),
2557 SYNTAX_COMSTART_SECOND (c1
))
2558 /* Duplicate code to avoid a complex if-expression
2559 which causes trouble for the SGI compiler. */
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
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte
));
2565 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
);
2566 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2567 state
.incomment
= comnested
? 1 : -1;
2568 state
.comstr_start
= prev_from
;
2573 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
2575 switch (SWITCH_ENUM_CAST (code
))
2579 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2580 curlevel
->last
= prev_from
;
2582 if (from
== end
) goto endquoted
;
2585 /* treat following character as a word constituent */
2588 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2589 curlevel
->last
= prev_from
;
2593 /* Some compilers can't handle this inside the switch. */
2594 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2600 if (from
== end
) goto endquoted
;
2612 curlevel
->prev
= curlevel
->last
;
2616 if (commentstop
== 1)
2621 assert (state
.incomment
!= 0); /* state.incomment = -1; */
2622 if (commentstop
|| boundary_stop
) goto done
;
2624 /* The (from == BEGV) test is to enter the loop in the middle so
2625 that we find a 2-char comment ender even if we start in the
2627 found
= forw_comment (from
, from_byte
, end
,
2628 state
.incomment
, state
.comstyle
,
2629 (from
== BEGV
) ? 0 : prev_from_syntax
,
2630 &out_charpos
, &out_bytepos
, &state
.incomment
);
2631 from
= out_charpos
; from_byte
= out_bytepos
;
2632 /* Beware! prev_from and friends are invalid now.
2633 Luckily, the `done' doesn't use them and the INC_FROM
2634 sets them to a sane value without looking at them. */
2635 if (!found
) goto done
;
2637 state
.incomment
= 0;
2638 state
.comstyle
= 0; /* reset the comment style */
2639 if (boundary_stop
) goto done
;
2643 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2645 /* curlevel++->last ran into compiler bug on Apollo */
2646 curlevel
->last
= prev_from
;
2647 if (++curlevel
== endlevel
)
2648 error ("Nesting too deep for parser");
2649 curlevel
->prev
= -1;
2650 curlevel
->last
= -1;
2651 if (targetdepth
== depth
) goto done
;
2656 if (depth
< mindepth
)
2658 if (curlevel
!= levelstart
)
2660 curlevel
->prev
= curlevel
->last
;
2661 if (targetdepth
== depth
) goto done
;
2666 state
.comstr_start
= from
- 1;
2667 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2668 curlevel
->last
= prev_from
;
2669 state
.instring
= (code
== Sstring
2670 ? (FETCH_CHAR (prev_from_byte
))
2672 if (boundary_stop
) goto done
;
2675 nofence
= state
.instring
!= ST_STRING_STYLE
;
2681 if (from
>= end
) goto done
;
2682 c
= FETCH_CHAR (from_byte
);
2683 /* Some compilers can't handle this inside the switch. */
2686 /* Check TEMP here so that if the char has
2687 a syntax-table property which says it is NOT
2688 a string character, it does not end the string. */
2689 if (nofence
&& c
== state
.instring
&& temp
== Sstring
)
2695 if (!nofence
) goto string_end
;
2700 startquotedinstring
:
2701 if (from
>= end
) goto endquoted
;
2707 state
.instring
= -1;
2708 curlevel
->prev
= curlevel
->last
;
2710 if (boundary_stop
) goto done
;
2719 stop
: /* Here if stopping before start of sexp. */
2720 from
= prev_from
; /* We have just fetched the char that starts it; */
2721 goto done
; /* but return the position before it. */
2726 state
.depth
= depth
;
2727 state
.mindepth
= mindepth
;
2728 state
.thislevelstart
= curlevel
->prev
;
2729 state
.prevlevelstart
2730 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
2731 state
.location
= from
;
2732 state
.levelstarts
= Qnil
;
2733 while (--curlevel
>= levelstart
)
2734 state
.levelstarts
= Fcons (make_number (curlevel
->last
),
2741 /* This comment supplies the doc string for parse-partial-sexp,
2742 for make-docfile to see. We cannot put this in the real DEFUN
2743 due to limits in the Unix cpp.
2745 DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 6, 0,
2746 "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
2747 Parsing stops at TO or when certain criteria are met;\n\
2748 point is set to where parsing stops.\n\
2749 If fifth arg STATE is omitted or nil,\n\
2750 parsing assumes that FROM is the beginning of a function.\n\
2751 Value is a list of ten elements describing final state of parsing:\n\
2752 0. depth in parens.\n\
2753 1. character address of start of innermost containing list; nil if none.\n\
2754 2. character address of start of last complete sexp terminated.\n\
2755 3. non-nil if inside a string.\n\
2756 (it is the character that will terminate the string,\n\
2757 or t if the string should be terminated by a generic string delimiter.)\n\
2758 4. nil if outside a comment, t if inside a non-nestable comment, \n\
2759 else an integer (the current comment nesting).\n\
2760 5. t if following a quote character.\n\
2761 6. the minimum paren-depth encountered during this scan.\n\
2762 7. t if in a comment of style b; `syntax-table' if the comment\n\
2763 should be terminated by a generic comment delimiter.\n\
2764 8. character address of start of comment or string; nil if not in one.\n\
2765 9. Intermediate data for continuation of parsing (subject to change).\n\
2766 If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
2767 in parentheses becomes equal to TARGETDEPTH.\n\
2768 Fourth arg STOPBEFORE non-nil means stop when come to\n\
2769 any character that starts a sexp.\n\
2770 Fifth arg STATE is a nine-element list like what this function returns.\n\
2771 It is used to initialize the state of the parse. Elements number 1, 2, 6\n\
2772 and 8 are ignored; you can leave off element 8 (the last) entirely.\n\
2773 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.\n\
2774 If it is `syntax-table', stop after the start of a comment or a string,\n\
2775 or after end of a comment or a string.")
2776 (from, to, targetdepth, stopbefore, state, commentstop)
2779 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
2780 0 /* See immediately above */)
2781 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
2782 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
2784 struct lisp_parse_state state
;
2787 if (!NILP (targetdepth
))
2789 CHECK_NUMBER (targetdepth
, 3);
2790 target
= XINT (targetdepth
);
2793 target
= -100000; /* We won't reach this depth */
2795 validate_region (&from
, &to
);
2796 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
2798 target
, !NILP (stopbefore
), oldstate
,
2800 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
2802 SET_PT (state
.location
);
2804 return Fcons (make_number (state
.depth
),
2805 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
2806 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
2807 Fcons (state
.instring
>= 0
2808 ? (state
.instring
== ST_STRING_STYLE
2809 ? Qt
: make_number (state
.instring
)) : Qnil
,
2810 Fcons (state
.incomment
< 0 ? Qt
:
2811 (state
.incomment
== 0 ? Qnil
:
2812 make_number (state
.incomment
)),
2813 Fcons (state
.quoted
? Qt
: Qnil
,
2814 Fcons (make_number (state
.mindepth
),
2815 Fcons ((state
.comstyle
2816 ? (state
.comstyle
== ST_COMMENT_STYLE
2817 ? Qsyntax_table
: Qt
) :
2819 Fcons (((state
.incomment
2820 || (state
.instring
>= 0))
2821 ? make_number (state
.comstr_start
)
2823 Fcons (state
.levelstarts
, Qnil
))))))))));
2832 /* This has to be done here, before we call Fmake_char_table. */
2833 Qsyntax_table
= intern ("syntax-table");
2834 staticpro (&Qsyntax_table
);
2836 /* Intern this now in case it isn't already done.
2837 Setting this variable twice is harmless.
2838 But don't staticpro it here--that is done in alloc.c. */
2839 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
2841 /* Create objects which can be shared among syntax tables. */
2842 Vsyntax_code_object
= Fmake_vector (make_number (13), Qnil
);
2843 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
2844 XVECTOR (Vsyntax_code_object
)->contents
[i
]
2845 = Fcons (make_number (i
), Qnil
);
2847 /* Now we are ready to set up this property, so we can
2848 create syntax tables. */
2849 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
2851 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
2853 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
2855 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
2856 for (i
= 'a'; i
<= 'z'; i
++)
2857 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2858 for (i
= 'A'; i
<= 'Z'; i
++)
2859 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2860 for (i
= '0'; i
<= '9'; i
++)
2861 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2863 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
2864 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
2866 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
2867 Fcons (make_number (Sopen
), make_number (')')));
2868 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
2869 Fcons (make_number (Sclose
), make_number ('(')));
2870 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
2871 Fcons (make_number (Sopen
), make_number (']')));
2872 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
2873 Fcons (make_number (Sclose
), make_number ('[')));
2874 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
2875 Fcons (make_number (Sopen
), make_number ('}')));
2876 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
2877 Fcons (make_number (Sclose
), make_number ('{')));
2878 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
2879 Fcons (make_number ((int) Sstring
), Qnil
));
2880 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
2881 Fcons (make_number ((int) Sescape
), Qnil
));
2883 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
2884 for (i
= 0; i
< 10; i
++)
2886 c
= "_-+*/&|<>="[i
];
2887 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2890 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
2891 for (i
= 0; i
< 12; i
++)
2893 c
= ".,;:?!#@~^'`"[i
];
2894 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2901 Qsyntax_table_p
= intern ("syntax-table-p");
2902 staticpro (&Qsyntax_table_p
);
2904 staticpro (&Vsyntax_code_object
);
2906 Qscan_error
= intern ("scan-error");
2907 staticpro (&Qscan_error
);
2908 Fput (Qscan_error
, Qerror_conditions
,
2909 Fcons (Qscan_error
, Fcons (Qerror
, Qnil
)));
2910 Fput (Qscan_error
, Qerror_message
,
2911 build_string ("Scan error"));
2913 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
2914 "Non-nil means `forward-sexp', etc., should treat comments as whitespace.");
2916 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
2917 "Non-nil means `forward-sexp', etc., grant `syntax-table' property.\n\
2918 The value of this property should be either a syntax table, or a cons\n\
2919 of the form (SYNTAXCODE . MATCHCHAR), SYNTAXCODE being the numeric\n\
2920 syntax code, MATCHCHAR being nil or the character to match (which is\n\
2921 relevant only for open/close type.");
2923 words_include_escapes
= 0;
2924 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
2925 "Non-nil means `forward-word', etc., should treat escape chars part of words.");
2927 defsubr (&Ssyntax_table_p
);
2928 defsubr (&Ssyntax_table
);
2929 defsubr (&Sstandard_syntax_table
);
2930 defsubr (&Scopy_syntax_table
);
2931 defsubr (&Sset_syntax_table
);
2932 defsubr (&Schar_syntax
);
2933 defsubr (&Smatching_paren
);
2934 defsubr (&Smodify_syntax_entry
);
2935 defsubr (&Sdescribe_syntax
);
2937 defsubr (&Sforward_word
);
2939 defsubr (&Sskip_chars_forward
);
2940 defsubr (&Sskip_chars_backward
);
2941 defsubr (&Sskip_syntax_forward
);
2942 defsubr (&Sskip_syntax_backward
);
2944 defsubr (&Sforward_comment
);
2945 defsubr (&Sscan_lists
);
2946 defsubr (&Sscan_sexps
);
2947 defsubr (&Sbackward_prefix_chars
);
2948 defsubr (&Sparse_partial_sexp
);