1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 1987, 1993, 1994, 1995, 1997, 1998, 1999, 2002,
3 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
32 /* Make syntax table lookup grant data in gl_state. */
33 #define SYNTAX_ENTRY_VIA_PROPERTY
36 #include "intervals.h"
38 /* We use these constants in place for comment-style and
39 string-ender-char to distinguish comments/strings started by
40 comment_fence and string_fence codes. */
42 #define ST_COMMENT_STYLE (256 + 1)
43 #define ST_STRING_STYLE (256 + 2)
46 Lisp_Object Qsyntax_table_p
, Qsyntax_table
, Qscan_error
;
48 int words_include_escapes
;
49 int parse_sexp_lookup_properties
;
51 /* Nonzero means `scan-sexps' treat all multibyte characters as symbol. */
52 int multibyte_syntax_as_symbol
;
54 /* Used as a temporary in SYNTAX_ENTRY and other macros in syntax.h,
55 if not compiled with GCC. No need to mark it, since it is used
56 only very temporarily. */
57 Lisp_Object syntax_temp
;
59 /* Non-zero means an open parenthesis in column 0 is always considered
60 to be the start of a defun. Zero means an open parenthesis in
61 column 0 has no special meaning. */
63 int open_paren_in_column_0_is_defun_start
;
65 /* This is the internal form of the parse state used in parse-partial-sexp. */
67 struct lisp_parse_state
69 int depth
; /* Depth at end of parsing. */
70 int instring
; /* -1 if not within string, else desired terminator. */
71 int incomment
; /* -1 if in unnestable comment else comment nesting */
72 int comstyle
; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
73 int quoted
; /* Nonzero if just after an escape char at end of parsing */
74 int thislevelstart
; /* Char number of most recent start-of-expression at current level */
75 int prevlevelstart
; /* Char number of start of containing expression */
76 int location
; /* Char number at which parsing stopped. */
77 int mindepth
; /* Minimum depth seen while scanning. */
78 int comstr_start
; /* Position just after last comment/string starter. */
79 Lisp_Object levelstarts
; /* Char numbers of starts-of-expression
80 of levels (starting from outermost). */
83 /* These variables are a cache for finding the start of a defun.
84 find_start_pos is the place for which the defun start was found.
85 find_start_value is the defun start position found for it.
86 find_start_value_byte is the corresponding byte position.
87 find_start_buffer is the buffer it was found in.
88 find_start_begv is the BEGV value when it was found.
89 find_start_modiff is the value of MODIFF when it was found. */
91 static int find_start_pos
;
92 static int find_start_value
;
93 static int find_start_value_byte
;
94 static struct buffer
*find_start_buffer
;
95 static int find_start_begv
;
96 static int find_start_modiff
;
99 static int find_defun_start
P_ ((int, int));
100 static int back_comment
P_ ((int, int, int, int, int, int *, int *));
101 static int char_quoted
P_ ((int, int));
102 static Lisp_Object skip_chars
P_ ((int, int, Lisp_Object
, Lisp_Object
, int));
103 static Lisp_Object scan_lists
P_ ((int, int, int, int));
104 static void scan_sexps_forward
P_ ((struct lisp_parse_state
*,
106 int, Lisp_Object
, int));
107 static int in_classes
P_ ((int, Lisp_Object
));
110 struct gl_state_s gl_state
; /* Global state of syntax parser. */
112 INTERVAL
interval_of ();
113 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
114 to scan to property-change. */
116 /* Update gl_state to an appropriate interval which contains CHARPOS. The
117 sign of COUNT give the relative position of CHARPOS wrt the previously
118 valid interval. If INIT, only [be]_property fields of gl_state are
119 valid at start, the rest is filled basing on OBJECT.
121 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
122 direction than the intervals - or in an interval. We update the
123 current syntax-table basing on the property of this interval, and
124 update the interval to start further than CHARPOS - or be
125 NULL_INTERVAL. We also update lim_property to be the next value of
126 charpos to call this subroutine again - or be before/after the
127 start/end of OBJECT. */
130 update_syntax_table (charpos
, count
, init
, object
)
131 int charpos
, count
, init
;
134 Lisp_Object tmp_table
;
135 int cnt
= 0, invalidate
= 1;
140 gl_state
.old_prop
= Qnil
;
141 gl_state
.start
= gl_state
.b_property
;
142 gl_state
.stop
= gl_state
.e_property
;
143 i
= interval_of (charpos
, object
);
144 gl_state
.backward_i
= gl_state
.forward_i
= i
;
146 if (NULL_INTERVAL_P (i
))
148 /* interval_of updates only ->position of the return value, so
149 update the parents manually to speed up update_interval. */
150 while (!NULL_PARENT (i
))
152 if (AM_RIGHT_CHILD (i
))
153 INTERVAL_PARENT (i
)->position
= i
->position
154 - LEFT_TOTAL_LENGTH (i
) + TOTAL_LENGTH (i
) /* right end */
155 - TOTAL_LENGTH (INTERVAL_PARENT (i
))
156 + LEFT_TOTAL_LENGTH (INTERVAL_PARENT (i
));
158 INTERVAL_PARENT (i
)->position
= i
->position
- LEFT_TOTAL_LENGTH (i
)
160 i
= INTERVAL_PARENT (i
);
162 i
= gl_state
.forward_i
;
163 gl_state
.b_property
= i
->position
- gl_state
.offset
;
164 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
167 oldi
= i
= count
> 0 ? gl_state
.forward_i
: gl_state
.backward_i
;
169 /* We are guaranteed to be called with CHARPOS either in i,
171 if (NULL_INTERVAL_P (i
))
172 error ("Error in syntax_table logic for to-the-end intervals");
173 else if (charpos
< i
->position
) /* Move left. */
176 error ("Error in syntax_table logic for intervals <-");
177 /* Update the interval. */
178 i
= update_interval (i
, charpos
);
179 if (INTERVAL_LAST_POS (i
) != gl_state
.b_property
)
182 gl_state
.forward_i
= i
;
183 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
186 else if (charpos
>= INTERVAL_LAST_POS (i
)) /* Move right. */
189 error ("Error in syntax_table logic for intervals ->");
190 /* Update the interval. */
191 i
= update_interval (i
, charpos
);
192 if (i
->position
!= gl_state
.e_property
)
195 gl_state
.backward_i
= i
;
196 gl_state
.b_property
= i
->position
- gl_state
.offset
;
201 tmp_table
= textget (i
->plist
, Qsyntax_table
);
204 invalidate
= !EQ (tmp_table
, gl_state
.old_prop
); /* Need to invalidate? */
206 if (invalidate
) /* Did not get to adjacent interval. */
207 { /* with the same table => */
208 /* invalidate the old range. */
211 gl_state
.backward_i
= i
;
212 gl_state
.b_property
= i
->position
- gl_state
.offset
;
216 gl_state
.forward_i
= i
;
217 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
221 if (!EQ (tmp_table
, gl_state
.old_prop
))
223 gl_state
.current_syntax_table
= tmp_table
;
224 gl_state
.old_prop
= tmp_table
;
225 if (EQ (Fsyntax_table_p (tmp_table
), Qt
))
227 gl_state
.use_global
= 0;
229 else if (CONSP (tmp_table
))
231 gl_state
.use_global
= 1;
232 gl_state
.global_code
= tmp_table
;
236 gl_state
.use_global
= 0;
237 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
241 while (!NULL_INTERVAL_P (i
))
243 if (cnt
&& !EQ (tmp_table
, textget (i
->plist
, Qsyntax_table
)))
247 gl_state
.e_property
= i
->position
- gl_state
.offset
;
248 gl_state
.forward_i
= i
;
252 gl_state
.b_property
= i
->position
+ LENGTH (i
) - gl_state
.offset
;
253 gl_state
.backward_i
= i
;
257 else if (cnt
== INTERVALS_AT_ONCE
)
261 gl_state
.e_property
= i
->position
+ LENGTH (i
) - gl_state
.offset
;
262 gl_state
.forward_i
= i
;
266 gl_state
.b_property
= i
->position
- gl_state
.offset
;
267 gl_state
.backward_i
= i
;
272 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
274 eassert (NULL_INTERVAL_P (i
)); /* This property goes to the end. */
276 gl_state
.e_property
= gl_state
.stop
;
278 gl_state
.b_property
= gl_state
.start
;
281 /* Returns TRUE if char at CHARPOS is quoted.
282 Global syntax-table data should be set up already to be good at CHARPOS
283 or after. On return global syntax data is good for lookup at CHARPOS. */
286 char_quoted (charpos
, bytepos
)
287 register int charpos
, bytepos
;
289 register enum syntaxcode code
;
290 register int beg
= BEGV
;
291 register int quoted
= 0;
294 DEC_BOTH (charpos
, bytepos
);
296 while (charpos
>= beg
)
300 UPDATE_SYNTAX_TABLE_BACKWARD (charpos
);
301 c
= FETCH_CHAR (bytepos
);
303 if (! (code
== Scharquote
|| code
== Sescape
))
306 DEC_BOTH (charpos
, bytepos
);
310 UPDATE_SYNTAX_TABLE (orig
);
314 /* Return the bytepos one character after BYTEPOS.
315 We assume that BYTEPOS is not at the end of the buffer. */
318 inc_bytepos (bytepos
)
321 if (NILP (current_buffer
->enable_multibyte_characters
))
328 /* Return the bytepos one character before BYTEPOS.
329 We assume that BYTEPOS is not at the start of the buffer. */
332 dec_bytepos (bytepos
)
335 if (NILP (current_buffer
->enable_multibyte_characters
))
342 /* Return a defun-start position before before POS and not too far before.
343 It should be the last one before POS, or nearly the last.
345 When open_paren_in_column_0_is_defun_start is nonzero,
346 only the beginning of the buffer is treated as a defun-start.
348 We record the information about where the scan started
349 and what its result was, so that another call in the same area
350 can return the same value very quickly.
352 There is no promise at which position the global syntax data is
353 valid on return from the subroutine, so the caller should explicitly
354 update the global data. */
357 find_defun_start (pos
, pos_byte
)
360 int opoint
= PT
, opoint_byte
= PT_BYTE
;
362 if (!open_paren_in_column_0_is_defun_start
)
364 find_start_value_byte
= BEGV_BYTE
;
368 /* Use previous finding, if it's valid and applies to this inquiry. */
369 if (current_buffer
== find_start_buffer
370 /* Reuse the defun-start even if POS is a little farther on.
371 POS might be in the next defun, but that's ok.
372 Our value may not be the best possible, but will still be usable. */
373 && pos
<= find_start_pos
+ 1000
374 && pos
>= find_start_value
375 && BEGV
== find_start_begv
376 && MODIFF
== find_start_modiff
)
377 return find_start_value
;
379 /* Back up to start of line. */
380 scan_newline (pos
, pos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
382 /* We optimize syntax-table lookup for rare updates. Thus we accept
383 only those `^\s(' which are good in global _and_ text-property
385 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
386 gl_state
.use_global
= 0;
391 /* Open-paren at start of line means we may have found our
393 c
= FETCH_CHAR (PT_BYTE
);
394 if (SYNTAX (c
) == Sopen
)
396 SETUP_SYNTAX_TABLE (PT
+ 1, -1); /* Try again... */
397 c
= FETCH_CHAR (PT_BYTE
);
398 if (SYNTAX (c
) == Sopen
)
400 /* Now fallback to the default value. */
401 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
402 gl_state
.use_global
= 0;
404 /* Move to beg of previous line. */
405 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -2, 1);
408 /* Record what we found, for the next try. */
409 find_start_value
= PT
;
410 find_start_value_byte
= PT_BYTE
;
411 find_start_buffer
= current_buffer
;
412 find_start_modiff
= MODIFF
;
413 find_start_begv
= BEGV
;
414 find_start_pos
= pos
;
416 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
418 return find_start_value
;
421 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
424 prev_char_comend_first (pos
, pos_byte
)
429 DEC_BOTH (pos
, pos_byte
);
430 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
431 c
= FETCH_CHAR (pos_byte
);
432 val
= SYNTAX_COMEND_FIRST (c
);
433 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
437 /* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
440 * prev_char_comstart_first (pos, pos_byte)
445 * DEC_BOTH (pos, pos_byte);
446 * UPDATE_SYNTAX_TABLE_BACKWARD (pos);
447 * c = FETCH_CHAR (pos_byte);
448 * val = SYNTAX_COMSTART_FIRST (c);
449 * UPDATE_SYNTAX_TABLE_FORWARD (pos + 1);
453 /* Checks whether charpos FROM is at the end of a comment.
454 FROM_BYTE is the bytepos corresponding to FROM.
455 Do not move back before STOP.
457 Return a positive value if we find a comment ending at FROM/FROM_BYTE;
460 If successful, store the charpos of the comment's beginning
461 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
463 Global syntax data remains valid for backward search starting at
464 the returned value (or at FROM, if the search was not successful). */
467 back_comment (from
, from_byte
, stop
, comnested
, comstyle
, charpos_ptr
, bytepos_ptr
)
468 int from
, from_byte
, stop
;
469 int comnested
, comstyle
;
470 int *charpos_ptr
, *bytepos_ptr
;
472 /* Look back, counting the parity of string-quotes,
473 and recording the comment-starters seen.
474 When we reach a safe place, assume that's not in a string;
475 then step the main scan to the earliest comment-starter seen
476 an even number of string quotes away from the safe place.
478 OFROM[I] is position of the earliest comment-starter seen
479 which is I+2X quotes from the comment-end.
480 PARITY is current parity of quotes from the comment end. */
481 int string_style
= -1; /* Presumed outside of any string. */
482 int string_lossage
= 0;
483 /* Not a real lossage: indicates that we have passed a matching comment
484 starter plus a non-matching comment-ender, meaning that any matching
485 comment-starter we might see later could be a false positive (hidden
486 inside another comment).
487 Test case: { a (* b } c (* d *) */
488 int comment_lossage
= 0;
489 int comment_end
= from
;
490 int comment_end_byte
= from_byte
;
491 int comstart_pos
= 0;
493 /* Place where the containing defun starts,
494 or 0 if we didn't come across it yet. */
496 int defun_start_byte
= 0;
497 register enum syntaxcode code
;
498 int nesting
= 1; /* current comment nesting */
502 /* FIXME: A }} comment-ender style leads to incorrect behavior
503 in the case of {{ c }}} because we ignore the last two chars which are
504 assumed to be comment-enders although they aren't. */
506 /* At beginning of range to scan, we're outside of strings;
507 that determines quote parity to the comment-end. */
510 int temp_byte
, prev_syntax
;
511 int com2start
, com2end
;
513 /* Move back and examine a character. */
514 DEC_BOTH (from
, from_byte
);
515 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
517 prev_syntax
= syntax
;
518 c
= FETCH_CHAR (from_byte
);
519 syntax
= SYNTAX_WITH_FLAGS (c
);
522 /* Check for 2-char comment markers. */
523 com2start
= (SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
524 && SYNTAX_FLAGS_COMSTART_SECOND (prev_syntax
)
525 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax
)
526 && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
)
527 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
);
528 com2end
= (SYNTAX_FLAGS_COMEND_FIRST (syntax
)
529 && SYNTAX_FLAGS_COMEND_SECOND (prev_syntax
));
531 /* Nasty cases with overlapping 2-char comment markers:
532 - snmp-mode: -- c -- foo -- c --
540 /* If a 2-char comment sequence partly overlaps with another,
541 we don't try to be clever. */
542 if (from
> stop
&& (com2end
|| com2start
))
544 int next
= from
, next_byte
= from_byte
, next_c
, next_syntax
;
545 DEC_BOTH (next
, next_byte
);
546 UPDATE_SYNTAX_TABLE_BACKWARD (next
);
547 next_c
= FETCH_CHAR (next_byte
);
548 next_syntax
= SYNTAX_WITH_FLAGS (next_c
);
549 if (((com2start
|| comnested
)
550 && SYNTAX_FLAGS_COMEND_SECOND (syntax
)
551 && SYNTAX_FLAGS_COMEND_FIRST (next_syntax
))
552 || ((com2end
|| comnested
)
553 && SYNTAX_FLAGS_COMSTART_SECOND (syntax
)
554 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
555 && SYNTAX_FLAGS_COMSTART_FIRST (next_syntax
)))
557 /* UPDATE_SYNTAX_TABLE_FORWARD (next + 1); */
560 if (com2start
&& comstart_pos
== 0)
561 /* We're looking at a comment starter. But it might be a comment
562 ender as well (see snmp-mode). The first time we see one, we
563 need to consider it as a comment starter,
564 and the subsequent times as a comment ender. */
567 /* Turn a 2-char comment sequences into the appropriate syntax. */
572 /* Ignore comment starters of a different style. */
573 else if (code
== Scomment
574 && (comstyle
!= SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
575 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
) != comnested
))
578 /* Ignore escaped characters, except comment-enders. */
579 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
586 c
= (code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
);
588 /* Track parity of quotes. */
589 if (string_style
== -1)
590 /* Entering a string. */
592 else if (string_style
== c
)
593 /* Leaving the string. */
596 /* If we have two kinds of string delimiters.
597 There's no way to grok this scanning backwards. */
602 /* We've already checked that it is the relevant comstyle. */
603 if (string_style
!= -1 || comment_lossage
|| string_lossage
)
604 /* There are odd string quotes involved, so let's be careful.
605 Test case in Pascal: " { " a { " } */
610 /* Record best comment-starter so far. */
612 comstart_byte
= from_byte
;
614 else if (--nesting
<= 0)
615 /* nested comments have to be balanced, so we don't need to
616 keep looking for earlier ones. We use here the same (slightly
617 incorrect) reasoning as below: since it is followed by uniform
618 paired string quotes, this comment-start has to be outside of
619 strings, else the comment-end itself would be inside a string. */
624 if (SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == comstyle
625 && ((com2end
&& SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
))
626 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
)
627 /* This is the same style of comment ender as ours. */
632 /* Anything before that can't count because it would match
633 this comment-ender rather than ours. */
634 from
= stop
; /* Break out of the loop. */
636 else if (comstart_pos
!= 0 || c
!= '\n')
637 /* We're mixing comment styles here, so we'd better be careful.
638 The (comstart_pos != 0 || c != '\n') check is not quite correct
639 (we should just always set comment_lossage), but removing it
640 would imply that any multiline comment in C would go through
641 lossage, which seems overkill.
642 The failure should only happen in the rare cases such as
648 /* Assume a defun-start point is outside of strings. */
649 if (open_paren_in_column_0_is_defun_start
651 || (temp_byte
= dec_bytepos (from_byte
),
652 FETCH_CHAR (temp_byte
) == '\n')))
655 defun_start_byte
= from_byte
;
656 from
= stop
; /* Break out of the loop. */
665 if (comstart_pos
== 0)
668 from_byte
= comment_end_byte
;
669 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
671 /* If comstart_pos is set and we get here (ie. didn't jump to `lossage'
672 or `done'), then we've found the beginning of the non-nested comment. */
673 else if (1) /* !comnested */
676 from_byte
= comstart_byte
;
677 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
681 struct lisp_parse_state state
;
683 /* We had two kinds of string delimiters mixed up
684 together. Decode this going forwards.
685 Scan fwd from a known safe place (beginning-of-defun)
686 to the one in question; this records where we
687 last passed a comment starter. */
688 /* If we did not already find the defun start, find it now. */
689 if (defun_start
== 0)
691 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
692 defun_start_byte
= find_start_value_byte
;
696 scan_sexps_forward (&state
,
697 defun_start
, defun_start_byte
,
698 comment_end
, -10000, 0, Qnil
, 0);
699 defun_start
= comment_end
;
700 if (state
.incomment
== (comnested
? 1 : -1)
701 && state
.comstyle
== comstyle
)
702 from
= state
.comstr_start
;
707 /* If comment_end is inside some other comment, maybe ours
708 is nested, so we need to try again from within the
709 surrounding comment. Example: { a (* " *) */
711 /* FIXME: We should advance by one or two chars. */
712 defun_start
= state
.comstr_start
+ 2;
713 defun_start_byte
= CHAR_TO_BYTE (defun_start
);
716 } while (defun_start
< comment_end
);
718 from_byte
= CHAR_TO_BYTE (from
);
719 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
724 *bytepos_ptr
= from_byte
;
726 return (from
== comment_end
) ? -1 : from
;
729 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
730 doc
: /* Return t if OBJECT is a syntax table.
731 Currently, any char-table counts as a syntax table. */)
735 if (CHAR_TABLE_P (object
)
736 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
742 check_syntax_table (obj
)
745 if (!(CHAR_TABLE_P (obj
)
746 && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
)))
747 wrong_type_argument (Qsyntax_table_p
, obj
);
750 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
751 doc
: /* Return the current syntax table.
752 This is the one specified by the current buffer. */)
755 return current_buffer
->syntax_table
;
758 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
759 Sstandard_syntax_table
, 0, 0, 0,
760 doc
: /* Return the standard syntax table.
761 This is the one used for new buffers. */)
764 return Vstandard_syntax_table
;
767 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
768 doc
: /* Construct a new syntax table and return it.
769 It is a copy of the TABLE, which defaults to the standard syntax table. */)
776 check_syntax_table (table
);
778 table
= Vstandard_syntax_table
;
780 copy
= Fcopy_sequence (table
);
782 /* Only the standard syntax table should have a default element.
783 Other syntax tables should inherit from parents instead. */
784 XCHAR_TABLE (copy
)->defalt
= Qnil
;
786 /* Copied syntax tables should all have parents.
787 If we copied one with no parent, such as the standard syntax table,
788 use the standard syntax table as the copy's parent. */
789 if (NILP (XCHAR_TABLE (copy
)->parent
))
790 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
794 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
795 doc
: /* Select a new syntax table for the current buffer.
796 One argument, a syntax table. */)
801 check_syntax_table (table
);
802 current_buffer
->syntax_table
= table
;
803 /* Indicate that this buffer now has a specified syntax table. */
804 idx
= PER_BUFFER_VAR_IDX (syntax_table
);
805 SET_PER_BUFFER_VALUE_P (current_buffer
, idx
, 1);
809 /* Convert a letter which signifies a syntax code
810 into the code it signifies.
811 This is used by modify-syntax-entry, and other things. */
813 unsigned char syntax_spec_code
[0400] =
814 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
815 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
816 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
817 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
818 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
819 (char) Smath
, 0377, 0377, (char) Squote
,
820 (char) Sopen
, (char) Sclose
, 0377, 0377,
821 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
822 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
823 0377, 0377, 0377, 0377,
824 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
825 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
826 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
827 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
828 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
829 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
830 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
831 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
832 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
835 /* Indexed by syntax code, give the letter that describes it. */
837 char syntax_code_spec
[16] =
839 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
843 /* Indexed by syntax code, give the object (cons of syntax code and
844 nil) to be stored in syntax table. Since these objects can be
845 shared among syntax tables, we generate them in advance. By
846 sharing objects, the function `describe-syntax' can give a more
848 static Lisp_Object Vsyntax_code_object
;
851 /* Look up the value for CHARACTER in syntax table TABLE's parent
852 and its parents. SYNTAX_ENTRY calls this, when TABLE itself has nil
853 for CHARACTER. It's actually used only when not compiled with GCC. */
856 syntax_parent_lookup (table
, character
)
864 table
= XCHAR_TABLE (table
)->parent
;
868 value
= XCHAR_TABLE (table
)->contents
[character
];
874 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
875 doc
: /* Return the syntax code of CHARACTER, described by a character.
876 For example, if CHARACTER is a word constituent,
877 the character `w' is returned.
878 The characters that correspond to various syntax codes
879 are listed in the documentation of `modify-syntax-entry'. */)
881 Lisp_Object character
;
884 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
886 gl_state
.use_global
= 0;
887 CHECK_NUMBER (character
);
888 char_int
= XINT (character
);
889 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
892 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
893 doc
: /* Return the matching parenthesis of CHARACTER, or nil if none. */)
895 Lisp_Object character
;
898 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
899 gl_state
.use_global
= 0;
900 CHECK_NUMBER (character
);
901 char_int
= XINT (character
);
902 code
= SYNTAX (char_int
);
903 if (code
== Sopen
|| code
== Sclose
)
904 return SYNTAX_MATCH (char_int
);
908 DEFUN ("string-to-syntax", Fstring_to_syntax
, Sstring_to_syntax
, 1, 1, 0,
909 doc
: /* Convert a syntax specification STRING into syntax cell form.
910 STRING should be a string as it is allowed as argument of
911 `modify-syntax-entry'. Value is the equivalent cons cell
912 (CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'
917 register const unsigned char *p
;
918 register enum syntaxcode code
;
922 CHECK_STRING (string
);
925 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
926 if (((int) code
& 0377) == 0377)
927 error ("Invalid syntax description letter: %c", p
[-1]);
929 if (code
== Sinherit
)
935 int character
= (STRING_CHAR_AND_LENGTH
936 (p
, SBYTES (string
) - 1, len
));
937 XSETINT (match
, character
);
938 if (XFASTINT (match
) == ' ')
978 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
979 return XVECTOR (Vsyntax_code_object
)->contents
[val
];
981 /* Since we can't use a shared object, let's make a new one. */
982 return Fcons (make_number (val
), match
);
985 /* I really don't know why this is interactive
986 help-form should at least be made useful whilst reading the second arg. */
987 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
988 "cSet syntax for character: \nsSet syntax for %s to: ",
989 doc
: /* Set syntax for character CHAR according to string NEWENTRY.
990 The syntax is changed only for table SYNTAX-TABLE, which defaults to
991 the current buffer's syntax table.
992 The first character of NEWENTRY should be one of the following:
993 Space or - whitespace syntax. w word constituent.
994 _ symbol constituent. . punctuation.
995 ( open-parenthesis. ) close-parenthesis.
996 " string quote. \\ escape.
997 $ paired delimiter. ' expression quote or prefix operator.
998 < comment starter. > comment ender.
999 / character-quote. @ inherit from `standard-syntax-table'.
1000 | generic string fence. ! generic comment fence.
1002 Only single-character comment start and end sequences are represented thus.
1003 Two-character sequences are represented as described below.
1004 The second character of NEWENTRY is the matching parenthesis,
1005 used only if the first character is `(' or `)'.
1006 Any additional characters are flags.
1007 Defined flags are the characters 1, 2, 3, 4, b, p, and n.
1008 1 means CHAR is the start of a two-char comment start sequence.
1009 2 means CHAR is the second character of such a sequence.
1010 3 means CHAR is the start of a two-char comment end sequence.
1011 4 means CHAR is the second character of such a sequence.
1013 There can be up to two orthogonal comment sequences. This is to support
1014 language modes such as C++. By default, all comment sequences are of style
1015 a, but you can set the comment sequence style to b (on the second character
1016 of a comment-start, or the first character of a comment-end sequence) using
1018 b means CHAR is part of comment sequence b.
1019 n means CHAR is part of a nestable comment sequence.
1021 p means CHAR is a prefix character for `backward-prefix-chars';
1022 such characters are treated as whitespace when they occur
1023 between expressions.
1024 usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE) */)
1025 (c
, newentry
, syntax_table
)
1026 Lisp_Object c
, newentry
, syntax_table
;
1030 if (NILP (syntax_table
))
1031 syntax_table
= current_buffer
->syntax_table
;
1033 check_syntax_table (syntax_table
);
1035 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), Fstring_to_syntax (newentry
));
1039 /* Dump syntax table to buffer in human-readable format */
1041 DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value
,
1042 Sinternal_describe_syntax_value
, 1, 1, 0,
1043 doc
: /* Insert a description of the internal syntax description SYNTAX at point. */)
1047 register enum syntaxcode code
;
1048 char desc
, start1
, start2
, end1
, end2
, prefix
, comstyle
, comnested
;
1050 Lisp_Object first
, match_lisp
, value
= syntax
;
1054 insert_string ("default");
1058 if (CHAR_TABLE_P (value
))
1060 insert_string ("deeper char-table ...");
1066 insert_string ("invalid");
1070 first
= XCAR (value
);
1071 match_lisp
= XCDR (value
);
1073 if (!INTEGERP (first
) || !(NILP (match_lisp
) || INTEGERP (match_lisp
)))
1075 insert_string ("invalid");
1079 code
= (enum syntaxcode
) (XINT (first
) & 0377);
1080 start1
= (XINT (first
) >> 16) & 1;
1081 start2
= (XINT (first
) >> 17) & 1;
1082 end1
= (XINT (first
) >> 18) & 1;
1083 end2
= (XINT (first
) >> 19) & 1;
1084 prefix
= (XINT (first
) >> 20) & 1;
1085 comstyle
= (XINT (first
) >> 21) & 1;
1086 comnested
= (XINT (first
) >> 22) & 1;
1088 if ((int) code
< 0 || (int) code
>= (int) Smax
)
1090 insert_string ("invalid");
1093 desc
= syntax_code_spec
[(int) code
];
1095 str
[0] = desc
, str
[1] = 0;
1098 if (NILP (match_lisp
))
1101 insert_char (XINT (match_lisp
));
1120 insert_string ("\twhich means: ");
1122 switch (SWITCH_ENUM_CAST (code
))
1125 insert_string ("whitespace"); break;
1127 insert_string ("punctuation"); break;
1129 insert_string ("word"); break;
1131 insert_string ("symbol"); break;
1133 insert_string ("open"); break;
1135 insert_string ("close"); break;
1137 insert_string ("prefix"); break;
1139 insert_string ("string"); break;
1141 insert_string ("math"); break;
1143 insert_string ("escape"); break;
1145 insert_string ("charquote"); break;
1147 insert_string ("comment"); break;
1149 insert_string ("endcomment"); break;
1151 insert_string ("inherit"); break;
1152 case Scomment_fence
:
1153 insert_string ("comment fence"); break;
1155 insert_string ("string fence"); break;
1157 insert_string ("invalid");
1161 if (!NILP (match_lisp
))
1163 insert_string (", matches ");
1164 insert_char (XINT (match_lisp
));
1168 insert_string (",\n\t is the first character of a comment-start sequence");
1170 insert_string (",\n\t is the second character of a comment-start sequence");
1173 insert_string (",\n\t is the first character of a comment-end sequence");
1175 insert_string (",\n\t is the second character of a comment-end sequence");
1177 insert_string (" (comment style b)");
1179 insert_string (" (nestable)");
1182 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
1187 int parse_sexp_ignore_comments
;
1189 /* Return the position across COUNT words from FROM.
1190 If that many words cannot be found before the end of the buffer, return 0.
1191 COUNT negative means scan backward and stop at word beginning. */
1194 scan_words (from
, count
)
1195 register int from
, count
;
1197 register int beg
= BEGV
;
1198 register int end
= ZV
;
1199 register int from_byte
= CHAR_TO_BYTE (from
);
1200 register enum syntaxcode code
;
1206 SETUP_SYNTAX_TABLE (from
, count
);
1217 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1218 ch0
= FETCH_CHAR (from_byte
);
1219 code
= SYNTAX (ch0
);
1220 INC_BOTH (from
, from_byte
);
1221 if (words_include_escapes
1222 && (code
== Sescape
|| code
== Scharquote
))
1227 /* Now CH0 is a character which begins a word and FROM is the
1228 position of the next character. */
1231 if (from
== end
) break;
1232 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1233 ch1
= FETCH_CHAR (from_byte
);
1234 code
= SYNTAX (ch1
);
1235 if (!(words_include_escapes
1236 && (code
== Sescape
|| code
== Scharquote
)))
1237 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1239 INC_BOTH (from
, from_byte
);
1253 DEC_BOTH (from
, from_byte
);
1254 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1255 ch1
= FETCH_CHAR (from_byte
);
1256 code
= SYNTAX (ch1
);
1257 if (words_include_escapes
1258 && (code
== Sescape
|| code
== Scharquote
))
1263 /* Now CH1 is a character which ends a word and FROM is the
1271 temp_byte
= dec_bytepos (from_byte
);
1272 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1273 ch0
= FETCH_CHAR (temp_byte
);
1274 code
= SYNTAX (ch0
);
1275 if (!(words_include_escapes
1276 && (code
== Sescape
|| code
== Scharquote
)))
1277 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1279 DEC_BOTH (from
, from_byte
);
1290 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 0, 1, "p",
1291 doc
: /* Move point forward ARG words (backward if ARG is negative).
1293 If an edge of the buffer or a field boundary is reached, point is left there
1294 and the function returns nil. Field boundaries are not noticed if
1295 `inhibit-field-text-motion' is non-nil. */)
1303 XSETFASTINT (arg
, 1);
1307 val
= orig_val
= scan_words (PT
, XINT (arg
));
1309 val
= XINT (arg
) > 0 ? ZV
: BEGV
;
1311 /* Avoid jumping out of an input field. */
1312 tmp
= Fconstrain_to_field (make_number (val
), make_number (PT
),
1314 val
= XFASTINT (tmp
);
1317 return val
== orig_val
? Qt
: Qnil
;
1320 Lisp_Object
skip_chars ();
1322 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1323 doc
: /* Move point forward, stopping before a char not in STRING, or at pos LIM.
1324 STRING is like the inside of a `[...]' in a regular expression
1325 except that `]' is never special and `\\' quotes `^', `-' or `\\'
1326 (but not as the end of a range; quoting is never needed there).
1327 Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
1328 With arg "^a-zA-Z", skips nonletters stopping before first letter.
1329 Char classes, e.g. `[:alpha:]', are supported.
1331 Returns the distance traveled, either zero or positive. */)
1333 Lisp_Object string
, lim
;
1335 return skip_chars (1, 0, string
, lim
, 1);
1338 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1339 doc
: /* Move point backward, stopping after a char not in STRING, or at pos LIM.
1340 See `skip-chars-forward' for details.
1341 Returns the distance traveled, either zero or negative. */)
1343 Lisp_Object string
, lim
;
1345 return skip_chars (0, 0, string
, lim
, 1);
1348 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1349 doc
: /* Move point forward across chars in specified syntax classes.
1350 SYNTAX is a string of syntax code characters.
1351 Stop before a char whose syntax is not in SYNTAX, or at position LIM.
1352 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1353 This function returns the distance traveled, either zero or positive. */)
1355 Lisp_Object syntax
, lim
;
1357 return skip_chars (1, 1, syntax
, lim
, 0);
1360 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1361 doc
: /* Move point backward across chars in specified syntax classes.
1362 SYNTAX is a string of syntax code characters.
1363 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
1364 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1365 This function returns the distance traveled, either zero or negative. */)
1367 Lisp_Object syntax
, lim
;
1369 return skip_chars (0, 1, syntax
, lim
, 0);
1373 skip_chars (forwardp
, syntaxp
, string
, lim
, handle_iso_classes
)
1374 int forwardp
, syntaxp
;
1375 Lisp_Object string
, lim
;
1376 int handle_iso_classes
;
1378 register unsigned int c
;
1379 unsigned char fastmap
[0400];
1380 /* If SYNTAXP is 0, STRING may contain multi-byte form of characters
1381 of which codes don't fit in FASTMAP. In that case, set the
1382 ranges of characters in CHAR_RANGES. */
1384 int n_char_ranges
= 0;
1386 register int i
, i_byte
;
1387 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1388 int string_multibyte
;
1390 const unsigned char *str
;
1392 Lisp_Object iso_classes
;
1394 CHECK_STRING (string
);
1395 char_ranges
= (int *) alloca (SCHARS (string
) * (sizeof (int)) * 2);
1396 string_multibyte
= STRING_MULTIBYTE (string
);
1397 str
= SDATA (string
);
1398 size_byte
= SBYTES (string
);
1401 /* Adjust the multibyteness of the string to that of the buffer. */
1402 if (multibyte
!= string_multibyte
)
1407 nbytes
= count_size_as_multibyte (SDATA (string
),
1410 nbytes
= SCHARS (string
);
1411 if (nbytes
!= size_byte
)
1413 unsigned char *tmp
= (unsigned char *) alloca (nbytes
);
1414 copy_text (SDATA (string
), tmp
, size_byte
,
1415 string_multibyte
, multibyte
);
1422 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1424 CHECK_NUMBER_COERCE_MARKER (lim
);
1426 /* In any case, don't allow scan outside bounds of buffer. */
1427 if (XINT (lim
) > ZV
)
1428 XSETFASTINT (lim
, ZV
);
1429 if (XINT (lim
) < BEGV
)
1430 XSETFASTINT (lim
, BEGV
);
1432 bzero (fastmap
, sizeof fastmap
);
1436 if (i_byte
< size_byte
1437 && SREF (string
, 0) == '^')
1439 negate
= 1; i_byte
++;
1442 /* Find the characters specified and set their elements of fastmap.
1443 If syntaxp, each character counts as itself.
1444 Otherwise, handle backslashes and ranges specially. */
1446 while (i_byte
< size_byte
)
1448 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, size_byte
- i_byte
, len
);
1452 fastmap
[syntax_spec_code
[c
& 0377]] = 1;
1455 if (handle_iso_classes
&& c
== '['
1456 && i_byte
< size_byte
1457 && STRING_CHAR (str
+ i_byte
, size_byte
- i_byte
) == ':')
1459 const unsigned char *class_beg
= str
+ i_byte
+ 1;
1460 const unsigned char *class_end
= class_beg
;
1461 const unsigned char *class_limit
= str
+ size_byte
- 2;
1462 /* Leave room for the null. */
1463 unsigned char class_name
[CHAR_CLASS_MAX_LENGTH
+ 1];
1466 if (class_limit
- class_beg
> CHAR_CLASS_MAX_LENGTH
)
1467 class_limit
= class_beg
+ CHAR_CLASS_MAX_LENGTH
;
1469 while (class_end
< class_limit
1470 && *class_end
>= 'a' && *class_end
<= 'z')
1473 if (class_end
== class_beg
1474 || *class_end
!= ':' || class_end
[1] != ']')
1475 goto not_a_class_name
;
1477 bcopy (class_beg
, class_name
, class_end
- class_beg
);
1478 class_name
[class_end
- class_beg
] = 0;
1480 cc
= re_wctype (class_name
);
1482 error ("Invalid ISO C character class");
1484 iso_classes
= Fcons (make_number (cc
), iso_classes
);
1486 i_byte
= class_end
+ 2 - str
;
1493 if (i_byte
== size_byte
)
1496 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
,
1497 size_byte
- i_byte
, len
);
1500 /* Treat `-' as range character only if another character
1502 if (i_byte
+ 1 < size_byte
1503 && str
[i_byte
] == '-')
1507 /* Skip over the dash. */
1510 /* Get the end of the range. */
1511 c2
= STRING_CHAR_AND_LENGTH (str
+ i_byte
,
1512 size_byte
- i_byte
, len
);
1515 if (SINGLE_BYTE_CHAR_P (c
))
1517 if (! SINGLE_BYTE_CHAR_P (c2
))
1519 /* Handle a range starting with a character of
1520 less than 256, and ending with a character of
1521 not less than 256. Split that into two
1522 ranges, the low one ending at 0377, and the
1523 high one starting at the smallest character
1524 in the charset of C2 and ending at C2. */
1525 int charset
= CHAR_CHARSET (c2
);
1526 int c1
= MAKE_CHAR (charset
, 0, 0);
1528 char_ranges
[n_char_ranges
++] = c1
;
1529 char_ranges
[n_char_ranges
++] = c2
;
1538 else if (c
<= c2
) /* Both C and C2 are multibyte char. */
1540 char_ranges
[n_char_ranges
++] = c
;
1541 char_ranges
[n_char_ranges
++] = c2
;
1546 if (SINGLE_BYTE_CHAR_P (c
))
1550 char_ranges
[n_char_ranges
++] = c
;
1551 char_ranges
[n_char_ranges
++] = c
;
1557 /* If ^ was the first character, complement the fastmap. */
1559 for (i
= 0; i
< sizeof fastmap
; i
++)
1563 int start_point
= PT
;
1565 int pos_byte
= PT_BYTE
;
1566 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
1570 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
1571 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
1575 endp
= CHAR_POS_ADDR (XINT (lim
));
1576 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
1582 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1597 c
= STRING_CHAR_AND_LENGTH (p
, MAX_MULTIBYTE_LENGTH
, nbytes
);
1598 if (! fastmap
[(int) SYNTAX (c
)])
1600 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
1601 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1613 if (! fastmap
[(int) SYNTAX (*p
)])
1616 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1624 unsigned char *prev_p
;
1635 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
1636 PARSE_MULTIBYTE_SEQ (p
, MAX_MULTIBYTE_LENGTH
, nbytes
);
1637 if (prev_p
- p
> nbytes
)
1638 p
= prev_p
- 1, c
= *p
, nbytes
= 1;
1640 c
= STRING_CHAR (p
, MAX_MULTIBYTE_LENGTH
);
1641 pos
--, pos_byte
-= nbytes
;
1642 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
1643 if (! fastmap
[(int) SYNTAX (c
)])
1660 if (! fastmap
[(int) SYNTAX (p
[-1])])
1663 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
1683 c
= STRING_CHAR_AND_LENGTH (p
, MAX_MULTIBYTE_LENGTH
, nbytes
);
1685 if (! NILP (iso_classes
) && in_classes (c
, iso_classes
))
1693 if (SINGLE_BYTE_CHAR_P (c
))
1700 /* If we are looking at a multibyte character,
1701 we must look up the character in the table
1702 CHAR_RANGES. If there's no data in the
1703 table, that character is not what we want to
1706 /* The following code do the right thing even if
1707 n_char_ranges is zero (i.e. no data in
1709 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1710 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1712 if (!(negate
^ (i
< n_char_ranges
)))
1716 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
1729 if (!NILP (iso_classes
) && in_classes (*p
, iso_classes
))
1734 goto fwd_unibyte_ok
;
1748 unsigned char *prev_p
;
1759 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
1760 PARSE_MULTIBYTE_SEQ (p
, MAX_MULTIBYTE_LENGTH
, nbytes
);
1761 if (prev_p
- p
> nbytes
)
1762 p
= prev_p
- 1, c
= *p
, nbytes
= 1;
1764 c
= STRING_CHAR (p
, MAX_MULTIBYTE_LENGTH
);
1766 if (! NILP (iso_classes
) && in_classes (c
, iso_classes
))
1774 if (SINGLE_BYTE_CHAR_P (c
))
1781 /* See the comment in the previous similar code. */
1782 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1783 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1785 if (!(negate
^ (i
< n_char_ranges
)))
1789 pos
--, pos_byte
-= nbytes
;
1802 if (! NILP (iso_classes
) && in_classes (p
[-1], iso_classes
))
1807 goto back_unibyte_ok
;
1810 if (!fastmap
[p
[-1]])
1818 #if 0 /* Not needed now that a position in mid-character
1819 cannot be specified in Lisp. */
1821 /* INC_POS or DEC_POS might have moved POS over LIM. */
1822 && (forwardp
? (pos
> XINT (lim
)) : (pos
< XINT (lim
))))
1829 SET_PT_BOTH (pos
, pos_byte
);
1832 return make_number (PT
- start_point
);
1836 /* Return 1 if character C belongs to one of the ISO classes
1837 in the list ISO_CLASSES. Each class is represented by an
1838 integer which is its type according to re_wctype. */
1841 in_classes (c
, iso_classes
)
1843 Lisp_Object iso_classes
;
1847 while (! NILP (iso_classes
))
1850 elt
= XCAR (iso_classes
);
1851 iso_classes
= XCDR (iso_classes
);
1853 if (re_iswctype (c
, XFASTINT (elt
)))
1860 /* Jump over a comment, assuming we are at the beginning of one.
1861 FROM is the current position.
1862 FROM_BYTE is the bytepos corresponding to FROM.
1863 Do not move past STOP (a charpos).
1864 The comment over which we have to jump is of style STYLE
1865 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
1866 NESTING should be positive to indicate the nesting at the beginning
1867 for nested comments and should be zero or negative else.
1868 ST_COMMENT_STYLE cannot be nested.
1869 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
1870 (or 0 If the search cannot start in the middle of a two-character).
1872 If successful, return 1 and store the charpos of the comment's end
1873 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
1874 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
1875 corresponding bytepos into *BYTEPOS_PTR and the current nesting
1876 (as defined for state.incomment) in *INCOMMENT_PTR.
1878 The comment end is the last character of the comment rather than the
1879 character just after the comment.
1881 Global syntax data is assumed to initially be valid for FROM and
1882 remains valid for forward search starting at the returned position. */
1885 forw_comment (from
, from_byte
, stop
, nesting
, style
, prev_syntax
,
1886 charpos_ptr
, bytepos_ptr
, incomment_ptr
)
1887 int from
, from_byte
, stop
;
1888 int nesting
, style
, prev_syntax
;
1889 int *charpos_ptr
, *bytepos_ptr
, *incomment_ptr
;
1892 register enum syntaxcode code
;
1893 register int syntax
;
1895 if (nesting
<= 0) nesting
= -1;
1897 /* Enter the loop in the middle so that we find
1898 a 2-char comment ender if we start in the middle of it. */
1899 syntax
= prev_syntax
;
1900 if (syntax
!= 0) goto forw_incomment
;
1906 *incomment_ptr
= nesting
;
1907 *charpos_ptr
= from
;
1908 *bytepos_ptr
= from_byte
;
1911 c
= FETCH_CHAR (from_byte
);
1912 syntax
= SYNTAX_WITH_FLAGS (c
);
1913 code
= syntax
& 0xff;
1914 if (code
== Sendcomment
1915 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1916 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ?
1917 (nesting
> 0 && --nesting
== 0) : nesting
< 0))
1918 /* we have encountered a comment end of the same style
1919 as the comment sequence which began this comment
1922 if (code
== Scomment_fence
1923 && style
== ST_COMMENT_STYLE
)
1924 /* we have encountered a comment end of the same style
1925 as the comment sequence which began this comment
1930 && SYNTAX_FLAGS_COMMENT_NESTED (syntax
)
1931 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
)
1932 /* we have encountered a nested comment of the same style
1933 as the comment sequence which began this comment section */
1935 INC_BOTH (from
, from_byte
);
1936 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1939 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
1940 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1941 && (c1
= FETCH_CHAR (from_byte
),
1942 SYNTAX_COMEND_SECOND (c1
))
1943 && ((SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
1944 SYNTAX_COMMENT_NESTED (c1
)) ? nesting
> 0 : nesting
< 0))
1947 /* we have encountered a comment end of the same style
1948 as the comment sequence which began this comment
1953 INC_BOTH (from
, from_byte
);
1954 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1959 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
1960 && (c1
= FETCH_CHAR (from_byte
),
1961 SYNTAX_COMMENT_STYLE (c1
) == style
1962 && SYNTAX_COMSTART_SECOND (c1
))
1963 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
1964 SYNTAX_COMMENT_NESTED (c1
)))
1965 /* we have encountered a nested comment of the same style
1966 as the comment sequence which began this comment
1969 INC_BOTH (from
, from_byte
);
1970 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1974 *charpos_ptr
= from
;
1975 *bytepos_ptr
= from_byte
;
1979 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
1981 Move forward across up to COUNT comments. If COUNT is negative, move backward.
1982 Stop scanning if we find something other than a comment or whitespace.
1983 Set point to where scanning stops.
1984 If COUNT comments are found as expected, with nothing except whitespace
1985 between them, return t; otherwise return nil. */)
1993 register enum syntaxcode code
;
1994 int comstyle
= 0; /* style of comment encountered */
1995 int comnested
= 0; /* whether the comment is nestable or not */
1998 int out_charpos
, out_bytepos
;
2001 CHECK_NUMBER (count
);
2002 count1
= XINT (count
);
2003 stop
= count1
> 0 ? ZV
: BEGV
;
2009 from_byte
= PT_BYTE
;
2011 SETUP_SYNTAX_TABLE (from
, count1
);
2020 SET_PT_BOTH (from
, from_byte
);
2024 c
= FETCH_CHAR (from_byte
);
2026 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2027 comnested
= SYNTAX_COMMENT_NESTED (c
);
2028 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2029 INC_BOTH (from
, from_byte
);
2030 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2031 if (from
< stop
&& comstart_first
2032 && (c1
= FETCH_CHAR (from_byte
),
2033 SYNTAX_COMSTART_SECOND (c1
)))
2035 /* We have encountered a comment start sequence and we
2036 are ignoring all text inside comments. We must record
2037 the comment style this sequence begins so that later,
2038 only a comment end of the same style actually ends
2039 the comment section. */
2041 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2042 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2043 INC_BOTH (from
, from_byte
);
2044 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2047 while (code
== Swhitespace
|| (code
== Sendcomment
&& c
== '\n'));
2049 if (code
== Scomment_fence
)
2050 comstyle
= ST_COMMENT_STYLE
;
2051 else if (code
!= Scomment
)
2054 DEC_BOTH (from
, from_byte
);
2055 SET_PT_BOTH (from
, from_byte
);
2058 /* We're at the start of a comment. */
2059 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
2060 &out_charpos
, &out_bytepos
, &dummy
);
2061 from
= out_charpos
; from_byte
= out_bytepos
;
2065 SET_PT_BOTH (from
, from_byte
);
2068 INC_BOTH (from
, from_byte
);
2069 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2070 /* We have skipped one comment. */
2082 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
2087 DEC_BOTH (from
, from_byte
);
2088 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
2089 quoted
= char_quoted (from
, from_byte
);
2090 c
= FETCH_CHAR (from_byte
);
2093 comnested
= SYNTAX_COMMENT_NESTED (c
);
2094 if (code
== Sendcomment
)
2095 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2096 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2097 && prev_char_comend_first (from
, from_byte
)
2098 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
2100 /* We must record the comment style encountered so that
2101 later, we can match only the proper comment begin
2102 sequence of the same style. */
2103 DEC_BOTH (from
, from_byte
);
2105 /* Calling char_quoted, above, set up global syntax position
2106 at the new value of FROM. */
2107 c1
= FETCH_CHAR (from_byte
);
2108 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2109 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2112 if (code
== Scomment_fence
)
2114 /* Skip until first preceding unquoted comment_fence. */
2115 int found
= 0, ini
= from
, ini_byte
= from_byte
;
2119 DEC_BOTH (from
, from_byte
);
2122 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2123 c
= FETCH_CHAR (from_byte
);
2124 if (SYNTAX (c
) == Scomment_fence
2125 && !char_quoted (from
, from_byte
))
2133 from
= ini
; /* Set point to ini + 1. */
2134 from_byte
= ini_byte
;
2138 else if (code
== Sendcomment
)
2140 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2141 &out_charpos
, &out_bytepos
);
2145 /* This end-of-line is not an end-of-comment.
2146 Treat it like a whitespace.
2147 CC-mode (and maybe others) relies on this behavior. */
2151 /* Failure: we should go back to the end of this
2152 not-quite-endcomment. */
2153 if (SYNTAX(c
) != code
)
2154 /* It was a two-char Sendcomment. */
2155 INC_BOTH (from
, from_byte
);
2161 /* We have skipped one comment. */
2162 from
= out_charpos
, from_byte
= out_bytepos
;
2166 else if (code
!= Swhitespace
|| quoted
)
2170 INC_BOTH (from
, from_byte
);
2171 SET_PT_BOTH (from
, from_byte
);
2179 SET_PT_BOTH (from
, from_byte
);
2184 /* Return syntax code of character C if C is a single byte character
2185 or `multibyte_symbol_p' is zero. Otherwise, return Ssymbol. */
2187 #define SYNTAX_WITH_MULTIBYTE_CHECK(c) \
2188 ((SINGLE_BYTE_CHAR_P (c) || !multibyte_symbol_p) \
2189 ? SYNTAX (c) : Ssymbol)
2192 scan_lists (from
, count
, depth
, sexpflag
)
2194 int count
, depth
, sexpflag
;
2197 register int stop
= count
> 0 ? ZV
: BEGV
;
2202 register enum syntaxcode code
, temp_code
;
2203 int min_depth
= depth
; /* Err out if depth gets less than this. */
2204 int comstyle
= 0; /* style of comment encountered */
2205 int comnested
= 0; /* whether the comment is nestable or not */
2207 int last_good
= from
;
2210 int out_bytepos
, out_charpos
;
2212 int multibyte_symbol_p
= sexpflag
&& multibyte_syntax_as_symbol
;
2214 if (depth
> 0) min_depth
= 0;
2216 if (from
> ZV
) from
= ZV
;
2217 if (from
< BEGV
) from
= BEGV
;
2219 from_byte
= CHAR_TO_BYTE (from
);
2224 SETUP_SYNTAX_TABLE (from
, count
);
2229 int comstart_first
, prefix
;
2230 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2231 c
= FETCH_CHAR (from_byte
);
2232 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2233 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2234 comnested
= SYNTAX_COMMENT_NESTED (c
);
2235 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2236 prefix
= SYNTAX_PREFIX (c
);
2237 if (depth
== min_depth
)
2239 INC_BOTH (from
, from_byte
);
2240 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2241 if (from
< stop
&& comstart_first
2242 && (c
= FETCH_CHAR (from_byte
), SYNTAX_COMSTART_SECOND (c
))
2243 && parse_sexp_ignore_comments
)
2245 /* we have encountered a comment start sequence and we
2246 are ignoring all text inside comments. We must record
2247 the comment style this sequence begins so that later,
2248 only a comment end of the same style actually ends
2249 the comment section */
2251 c1
= FETCH_CHAR (from_byte
);
2252 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2253 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2254 INC_BOTH (from
, from_byte
);
2255 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2261 switch (SWITCH_ENUM_CAST (code
))
2265 if (from
== stop
) goto lose
;
2266 INC_BOTH (from
, from_byte
);
2267 /* treat following character as a word constituent */
2270 if (depth
|| !sexpflag
) break;
2271 /* This word counts as a sexp; return at end of it. */
2274 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2276 /* Some compilers can't handle this inside the switch. */
2277 c
= FETCH_CHAR (from_byte
);
2278 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2283 INC_BOTH (from
, from_byte
);
2284 if (from
== stop
) goto lose
;
2293 INC_BOTH (from
, from_byte
);
2297 case Scomment_fence
:
2298 comstyle
= ST_COMMENT_STYLE
;
2301 if (!parse_sexp_ignore_comments
) break;
2302 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2303 found
= forw_comment (from
, from_byte
, stop
,
2304 comnested
, comstyle
, 0,
2305 &out_charpos
, &out_bytepos
, &dummy
);
2306 from
= out_charpos
, from_byte
= out_bytepos
;
2313 INC_BOTH (from
, from_byte
);
2314 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2320 if (from
!= stop
&& c
== FETCH_CHAR (from_byte
))
2322 INC_BOTH (from
, from_byte
);
2332 if (!++depth
) goto done
;
2337 if (!--depth
) goto done
;
2338 if (depth
< min_depth
)
2339 Fsignal (Qscan_error
,
2340 Fcons (build_string ("Containing expression ends prematurely"),
2341 Fcons (make_number (last_good
),
2342 Fcons (make_number (from
), Qnil
))));
2347 temp_pos
= dec_bytepos (from_byte
);
2348 stringterm
= FETCH_CHAR (temp_pos
);
2351 if (from
>= stop
) goto lose
;
2352 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2353 c
= FETCH_CHAR (from_byte
);
2356 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2357 : SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring_fence
)
2360 /* Some compilers can't handle this inside the switch. */
2361 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2366 INC_BOTH (from
, from_byte
);
2368 INC_BOTH (from
, from_byte
);
2370 INC_BOTH (from
, from_byte
);
2371 if (!depth
&& sexpflag
) goto done
;
2374 /* Ignore whitespace, punctuation, quote, endcomment. */
2379 /* Reached end of buffer. Error if within object, return nil if between */
2380 if (depth
) goto lose
;
2385 /* End of object reached */
2394 DEC_BOTH (from
, from_byte
);
2395 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2396 c
= FETCH_CHAR (from_byte
);
2397 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2398 if (depth
== min_depth
)
2401 comnested
= SYNTAX_COMMENT_NESTED (c
);
2402 if (code
== Sendcomment
)
2403 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2404 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2405 && prev_char_comend_first (from
, from_byte
)
2406 && parse_sexp_ignore_comments
)
2408 /* We must record the comment style encountered so that
2409 later, we can match only the proper comment begin
2410 sequence of the same style. */
2411 DEC_BOTH (from
, from_byte
);
2412 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2414 c1
= FETCH_CHAR (from_byte
);
2415 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2416 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2419 /* Quoting turns anything except a comment-ender
2420 into a word character. Note that this cannot be true
2421 if we decremented FROM in the if-statement above. */
2422 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2424 DEC_BOTH (from
, from_byte
);
2427 else if (SYNTAX_PREFIX (c
))
2430 switch (SWITCH_ENUM_CAST (code
))
2436 if (depth
|| !sexpflag
) break;
2437 /* This word counts as a sexp; count object finished
2438 after passing it. */
2441 temp_pos
= from_byte
;
2442 if (! NILP (current_buffer
->enable_multibyte_characters
))
2446 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2447 c1
= FETCH_CHAR (temp_pos
);
2448 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2449 /* Don't allow comment-end to be quoted. */
2450 if (temp_code
== Sendcomment
)
2452 quoted
= char_quoted (from
- 1, temp_pos
);
2455 DEC_BOTH (from
, from_byte
);
2456 temp_pos
= dec_bytepos (temp_pos
);
2457 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2459 c1
= FETCH_CHAR (temp_pos
);
2460 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2461 if (! (quoted
|| temp_code
== Sword
2462 || temp_code
== Ssymbol
2463 || temp_code
== Squote
))
2465 DEC_BOTH (from
, from_byte
);
2472 temp_pos
= dec_bytepos (from_byte
);
2473 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2474 if (from
!= stop
&& c
== FETCH_CHAR (temp_pos
))
2475 DEC_BOTH (from
, from_byte
);
2484 if (!++depth
) goto done2
;
2489 if (!--depth
) goto done2
;
2490 if (depth
< min_depth
)
2491 Fsignal (Qscan_error
,
2492 Fcons (build_string ("Containing expression ends prematurely"),
2493 Fcons (make_number (last_good
),
2494 Fcons (make_number (from
), Qnil
))));
2498 if (!parse_sexp_ignore_comments
)
2500 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2501 &out_charpos
, &out_bytepos
);
2502 /* FIXME: if found == -1, then it really wasn't a comment-end.
2503 For single-char Sendcomment, we can't do much about it apart
2504 from skipping the char.
2505 For 2-char endcomments, we could try again, taking both
2506 chars as separate entities, but it's a lot of trouble
2507 for very little gain, so we don't bother either. -sm */
2509 from
= out_charpos
, from_byte
= out_bytepos
;
2512 case Scomment_fence
:
2516 if (from
== stop
) goto lose
;
2517 DEC_BOTH (from
, from_byte
);
2518 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2519 if (!char_quoted (from
, from_byte
)
2520 && (c
= FETCH_CHAR (from_byte
),
2521 SYNTAX_WITH_MULTIBYTE_CHECK (c
) == code
))
2524 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2528 stringterm
= FETCH_CHAR (from_byte
);
2531 if (from
== stop
) goto lose
;
2532 DEC_BOTH (from
, from_byte
);
2533 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2534 if (!char_quoted (from
, from_byte
)
2535 && stringterm
== (c
= FETCH_CHAR (from_byte
))
2536 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2539 if (!depth
&& sexpflag
) goto done2
;
2542 /* Ignore whitespace, punctuation, quote, endcomment. */
2547 /* Reached start of buffer. Error if within object, return nil if between */
2548 if (depth
) goto lose
;
2559 XSETFASTINT (val
, from
);
2563 Fsignal (Qscan_error
,
2564 Fcons (build_string ("Unbalanced parentheses"),
2565 Fcons (make_number (last_good
),
2566 Fcons (make_number (from
), Qnil
))));
2571 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2572 doc
: /* Scan from character number FROM by COUNT lists.
2573 Returns the character number of the position thus found.
2575 If DEPTH is nonzero, paren depth begins counting from that value,
2576 only places where the depth in parentheses becomes zero
2577 are candidates for stopping; COUNT such places are counted.
2578 Thus, a positive value for DEPTH means go out levels.
2580 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2582 If the beginning or end of (the accessible part of) the buffer is reached
2583 and the depth is wrong, an error is signaled.
2584 If the depth is right but the count is not used up, nil is returned. */)
2585 (from
, count
, depth
)
2586 Lisp_Object from
, count
, depth
;
2588 CHECK_NUMBER (from
);
2589 CHECK_NUMBER (count
);
2590 CHECK_NUMBER (depth
);
2592 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2595 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2596 doc
: /* Scan from character number FROM by COUNT balanced expressions.
2597 If COUNT is negative, scan backwards.
2598 Returns the character number of the position thus found.
2600 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2602 If the beginning or end of (the accessible part of) the buffer is reached
2603 in the middle of a parenthetical grouping, an error is signaled.
2604 If the beginning or end is reached between groupings
2605 but before count is used up, nil is returned. */)
2607 Lisp_Object from
, count
;
2609 CHECK_NUMBER (from
);
2610 CHECK_NUMBER (count
);
2612 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2615 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2617 doc
: /* Move point backward over any number of chars with prefix syntax.
2618 This includes chars with "quote" or "prefix" syntax (' or p). */)
2623 int opoint_byte
= PT_BYTE
;
2625 int pos_byte
= PT_BYTE
;
2630 SET_PT_BOTH (opoint
, opoint_byte
);
2635 SETUP_SYNTAX_TABLE (pos
, -1);
2637 DEC_BOTH (pos
, pos_byte
);
2639 while (!char_quoted (pos
, pos_byte
)
2640 /* Previous statement updates syntax table. */
2641 && ((c
= FETCH_CHAR (pos_byte
), SYNTAX (c
) == Squote
)
2642 || SYNTAX_PREFIX (c
)))
2645 opoint_byte
= pos_byte
;
2648 DEC_BOTH (pos
, pos_byte
);
2651 SET_PT_BOTH (opoint
, opoint_byte
);
2656 /* Parse forward from FROM / FROM_BYTE to END,
2657 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2658 and return a description of the state of the parse at END.
2659 If STOPBEFORE is nonzero, stop at the start of an atom.
2660 If COMMENTSTOP is 1, stop at the start of a comment.
2661 If COMMENTSTOP is -1, stop at the start or end of a comment,
2662 after the beginning of a string, or after the end of a string. */
2665 scan_sexps_forward (stateptr
, from
, from_byte
, end
, targetdepth
,
2666 stopbefore
, oldstate
, commentstop
)
2667 struct lisp_parse_state
*stateptr
;
2669 int end
, targetdepth
, stopbefore
, from_byte
;
2670 Lisp_Object oldstate
;
2673 struct lisp_parse_state state
;
2675 register enum syntaxcode code
;
2678 struct level
{ int last
, prev
; };
2679 struct level levelstart
[100];
2680 register struct level
*curlevel
= levelstart
;
2681 struct level
*endlevel
= levelstart
+ 100;
2682 register int depth
; /* Paren depth of current scanning location.
2683 level - levelstart equals this except
2684 when the depth becomes negative. */
2685 int mindepth
; /* Lowest DEPTH value seen. */
2686 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2688 int prev_from
; /* Keep one character before FROM. */
2690 int prev_from_syntax
;
2691 int boundary_stop
= commentstop
== -1;
2694 int out_bytepos
, out_charpos
;
2698 prev_from_byte
= from_byte
;
2700 DEC_BOTH (prev_from
, prev_from_byte
);
2702 /* Use this macro instead of `from++'. */
2704 do { prev_from = from; \
2705 prev_from_byte = from_byte; \
2706 temp = FETCH_CHAR (prev_from_byte); \
2707 prev_from_syntax = SYNTAX_WITH_FLAGS (temp); \
2708 INC_BOTH (from, from_byte); \
2710 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2716 if (NILP (oldstate
))
2719 state
.instring
= -1;
2720 state
.incomment
= 0;
2721 state
.comstyle
= 0; /* comment style a by default. */
2722 state
.comstr_start
= -1; /* no comment/string seen. */
2726 tem
= Fcar (oldstate
);
2732 oldstate
= Fcdr (oldstate
);
2733 oldstate
= Fcdr (oldstate
);
2734 oldstate
= Fcdr (oldstate
);
2735 tem
= Fcar (oldstate
);
2736 /* Check whether we are inside string_fence-style string: */
2737 state
.instring
= (!NILP (tem
)
2738 ? (INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2741 oldstate
= Fcdr (oldstate
);
2742 tem
= Fcar (oldstate
);
2743 state
.incomment
= (!NILP (tem
)
2744 ? (INTEGERP (tem
) ? XINT (tem
) : -1)
2747 oldstate
= Fcdr (oldstate
);
2748 tem
= Fcar (oldstate
);
2749 start_quoted
= !NILP (tem
);
2751 /* if the eighth element of the list is nil, we are in comment
2752 style a. If it is non-nil, we are in comment style b */
2753 oldstate
= Fcdr (oldstate
);
2754 oldstate
= Fcdr (oldstate
);
2755 tem
= Fcar (oldstate
);
2756 state
.comstyle
= NILP (tem
) ? 0 : (EQ (tem
, Qsyntax_table
)
2757 ? ST_COMMENT_STYLE
: 1);
2759 oldstate
= Fcdr (oldstate
);
2760 tem
= Fcar (oldstate
);
2761 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2762 oldstate
= Fcdr (oldstate
);
2763 tem
= Fcar (oldstate
);
2764 while (!NILP (tem
)) /* >= second enclosing sexps. */
2766 /* curlevel++->last ran into compiler bug on Apollo */
2767 curlevel
->last
= XINT (Fcar (tem
));
2768 if (++curlevel
== endlevel
)
2769 curlevel
--; /* error ("Nesting too deep for parser"); */
2770 curlevel
->prev
= -1;
2771 curlevel
->last
= -1;
2778 curlevel
->prev
= -1;
2779 curlevel
->last
= -1;
2781 SETUP_SYNTAX_TABLE (prev_from
, 1);
2782 temp
= FETCH_CHAR (prev_from_byte
);
2783 prev_from_syntax
= SYNTAX_WITH_FLAGS (temp
);
2784 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2786 /* Enter the loop at a place appropriate for initial state. */
2788 if (state
.incomment
)
2789 goto startincomment
;
2790 if (state
.instring
>= 0)
2792 nofence
= state
.instring
!= ST_STRING_STYLE
;
2794 goto startquotedinstring
;
2797 else if (start_quoted
)
2803 code
= prev_from_syntax
& 0xff;
2806 && SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
)
2807 && (c1
= FETCH_CHAR (from_byte
),
2808 SYNTAX_COMSTART_SECOND (c1
)))
2809 /* Duplicate code to avoid a complex if-expression
2810 which causes trouble for the SGI compiler. */
2812 /* Record the comment style we have entered so that only
2813 the comment-end sequence of the same style actually
2814 terminates the comment section. */
2815 state
.comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2816 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
);
2817 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2818 state
.incomment
= comnested
? 1 : -1;
2819 state
.comstr_start
= prev_from
;
2823 else if (code
== Scomment_fence
)
2825 /* Record the comment style we have entered so that only
2826 the comment-end sequence of the same style actually
2827 terminates the comment section. */
2828 state
.comstyle
= ST_COMMENT_STYLE
;
2829 state
.incomment
= -1;
2830 state
.comstr_start
= prev_from
;
2833 else if (code
== Scomment
)
2835 state
.comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax
);
2836 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
2838 state
.comstr_start
= prev_from
;
2841 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
2843 switch (SWITCH_ENUM_CAST (code
))
2847 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2848 curlevel
->last
= prev_from
;
2850 if (from
== end
) goto endquoted
;
2853 /* treat following character as a word constituent */
2856 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2857 curlevel
->last
= prev_from
;
2861 /* Some compilers can't handle this inside the switch. */
2862 temp
= FETCH_CHAR (from_byte
);
2863 temp
= SYNTAX (temp
);
2869 if (from
== end
) goto endquoted
;
2881 curlevel
->prev
= curlevel
->last
;
2884 case Scomment_fence
: /* Can't happen because it's handled above. */
2886 if (commentstop
|| boundary_stop
) goto done
;
2888 /* The (from == BEGV) test was to enter the loop in the middle so
2889 that we find a 2-char comment ender even if we start in the
2890 middle of it. We don't want to do that if we're just at the
2891 beginning of the comment (think of (*) ... (*)). */
2892 found
= forw_comment (from
, from_byte
, end
,
2893 state
.incomment
, state
.comstyle
,
2894 (from
== BEGV
|| from
< state
.comstr_start
+ 3)
2895 ? 0 : prev_from_syntax
,
2896 &out_charpos
, &out_bytepos
, &state
.incomment
);
2897 from
= out_charpos
; from_byte
= out_bytepos
;
2898 /* Beware! prev_from and friends are invalid now.
2899 Luckily, the `done' doesn't use them and the INC_FROM
2900 sets them to a sane value without looking at them. */
2901 if (!found
) goto done
;
2903 state
.incomment
= 0;
2904 state
.comstyle
= 0; /* reset the comment style */
2905 if (boundary_stop
) goto done
;
2909 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2911 /* curlevel++->last ran into compiler bug on Apollo */
2912 curlevel
->last
= prev_from
;
2913 if (++curlevel
== endlevel
)
2914 curlevel
--; /* error ("Nesting too deep for parser"); */
2915 curlevel
->prev
= -1;
2916 curlevel
->last
= -1;
2917 if (targetdepth
== depth
) goto done
;
2922 if (depth
< mindepth
)
2924 if (curlevel
!= levelstart
)
2926 curlevel
->prev
= curlevel
->last
;
2927 if (targetdepth
== depth
) goto done
;
2932 state
.comstr_start
= from
- 1;
2933 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2934 curlevel
->last
= prev_from
;
2935 state
.instring
= (code
== Sstring
2936 ? (FETCH_CHAR (prev_from_byte
))
2938 if (boundary_stop
) goto done
;
2941 nofence
= state
.instring
!= ST_STRING_STYLE
;
2947 if (from
>= end
) goto done
;
2948 c
= FETCH_CHAR (from_byte
);
2949 /* Some compilers can't handle this inside the switch. */
2952 /* Check TEMP here so that if the char has
2953 a syntax-table property which says it is NOT
2954 a string character, it does not end the string. */
2955 if (nofence
&& c
== state
.instring
&& temp
== Sstring
)
2961 if (!nofence
) goto string_end
;
2966 startquotedinstring
:
2967 if (from
>= end
) goto endquoted
;
2973 state
.instring
= -1;
2974 curlevel
->prev
= curlevel
->last
;
2976 if (boundary_stop
) goto done
;
2980 /* FIXME: We should do something with it. */
2983 /* Ignore whitespace, punctuation, quote, endcomment. */
2989 stop
: /* Here if stopping before start of sexp. */
2990 from
= prev_from
; /* We have just fetched the char that starts it; */
2991 goto done
; /* but return the position before it. */
2996 state
.depth
= depth
;
2997 state
.mindepth
= mindepth
;
2998 state
.thislevelstart
= curlevel
->prev
;
2999 state
.prevlevelstart
3000 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
3001 state
.location
= from
;
3002 state
.levelstarts
= Qnil
;
3003 while (--curlevel
>= levelstart
)
3004 state
.levelstarts
= Fcons (make_number (curlevel
->last
),
3011 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
3012 doc
: /* Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
3013 Parsing stops at TO or when certain criteria are met;
3014 point is set to where parsing stops.
3015 If fifth arg OLDSTATE is omitted or nil,
3016 parsing assumes that FROM is the beginning of a function.
3017 Value is a list of ten elements describing final state of parsing:
3019 1. character address of start of innermost containing list; nil if none.
3020 2. character address of start of last complete sexp terminated.
3021 3. non-nil if inside a string.
3022 (it is the character that will terminate the string,
3023 or t if the string should be terminated by a generic string delimiter.)
3024 4. nil if outside a comment, t if inside a non-nestable comment,
3025 else an integer (the current comment nesting).
3026 5. t if following a quote character.
3027 6. the minimum paren-depth encountered during this scan.
3028 7. t if in a comment of style b; symbol `syntax-table' if the comment
3029 should be terminated by a generic comment delimiter.
3030 8. character address of start of comment or string; nil if not in one.
3031 9. Intermediate data for continuation of parsing (subject to change).
3032 If third arg TARGETDEPTH is non-nil, parsing stops if the depth
3033 in parentheses becomes equal to TARGETDEPTH.
3034 Fourth arg STOPBEFORE non-nil means stop when come to
3035 any character that starts a sexp.
3036 Fifth arg OLDSTATE is a nine-element list like what this function returns.
3037 It is used to initialize the state of the parse. Elements number 1, 2, 6
3038 and 8 are ignored; you can leave off element 8 (the last) entirely.
3039 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
3040 If it is symbol `syntax-table', stop after the start of a comment or a
3041 string, or after end of a comment or a string. */)
3042 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
3043 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
3045 struct lisp_parse_state state
;
3048 if (!NILP (targetdepth
))
3050 CHECK_NUMBER (targetdepth
);
3051 target
= XINT (targetdepth
);
3054 target
= -100000; /* We won't reach this depth */
3056 validate_region (&from
, &to
);
3057 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
3059 target
, !NILP (stopbefore
), oldstate
,
3061 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
3063 SET_PT (state
.location
);
3065 return Fcons (make_number (state
.depth
),
3066 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
3067 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
3068 Fcons (state
.instring
>= 0
3069 ? (state
.instring
== ST_STRING_STYLE
3070 ? Qt
: make_number (state
.instring
)) : Qnil
,
3071 Fcons (state
.incomment
< 0 ? Qt
:
3072 (state
.incomment
== 0 ? Qnil
:
3073 make_number (state
.incomment
)),
3074 Fcons (state
.quoted
? Qt
: Qnil
,
3075 Fcons (make_number (state
.mindepth
),
3076 Fcons ((state
.comstyle
3077 ? (state
.comstyle
== ST_COMMENT_STYLE
3078 ? Qsyntax_table
: Qt
) :
3080 Fcons (((state
.incomment
3081 || (state
.instring
>= 0))
3082 ? make_number (state
.comstr_start
)
3084 Fcons (state
.levelstarts
, Qnil
))))))))));
3093 /* This has to be done here, before we call Fmake_char_table. */
3094 Qsyntax_table
= intern ("syntax-table");
3095 staticpro (&Qsyntax_table
);
3097 /* Intern this now in case it isn't already done.
3098 Setting this variable twice is harmless.
3099 But don't staticpro it here--that is done in alloc.c. */
3100 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
3102 /* Create objects which can be shared among syntax tables. */
3103 Vsyntax_code_object
= Fmake_vector (make_number (Smax
), Qnil
);
3104 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
3105 XVECTOR (Vsyntax_code_object
)->contents
[i
]
3106 = Fcons (make_number (i
), Qnil
);
3108 /* Now we are ready to set up this property, so we can
3109 create syntax tables. */
3110 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
3112 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
3114 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
3116 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
3117 for (i
= 'a'; i
<= 'z'; i
++)
3118 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3119 for (i
= 'A'; i
<= 'Z'; i
++)
3120 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3121 for (i
= '0'; i
<= '9'; i
++)
3122 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3124 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
3125 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
3127 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
3128 Fcons (make_number (Sopen
), make_number (')')));
3129 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
3130 Fcons (make_number (Sclose
), make_number ('(')));
3131 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
3132 Fcons (make_number (Sopen
), make_number (']')));
3133 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
3134 Fcons (make_number (Sclose
), make_number ('[')));
3135 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
3136 Fcons (make_number (Sopen
), make_number ('}')));
3137 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
3138 Fcons (make_number (Sclose
), make_number ('{')));
3139 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
3140 Fcons (make_number ((int) Sstring
), Qnil
));
3141 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
3142 Fcons (make_number ((int) Sescape
), Qnil
));
3144 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
3145 for (i
= 0; i
< 10; i
++)
3147 c
= "_-+*/&|<>="[i
];
3148 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3151 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
3152 for (i
= 0; i
< 12; i
++)
3154 c
= ".,;:?!#@~^'`"[i
];
3155 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3158 /* All multibyte characters have syntax `word' by default. */
3159 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
3160 for (i
= CHAR_TABLE_SINGLE_BYTE_SLOTS
; i
< CHAR_TABLE_ORDINARY_SLOTS
; i
++)
3161 XCHAR_TABLE (Vstandard_syntax_table
)->contents
[i
] = temp
;
3167 Qsyntax_table_p
= intern ("syntax-table-p");
3168 staticpro (&Qsyntax_table_p
);
3170 staticpro (&Vsyntax_code_object
);
3172 staticpro (&gl_state
.object
);
3173 staticpro (&gl_state
.global_code
);
3174 staticpro (&gl_state
.current_syntax_table
);
3175 staticpro (&gl_state
.old_prop
);
3177 /* Defined in regex.c */
3178 staticpro (&re_match_object
);
3180 Qscan_error
= intern ("scan-error");
3181 staticpro (&Qscan_error
);
3182 Fput (Qscan_error
, Qerror_conditions
,
3183 Fcons (Qscan_error
, Fcons (Qerror
, Qnil
)));
3184 Fput (Qscan_error
, Qerror_message
,
3185 build_string ("Scan error"));
3187 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
3188 doc
: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace. */);
3190 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
3191 doc
: /* Non-nil means `forward-sexp', etc., obey `syntax-table' property.
3192 Otherwise, that text property is simply ignored.
3193 See the info node `(elisp)Syntax Properties' for a description of the
3194 `syntax-table' property. */);
3196 words_include_escapes
= 0;
3197 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
3198 doc
: /* Non-nil means `forward-word', etc., should treat escape chars part of words. */);
3200 DEFVAR_BOOL ("multibyte-syntax-as-symbol", &multibyte_syntax_as_symbol
,
3201 doc
: /* Non-nil means `scan-sexps' treats all multibyte characters as symbol. */);
3202 multibyte_syntax_as_symbol
= 0;
3204 DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
3205 &open_paren_in_column_0_is_defun_start
,
3206 doc
: /* *Non-nil means an open paren in column 0 denotes the start of a defun. */);
3207 open_paren_in_column_0_is_defun_start
= 1;
3209 defsubr (&Ssyntax_table_p
);
3210 defsubr (&Ssyntax_table
);
3211 defsubr (&Sstandard_syntax_table
);
3212 defsubr (&Scopy_syntax_table
);
3213 defsubr (&Sset_syntax_table
);
3214 defsubr (&Schar_syntax
);
3215 defsubr (&Smatching_paren
);
3216 defsubr (&Sstring_to_syntax
);
3217 defsubr (&Smodify_syntax_entry
);
3218 defsubr (&Sinternal_describe_syntax_value
);
3220 defsubr (&Sforward_word
);
3222 defsubr (&Sskip_chars_forward
);
3223 defsubr (&Sskip_chars_backward
);
3224 defsubr (&Sskip_syntax_forward
);
3225 defsubr (&Sskip_syntax_backward
);
3227 defsubr (&Sforward_comment
);
3228 defsubr (&Sscan_lists
);
3229 defsubr (&Sscan_sexps
);
3230 defsubr (&Sbackward_prefix_chars
);
3231 defsubr (&Sparse_partial_sexp
);
3234 /* arch-tag: 3e297b9f-088e-4b64-8f4c-fb0b3443e412
3235 (do not change this comment) */