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, 2006 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. */
28 #include "character.h"
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, Lisp_Object
, Lisp_Object
, int));
103 static Lisp_Object skip_syntaxes
P_ ((int, Lisp_Object
, Lisp_Object
));
104 static Lisp_Object scan_lists
P_ ((int, int, int, int));
105 static void scan_sexps_forward
P_ ((struct lisp_parse_state
*,
107 int, Lisp_Object
, int));
108 static int in_classes
P_ ((int, Lisp_Object
));
111 struct gl_state_s gl_state
; /* Global state of syntax parser. */
113 INTERVAL
interval_of ();
114 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
115 to scan to property-change. */
117 /* Update gl_state to an appropriate interval which contains CHARPOS. The
118 sign of COUNT give the relative position of CHARPOS wrt the previously
119 valid interval. If INIT, only [be]_property fields of gl_state are
120 valid at start, the rest is filled basing on OBJECT.
122 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
123 direction than the intervals - or in an interval. We update the
124 current syntax-table basing on the property of this interval, and
125 update the interval to start further than CHARPOS - or be
126 NULL_INTERVAL. We also update lim_property to be the next value of
127 charpos to call this subroutine again - or be before/after the
128 start/end of OBJECT. */
131 update_syntax_table (charpos
, count
, init
, object
)
132 int charpos
, count
, init
;
135 Lisp_Object tmp_table
;
136 int cnt
= 0, invalidate
= 1;
141 gl_state
.old_prop
= Qnil
;
142 gl_state
.start
= gl_state
.b_property
;
143 gl_state
.stop
= gl_state
.e_property
;
144 i
= interval_of (charpos
, object
);
145 gl_state
.backward_i
= gl_state
.forward_i
= i
;
147 if (NULL_INTERVAL_P (i
))
149 /* interval_of updates only ->position of the return value, so
150 update the parents manually to speed up update_interval. */
151 while (!NULL_PARENT (i
))
153 if (AM_RIGHT_CHILD (i
))
154 INTERVAL_PARENT (i
)->position
= i
->position
155 - LEFT_TOTAL_LENGTH (i
) + TOTAL_LENGTH (i
) /* right end */
156 - TOTAL_LENGTH (INTERVAL_PARENT (i
))
157 + LEFT_TOTAL_LENGTH (INTERVAL_PARENT (i
));
159 INTERVAL_PARENT (i
)->position
= i
->position
- LEFT_TOTAL_LENGTH (i
)
161 i
= INTERVAL_PARENT (i
);
163 i
= gl_state
.forward_i
;
164 gl_state
.b_property
= i
->position
- gl_state
.offset
;
165 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
168 i
= count
> 0 ? gl_state
.forward_i
: gl_state
.backward_i
;
170 /* We are guaranteed to be called with CHARPOS either in i,
172 if (NULL_INTERVAL_P (i
))
173 error ("Error in syntax_table logic for to-the-end intervals");
174 else if (charpos
< i
->position
) /* Move left. */
177 error ("Error in syntax_table logic for intervals <-");
178 /* Update the interval. */
179 i
= update_interval (i
, charpos
);
180 if (INTERVAL_LAST_POS (i
) != gl_state
.b_property
)
183 gl_state
.forward_i
= i
;
184 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
187 else if (charpos
>= INTERVAL_LAST_POS (i
)) /* Move right. */
190 error ("Error in syntax_table logic for intervals ->");
191 /* Update the interval. */
192 i
= update_interval (i
, charpos
);
193 if (i
->position
!= gl_state
.e_property
)
196 gl_state
.backward_i
= i
;
197 gl_state
.b_property
= i
->position
- gl_state
.offset
;
202 tmp_table
= textget (i
->plist
, Qsyntax_table
);
205 invalidate
= !EQ (tmp_table
, gl_state
.old_prop
); /* Need to invalidate? */
207 if (invalidate
) /* Did not get to adjacent interval. */
208 { /* with the same table => */
209 /* invalidate the old range. */
212 gl_state
.backward_i
= i
;
213 gl_state
.b_property
= i
->position
- gl_state
.offset
;
217 gl_state
.forward_i
= i
;
218 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
222 if (!EQ (tmp_table
, gl_state
.old_prop
))
224 gl_state
.current_syntax_table
= tmp_table
;
225 gl_state
.old_prop
= tmp_table
;
226 if (EQ (Fsyntax_table_p (tmp_table
), Qt
))
228 gl_state
.use_global
= 0;
230 else if (CONSP (tmp_table
))
232 gl_state
.use_global
= 1;
233 gl_state
.global_code
= tmp_table
;
237 gl_state
.use_global
= 0;
238 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
242 while (!NULL_INTERVAL_P (i
))
244 if (cnt
&& !EQ (tmp_table
, textget (i
->plist
, Qsyntax_table
)))
248 gl_state
.e_property
= i
->position
- gl_state
.offset
;
249 gl_state
.forward_i
= i
;
254 = i
->position
+ LENGTH (i
) - gl_state
.offset
;
255 gl_state
.backward_i
= i
;
259 else if (cnt
== INTERVALS_AT_ONCE
)
264 = i
->position
+ LENGTH (i
) - gl_state
.offset
265 /* e_property at EOB is not set to ZV but to ZV+1, so that
266 we can do INC(from);UPDATE_SYNTAX_TABLE_FORWARD without
267 having to check eob between the two. */
268 + (NULL_INTERVAL_P (next_interval (i
)) ? 1 : 0);
269 gl_state
.forward_i
= i
;
273 gl_state
.b_property
= i
->position
- gl_state
.offset
;
274 gl_state
.backward_i
= i
;
279 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
281 eassert (NULL_INTERVAL_P (i
)); /* This property goes to the end. */
283 gl_state
.e_property
= gl_state
.stop
;
285 gl_state
.b_property
= gl_state
.start
;
288 /* Returns TRUE if char at CHARPOS is quoted.
289 Global syntax-table data should be set up already to be good at CHARPOS
290 or after. On return global syntax data is good for lookup at CHARPOS. */
293 char_quoted (charpos
, bytepos
)
294 register int charpos
, bytepos
;
296 register enum syntaxcode code
;
297 register int beg
= BEGV
;
298 register int quoted
= 0;
301 DEC_BOTH (charpos
, bytepos
);
303 while (charpos
>= beg
)
307 UPDATE_SYNTAX_TABLE_BACKWARD (charpos
);
308 c
= FETCH_CHAR_AS_MULTIBYTE (bytepos
);
310 if (! (code
== Scharquote
|| code
== Sescape
))
313 DEC_BOTH (charpos
, bytepos
);
317 UPDATE_SYNTAX_TABLE (orig
);
321 /* Return the bytepos one character after BYTEPOS.
322 We assume that BYTEPOS is not at the end of the buffer. */
325 inc_bytepos (bytepos
)
328 if (NILP (current_buffer
->enable_multibyte_characters
))
335 /* Return the bytepos one character before BYTEPOS.
336 We assume that BYTEPOS is not at the start of the buffer. */
339 dec_bytepos (bytepos
)
342 if (NILP (current_buffer
->enable_multibyte_characters
))
349 /* Return a defun-start position before before POS and not too far before.
350 It should be the last one before POS, or nearly the last.
352 When open_paren_in_column_0_is_defun_start is nonzero,
353 only the beginning of the buffer is treated as a defun-start.
355 We record the information about where the scan started
356 and what its result was, so that another call in the same area
357 can return the same value very quickly.
359 There is no promise at which position the global syntax data is
360 valid on return from the subroutine, so the caller should explicitly
361 update the global data. */
364 find_defun_start (pos
, pos_byte
)
367 int opoint
= PT
, opoint_byte
= PT_BYTE
;
369 if (!open_paren_in_column_0_is_defun_start
)
371 find_start_value_byte
= BEGV_BYTE
;
375 /* Use previous finding, if it's valid and applies to this inquiry. */
376 if (current_buffer
== find_start_buffer
377 /* Reuse the defun-start even if POS is a little farther on.
378 POS might be in the next defun, but that's ok.
379 Our value may not be the best possible, but will still be usable. */
380 && pos
<= find_start_pos
+ 1000
381 && pos
>= find_start_value
382 && BEGV
== find_start_begv
383 && MODIFF
== find_start_modiff
)
384 return find_start_value
;
386 /* Back up to start of line. */
387 scan_newline (pos
, pos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
389 /* We optimize syntax-table lookup for rare updates. Thus we accept
390 only those `^\s(' which are good in global _and_ text-property
392 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
393 gl_state
.use_global
= 0;
398 /* Open-paren at start of line means we may have found our
400 c
= FETCH_CHAR_AS_MULTIBYTE (PT_BYTE
);
401 if (SYNTAX (c
) == Sopen
)
403 SETUP_SYNTAX_TABLE (PT
+ 1, -1); /* Try again... */
404 c
= FETCH_CHAR_AS_MULTIBYTE (PT_BYTE
);
405 if (SYNTAX (c
) == Sopen
)
407 /* Now fallback to the default value. */
408 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
409 gl_state
.use_global
= 0;
411 /* Move to beg of previous line. */
412 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -2, 1);
415 /* Record what we found, for the next try. */
416 find_start_value
= PT
;
417 find_start_value_byte
= PT_BYTE
;
418 find_start_buffer
= current_buffer
;
419 find_start_modiff
= MODIFF
;
420 find_start_begv
= BEGV
;
421 find_start_pos
= pos
;
423 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
425 return find_start_value
;
428 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
431 prev_char_comend_first (pos
, pos_byte
)
436 DEC_BOTH (pos
, pos_byte
);
437 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
438 c
= FETCH_CHAR (pos_byte
);
439 val
= SYNTAX_COMEND_FIRST (c
);
440 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
444 /* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
447 * prev_char_comstart_first (pos, pos_byte)
452 * DEC_BOTH (pos, pos_byte);
453 * UPDATE_SYNTAX_TABLE_BACKWARD (pos);
454 * c = FETCH_CHAR (pos_byte);
455 * val = SYNTAX_COMSTART_FIRST (c);
456 * UPDATE_SYNTAX_TABLE_FORWARD (pos + 1);
460 /* Checks whether charpos FROM is at the end of a comment.
461 FROM_BYTE is the bytepos corresponding to FROM.
462 Do not move back before STOP.
464 Return a positive value if we find a comment ending at FROM/FROM_BYTE;
467 If successful, store the charpos of the comment's beginning
468 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
470 Global syntax data remains valid for backward search starting at
471 the returned value (or at FROM, if the search was not successful). */
474 back_comment (from
, from_byte
, stop
, comnested
, comstyle
, charpos_ptr
, bytepos_ptr
)
475 int from
, from_byte
, stop
;
476 int comnested
, comstyle
;
477 int *charpos_ptr
, *bytepos_ptr
;
479 /* Look back, counting the parity of string-quotes,
480 and recording the comment-starters seen.
481 When we reach a safe place, assume that's not in a string;
482 then step the main scan to the earliest comment-starter seen
483 an even number of string quotes away from the safe place.
485 OFROM[I] is position of the earliest comment-starter seen
486 which is I+2X quotes from the comment-end.
487 PARITY is current parity of quotes from the comment end. */
488 int string_style
= -1; /* Presumed outside of any string. */
489 int string_lossage
= 0;
490 /* Not a real lossage: indicates that we have passed a matching comment
491 starter plus a non-matching comment-ender, meaning that any matching
492 comment-starter we might see later could be a false positive (hidden
493 inside another comment).
494 Test case: { a (* b } c (* d *) */
495 int comment_lossage
= 0;
496 int comment_end
= from
;
497 int comment_end_byte
= from_byte
;
498 int comstart_pos
= 0;
500 /* Place where the containing defun starts,
501 or 0 if we didn't come across it yet. */
503 int defun_start_byte
= 0;
504 register enum syntaxcode code
;
505 int nesting
= 1; /* current comment nesting */
509 /* FIXME: A }} comment-ender style leads to incorrect behavior
510 in the case of {{ c }}} because we ignore the last two chars which are
511 assumed to be comment-enders although they aren't. */
513 /* At beginning of range to scan, we're outside of strings;
514 that determines quote parity to the comment-end. */
517 int temp_byte
, prev_syntax
;
518 int com2start
, com2end
;
520 /* Move back and examine a character. */
521 DEC_BOTH (from
, from_byte
);
522 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
524 prev_syntax
= syntax
;
525 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
526 syntax
= SYNTAX_WITH_FLAGS (c
);
529 /* Check for 2-char comment markers. */
530 com2start
= (SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
531 && SYNTAX_FLAGS_COMSTART_SECOND (prev_syntax
)
532 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax
)
533 && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
)
534 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
);
535 com2end
= (SYNTAX_FLAGS_COMEND_FIRST (syntax
)
536 && SYNTAX_FLAGS_COMEND_SECOND (prev_syntax
));
538 /* Nasty cases with overlapping 2-char comment markers:
539 - snmp-mode: -- c -- foo -- c --
547 /* If a 2-char comment sequence partly overlaps with another,
548 we don't try to be clever. */
549 if (from
> stop
&& (com2end
|| com2start
))
551 int next
= from
, next_byte
= from_byte
, next_c
, next_syntax
;
552 DEC_BOTH (next
, next_byte
);
553 UPDATE_SYNTAX_TABLE_BACKWARD (next
);
554 next_c
= FETCH_CHAR_AS_MULTIBYTE (next_byte
);
555 next_syntax
= SYNTAX_WITH_FLAGS (next_c
);
556 if (((com2start
|| comnested
)
557 && SYNTAX_FLAGS_COMEND_SECOND (syntax
)
558 && SYNTAX_FLAGS_COMEND_FIRST (next_syntax
))
559 || ((com2end
|| comnested
)
560 && SYNTAX_FLAGS_COMSTART_SECOND (syntax
)
561 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
562 && SYNTAX_FLAGS_COMSTART_FIRST (next_syntax
)))
564 /* UPDATE_SYNTAX_TABLE_FORWARD (next + 1); */
567 if (com2start
&& comstart_pos
== 0)
568 /* We're looking at a comment starter. But it might be a comment
569 ender as well (see snmp-mode). The first time we see one, we
570 need to consider it as a comment starter,
571 and the subsequent times as a comment ender. */
574 /* Turn a 2-char comment sequences into the appropriate syntax. */
579 /* Ignore comment starters of a different style. */
580 else if (code
== Scomment
581 && (comstyle
!= SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
582 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
) != comnested
))
585 /* Ignore escaped characters, except comment-enders. */
586 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
593 c
= (code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
);
595 /* Track parity of quotes. */
596 if (string_style
== -1)
597 /* Entering a string. */
599 else if (string_style
== c
)
600 /* Leaving the string. */
603 /* If we have two kinds of string delimiters.
604 There's no way to grok this scanning backwards. */
609 /* We've already checked that it is the relevant comstyle. */
610 if (string_style
!= -1 || comment_lossage
|| string_lossage
)
611 /* There are odd string quotes involved, so let's be careful.
612 Test case in Pascal: " { " a { " } */
617 /* Record best comment-starter so far. */
619 comstart_byte
= from_byte
;
621 else if (--nesting
<= 0)
622 /* nested comments have to be balanced, so we don't need to
623 keep looking for earlier ones. We use here the same (slightly
624 incorrect) reasoning as below: since it is followed by uniform
625 paired string quotes, this comment-start has to be outside of
626 strings, else the comment-end itself would be inside a string. */
631 if (SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == comstyle
632 && ((com2end
&& SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
))
633 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
)
634 /* This is the same style of comment ender as ours. */
639 /* Anything before that can't count because it would match
640 this comment-ender rather than ours. */
641 from
= stop
; /* Break out of the loop. */
643 else if (comstart_pos
!= 0 || c
!= '\n')
644 /* We're mixing comment styles here, so we'd better be careful.
645 The (comstart_pos != 0 || c != '\n') check is not quite correct
646 (we should just always set comment_lossage), but removing it
647 would imply that any multiline comment in C would go through
648 lossage, which seems overkill.
649 The failure should only happen in the rare cases such as
655 /* Assume a defun-start point is outside of strings. */
656 if (open_paren_in_column_0_is_defun_start
658 || (temp_byte
= dec_bytepos (from_byte
),
659 FETCH_CHAR (temp_byte
) == '\n')))
662 defun_start_byte
= from_byte
;
663 from
= stop
; /* Break out of the loop. */
672 if (comstart_pos
== 0)
675 from_byte
= comment_end_byte
;
676 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
678 /* If comstart_pos is set and we get here (ie. didn't jump to `lossage'
679 or `done'), then we've found the beginning of the non-nested comment. */
680 else if (1) /* !comnested */
683 from_byte
= comstart_byte
;
684 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
688 struct lisp_parse_state state
;
690 /* We had two kinds of string delimiters mixed up
691 together. Decode this going forwards.
692 Scan fwd from a known safe place (beginning-of-defun)
693 to the one in question; this records where we
694 last passed a comment starter. */
695 /* If we did not already find the defun start, find it now. */
696 if (defun_start
== 0)
698 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
699 defun_start_byte
= find_start_value_byte
;
703 scan_sexps_forward (&state
,
704 defun_start
, defun_start_byte
,
705 comment_end
, -10000, 0, Qnil
, 0);
706 defun_start
= comment_end
;
707 if (state
.incomment
== (comnested
? 1 : -1)
708 && state
.comstyle
== comstyle
)
709 from
= state
.comstr_start
;
714 /* If comment_end is inside some other comment, maybe ours
715 is nested, so we need to try again from within the
716 surrounding comment. Example: { a (* " *) */
718 /* FIXME: We should advance by one or two chars. */
719 defun_start
= state
.comstr_start
+ 2;
720 defun_start_byte
= CHAR_TO_BYTE (defun_start
);
723 } while (defun_start
< comment_end
);
725 from_byte
= CHAR_TO_BYTE (from
);
726 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
731 *bytepos_ptr
= from_byte
;
733 return (from
== comment_end
) ? -1 : from
;
736 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
737 doc
: /* Return t if OBJECT is a syntax table.
738 Currently, any char-table counts as a syntax table. */)
742 if (CHAR_TABLE_P (object
)
743 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
749 check_syntax_table (obj
)
752 if (!(CHAR_TABLE_P (obj
)
753 && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
)))
754 wrong_type_argument (Qsyntax_table_p
, obj
);
757 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
758 doc
: /* Return the current syntax table.
759 This is the one specified by the current buffer. */)
762 return current_buffer
->syntax_table
;
765 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
766 Sstandard_syntax_table
, 0, 0, 0,
767 doc
: /* Return the standard syntax table.
768 This is the one used for new buffers. */)
771 return Vstandard_syntax_table
;
774 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
775 doc
: /* Construct a new syntax table and return it.
776 It is a copy of the TABLE, which defaults to the standard syntax table. */)
783 check_syntax_table (table
);
785 table
= Vstandard_syntax_table
;
787 copy
= Fcopy_sequence (table
);
789 /* Only the standard syntax table should have a default element.
790 Other syntax tables should inherit from parents instead. */
791 XCHAR_TABLE (copy
)->defalt
= Qnil
;
793 /* Copied syntax tables should all have parents.
794 If we copied one with no parent, such as the standard syntax table,
795 use the standard syntax table as the copy's parent. */
796 if (NILP (XCHAR_TABLE (copy
)->parent
))
797 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
801 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
802 doc
: /* Select a new syntax table for the current buffer.
803 One argument, a syntax table. */)
808 check_syntax_table (table
);
809 current_buffer
->syntax_table
= table
;
810 /* Indicate that this buffer now has a specified syntax table. */
811 idx
= PER_BUFFER_VAR_IDX (syntax_table
);
812 SET_PER_BUFFER_VALUE_P (current_buffer
, idx
, 1);
816 /* Convert a letter which signifies a syntax code
817 into the code it signifies.
818 This is used by modify-syntax-entry, and other things. */
820 unsigned char syntax_spec_code
[0400] =
821 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
822 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
823 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
824 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
825 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
826 (char) Smath
, 0377, 0377, (char) Squote
,
827 (char) Sopen
, (char) Sclose
, 0377, 0377,
828 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
829 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
830 0377, 0377, 0377, 0377,
831 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
832 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
833 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
834 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
835 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
836 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
837 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
838 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
839 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
842 /* Indexed by syntax code, give the letter that describes it. */
844 char syntax_code_spec
[16] =
846 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
850 /* Indexed by syntax code, give the object (cons of syntax code and
851 nil) to be stored in syntax table. Since these objects can be
852 shared among syntax tables, we generate them in advance. By
853 sharing objects, the function `describe-syntax' can give a more
855 static Lisp_Object Vsyntax_code_object
;
858 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
859 doc
: /* Return the syntax code of CHARACTER, described by a character.
860 For example, if CHARACTER is a word constituent,
861 the character `w' is returned.
862 The characters that correspond to various syntax codes
863 are listed in the documentation of `modify-syntax-entry'. */)
865 Lisp_Object character
;
868 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
870 gl_state
.use_global
= 0;
871 CHECK_NUMBER (character
);
872 char_int
= XINT (character
);
873 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
876 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
877 doc
: /* Return the matching parenthesis of CHARACTER, or nil if none. */)
879 Lisp_Object character
;
882 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
883 gl_state
.use_global
= 0;
884 CHECK_NUMBER (character
);
885 char_int
= XINT (character
);
886 code
= SYNTAX (char_int
);
887 if (code
== Sopen
|| code
== Sclose
)
888 return SYNTAX_MATCH (char_int
);
892 DEFUN ("string-to-syntax", Fstring_to_syntax
, Sstring_to_syntax
, 1, 1, 0,
893 doc
: /* Convert a syntax specification STRING into syntax cell form.
894 STRING should be a string as it is allowed as argument of
895 `modify-syntax-entry'. Value is the equivalent cons cell
896 (CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'
901 register const unsigned char *p
;
902 register enum syntaxcode code
;
906 CHECK_STRING (string
);
909 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
910 if (((int) code
& 0377) == 0377)
911 error ("Invalid syntax description letter: %c", p
[-1]);
913 if (code
== Sinherit
)
919 int character
= (STRING_CHAR_AND_LENGTH
920 (p
, SBYTES (string
) - 1, len
));
921 XSETINT (match
, character
);
922 if (XFASTINT (match
) == ' ')
962 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
963 return XVECTOR (Vsyntax_code_object
)->contents
[val
];
965 /* Since we can't use a shared object, let's make a new one. */
966 return Fcons (make_number (val
), match
);
969 /* I really don't know why this is interactive
970 help-form should at least be made useful whilst reading the second arg. */
971 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
972 "cSet syntax for character: \nsSet syntax for %s to: ",
973 doc
: /* Set syntax for character CHAR according to string NEWENTRY.
974 The syntax is changed only for table SYNTAX-TABLE, which defaults to
975 the current buffer's syntax table.
976 CHAR may be a cons (MIN . MAX), in which case, syntaxes of all characters
977 in the range MIN and MAX are changed.
978 The first character of NEWENTRY should be one of the following:
979 Space or - whitespace syntax. w word constituent.
980 _ symbol constituent. . punctuation.
981 ( open-parenthesis. ) close-parenthesis.
982 " string quote. \\ escape.
983 $ paired delimiter. ' expression quote or prefix operator.
984 < comment starter. > comment ender.
985 / character-quote. @ inherit from `standard-syntax-table'.
986 | generic string fence. ! generic comment fence.
988 Only single-character comment start and end sequences are represented thus.
989 Two-character sequences are represented as described below.
990 The second character of NEWENTRY is the matching parenthesis,
991 used only if the first character is `(' or `)'.
992 Any additional characters are flags.
993 Defined flags are the characters 1, 2, 3, 4, b, p, and n.
994 1 means CHAR is the start of a two-char comment start sequence.
995 2 means CHAR is the second character of such a sequence.
996 3 means CHAR is the start of a two-char comment end sequence.
997 4 means CHAR is the second character of such a sequence.
999 There can be up to two orthogonal comment sequences. This is to support
1000 language modes such as C++. By default, all comment sequences are of style
1001 a, but you can set the comment sequence style to b (on the second character
1002 of a comment-start, or the first character of a comment-end sequence) using
1004 b means CHAR is part of comment sequence b.
1005 n means CHAR is part of a nestable comment sequence.
1007 p means CHAR is a prefix character for `backward-prefix-chars';
1008 such characters are treated as whitespace when they occur
1009 between expressions.
1010 usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE) */)
1011 (c
, newentry
, syntax_table
)
1012 Lisp_Object c
, newentry
, syntax_table
;
1016 CHECK_CHARACTER_CAR (c
);
1017 CHECK_CHARACTER_CDR (c
);
1020 CHECK_CHARACTER (c
);
1022 if (NILP (syntax_table
))
1023 syntax_table
= current_buffer
->syntax_table
;
1025 check_syntax_table (syntax_table
);
1027 newentry
= Fstring_to_syntax (newentry
);
1029 SET_RAW_SYNTAX_ENTRY_RANGE (syntax_table
, c
, newentry
);
1031 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), newentry
);
1035 /* Dump syntax table to buffer in human-readable format */
1037 DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value
,
1038 Sinternal_describe_syntax_value
, 1, 1, 0,
1039 doc
: /* Insert a description of the internal syntax description SYNTAX at point. */)
1043 register enum syntaxcode code
;
1044 char desc
, start1
, start2
, end1
, end2
, prefix
, comstyle
, comnested
;
1046 Lisp_Object first
, match_lisp
, value
= syntax
;
1050 insert_string ("default");
1054 if (CHAR_TABLE_P (value
))
1056 insert_string ("deeper char-table ...");
1062 insert_string ("invalid");
1066 first
= XCAR (value
);
1067 match_lisp
= XCDR (value
);
1069 if (!INTEGERP (first
) || !(NILP (match_lisp
) || INTEGERP (match_lisp
)))
1071 insert_string ("invalid");
1075 code
= (enum syntaxcode
) (XINT (first
) & 0377);
1076 start1
= (XINT (first
) >> 16) & 1;
1077 start2
= (XINT (first
) >> 17) & 1;
1078 end1
= (XINT (first
) >> 18) & 1;
1079 end2
= (XINT (first
) >> 19) & 1;
1080 prefix
= (XINT (first
) >> 20) & 1;
1081 comstyle
= (XINT (first
) >> 21) & 1;
1082 comnested
= (XINT (first
) >> 22) & 1;
1084 if ((int) code
< 0 || (int) code
>= (int) Smax
)
1086 insert_string ("invalid");
1089 desc
= syntax_code_spec
[(int) code
];
1091 str
[0] = desc
, str
[1] = 0;
1094 if (NILP (match_lisp
))
1097 insert_char (XINT (match_lisp
));
1116 insert_string ("\twhich means: ");
1118 switch (SWITCH_ENUM_CAST (code
))
1121 insert_string ("whitespace"); break;
1123 insert_string ("punctuation"); break;
1125 insert_string ("word"); break;
1127 insert_string ("symbol"); break;
1129 insert_string ("open"); break;
1131 insert_string ("close"); break;
1133 insert_string ("prefix"); break;
1135 insert_string ("string"); break;
1137 insert_string ("math"); break;
1139 insert_string ("escape"); break;
1141 insert_string ("charquote"); break;
1143 insert_string ("comment"); break;
1145 insert_string ("endcomment"); break;
1147 insert_string ("inherit"); break;
1148 case Scomment_fence
:
1149 insert_string ("comment fence"); break;
1151 insert_string ("string fence"); break;
1153 insert_string ("invalid");
1157 if (!NILP (match_lisp
))
1159 insert_string (", matches ");
1160 insert_char (XINT (match_lisp
));
1164 insert_string (",\n\t is the first character of a comment-start sequence");
1166 insert_string (",\n\t is the second character of a comment-start sequence");
1169 insert_string (",\n\t is the first character of a comment-end sequence");
1171 insert_string (",\n\t is the second character of a comment-end sequence");
1173 insert_string (" (comment style b)");
1175 insert_string (" (nestable)");
1178 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
1183 int parse_sexp_ignore_comments
;
1185 /* Char-table of functions that find the next or previous word
1187 Lisp_Object Vfind_word_boundary_function_table
;
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
;
1202 Lisp_Object func
, script
, pos
;
1207 SETUP_SYNTAX_TABLE (from
, count
);
1218 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1219 ch0
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1220 code
= SYNTAX (ch0
);
1221 INC_BOTH (from
, from_byte
);
1222 if (words_include_escapes
1223 && (code
== Sescape
|| code
== Scharquote
))
1228 /* Now CH0 is a character which begins a word and FROM is the
1229 position of the next character. */
1230 func
= CHAR_TABLE_REF (Vfind_word_boundary_function_table
, ch0
);
1231 if (! NILP (Ffboundp (func
)))
1233 pos
= call2 (func
, make_number (from
- 1), make_number (end
));
1234 if (INTEGERP (pos
) && XINT (pos
) > from
)
1237 from_byte
= CHAR_TO_BYTE (from
);
1242 script
= CHAR_TABLE_REF (Vchar_script_table
, ch0
);
1245 if (from
== end
) break;
1246 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1247 ch1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1248 code
= SYNTAX (ch1
);
1250 && (! words_include_escapes
1251 || (code
!= Sescape
&& code
!= Scharquote
)))
1252 || ! EQ (CHAR_TABLE_REF (Vchar_script_table
, ch1
), script
))
1254 INC_BOTH (from
, from_byte
);
1269 DEC_BOTH (from
, from_byte
);
1270 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1271 ch1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1272 code
= SYNTAX (ch1
);
1273 if (words_include_escapes
1274 && (code
== Sescape
|| code
== Scharquote
))
1279 /* Now CH1 is a character which ends a word and FROM is the
1281 func
= CHAR_TABLE_REF (Vfind_word_boundary_function_table
, ch1
);
1282 if (! NILP (Ffboundp (func
)))
1284 pos
= call2 (func
, make_number (from
), make_number (beg
));
1285 if (INTEGERP (pos
) && XINT (pos
) < from
)
1288 from_byte
= CHAR_TO_BYTE (from
);
1293 script
= CHAR_TABLE_REF (Vchar_script_table
, ch1
);
1300 temp_byte
= dec_bytepos (from_byte
);
1301 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1302 ch0
= FETCH_CHAR_AS_MULTIBYTE (temp_byte
);
1303 code
= SYNTAX (ch0
);
1305 && (! words_include_escapes
1306 || (code
!= Sescape
&& code
!= Scharquote
)))
1307 || ! EQ (CHAR_TABLE_REF (Vchar_script_table
, ch0
), script
))
1309 DEC_BOTH (from
, from_byte
);
1321 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 0, 1, "p",
1322 doc
: /* Move point forward ARG words (backward if ARG is negative).
1324 If an edge of the buffer or a field boundary is reached, point is left there
1325 and the function returns nil. Field boundaries are not noticed if
1326 `inhibit-field-text-motion' is non-nil. */)
1334 XSETFASTINT (arg
, 1);
1338 val
= orig_val
= scan_words (PT
, XINT (arg
));
1340 val
= XINT (arg
) > 0 ? ZV
: BEGV
;
1342 /* Avoid jumping out of an input field. */
1343 tmp
= Fconstrain_to_field (make_number (val
), make_number (PT
),
1345 val
= XFASTINT (tmp
);
1348 return val
== orig_val
? Qt
: Qnil
;
1351 Lisp_Object
skip_chars ();
1353 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1354 doc
: /* Move point forward, stopping before a char not in STRING, or at pos LIM.
1355 STRING is like the inside of a `[...]' in a regular expression
1356 except that `]' is never special and `\\' quotes `^', `-' or `\\'
1357 (but not as the end of a range; quoting is never needed there).
1358 Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
1359 With arg "^a-zA-Z", skips nonletters stopping before first letter.
1360 Char classes, e.g. `[:alpha:]', are supported.
1362 Returns the distance traveled, either zero or positive. */)
1364 Lisp_Object string
, lim
;
1366 return skip_chars (1, string
, lim
, 1);
1369 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1370 doc
: /* Move point backward, stopping after a char not in STRING, or at pos LIM.
1371 See `skip-chars-forward' for details.
1372 Returns the distance traveled, either zero or negative. */)
1374 Lisp_Object string
, lim
;
1376 return skip_chars (0, string
, lim
, 1);
1379 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1380 doc
: /* Move point forward across chars in specified syntax classes.
1381 SYNTAX is a string of syntax code characters.
1382 Stop before a char whose syntax is not in SYNTAX, or at position LIM.
1383 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1384 This function returns the distance traveled, either zero or positive. */)
1386 Lisp_Object syntax
, lim
;
1388 return skip_syntaxes (1, syntax
, lim
);
1391 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1392 doc
: /* Move point backward across chars in specified syntax classes.
1393 SYNTAX is a string of syntax code characters.
1394 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
1395 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1396 This function returns the distance traveled, either zero or negative. */)
1398 Lisp_Object syntax
, lim
;
1400 return skip_syntaxes (0, syntax
, lim
);
1404 skip_chars (forwardp
, string
, lim
, handle_iso_classes
)
1406 Lisp_Object string
, lim
;
1407 int handle_iso_classes
;
1409 register unsigned int c
;
1410 unsigned char fastmap
[0400];
1411 /* Store the ranges of non-ASCII characters. */
1413 int n_char_ranges
= 0;
1415 register int i
, i_byte
;
1416 /* Set to 1 if the current buffer is multibyte and the region
1417 contains non-ASCII chars. */
1419 /* Set to 1 if STRING is multibyte and it contains non-ASCII
1421 int string_multibyte
;
1423 const unsigned char *str
;
1425 Lisp_Object iso_classes
;
1427 CHECK_STRING (string
);
1431 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1433 CHECK_NUMBER_COERCE_MARKER (lim
);
1435 /* In any case, don't allow scan outside bounds of buffer. */
1436 if (XINT (lim
) > ZV
)
1437 XSETFASTINT (lim
, ZV
);
1438 if (XINT (lim
) < BEGV
)
1439 XSETFASTINT (lim
, BEGV
);
1441 multibyte
= (!NILP (current_buffer
->enable_multibyte_characters
)
1442 && (XINT (lim
) - PT
!= CHAR_TO_BYTE (XINT (lim
)) - PT_BYTE
));
1443 string_multibyte
= SBYTES (string
) > SCHARS (string
);
1445 bzero (fastmap
, sizeof fastmap
);
1447 str
= SDATA (string
);
1448 size_byte
= SBYTES (string
);
1451 if (i_byte
< size_byte
1452 && SREF (string
, 0) == '^')
1454 negate
= 1; i_byte
++;
1457 /* Find the characters specified and set their elements of fastmap.
1458 Handle backslashes and ranges specially.
1460 If STRING contains non-ASCII characters, setup char_ranges for
1461 them and use fastmap only for their leading codes. */
1463 if (! string_multibyte
)
1465 int string_has_eight_bit
= 0;
1467 /* At first setup fastmap. */
1468 while (i_byte
< size_byte
)
1472 if (handle_iso_classes
&& c
== '['
1473 && i_byte
< size_byte
1474 && str
[i_byte
] == ':')
1476 const unsigned char *class_beg
= str
+ i_byte
+ 1;
1477 const unsigned char *class_end
= class_beg
;
1478 const unsigned char *class_limit
= str
+ size_byte
- 2;
1479 /* Leave room for the null. */
1480 unsigned char class_name
[CHAR_CLASS_MAX_LENGTH
+ 1];
1483 if (class_limit
- class_beg
> CHAR_CLASS_MAX_LENGTH
)
1484 class_limit
= class_beg
+ CHAR_CLASS_MAX_LENGTH
;
1486 while (class_end
< class_limit
1487 && *class_end
>= 'a' && *class_end
<= 'z')
1490 if (class_end
== class_beg
1491 || *class_end
!= ':' || class_end
[1] != ']')
1492 goto not_a_class_name
;
1494 bcopy (class_beg
, class_name
, class_end
- class_beg
);
1495 class_name
[class_end
- class_beg
] = 0;
1497 cc
= re_wctype (class_name
);
1499 error ("Invalid ISO C character class");
1501 iso_classes
= Fcons (make_number (cc
), iso_classes
);
1503 i_byte
= class_end
+ 2 - str
;
1510 if (i_byte
== size_byte
)
1515 /* Treat `-' as range character only if another character
1517 if (i_byte
+ 1 < size_byte
1518 && str
[i_byte
] == '-')
1522 /* Skip over the dash. */
1525 /* Get the end of the range. */
1528 && i_byte
< size_byte
)
1535 if (! ASCII_CHAR_P (c2
))
1536 string_has_eight_bit
= 1;
1542 if (! ASCII_CHAR_P (c
))
1543 string_has_eight_bit
= 1;
1547 /* If the current range is multibyte and STRING contains
1548 eight-bit chars, arrange fastmap and setup char_ranges for
1549 the corresponding multibyte chars. */
1550 if (multibyte
&& string_has_eight_bit
)
1552 unsigned char fastmap2
[0400];
1553 int range_start_byte
, range_start_char
;
1555 bcopy (fastmap2
+ 0200, fastmap
+ 0200, 0200);
1556 bzero (fastmap
+ 0200, 0200);
1557 /* We are sure that this loop stops. */
1558 for (i
= 0200; ! fastmap2
[i
]; i
++);
1559 c
= unibyte_char_to_multibyte (i
);
1560 fastmap
[CHAR_LEADING_CODE (c
)] = 1;
1561 range_start_byte
= i
;
1562 range_start_char
= c
;
1563 char_ranges
= (int *) alloca (sizeof (int) * 128 * 2);
1564 for (i
= 129; i
< 0400; i
++)
1566 c
= unibyte_char_to_multibyte (i
);
1567 fastmap
[CHAR_LEADING_CODE (c
)] = 1;
1568 if (i
- range_start_byte
!= c
- range_start_char
)
1570 char_ranges
[n_char_ranges
++] = range_start_char
;
1571 char_ranges
[n_char_ranges
++] = ((i
- 1 - range_start_byte
)
1572 + range_start_char
);
1573 range_start_byte
= i
;
1574 range_start_char
= c
;
1577 char_ranges
[n_char_ranges
++] = range_start_char
;
1578 char_ranges
[n_char_ranges
++] = ((i
- 1 - range_start_byte
)
1579 + range_start_char
);
1582 else /* STRING is multibyte */
1584 char_ranges
= (int *) alloca (sizeof (int) * SCHARS (string
) * 2);
1586 while (i_byte
< size_byte
)
1588 unsigned char leading_code
;
1590 leading_code
= str
[i_byte
];
1591 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, size_byte
-i_byte
, len
);
1594 if (handle_iso_classes
&& c
== '['
1595 && i_byte
< size_byte
1596 && STRING_CHAR (str
+ i_byte
, size_byte
- i_byte
) == ':')
1598 const unsigned char *class_beg
= str
+ i_byte
+ 1;
1599 const unsigned char *class_end
= class_beg
;
1600 const unsigned char *class_limit
= str
+ size_byte
- 2;
1601 /* Leave room for the null. */
1602 unsigned char class_name
[CHAR_CLASS_MAX_LENGTH
+ 1];
1605 if (class_limit
- class_beg
> CHAR_CLASS_MAX_LENGTH
)
1606 class_limit
= class_beg
+ CHAR_CLASS_MAX_LENGTH
;
1608 while (class_end
< class_limit
1609 && *class_end
>= 'a' && *class_end
<= 'z')
1612 if (class_end
== class_beg
1613 || *class_end
!= ':' || class_end
[1] != ']')
1614 goto not_a_class_name_multibyte
;
1616 bcopy (class_beg
, class_name
, class_end
- class_beg
);
1617 class_name
[class_end
- class_beg
] = 0;
1619 cc
= re_wctype (class_name
);
1621 error ("Invalid ISO C character class");
1623 iso_classes
= Fcons (make_number (cc
), iso_classes
);
1625 i_byte
= class_end
+ 2 - str
;
1629 not_a_class_name_multibyte
:
1632 if (i_byte
== size_byte
)
1635 leading_code
= str
[i_byte
];
1636 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
,
1637 size_byte
- i_byte
, len
);
1640 /* Treat `-' as range character only if another character
1642 if (i_byte
+ 1 < size_byte
1643 && str
[i_byte
] == '-')
1646 unsigned char leading_code2
;
1648 /* Skip over the dash. */
1651 /* Get the end of the range. */
1652 leading_code2
= str
[i_byte
];
1653 c2
= STRING_CHAR_AND_LENGTH (str
+ i_byte
,
1654 size_byte
- i_byte
, len
);
1658 && i_byte
< size_byte
)
1660 leading_code2
= str
[i_byte
];
1661 c2
=STRING_CHAR_AND_LENGTH (str
+ i_byte
, size_byte
-i_byte
, len
);
1667 if (ASCII_CHAR_P (c
))
1669 while (c
<= c2
&& c
< 0x80)
1671 leading_code
= CHAR_LEADING_CODE (c
);
1673 if (! ASCII_CHAR_P (c
))
1675 while (leading_code
<= leading_code2
)
1676 fastmap
[leading_code
++] = 1;
1679 char_ranges
[n_char_ranges
++] = c
;
1680 char_ranges
[n_char_ranges
++] = c2
;
1686 if (ASCII_CHAR_P (c
))
1690 fastmap
[leading_code
] = 1;
1691 char_ranges
[n_char_ranges
++] = c
;
1692 char_ranges
[n_char_ranges
++] = c
;
1697 /* If the current range is unibyte and STRING contains non-ASCII
1698 chars, arrange fastmap for the corresponding unibyte
1701 if (! multibyte
&& n_char_ranges
> 0)
1703 bzero (fastmap
+ 0200, 0200);
1704 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1706 int c1
= char_ranges
[i
];
1707 int c2
= char_ranges
[i
+ 1];
1709 for (; c1
<= c2
; c1
++)
1710 fastmap
[CHAR_TO_BYTE8 (c1
)] = 1;
1715 /* If ^ was the first character, complement the fastmap. */
1719 for (i
= 0; i
< sizeof fastmap
; i
++)
1723 for (i
= 0; i
< 0200; i
++)
1725 /* All non-ASCII chars possibly match. */
1726 for (; i
< sizeof fastmap
; i
++)
1732 int start_point
= PT
;
1734 int pos_byte
= PT_BYTE
;
1735 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
1739 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
1740 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
1744 endp
= CHAR_POS_ADDR (XINT (lim
));
1745 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
1763 c
= STRING_CHAR_AND_LENGTH (p
, MAX_MULTIBYTE_LENGTH
, nbytes
);
1764 if (! NILP (iso_classes
) && in_classes (c
, iso_classes
))
1774 if (! ASCII_CHAR_P (c
))
1776 /* As we are looking at a multibyte character, we
1777 must look up the character in the table
1778 CHAR_RANGES. If there's no data in the table,
1779 that character is not what we want to skip. */
1781 /* The following code do the right thing even if
1782 n_char_ranges is zero (i.e. no data in
1784 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1785 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1787 if (!(negate
^ (i
< n_char_ranges
)))
1791 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
1804 if (!NILP (iso_classes
) && in_classes (*p
, iso_classes
))
1809 goto fwd_unibyte_ok
;
1815 p
++, pos
++, pos_byte
++;
1823 unsigned char *prev_p
;
1833 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
1834 c
= STRING_CHAR (p
, MAX_MULTIBYTE_LENGTH
);
1836 if (! NILP (iso_classes
) && in_classes (c
, iso_classes
))
1846 if (! ASCII_CHAR_P (c
))
1848 /* See the comment in the previous similar code. */
1849 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1850 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1852 if (!(negate
^ (i
< n_char_ranges
)))
1856 pos
--, pos_byte
-= prev_p
- p
;
1869 if (! NILP (iso_classes
) && in_classes (p
[-1], iso_classes
))
1874 goto back_unibyte_ok
;
1877 if (!fastmap
[p
[-1]])
1880 p
--, pos
--, pos_byte
--;
1884 SET_PT_BOTH (pos
, pos_byte
);
1887 return make_number (PT
- start_point
);
1893 skip_syntaxes (forwardp
, string
, lim
)
1895 Lisp_Object string
, lim
;
1897 register unsigned int c
;
1898 unsigned char fastmap
[0400];
1900 register int i
, i_byte
;
1905 CHECK_STRING (string
);
1908 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1910 CHECK_NUMBER_COERCE_MARKER (lim
);
1912 /* In any case, don't allow scan outside bounds of buffer. */
1913 if (XINT (lim
) > ZV
)
1914 XSETFASTINT (lim
, ZV
);
1915 if (XINT (lim
) < BEGV
)
1916 XSETFASTINT (lim
, BEGV
);
1918 if (forwardp
? (PT
>= XFASTINT (lim
)) : (PT
<= XFASTINT (lim
)))
1919 return make_number (0);
1921 multibyte
= (!NILP (current_buffer
->enable_multibyte_characters
)
1922 && (XINT (lim
) - PT
!= CHAR_TO_BYTE (XINT (lim
)) - PT_BYTE
));
1924 bzero (fastmap
, sizeof fastmap
);
1926 if (SBYTES (string
) > SCHARS (string
))
1927 /* As this is very rare case (syntax spec is ASCII only), don't
1928 consider efficiency. */
1929 string
= string_make_unibyte (string
);
1931 str
= SDATA (string
);
1932 size_byte
= SBYTES (string
);
1935 if (i_byte
< size_byte
1936 && SREF (string
, 0) == '^')
1938 negate
= 1; i_byte
++;
1941 /* Find the syntaxes specified and set their elements of fastmap. */
1943 while (i_byte
< size_byte
)
1946 fastmap
[syntax_spec_code
[c
]] = 1;
1949 /* If ^ was the first character, complement the fastmap. */
1951 for (i
= 0; i
< sizeof fastmap
; i
++)
1955 int start_point
= PT
;
1957 int pos_byte
= PT_BYTE
;
1958 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
1962 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
1963 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
1967 endp
= CHAR_POS_ADDR (XINT (lim
));
1968 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
1972 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1988 c
= STRING_CHAR_AND_LENGTH (p
, MAX_MULTIBYTE_LENGTH
, nbytes
);
1989 if (! fastmap
[(int) SYNTAX (c
)])
1991 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
1992 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
2006 if (! fastmap
[(int) SYNTAX (*p
)])
2008 p
++, pos
++, pos_byte
++;
2009 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
2019 unsigned char *prev_p
;
2029 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
2030 c
= STRING_CHAR (p
, MAX_MULTIBYTE_LENGTH
);
2031 if (! fastmap
[(int) SYNTAX (c
)])
2033 pos
--, pos_byte
-= prev_p
- p
;
2034 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
2048 if (! fastmap
[(int) SYNTAX (p
[-1])])
2050 p
--, pos
--, pos_byte
--;
2051 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
2056 SET_PT_BOTH (pos
, pos_byte
);
2059 return make_number (PT
- start_point
);
2063 /* Return 1 if character C belongs to one of the ISO classes
2064 in the list ISO_CLASSES. Each class is represented by an
2065 integer which is its type according to re_wctype. */
2068 in_classes (c
, iso_classes
)
2070 Lisp_Object iso_classes
;
2074 while (! NILP (iso_classes
))
2077 elt
= XCAR (iso_classes
);
2078 iso_classes
= XCDR (iso_classes
);
2080 if (re_iswctype (c
, XFASTINT (elt
)))
2087 /* Jump over a comment, assuming we are at the beginning of one.
2088 FROM is the current position.
2089 FROM_BYTE is the bytepos corresponding to FROM.
2090 Do not move past STOP (a charpos).
2091 The comment over which we have to jump is of style STYLE
2092 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
2093 NESTING should be positive to indicate the nesting at the beginning
2094 for nested comments and should be zero or negative else.
2095 ST_COMMENT_STYLE cannot be nested.
2096 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
2097 (or 0 If the search cannot start in the middle of a two-character).
2099 If successful, return 1 and store the charpos of the comment's end
2100 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
2101 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
2102 corresponding bytepos into *BYTEPOS_PTR and the current nesting
2103 (as defined for state.incomment) in *INCOMMENT_PTR.
2105 The comment end is the last character of the comment rather than the
2106 character just after the comment.
2108 Global syntax data is assumed to initially be valid for FROM and
2109 remains valid for forward search starting at the returned position. */
2112 forw_comment (from
, from_byte
, stop
, nesting
, style
, prev_syntax
,
2113 charpos_ptr
, bytepos_ptr
, incomment_ptr
)
2114 int from
, from_byte
, stop
;
2115 int nesting
, style
, prev_syntax
;
2116 int *charpos_ptr
, *bytepos_ptr
, *incomment_ptr
;
2119 register enum syntaxcode code
;
2120 register int syntax
;
2122 if (nesting
<= 0) nesting
= -1;
2124 /* Enter the loop in the middle so that we find
2125 a 2-char comment ender if we start in the middle of it. */
2126 syntax
= prev_syntax
;
2127 if (syntax
!= 0) goto forw_incomment
;
2133 *incomment_ptr
= nesting
;
2134 *charpos_ptr
= from
;
2135 *bytepos_ptr
= from_byte
;
2138 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2139 syntax
= SYNTAX_WITH_FLAGS (c
);
2140 code
= syntax
& 0xff;
2141 if (code
== Sendcomment
2142 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
2143 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ?
2144 (nesting
> 0 && --nesting
== 0) : nesting
< 0))
2145 /* we have encountered a comment end of the same style
2146 as the comment sequence which began this comment
2149 if (code
== Scomment_fence
2150 && style
== ST_COMMENT_STYLE
)
2151 /* we have encountered a comment end of the same style
2152 as the comment sequence which began this comment
2157 && SYNTAX_FLAGS_COMMENT_NESTED (syntax
)
2158 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
)
2159 /* we have encountered a nested comment of the same style
2160 as the comment sequence which began this comment section */
2162 INC_BOTH (from
, from_byte
);
2163 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2166 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
2167 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
2168 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2169 SYNTAX_COMEND_SECOND (c1
))
2170 && ((SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
2171 SYNTAX_COMMENT_NESTED (c1
)) ? nesting
> 0 : nesting
< 0))
2174 /* we have encountered a comment end of the same style
2175 as the comment sequence which began this comment
2180 INC_BOTH (from
, from_byte
);
2181 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2186 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
2187 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2188 SYNTAX_COMMENT_STYLE (c1
) == style
2189 && SYNTAX_COMSTART_SECOND (c1
))
2190 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
2191 SYNTAX_COMMENT_NESTED (c1
)))
2192 /* we have encountered a nested comment of the same style
2193 as the comment sequence which began this comment
2196 INC_BOTH (from
, from_byte
);
2197 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2201 *charpos_ptr
= from
;
2202 *bytepos_ptr
= from_byte
;
2206 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
2208 Move forward across up to COUNT comments. If COUNT is negative, move backward.
2209 Stop scanning if we find something other than a comment or whitespace.
2210 Set point to where scanning stops.
2211 If COUNT comments are found as expected, with nothing except whitespace
2212 between them, return t; otherwise return nil. */)
2220 register enum syntaxcode code
;
2221 int comstyle
= 0; /* style of comment encountered */
2222 int comnested
= 0; /* whether the comment is nestable or not */
2225 int out_charpos
, out_bytepos
;
2228 CHECK_NUMBER (count
);
2229 count1
= XINT (count
);
2230 stop
= count1
> 0 ? ZV
: BEGV
;
2236 from_byte
= PT_BYTE
;
2238 SETUP_SYNTAX_TABLE (from
, count1
);
2247 SET_PT_BOTH (from
, from_byte
);
2251 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2253 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2254 comnested
= SYNTAX_COMMENT_NESTED (c
);
2255 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2256 INC_BOTH (from
, from_byte
);
2257 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2258 if (from
< stop
&& comstart_first
2259 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2260 SYNTAX_COMSTART_SECOND (c1
)))
2262 /* We have encountered a comment start sequence and we
2263 are ignoring all text inside comments. We must record
2264 the comment style this sequence begins so that later,
2265 only a comment end of the same style actually ends
2266 the comment section. */
2268 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2269 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2270 INC_BOTH (from
, from_byte
);
2271 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2274 while (code
== Swhitespace
|| (code
== Sendcomment
&& c
== '\n'));
2276 if (code
== Scomment_fence
)
2277 comstyle
= ST_COMMENT_STYLE
;
2278 else if (code
!= Scomment
)
2281 DEC_BOTH (from
, from_byte
);
2282 SET_PT_BOTH (from
, from_byte
);
2285 /* We're at the start of a comment. */
2286 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
2287 &out_charpos
, &out_bytepos
, &dummy
);
2288 from
= out_charpos
; from_byte
= out_bytepos
;
2292 SET_PT_BOTH (from
, from_byte
);
2295 INC_BOTH (from
, from_byte
);
2296 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2297 /* We have skipped one comment. */
2309 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
2314 DEC_BOTH (from
, from_byte
);
2315 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
2316 quoted
= char_quoted (from
, from_byte
);
2317 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2320 comnested
= SYNTAX_COMMENT_NESTED (c
);
2321 if (code
== Sendcomment
)
2322 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2323 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2324 && prev_char_comend_first (from
, from_byte
)
2325 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
2327 /* We must record the comment style encountered so that
2328 later, we can match only the proper comment begin
2329 sequence of the same style. */
2330 DEC_BOTH (from
, from_byte
);
2332 /* Calling char_quoted, above, set up global syntax position
2333 at the new value of FROM. */
2334 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2335 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2336 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2339 if (code
== Scomment_fence
)
2341 /* Skip until first preceding unquoted comment_fence. */
2342 int found
= 0, ini
= from
, ini_byte
= from_byte
;
2346 DEC_BOTH (from
, from_byte
);
2349 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2350 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2351 if (SYNTAX (c
) == Scomment_fence
2352 && !char_quoted (from
, from_byte
))
2360 from
= ini
; /* Set point to ini + 1. */
2361 from_byte
= ini_byte
;
2365 else if (code
== Sendcomment
)
2367 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2368 &out_charpos
, &out_bytepos
);
2372 /* This end-of-line is not an end-of-comment.
2373 Treat it like a whitespace.
2374 CC-mode (and maybe others) relies on this behavior. */
2378 /* Failure: we should go back to the end of this
2379 not-quite-endcomment. */
2380 if (SYNTAX(c
) != code
)
2381 /* It was a two-char Sendcomment. */
2382 INC_BOTH (from
, from_byte
);
2388 /* We have skipped one comment. */
2389 from
= out_charpos
, from_byte
= out_bytepos
;
2393 else if (code
!= Swhitespace
|| quoted
)
2397 INC_BOTH (from
, from_byte
);
2398 SET_PT_BOTH (from
, from_byte
);
2406 SET_PT_BOTH (from
, from_byte
);
2411 /* Return syntax code of character C if C is an ASCII character
2412 or `multibyte_symbol_p' is zero. Otherwise, return Ssymbol. */
2414 #define SYNTAX_WITH_MULTIBYTE_CHECK(c) \
2415 ((ASCII_CHAR_P (c) || !multibyte_symbol_p) \
2416 ? SYNTAX (c) : Ssymbol)
2419 scan_lists (from
, count
, depth
, sexpflag
)
2421 int count
, depth
, sexpflag
;
2424 register int stop
= count
> 0 ? ZV
: BEGV
;
2429 register enum syntaxcode code
, temp_code
;
2430 int min_depth
= depth
; /* Err out if depth gets less than this. */
2431 int comstyle
= 0; /* style of comment encountered */
2432 int comnested
= 0; /* whether the comment is nestable or not */
2434 int last_good
= from
;
2437 int out_bytepos
, out_charpos
;
2439 int multibyte_symbol_p
= sexpflag
&& multibyte_syntax_as_symbol
;
2441 if (depth
> 0) min_depth
= 0;
2443 if (from
> ZV
) from
= ZV
;
2444 if (from
< BEGV
) from
= BEGV
;
2446 from_byte
= CHAR_TO_BYTE (from
);
2451 SETUP_SYNTAX_TABLE (from
, count
);
2456 int comstart_first
, prefix
;
2457 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2458 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2459 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2460 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2461 comnested
= SYNTAX_COMMENT_NESTED (c
);
2462 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2463 prefix
= SYNTAX_PREFIX (c
);
2464 if (depth
== min_depth
)
2466 INC_BOTH (from
, from_byte
);
2467 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2468 if (from
< stop
&& comstart_first
2469 && (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2470 SYNTAX_COMSTART_SECOND (c
))
2471 && parse_sexp_ignore_comments
)
2473 /* we have encountered a comment start sequence and we
2474 are ignoring all text inside comments. We must record
2475 the comment style this sequence begins so that later,
2476 only a comment end of the same style actually ends
2477 the comment section */
2479 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2480 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2481 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2482 INC_BOTH (from
, from_byte
);
2483 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2489 switch (SWITCH_ENUM_CAST (code
))
2493 if (from
== stop
) goto lose
;
2494 INC_BOTH (from
, from_byte
);
2495 /* treat following character as a word constituent */
2498 if (depth
|| !sexpflag
) break;
2499 /* This word counts as a sexp; return at end of it. */
2502 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2504 /* Some compilers can't handle this inside the switch. */
2505 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2506 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2511 INC_BOTH (from
, from_byte
);
2512 if (from
== stop
) goto lose
;
2521 INC_BOTH (from
, from_byte
);
2525 case Scomment_fence
:
2526 comstyle
= ST_COMMENT_STYLE
;
2529 if (!parse_sexp_ignore_comments
) break;
2530 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2531 found
= forw_comment (from
, from_byte
, stop
,
2532 comnested
, comstyle
, 0,
2533 &out_charpos
, &out_bytepos
, &dummy
);
2534 from
= out_charpos
, from_byte
= out_bytepos
;
2541 INC_BOTH (from
, from_byte
);
2542 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2548 if (from
!= stop
&& c
== FETCH_CHAR_AS_MULTIBYTE (from_byte
))
2550 INC_BOTH (from
, from_byte
);
2560 if (!++depth
) goto done
;
2565 if (!--depth
) goto done
;
2566 if (depth
< min_depth
)
2567 Fsignal (Qscan_error
,
2568 Fcons (build_string ("Containing expression ends prematurely"),
2569 Fcons (make_number (last_good
),
2570 Fcons (make_number (from
), Qnil
))));
2575 temp_pos
= dec_bytepos (from_byte
);
2576 stringterm
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2579 if (from
>= stop
) goto lose
;
2580 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2581 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2584 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2585 : SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring_fence
)
2588 /* Some compilers can't handle this inside the switch. */
2589 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2594 INC_BOTH (from
, from_byte
);
2596 INC_BOTH (from
, from_byte
);
2598 INC_BOTH (from
, from_byte
);
2599 if (!depth
&& sexpflag
) goto done
;
2602 /* Ignore whitespace, punctuation, quote, endcomment. */
2607 /* Reached end of buffer. Error if within object, return nil if between */
2608 if (depth
) goto lose
;
2613 /* End of object reached */
2622 DEC_BOTH (from
, from_byte
);
2623 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2624 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2625 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2626 if (depth
== min_depth
)
2629 comnested
= SYNTAX_COMMENT_NESTED (c
);
2630 if (code
== Sendcomment
)
2631 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2632 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2633 && prev_char_comend_first (from
, from_byte
)
2634 && parse_sexp_ignore_comments
)
2636 /* We must record the comment style encountered so that
2637 later, we can match only the proper comment begin
2638 sequence of the same style. */
2639 DEC_BOTH (from
, from_byte
);
2640 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2642 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2643 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2644 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2647 /* Quoting turns anything except a comment-ender
2648 into a word character. Note that this cannot be true
2649 if we decremented FROM in the if-statement above. */
2650 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2652 DEC_BOTH (from
, from_byte
);
2655 else if (SYNTAX_PREFIX (c
))
2658 switch (SWITCH_ENUM_CAST (code
))
2664 if (depth
|| !sexpflag
) break;
2665 /* This word counts as a sexp; count object finished
2666 after passing it. */
2669 temp_pos
= from_byte
;
2670 if (! NILP (current_buffer
->enable_multibyte_characters
))
2674 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2675 c1
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2676 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2677 /* Don't allow comment-end to be quoted. */
2678 if (temp_code
== Sendcomment
)
2680 quoted
= char_quoted (from
- 1, temp_pos
);
2683 DEC_BOTH (from
, from_byte
);
2684 temp_pos
= dec_bytepos (temp_pos
);
2685 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2687 c1
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2688 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2689 if (! (quoted
|| temp_code
== Sword
2690 || temp_code
== Ssymbol
2691 || temp_code
== Squote
))
2693 DEC_BOTH (from
, from_byte
);
2700 temp_pos
= dec_bytepos (from_byte
);
2701 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2702 if (from
!= stop
&& c
== FETCH_CHAR_AS_MULTIBYTE (temp_pos
))
2703 DEC_BOTH (from
, from_byte
);
2712 if (!++depth
) goto done2
;
2717 if (!--depth
) goto done2
;
2718 if (depth
< min_depth
)
2719 Fsignal (Qscan_error
,
2720 Fcons (build_string ("Containing expression ends prematurely"),
2721 Fcons (make_number (last_good
),
2722 Fcons (make_number (from
), Qnil
))));
2726 if (!parse_sexp_ignore_comments
)
2728 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2729 &out_charpos
, &out_bytepos
);
2730 /* FIXME: if found == -1, then it really wasn't a comment-end.
2731 For single-char Sendcomment, we can't do much about it apart
2732 from skipping the char.
2733 For 2-char endcomments, we could try again, taking both
2734 chars as separate entities, but it's a lot of trouble
2735 for very little gain, so we don't bother either. -sm */
2737 from
= out_charpos
, from_byte
= out_bytepos
;
2740 case Scomment_fence
:
2744 if (from
== stop
) goto lose
;
2745 DEC_BOTH (from
, from_byte
);
2746 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2747 if (!char_quoted (from
, from_byte
)
2748 && (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2749 SYNTAX_WITH_MULTIBYTE_CHECK (c
) == code
))
2752 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2756 stringterm
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2759 if (from
== stop
) goto lose
;
2760 DEC_BOTH (from
, from_byte
);
2761 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2762 if (!char_quoted (from
, from_byte
)
2764 == (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
)))
2765 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2768 if (!depth
&& sexpflag
) goto done2
;
2771 /* Ignore whitespace, punctuation, quote, endcomment. */
2776 /* Reached start of buffer. Error if within object, return nil if between */
2777 if (depth
) goto lose
;
2788 XSETFASTINT (val
, from
);
2792 Fsignal (Qscan_error
,
2793 Fcons (build_string ("Unbalanced parentheses"),
2794 Fcons (make_number (last_good
),
2795 Fcons (make_number (from
), Qnil
))));
2800 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2801 doc
: /* Scan from character number FROM by COUNT lists.
2802 Returns the character number of the position thus found.
2804 If DEPTH is nonzero, paren depth begins counting from that value,
2805 only places where the depth in parentheses becomes zero
2806 are candidates for stopping; COUNT such places are counted.
2807 Thus, a positive value for DEPTH means go out levels.
2809 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2811 If the beginning or end of (the accessible part of) the buffer is reached
2812 and the depth is wrong, an error is signaled.
2813 If the depth is right but the count is not used up, nil is returned. */)
2814 (from
, count
, depth
)
2815 Lisp_Object from
, count
, depth
;
2817 CHECK_NUMBER (from
);
2818 CHECK_NUMBER (count
);
2819 CHECK_NUMBER (depth
);
2821 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2824 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2825 doc
: /* Scan from character number FROM by COUNT balanced expressions.
2826 If COUNT is negative, scan backwards.
2827 Returns the character number of the position thus found.
2829 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2831 If the beginning or end of (the accessible part of) the buffer is reached
2832 in the middle of a parenthetical grouping, an error is signaled.
2833 If the beginning or end is reached between groupings
2834 but before count is used up, nil is returned. */)
2836 Lisp_Object from
, count
;
2838 CHECK_NUMBER (from
);
2839 CHECK_NUMBER (count
);
2841 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2844 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2846 doc
: /* Move point backward over any number of chars with prefix syntax.
2847 This includes chars with "quote" or "prefix" syntax (' or p). */)
2852 int opoint_byte
= PT_BYTE
;
2854 int pos_byte
= PT_BYTE
;
2859 SET_PT_BOTH (opoint
, opoint_byte
);
2864 SETUP_SYNTAX_TABLE (pos
, -1);
2866 DEC_BOTH (pos
, pos_byte
);
2868 while (!char_quoted (pos
, pos_byte
)
2869 /* Previous statement updates syntax table. */
2870 && ((c
= FETCH_CHAR_AS_MULTIBYTE (pos_byte
), SYNTAX (c
) == Squote
)
2871 || SYNTAX_PREFIX (c
)))
2874 opoint_byte
= pos_byte
;
2877 DEC_BOTH (pos
, pos_byte
);
2880 SET_PT_BOTH (opoint
, opoint_byte
);
2885 /* Parse forward from FROM / FROM_BYTE to END,
2886 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2887 and return a description of the state of the parse at END.
2888 If STOPBEFORE is nonzero, stop at the start of an atom.
2889 If COMMENTSTOP is 1, stop at the start of a comment.
2890 If COMMENTSTOP is -1, stop at the start or end of a comment,
2891 after the beginning of a string, or after the end of a string. */
2894 scan_sexps_forward (stateptr
, from
, from_byte
, end
, targetdepth
,
2895 stopbefore
, oldstate
, commentstop
)
2896 struct lisp_parse_state
*stateptr
;
2899 int end
, targetdepth
, stopbefore
;
2900 Lisp_Object oldstate
;
2903 struct lisp_parse_state state
;
2905 register enum syntaxcode code
;
2908 struct level
{ int last
, prev
; };
2909 struct level levelstart
[100];
2910 register struct level
*curlevel
= levelstart
;
2911 struct level
*endlevel
= levelstart
+ 100;
2912 register int depth
; /* Paren depth of current scanning location.
2913 level - levelstart equals this except
2914 when the depth becomes negative. */
2915 int mindepth
; /* Lowest DEPTH value seen. */
2916 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2918 int prev_from
; /* Keep one character before FROM. */
2920 int prev_from_syntax
;
2921 int boundary_stop
= commentstop
== -1;
2924 int out_bytepos
, out_charpos
;
2928 prev_from_byte
= from_byte
;
2930 DEC_BOTH (prev_from
, prev_from_byte
);
2932 /* Use this macro instead of `from++'. */
2934 do { prev_from = from; \
2935 prev_from_byte = from_byte; \
2936 temp = FETCH_CHAR_AS_MULTIBYTE (prev_from_byte); \
2937 prev_from_syntax = SYNTAX_WITH_FLAGS (temp); \
2938 INC_BOTH (from, from_byte); \
2940 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2946 if (NILP (oldstate
))
2949 state
.instring
= -1;
2950 state
.incomment
= 0;
2951 state
.comstyle
= 0; /* comment style a by default. */
2952 state
.comstr_start
= -1; /* no comment/string seen. */
2956 tem
= Fcar (oldstate
);
2962 oldstate
= Fcdr (oldstate
);
2963 oldstate
= Fcdr (oldstate
);
2964 oldstate
= Fcdr (oldstate
);
2965 tem
= Fcar (oldstate
);
2966 /* Check whether we are inside string_fence-style string: */
2967 state
.instring
= (!NILP (tem
)
2968 ? (INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2971 oldstate
= Fcdr (oldstate
);
2972 tem
= Fcar (oldstate
);
2973 state
.incomment
= (!NILP (tem
)
2974 ? (INTEGERP (tem
) ? XINT (tem
) : -1)
2977 oldstate
= Fcdr (oldstate
);
2978 tem
= Fcar (oldstate
);
2979 start_quoted
= !NILP (tem
);
2981 /* if the eighth element of the list is nil, we are in comment
2982 style a. If it is non-nil, we are in comment style b */
2983 oldstate
= Fcdr (oldstate
);
2984 oldstate
= Fcdr (oldstate
);
2985 tem
= Fcar (oldstate
);
2986 state
.comstyle
= NILP (tem
) ? 0 : (EQ (tem
, Qsyntax_table
)
2987 ? ST_COMMENT_STYLE
: 1);
2989 oldstate
= Fcdr (oldstate
);
2990 tem
= Fcar (oldstate
);
2991 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2992 oldstate
= Fcdr (oldstate
);
2993 tem
= Fcar (oldstate
);
2994 while (!NILP (tem
)) /* >= second enclosing sexps. */
2996 /* curlevel++->last ran into compiler bug on Apollo */
2997 curlevel
->last
= XINT (Fcar (tem
));
2998 if (++curlevel
== endlevel
)
2999 curlevel
--; /* error ("Nesting too deep for parser"); */
3000 curlevel
->prev
= -1;
3001 curlevel
->last
= -1;
3008 curlevel
->prev
= -1;
3009 curlevel
->last
= -1;
3011 SETUP_SYNTAX_TABLE (prev_from
, 1);
3012 temp
= FETCH_CHAR (prev_from_byte
);
3013 prev_from_syntax
= SYNTAX_WITH_FLAGS (temp
);
3014 UPDATE_SYNTAX_TABLE_FORWARD (from
);
3016 /* Enter the loop at a place appropriate for initial state. */
3018 if (state
.incomment
)
3019 goto startincomment
;
3020 if (state
.instring
>= 0)
3022 nofence
= state
.instring
!= ST_STRING_STYLE
;
3024 goto startquotedinstring
;
3027 else if (start_quoted
)
3033 code
= prev_from_syntax
& 0xff;
3036 && SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
)
3037 && (c1
= FETCH_CHAR (from_byte
),
3038 SYNTAX_COMSTART_SECOND (c1
)))
3039 /* Duplicate code to avoid a complex if-expression
3040 which causes trouble for the SGI compiler. */
3042 /* Record the comment style we have entered so that only
3043 the comment-end sequence of the same style actually
3044 terminates the comment section. */
3045 state
.comstyle
= SYNTAX_COMMENT_STYLE (c1
);
3046 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
);
3047 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
3048 state
.incomment
= comnested
? 1 : -1;
3049 state
.comstr_start
= prev_from
;
3053 else if (code
== Scomment_fence
)
3055 /* Record the comment style we have entered so that only
3056 the comment-end sequence of the same style actually
3057 terminates the comment section. */
3058 state
.comstyle
= ST_COMMENT_STYLE
;
3059 state
.incomment
= -1;
3060 state
.comstr_start
= prev_from
;
3063 else if (code
== Scomment
)
3065 state
.comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax
);
3066 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
3068 state
.comstr_start
= prev_from
;
3071 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
3073 switch (SWITCH_ENUM_CAST (code
))
3077 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3078 curlevel
->last
= prev_from
;
3080 if (from
== end
) goto endquoted
;
3083 /* treat following character as a word constituent */
3086 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3087 curlevel
->last
= prev_from
;
3091 /* Some compilers can't handle this inside the switch. */
3092 temp
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
3093 temp
= SYNTAX (temp
);
3099 if (from
== end
) goto endquoted
;
3111 curlevel
->prev
= curlevel
->last
;
3114 case Scomment_fence
: /* Can't happen because it's handled above. */
3116 if (commentstop
|| boundary_stop
) goto done
;
3118 /* The (from == BEGV) test was to enter the loop in the middle so
3119 that we find a 2-char comment ender even if we start in the
3120 middle of it. We don't want to do that if we're just at the
3121 beginning of the comment (think of (*) ... (*)). */
3122 found
= forw_comment (from
, from_byte
, end
,
3123 state
.incomment
, state
.comstyle
,
3124 (from
== BEGV
|| from
< state
.comstr_start
+ 3)
3125 ? 0 : prev_from_syntax
,
3126 &out_charpos
, &out_bytepos
, &state
.incomment
);
3127 from
= out_charpos
; from_byte
= out_bytepos
;
3128 /* Beware! prev_from and friends are invalid now.
3129 Luckily, the `done' doesn't use them and the INC_FROM
3130 sets them to a sane value without looking at them. */
3131 if (!found
) goto done
;
3133 state
.incomment
= 0;
3134 state
.comstyle
= 0; /* reset the comment style */
3135 if (boundary_stop
) goto done
;
3139 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3141 /* curlevel++->last ran into compiler bug on Apollo */
3142 curlevel
->last
= prev_from
;
3143 if (++curlevel
== endlevel
)
3144 curlevel
--; /* error ("Nesting too deep for parser"); */
3145 curlevel
->prev
= -1;
3146 curlevel
->last
= -1;
3147 if (targetdepth
== depth
) goto done
;
3152 if (depth
< mindepth
)
3154 if (curlevel
!= levelstart
)
3156 curlevel
->prev
= curlevel
->last
;
3157 if (targetdepth
== depth
) goto done
;
3162 state
.comstr_start
= from
- 1;
3163 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3164 curlevel
->last
= prev_from
;
3165 state
.instring
= (code
== Sstring
3166 ? (FETCH_CHAR_AS_MULTIBYTE (prev_from_byte
))
3168 if (boundary_stop
) goto done
;
3171 nofence
= state
.instring
!= ST_STRING_STYLE
;
3177 if (from
>= end
) goto done
;
3178 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
3179 /* Some compilers can't handle this inside the switch. */
3182 /* Check TEMP here so that if the char has
3183 a syntax-table property which says it is NOT
3184 a string character, it does not end the string. */
3185 if (nofence
&& c
== state
.instring
&& temp
== Sstring
)
3191 if (!nofence
) goto string_end
;
3196 startquotedinstring
:
3197 if (from
>= end
) goto endquoted
;
3203 state
.instring
= -1;
3204 curlevel
->prev
= curlevel
->last
;
3206 if (boundary_stop
) goto done
;
3210 /* FIXME: We should do something with it. */
3213 /* Ignore whitespace, punctuation, quote, endcomment. */
3219 stop
: /* Here if stopping before start of sexp. */
3220 from
= prev_from
; /* We have just fetched the char that starts it; */
3221 goto done
; /* but return the position before it. */
3226 state
.depth
= depth
;
3227 state
.mindepth
= mindepth
;
3228 state
.thislevelstart
= curlevel
->prev
;
3229 state
.prevlevelstart
3230 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
3231 state
.location
= from
;
3232 state
.levelstarts
= Qnil
;
3233 while (--curlevel
>= levelstart
)
3234 state
.levelstarts
= Fcons (make_number (curlevel
->last
),
3241 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
3242 doc
: /* Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
3243 Parsing stops at TO or when certain criteria are met;
3244 point is set to where parsing stops.
3245 If fifth arg OLDSTATE is omitted or nil,
3246 parsing assumes that FROM is the beginning of a function.
3247 Value is a list of elements describing final state of parsing:
3249 1. character address of start of innermost containing list; nil if none.
3250 2. character address of start of last complete sexp terminated.
3251 3. non-nil if inside a string.
3252 (it is the character that will terminate the string,
3253 or t if the string should be terminated by a generic string delimiter.)
3254 4. nil if outside a comment, t if inside a non-nestable comment,
3255 else an integer (the current comment nesting).
3256 5. t if following a quote character.
3257 6. the minimum paren-depth encountered during this scan.
3258 7. t if in a comment of style b; symbol `syntax-table' if the comment
3259 should be terminated by a generic comment delimiter.
3260 8. character address of start of comment or string; nil if not in one.
3261 9. Intermediate data for continuation of parsing (subject to change).
3262 If third arg TARGETDEPTH is non-nil, parsing stops if the depth
3263 in parentheses becomes equal to TARGETDEPTH.
3264 Fourth arg STOPBEFORE non-nil means stop when come to
3265 any character that starts a sexp.
3266 Fifth arg OLDSTATE is a list like what this function returns.
3267 It is used to initialize the state of the parse. Elements number 1, 2, 6
3268 and 8 are ignored; you can leave off element 8 (the last) entirely.
3269 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
3270 If it is symbol `syntax-table', stop after the start of a comment or a
3271 string, or after end of a comment or a string. */)
3272 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
3273 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
3275 struct lisp_parse_state state
;
3278 if (!NILP (targetdepth
))
3280 CHECK_NUMBER (targetdepth
);
3281 target
= XINT (targetdepth
);
3284 target
= -100000; /* We won't reach this depth */
3286 validate_region (&from
, &to
);
3287 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
3289 target
, !NILP (stopbefore
), oldstate
,
3291 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
3293 SET_PT (state
.location
);
3295 return Fcons (make_number (state
.depth
),
3296 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
3297 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
3298 Fcons (state
.instring
>= 0
3299 ? (state
.instring
== ST_STRING_STYLE
3300 ? Qt
: make_number (state
.instring
)) : Qnil
,
3301 Fcons (state
.incomment
< 0 ? Qt
:
3302 (state
.incomment
== 0 ? Qnil
:
3303 make_number (state
.incomment
)),
3304 Fcons (state
.quoted
? Qt
: Qnil
,
3305 Fcons (make_number (state
.mindepth
),
3306 Fcons ((state
.comstyle
3307 ? (state
.comstyle
== ST_COMMENT_STYLE
3308 ? Qsyntax_table
: Qt
) :
3310 Fcons (((state
.incomment
3311 || (state
.instring
>= 0))
3312 ? make_number (state
.comstr_start
)
3314 Fcons (state
.levelstarts
, Qnil
))))))))));
3323 /* This has to be done here, before we call Fmake_char_table. */
3324 Qsyntax_table
= intern ("syntax-table");
3325 staticpro (&Qsyntax_table
);
3327 /* Intern this now in case it isn't already done.
3328 Setting this variable twice is harmless.
3329 But don't staticpro it here--that is done in alloc.c. */
3330 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
3332 /* Create objects which can be shared among syntax tables. */
3333 Vsyntax_code_object
= Fmake_vector (make_number (Smax
), Qnil
);
3334 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
3335 XVECTOR (Vsyntax_code_object
)->contents
[i
]
3336 = Fcons (make_number (i
), Qnil
);
3338 /* Now we are ready to set up this property, so we can
3339 create syntax tables. */
3340 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
3342 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
3344 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
3346 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
3347 for (i
= 'a'; i
<= 'z'; i
++)
3348 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3349 for (i
= 'A'; i
<= 'Z'; i
++)
3350 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3351 for (i
= '0'; i
<= '9'; i
++)
3352 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3354 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
3355 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
3357 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
3358 Fcons (make_number (Sopen
), make_number (')')));
3359 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
3360 Fcons (make_number (Sclose
), make_number ('(')));
3361 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
3362 Fcons (make_number (Sopen
), make_number (']')));
3363 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
3364 Fcons (make_number (Sclose
), make_number ('[')));
3365 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
3366 Fcons (make_number (Sopen
), make_number ('}')));
3367 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
3368 Fcons (make_number (Sclose
), make_number ('{')));
3369 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
3370 Fcons (make_number ((int) Sstring
), Qnil
));
3371 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
3372 Fcons (make_number ((int) Sescape
), Qnil
));
3374 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
3375 for (i
= 0; i
< 10; i
++)
3377 c
= "_-+*/&|<>="[i
];
3378 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3381 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
3382 for (i
= 0; i
< 12; i
++)
3384 c
= ".,;:?!#@~^'`"[i
];
3385 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3388 /* All multibyte characters have syntax `word' by default. */
3389 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
3390 char_table_set_range (Vstandard_syntax_table
, 0x80, MAX_CHAR
, temp
);
3396 Qsyntax_table_p
= intern ("syntax-table-p");
3397 staticpro (&Qsyntax_table_p
);
3399 staticpro (&Vsyntax_code_object
);
3401 staticpro (&gl_state
.object
);
3402 staticpro (&gl_state
.global_code
);
3403 staticpro (&gl_state
.current_syntax_table
);
3404 staticpro (&gl_state
.old_prop
);
3406 /* Defined in regex.c */
3407 staticpro (&re_match_object
);
3409 Qscan_error
= intern ("scan-error");
3410 staticpro (&Qscan_error
);
3411 Fput (Qscan_error
, Qerror_conditions
,
3412 Fcons (Qscan_error
, Fcons (Qerror
, Qnil
)));
3413 Fput (Qscan_error
, Qerror_message
,
3414 build_string ("Scan error"));
3416 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
3417 doc
: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace. */);
3419 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
3420 doc
: /* Non-nil means `forward-sexp', etc., obey `syntax-table' property.
3421 Otherwise, that text property is simply ignored.
3422 See the info node `(elisp)Syntax Properties' for a description of the
3423 `syntax-table' property. */);
3425 words_include_escapes
= 0;
3426 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
3427 doc
: /* Non-nil means `forward-word', etc., should treat escape chars part of words. */);
3429 DEFVAR_BOOL ("multibyte-syntax-as-symbol", &multibyte_syntax_as_symbol
,
3430 doc
: /* Non-nil means `scan-sexps' treats all multibyte characters as symbol. */);
3431 multibyte_syntax_as_symbol
= 0;
3433 DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
3434 &open_paren_in_column_0_is_defun_start
,
3435 doc
: /* *Non-nil means an open paren in column 0 denotes the start of a defun. */);
3436 open_paren_in_column_0_is_defun_start
= 1;
3439 DEFVAR_LISP ("find-word-boundary-function-table",
3440 &Vfind_word_boundary_function_table
,
3442 Char table of functions to search for the word boundary.
3443 Each function is called with two arguments; POS and LIMIT.
3444 POS and LIMIT are character positions in the current buffer.
3446 If POS is less than LIMIT, POS is at the first character of a word,
3447 and the return value of a function is a position after the last
3448 character of that word.
3450 If POS is not less than LIMIT, POS is at the last character of a word,
3451 and the return value of a function is a position at the first
3452 character of that word.
3454 In both cases, LIMIT bounds the search. */);
3455 Vfind_word_boundary_function_table
= Fmake_char_table (Qnil
, Qnil
);
3457 defsubr (&Ssyntax_table_p
);
3458 defsubr (&Ssyntax_table
);
3459 defsubr (&Sstandard_syntax_table
);
3460 defsubr (&Scopy_syntax_table
);
3461 defsubr (&Sset_syntax_table
);
3462 defsubr (&Schar_syntax
);
3463 defsubr (&Smatching_paren
);
3464 defsubr (&Sstring_to_syntax
);
3465 defsubr (&Smodify_syntax_entry
);
3466 defsubr (&Sinternal_describe_syntax_value
);
3468 defsubr (&Sforward_word
);
3470 defsubr (&Sskip_chars_forward
);
3471 defsubr (&Sskip_chars_backward
);
3472 defsubr (&Sskip_syntax_forward
);
3473 defsubr (&Sskip_syntax_backward
);
3475 defsubr (&Sforward_comment
);
3476 defsubr (&Sscan_lists
);
3477 defsubr (&Sscan_sexps
);
3478 defsubr (&Sbackward_prefix_chars
);
3479 defsubr (&Sparse_partial_sexp
);
3482 /* arch-tag: 3e297b9f-088e-4b64-8f4c-fb0b3443e412
3483 (do not change this comment) */