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 /* Nonzero means `scan-sexps' treat all multibyte characters as symbol. */
49 int multibyte_syntax_as_symbol
;
51 /* Used as a temporary in SYNTAX_ENTRY and other macros in syntax.h,
52 if not compiled with GCC. No need to mark it, since it is used
53 only very temporarily. */
54 Lisp_Object syntax_temp
;
56 /* Non-zero means an open parenthesis in column 0 is always considered
57 to be the start of a defun. Zero means an open parenthesis in
58 column 0 has no special meaning. */
60 int open_paren_in_column_0_is_defun_start
;
62 /* This is the internal form of the parse state used in parse-partial-sexp. */
64 struct lisp_parse_state
66 int depth
; /* Depth at end of parsing. */
67 int instring
; /* -1 if not within string, else desired terminator. */
68 int incomment
; /* -1 if in unnestable comment else comment nesting */
69 int comstyle
; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
70 int quoted
; /* Nonzero if just after an escape char at end of parsing */
71 int thislevelstart
; /* Char number of most recent start-of-expression at current level */
72 int prevlevelstart
; /* Char number of start of containing expression */
73 int location
; /* Char number at which parsing stopped. */
74 int mindepth
; /* Minimum depth seen while scanning. */
75 int comstr_start
; /* Position just after last comment/string starter. */
76 Lisp_Object levelstarts
; /* Char numbers of starts-of-expression
77 of levels (starting from outermost). */
80 /* These variables are a cache for finding the start of a defun.
81 find_start_pos is the place for which the defun start was found.
82 find_start_value is the defun start position found for it.
83 find_start_value_byte is the corresponding byte position.
84 find_start_buffer is the buffer it was found in.
85 find_start_begv is the BEGV value when it was found.
86 find_start_modiff is the value of MODIFF when it was found. */
88 static int find_start_pos
;
89 static int find_start_value
;
90 static int find_start_value_byte
;
91 static struct buffer
*find_start_buffer
;
92 static int find_start_begv
;
93 static int find_start_modiff
;
96 static int find_defun_start
P_ ((int, int));
97 static int back_comment
P_ ((int, int, int, int, int, int *, int *));
98 static int char_quoted
P_ ((int, int));
99 static Lisp_Object skip_chars
P_ ((int, int, Lisp_Object
, Lisp_Object
));
100 static Lisp_Object scan_lists
P_ ((int, int, int, int));
101 static void scan_sexps_forward
P_ ((struct lisp_parse_state
*,
103 int, Lisp_Object
, int));
106 struct gl_state_s gl_state
; /* Global state of syntax parser. */
108 INTERVAL
interval_of ();
109 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
110 to scan to property-change. */
112 /* Update gl_state to an appropriate interval which contains CHARPOS. The
113 sign of COUNT give the relative position of CHARPOS wrt the previously
114 valid interval. If INIT, only [be]_property fields of gl_state are
115 valid at start, the rest is filled basing on OBJECT.
117 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
118 direction than the intervals - or in an interval. We update the
119 current syntax-table basing on the property of this interval, and
120 update the interval to start further than CHARPOS - or be
121 NULL_INTERVAL. We also update lim_property to be the next value of
122 charpos to call this subroutine again - or be before/after the
123 start/end of OBJECT. */
126 update_syntax_table (charpos
, count
, init
, object
)
127 int charpos
, count
, init
;
130 Lisp_Object tmp_table
;
131 int cnt
= 0, invalidate
= 1;
136 gl_state
.start
= gl_state
.b_property
;
137 gl_state
.stop
= gl_state
.e_property
;
138 gl_state
.forward_i
= interval_of (charpos
, object
);
139 i
= gl_state
.backward_i
= gl_state
.forward_i
;
140 gl_state
.left_ok
= gl_state
.right_ok
= 1;
142 if (NULL_INTERVAL_P (i
))
144 /* interval_of updates only ->position of the return value, so
145 update the parents manually to speed up update_interval. */
146 while (!NULL_PARENT (i
))
148 if (AM_RIGHT_CHILD (i
))
149 INTERVAL_PARENT (i
)->position
= i
->position
150 - LEFT_TOTAL_LENGTH (i
) + TOTAL_LENGTH (i
) /* right end */
151 - TOTAL_LENGTH (INTERVAL_PARENT (i
))
152 + LEFT_TOTAL_LENGTH (INTERVAL_PARENT (i
));
154 INTERVAL_PARENT (i
)->position
= i
->position
- LEFT_TOTAL_LENGTH (i
)
156 i
= INTERVAL_PARENT (i
);
158 i
= gl_state
.forward_i
;
159 gl_state
.b_property
= i
->position
- 1 - gl_state
.offset
;
160 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
163 oldi
= i
= count
> 0 ? gl_state
.forward_i
: gl_state
.backward_i
;
165 /* We are guarantied to be called with CHARPOS either in i,
167 if (NULL_INTERVAL_P (i
))
168 error ("Error in syntax_table logic for to-the-end intervals");
169 else if (charpos
< i
->position
) /* Move left. */
172 error ("Error in syntax_table logic for intervals <-");
173 /* Update the interval. */
174 i
= update_interval (i
, charpos
);
175 if (oldi
->position
!= INTERVAL_LAST_POS (i
))
178 gl_state
.right_ok
= 1; /* Invalidate the other end. */
179 gl_state
.forward_i
= i
;
180 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
183 else if (charpos
>= INTERVAL_LAST_POS (i
)) /* Move right. */
186 error ("Error in syntax_table logic for intervals ->");
187 /* Update the interval. */
188 i
= update_interval (i
, charpos
);
189 if (i
->position
!= INTERVAL_LAST_POS (oldi
))
192 gl_state
.left_ok
= 1; /* Invalidate the other end. */
193 gl_state
.backward_i
= i
;
194 gl_state
.b_property
= i
->position
- 1 - gl_state
.offset
;
197 else if (count
> 0 ? gl_state
.right_ok
: gl_state
.left_ok
)
199 /* We do not need to recalculate tmp_table. */
200 tmp_table
= gl_state
.old_prop
;
204 tmp_table
= textget (i
->plist
, Qsyntax_table
);
207 invalidate
= !EQ (tmp_table
, gl_state
.old_prop
); /* Need to invalidate? */
209 if (invalidate
) /* Did not get to adjacent interval. */
210 { /* with the same table => */
211 /* invalidate the old range. */
214 gl_state
.backward_i
= i
;
215 gl_state
.left_ok
= 1; /* Invalidate the other end. */
216 gl_state
.b_property
= i
->position
- 1 - gl_state
.offset
;
220 gl_state
.forward_i
= i
;
221 gl_state
.right_ok
= 1; /* Invalidate the other end. */
222 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
226 gl_state
.current_syntax_table
= tmp_table
;
227 gl_state
.old_prop
= tmp_table
;
228 if (EQ (Fsyntax_table_p (tmp_table
), Qt
))
230 gl_state
.use_global
= 0;
232 else if (CONSP (tmp_table
))
234 gl_state
.use_global
= 1;
235 gl_state
.global_code
= tmp_table
;
239 gl_state
.use_global
= 0;
240 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
243 while (!NULL_INTERVAL_P (i
))
245 if (cnt
&& !EQ (tmp_table
, textget (i
->plist
, Qsyntax_table
)))
248 gl_state
.right_ok
= 0;
250 gl_state
.left_ok
= 0;
253 else if (cnt
== INTERVALS_AT_ONCE
)
256 gl_state
.right_ok
= 1;
258 gl_state
.left_ok
= 1;
262 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
264 if (NULL_INTERVAL_P (i
))
265 { /* This property goes to the end. */
267 gl_state
.e_property
= gl_state
.stop
;
269 gl_state
.b_property
= gl_state
.start
;
275 gl_state
.e_property
= i
->position
- gl_state
.offset
;
276 gl_state
.forward_i
= i
;
280 gl_state
.b_property
= i
->position
+ LENGTH (i
) - 1 - gl_state
.offset
;
281 gl_state
.backward_i
= i
;
286 /* Returns TRUE if char at CHARPOS is quoted.
287 Global syntax-table data should be set up already to be good at CHARPOS
288 or after. On return global syntax data is good for lookup at CHARPOS. */
291 char_quoted (charpos
, bytepos
)
292 register int charpos
, bytepos
;
294 register enum syntaxcode code
;
295 register int beg
= BEGV
;
296 register int quoted
= 0;
299 DEC_BOTH (charpos
, bytepos
);
301 while (bytepos
>= beg
)
303 UPDATE_SYNTAX_TABLE_BACKWARD (charpos
);
304 code
= SYNTAX (FETCH_CHAR (bytepos
));
305 if (! (code
== Scharquote
|| code
== Sescape
))
308 DEC_BOTH (charpos
, bytepos
);
312 UPDATE_SYNTAX_TABLE (orig
);
316 /* Return the bytepos one character after BYTEPOS.
317 We assume that BYTEPOS is not at the end of the buffer. */
320 inc_bytepos (bytepos
)
323 if (NILP (current_buffer
->enable_multibyte_characters
))
330 /* Return the bytepos one character before BYTEPOS.
331 We assume that BYTEPOS is not at the start of the buffer. */
334 dec_bytepos (bytepos
)
337 if (NILP (current_buffer
->enable_multibyte_characters
))
344 /* Find a defun-start that is the last one before POS (or nearly the last).
345 We record what we find, so that another call in the same area
346 can return the same value right away.
348 There is no promise at which position the global syntax data is
349 valid on return from the subroutine, so the caller should explicitly
350 update the global data. */
353 find_defun_start (pos
, pos_byte
)
356 int opoint
= PT
, opoint_byte
= PT_BYTE
;
358 /* Use previous finding, if it's valid and applies to this inquiry. */
359 if (current_buffer
== find_start_buffer
360 /* Reuse the defun-start even if POS is a little farther on.
361 POS might be in the next defun, but that's ok.
362 Our value may not be the best possible, but will still be usable. */
363 && pos
<= find_start_pos
+ 1000
364 && pos
>= find_start_value
365 && BEGV
== find_start_begv
366 && MODIFF
== find_start_modiff
)
367 return find_start_value
;
369 /* Back up to start of line. */
370 scan_newline (pos
, pos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
372 /* We optimize syntax-table lookup for rare updates. Thus we accept
373 only those `^\s(' which are good in global _and_ text-property
375 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
376 gl_state
.use_global
= 0;
377 if (open_paren_in_column_0_is_defun_start
)
381 /* Open-paren at start of line means we may have found our
383 if (SYNTAX (FETCH_CHAR (PT_BYTE
)) == Sopen
)
385 SETUP_SYNTAX_TABLE (PT
+ 1, -1); /* Try again... */
386 if (SYNTAX (FETCH_CHAR (PT_BYTE
)) == Sopen
)
388 /* Now fallback to the default value. */
389 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
390 gl_state
.use_global
= 0;
392 /* Move to beg of previous line. */
393 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -2, 1);
397 /* Record what we found, for the next try. */
398 find_start_value
= PT
;
399 find_start_value_byte
= PT_BYTE
;
400 find_start_buffer
= current_buffer
;
401 find_start_modiff
= MODIFF
;
402 find_start_begv
= BEGV
;
403 find_start_pos
= pos
;
405 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
407 return find_start_value
;
410 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
413 prev_char_comend_first (pos
, pos_byte
)
418 DEC_BOTH (pos
, pos_byte
);
419 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
420 c
= FETCH_CHAR (pos_byte
);
421 val
= SYNTAX_COMEND_FIRST (c
);
422 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
426 /* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
429 prev_char_comstart_first (pos
, pos_byte
)
434 DEC_BOTH (pos
, pos_byte
);
435 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
436 c
= FETCH_CHAR (pos_byte
);
437 val
= SYNTAX_COMSTART_FIRST (c
);
438 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
442 /* Checks whether charpos FROM is at the end of a comment.
443 FROM_BYTE is the bytepos corresponding to FROM.
444 Do not move back before STOP.
446 Return a positive value if we find a comment ending at FROM/FROM_BYTE;
449 If successful, store the charpos of the comment's beginning
450 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
452 Global syntax data remains valid for backward search starting at
453 the returned value (or at FROM, if the search was not successful). */
456 back_comment (from
, from_byte
, stop
, comnested
, comstyle
, charpos_ptr
, bytepos_ptr
)
457 int from
, from_byte
, stop
;
458 int comnested
, comstyle
;
459 int *charpos_ptr
, *bytepos_ptr
;
461 /* Look back, counting the parity of string-quotes,
462 and recording the comment-starters seen.
463 When we reach a safe place, assume that's not in a string;
464 then step the main scan to the earliest comment-starter seen
465 an even number of string quotes away from the safe place.
467 OFROM[I] is position of the earliest comment-starter seen
468 which is I+2X quotes from the comment-end.
469 PARITY is current parity of quotes from the comment end. */
470 int string_style
= -1; /* Presumed outside of any string. */
471 int string_lossage
= 0;
472 /* Not a real lossage: indicates that we have passed a matching comment
473 starter plus an non-matching comment-ender, meaning that any matching
474 comment-starter we might see later could be a false positive (hidden
475 inside another comment).
476 Test case: { a (* b } c (* d *) */
477 int comment_lossage
= 0;
478 int comment_end
= from
;
479 int comment_end_byte
= from_byte
;
480 int comstart_pos
= 0;
482 int scanstart
= from
- 1;
483 /* Place where the containing defun starts,
484 or 0 if we didn't come across it yet. */
486 int defun_start_byte
= 0;
487 register enum syntaxcode code
;
488 int nesting
= 1; /* current comment nesting */
491 /* At beginning of range to scan, we're outside of strings;
492 that determines quote parity to the comment-end. */
497 /* Move back and examine a character. */
498 DEC_BOTH (from
, from_byte
);
499 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
501 c
= FETCH_CHAR (from_byte
);
504 /* If this char is the second of a 2-char comment end sequence,
505 back up and give the pair the appropriate syntax. */
506 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
507 && prev_char_comend_first (from
, from_byte
))
510 DEC_BOTH (from
, from_byte
);
511 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
512 c
= FETCH_CHAR (from_byte
);
515 /* If this char starts a 2-char comment start sequence,
516 treat it like a 1-char comment starter. */
517 if (from
< scanstart
&& SYNTAX_COMSTART_FIRST (c
))
519 temp_byte
= inc_bytepos (from_byte
);
520 UPDATE_SYNTAX_TABLE_FORWARD (from
+ 1);
521 if (SYNTAX_COMSTART_SECOND (FETCH_CHAR (temp_byte
))
522 && comstyle
== SYNTAX_COMMENT_STYLE (FETCH_CHAR (temp_byte
)))
524 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
526 else if (code
== Scomment
&& comstyle
!= SYNTAX_COMMENT_STYLE (c
))
527 /* Ignore comment starters of a different style. */
530 /* Ignore escaped characters, except comment-enders. */
531 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
538 c
= (code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
);
540 /* Track parity of quotes. */
541 if (string_style
== -1)
542 /* Entering a string. */
544 else if (string_style
== c
)
545 /* Leaving the string. */
548 /* If we have two kinds of string delimiters.
549 There's no way to grok this scanning backwards. */
554 /* We've already checked that it is the relevant comstyle. */
555 if (string_style
!= -1 || comment_lossage
|| string_lossage
)
556 /* There are odd string quotes involved, so let's be careful.
557 Test case in Pascal: " { " a { " } */
562 /* Record best comment-starter so far. */
564 comstart_byte
= from_byte
;
566 else if (--nesting
<= 0)
567 /* nested comments have to be balanced, so we don't need to
568 keep looking for earlier ones. We use here the same (slightly
569 incorrect) reasoning as below: since it is followed by uniform
570 paired string quotes, this comment-start has to be outside of
571 strings, else the comment-end itself would be inside a string. */
576 if (SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte
)) == comstyle
)
577 /* This is the same style of comment ender as ours. */
582 /* Anything before that can't count because it would match
583 this comment-ender rather than ours. */
584 from
= stop
; /* Break out of the loop. */
586 else if (comstart_pos
!= 0 || c
!= '\n')
587 /* We're mixing comment styles here, so we'd better be careful.
588 The (comstart_pos != 0 || c != '\n') check is not quite correct
589 (we should just always set comment_lossage), but removing it
590 would imply that any multiline comment in C would go through
591 lossage, which seems overkill.
592 The failure should only happen in the rare cases such as
598 /* Assume a defun-start point is outside of strings. */
599 if (open_paren_in_column_0_is_defun_start
601 || (temp_byte
= dec_bytepos (from_byte
),
602 FETCH_CHAR (temp_byte
) == '\n')))
605 defun_start_byte
= from_byte
;
606 from
= stop
; /* Break out of the loop. */
615 if (comstart_pos
== 0)
618 from_byte
= comment_end_byte
;
619 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
621 /* If comstart_pos is set and we get here (ie. didn't jump to `lossage'
622 or `done'), then we've found the beginning of the non-nested comment. */
623 else if (1) /* !comnested */
626 from_byte
= comstart_byte
;
627 /* Globals are correct now. */
631 struct lisp_parse_state state
;
633 /* We had two kinds of string delimiters mixed up
634 together. Decode this going forwards.
635 Scan fwd from a known safe place (beginning-of-defun)
636 to the one in question; this records where we
637 last passed a comment starter. */
638 /* If we did not already find the defun start, find it now. */
639 if (defun_start
== 0)
641 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
642 defun_start_byte
= find_start_value_byte
;
646 scan_sexps_forward (&state
,
647 defun_start
, defun_start_byte
,
648 comment_end
, -10000, 0, Qnil
, 0);
649 defun_start
= comment_end
;
650 if (state
.incomment
== (comnested
? 1 : -1)
651 && state
.comstyle
== comstyle
)
652 from
= state
.comstr_start
;
657 /* If comment_end is inside some other comment, maybe ours
658 is nested, so we need to try again from within the
659 surrounding comment. Example: { a (* " *) */
661 /* FIXME: We should advance by one or two chars. */
662 defun_start
= state
.comstr_start
+ 2;
663 defun_start_byte
= CHAR_TO_BYTE (defun_start
);
666 } while (defun_start
< comment_end
);
668 from_byte
= CHAR_TO_BYTE (from
);
669 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
674 *bytepos_ptr
= from_byte
;
676 return (from
== comment_end
) ? -1 : from
;
679 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
680 "Return t if OBJECT is a syntax table.\n\
681 Currently, any char-table counts as a syntax table.")
685 if (CHAR_TABLE_P (object
)
686 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
692 check_syntax_table (obj
)
695 if (!(CHAR_TABLE_P (obj
)
696 && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
)))
697 wrong_type_argument (Qsyntax_table_p
, obj
);
700 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
701 "Return the current syntax table.\n\
702 This is the one specified by the current buffer.")
705 return current_buffer
->syntax_table
;
708 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
709 Sstandard_syntax_table
, 0, 0, 0,
710 "Return the standard syntax table.\n\
711 This is the one used for new buffers.")
714 return Vstandard_syntax_table
;
717 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
718 "Construct a new syntax table and return it.\n\
719 It is a copy of the TABLE, which defaults to the standard syntax table.")
726 check_syntax_table (table
);
728 table
= Vstandard_syntax_table
;
730 copy
= Fcopy_sequence (table
);
732 /* Only the standard syntax table should have a default element.
733 Other syntax tables should inherit from parents instead. */
734 XCHAR_TABLE (copy
)->defalt
= Qnil
;
736 /* Copied syntax tables should all have parents.
737 If we copied one with no parent, such as the standard syntax table,
738 use the standard syntax table as the copy's parent. */
739 if (NILP (XCHAR_TABLE (copy
)->parent
))
740 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
744 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
745 "Select a new syntax table for the current buffer.\n\
746 One argument, a syntax table.")
751 check_syntax_table (table
);
752 current_buffer
->syntax_table
= table
;
753 /* Indicate that this buffer now has a specified syntax table. */
754 idx
= PER_BUFFER_VAR_IDX (syntax_table
);
755 SET_PER_BUFFER_VALUE_P (current_buffer
, idx
, 1);
759 /* Convert a letter which signifies a syntax code
760 into the code it signifies.
761 This is used by modify-syntax-entry, and other things. */
763 unsigned char syntax_spec_code
[0400] =
764 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
765 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
766 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
767 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
768 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
769 (char) Smath
, 0377, 0377, (char) Squote
,
770 (char) Sopen
, (char) Sclose
, 0377, 0377,
771 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
772 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
773 0377, 0377, 0377, 0377,
774 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
775 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
776 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
777 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
778 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
779 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
780 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
781 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
782 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
785 /* Indexed by syntax code, give the letter that describes it. */
787 char syntax_code_spec
[16] =
789 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
793 /* Indexed by syntax code, give the object (cons of syntax code and
794 nil) to be stored in syntax table. Since these objects can be
795 shared among syntax tables, we generate them in advance. By
796 sharing objects, the function `describe-syntax' can give a more
798 static Lisp_Object Vsyntax_code_object
;
801 /* Look up the value for CHARACTER in syntax table TABLE's parent
802 and its parents. SYNTAX_ENTRY calls this, when TABLE itself has nil
803 for CHARACTER. It's actually used only when not compiled with GCC. */
806 syntax_parent_lookup (table
, character
)
814 table
= XCHAR_TABLE (table
)->parent
;
818 value
= XCHAR_TABLE (table
)->contents
[character
];
824 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
825 "Return the syntax code of CHARACTER, described by a character.\n\
826 For example, if CHARACTER is a word constituent,\n\
827 the character `w' is returned.\n\
828 The characters that correspond to various syntax codes\n\
829 are listed in the documentation of `modify-syntax-entry'.")
831 Lisp_Object character
;
834 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
836 gl_state
.use_global
= 0;
837 CHECK_NUMBER (character
, 0);
838 char_int
= XINT (character
);
839 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
842 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
843 "Return the matching parenthesis of CHARACTER, or nil if none.")
845 Lisp_Object character
;
848 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
849 gl_state
.use_global
= 0;
850 CHECK_NUMBER (character
, 0);
851 char_int
= XINT (character
);
852 code
= SYNTAX (char_int
);
853 if (code
== Sopen
|| code
== Sclose
)
854 return SYNTAX_MATCH (char_int
);
858 /* This comment supplies the doc string for modify-syntax-entry,
859 for make-docfile to see. We cannot put this in the real DEFUN
860 due to limits in the Unix cpp.
862 DEFUN ("modify-syntax-entry", foo, bar, 2, 3, 0,
863 "Set syntax for character CHAR according to string S.\n\
864 The syntax is changed only for table TABLE, which defaults to\n\
865 the current buffer's syntax table.\n\
866 The first character of S should be one of the following:\n\
867 Space or - whitespace syntax. w word constituent.\n\
868 _ symbol constituent. . punctuation.\n\
869 ( open-parenthesis. ) close-parenthesis.\n\
870 \" string quote. \\ escape.\n\
871 $ paired delimiter. ' expression quote or prefix operator.\n\
872 < comment starter. > comment ender.\n\
873 / character-quote. @ inherit from `standard-syntax-table'.\n\
875 Only single-character comment start and end sequences are represented thus.\n\
876 Two-character sequences are represented as described below.\n\
877 The second character of S is the matching parenthesis,\n\
878 used only if the first character is `(' or `)'.\n\
879 Any additional characters are flags.\n\
880 Defined flags are the characters 1, 2, 3, 4, b, p, and n.\n\
881 1 means CHAR is the start of a two-char comment start sequence.\n\
882 2 means CHAR is the second character of such a sequence.\n\
883 3 means CHAR is the start of a two-char comment end sequence.\n\
884 4 means CHAR is the second character of such a sequence.\n\
886 There can be up to two orthogonal comment sequences. This is to support\n\
887 language modes such as C++. By default, all comment sequences are of style\n\
888 a, but you can set the comment sequence style to b (on the second character\n\
889 of a comment-start, or the first character of a comment-end sequence) using\n\
891 b means CHAR is part of comment sequence b.\n\
892 n means CHAR is part of a nestable comment sequence.\n\
894 p means CHAR is a prefix character for `backward-prefix-chars';\n\
895 such characters are treated as whitespace when they occur\n\
896 between expressions.")
900 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
901 /* I really don't know why this is interactive
902 help-form should at least be made useful whilst reading the second arg
904 "cSet syntax for character: \nsSet syntax for %s to: ",
905 0 /* See immediately above */)
906 (c
, newentry
, syntax_table
)
907 Lisp_Object c
, newentry
, syntax_table
;
909 register unsigned char *p
;
910 register enum syntaxcode code
;
915 CHECK_STRING (newentry
, 1);
917 if (NILP (syntax_table
))
918 syntax_table
= current_buffer
->syntax_table
;
920 check_syntax_table (syntax_table
);
922 p
= XSTRING (newentry
)->data
;
923 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
924 if (((int) code
& 0377) == 0377)
925 error ("invalid syntax description letter: %c", p
[-1]);
927 if (code
== Sinherit
)
929 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), Qnil
);
936 int character
= (STRING_CHAR_AND_LENGTH
937 (p
, STRING_BYTES (XSTRING (newentry
)) - 1, len
));
938 XSETINT (match
, character
);
939 if (XFASTINT (match
) == ' ')
979 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
980 newentry
= XVECTOR (Vsyntax_code_object
)->contents
[val
];
982 /* Since we can't use a shared object, let's make a new one. */
983 newentry
= Fcons (make_number (val
), match
);
985 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), newentry
);
990 /* Dump syntax table to buffer in human-readable format */
993 describe_syntax (value
)
996 register enum syntaxcode code
;
997 char desc
, start1
, start2
, end1
, end2
, prefix
, comstyle
, comnested
;
999 Lisp_Object first
, match_lisp
;
1001 Findent_to (make_number (16), make_number (1));
1005 insert_string ("default\n");
1009 if (CHAR_TABLE_P (value
))
1011 insert_string ("deeper char-table ...\n");
1017 insert_string ("invalid\n");
1021 first
= XCAR (value
);
1022 match_lisp
= XCDR (value
);
1024 if (!INTEGERP (first
) || !(NILP (match_lisp
) || INTEGERP (match_lisp
)))
1026 insert_string ("invalid\n");
1030 code
= (enum syntaxcode
) (XINT (first
) & 0377);
1031 start1
= (XINT (first
) >> 16) & 1;
1032 start2
= (XINT (first
) >> 17) & 1;
1033 end1
= (XINT (first
) >> 18) & 1;
1034 end2
= (XINT (first
) >> 19) & 1;
1035 prefix
= (XINT (first
) >> 20) & 1;
1036 comstyle
= (XINT (first
) >> 21) & 1;
1037 comnested
= (XINT (first
) >> 22) & 1;
1039 if ((int) code
< 0 || (int) code
>= (int) Smax
)
1041 insert_string ("invalid");
1044 desc
= syntax_code_spec
[(int) code
];
1046 str
[0] = desc
, str
[1] = 0;
1049 if (NILP (match_lisp
))
1052 insert_char (XINT (match_lisp
));
1071 insert_string ("\twhich means: ");
1073 switch (SWITCH_ENUM_CAST (code
))
1076 insert_string ("whitespace"); break;
1078 insert_string ("punctuation"); break;
1080 insert_string ("word"); break;
1082 insert_string ("symbol"); break;
1084 insert_string ("open"); break;
1086 insert_string ("close"); break;
1088 insert_string ("quote"); break;
1090 insert_string ("string"); break;
1092 insert_string ("math"); break;
1094 insert_string ("escape"); break;
1096 insert_string ("charquote"); break;
1098 insert_string ("comment"); break;
1100 insert_string ("endcomment"); break;
1102 insert_string ("invalid");
1106 if (!NILP (match_lisp
))
1108 insert_string (", matches ");
1109 insert_char (XINT (match_lisp
));
1113 insert_string (",\n\t is the first character of a comment-start sequence");
1115 insert_string (",\n\t is the second character of a comment-start sequence");
1118 insert_string (",\n\t is the first character of a comment-end sequence");
1120 insert_string (",\n\t is the second character of a comment-end sequence");
1122 insert_string (" (comment style b)");
1124 insert_string (" (nestable)");
1127 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
1129 insert_string ("\n");
1133 describe_syntax_1 (vector
)
1136 struct buffer
*old
= current_buffer
;
1137 set_buffer_internal (XBUFFER (Vstandard_output
));
1138 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
, (int *) 0, 0);
1139 while (! NILP (XCHAR_TABLE (vector
)->parent
))
1141 vector
= XCHAR_TABLE (vector
)->parent
;
1142 insert_string ("\nThe parent syntax table is:");
1143 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
,
1147 call0 (intern ("help-mode"));
1148 set_buffer_internal (old
);
1152 DEFUN ("describe-syntax", Fdescribe_syntax
, Sdescribe_syntax
, 0, 0, "",
1153 "Describe the syntax specifications in the syntax table.\n\
1154 The descriptions are inserted in a buffer, which is then displayed.")
1157 internal_with_output_to_temp_buffer
1158 ("*Help*", describe_syntax_1
, current_buffer
->syntax_table
);
1163 int parse_sexp_ignore_comments
;
1165 /* Return the position across COUNT words from FROM.
1166 If that many words cannot be found before the end of the buffer, return 0.
1167 COUNT negative means scan backward and stop at word beginning. */
1170 scan_words (from
, count
)
1171 register int from
, count
;
1173 register int beg
= BEGV
;
1174 register int end
= ZV
;
1175 register int from_byte
= CHAR_TO_BYTE (from
);
1176 register enum syntaxcode code
;
1182 SETUP_SYNTAX_TABLE (from
, count
);
1193 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1194 ch0
= FETCH_CHAR (from_byte
);
1195 code
= SYNTAX (ch0
);
1196 INC_BOTH (from
, from_byte
);
1197 if (words_include_escapes
1198 && (code
== Sescape
|| code
== Scharquote
))
1203 /* Now CH0 is a character which begins a word and FROM is the
1204 position of the next character. */
1207 if (from
== end
) break;
1208 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1209 ch1
= FETCH_CHAR (from_byte
);
1210 code
= SYNTAX (ch1
);
1211 if (!(words_include_escapes
1212 && (code
== Sescape
|| code
== Scharquote
)))
1213 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1215 INC_BOTH (from
, from_byte
);
1229 DEC_BOTH (from
, from_byte
);
1230 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1231 ch1
= FETCH_CHAR (from_byte
);
1232 code
= SYNTAX (ch1
);
1233 if (words_include_escapes
1234 && (code
== Sescape
|| code
== Scharquote
))
1239 /* Now CH1 is a character which ends a word and FROM is the
1247 temp_byte
= dec_bytepos (from_byte
);
1248 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1249 ch0
= FETCH_CHAR (temp_byte
);
1250 code
= SYNTAX (ch0
);
1251 if (!(words_include_escapes
1252 && (code
== Sescape
|| code
== Scharquote
)))
1253 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1255 DEC_BOTH (from
, from_byte
);
1266 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 1, 1, "p",
1267 "Move point forward ARG words (backward if ARG is negative).\n\
1268 Normally returns t.\n\
1269 If an edge of the buffer or a field boundary is reached, point is left there\n\
1270 and the function returns nil. Field boundaries are not noticed if\n\
1271 `inhibit-field-text-motion' is non-nil.")
1276 CHECK_NUMBER (count
, 0);
1278 val
= orig_val
= scan_words (PT
, XINT (count
));
1280 val
= XINT (count
) > 0 ? ZV
: BEGV
;
1282 /* Avoid jumping out of an input field. */
1283 val
= XFASTINT (Fconstrain_to_field (make_number (val
), make_number (PT
),
1287 return val
== orig_val
? Qt
: Qnil
;
1290 Lisp_Object
skip_chars ();
1292 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1293 "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
1294 STRING is like the inside of a `[...]' in a regular expression\n\
1295 except that `]' is never special and `\\' quotes `^', `-' or `\\'\n\
1296 (but not as the end of a range; quoting is never needed there).\n\
1297 Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
1298 With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
1299 Returns the distance traveled, either zero or positive.")
1301 Lisp_Object string
, lim
;
1303 return skip_chars (1, 0, string
, lim
);
1306 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1307 "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
1308 See `skip-chars-forward' for details.\n\
1309 Returns the distance traveled, either zero or negative.")
1311 Lisp_Object string
, lim
;
1313 return skip_chars (0, 0, string
, lim
);
1316 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1317 "Move point forward across chars in specified syntax classes.\n\
1318 SYNTAX is a string of syntax code characters.\n\
1319 Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
1320 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1321 This function returns the distance traveled, either zero or positive.")
1323 Lisp_Object syntax
, lim
;
1325 return skip_chars (1, 1, syntax
, lim
);
1328 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1329 "Move point backward across chars in specified syntax classes.\n\
1330 SYNTAX is a string of syntax code characters.\n\
1331 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
1332 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1333 This function returns the distance traveled, either zero or negative.")
1335 Lisp_Object syntax
, lim
;
1337 return skip_chars (0, 1, syntax
, lim
);
1341 skip_chars (forwardp
, syntaxp
, string
, lim
)
1342 int forwardp
, syntaxp
;
1343 Lisp_Object string
, lim
;
1345 register unsigned int c
;
1347 unsigned char fastmap
[0400];
1348 /* If SYNTAXP is 0, STRING may contain multi-byte form of characters
1349 of which codes don't fit in FASTMAP. In that case, we set the
1350 first byte of multibyte form (i.e. base leading-code) in FASTMAP
1351 and set the actual ranges of characters in CHAR_RANGES. In the
1352 form "X-Y" of STRING, both X and Y must belong to the same
1353 character set because a range striding across character sets is
1356 int n_char_ranges
= 0;
1358 register int i
, i_byte
;
1359 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1360 int string_multibyte
;
1365 CHECK_STRING (string
, 0);
1366 char_ranges
= (int *) alloca (XSTRING (string
)->size
* (sizeof (int)) * 2);
1367 string_multibyte
= STRING_MULTIBYTE (string
);
1368 str
= XSTRING (string
)->data
;
1369 size_byte
= STRING_BYTES (XSTRING (string
));
1371 /* Adjust the multibyteness of the string to that of the buffer. */
1372 if (multibyte
!= string_multibyte
)
1377 nbytes
= count_size_as_multibyte (XSTRING (string
)->data
,
1378 XSTRING (string
)->size
);
1380 nbytes
= XSTRING (string
)->size
;
1381 if (nbytes
!= size_byte
)
1383 str
= (unsigned char *) alloca (nbytes
);
1384 copy_text (XSTRING (string
)->data
, str
, size_byte
,
1385 string_multibyte
, multibyte
);
1391 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1393 CHECK_NUMBER_COERCE_MARKER (lim
, 0);
1395 /* In any case, don't allow scan outside bounds of buffer. */
1396 if (XINT (lim
) > ZV
)
1397 XSETFASTINT (lim
, ZV
);
1398 if (XINT (lim
) < BEGV
)
1399 XSETFASTINT (lim
, BEGV
);
1401 bzero (fastmap
, sizeof fastmap
);
1405 if (i_byte
< size_byte
1406 && XSTRING (string
)->data
[0] == '^')
1408 negate
= 1; i_byte
++;
1411 /* Find the characters specified and set their elements of fastmap.
1412 If syntaxp, each character counts as itself.
1413 Otherwise, handle backslashes and ranges specially. */
1415 while (i_byte
< size_byte
)
1417 int c_leading_code
= str
[i_byte
];
1419 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, size_byte
- i_byte
, len
);
1423 fastmap
[syntax_spec_code
[c
& 0377]] = 1;
1428 if (i_byte
== size_byte
)
1431 c_leading_code
= str
[i_byte
];
1432 c
= STRING_CHAR_AND_LENGTH (str
+i_byte
, size_byte
-i_byte
, len
);
1435 if (i_byte
< size_byte
1436 && str
[i_byte
] == '-')
1438 unsigned int c2
, c2_leading_code
;
1440 /* Skip over the dash. */
1443 if (i_byte
== size_byte
)
1446 /* Get the end of the range. */
1447 c2_leading_code
= str
[i_byte
];
1448 c2
=STRING_CHAR_AND_LENGTH (str
+i_byte
, size_byte
-i_byte
, len
);
1451 if (SINGLE_BYTE_CHAR_P (c
))
1453 if (! SINGLE_BYTE_CHAR_P (c2
))
1455 /* Handle a range such as \177-\377 in multibyte
1456 mode. Split that into two ranges, the low
1457 one ending at 0237, and the high one starting
1458 at the smallest character in the charset of
1459 C2 and ending at C2. */
1460 int charset
= CHAR_CHARSET (c2
);
1461 int c1
= MAKE_CHAR (charset
, 0, 0);
1463 fastmap
[c2_leading_code
] = 1;
1464 char_ranges
[n_char_ranges
++] = c1
;
1465 char_ranges
[n_char_ranges
++] = c2
;
1474 else if (! SINGLE_BYTE_CHAR_P (c2
))
1476 if (c_leading_code
!= c2_leading_code
)
1477 error ("Invalid character range: %s",
1478 XSTRING (string
)->data
);
1481 fastmap
[c_leading_code
] = 1;
1482 char_ranges
[n_char_ranges
++] = c
;
1483 char_ranges
[n_char_ranges
++] = c2
;
1489 if (SINGLE_BYTE_CHAR_P (c
))
1493 fastmap
[c_leading_code
] = 1;
1494 char_ranges
[n_char_ranges
++] = c
;
1495 char_ranges
[n_char_ranges
++] = c
;
1501 /* If ^ was the first character, complement the fastmap. In
1502 addition, as all multibyte characters have possibility of
1503 matching, set all entries for base leading codes, which is
1504 harmless even if SYNTAXP is 1. */
1507 for (i
= 0; i
< sizeof fastmap
; i
++)
1509 if (!multibyte
|| !BASE_LEADING_CODE_P (i
))
1516 int start_point
= PT
;
1518 int pos_byte
= PT_BYTE
;
1523 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1528 if (pos
< XINT (lim
))
1529 while (fastmap
[(int) SYNTAX (FETCH_CHAR (pos_byte
))])
1531 /* Since we already checked for multibyteness,
1532 avoid using INC_BOTH which checks again. */
1535 if (pos
>= XINT (lim
))
1537 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1542 while (pos
< XINT (lim
)
1543 && fastmap
[(int) SYNTAX (FETCH_BYTE (pos
))])
1546 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1554 while (pos
> XINT (lim
))
1556 int savepos
= pos_byte
;
1557 /* Since we already checked for multibyteness,
1558 avoid using DEC_BOTH which checks again. */
1561 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
1562 if (!fastmap
[(int) SYNTAX (FETCH_CHAR (pos_byte
))])
1572 if (pos
> XINT (lim
))
1573 while (fastmap
[(int) SYNTAX (FETCH_BYTE (pos
- 1))])
1576 if (pos
<= XINT (lim
))
1578 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
1588 while (pos
< XINT (lim
) && fastmap
[(c
= FETCH_BYTE (pos_byte
))])
1590 /* If we are looking at a multibyte character, we
1591 must look up the character in the table
1592 CHAR_RANGES. If there's no data in the table,
1593 that character is not what we want to skip. */
1594 if (BASE_LEADING_CODE_P (c
)
1595 && (c
= FETCH_MULTIBYTE_CHAR (pos_byte
),
1596 ! SINGLE_BYTE_CHAR_P (c
)))
1598 /* The following code do the right thing even if
1599 n_char_ranges is zero (i.e. no data in
1601 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1602 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1604 if (!(negate
^ (i
< n_char_ranges
)))
1607 INC_BOTH (pos
, pos_byte
);
1610 while (pos
< XINT (lim
) && fastmap
[FETCH_BYTE (pos
)])
1616 while (pos
> XINT (lim
))
1618 int prev_pos_byte
= pos_byte
;
1620 DEC_POS (prev_pos_byte
);
1621 if (!fastmap
[(c
= FETCH_BYTE (prev_pos_byte
))])
1624 /* See the comment in the previous similar code. */
1625 if (BASE_LEADING_CODE_P (c
)
1626 && (c
= FETCH_MULTIBYTE_CHAR (prev_pos_byte
),
1627 ! SINGLE_BYTE_CHAR_P (c
)))
1629 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1630 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1632 if (!(negate
^ (i
< n_char_ranges
)))
1636 pos_byte
= prev_pos_byte
;
1639 while (pos
> XINT (lim
) && fastmap
[FETCH_BYTE (pos
- 1)])
1644 #if 0 /* Not needed now that a position in mid-character
1645 cannot be specified in Lisp. */
1647 /* INC_POS or DEC_POS might have moved POS over LIM. */
1648 && (forwardp
? (pos
> XINT (lim
)) : (pos
< XINT (lim
))))
1655 SET_PT_BOTH (pos
, pos_byte
);
1658 return make_number (PT
- start_point
);
1662 /* Jump over a comment, assuming we are at the beginning of one.
1663 FROM is the current position.
1664 FROM_BYTE is the bytepos corresponding to FROM.
1665 Do not move past STOP (a charpos).
1666 The comment over which we have to jump is of style STYLE
1667 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
1668 NESTING should be positive to indicate the nesting at the beginning
1669 for nested comments and should be zero or negative else.
1670 ST_COMMENT_STYLE cannot be nested.
1671 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
1672 (or 0 If the search cannot start in the middle of a two-character).
1674 If successful, return 1 and store the charpos of the comment's end
1675 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
1676 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
1677 corresponding bytepos into *BYTEPOS_PTR and the current nesting
1678 (as defined for state.incomment) in *INCOMMENT_PTR.
1680 The comment end is the last character of the comment rather than the
1681 character just after the comment.
1683 Global syntax data is assumed to initially be valid for FROM and
1684 remains valid for forward search starting at the returned position. */
1687 forw_comment (from
, from_byte
, stop
, nesting
, style
, prev_syntax
,
1688 charpos_ptr
, bytepos_ptr
, incomment_ptr
)
1689 int from
, from_byte
, stop
;
1690 int nesting
, style
, prev_syntax
;
1691 int *charpos_ptr
, *bytepos_ptr
, *incomment_ptr
;
1694 register enum syntaxcode code
;
1695 register int syntax
;
1697 if (nesting
<= 0) nesting
= -1;
1699 /* Enter the loop in the middle so that we find
1700 a 2-char comment ender if we start in the middle of it. */
1701 syntax
= prev_syntax
;
1702 if (syntax
!= 0) goto forw_incomment
;
1708 *incomment_ptr
= nesting
;
1709 *charpos_ptr
= from
;
1710 *bytepos_ptr
= from_byte
;
1713 c
= FETCH_CHAR (from_byte
);
1714 syntax
= SYNTAX_WITH_FLAGS (c
);
1715 code
= syntax
& 0xff;
1716 if (code
== Sendcomment
1717 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1719 /* we have encountered a comment end of the same style
1720 as the comment sequence which began this comment
1723 if (code
== Scomment_fence
1724 && style
== ST_COMMENT_STYLE
)
1725 /* we have encountered a comment end of the same style
1726 as the comment sequence which began this comment
1731 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
)
1732 /* we have encountered a nested comment of the same style
1733 as the comment sequence which began this comment section */
1735 INC_BOTH (from
, from_byte
);
1736 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1739 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
1740 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1741 && (c1
= FETCH_CHAR (from_byte
),
1742 SYNTAX_COMEND_SECOND (c1
)))
1745 /* we have encountered a comment end of the same style
1746 as the comment sequence which began this comment
1751 INC_BOTH (from
, from_byte
);
1752 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1757 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
1758 && (c1
= FETCH_CHAR (from_byte
),
1759 SYNTAX_COMMENT_STYLE (c1
) == style
1760 && SYNTAX_COMSTART_SECOND (c1
)))
1761 /* we have encountered a nested comment of the same style
1762 as the comment sequence which began this comment
1765 INC_BOTH (from
, from_byte
);
1766 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1770 *charpos_ptr
= from
;
1771 *bytepos_ptr
= from_byte
;
1775 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
1776 "Move forward across up to N comments. If N is negative, move backward.\n\
1777 Stop scanning if we find something other than a comment or whitespace.\n\
1778 Set point to where scanning stops.\n\
1779 If N comments are found as expected, with nothing except whitespace\n\
1780 between them, return t; otherwise return nil.")
1788 register enum syntaxcode code
;
1789 int comstyle
= 0; /* style of comment encountered */
1790 int comnested
= 0; /* whether the comment is nestable or not */
1793 int out_charpos
, out_bytepos
;
1796 CHECK_NUMBER (count
, 0);
1797 count1
= XINT (count
);
1798 stop
= count1
> 0 ? ZV
: BEGV
;
1804 from_byte
= PT_BYTE
;
1806 SETUP_SYNTAX_TABLE (from
, count1
);
1815 SET_PT_BOTH (from
, from_byte
);
1819 c
= FETCH_CHAR (from_byte
);
1821 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
1822 comnested
= SYNTAX_COMMENT_NESTED (c
);
1823 comstyle
= SYNTAX_COMMENT_STYLE (c
);
1824 INC_BOTH (from
, from_byte
);
1825 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1826 if (from
< stop
&& comstart_first
1827 && (c1
= FETCH_CHAR (from_byte
),
1828 SYNTAX_COMSTART_SECOND (c1
)))
1830 /* We have encountered a comment start sequence and we
1831 are ignoring all text inside comments. We must record
1832 the comment style this sequence begins so that later,
1833 only a comment end of the same style actually ends
1834 the comment section. */
1836 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1837 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1838 INC_BOTH (from
, from_byte
);
1839 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1841 /* FIXME: here we ignore 2-char endcomments while we don't
1842 when going backwards. */
1844 while (code
== Swhitespace
|| code
== Sendcomment
);
1846 if (code
== Scomment_fence
)
1847 comstyle
= ST_COMMENT_STYLE
;
1848 else if (code
!= Scomment
)
1851 DEC_BOTH (from
, from_byte
);
1852 SET_PT_BOTH (from
, from_byte
);
1855 /* We're at the start of a comment. */
1856 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
1857 &out_charpos
, &out_bytepos
, &dummy
);
1858 from
= out_charpos
; from_byte
= out_bytepos
;
1862 SET_PT_BOTH (from
, from_byte
);
1865 INC_BOTH (from
, from_byte
);
1866 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1867 /* We have skipped one comment. */
1875 int quoted
, comstart_second
;
1879 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
1884 DEC_BOTH (from
, from_byte
);
1885 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
1886 quoted
= char_quoted (from
, from_byte
);
1889 DEC_BOTH (from
, from_byte
);
1892 c
= FETCH_CHAR (from_byte
);
1895 comnested
= SYNTAX_COMMENT_NESTED (c
);
1896 if (code
== Sendcomment
)
1897 comstyle
= SYNTAX_COMMENT_STYLE (c
);
1898 comstart_second
= SYNTAX_COMSTART_SECOND (c
);
1899 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1900 && prev_char_comend_first (from
, from_byte
)
1901 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
1903 /* We must record the comment style encountered so that
1904 later, we can match only the proper comment begin
1905 sequence of the same style. */
1906 DEC_BOTH (from
, from_byte
);
1908 /* Calling char_quoted, above, set up global syntax position
1909 at the new value of FROM. */
1910 c1
= FETCH_CHAR (from_byte
);
1911 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1912 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1914 if (from
> stop
&& comstart_second
1915 && prev_char_comstart_first (from
, from_byte
)
1916 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
1919 DEC_BOTH (from
, from_byte
);
1922 if (code
== Scomment_fence
)
1924 /* Skip until first preceding unquoted comment_fence. */
1925 int found
= 0, ini
= from
, ini_byte
= from_byte
;
1929 DEC_BOTH (from
, from_byte
);
1932 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1933 c
= FETCH_CHAR (from_byte
);
1934 if (SYNTAX (c
) == Scomment_fence
1935 && !char_quoted (from
, from_byte
))
1943 from
= ini
; /* Set point to ini + 1. */
1944 from_byte
= ini_byte
;
1948 else if (code
== Sendcomment
)
1950 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
1951 &out_charpos
, &out_bytepos
);
1954 #if 0 /* cc-mode (and maybe others) relies on the bogus behavior. */
1955 /* Failure: we should go back to the end of this
1956 not-quite-endcomment. */
1957 if (SYNTAX(c
) != code
)
1958 /* It was a two-char Sendcomment. */
1959 INC_BOTH (from
, from_byte
);
1964 /* We have skipped one comment. */
1965 from
= out_charpos
, from_byte
= out_bytepos
;
1968 else if (code
!= Swhitespace
&& code
!= Scomment
)
1972 INC_BOTH (from
, from_byte
);
1973 SET_PT_BOTH (from
, from_byte
);
1981 SET_PT_BOTH (from
, from_byte
);
1986 /* Return syntax code of character C if C is a single byte character
1987 or `multibyte_symbol_p' is zero. Otherwise, retrun Ssymbol. */
1989 #define SYNTAX_WITH_MULTIBYTE_CHECK(c) \
1990 ((SINGLE_BYTE_CHAR_P (c) || !multibyte_symbol_p) \
1991 ? SYNTAX (c) : Ssymbol)
1994 scan_lists (from
, count
, depth
, sexpflag
)
1996 int count
, depth
, sexpflag
;
1999 register int stop
= count
> 0 ? ZV
: BEGV
;
2004 register enum syntaxcode code
, temp_code
;
2005 int min_depth
= depth
; /* Err out if depth gets less than this. */
2006 int comstyle
= 0; /* style of comment encountered */
2007 int comnested
= 0; /* whether the comment is nestable or not */
2009 int last_good
= from
;
2012 int out_bytepos
, out_charpos
;
2014 int multibyte_symbol_p
= sexpflag
&& multibyte_syntax_as_symbol
;
2016 if (depth
> 0) min_depth
= 0;
2018 if (from
> ZV
) from
= ZV
;
2019 if (from
< BEGV
) from
= BEGV
;
2021 from_byte
= CHAR_TO_BYTE (from
);
2026 SETUP_SYNTAX_TABLE (from
, count
);
2031 int comstart_first
, prefix
;
2032 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2033 c
= FETCH_CHAR (from_byte
);
2034 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2035 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2036 comnested
= SYNTAX_COMMENT_NESTED (c
);
2037 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2038 prefix
= SYNTAX_PREFIX (c
);
2039 if (depth
== min_depth
)
2041 INC_BOTH (from
, from_byte
);
2042 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2043 if (from
< stop
&& comstart_first
2044 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte
))
2045 && parse_sexp_ignore_comments
)
2047 /* we have encountered a comment start sequence and we
2048 are ignoring all text inside comments. We must record
2049 the comment style this sequence begins so that later,
2050 only a comment end of the same style actually ends
2051 the comment section */
2053 c1
= FETCH_CHAR (from_byte
);
2054 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2055 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2056 INC_BOTH (from
, from_byte
);
2057 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2063 switch (SWITCH_ENUM_CAST (code
))
2067 if (from
== stop
) goto lose
;
2068 INC_BOTH (from
, from_byte
);
2069 /* treat following character as a word constituent */
2072 if (depth
|| !sexpflag
) break;
2073 /* This word counts as a sexp; return at end of it. */
2076 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2078 /* Some compilers can't handle this inside the switch. */
2079 c
= FETCH_CHAR (from_byte
);
2080 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2085 INC_BOTH (from
, from_byte
);
2086 if (from
== stop
) goto lose
;
2095 INC_BOTH (from
, from_byte
);
2099 case Scomment_fence
:
2100 comstyle
= ST_COMMENT_STYLE
;
2103 if (!parse_sexp_ignore_comments
) break;
2104 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2105 found
= forw_comment (from
, from_byte
, stop
,
2106 comnested
, comstyle
, 0,
2107 &out_charpos
, &out_bytepos
, &dummy
);
2108 from
= out_charpos
, from_byte
= out_bytepos
;
2115 INC_BOTH (from
, from_byte
);
2116 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2122 if (from
!= stop
&& c
== FETCH_CHAR (from_byte
))
2124 INC_BOTH (from
, from_byte
);
2134 if (!++depth
) goto done
;
2139 if (!--depth
) goto done
;
2140 if (depth
< min_depth
)
2141 Fsignal (Qscan_error
,
2142 Fcons (build_string ("Containing expression ends prematurely"),
2143 Fcons (make_number (last_good
),
2144 Fcons (make_number (from
), Qnil
))));
2149 temp_pos
= dec_bytepos (from_byte
);
2150 stringterm
= FETCH_CHAR (temp_pos
);
2153 if (from
>= stop
) goto lose
;
2154 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2155 c
= FETCH_CHAR (from_byte
);
2158 : SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring_fence
)
2161 /* Some compilers can't handle this inside the switch. */
2162 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2167 INC_BOTH (from
, from_byte
);
2169 INC_BOTH (from
, from_byte
);
2171 INC_BOTH (from
, from_byte
);
2172 if (!depth
&& sexpflag
) goto done
;
2177 /* Reached end of buffer. Error if within object, return nil if between */
2178 if (depth
) goto lose
;
2183 /* End of object reached */
2192 DEC_BOTH (from
, from_byte
);
2193 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2194 c
= FETCH_CHAR (from_byte
);
2195 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2196 if (depth
== min_depth
)
2199 comnested
= SYNTAX_COMMENT_NESTED (c
);
2200 if (code
== Sendcomment
)
2201 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2202 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2203 && prev_char_comend_first (from
, from_byte
)
2204 && parse_sexp_ignore_comments
)
2206 /* We must record the comment style encountered so that
2207 later, we can match only the proper comment begin
2208 sequence of the same style. */
2209 DEC_BOTH (from
, from_byte
);
2210 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2212 c1
= FETCH_CHAR (from_byte
);
2213 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2214 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2217 /* Quoting turns anything except a comment-ender
2218 into a word character. Note that this cannot be true
2219 if we decremented FROM in the if-statement above. */
2220 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2222 else if (SYNTAX_PREFIX (c
))
2225 switch (SWITCH_ENUM_CAST (code
))
2231 if (depth
|| !sexpflag
) break;
2232 /* This word counts as a sexp; count object finished
2233 after passing it. */
2236 temp_pos
= from_byte
;
2237 if (! NILP (current_buffer
->enable_multibyte_characters
))
2241 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2242 c1
= FETCH_CHAR (temp_pos
);
2243 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2244 /* Don't allow comment-end to be quoted. */
2245 if (temp_code
== Sendcomment
)
2247 quoted
= char_quoted (from
- 1, temp_pos
);
2250 DEC_BOTH (from
, from_byte
);
2251 temp_pos
= dec_bytepos (temp_pos
);
2252 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2254 c1
= FETCH_CHAR (temp_pos
);
2255 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2256 if (! (quoted
|| temp_code
== Sword
2257 || temp_code
== Ssymbol
2258 || temp_code
== Squote
))
2260 DEC_BOTH (from
, from_byte
);
2267 temp_pos
= dec_bytepos (from_byte
);
2268 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2269 if (from
!= stop
&& c
== FETCH_CHAR (temp_pos
))
2270 DEC_BOTH (from
, from_byte
);
2279 if (!++depth
) goto done2
;
2284 if (!--depth
) goto done2
;
2285 if (depth
< min_depth
)
2286 Fsignal (Qscan_error
,
2287 Fcons (build_string ("Containing expression ends prematurely"),
2288 Fcons (make_number (last_good
),
2289 Fcons (make_number (from
), Qnil
))));
2293 if (!parse_sexp_ignore_comments
)
2295 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2296 &out_charpos
, &out_bytepos
);
2297 /* FIXME: if found == -1, then it really wasn't a comment-end.
2298 For single-char Sendcomment, we can't do much about it apart
2299 from skipping the char.
2300 For 2-char endcomments, we could try again, taking both
2301 chars as separate entities, but it's a lot of trouble
2302 for very little gain, so we don't bother either. -sm */
2304 from
= out_charpos
, from_byte
= out_bytepos
;
2307 case Scomment_fence
:
2311 DEC_BOTH (from
, from_byte
);
2312 if (from
== stop
) goto lose
;
2313 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2314 if (!char_quoted (from
, from_byte
)
2315 && (c
= FETCH_CHAR (from_byte
),
2316 SYNTAX_WITH_MULTIBYTE_CHECK (c
) == code
))
2319 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2323 stringterm
= FETCH_CHAR (from_byte
);
2326 if (from
== stop
) goto lose
;
2327 temp_pos
= from_byte
;
2328 if (! NILP (current_buffer
->enable_multibyte_characters
))
2332 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2333 if (!char_quoted (from
- 1, temp_pos
)
2334 && stringterm
== FETCH_CHAR (temp_pos
))
2336 DEC_BOTH (from
, from_byte
);
2338 DEC_BOTH (from
, from_byte
);
2339 if (!depth
&& sexpflag
) goto done2
;
2344 /* Reached start of buffer. Error if within object, return nil if between */
2345 if (depth
) goto lose
;
2356 XSETFASTINT (val
, from
);
2360 Fsignal (Qscan_error
,
2361 Fcons (build_string ("Unbalanced parentheses"),
2362 Fcons (make_number (last_good
),
2363 Fcons (make_number (from
), Qnil
))));
2368 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2369 "Scan from character number FROM by COUNT lists.\n\
2370 Returns the character number of the position thus found.\n\
2372 If DEPTH is nonzero, paren depth begins counting from that value,\n\
2373 only places where the depth in parentheses becomes zero\n\
2374 are candidates for stopping; COUNT such places are counted.\n\
2375 Thus, a positive value for DEPTH means go out levels.\n\
2377 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2379 If the beginning or end of (the accessible part of) the buffer is reached\n\
2380 and the depth is wrong, an error is signaled.\n\
2381 If the depth is right but the count is not used up, nil is returned.")
2382 (from
, count
, depth
)
2383 Lisp_Object from
, count
, depth
;
2385 CHECK_NUMBER (from
, 0);
2386 CHECK_NUMBER (count
, 1);
2387 CHECK_NUMBER (depth
, 2);
2389 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2392 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2393 "Scan from character number FROM by COUNT balanced expressions.\n\
2394 If COUNT is negative, scan backwards.\n\
2395 Returns the character number of the position thus found.\n\
2397 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2399 If the beginning or end of (the accessible part of) the buffer is reached\n\
2400 in the middle of a parenthetical grouping, an error is signaled.\n\
2401 If the beginning or end is reached between groupings\n\
2402 but before count is used up, nil is returned.")
2404 Lisp_Object from
, count
;
2406 CHECK_NUMBER (from
, 0);
2407 CHECK_NUMBER (count
, 1);
2409 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2412 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2414 "Move point backward over any number of chars with prefix syntax.\n\
2415 This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
2420 int opoint_byte
= PT_BYTE
;
2422 int pos_byte
= PT_BYTE
;
2427 SET_PT_BOTH (opoint
, opoint_byte
);
2432 SETUP_SYNTAX_TABLE (pos
, -1);
2434 DEC_BOTH (pos
, pos_byte
);
2436 while (!char_quoted (pos
, pos_byte
)
2437 /* Previous statement updates syntax table. */
2438 && ((c
= FETCH_CHAR (pos_byte
), SYNTAX (c
) == Squote
)
2439 || SYNTAX_PREFIX (c
)))
2442 opoint_byte
= pos_byte
;
2445 DEC_BOTH (pos
, pos_byte
);
2448 SET_PT_BOTH (opoint
, opoint_byte
);
2453 /* Parse forward from FROM / FROM_BYTE to END,
2454 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2455 and return a description of the state of the parse at END.
2456 If STOPBEFORE is nonzero, stop at the start of an atom.
2457 If COMMENTSTOP is 1, stop at the start of a comment.
2458 If COMMENTSTOP is -1, stop at the start or end of a comment,
2459 after the beginning of a string, or after the end of a string. */
2462 scan_sexps_forward (stateptr
, from
, from_byte
, end
, targetdepth
,
2463 stopbefore
, oldstate
, commentstop
)
2464 struct lisp_parse_state
*stateptr
;
2466 int end
, targetdepth
, stopbefore
;
2467 Lisp_Object oldstate
;
2470 struct lisp_parse_state state
;
2472 register enum syntaxcode code
;
2475 struct level
{ int last
, prev
; };
2476 struct level levelstart
[100];
2477 register struct level
*curlevel
= levelstart
;
2478 struct level
*endlevel
= levelstart
+ 100;
2479 register int depth
; /* Paren depth of current scanning location.
2480 level - levelstart equals this except
2481 when the depth becomes negative. */
2482 int mindepth
; /* Lowest DEPTH value seen. */
2483 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2485 int prev_from
; /* Keep one character before FROM. */
2487 int prev_from_syntax
;
2488 int boundary_stop
= commentstop
== -1;
2491 int out_bytepos
, out_charpos
;
2495 prev_from_byte
= from_byte
;
2497 DEC_BOTH (prev_from
, prev_from_byte
);
2499 /* Use this macro instead of `from++'. */
2501 do { prev_from = from; \
2502 prev_from_byte = from_byte; \
2504 = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte)); \
2505 INC_BOTH (from, from_byte); \
2506 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2512 if (NILP (oldstate
))
2515 state
.instring
= -1;
2516 state
.incomment
= 0;
2517 state
.comstyle
= 0; /* comment style a by default. */
2518 state
.comstr_start
= -1; /* no comment/string seen. */
2522 tem
= Fcar (oldstate
);
2528 oldstate
= Fcdr (oldstate
);
2529 oldstate
= Fcdr (oldstate
);
2530 oldstate
= Fcdr (oldstate
);
2531 tem
= Fcar (oldstate
);
2532 /* Check whether we are inside string_fence-style string: */
2533 state
.instring
= (!NILP (tem
)
2534 ? (INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2537 oldstate
= Fcdr (oldstate
);
2538 tem
= Fcar (oldstate
);
2539 state
.incomment
= (!NILP (tem
)
2540 ? (INTEGERP (tem
) ? XINT (tem
) : -1)
2543 oldstate
= Fcdr (oldstate
);
2544 tem
= Fcar (oldstate
);
2545 start_quoted
= !NILP (tem
);
2547 /* if the eighth element of the list is nil, we are in comment
2548 style a. If it is non-nil, we are in comment style b */
2549 oldstate
= Fcdr (oldstate
);
2550 oldstate
= Fcdr (oldstate
);
2551 tem
= Fcar (oldstate
);
2552 state
.comstyle
= NILP (tem
) ? 0 : (EQ (tem
, Qsyntax_table
)
2553 ? ST_COMMENT_STYLE
: 1);
2555 oldstate
= Fcdr (oldstate
);
2556 tem
= Fcar (oldstate
);
2557 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2558 oldstate
= Fcdr (oldstate
);
2559 tem
= Fcar (oldstate
);
2560 while (!NILP (tem
)) /* >= second enclosing sexps. */
2562 /* curlevel++->last ran into compiler bug on Apollo */
2563 curlevel
->last
= XINT (Fcar (tem
));
2564 if (++curlevel
== endlevel
)
2565 curlevel
--; /* error ("Nesting too deep for parser"); */
2566 curlevel
->prev
= -1;
2567 curlevel
->last
= -1;
2574 curlevel
->prev
= -1;
2575 curlevel
->last
= -1;
2577 SETUP_SYNTAX_TABLE (prev_from
, 1);
2578 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2579 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2581 /* Enter the loop at a place appropriate for initial state. */
2583 if (state
.incomment
)
2584 goto startincomment
;
2585 if (state
.instring
>= 0)
2587 nofence
= state
.instring
!= ST_STRING_STYLE
;
2589 goto startquotedinstring
;
2592 else if (start_quoted
)
2595 #if 0 /* This seems to be redundant with the identical code above. */
2596 SETUP_SYNTAX_TABLE (prev_from
, 1);
2597 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2598 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2604 code
= prev_from_syntax
& 0xff;
2606 if (code
== Scomment
)
2608 state
.comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax
);
2609 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
2611 state
.comstr_start
= prev_from
;
2613 else if (code
== Scomment_fence
)
2615 /* Record the comment style we have entered so that only
2616 the comment-end sequence of the same style actually
2617 terminates the comment section. */
2618 state
.comstyle
= ST_COMMENT_STYLE
;
2619 state
.incomment
= -1;
2620 state
.comstr_start
= prev_from
;
2623 else if (from
< end
)
2624 if (SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
))
2625 if (c1
= FETCH_CHAR (from_byte
),
2626 SYNTAX_COMSTART_SECOND (c1
))
2627 /* Duplicate code to avoid a complex if-expression
2628 which causes trouble for the SGI compiler. */
2630 /* Record the comment style we have entered so that only
2631 the comment-end sequence of the same style actually
2632 terminates the comment section. */
2633 state
.comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte
));
2634 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
);
2635 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2636 state
.incomment
= comnested
? 1 : -1;
2637 state
.comstr_start
= prev_from
;
2642 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
2644 switch (SWITCH_ENUM_CAST (code
))
2648 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2649 curlevel
->last
= prev_from
;
2651 if (from
== end
) goto endquoted
;
2654 /* treat following character as a word constituent */
2657 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2658 curlevel
->last
= prev_from
;
2662 /* Some compilers can't handle this inside the switch. */
2663 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2669 if (from
== end
) goto endquoted
;
2681 curlevel
->prev
= curlevel
->last
;
2685 if (commentstop
|| boundary_stop
) goto done
;
2687 /* The (from == BEGV) test was to enter the loop in the middle so
2688 that we find a 2-char comment ender even if we start in the
2689 middle of it. We don't want to do that if we're just at the
2690 beginning of the comment (think of (*) ... (*)). */
2691 found
= forw_comment (from
, from_byte
, end
,
2692 state
.incomment
, state
.comstyle
,
2693 (from
== BEGV
|| from
< state
.comstr_start
+ 3)
2694 ? 0 : prev_from_syntax
,
2695 &out_charpos
, &out_bytepos
, &state
.incomment
);
2696 from
= out_charpos
; from_byte
= out_bytepos
;
2697 /* Beware! prev_from and friends are invalid now.
2698 Luckily, the `done' doesn't use them and the INC_FROM
2699 sets them to a sane value without looking at them. */
2700 if (!found
) goto done
;
2702 state
.incomment
= 0;
2703 state
.comstyle
= 0; /* reset the comment style */
2704 if (boundary_stop
) goto done
;
2708 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2710 /* curlevel++->last ran into compiler bug on Apollo */
2711 curlevel
->last
= prev_from
;
2712 if (++curlevel
== endlevel
)
2713 curlevel
--; /* error ("Nesting too deep for parser"); */
2714 curlevel
->prev
= -1;
2715 curlevel
->last
= -1;
2716 if (targetdepth
== depth
) goto done
;
2721 if (depth
< mindepth
)
2723 if (curlevel
!= levelstart
)
2725 curlevel
->prev
= curlevel
->last
;
2726 if (targetdepth
== depth
) goto done
;
2731 state
.comstr_start
= from
- 1;
2732 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2733 curlevel
->last
= prev_from
;
2734 state
.instring
= (code
== Sstring
2735 ? (FETCH_CHAR (prev_from_byte
))
2737 if (boundary_stop
) goto done
;
2740 nofence
= state
.instring
!= ST_STRING_STYLE
;
2746 if (from
>= end
) goto done
;
2747 c
= FETCH_CHAR (from_byte
);
2748 /* Some compilers can't handle this inside the switch. */
2751 /* Check TEMP here so that if the char has
2752 a syntax-table property which says it is NOT
2753 a string character, it does not end the string. */
2754 if (nofence
&& c
== state
.instring
&& temp
== Sstring
)
2760 if (!nofence
) goto string_end
;
2765 startquotedinstring
:
2766 if (from
>= end
) goto endquoted
;
2772 state
.instring
= -1;
2773 curlevel
->prev
= curlevel
->last
;
2775 if (boundary_stop
) goto done
;
2784 stop
: /* Here if stopping before start of sexp. */
2785 from
= prev_from
; /* We have just fetched the char that starts it; */
2786 goto done
; /* but return the position before it. */
2791 state
.depth
= depth
;
2792 state
.mindepth
= mindepth
;
2793 state
.thislevelstart
= curlevel
->prev
;
2794 state
.prevlevelstart
2795 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
2796 state
.location
= from
;
2797 state
.levelstarts
= Qnil
;
2798 while (--curlevel
>= levelstart
)
2799 state
.levelstarts
= Fcons (make_number (curlevel
->last
),
2806 /* This comment supplies the doc string for parse-partial-sexp,
2807 for make-docfile to see. We cannot put this in the real DEFUN
2808 due to limits in the Unix cpp.
2810 DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 6, 0,
2811 "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
2812 Parsing stops at TO or when certain criteria are met;\n\
2813 point is set to where parsing stops.\n\
2814 If fifth arg STATE is omitted or nil,\n\
2815 parsing assumes that FROM is the beginning of a function.\n\
2816 Value is a list of ten elements describing final state of parsing:\n\
2817 0. depth in parens.\n\
2818 1. character address of start of innermost containing list; nil if none.\n\
2819 2. character address of start of last complete sexp terminated.\n\
2820 3. non-nil if inside a string.\n\
2821 (it is the character that will terminate the string,\n\
2822 or t if the string should be terminated by a generic string delimiter.)\n\
2823 4. nil if outside a comment, t if inside a non-nestable comment, \n\
2824 else an integer (the current comment nesting).\n\
2825 5. t if following a quote character.\n\
2826 6. the minimum paren-depth encountered during this scan.\n\
2827 7. t if in a comment of style b; symbol `syntax-table' if the comment\n\
2828 should be terminated by a generic comment delimiter.\n\
2829 8. character address of start of comment or string; nil if not in one.\n\
2830 9. Intermediate data for continuation of parsing (subject to change).\n\
2831 If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
2832 in parentheses becomes equal to TARGETDEPTH.\n\
2833 Fourth arg STOPBEFORE non-nil means stop when come to\n\
2834 any character that starts a sexp.\n\
2835 Fifth arg STATE is a nine-element list like what this function returns.\n\
2836 It is used to initialize the state of the parse. Elements number 1, 2, 6\n\
2837 and 8 are ignored; you can leave off element 8 (the last) entirely.\n\
2838 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.\n\
2839 If it is symbol `syntax-table', stop after the start of a comment or a\n\
2840 string, or after end of a comment or a string.")
2841 (from, to, targetdepth, stopbefore, state, commentstop)
2844 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
2845 0 /* See immediately above */)
2846 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
2847 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
2849 struct lisp_parse_state state
;
2852 if (!NILP (targetdepth
))
2854 CHECK_NUMBER (targetdepth
, 3);
2855 target
= XINT (targetdepth
);
2858 target
= -100000; /* We won't reach this depth */
2860 validate_region (&from
, &to
);
2861 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
2863 target
, !NILP (stopbefore
), oldstate
,
2865 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
2867 SET_PT (state
.location
);
2869 return Fcons (make_number (state
.depth
),
2870 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
2871 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
2872 Fcons (state
.instring
>= 0
2873 ? (state
.instring
== ST_STRING_STYLE
2874 ? Qt
: make_number (state
.instring
)) : Qnil
,
2875 Fcons (state
.incomment
< 0 ? Qt
:
2876 (state
.incomment
== 0 ? Qnil
:
2877 make_number (state
.incomment
)),
2878 Fcons (state
.quoted
? Qt
: Qnil
,
2879 Fcons (make_number (state
.mindepth
),
2880 Fcons ((state
.comstyle
2881 ? (state
.comstyle
== ST_COMMENT_STYLE
2882 ? Qsyntax_table
: Qt
) :
2884 Fcons (((state
.incomment
2885 || (state
.instring
>= 0))
2886 ? make_number (state
.comstr_start
)
2888 Fcons (state
.levelstarts
, Qnil
))))))))));
2897 /* This has to be done here, before we call Fmake_char_table. */
2898 Qsyntax_table
= intern ("syntax-table");
2899 staticpro (&Qsyntax_table
);
2901 /* Intern this now in case it isn't already done.
2902 Setting this variable twice is harmless.
2903 But don't staticpro it here--that is done in alloc.c. */
2904 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
2906 /* Create objects which can be shared among syntax tables. */
2907 Vsyntax_code_object
= Fmake_vector (make_number (13), Qnil
);
2908 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
2909 XVECTOR (Vsyntax_code_object
)->contents
[i
]
2910 = Fcons (make_number (i
), Qnil
);
2912 /* Now we are ready to set up this property, so we can
2913 create syntax tables. */
2914 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
2916 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
2918 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
2920 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
2921 for (i
= 'a'; i
<= 'z'; i
++)
2922 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2923 for (i
= 'A'; i
<= 'Z'; i
++)
2924 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2925 for (i
= '0'; i
<= '9'; i
++)
2926 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2928 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
2929 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
2931 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
2932 Fcons (make_number (Sopen
), make_number (')')));
2933 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
2934 Fcons (make_number (Sclose
), make_number ('(')));
2935 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
2936 Fcons (make_number (Sopen
), make_number (']')));
2937 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
2938 Fcons (make_number (Sclose
), make_number ('[')));
2939 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
2940 Fcons (make_number (Sopen
), make_number ('}')));
2941 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
2942 Fcons (make_number (Sclose
), make_number ('{')));
2943 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
2944 Fcons (make_number ((int) Sstring
), Qnil
));
2945 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
2946 Fcons (make_number ((int) Sescape
), Qnil
));
2948 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
2949 for (i
= 0; i
< 10; i
++)
2951 c
= "_-+*/&|<>="[i
];
2952 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2955 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
2956 for (i
= 0; i
< 12; i
++)
2958 c
= ".,;:?!#@~^'`"[i
];
2959 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2962 /* All multibyte characters have syntax `word' by default. */
2963 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
2964 for (i
= CHAR_TABLE_SINGLE_BYTE_SLOTS
; i
< CHAR_TABLE_ORDINARY_SLOTS
; i
++)
2965 XCHAR_TABLE (Vstandard_syntax_table
)->contents
[i
] = temp
;
2971 Qsyntax_table_p
= intern ("syntax-table-p");
2972 staticpro (&Qsyntax_table_p
);
2974 staticpro (&Vsyntax_code_object
);
2976 Qscan_error
= intern ("scan-error");
2977 staticpro (&Qscan_error
);
2978 Fput (Qscan_error
, Qerror_conditions
,
2979 Fcons (Qscan_error
, Fcons (Qerror
, Qnil
)));
2980 Fput (Qscan_error
, Qerror_message
,
2981 build_string ("Scan error"));
2983 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
2984 "Non-nil means `forward-sexp', etc., should treat comments as whitespace.");
2986 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
2987 "Non-nil means `forward-sexp', etc., grant `syntax-table' property.\n\
2988 The value of this property should be either a syntax table, or a cons\n\
2989 of the form (SYNTAXCODE . MATCHCHAR), SYNTAXCODE being the numeric\n\
2990 syntax code, MATCHCHAR being nil or the character to match (which is\n\
2991 relevant only for open/close type.");
2993 words_include_escapes
= 0;
2994 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
2995 "Non-nil means `forward-word', etc., should treat escape chars part of words.");
2997 DEFVAR_BOOL ("multibyte-syntax-as-symbol", &multibyte_syntax_as_symbol
,
2998 "Non-nil means `scan-sexps' treats all multibyte characters as symbol.");
2999 multibyte_syntax_as_symbol
= 0;
3001 DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
3002 &open_paren_in_column_0_is_defun_start
,
3003 "Non-nil means an open paren in column 0 denotes the start of a defun.");
3004 open_paren_in_column_0_is_defun_start
= 1;
3006 defsubr (&Ssyntax_table_p
);
3007 defsubr (&Ssyntax_table
);
3008 defsubr (&Sstandard_syntax_table
);
3009 defsubr (&Scopy_syntax_table
);
3010 defsubr (&Sset_syntax_table
);
3011 defsubr (&Schar_syntax
);
3012 defsubr (&Smatching_paren
);
3013 defsubr (&Smodify_syntax_entry
);
3014 defsubr (&Sdescribe_syntax
);
3016 defsubr (&Sforward_word
);
3018 defsubr (&Sskip_chars_forward
);
3019 defsubr (&Sskip_chars_backward
);
3020 defsubr (&Sskip_syntax_forward
);
3021 defsubr (&Sskip_syntax_backward
);
3023 defsubr (&Sforward_comment
);
3024 defsubr (&Sscan_lists
);
3025 defsubr (&Sscan_sexps
);
3026 defsubr (&Sbackward_prefix_chars
);
3027 defsubr (&Sparse_partial_sexp
);