1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 87, 93, 94, 95, 97, 1998, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
30 /* Make syntax table lookup grant data in gl_state. */
31 #define SYNTAX_ENTRY_VIA_PROPERTY
34 #include "intervals.h"
36 /* We use these constants in place for comment-style and
37 string-ender-char to distinguish comments/strings started by
38 comment_fence and string_fence codes. */
40 #define ST_COMMENT_STYLE (256 + 1)
41 #define ST_STRING_STYLE (256 + 2)
44 Lisp_Object Qsyntax_table_p
, Qsyntax_table
, Qscan_error
;
46 int words_include_escapes
;
47 int parse_sexp_lookup_properties
;
49 /* Nonzero means `scan-sexps' treat all multibyte characters as symbol. */
50 int multibyte_syntax_as_symbol
;
52 /* Used as a temporary in SYNTAX_ENTRY and other macros in syntax.h,
53 if not compiled with GCC. No need to mark it, since it is used
54 only very temporarily. */
55 Lisp_Object syntax_temp
;
57 /* Non-zero means an open parenthesis in column 0 is always considered
58 to be the start of a defun. Zero means an open parenthesis in
59 column 0 has no special meaning. */
61 int open_paren_in_column_0_is_defun_start
;
63 /* This is the internal form of the parse state used in parse-partial-sexp. */
65 struct lisp_parse_state
67 int depth
; /* Depth at end of parsing. */
68 int instring
; /* -1 if not within string, else desired terminator. */
69 int incomment
; /* -1 if in unnestable comment else comment nesting */
70 int comstyle
; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
71 int quoted
; /* Nonzero if just after an escape char at end of parsing */
72 int thislevelstart
; /* Char number of most recent start-of-expression at current level */
73 int prevlevelstart
; /* Char number of start of containing expression */
74 int location
; /* Char number at which parsing stopped. */
75 int mindepth
; /* Minimum depth seen while scanning. */
76 int comstr_start
; /* Position just after last comment/string starter. */
77 Lisp_Object levelstarts
; /* Char numbers of starts-of-expression
78 of levels (starting from outermost). */
81 /* These variables are a cache for finding the start of a defun.
82 find_start_pos is the place for which the defun start was found.
83 find_start_value is the defun start position found for it.
84 find_start_value_byte is the corresponding byte position.
85 find_start_buffer is the buffer it was found in.
86 find_start_begv is the BEGV value when it was found.
87 find_start_modiff is the value of MODIFF when it was found. */
89 static int find_start_pos
;
90 static int find_start_value
;
91 static int find_start_value_byte
;
92 static struct buffer
*find_start_buffer
;
93 static int find_start_begv
;
94 static int find_start_modiff
;
97 static int find_defun_start
P_ ((int, int));
98 static int back_comment
P_ ((int, int, int, int, int, int *, int *));
99 static int char_quoted
P_ ((int, int));
100 static Lisp_Object skip_chars
P_ ((int, int, Lisp_Object
, Lisp_Object
));
101 static Lisp_Object scan_lists
P_ ((int, int, int, int));
102 static void scan_sexps_forward
P_ ((struct lisp_parse_state
*,
104 int, Lisp_Object
, int));
107 struct gl_state_s gl_state
; /* Global state of syntax parser. */
109 INTERVAL
interval_of ();
110 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
111 to scan to property-change. */
113 /* Update gl_state to an appropriate interval which contains CHARPOS. The
114 sign of COUNT give the relative position of CHARPOS wrt the previously
115 valid interval. If INIT, only [be]_property fields of gl_state are
116 valid at start, the rest is filled basing on OBJECT.
118 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
119 direction than the intervals - or in an interval. We update the
120 current syntax-table basing on the property of this interval, and
121 update the interval to start further than CHARPOS - or be
122 NULL_INTERVAL. We also update lim_property to be the next value of
123 charpos to call this subroutine again - or be before/after the
124 start/end of OBJECT. */
127 update_syntax_table (charpos
, count
, init
, object
)
128 int charpos
, count
, init
;
131 Lisp_Object tmp_table
;
132 int cnt
= 0, invalidate
= 1;
137 gl_state
.old_prop
= Qnil
;
138 gl_state
.start
= gl_state
.b_property
;
139 gl_state
.stop
= gl_state
.e_property
;
140 i
= interval_of (charpos
, object
);
141 gl_state
.backward_i
= gl_state
.forward_i
= i
;
143 if (NULL_INTERVAL_P (i
))
145 /* interval_of updates only ->position of the return value, so
146 update the parents manually to speed up update_interval. */
147 while (!NULL_PARENT (i
))
149 if (AM_RIGHT_CHILD (i
))
150 INTERVAL_PARENT (i
)->position
= i
->position
151 - LEFT_TOTAL_LENGTH (i
) + TOTAL_LENGTH (i
) /* right end */
152 - TOTAL_LENGTH (INTERVAL_PARENT (i
))
153 + LEFT_TOTAL_LENGTH (INTERVAL_PARENT (i
));
155 INTERVAL_PARENT (i
)->position
= i
->position
- LEFT_TOTAL_LENGTH (i
)
157 i
= INTERVAL_PARENT (i
);
159 i
= gl_state
.forward_i
;
160 gl_state
.b_property
= i
->position
- gl_state
.offset
;
161 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
164 oldi
= i
= count
> 0 ? gl_state
.forward_i
: gl_state
.backward_i
;
166 /* We are guaranteed to be called with CHARPOS either in i,
168 if (NULL_INTERVAL_P (i
))
169 error ("Error in syntax_table logic for to-the-end intervals");
170 else if (charpos
< i
->position
) /* Move left. */
173 error ("Error in syntax_table logic for intervals <-");
174 /* Update the interval. */
175 i
= update_interval (i
, charpos
);
176 if (INTERVAL_LAST_POS (i
) != gl_state
.b_property
)
179 gl_state
.forward_i
= i
;
180 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
183 else if (charpos
>= INTERVAL_LAST_POS (i
)) /* Move right. */
186 error ("Error in syntax_table logic for intervals ->");
187 /* Update the interval. */
188 i
= update_interval (i
, charpos
);
189 if (i
->position
!= gl_state
.e_property
)
192 gl_state
.backward_i
= i
;
193 gl_state
.b_property
= i
->position
- gl_state
.offset
;
198 tmp_table
= textget (i
->plist
, Qsyntax_table
);
201 invalidate
= !EQ (tmp_table
, gl_state
.old_prop
); /* Need to invalidate? */
203 if (invalidate
) /* Did not get to adjacent interval. */
204 { /* with the same table => */
205 /* invalidate the old range. */
208 gl_state
.backward_i
= i
;
209 gl_state
.b_property
= i
->position
- gl_state
.offset
;
213 gl_state
.forward_i
= i
;
214 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
218 if (!EQ (tmp_table
, gl_state
.old_prop
))
220 gl_state
.current_syntax_table
= tmp_table
;
221 gl_state
.old_prop
= tmp_table
;
222 if (EQ (Fsyntax_table_p (tmp_table
), Qt
))
224 gl_state
.use_global
= 0;
226 else if (CONSP (tmp_table
))
228 gl_state
.use_global
= 1;
229 gl_state
.global_code
= tmp_table
;
233 gl_state
.use_global
= 0;
234 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
238 while (!NULL_INTERVAL_P (i
))
240 if (cnt
&& !EQ (tmp_table
, textget (i
->plist
, Qsyntax_table
)))
244 gl_state
.e_property
= i
->position
- gl_state
.offset
;
245 gl_state
.forward_i
= i
;
249 gl_state
.b_property
= i
->position
+ LENGTH (i
) - gl_state
.offset
;
250 gl_state
.backward_i
= i
;
254 else if (cnt
== INTERVALS_AT_ONCE
)
258 gl_state
.e_property
= i
->position
+ LENGTH (i
) - gl_state
.offset
;
259 gl_state
.forward_i
= i
;
263 gl_state
.b_property
= i
->position
- gl_state
.offset
;
264 gl_state
.backward_i
= i
;
269 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
271 eassert (NULL_INTERVAL_P (i
)); /* This property goes to the end. */
273 gl_state
.e_property
= gl_state
.stop
;
275 gl_state
.b_property
= gl_state
.start
;
278 /* Returns TRUE if char at CHARPOS is quoted.
279 Global syntax-table data should be set up already to be good at CHARPOS
280 or after. On return global syntax data is good for lookup at CHARPOS. */
283 char_quoted (charpos
, bytepos
)
284 register int charpos
, bytepos
;
286 register enum syntaxcode code
;
287 register int beg
= BEGV
;
288 register int quoted
= 0;
291 DEC_BOTH (charpos
, bytepos
);
293 while (bytepos
>= beg
)
295 UPDATE_SYNTAX_TABLE_BACKWARD (charpos
);
296 code
= SYNTAX (FETCH_CHAR (bytepos
));
297 if (! (code
== Scharquote
|| code
== Sescape
))
300 DEC_BOTH (charpos
, bytepos
);
304 UPDATE_SYNTAX_TABLE (orig
);
308 /* Return the bytepos one character after BYTEPOS.
309 We assume that BYTEPOS is not at the end of the buffer. */
312 inc_bytepos (bytepos
)
315 if (NILP (current_buffer
->enable_multibyte_characters
))
322 /* Return the bytepos one character before BYTEPOS.
323 We assume that BYTEPOS is not at the start of the buffer. */
326 dec_bytepos (bytepos
)
329 if (NILP (current_buffer
->enable_multibyte_characters
))
336 /* Return a defun-start position before before POS and not too far before.
337 It should be the last one before POS, or nearly the last.
339 When open_paren_in_column_0_is_defun_start is nonzero,
340 the beginning of every line is treated as a defun-start.
342 We record the information about where the scan started
343 and what its result was, so that another call in the same area
344 can return the same value very quickly.
346 There is no promise at which position the global syntax data is
347 valid on return from the subroutine, so the caller should explicitly
348 update the global data. */
351 find_defun_start (pos
, pos_byte
)
354 int opoint
= PT
, opoint_byte
= PT_BYTE
;
356 /* Use previous finding, if it's valid and applies to this inquiry. */
357 if (current_buffer
== find_start_buffer
358 /* Reuse the defun-start even if POS is a little farther on.
359 POS might be in the next defun, but that's ok.
360 Our value may not be the best possible, but will still be usable. */
361 && pos
<= find_start_pos
+ 1000
362 && pos
>= find_start_value
363 && BEGV
== find_start_begv
364 && MODIFF
== find_start_modiff
)
365 return find_start_value
;
367 /* Back up to start of line. */
368 scan_newline (pos
, pos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
370 /* We optimize syntax-table lookup for rare updates. Thus we accept
371 only those `^\s(' which are good in global _and_ text-property
373 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
374 gl_state
.use_global
= 0;
375 if (open_paren_in_column_0_is_defun_start
)
379 /* Open-paren at start of line means we may have found our
381 if (SYNTAX (FETCH_CHAR (PT_BYTE
)) == Sopen
)
383 SETUP_SYNTAX_TABLE (PT
+ 1, -1); /* Try again... */
384 if (SYNTAX (FETCH_CHAR (PT_BYTE
)) == Sopen
)
386 /* Now fallback to the default value. */
387 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
388 gl_state
.use_global
= 0;
390 /* Move to beg of previous line. */
391 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -2, 1);
395 /* Record what we found, for the next try. */
396 find_start_value
= PT
;
397 find_start_value_byte
= PT_BYTE
;
398 find_start_buffer
= current_buffer
;
399 find_start_modiff
= MODIFF
;
400 find_start_begv
= BEGV
;
401 find_start_pos
= pos
;
403 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
405 return find_start_value
;
408 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
411 prev_char_comend_first (pos
, pos_byte
)
416 DEC_BOTH (pos
, pos_byte
);
417 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
418 c
= FETCH_CHAR (pos_byte
);
419 val
= SYNTAX_COMEND_FIRST (c
);
420 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
424 /* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
427 * prev_char_comstart_first (pos, pos_byte)
432 * DEC_BOTH (pos, pos_byte);
433 * UPDATE_SYNTAX_TABLE_BACKWARD (pos);
434 * c = FETCH_CHAR (pos_byte);
435 * val = SYNTAX_COMSTART_FIRST (c);
436 * UPDATE_SYNTAX_TABLE_FORWARD (pos + 1);
440 /* Checks whether charpos FROM is at the end of a comment.
441 FROM_BYTE is the bytepos corresponding to FROM.
442 Do not move back before STOP.
444 Return a positive value if we find a comment ending at FROM/FROM_BYTE;
447 If successful, store the charpos of the comment's beginning
448 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
450 Global syntax data remains valid for backward search starting at
451 the returned value (or at FROM, if the search was not successful). */
454 back_comment (from
, from_byte
, stop
, comnested
, comstyle
, charpos_ptr
, bytepos_ptr
)
455 int from
, from_byte
, stop
;
456 int comnested
, comstyle
;
457 int *charpos_ptr
, *bytepos_ptr
;
459 /* Look back, counting the parity of string-quotes,
460 and recording the comment-starters seen.
461 When we reach a safe place, assume that's not in a string;
462 then step the main scan to the earliest comment-starter seen
463 an even number of string quotes away from the safe place.
465 OFROM[I] is position of the earliest comment-starter seen
466 which is I+2X quotes from the comment-end.
467 PARITY is current parity of quotes from the comment end. */
468 int string_style
= -1; /* Presumed outside of any string. */
469 int string_lossage
= 0;
470 /* Not a real lossage: indicates that we have passed a matching comment
471 starter plus an non-matching comment-ender, meaning that any matching
472 comment-starter we might see later could be a false positive (hidden
473 inside another comment).
474 Test case: { a (* b } c (* d *) */
475 int comment_lossage
= 0;
476 int comment_end
= from
;
477 int comment_end_byte
= from_byte
;
478 int comstart_pos
= 0;
480 /* Place where the containing defun starts,
481 or 0 if we didn't come across it yet. */
483 int defun_start_byte
= 0;
484 register enum syntaxcode code
;
485 int nesting
= 1; /* current comment nesting */
489 /* FIXME: A }} comment-ender style leads to incorrect behavior
490 in the case of {{ c }}} because we ignore the last two chars which are
491 assumed to be comment-enders although they aren't. */
493 /* At beginning of range to scan, we're outside of strings;
494 that determines quote parity to the comment-end. */
497 int temp_byte
, prev_syntax
;
498 int com2start
, com2end
;
500 /* Move back and examine a character. */
501 DEC_BOTH (from
, from_byte
);
502 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
504 prev_syntax
= syntax
;
505 c
= FETCH_CHAR (from_byte
);
506 syntax
= SYNTAX_WITH_FLAGS (c
);
509 /* Check for 2-char comment markers. */
510 com2start
= (SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
511 && SYNTAX_FLAGS_COMSTART_SECOND (prev_syntax
)
512 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax
)
513 && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
)
514 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
);
515 com2end
= (SYNTAX_FLAGS_COMEND_FIRST (syntax
)
516 && SYNTAX_FLAGS_COMEND_SECOND (prev_syntax
));
518 /* Nasty cases with overlapping 2-char comment markers:
519 - snmp-mode: -- c -- foo -- c --
527 /* If a 2-char comment sequence partly overlaps with another,
528 we don't try to be clever. */
529 if (from
> stop
&& (com2end
|| com2start
))
531 int next
= from
, next_byte
= from_byte
, next_c
, next_syntax
;
532 DEC_BOTH (next
, next_byte
);
533 UPDATE_SYNTAX_TABLE_BACKWARD (next
);
534 next_c
= FETCH_CHAR (next_byte
);
535 next_syntax
= SYNTAX_WITH_FLAGS (next_c
);
536 if (((com2start
|| comnested
)
537 && SYNTAX_FLAGS_COMEND_SECOND (syntax
)
538 && SYNTAX_FLAGS_COMEND_FIRST (next_syntax
))
539 || ((com2end
|| comnested
)
540 && SYNTAX_FLAGS_COMSTART_SECOND (syntax
)
541 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
542 && SYNTAX_FLAGS_COMSTART_FIRST (next_syntax
)))
544 /* UPDATE_SYNTAX_TABLE_FORWARD (next + 1); */
547 if (com2start
&& comstart_pos
== 0)
548 /* We're looking at a comment starter. But it might be a comment
549 ender as well (see snmp-mode). The first time we see one, we
550 need to consider it as a comment starter,
551 and the subsequent times as a comment ender. */
554 /* Turn a 2-char comment sequences into the appropriate syntax. */
559 /* Ignore comment starters of a different style. */
560 else if (code
== Scomment
561 && (comstyle
!= SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
562 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
) != comnested
))
565 /* Ignore escaped characters, except comment-enders. */
566 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
573 c
= (code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
);
575 /* Track parity of quotes. */
576 if (string_style
== -1)
577 /* Entering a string. */
579 else if (string_style
== c
)
580 /* Leaving the string. */
583 /* If we have two kinds of string delimiters.
584 There's no way to grok this scanning backwards. */
589 /* We've already checked that it is the relevant comstyle. */
590 if (string_style
!= -1 || comment_lossage
|| string_lossage
)
591 /* There are odd string quotes involved, so let's be careful.
592 Test case in Pascal: " { " a { " } */
597 /* Record best comment-starter so far. */
599 comstart_byte
= from_byte
;
601 else if (--nesting
<= 0)
602 /* nested comments have to be balanced, so we don't need to
603 keep looking for earlier ones. We use here the same (slightly
604 incorrect) reasoning as below: since it is followed by uniform
605 paired string quotes, this comment-start has to be outside of
606 strings, else the comment-end itself would be inside a string. */
611 if (SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == comstyle
612 && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
)
613 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
)
614 /* This is the same style of comment ender as ours. */
619 /* Anything before that can't count because it would match
620 this comment-ender rather than ours. */
621 from
= stop
; /* Break out of the loop. */
623 else if (comstart_pos
!= 0 || c
!= '\n')
624 /* We're mixing comment styles here, so we'd better be careful.
625 The (comstart_pos != 0 || c != '\n') check is not quite correct
626 (we should just always set comment_lossage), but removing it
627 would imply that any multiline comment in C would go through
628 lossage, which seems overkill.
629 The failure should only happen in the rare cases such as
635 /* Assume a defun-start point is outside of strings. */
636 if (open_paren_in_column_0_is_defun_start
638 || (temp_byte
= dec_bytepos (from_byte
),
639 FETCH_CHAR (temp_byte
) == '\n')))
642 defun_start_byte
= from_byte
;
643 from
= stop
; /* Break out of the loop. */
652 if (comstart_pos
== 0)
655 from_byte
= comment_end_byte
;
656 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
658 /* If comstart_pos is set and we get here (ie. didn't jump to `lossage'
659 or `done'), then we've found the beginning of the non-nested comment. */
660 else if (1) /* !comnested */
663 from_byte
= comstart_byte
;
664 /* Globals are correct now. */
668 struct lisp_parse_state state
;
670 /* We had two kinds of string delimiters mixed up
671 together. Decode this going forwards.
672 Scan fwd from a known safe place (beginning-of-defun)
673 to the one in question; this records where we
674 last passed a comment starter. */
675 /* If we did not already find the defun start, find it now. */
676 if (defun_start
== 0)
678 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
679 defun_start_byte
= find_start_value_byte
;
683 scan_sexps_forward (&state
,
684 defun_start
, defun_start_byte
,
685 comment_end
, -10000, 0, Qnil
, 0);
686 defun_start
= comment_end
;
687 if (state
.incomment
== (comnested
? 1 : -1)
688 && state
.comstyle
== comstyle
)
689 from
= state
.comstr_start
;
694 /* If comment_end is inside some other comment, maybe ours
695 is nested, so we need to try again from within the
696 surrounding comment. Example: { a (* " *) */
698 /* FIXME: We should advance by one or two chars. */
699 defun_start
= state
.comstr_start
+ 2;
700 defun_start_byte
= CHAR_TO_BYTE (defun_start
);
703 } while (defun_start
< comment_end
);
705 from_byte
= CHAR_TO_BYTE (from
);
706 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
711 *bytepos_ptr
= from_byte
;
713 return (from
== comment_end
) ? -1 : from
;
716 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
717 doc
: /* Return t if OBJECT is a syntax table.
718 Currently, any char-table counts as a syntax table. */)
722 if (CHAR_TABLE_P (object
)
723 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
729 check_syntax_table (obj
)
732 if (!(CHAR_TABLE_P (obj
)
733 && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
)))
734 wrong_type_argument (Qsyntax_table_p
, obj
);
737 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
738 doc
: /* Return the current syntax table.
739 This is the one specified by the current buffer. */)
742 return current_buffer
->syntax_table
;
745 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
746 Sstandard_syntax_table
, 0, 0, 0,
747 doc
: /* Return the standard syntax table.
748 This is the one used for new buffers. */)
751 return Vstandard_syntax_table
;
754 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
755 doc
: /* Construct a new syntax table and return it.
756 It is a copy of the TABLE, which defaults to the standard syntax table. */)
763 check_syntax_table (table
);
765 table
= Vstandard_syntax_table
;
767 copy
= Fcopy_sequence (table
);
769 /* Only the standard syntax table should have a default element.
770 Other syntax tables should inherit from parents instead. */
771 XCHAR_TABLE (copy
)->defalt
= Qnil
;
773 /* Copied syntax tables should all have parents.
774 If we copied one with no parent, such as the standard syntax table,
775 use the standard syntax table as the copy's parent. */
776 if (NILP (XCHAR_TABLE (copy
)->parent
))
777 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
781 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
782 doc
: /* Select a new syntax table for the current buffer.
783 One argument, a syntax table. */)
788 check_syntax_table (table
);
789 current_buffer
->syntax_table
= table
;
790 /* Indicate that this buffer now has a specified syntax table. */
791 idx
= PER_BUFFER_VAR_IDX (syntax_table
);
792 SET_PER_BUFFER_VALUE_P (current_buffer
, idx
, 1);
796 /* Convert a letter which signifies a syntax code
797 into the code it signifies.
798 This is used by modify-syntax-entry, and other things. */
800 unsigned char syntax_spec_code
[0400] =
801 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
802 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
803 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
804 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
805 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
806 (char) Smath
, 0377, 0377, (char) Squote
,
807 (char) Sopen
, (char) Sclose
, 0377, 0377,
808 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
809 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
810 0377, 0377, 0377, 0377,
811 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
812 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
813 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
814 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
815 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
816 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
817 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
818 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
819 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
822 /* Indexed by syntax code, give the letter that describes it. */
824 char syntax_code_spec
[16] =
826 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
830 /* Indexed by syntax code, give the object (cons of syntax code and
831 nil) to be stored in syntax table. Since these objects can be
832 shared among syntax tables, we generate them in advance. By
833 sharing objects, the function `describe-syntax' can give a more
835 static Lisp_Object Vsyntax_code_object
;
838 /* Look up the value for CHARACTER in syntax table TABLE's parent
839 and its parents. SYNTAX_ENTRY calls this, when TABLE itself has nil
840 for CHARACTER. It's actually used only when not compiled with GCC. */
843 syntax_parent_lookup (table
, character
)
851 table
= XCHAR_TABLE (table
)->parent
;
855 value
= XCHAR_TABLE (table
)->contents
[character
];
861 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
862 doc
: /* Return the syntax code of CHARACTER, described by a character.
863 For example, if CHARACTER is a word constituent,
864 the character `w' is returned.
865 The characters that correspond to various syntax codes
866 are listed in the documentation of `modify-syntax-entry'. */)
868 Lisp_Object character
;
871 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
873 gl_state
.use_global
= 0;
874 CHECK_NUMBER (character
);
875 char_int
= XINT (character
);
876 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
879 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
880 doc
: /* Return the matching parenthesis of CHARACTER, or nil if none. */)
882 Lisp_Object character
;
885 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 code
= SYNTAX (char_int
);
890 if (code
== Sopen
|| code
== Sclose
)
891 return SYNTAX_MATCH (char_int
);
895 DEFUN ("string-to-syntax", Fstring_to_syntax
, Sstring_to_syntax
, 1, 1, 0,
896 doc
: /* Convert a syntax specification STRING into syntax cell form.
897 STRING should be a string as it is allowed as argument of
898 `modify-syntax-entry'. Value is the equivalent cons cell
899 (CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'
904 register unsigned char *p
;
905 register enum syntaxcode code
;
909 CHECK_STRING (string
);
911 p
= XSTRING (string
)->data
;
912 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
913 if (((int) code
& 0377) == 0377)
914 error ("invalid syntax description letter: %c", p
[-1]);
916 if (code
== Sinherit
)
922 int character
= (STRING_CHAR_AND_LENGTH
923 (p
, STRING_BYTES (XSTRING (string
)) - 1, len
));
924 XSETINT (match
, character
);
925 if (XFASTINT (match
) == ' ')
965 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
966 return XVECTOR (Vsyntax_code_object
)->contents
[val
];
968 /* Since we can't use a shared object, let's make a new one. */
969 return Fcons (make_number (val
), match
);
972 /* I really don't know why this is interactive
973 help-form should at least be made useful whilst reading the second arg. */
974 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
975 "cSet syntax for character: \nsSet syntax for %s to: ",
976 doc
: /* Set syntax for character CHAR according to string NEWENTRY.
977 The syntax is changed only for table SYNTAX_TABLE, which defaults to
978 the current buffer's syntax table.
979 The first character of NEWENTRY should be one of the following:
980 Space or - whitespace syntax. w word constituent.
981 _ symbol constituent. . punctuation.
982 ( open-parenthesis. ) close-parenthesis.
983 " string quote. \\ escape.
984 $ paired delimiter. ' expression quote or prefix operator.
985 < comment starter. > comment ender.
986 / character-quote. @ inherit from `standard-syntax-table'.
987 | generic string fence. ! generic comment fence.
989 Only single-character comment start and end sequences are represented thus.
990 Two-character sequences are represented as described below.
991 The second character of NEWENTRY is the matching parenthesis,
992 used only if the first character is `(' or `)'.
993 Any additional characters are flags.
994 Defined flags are the characters 1, 2, 3, 4, b, p, and n.
995 1 means CHAR is the start of a two-char comment start sequence.
996 2 means CHAR is the second character of such a sequence.
997 3 means CHAR is the start of a two-char comment end sequence.
998 4 means CHAR is the second character of such a sequence.
1000 There can be up to two orthogonal comment sequences. This is to support
1001 language modes such as C++. By default, all comment sequences are of style
1002 a, but you can set the comment sequence style to b (on the second character
1003 of a comment-start, or the first character of a comment-end sequence) using
1005 b means CHAR is part of comment sequence b.
1006 n means CHAR is part of a nestable comment sequence.
1008 p means CHAR is a prefix character for `backward-prefix-chars';
1009 such characters are treated as whitespace when they occur
1010 between expressions.
1011 usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE) */)
1012 (c
, newentry
, syntax_table
)
1013 Lisp_Object c
, newentry
, syntax_table
;
1017 if (NILP (syntax_table
))
1018 syntax_table
= current_buffer
->syntax_table
;
1020 check_syntax_table (syntax_table
);
1022 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), Fstring_to_syntax (newentry
));
1026 /* Dump syntax table to buffer in human-readable format */
1028 DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value
,
1029 Sinternal_describe_syntax_value
, 1, 1, 0,
1030 doc
: /* Insert a description of the internal syntax description SYNTAX at point. */)
1034 register enum syntaxcode code
;
1035 char desc
, start1
, start2
, end1
, end2
, prefix
, comstyle
, comnested
;
1037 Lisp_Object first
, match_lisp
, value
= syntax
;
1041 insert_string ("default");
1045 if (CHAR_TABLE_P (value
))
1047 insert_string ("deeper char-table ...");
1053 insert_string ("invalid");
1057 first
= XCAR (value
);
1058 match_lisp
= XCDR (value
);
1060 if (!INTEGERP (first
) || !(NILP (match_lisp
) || INTEGERP (match_lisp
)))
1062 insert_string ("invalid");
1066 code
= (enum syntaxcode
) (XINT (first
) & 0377);
1067 start1
= (XINT (first
) >> 16) & 1;
1068 start2
= (XINT (first
) >> 17) & 1;
1069 end1
= (XINT (first
) >> 18) & 1;
1070 end2
= (XINT (first
) >> 19) & 1;
1071 prefix
= (XINT (first
) >> 20) & 1;
1072 comstyle
= (XINT (first
) >> 21) & 1;
1073 comnested
= (XINT (first
) >> 22) & 1;
1075 if ((int) code
< 0 || (int) code
>= (int) Smax
)
1077 insert_string ("invalid");
1080 desc
= syntax_code_spec
[(int) code
];
1082 str
[0] = desc
, str
[1] = 0;
1085 if (NILP (match_lisp
))
1088 insert_char (XINT (match_lisp
));
1107 insert_string ("\twhich means: ");
1109 switch (SWITCH_ENUM_CAST (code
))
1112 insert_string ("whitespace"); break;
1114 insert_string ("punctuation"); break;
1116 insert_string ("word"); break;
1118 insert_string ("symbol"); break;
1120 insert_string ("open"); break;
1122 insert_string ("close"); break;
1124 insert_string ("prefix"); break;
1126 insert_string ("string"); break;
1128 insert_string ("math"); break;
1130 insert_string ("escape"); break;
1132 insert_string ("charquote"); break;
1134 insert_string ("comment"); break;
1136 insert_string ("endcomment"); break;
1138 insert_string ("inherit"); break;
1139 case Scomment_fence
:
1140 insert_string ("comment fence"); break;
1142 insert_string ("string fence"); break;
1144 insert_string ("invalid");
1148 if (!NILP (match_lisp
))
1150 insert_string (", matches ");
1151 insert_char (XINT (match_lisp
));
1155 insert_string (",\n\t is the first character of a comment-start sequence");
1157 insert_string (",\n\t is the second character of a comment-start sequence");
1160 insert_string (",\n\t is the first character of a comment-end sequence");
1162 insert_string (",\n\t is the second character of a comment-end sequence");
1164 insert_string (" (comment style b)");
1166 insert_string (" (nestable)");
1169 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
1176 describe_syntax (value
)
1179 Findent_to (make_number (16), make_number (1));
1180 Finternal_describe_syntax_value (value
);
1181 insert_string ("\n");
1186 describe_syntax_1 (vector
)
1189 struct buffer
*old
= current_buffer
;
1190 set_buffer_internal (XBUFFER (Vstandard_output
));
1191 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
, (int *) 0, 0);
1192 while (! NILP (XCHAR_TABLE (vector
)->parent
))
1194 vector
= XCHAR_TABLE (vector
)->parent
;
1195 insert_string ("\nThe parent syntax table is:");
1196 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
,
1200 call0 (intern ("help-mode"));
1201 set_buffer_internal (old
);
1205 DEFUN ("describe-syntax", Fdescribe_syntax
, Sdescribe_syntax
, 0, 0, "",
1206 doc
: /* Describe the syntax specifications in the syntax table.
1207 The descriptions are inserted in a buffer, which is then displayed. */)
1210 internal_with_output_to_temp_buffer
1211 ("*Help*", describe_syntax_1
, current_buffer
->syntax_table
);
1216 int parse_sexp_ignore_comments
;
1218 /* Return the position across COUNT words from FROM.
1219 If that many words cannot be found before the end of the buffer, return 0.
1220 COUNT negative means scan backward and stop at word beginning. */
1223 scan_words (from
, count
)
1224 register int from
, count
;
1226 register int beg
= BEGV
;
1227 register int end
= ZV
;
1228 register int from_byte
= CHAR_TO_BYTE (from
);
1229 register enum syntaxcode code
;
1235 SETUP_SYNTAX_TABLE (from
, count
);
1246 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1247 ch0
= FETCH_CHAR (from_byte
);
1248 code
= SYNTAX (ch0
);
1249 INC_BOTH (from
, from_byte
);
1250 if (words_include_escapes
1251 && (code
== Sescape
|| code
== Scharquote
))
1256 /* Now CH0 is a character which begins a word and FROM is the
1257 position of the next character. */
1260 if (from
== end
) break;
1261 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1262 ch1
= FETCH_CHAR (from_byte
);
1263 code
= SYNTAX (ch1
);
1264 if (!(words_include_escapes
1265 && (code
== Sescape
|| code
== Scharquote
)))
1266 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1268 INC_BOTH (from
, from_byte
);
1282 DEC_BOTH (from
, from_byte
);
1283 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1284 ch1
= FETCH_CHAR (from_byte
);
1285 code
= SYNTAX (ch1
);
1286 if (words_include_escapes
1287 && (code
== Sescape
|| code
== Scharquote
))
1292 /* Now CH1 is a character which ends a word and FROM is the
1300 temp_byte
= dec_bytepos (from_byte
);
1301 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1302 ch0
= FETCH_CHAR (temp_byte
);
1303 code
= SYNTAX (ch0
);
1304 if (!(words_include_escapes
1305 && (code
== Sescape
|| code
== Scharquote
)))
1306 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1308 DEC_BOTH (from
, from_byte
);
1319 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 1, 1, "p",
1320 doc
: /* Move point forward ARG words (backward if ARG is negative).
1322 If an edge of the buffer or a field boundary is reached, point is left there
1323 and the function returns nil. Field boundaries are not noticed if
1324 `inhibit-field-text-motion' is non-nil. */)
1329 CHECK_NUMBER (count
);
1331 val
= orig_val
= scan_words (PT
, XINT (count
));
1333 val
= XINT (count
) > 0 ? ZV
: BEGV
;
1335 /* Avoid jumping out of an input field. */
1336 val
= XFASTINT (Fconstrain_to_field (make_number (val
), make_number (PT
),
1340 return val
== orig_val
? Qt
: Qnil
;
1343 Lisp_Object
skip_chars ();
1345 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1346 doc
: /* Move point forward, stopping before a char not in STRING, or at pos LIM.
1347 STRING is like the inside of a `[...]' in a regular expression
1348 except that `]' is never special and `\\' quotes `^', `-' or `\\'
1349 (but not as the end of a range; quoting is never needed there).
1350 Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
1351 With arg "^a-zA-Z", skips nonletters stopping before first letter.
1352 Returns the distance traveled, either zero or positive. */)
1354 Lisp_Object string
, lim
;
1356 return skip_chars (1, 0, string
, lim
);
1359 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1360 doc
: /* Move point backward, stopping after a char not in STRING, or at pos LIM.
1361 See `skip-chars-forward' for details.
1362 Returns the distance traveled, either zero or negative. */)
1364 Lisp_Object string
, lim
;
1366 return skip_chars (0, 0, string
, lim
);
1369 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1370 doc
: /* Move point forward across chars in specified syntax classes.
1371 SYNTAX is a string of syntax code characters.
1372 Stop before a char whose syntax is not in SYNTAX, or at position LIM.
1373 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1374 This function returns the distance traveled, either zero or positive. */)
1376 Lisp_Object syntax
, lim
;
1378 return skip_chars (1, 1, syntax
, lim
);
1381 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1382 doc
: /* Move point backward across chars in specified syntax classes.
1383 SYNTAX is a string of syntax code characters.
1384 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
1385 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1386 This function returns the distance traveled, either zero or negative. */)
1388 Lisp_Object syntax
, lim
;
1390 return skip_chars (0, 1, syntax
, lim
);
1394 skip_chars (forwardp
, syntaxp
, string
, lim
)
1395 int forwardp
, syntaxp
;
1396 Lisp_Object string
, lim
;
1398 register unsigned int c
;
1399 unsigned char fastmap
[0400];
1400 /* If SYNTAXP is 0, STRING may contain multi-byte form of characters
1401 of which codes don't fit in FASTMAP. In that case, set the
1402 ranges of characters in CHAR_RANGES. */
1404 int n_char_ranges
= 0;
1406 register int i
, i_byte
;
1407 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1408 int string_multibyte
;
1413 CHECK_STRING (string
);
1414 char_ranges
= (int *) alloca (XSTRING (string
)->size
* (sizeof (int)) * 2);
1415 string_multibyte
= STRING_MULTIBYTE (string
);
1416 str
= XSTRING (string
)->data
;
1417 size_byte
= STRING_BYTES (XSTRING (string
));
1419 /* Adjust the multibyteness of the string to that of the buffer. */
1420 if (multibyte
!= string_multibyte
)
1425 nbytes
= count_size_as_multibyte (XSTRING (string
)->data
,
1426 XSTRING (string
)->size
);
1428 nbytes
= XSTRING (string
)->size
;
1429 if (nbytes
!= size_byte
)
1431 str
= (unsigned char *) alloca (nbytes
);
1432 copy_text (XSTRING (string
)->data
, str
, size_byte
,
1433 string_multibyte
, multibyte
);
1439 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1441 CHECK_NUMBER_COERCE_MARKER (lim
);
1443 /* In any case, don't allow scan outside bounds of buffer. */
1444 if (XINT (lim
) > ZV
)
1445 XSETFASTINT (lim
, ZV
);
1446 if (XINT (lim
) < BEGV
)
1447 XSETFASTINT (lim
, BEGV
);
1449 bzero (fastmap
, sizeof fastmap
);
1453 if (i_byte
< size_byte
1454 && XSTRING (string
)->data
[0] == '^')
1456 negate
= 1; i_byte
++;
1459 /* Find the characters specified and set their elements of fastmap.
1460 If syntaxp, each character counts as itself.
1461 Otherwise, handle backslashes and ranges specially. */
1463 while (i_byte
< size_byte
)
1465 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, size_byte
- i_byte
, len
);
1469 fastmap
[syntax_spec_code
[c
& 0377]] = 1;
1474 if (i_byte
== size_byte
)
1477 c
= STRING_CHAR_AND_LENGTH (str
+i_byte
, size_byte
-i_byte
, len
);
1480 if (i_byte
< size_byte
1481 && str
[i_byte
] == '-')
1485 /* Skip over the dash. */
1488 if (i_byte
== size_byte
)
1491 /* Get the end of the range. */
1492 c2
=STRING_CHAR_AND_LENGTH (str
+i_byte
, size_byte
-i_byte
, len
);
1495 if (SINGLE_BYTE_CHAR_P (c
))
1497 if (! SINGLE_BYTE_CHAR_P (c2
))
1499 /* Handle a range starting with a character of
1500 less than 256, and ending with a character of
1501 not less than 256. Split that into two
1502 ranges, the low one ending at 0377, and the
1503 high one starting at the smallest character
1504 in the charset of C2 and ending at C2. */
1505 int charset
= CHAR_CHARSET (c2
);
1506 int c1
= MAKE_CHAR (charset
, 0, 0);
1508 char_ranges
[n_char_ranges
++] = c1
;
1509 char_ranges
[n_char_ranges
++] = c2
;
1518 else if (c
<= c2
) /* Both C and C2 are multibyte char. */
1520 char_ranges
[n_char_ranges
++] = c
;
1521 char_ranges
[n_char_ranges
++] = c2
;
1526 if (SINGLE_BYTE_CHAR_P (c
))
1530 char_ranges
[n_char_ranges
++] = c
;
1531 char_ranges
[n_char_ranges
++] = c
;
1537 /* If ^ was the first character, complement the fastmap. */
1539 for (i
= 0; i
< sizeof fastmap
; i
++)
1543 int start_point
= PT
;
1545 int pos_byte
= PT_BYTE
;
1550 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1555 if (pos
< XINT (lim
))
1556 while (fastmap
[(int) SYNTAX (FETCH_CHAR (pos_byte
))])
1558 /* Since we already checked for multibyteness,
1559 avoid using INC_BOTH which checks again. */
1562 if (pos
>= XINT (lim
))
1564 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1569 while (pos
< XINT (lim
)
1570 && fastmap
[(int) SYNTAX (FETCH_BYTE (pos
))])
1573 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1581 while (pos
> XINT (lim
))
1583 int savepos
= pos_byte
;
1584 /* Since we already checked for multibyteness,
1585 avoid using DEC_BOTH which checks again. */
1588 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
1589 if (!fastmap
[(int) SYNTAX (FETCH_CHAR (pos_byte
))])
1599 if (pos
> XINT (lim
))
1600 while (fastmap
[(int) SYNTAX (FETCH_BYTE (pos
- 1))])
1603 if (pos
<= XINT (lim
))
1605 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
1615 while (pos
< XINT (lim
))
1617 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
1618 if (SINGLE_BYTE_CHAR_P (c
))
1625 /* If we are looking at a multibyte character,
1626 we must look up the character in the table
1627 CHAR_RANGES. If there's no data in the
1628 table, that character is not what we want to
1631 /* The following code do the right thing even if
1632 n_char_ranges is zero (i.e. no data in
1634 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1635 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1637 if (!(negate
^ (i
< n_char_ranges
)))
1640 INC_BOTH (pos
, pos_byte
);
1643 while (pos
< XINT (lim
) && fastmap
[FETCH_BYTE (pos
)])
1649 while (pos
> XINT (lim
))
1651 int prev_pos_byte
= pos_byte
;
1653 DEC_POS (prev_pos_byte
);
1654 c
= FETCH_MULTIBYTE_CHAR (prev_pos_byte
);
1655 if (SINGLE_BYTE_CHAR_P (c
))
1662 /* See the comment in the previous similar code. */
1663 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1664 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1666 if (!(negate
^ (i
< n_char_ranges
)))
1670 pos_byte
= prev_pos_byte
;
1673 while (pos
> XINT (lim
) && fastmap
[FETCH_BYTE (pos
- 1)])
1678 #if 0 /* Not needed now that a position in mid-character
1679 cannot be specified in Lisp. */
1681 /* INC_POS or DEC_POS might have moved POS over LIM. */
1682 && (forwardp
? (pos
> XINT (lim
)) : (pos
< XINT (lim
))))
1689 SET_PT_BOTH (pos
, pos_byte
);
1692 return make_number (PT
- start_point
);
1696 /* Jump over a comment, assuming we are at the beginning of one.
1697 FROM is the current position.
1698 FROM_BYTE is the bytepos corresponding to FROM.
1699 Do not move past STOP (a charpos).
1700 The comment over which we have to jump is of style STYLE
1701 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
1702 NESTING should be positive to indicate the nesting at the beginning
1703 for nested comments and should be zero or negative else.
1704 ST_COMMENT_STYLE cannot be nested.
1705 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
1706 (or 0 If the search cannot start in the middle of a two-character).
1708 If successful, return 1 and store the charpos of the comment's end
1709 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
1710 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
1711 corresponding bytepos into *BYTEPOS_PTR and the current nesting
1712 (as defined for state.incomment) in *INCOMMENT_PTR.
1714 The comment end is the last character of the comment rather than the
1715 character just after the comment.
1717 Global syntax data is assumed to initially be valid for FROM and
1718 remains valid for forward search starting at the returned position. */
1721 forw_comment (from
, from_byte
, stop
, nesting
, style
, prev_syntax
,
1722 charpos_ptr
, bytepos_ptr
, incomment_ptr
)
1723 int from
, from_byte
, stop
;
1724 int nesting
, style
, prev_syntax
;
1725 int *charpos_ptr
, *bytepos_ptr
, *incomment_ptr
;
1728 register enum syntaxcode code
;
1729 register int syntax
;
1731 if (nesting
<= 0) nesting
= -1;
1733 /* Enter the loop in the middle so that we find
1734 a 2-char comment ender if we start in the middle of it. */
1735 syntax
= prev_syntax
;
1736 if (syntax
!= 0) goto forw_incomment
;
1742 *incomment_ptr
= nesting
;
1743 *charpos_ptr
= from
;
1744 *bytepos_ptr
= from_byte
;
1747 c
= FETCH_CHAR (from_byte
);
1748 syntax
= SYNTAX_WITH_FLAGS (c
);
1749 code
= syntax
& 0xff;
1750 if (code
== Sendcomment
1751 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1752 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ?
1753 (nesting
> 0 && --nesting
== 0) : nesting
< 0))
1754 /* we have encountered a comment end of the same style
1755 as the comment sequence which began this comment
1758 if (code
== Scomment_fence
1759 && style
== ST_COMMENT_STYLE
)
1760 /* we have encountered a comment end of the same style
1761 as the comment sequence which began this comment
1766 && SYNTAX_FLAGS_COMMENT_NESTED (syntax
)
1767 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
)
1768 /* we have encountered a nested comment of the same style
1769 as the comment sequence which began this comment section */
1771 INC_BOTH (from
, from_byte
);
1772 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1775 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
1776 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1777 && (c1
= FETCH_CHAR (from_byte
),
1778 SYNTAX_COMEND_SECOND (c1
))
1779 && ((SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
1780 SYNTAX_COMMENT_NESTED (c1
)) ? nesting
> 0 : nesting
< 0))
1783 /* we have encountered a comment end of the same style
1784 as the comment sequence which began this comment
1789 INC_BOTH (from
, from_byte
);
1790 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1795 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
1796 && (c1
= FETCH_CHAR (from_byte
),
1797 SYNTAX_COMMENT_STYLE (c1
) == style
1798 && SYNTAX_COMSTART_SECOND (c1
))
1799 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
1800 SYNTAX_COMMENT_NESTED (c1
)))
1801 /* we have encountered a nested comment of the same style
1802 as the comment sequence which began this comment
1805 INC_BOTH (from
, from_byte
);
1806 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1810 *charpos_ptr
= from
;
1811 *bytepos_ptr
= from_byte
;
1815 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
1816 doc
: /* Move forward across up to N comments. If N is negative, move backward.
1817 Stop scanning if we find something other than a comment or whitespace.
1818 Set point to where scanning stops.
1819 If N comments are found as expected, with nothing except whitespace
1820 between them, return t; otherwise return nil. */)
1828 register enum syntaxcode code
;
1829 int comstyle
= 0; /* style of comment encountered */
1830 int comnested
= 0; /* whether the comment is nestable or not */
1833 int out_charpos
, out_bytepos
;
1836 CHECK_NUMBER (count
);
1837 count1
= XINT (count
);
1838 stop
= count1
> 0 ? ZV
: BEGV
;
1844 from_byte
= PT_BYTE
;
1846 SETUP_SYNTAX_TABLE (from
, count1
);
1855 SET_PT_BOTH (from
, from_byte
);
1859 c
= FETCH_CHAR (from_byte
);
1861 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
1862 comnested
= SYNTAX_COMMENT_NESTED (c
);
1863 comstyle
= SYNTAX_COMMENT_STYLE (c
);
1864 INC_BOTH (from
, from_byte
);
1865 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1866 if (from
< stop
&& comstart_first
1867 && (c1
= FETCH_CHAR (from_byte
),
1868 SYNTAX_COMSTART_SECOND (c1
)))
1870 /* We have encountered a comment start sequence and we
1871 are ignoring all text inside comments. We must record
1872 the comment style this sequence begins so that later,
1873 only a comment end of the same style actually ends
1874 the comment section. */
1876 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1877 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1878 INC_BOTH (from
, from_byte
);
1879 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1882 while (code
== Swhitespace
|| (code
== Sendcomment
&& c
== '\n'));
1884 if (code
== Scomment_fence
)
1885 comstyle
= ST_COMMENT_STYLE
;
1886 else if (code
!= Scomment
)
1889 DEC_BOTH (from
, from_byte
);
1890 SET_PT_BOTH (from
, from_byte
);
1893 /* We're at the start of a comment. */
1894 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
1895 &out_charpos
, &out_bytepos
, &dummy
);
1896 from
= out_charpos
; from_byte
= out_bytepos
;
1900 SET_PT_BOTH (from
, from_byte
);
1903 INC_BOTH (from
, from_byte
);
1904 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1905 /* We have skipped one comment. */
1917 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
1922 DEC_BOTH (from
, from_byte
);
1923 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
1924 quoted
= char_quoted (from
, from_byte
);
1925 c
= FETCH_CHAR (from_byte
);
1928 comnested
= SYNTAX_COMMENT_NESTED (c
);
1929 if (code
== Sendcomment
)
1930 comstyle
= SYNTAX_COMMENT_STYLE (c
);
1931 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1932 && prev_char_comend_first (from
, from_byte
)
1933 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
1935 /* We must record the comment style encountered so that
1936 later, we can match only the proper comment begin
1937 sequence of the same style. */
1938 DEC_BOTH (from
, from_byte
);
1940 /* Calling char_quoted, above, set up global syntax position
1941 at the new value of FROM. */
1942 c1
= FETCH_CHAR (from_byte
);
1943 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1944 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
1947 if (code
== Scomment_fence
)
1949 /* Skip until first preceding unquoted comment_fence. */
1950 int found
= 0, ini
= from
, ini_byte
= from_byte
;
1954 DEC_BOTH (from
, from_byte
);
1957 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1958 c
= FETCH_CHAR (from_byte
);
1959 if (SYNTAX (c
) == Scomment_fence
1960 && !char_quoted (from
, from_byte
))
1968 from
= ini
; /* Set point to ini + 1. */
1969 from_byte
= ini_byte
;
1973 else if (code
== Sendcomment
)
1975 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
1976 &out_charpos
, &out_bytepos
);
1980 /* This end-of-line is not an end-of-comment.
1981 Treat it like a whitespace.
1982 CC-mode (and maybe others) relies on this behavior. */
1986 /* Failure: we should go back to the end of this
1987 not-quite-endcomment. */
1988 if (SYNTAX(c
) != code
)
1989 /* It was a two-char Sendcomment. */
1990 INC_BOTH (from
, from_byte
);
1996 /* We have skipped one comment. */
1997 from
= out_charpos
, from_byte
= out_bytepos
;
2001 else if (code
!= Swhitespace
|| quoted
)
2005 INC_BOTH (from
, from_byte
);
2006 SET_PT_BOTH (from
, from_byte
);
2014 SET_PT_BOTH (from
, from_byte
);
2019 /* Return syntax code of character C if C is a single byte character
2020 or `multibyte_symbol_p' is zero. Otherwise, return Ssymbol. */
2022 #define SYNTAX_WITH_MULTIBYTE_CHECK(c) \
2023 ((SINGLE_BYTE_CHAR_P (c) || !multibyte_symbol_p) \
2024 ? SYNTAX (c) : Ssymbol)
2027 scan_lists (from
, count
, depth
, sexpflag
)
2029 int count
, depth
, sexpflag
;
2032 register int stop
= count
> 0 ? ZV
: BEGV
;
2037 register enum syntaxcode code
, temp_code
;
2038 int min_depth
= depth
; /* Err out if depth gets less than this. */
2039 int comstyle
= 0; /* style of comment encountered */
2040 int comnested
= 0; /* whether the comment is nestable or not */
2042 int last_good
= from
;
2045 int out_bytepos
, out_charpos
;
2047 int multibyte_symbol_p
= sexpflag
&& multibyte_syntax_as_symbol
;
2049 if (depth
> 0) min_depth
= 0;
2051 if (from
> ZV
) from
= ZV
;
2052 if (from
< BEGV
) from
= BEGV
;
2054 from_byte
= CHAR_TO_BYTE (from
);
2059 SETUP_SYNTAX_TABLE (from
, count
);
2064 int comstart_first
, prefix
;
2065 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2066 c
= FETCH_CHAR (from_byte
);
2067 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2068 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2069 comnested
= SYNTAX_COMMENT_NESTED (c
);
2070 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2071 prefix
= SYNTAX_PREFIX (c
);
2072 if (depth
== min_depth
)
2074 INC_BOTH (from
, from_byte
);
2075 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2076 if (from
< stop
&& comstart_first
2077 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte
))
2078 && parse_sexp_ignore_comments
)
2080 /* we have encountered a comment start sequence and we
2081 are ignoring all text inside comments. We must record
2082 the comment style this sequence begins so that later,
2083 only a comment end of the same style actually ends
2084 the comment section */
2086 c1
= FETCH_CHAR (from_byte
);
2087 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2088 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2089 INC_BOTH (from
, from_byte
);
2090 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2096 switch (SWITCH_ENUM_CAST (code
))
2100 if (from
== stop
) goto lose
;
2101 INC_BOTH (from
, from_byte
);
2102 /* treat following character as a word constituent */
2105 if (depth
|| !sexpflag
) break;
2106 /* This word counts as a sexp; return at end of it. */
2109 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2111 /* Some compilers can't handle this inside the switch. */
2112 c
= FETCH_CHAR (from_byte
);
2113 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2118 INC_BOTH (from
, from_byte
);
2119 if (from
== stop
) goto lose
;
2128 INC_BOTH (from
, from_byte
);
2132 case Scomment_fence
:
2133 comstyle
= ST_COMMENT_STYLE
;
2136 if (!parse_sexp_ignore_comments
) break;
2137 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2138 found
= forw_comment (from
, from_byte
, stop
,
2139 comnested
, comstyle
, 0,
2140 &out_charpos
, &out_bytepos
, &dummy
);
2141 from
= out_charpos
, from_byte
= out_bytepos
;
2148 INC_BOTH (from
, from_byte
);
2149 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2155 if (from
!= stop
&& c
== FETCH_CHAR (from_byte
))
2157 INC_BOTH (from
, from_byte
);
2167 if (!++depth
) goto done
;
2172 if (!--depth
) goto done
;
2173 if (depth
< min_depth
)
2174 Fsignal (Qscan_error
,
2175 Fcons (build_string ("Containing expression ends prematurely"),
2176 Fcons (make_number (last_good
),
2177 Fcons (make_number (from
), Qnil
))));
2182 temp_pos
= dec_bytepos (from_byte
);
2183 stringterm
= FETCH_CHAR (temp_pos
);
2186 if (from
>= stop
) goto lose
;
2187 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2188 c
= FETCH_CHAR (from_byte
);
2191 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2192 : SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring_fence
)
2195 /* Some compilers can't handle this inside the switch. */
2196 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2201 INC_BOTH (from
, from_byte
);
2203 INC_BOTH (from
, from_byte
);
2205 INC_BOTH (from
, from_byte
);
2206 if (!depth
&& sexpflag
) goto done
;
2211 /* Reached end of buffer. Error if within object, return nil if between */
2212 if (depth
) goto lose
;
2217 /* End of object reached */
2226 DEC_BOTH (from
, from_byte
);
2227 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2228 c
= FETCH_CHAR (from_byte
);
2229 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2230 if (depth
== min_depth
)
2233 comnested
= SYNTAX_COMMENT_NESTED (c
);
2234 if (code
== Sendcomment
)
2235 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2236 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2237 && prev_char_comend_first (from
, from_byte
)
2238 && parse_sexp_ignore_comments
)
2240 /* We must record the comment style encountered so that
2241 later, we can match only the proper comment begin
2242 sequence of the same style. */
2243 DEC_BOTH (from
, from_byte
);
2244 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2246 c1
= FETCH_CHAR (from_byte
);
2247 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2248 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2251 /* Quoting turns anything except a comment-ender
2252 into a word character. Note that this cannot be true
2253 if we decremented FROM in the if-statement above. */
2254 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2256 else if (SYNTAX_PREFIX (c
))
2259 switch (SWITCH_ENUM_CAST (code
))
2265 if (depth
|| !sexpflag
) break;
2266 /* This word counts as a sexp; count object finished
2267 after passing it. */
2270 temp_pos
= from_byte
;
2271 if (! NILP (current_buffer
->enable_multibyte_characters
))
2275 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2276 c1
= FETCH_CHAR (temp_pos
);
2277 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2278 /* Don't allow comment-end to be quoted. */
2279 if (temp_code
== Sendcomment
)
2281 quoted
= char_quoted (from
- 1, temp_pos
);
2284 DEC_BOTH (from
, from_byte
);
2285 temp_pos
= dec_bytepos (temp_pos
);
2286 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2288 c1
= FETCH_CHAR (temp_pos
);
2289 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2290 if (! (quoted
|| temp_code
== Sword
2291 || temp_code
== Ssymbol
2292 || temp_code
== Squote
))
2294 DEC_BOTH (from
, from_byte
);
2301 temp_pos
= dec_bytepos (from_byte
);
2302 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2303 if (from
!= stop
&& c
== FETCH_CHAR (temp_pos
))
2304 DEC_BOTH (from
, from_byte
);
2313 if (!++depth
) goto done2
;
2318 if (!--depth
) goto done2
;
2319 if (depth
< min_depth
)
2320 Fsignal (Qscan_error
,
2321 Fcons (build_string ("Containing expression ends prematurely"),
2322 Fcons (make_number (last_good
),
2323 Fcons (make_number (from
), Qnil
))));
2327 if (!parse_sexp_ignore_comments
)
2329 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2330 &out_charpos
, &out_bytepos
);
2331 /* FIXME: if found == -1, then it really wasn't a comment-end.
2332 For single-char Sendcomment, we can't do much about it apart
2333 from skipping the char.
2334 For 2-char endcomments, we could try again, taking both
2335 chars as separate entities, but it's a lot of trouble
2336 for very little gain, so we don't bother either. -sm */
2338 from
= out_charpos
, from_byte
= out_bytepos
;
2341 case Scomment_fence
:
2345 DEC_BOTH (from
, from_byte
);
2346 if (from
== stop
) goto lose
;
2347 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2348 if (!char_quoted (from
, from_byte
)
2349 && (c
= FETCH_CHAR (from_byte
),
2350 SYNTAX_WITH_MULTIBYTE_CHECK (c
) == code
))
2353 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2357 stringterm
= FETCH_CHAR (from_byte
);
2360 if (from
== stop
) goto lose
;
2361 temp_pos
= from_byte
;
2362 if (! NILP (current_buffer
->enable_multibyte_characters
))
2366 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2367 if (!char_quoted (from
- 1, temp_pos
)
2368 && stringterm
== (c
= FETCH_CHAR (temp_pos
))
2369 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2371 DEC_BOTH (from
, from_byte
);
2373 DEC_BOTH (from
, from_byte
);
2374 if (!depth
&& sexpflag
) goto done2
;
2379 /* Reached start of buffer. Error if within object, return nil if between */
2380 if (depth
) goto lose
;
2391 XSETFASTINT (val
, from
);
2395 Fsignal (Qscan_error
,
2396 Fcons (build_string ("Unbalanced parentheses"),
2397 Fcons (make_number (last_good
),
2398 Fcons (make_number (from
), Qnil
))));
2403 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2404 doc
: /* Scan from character number FROM by COUNT lists.
2405 Returns the character number of the position thus found.
2407 If DEPTH is nonzero, paren depth begins counting from that value,
2408 only places where the depth in parentheses becomes zero
2409 are candidates for stopping; COUNT such places are counted.
2410 Thus, a positive value for DEPTH means go out levels.
2412 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2414 If the beginning or end of (the accessible part of) the buffer is reached
2415 and the depth is wrong, an error is signaled.
2416 If the depth is right but the count is not used up, nil is returned. */)
2417 (from
, count
, depth
)
2418 Lisp_Object from
, count
, depth
;
2420 CHECK_NUMBER (from
);
2421 CHECK_NUMBER (count
);
2422 CHECK_NUMBER (depth
);
2424 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2427 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2428 doc
: /* Scan from character number FROM by COUNT balanced expressions.
2429 If COUNT is negative, scan backwards.
2430 Returns the character number of the position thus found.
2432 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2434 If the beginning or end of (the accessible part of) the buffer is reached
2435 in the middle of a parenthetical grouping, an error is signaled.
2436 If the beginning or end is reached between groupings
2437 but before count is used up, nil is returned. */)
2439 Lisp_Object from
, count
;
2441 CHECK_NUMBER (from
);
2442 CHECK_NUMBER (count
);
2444 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2447 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2449 doc
: /* Move point backward over any number of chars with prefix syntax.
2450 This includes chars with "quote" or "prefix" syntax (' or p). */)
2455 int opoint_byte
= PT_BYTE
;
2457 int pos_byte
= PT_BYTE
;
2462 SET_PT_BOTH (opoint
, opoint_byte
);
2467 SETUP_SYNTAX_TABLE (pos
, -1);
2469 DEC_BOTH (pos
, pos_byte
);
2471 while (!char_quoted (pos
, pos_byte
)
2472 /* Previous statement updates syntax table. */
2473 && ((c
= FETCH_CHAR (pos_byte
), SYNTAX (c
) == Squote
)
2474 || SYNTAX_PREFIX (c
)))
2477 opoint_byte
= pos_byte
;
2480 DEC_BOTH (pos
, pos_byte
);
2483 SET_PT_BOTH (opoint
, opoint_byte
);
2488 /* Parse forward from FROM / FROM_BYTE to END,
2489 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2490 and return a description of the state of the parse at END.
2491 If STOPBEFORE is nonzero, stop at the start of an atom.
2492 If COMMENTSTOP is 1, stop at the start of a comment.
2493 If COMMENTSTOP is -1, stop at the start or end of a comment,
2494 after the beginning of a string, or after the end of a string. */
2497 scan_sexps_forward (stateptr
, from
, from_byte
, end
, targetdepth
,
2498 stopbefore
, oldstate
, commentstop
)
2499 struct lisp_parse_state
*stateptr
;
2501 int end
, targetdepth
, stopbefore
;
2502 Lisp_Object oldstate
;
2505 struct lisp_parse_state state
;
2507 register enum syntaxcode code
;
2510 struct level
{ int last
, prev
; };
2511 struct level levelstart
[100];
2512 register struct level
*curlevel
= levelstart
;
2513 struct level
*endlevel
= levelstart
+ 100;
2514 register int depth
; /* Paren depth of current scanning location.
2515 level - levelstart equals this except
2516 when the depth becomes negative. */
2517 int mindepth
; /* Lowest DEPTH value seen. */
2518 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2520 int prev_from
; /* Keep one character before FROM. */
2522 int prev_from_syntax
;
2523 int boundary_stop
= commentstop
== -1;
2526 int out_bytepos
, out_charpos
;
2530 prev_from_byte
= from_byte
;
2532 DEC_BOTH (prev_from
, prev_from_byte
);
2534 /* Use this macro instead of `from++'. */
2536 do { prev_from = from; \
2537 prev_from_byte = from_byte; \
2539 = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte)); \
2540 INC_BOTH (from, from_byte); \
2541 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2547 if (NILP (oldstate
))
2550 state
.instring
= -1;
2551 state
.incomment
= 0;
2552 state
.comstyle
= 0; /* comment style a by default. */
2553 state
.comstr_start
= -1; /* no comment/string seen. */
2557 tem
= Fcar (oldstate
);
2563 oldstate
= Fcdr (oldstate
);
2564 oldstate
= Fcdr (oldstate
);
2565 oldstate
= Fcdr (oldstate
);
2566 tem
= Fcar (oldstate
);
2567 /* Check whether we are inside string_fence-style string: */
2568 state
.instring
= (!NILP (tem
)
2569 ? (INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2572 oldstate
= Fcdr (oldstate
);
2573 tem
= Fcar (oldstate
);
2574 state
.incomment
= (!NILP (tem
)
2575 ? (INTEGERP (tem
) ? XINT (tem
) : -1)
2578 oldstate
= Fcdr (oldstate
);
2579 tem
= Fcar (oldstate
);
2580 start_quoted
= !NILP (tem
);
2582 /* if the eighth element of the list is nil, we are in comment
2583 style a. If it is non-nil, we are in comment style b */
2584 oldstate
= Fcdr (oldstate
);
2585 oldstate
= Fcdr (oldstate
);
2586 tem
= Fcar (oldstate
);
2587 state
.comstyle
= NILP (tem
) ? 0 : (EQ (tem
, Qsyntax_table
)
2588 ? ST_COMMENT_STYLE
: 1);
2590 oldstate
= Fcdr (oldstate
);
2591 tem
= Fcar (oldstate
);
2592 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2593 oldstate
= Fcdr (oldstate
);
2594 tem
= Fcar (oldstate
);
2595 while (!NILP (tem
)) /* >= second enclosing sexps. */
2597 /* curlevel++->last ran into compiler bug on Apollo */
2598 curlevel
->last
= XINT (Fcar (tem
));
2599 if (++curlevel
== endlevel
)
2600 curlevel
--; /* error ("Nesting too deep for parser"); */
2601 curlevel
->prev
= -1;
2602 curlevel
->last
= -1;
2609 curlevel
->prev
= -1;
2610 curlevel
->last
= -1;
2612 SETUP_SYNTAX_TABLE (prev_from
, 1);
2613 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2614 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2616 /* Enter the loop at a place appropriate for initial state. */
2618 if (state
.incomment
)
2619 goto startincomment
;
2620 if (state
.instring
>= 0)
2622 nofence
= state
.instring
!= ST_STRING_STYLE
;
2624 goto startquotedinstring
;
2627 else if (start_quoted
)
2630 #if 0 /* This seems to be redundant with the identical code above. */
2631 SETUP_SYNTAX_TABLE (prev_from
, 1);
2632 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2633 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2639 code
= prev_from_syntax
& 0xff;
2641 if (code
== Scomment
)
2643 state
.comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax
);
2644 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
2646 state
.comstr_start
= prev_from
;
2648 else if (code
== Scomment_fence
)
2650 /* Record the comment style we have entered so that only
2651 the comment-end sequence of the same style actually
2652 terminates the comment section. */
2653 state
.comstyle
= ST_COMMENT_STYLE
;
2654 state
.incomment
= -1;
2655 state
.comstr_start
= prev_from
;
2658 else if (from
< end
)
2659 if (SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
))
2660 if (c1
= FETCH_CHAR (from_byte
),
2661 SYNTAX_COMSTART_SECOND (c1
))
2662 /* Duplicate code to avoid a complex if-expression
2663 which causes trouble for the SGI compiler. */
2665 /* Record the comment style we have entered so that only
2666 the comment-end sequence of the same style actually
2667 terminates the comment section. */
2668 state
.comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte
));
2669 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
);
2670 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2671 state
.incomment
= comnested
? 1 : -1;
2672 state
.comstr_start
= prev_from
;
2677 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
2679 switch (SWITCH_ENUM_CAST (code
))
2683 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2684 curlevel
->last
= prev_from
;
2686 if (from
== end
) goto endquoted
;
2689 /* treat following character as a word constituent */
2692 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2693 curlevel
->last
= prev_from
;
2697 /* Some compilers can't handle this inside the switch. */
2698 temp
= SYNTAX (FETCH_CHAR (from_byte
));
2704 if (from
== end
) goto endquoted
;
2716 curlevel
->prev
= curlevel
->last
;
2720 if (commentstop
|| boundary_stop
) goto done
;
2722 /* The (from == BEGV) test was to enter the loop in the middle so
2723 that we find a 2-char comment ender even if we start in the
2724 middle of it. We don't want to do that if we're just at the
2725 beginning of the comment (think of (*) ... (*)). */
2726 found
= forw_comment (from
, from_byte
, end
,
2727 state
.incomment
, state
.comstyle
,
2728 (from
== BEGV
|| from
< state
.comstr_start
+ 3)
2729 ? 0 : prev_from_syntax
,
2730 &out_charpos
, &out_bytepos
, &state
.incomment
);
2731 from
= out_charpos
; from_byte
= out_bytepos
;
2732 /* Beware! prev_from and friends are invalid now.
2733 Luckily, the `done' doesn't use them and the INC_FROM
2734 sets them to a sane value without looking at them. */
2735 if (!found
) goto done
;
2737 state
.incomment
= 0;
2738 state
.comstyle
= 0; /* reset the comment style */
2739 if (boundary_stop
) goto done
;
2743 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2745 /* curlevel++->last ran into compiler bug on Apollo */
2746 curlevel
->last
= prev_from
;
2747 if (++curlevel
== endlevel
)
2748 curlevel
--; /* error ("Nesting too deep for parser"); */
2749 curlevel
->prev
= -1;
2750 curlevel
->last
= -1;
2751 if (targetdepth
== depth
) goto done
;
2756 if (depth
< mindepth
)
2758 if (curlevel
!= levelstart
)
2760 curlevel
->prev
= curlevel
->last
;
2761 if (targetdepth
== depth
) goto done
;
2766 state
.comstr_start
= from
- 1;
2767 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2768 curlevel
->last
= prev_from
;
2769 state
.instring
= (code
== Sstring
2770 ? (FETCH_CHAR (prev_from_byte
))
2772 if (boundary_stop
) goto done
;
2775 nofence
= state
.instring
!= ST_STRING_STYLE
;
2781 if (from
>= end
) goto done
;
2782 c
= FETCH_CHAR (from_byte
);
2783 /* Some compilers can't handle this inside the switch. */
2786 /* Check TEMP here so that if the char has
2787 a syntax-table property which says it is NOT
2788 a string character, it does not end the string. */
2789 if (nofence
&& c
== state
.instring
&& temp
== Sstring
)
2795 if (!nofence
) goto string_end
;
2800 startquotedinstring
:
2801 if (from
>= end
) goto endquoted
;
2807 state
.instring
= -1;
2808 curlevel
->prev
= curlevel
->last
;
2810 if (boundary_stop
) goto done
;
2819 stop
: /* Here if stopping before start of sexp. */
2820 from
= prev_from
; /* We have just fetched the char that starts it; */
2821 goto done
; /* but return the position before it. */
2826 state
.depth
= depth
;
2827 state
.mindepth
= mindepth
;
2828 state
.thislevelstart
= curlevel
->prev
;
2829 state
.prevlevelstart
2830 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
2831 state
.location
= from
;
2832 state
.levelstarts
= Qnil
;
2833 while (--curlevel
>= levelstart
)
2834 state
.levelstarts
= Fcons (make_number (curlevel
->last
),
2841 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
2842 doc
: /* Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
2843 Parsing stops at TO or when certain criteria are met;
2844 point is set to where parsing stops.
2845 If fifth arg OLDSTATE is omitted or nil,
2846 parsing assumes that FROM is the beginning of a function.
2847 Value is a list of ten elements describing final state of parsing:
2849 1. character address of start of innermost containing list; nil if none.
2850 2. character address of start of last complete sexp terminated.
2851 3. non-nil if inside a string.
2852 (it is the character that will terminate the string,
2853 or t if the string should be terminated by a generic string delimiter.)
2854 4. nil if outside a comment, t if inside a non-nestable comment,
2855 else an integer (the current comment nesting).
2856 5. t if following a quote character.
2857 6. the minimum paren-depth encountered during this scan.
2858 7. t if in a comment of style b; symbol `syntax-table' if the comment
2859 should be terminated by a generic comment delimiter.
2860 8. character address of start of comment or string; nil if not in one.
2861 9. Intermediate data for continuation of parsing (subject to change).
2862 If third arg TARGETDEPTH is non-nil, parsing stops if the depth
2863 in parentheses becomes equal to TARGETDEPTH.
2864 Fourth arg STOPBEFORE non-nil means stop when come to
2865 any character that starts a sexp.
2866 Fifth arg OLDSTATE is a nine-element list like what this function returns.
2867 It is used to initialize the state of the parse. Elements number 1, 2, 6
2868 and 8 are ignored; you can leave off element 8 (the last) entirely.
2869 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
2870 If it is symbol `syntax-table', stop after the start of a comment or a
2871 string, or after end of a comment or a string. */)
2872 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
2873 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
2875 struct lisp_parse_state state
;
2878 if (!NILP (targetdepth
))
2880 CHECK_NUMBER (targetdepth
);
2881 target
= XINT (targetdepth
);
2884 target
= -100000; /* We won't reach this depth */
2886 validate_region (&from
, &to
);
2887 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
2889 target
, !NILP (stopbefore
), oldstate
,
2891 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
2893 SET_PT (state
.location
);
2895 return Fcons (make_number (state
.depth
),
2896 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
2897 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
2898 Fcons (state
.instring
>= 0
2899 ? (state
.instring
== ST_STRING_STYLE
2900 ? Qt
: make_number (state
.instring
)) : Qnil
,
2901 Fcons (state
.incomment
< 0 ? Qt
:
2902 (state
.incomment
== 0 ? Qnil
:
2903 make_number (state
.incomment
)),
2904 Fcons (state
.quoted
? Qt
: Qnil
,
2905 Fcons (make_number (state
.mindepth
),
2906 Fcons ((state
.comstyle
2907 ? (state
.comstyle
== ST_COMMENT_STYLE
2908 ? Qsyntax_table
: Qt
) :
2910 Fcons (((state
.incomment
2911 || (state
.instring
>= 0))
2912 ? make_number (state
.comstr_start
)
2914 Fcons (state
.levelstarts
, Qnil
))))))))));
2923 /* This has to be done here, before we call Fmake_char_table. */
2924 Qsyntax_table
= intern ("syntax-table");
2925 staticpro (&Qsyntax_table
);
2927 /* Intern this now in case it isn't already done.
2928 Setting this variable twice is harmless.
2929 But don't staticpro it here--that is done in alloc.c. */
2930 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
2932 /* Create objects which can be shared among syntax tables. */
2933 Vsyntax_code_object
= Fmake_vector (make_number (Smax
), Qnil
);
2934 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
2935 XVECTOR (Vsyntax_code_object
)->contents
[i
]
2936 = Fcons (make_number (i
), Qnil
);
2938 /* Now we are ready to set up this property, so we can
2939 create syntax tables. */
2940 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
2942 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
2944 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
2946 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
2947 for (i
= 'a'; i
<= 'z'; i
++)
2948 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2949 for (i
= 'A'; i
<= 'Z'; i
++)
2950 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2951 for (i
= '0'; i
<= '9'; i
++)
2952 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2954 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
2955 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
2957 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
2958 Fcons (make_number (Sopen
), make_number (')')));
2959 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
2960 Fcons (make_number (Sclose
), make_number ('(')));
2961 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
2962 Fcons (make_number (Sopen
), make_number (']')));
2963 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
2964 Fcons (make_number (Sclose
), make_number ('[')));
2965 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
2966 Fcons (make_number (Sopen
), make_number ('}')));
2967 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
2968 Fcons (make_number (Sclose
), make_number ('{')));
2969 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
2970 Fcons (make_number ((int) Sstring
), Qnil
));
2971 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
2972 Fcons (make_number ((int) Sescape
), Qnil
));
2974 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
2975 for (i
= 0; i
< 10; i
++)
2977 c
= "_-+*/&|<>="[i
];
2978 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2981 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
2982 for (i
= 0; i
< 12; i
++)
2984 c
= ".,;:?!#@~^'`"[i
];
2985 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2988 /* All multibyte characters have syntax `word' by default. */
2989 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
2990 for (i
= CHAR_TABLE_SINGLE_BYTE_SLOTS
; i
< CHAR_TABLE_ORDINARY_SLOTS
; i
++)
2991 XCHAR_TABLE (Vstandard_syntax_table
)->contents
[i
] = temp
;
2997 Qsyntax_table_p
= intern ("syntax-table-p");
2998 staticpro (&Qsyntax_table_p
);
3000 staticpro (&Vsyntax_code_object
);
3002 Qscan_error
= intern ("scan-error");
3003 staticpro (&Qscan_error
);
3004 Fput (Qscan_error
, Qerror_conditions
,
3005 Fcons (Qscan_error
, Fcons (Qerror
, Qnil
)));
3006 Fput (Qscan_error
, Qerror_message
,
3007 build_string ("Scan error"));
3009 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
3010 doc
: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace. */);
3012 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
3013 doc
: /* Non-nil means `forward-sexp', etc., obey `syntax-table' property.
3014 Otherwise, that text property is simply ignored.
3015 See the info node `(elisp)Syntax Properties' for a description of the
3016 `syntax-table' property. */);
3018 words_include_escapes
= 0;
3019 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
3020 doc
: /* Non-nil means `forward-word', etc., should treat escape chars part of words. */);
3022 DEFVAR_BOOL ("multibyte-syntax-as-symbol", &multibyte_syntax_as_symbol
,
3023 doc
: /* Non-nil means `scan-sexps' treats all multibyte characters as symbol. */);
3024 multibyte_syntax_as_symbol
= 0;
3026 DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
3027 &open_paren_in_column_0_is_defun_start
,
3028 doc
: /* Non-nil means an open paren in column 0 denotes the start of a defun. */);
3029 open_paren_in_column_0_is_defun_start
= 1;
3031 defsubr (&Ssyntax_table_p
);
3032 defsubr (&Ssyntax_table
);
3033 defsubr (&Sstandard_syntax_table
);
3034 defsubr (&Scopy_syntax_table
);
3035 defsubr (&Sset_syntax_table
);
3036 defsubr (&Schar_syntax
);
3037 defsubr (&Smatching_paren
);
3038 defsubr (&Sstring_to_syntax
);
3039 defsubr (&Smodify_syntax_entry
);
3040 defsubr (&Sdescribe_syntax
);
3041 defsubr (&Sinternal_describe_syntax_value
);
3043 defsubr (&Sforward_word
);
3045 defsubr (&Sskip_chars_forward
);
3046 defsubr (&Sskip_chars_backward
);
3047 defsubr (&Sskip_syntax_forward
);
3048 defsubr (&Sskip_syntax_backward
);
3050 defsubr (&Sforward_comment
);
3051 defsubr (&Sscan_lists
);
3052 defsubr (&Sscan_sexps
);
3053 defsubr (&Sbackward_prefix_chars
);
3054 defsubr (&Sparse_partial_sexp
);