1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 1987, 1993-1995, 1997-1999, 2001-2015 Free
3 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 3 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
23 #include <sys/types.h>
26 #include "character.h"
30 #include "intervals.h"
33 /* Make syntax table lookup grant data in gl_state. */
34 #define SYNTAX(c) syntax_property (c, 1)
35 #define SYNTAX_ENTRY(c) syntax_property_entry (c, 1)
36 #define SYNTAX_WITH_FLAGS(c) syntax_property_with_flags (c, 1)
38 /* Eight single-bit flags have the following meanings:
39 1. This character is the first of a two-character comment-start sequence.
40 2. This character is the second of a two-character comment-start sequence.
41 3. This character is the first of a two-character comment-end sequence.
42 4. This character is the second of a two-character comment-end sequence.
43 5. This character is a prefix, for backward-prefix-chars.
44 6. The char is part of a delimiter for comments of style "b".
45 7. This character is part of a nestable comment sequence.
46 8. The char is part of a delimiter for comments of style "c".
47 Note that any two-character sequence whose first character has flag 1
48 and whose second character has flag 2 will be interpreted as a comment start.
50 Bits 6 and 8 discriminate among different comment styles.
51 Languages such as C++ allow two orthogonal syntax start/end pairs
52 and bit 6 determines whether a comment-end or Scommentend
53 ends style a or b. Comment markers can start style a, b, c, or bc.
54 Style a is always the default.
55 For 2-char comment markers, the style b flag is looked up only on the second
56 char of the comment marker and on the first char of the comment ender.
57 For style c (like the nested flag), the flag can be placed on any of
60 /* These functions extract specific flags from an integer
61 that holds the syntax code and the flags. */
64 SYNTAX_FLAGS_COMSTART_FIRST (int flags
)
66 return (flags
>> 16) & 1;
69 SYNTAX_FLAGS_COMSTART_SECOND (int flags
)
71 return (flags
>> 17) & 1;
74 SYNTAX_FLAGS_COMEND_FIRST (int flags
)
76 return (flags
>> 18) & 1;
79 SYNTAX_FLAGS_COMEND_SECOND (int flags
)
81 return (flags
>> 19) & 1;
84 SYNTAX_FLAGS_PREFIX (int flags
)
86 return (flags
>> 20) & 1;
89 SYNTAX_FLAGS_COMMENT_STYLEB (int flags
)
91 return (flags
>> 21) & 1;
94 SYNTAX_FLAGS_COMMENT_STYLEC (int flags
)
96 return (flags
>> 23) & 1;
99 SYNTAX_FLAGS_COMMENT_STYLEC2 (int flags
)
101 return (flags
>> 22) & 2; /* SYNTAX_FLAGS_COMMENT_STYLEC (flags) * 2 */
104 SYNTAX_FLAGS_COMMENT_NESTED (int flags
)
106 return (flags
>> 22) & 1;
109 /* FLAGS should be the flags of the main char of the comment marker, e.g.
110 the second for comstart and the first for comend. */
112 SYNTAX_FLAGS_COMMENT_STYLE (int flags
, int other_flags
)
114 return (SYNTAX_FLAGS_COMMENT_STYLEB (flags
)
115 | SYNTAX_FLAGS_COMMENT_STYLEC2 (flags
)
116 | SYNTAX_FLAGS_COMMENT_STYLEC2 (other_flags
));
119 /* Extract a particular flag for a given character. */
122 SYNTAX_COMEND_FIRST (int c
)
124 return SYNTAX_FLAGS_COMEND_FIRST (SYNTAX_WITH_FLAGS (c
));
127 /* We use these constants in place for comment-style and
128 string-ender-char to distinguish comments/strings started by
129 comment_fence and string_fence codes. */
133 ST_COMMENT_STYLE
= 256 + 1,
134 ST_STRING_STYLE
= 256 + 2
137 /* This is the internal form of the parse state used in parse-partial-sexp. */
139 struct lisp_parse_state
141 EMACS_INT depth
; /* Depth at end of parsing. */
142 int instring
; /* -1 if not within string, else desired terminator. */
143 EMACS_INT incomment
; /* -1 if in unnestable comment else comment nesting */
144 int comstyle
; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
145 bool quoted
; /* True if just after an escape char at end of parsing. */
146 EMACS_INT mindepth
; /* Minimum depth seen while scanning. */
147 /* Char number of most recent start-of-expression at current level */
148 ptrdiff_t thislevelstart
;
149 /* Char number of start of containing expression */
150 ptrdiff_t prevlevelstart
;
151 ptrdiff_t location
; /* Char number at which parsing stopped. */
152 ptrdiff_t location_byte
; /* Corresponding byte position. */
153 ptrdiff_t comstr_start
; /* Position of last comment/string starter. */
154 Lisp_Object levelstarts
; /* Char numbers of starts-of-expression
155 of levels (starting from outermost). */
158 /* These variables are a cache for finding the start of a defun.
159 find_start_pos is the place for which the defun start was found.
160 find_start_value is the defun start position found for it.
161 find_start_value_byte is the corresponding byte position.
162 find_start_buffer is the buffer it was found in.
163 find_start_begv is the BEGV value when it was found.
164 find_start_modiff is the value of MODIFF when it was found. */
166 static ptrdiff_t find_start_pos
;
167 static ptrdiff_t find_start_value
;
168 static ptrdiff_t find_start_value_byte
;
169 static struct buffer
*find_start_buffer
;
170 static ptrdiff_t find_start_begv
;
171 static EMACS_INT find_start_modiff
;
174 static Lisp_Object
skip_chars (bool, Lisp_Object
, Lisp_Object
, bool);
175 static Lisp_Object
skip_syntaxes (bool, Lisp_Object
, Lisp_Object
);
176 static Lisp_Object
scan_lists (EMACS_INT
, EMACS_INT
, EMACS_INT
, bool);
177 static void scan_sexps_forward (struct lisp_parse_state
*,
178 ptrdiff_t, ptrdiff_t, ptrdiff_t, EMACS_INT
,
179 bool, Lisp_Object
, int);
180 static bool in_classes (int, Lisp_Object
);
181 static void parse_sexp_propertize (ptrdiff_t charpos
);
183 /* This setter is used only in this file, so it can be private. */
185 bset_syntax_table (struct buffer
*b
, Lisp_Object val
)
187 b
->syntax_table_
= val
;
190 /* Whether the syntax of the character C has the prefix flag set. */
192 syntax_prefix_flag_p (int c
)
194 return SYNTAX_FLAGS_PREFIX (SYNTAX_WITH_FLAGS (c
));
197 struct gl_state_s gl_state
; /* Global state of syntax parser. */
199 enum { INTERVALS_AT_ONCE
= 10 }; /* 1 + max-number of intervals
200 to scan to property-change. */
202 /* Set the syntax entry VAL for char C in table TABLE. */
205 SET_RAW_SYNTAX_ENTRY (Lisp_Object table
, int c
, Lisp_Object val
)
207 CHAR_TABLE_SET (table
, c
, val
);
210 /* Set the syntax entry VAL for char-range RANGE in table TABLE.
211 RANGE is a cons (FROM . TO) specifying the range of characters. */
214 SET_RAW_SYNTAX_ENTRY_RANGE (Lisp_Object table
, Lisp_Object range
,
217 Fset_char_table_range (table
, range
, val
);
220 /* Extract the information from the entry for character C
221 in the current syntax table. */
226 Lisp_Object ent
= SYNTAX_ENTRY (c
);
227 return CONSP (ent
) ? XCDR (ent
) : Qnil
;
230 /* This should be called with FROM at the start of forward
231 search, or after the last position of the backward search. It
232 makes sure that the first char is picked up with correct table, so
233 one does not need to call UPDATE_SYNTAX_TABLE immediately after the
235 Sign of COUNT gives the direction of the search.
239 SETUP_SYNTAX_TABLE (ptrdiff_t from
, ptrdiff_t count
)
241 SETUP_BUFFER_SYNTAX_TABLE ();
242 gl_state
.b_property
= BEGV
;
243 gl_state
.e_property
= ZV
+ 1;
244 gl_state
.object
= Qnil
;
246 if (parse_sexp_lookup_properties
)
249 update_syntax_table_forward (from
, true, true, Qnil
);
250 else if (from
> BEGV
)
252 update_syntax_table (from
- 1, count
, true, Qnil
);
253 parse_sexp_propertize (from
- 1);
258 /* Same as above, but in OBJECT. If OBJECT is nil, use current buffer.
259 If it is t (which is only used in fast_c_string_match_ignore_case),
260 ignore properties altogether.
262 This is meant for regex.c to use. For buffers, regex.c passes arguments
263 to the UPDATE_SYNTAX_TABLE functions which are relative to BEGV.
264 So if it is a buffer, we set the offset field to BEGV. */
267 SETUP_SYNTAX_TABLE_FOR_OBJECT (Lisp_Object object
,
268 ptrdiff_t from
, ptrdiff_t count
)
270 SETUP_BUFFER_SYNTAX_TABLE ();
271 gl_state
.object
= object
;
272 if (BUFFERP (gl_state
.object
))
274 struct buffer
*buf
= XBUFFER (gl_state
.object
);
275 gl_state
.b_property
= 1;
276 gl_state
.e_property
= BUF_ZV (buf
) - BUF_BEGV (buf
) + 1;
277 gl_state
.offset
= BUF_BEGV (buf
) - 1;
279 else if (NILP (gl_state
.object
))
281 gl_state
.b_property
= 1;
282 gl_state
.e_property
= ZV
- BEGV
+ 1;
283 gl_state
.offset
= BEGV
- 1;
285 else if (EQ (gl_state
.object
, Qt
))
287 gl_state
.b_property
= 0;
288 gl_state
.e_property
= PTRDIFF_MAX
;
293 gl_state
.b_property
= 0;
294 gl_state
.e_property
= 1 + SCHARS (gl_state
.object
);
297 if (parse_sexp_lookup_properties
)
298 update_syntax_table (from
+ gl_state
.offset
- (count
<= 0),
299 count
, 1, gl_state
.object
);
302 /* Update gl_state to an appropriate interval which contains CHARPOS. The
303 sign of COUNT give the relative position of CHARPOS wrt the previously
304 valid interval. If INIT, only [be]_property fields of gl_state are
305 valid at start, the rest is filled basing on OBJECT.
307 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
308 direction than the intervals - or in an interval. We update the
309 current syntax-table basing on the property of this interval, and
310 update the interval to start further than CHARPOS - or be
311 NULL. We also update lim_property to be the next value of
312 charpos to call this subroutine again - or be before/after the
313 start/end of OBJECT. */
316 update_syntax_table (ptrdiff_t charpos
, EMACS_INT count
, bool init
,
319 Lisp_Object tmp_table
;
321 bool invalidate
= true;
326 gl_state
.old_prop
= Qnil
;
327 gl_state
.start
= gl_state
.b_property
;
328 gl_state
.stop
= gl_state
.e_property
;
329 i
= interval_of (charpos
, object
);
330 gl_state
.backward_i
= gl_state
.forward_i
= i
;
334 /* interval_of updates only ->position of the return value, so
335 update the parents manually to speed up update_interval. */
336 while (!NULL_PARENT (i
))
338 if (AM_RIGHT_CHILD (i
))
339 INTERVAL_PARENT (i
)->position
= i
->position
340 - LEFT_TOTAL_LENGTH (i
) + TOTAL_LENGTH (i
) /* right end */
341 - TOTAL_LENGTH (INTERVAL_PARENT (i
))
342 + LEFT_TOTAL_LENGTH (INTERVAL_PARENT (i
));
344 INTERVAL_PARENT (i
)->position
= i
->position
- LEFT_TOTAL_LENGTH (i
)
346 i
= INTERVAL_PARENT (i
);
348 i
= gl_state
.forward_i
;
349 gl_state
.b_property
= i
->position
- gl_state
.offset
;
350 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
353 i
= count
> 0 ? gl_state
.forward_i
: gl_state
.backward_i
;
355 /* We are guaranteed to be called with CHARPOS either in i,
358 error ("Error in syntax_table logic for to-the-end intervals");
359 else if (charpos
< i
->position
) /* Move left. */
362 error ("Error in syntax_table logic for intervals <-");
363 /* Update the interval. */
364 i
= update_interval (i
, charpos
);
365 if (INTERVAL_LAST_POS (i
) != gl_state
.b_property
)
368 gl_state
.forward_i
= i
;
369 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
372 else if (charpos
>= INTERVAL_LAST_POS (i
)) /* Move right. */
375 error ("Error in syntax_table logic for intervals ->");
376 /* Update the interval. */
377 i
= update_interval (i
, charpos
);
378 if (i
->position
!= gl_state
.e_property
)
381 gl_state
.backward_i
= i
;
382 gl_state
.b_property
= i
->position
- gl_state
.offset
;
387 tmp_table
= textget (i
->plist
, Qsyntax_table
);
390 invalidate
= !EQ (tmp_table
, gl_state
.old_prop
); /* Need to invalidate? */
392 if (invalidate
) /* Did not get to adjacent interval. */
393 { /* with the same table => */
394 /* invalidate the old range. */
397 gl_state
.backward_i
= i
;
398 gl_state
.b_property
= i
->position
- gl_state
.offset
;
402 gl_state
.forward_i
= i
;
403 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
407 if (!EQ (tmp_table
, gl_state
.old_prop
))
409 gl_state
.current_syntax_table
= tmp_table
;
410 gl_state
.old_prop
= tmp_table
;
411 if (EQ (Fsyntax_table_p (tmp_table
), Qt
))
413 gl_state
.use_global
= 0;
415 else if (CONSP (tmp_table
))
417 gl_state
.use_global
= 1;
418 gl_state
.global_code
= tmp_table
;
422 gl_state
.use_global
= 0;
423 gl_state
.current_syntax_table
= BVAR (current_buffer
, syntax_table
);
429 if (cnt
&& !EQ (tmp_table
, textget (i
->plist
, Qsyntax_table
)))
433 gl_state
.e_property
= i
->position
- gl_state
.offset
;
434 gl_state
.forward_i
= i
;
439 = i
->position
+ LENGTH (i
) - gl_state
.offset
;
440 gl_state
.backward_i
= i
;
444 else if (cnt
== INTERVALS_AT_ONCE
)
449 = i
->position
+ LENGTH (i
) - gl_state
.offset
450 /* e_property at EOB is not set to ZV but to ZV+1, so that
451 we can do INC(from);UPDATE_SYNTAX_TABLE_FORWARD without
452 having to check eob between the two. */
453 + (next_interval (i
) ? 0 : 1);
454 gl_state
.forward_i
= i
;
458 gl_state
.b_property
= i
->position
- gl_state
.offset
;
459 gl_state
.backward_i
= i
;
464 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
466 eassert (i
== NULL
); /* This property goes to the end. */
469 gl_state
.e_property
= gl_state
.stop
;
470 gl_state
.forward_i
= i
;
473 gl_state
.b_property
= gl_state
.start
;
477 parse_sexp_propertize (ptrdiff_t charpos
)
480 if (syntax_propertize__done
<= charpos
481 && syntax_propertize__done
< zv
)
483 EMACS_INT modiffs
= CHARS_MODIFF
;
484 safe_call1 (Qinternal__syntax_propertize
,
485 make_number (min (zv
, 1 + charpos
)));
486 if (modiffs
!= CHARS_MODIFF
)
487 error ("parse-sexp-propertize-function modified the buffer!");
488 if (syntax_propertize__done
<= charpos
489 && syntax_propertize__done
< zv
)
490 error ("parse-sexp-propertize-function did not move"
491 " syntax-propertize--done");
492 SETUP_SYNTAX_TABLE (charpos
, 1);
494 else if (gl_state
.e_property
> syntax_propertize__done
)
496 gl_state
.e_property
= syntax_propertize__done
;
497 gl_state
.e_property_truncated
= true;
499 else if (gl_state
.e_property_truncated
500 && gl_state
.e_property
< syntax_propertize__done
)
501 { /* When moving backward, e_property might be set without resetting
502 e_property_truncated, so the e_property_truncated flag may
503 occasionally be left raised spuriously. This should be rare. */
504 gl_state
.e_property_truncated
= false;
505 update_syntax_table_forward (charpos
, false, true, Qnil
);
510 update_syntax_table_forward (ptrdiff_t charpos
, bool init
, bool propertize
,
513 if (gl_state
.e_property_truncated
)
515 eassert (NILP (object
));
516 eassert (charpos
>= gl_state
.e_property
);
520 update_syntax_table (charpos
, 1, init
, object
);
521 propertize
&= (NILP (object
)
522 && gl_state
.e_property
> syntax_propertize__done
);
526 parse_sexp_propertize (charpos
);
529 /* Returns true if char at CHARPOS is quoted.
530 Global syntax-table data should be set up already to be good at CHARPOS
531 or after. On return global syntax data is good for lookup at CHARPOS. */
534 char_quoted (ptrdiff_t charpos
, ptrdiff_t bytepos
)
536 enum syntaxcode code
;
537 ptrdiff_t beg
= BEGV
;
539 ptrdiff_t orig
= charpos
;
541 while (charpos
> beg
)
544 DEC_BOTH (charpos
, bytepos
);
546 UPDATE_SYNTAX_TABLE_BACKWARD (charpos
);
547 c
= FETCH_CHAR_AS_MULTIBYTE (bytepos
);
549 if (! (code
== Scharquote
|| code
== Sescape
))
555 UPDATE_SYNTAX_TABLE (orig
);
559 /* Return the bytepos one character before BYTEPOS.
560 We assume that BYTEPOS is not at the start of the buffer. */
563 dec_bytepos (ptrdiff_t bytepos
)
565 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
572 /* Return a defun-start position before POS and not too far before.
573 It should be the last one before POS, or nearly the last.
575 When open_paren_in_column_0_is_defun_start is nonzero,
576 only the beginning of the buffer is treated as a defun-start.
578 We record the information about where the scan started
579 and what its result was, so that another call in the same area
580 can return the same value very quickly.
582 There is no promise at which position the global syntax data is
583 valid on return from the subroutine, so the caller should explicitly
584 update the global data. */
587 find_defun_start (ptrdiff_t pos
, ptrdiff_t pos_byte
)
589 ptrdiff_t opoint
= PT
, opoint_byte
= PT_BYTE
;
591 /* Use previous finding, if it's valid and applies to this inquiry. */
592 if (current_buffer
== find_start_buffer
593 /* Reuse the defun-start even if POS is a little farther on.
594 POS might be in the next defun, but that's ok.
595 Our value may not be the best possible, but will still be usable. */
596 && pos
<= find_start_pos
+ 1000
597 && pos
>= find_start_value
598 && BEGV
== find_start_begv
599 && MODIFF
== find_start_modiff
)
600 return find_start_value
;
602 if (!open_paren_in_column_0_is_defun_start
)
604 find_start_value
= BEGV
;
605 find_start_value_byte
= BEGV_BYTE
;
609 /* Back up to start of line. */
610 scan_newline (pos
, pos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
612 /* We optimize syntax-table lookup for rare updates. Thus we accept
613 only those `^\s(' which are good in global _and_ text-property
615 SETUP_BUFFER_SYNTAX_TABLE ();
620 /* Open-paren at start of line means we may have found our
622 c
= FETCH_CHAR_AS_MULTIBYTE (PT_BYTE
);
623 if (SYNTAX (c
) == Sopen
)
625 SETUP_SYNTAX_TABLE (PT
+ 1, -1); /* Try again... */
626 c
= FETCH_CHAR_AS_MULTIBYTE (PT_BYTE
);
627 if (SYNTAX (c
) == Sopen
)
629 /* Now fallback to the default value. */
630 SETUP_BUFFER_SYNTAX_TABLE ();
632 /* Move to beg of previous line. */
633 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -2, 1);
636 /* Record what we found, for the next try. */
637 find_start_value
= PT
;
638 find_start_value_byte
= PT_BYTE
;
639 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
642 find_start_buffer
= current_buffer
;
643 find_start_modiff
= MODIFF
;
644 find_start_begv
= BEGV
;
645 find_start_pos
= pos
;
647 return find_start_value
;
650 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
653 prev_char_comend_first (ptrdiff_t pos
, ptrdiff_t pos_byte
)
658 DEC_BOTH (pos
, pos_byte
);
659 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
660 c
= FETCH_CHAR (pos_byte
);
661 val
= SYNTAX_COMEND_FIRST (c
);
662 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
666 /* Check whether charpos FROM is at the end of a comment.
667 FROM_BYTE is the bytepos corresponding to FROM.
668 Do not move back before STOP.
670 Return true if we find a comment ending at FROM/FROM_BYTE.
672 If successful, store the charpos of the comment's beginning
673 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
675 Global syntax data remains valid for backward search starting at
676 the returned value (or at FROM, if the search was not successful). */
679 back_comment (ptrdiff_t from
, ptrdiff_t from_byte
, ptrdiff_t stop
,
680 bool comnested
, int comstyle
, ptrdiff_t *charpos_ptr
,
681 ptrdiff_t *bytepos_ptr
)
683 /* Look back, counting the parity of string-quotes,
684 and recording the comment-starters seen.
685 When we reach a safe place, assume that's not in a string;
686 then step the main scan to the earliest comment-starter seen
687 an even number of string quotes away from the safe place.
689 OFROM[I] is position of the earliest comment-starter seen
690 which is I+2X quotes from the comment-end.
691 PARITY is current parity of quotes from the comment end. */
692 int string_style
= -1; /* Presumed outside of any string. */
693 bool string_lossage
= 0;
694 /* Not a real lossage: indicates that we have passed a matching comment
695 starter plus a non-matching comment-ender, meaning that any matching
696 comment-starter we might see later could be a false positive (hidden
697 inside another comment).
698 Test case: { a (* b } c (* d *) */
699 bool comment_lossage
= 0;
700 ptrdiff_t comment_end
= from
;
701 ptrdiff_t comment_end_byte
= from_byte
;
702 ptrdiff_t comstart_pos
= 0;
703 ptrdiff_t comstart_byte
IF_LINT (= 0);
704 /* Place where the containing defun starts,
705 or 0 if we didn't come across it yet. */
706 ptrdiff_t defun_start
= 0;
707 ptrdiff_t defun_start_byte
= 0;
708 enum syntaxcode code
;
709 ptrdiff_t nesting
= 1; /* Current comment nesting. */
713 /* FIXME: A }} comment-ender style leads to incorrect behavior
714 in the case of {{ c }}} because we ignore the last two chars which are
715 assumed to be comment-enders although they aren't. */
717 /* At beginning of range to scan, we're outside of strings;
718 that determines quote parity to the comment-end. */
723 bool com2start
, com2end
, comstart
;
725 /* Move back and examine a character. */
726 DEC_BOTH (from
, from_byte
);
727 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
729 prev_syntax
= syntax
;
730 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
731 syntax
= SYNTAX_WITH_FLAGS (c
);
734 /* Check for 2-char comment markers. */
735 com2start
= (SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
736 && SYNTAX_FLAGS_COMSTART_SECOND (prev_syntax
)
738 == SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax
, syntax
))
739 && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
)
740 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
);
741 com2end
= (SYNTAX_FLAGS_COMEND_FIRST (syntax
)
742 && SYNTAX_FLAGS_COMEND_SECOND (prev_syntax
));
743 comstart
= (com2start
|| code
== Scomment
);
745 /* Nasty cases with overlapping 2-char comment markers:
746 - snmp-mode: -- c -- foo -- c --
754 /* If a 2-char comment sequence partly overlaps with another,
755 we don't try to be clever. E.g. |*| in C, or }% in modes that
756 have %..\n and %{..}%. */
757 if (from
> stop
&& (com2end
|| comstart
))
759 ptrdiff_t next
= from
, next_byte
= from_byte
;
760 int next_c
, next_syntax
;
761 DEC_BOTH (next
, next_byte
);
762 UPDATE_SYNTAX_TABLE_BACKWARD (next
);
763 next_c
= FETCH_CHAR_AS_MULTIBYTE (next_byte
);
764 next_syntax
= SYNTAX_WITH_FLAGS (next_c
);
765 if (((comstart
|| comnested
)
766 && SYNTAX_FLAGS_COMEND_SECOND (syntax
)
767 && SYNTAX_FLAGS_COMEND_FIRST (next_syntax
))
768 || ((com2end
|| comnested
)
769 && SYNTAX_FLAGS_COMSTART_SECOND (syntax
)
771 == SYNTAX_FLAGS_COMMENT_STYLE (syntax
, prev_syntax
))
772 && SYNTAX_FLAGS_COMSTART_FIRST (next_syntax
)))
774 /* UPDATE_SYNTAX_TABLE_FORWARD (next + 1); */
777 if (com2start
&& comstart_pos
== 0)
778 /* We're looking at a comment starter. But it might be a comment
779 ender as well (see snmp-mode). The first time we see one, we
780 need to consider it as a comment starter,
781 and the subsequent times as a comment ender. */
784 /* Turn a 2-char comment sequences into the appropriate syntax. */
789 /* Ignore comment starters of a different style. */
790 else if (code
== Scomment
791 && (comstyle
!= SYNTAX_FLAGS_COMMENT_STYLE (syntax
, 0)
792 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
) != comnested
))
795 /* Ignore escaped characters, except comment-enders. */
796 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
803 c
= (code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
);
805 /* Track parity of quotes. */
806 if (string_style
== -1)
807 /* Entering a string. */
809 else if (string_style
== c
)
810 /* Leaving the string. */
813 /* If we have two kinds of string delimiters.
814 There's no way to grok this scanning backwards. */
819 /* We've already checked that it is the relevant comstyle. */
820 if (string_style
!= -1 || comment_lossage
|| string_lossage
)
821 /* There are odd string quotes involved, so let's be careful.
822 Test case in Pascal: " { " a { " } */
827 /* Record best comment-starter so far. */
829 comstart_byte
= from_byte
;
831 else if (--nesting
<= 0)
832 /* nested comments have to be balanced, so we don't need to
833 keep looking for earlier ones. We use here the same (slightly
834 incorrect) reasoning as below: since it is followed by uniform
835 paired string quotes, this comment-start has to be outside of
836 strings, else the comment-end itself would be inside a string. */
841 if (SYNTAX_FLAGS_COMMENT_STYLE (syntax
, 0) == comstyle
842 && ((com2end
&& SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
))
843 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
)
844 /* This is the same style of comment ender as ours. */
849 /* Anything before that can't count because it would match
850 this comment-ender rather than ours. */
851 from
= stop
; /* Break out of the loop. */
853 else if (comstart_pos
!= 0 || c
!= '\n')
854 /* We're mixing comment styles here, so we'd better be careful.
855 The (comstart_pos != 0 || c != '\n') check is not quite correct
856 (we should just always set comment_lossage), but removing it
857 would imply that any multiline comment in C would go through
858 lossage, which seems overkill.
859 The failure should only happen in the rare cases such as
865 /* Assume a defun-start point is outside of strings. */
866 if (open_paren_in_column_0_is_defun_start
868 || (temp_byte
= dec_bytepos (from_byte
),
869 FETCH_CHAR (temp_byte
) == '\n')))
872 defun_start_byte
= from_byte
;
873 from
= stop
; /* Break out of the loop. */
882 if (comstart_pos
== 0)
885 from_byte
= comment_end_byte
;
886 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
);
888 /* If comstart_pos is set and we get here (ie. didn't jump to `lossage'
889 or `done'), then we've found the beginning of the non-nested comment. */
890 else if (1) /* !comnested */
893 from_byte
= comstart_byte
;
894 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
898 struct lisp_parse_state state
;
899 bool adjusted
= true;
900 /* We had two kinds of string delimiters mixed up
901 together. Decode this going forwards.
902 Scan fwd from a known safe place (beginning-of-defun)
903 to the one in question; this records where we
904 last passed a comment starter. */
905 /* If we did not already find the defun start, find it now. */
906 if (defun_start
== 0)
908 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
909 defun_start_byte
= find_start_value_byte
;
910 adjusted
= (defun_start
> BEGV
);
914 scan_sexps_forward (&state
,
915 defun_start
, defun_start_byte
,
916 comment_end
, TYPE_MINIMUM (EMACS_INT
),
918 defun_start
= comment_end
;
923 = CONSP (state
.levelstarts
) ? XINT (XCAR (state
.levelstarts
))
924 : state
.thislevelstart
>= 0 ? state
.thislevelstart
926 find_start_value_byte
= CHAR_TO_BYTE (find_start_value
);
929 if (state
.incomment
== (comnested
? 1 : -1)
930 && state
.comstyle
== comstyle
)
931 from
= state
.comstr_start
;
936 /* If comment_end is inside some other comment, maybe ours
937 is nested, so we need to try again from within the
938 surrounding comment. Example: { a (* " *) */
940 /* FIXME: We should advance by one or two chars. */
941 defun_start
= state
.comstr_start
+ 2;
942 defun_start_byte
= CHAR_TO_BYTE (defun_start
);
945 } while (defun_start
< comment_end
);
947 from_byte
= CHAR_TO_BYTE (from
);
948 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
953 *bytepos_ptr
= from_byte
;
955 return from
!= comment_end
;
958 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
959 doc
: /* Return t if OBJECT is a syntax table.
960 Currently, any char-table counts as a syntax table. */)
963 if (CHAR_TABLE_P (object
)
964 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
970 check_syntax_table (Lisp_Object obj
)
972 CHECK_TYPE (CHAR_TABLE_P (obj
) && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
),
973 Qsyntax_table_p
, obj
);
976 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
977 doc
: /* Return the current syntax table.
978 This is the one specified by the current buffer. */)
981 return BVAR (current_buffer
, syntax_table
);
984 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
985 Sstandard_syntax_table
, 0, 0, 0,
986 doc
: /* Return the standard syntax table.
987 This is the one used for new buffers. */)
990 return Vstandard_syntax_table
;
993 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
994 doc
: /* Construct a new syntax table and return it.
995 It is a copy of the TABLE, which defaults to the standard syntax table. */)
1001 check_syntax_table (table
);
1003 table
= Vstandard_syntax_table
;
1005 copy
= Fcopy_sequence (table
);
1007 /* Only the standard syntax table should have a default element.
1008 Other syntax tables should inherit from parents instead. */
1009 set_char_table_defalt (copy
, Qnil
);
1011 /* Copied syntax tables should all have parents.
1012 If we copied one with no parent, such as the standard syntax table,
1013 use the standard syntax table as the copy's parent. */
1014 if (NILP (XCHAR_TABLE (copy
)->parent
))
1015 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
1019 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
1020 doc
: /* Select a new syntax table for the current buffer.
1021 One argument, a syntax table. */)
1025 check_syntax_table (table
);
1026 bset_syntax_table (current_buffer
, table
);
1027 /* Indicate that this buffer now has a specified syntax table. */
1028 idx
= PER_BUFFER_VAR_IDX (syntax_table
);
1029 SET_PER_BUFFER_VALUE_P (current_buffer
, idx
, 1);
1033 /* Convert a letter which signifies a syntax code
1034 into the code it signifies.
1035 This is used by modify-syntax-entry, and other things. */
1037 unsigned char const syntax_spec_code
[0400] =
1038 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
1039 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
1040 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
1041 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
1042 Swhitespace
, Scomment_fence
, Sstring
, 0377, Smath
, 0377, 0377, Squote
,
1043 Sopen
, Sclose
, 0377, 0377, 0377, Swhitespace
, Spunct
, Scharquote
,
1044 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
1045 0377, 0377, 0377, 0377, Scomment
, 0377, Sendcomment
, 0377,
1046 Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
1047 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
1048 0377, 0377, 0377, 0377, 0377, 0377, 0377, Sword
,
1049 0377, 0377, 0377, 0377, Sescape
, 0377, 0377, Ssymbol
,
1050 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
1051 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
1052 0377, 0377, 0377, 0377, 0377, 0377, 0377, Sword
,
1053 0377, 0377, 0377, 0377, Sstring_fence
, 0377, 0377, 0377
1056 /* Indexed by syntax code, give the letter that describes it. */
1058 char const syntax_code_spec
[16] =
1060 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
1064 /* Indexed by syntax code, give the object (cons of syntax code and
1065 nil) to be stored in syntax table. Since these objects can be
1066 shared among syntax tables, we generate them in advance. By
1067 sharing objects, the function `describe-syntax' can give a more
1069 static Lisp_Object Vsyntax_code_object
;
1072 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
1073 doc
: /* Return the syntax code of CHARACTER, described by a character.
1074 For example, if CHARACTER is a word constituent, the
1075 character `w' (119) is returned.
1076 The characters that correspond to various syntax codes
1077 are listed in the documentation of `modify-syntax-entry'. */)
1078 (Lisp_Object character
)
1081 CHECK_CHARACTER (character
);
1082 char_int
= XINT (character
);
1083 SETUP_BUFFER_SYNTAX_TABLE ();
1084 return make_number (syntax_code_spec
[SYNTAX (char_int
)]);
1087 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
1088 doc
: /* Return the matching parenthesis of CHARACTER, or nil if none. */)
1089 (Lisp_Object character
)
1092 enum syntaxcode code
;
1093 CHECK_CHARACTER (character
);
1094 char_int
= XINT (character
);
1095 SETUP_BUFFER_SYNTAX_TABLE ();
1096 code
= SYNTAX (char_int
);
1097 if (code
== Sopen
|| code
== Sclose
)
1098 return SYNTAX_MATCH (char_int
);
1102 DEFUN ("string-to-syntax", Fstring_to_syntax
, Sstring_to_syntax
, 1, 1, 0,
1103 doc
: /* Convert a syntax descriptor STRING into a raw syntax descriptor.
1104 STRING should be a string of the form allowed as argument of
1105 `modify-syntax-entry'. The return value is a raw syntax descriptor: a
1106 cons cell (CODE . MATCHING-CHAR) which can be used, for example, as
1107 the value of a `syntax-table' text property. */)
1108 (Lisp_Object string
)
1110 const unsigned char *p
;
1114 CHECK_STRING (string
);
1117 val
= syntax_spec_code
[*p
++];
1119 error ("Invalid syntax description letter: %c", p
[-1]);
1121 if (val
== Sinherit
)
1127 int character
= STRING_CHAR_AND_LENGTH (p
, len
);
1128 XSETINT (match
, character
);
1129 if (XFASTINT (match
) == ' ')
1172 if (val
< ASIZE (Vsyntax_code_object
) && NILP (match
))
1173 return AREF (Vsyntax_code_object
, val
);
1175 /* Since we can't use a shared object, let's make a new one. */
1176 return Fcons (make_number (val
), match
);
1179 /* I really don't know why this is interactive
1180 help-form should at least be made useful whilst reading the second arg. */
1181 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
1182 "cSet syntax for character: \nsSet syntax for %s to: ",
1183 doc
: /* Set syntax for character CHAR according to string NEWENTRY.
1184 The syntax is changed only for table SYNTAX-TABLE, which defaults to
1185 the current buffer's syntax table.
1186 CHAR may be a cons (MIN . MAX), in which case, syntaxes of all characters
1187 in the range MIN to MAX are changed.
1188 The first character of NEWENTRY should be one of the following:
1189 Space or - whitespace syntax. w word constituent.
1190 _ symbol constituent. . punctuation.
1191 ( open-parenthesis. ) close-parenthesis.
1192 " string quote. \\ escape.
1193 $ paired delimiter. \\=' expression quote or prefix operator.
1194 < comment starter. > comment ender.
1195 / character-quote. @ inherit from parent table.
1196 | generic string fence. ! generic comment fence.
1198 Only single-character comment start and end sequences are represented thus.
1199 Two-character sequences are represented as described below.
1200 The second character of NEWENTRY is the matching parenthesis,
1201 used only if the first character is `(' or `)'.
1202 Any additional characters are flags.
1203 Defined flags are the characters 1, 2, 3, 4, b, p, and n.
1204 1 means CHAR is the start of a two-char comment start sequence.
1205 2 means CHAR is the second character of such a sequence.
1206 3 means CHAR is the start of a two-char comment end sequence.
1207 4 means CHAR is the second character of such a sequence.
1209 There can be several orthogonal comment sequences. This is to support
1210 language modes such as C++. By default, all comment sequences are of style
1211 a, but you can set the comment sequence style to b (on the second character
1212 of a comment-start, and the first character of a comment-end sequence) and/or
1213 c (on any of its chars) using this flag:
1214 b means CHAR is part of comment sequence b.
1215 c means CHAR is part of comment sequence c.
1216 n means CHAR is part of a nestable comment sequence.
1218 p means CHAR is a prefix character for `backward-prefix-chars';
1219 such characters are treated as whitespace when they occur
1220 between expressions.
1221 usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE) */)
1222 (Lisp_Object c
, Lisp_Object newentry
, Lisp_Object syntax_table
)
1226 CHECK_CHARACTER_CAR (c
);
1227 CHECK_CHARACTER_CDR (c
);
1230 CHECK_CHARACTER (c
);
1232 if (NILP (syntax_table
))
1233 syntax_table
= BVAR (current_buffer
, syntax_table
);
1235 check_syntax_table (syntax_table
);
1237 newentry
= Fstring_to_syntax (newentry
);
1239 SET_RAW_SYNTAX_ENTRY_RANGE (syntax_table
, c
, newentry
);
1241 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), newentry
);
1243 /* We clear the regexp cache, since character classes can now have
1244 different values from those in the compiled regexps.*/
1245 clear_regexp_cache ();
1250 /* Dump syntax table to buffer in human-readable format */
1252 DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value
,
1253 Sinternal_describe_syntax_value
, 1, 1, 0,
1254 doc
: /* Insert a description of the internal syntax description SYNTAX at point. */)
1255 (Lisp_Object syntax
)
1257 int code
, syntax_code
;
1258 bool start1
, start2
, end1
, end2
, prefix
, comstyleb
, comstylec
, comnested
;
1260 Lisp_Object first
, match_lisp
, value
= syntax
;
1264 insert_string ("default");
1268 if (CHAR_TABLE_P (value
))
1270 insert_string ("deeper char-table ...");
1276 insert_string ("invalid");
1280 first
= XCAR (value
);
1281 match_lisp
= XCDR (value
);
1283 if (!INTEGERP (first
) || !(NILP (match_lisp
) || CHARACTERP (match_lisp
)))
1285 insert_string ("invalid");
1289 syntax_code
= XINT (first
) & INT_MAX
;
1290 code
= syntax_code
& 0377;
1291 start1
= SYNTAX_FLAGS_COMSTART_FIRST (syntax_code
);
1292 start2
= SYNTAX_FLAGS_COMSTART_SECOND (syntax_code
);
1293 end1
= SYNTAX_FLAGS_COMEND_FIRST (syntax_code
);
1294 end2
= SYNTAX_FLAGS_COMEND_SECOND (syntax_code
);
1295 prefix
= SYNTAX_FLAGS_PREFIX (syntax_code
);
1296 comstyleb
= SYNTAX_FLAGS_COMMENT_STYLEB (syntax_code
);
1297 comstylec
= SYNTAX_FLAGS_COMMENT_STYLEC (syntax_code
);
1298 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (syntax_code
);
1302 insert_string ("invalid");
1306 str
[0] = syntax_code_spec
[code
], str
[1] = 0;
1309 if (NILP (match_lisp
))
1312 insert_char (XINT (match_lisp
));
1333 insert_string ("\twhich means: ");
1338 insert_string ("whitespace"); break;
1340 insert_string ("punctuation"); break;
1342 insert_string ("word"); break;
1344 insert_string ("symbol"); break;
1346 insert_string ("open"); break;
1348 insert_string ("close"); break;
1350 insert_string ("prefix"); break;
1352 insert_string ("string"); break;
1354 insert_string ("math"); break;
1356 insert_string ("escape"); break;
1358 insert_string ("charquote"); break;
1360 insert_string ("comment"); break;
1362 insert_string ("endcomment"); break;
1364 insert_string ("inherit"); break;
1365 case Scomment_fence
:
1366 insert_string ("comment fence"); break;
1368 insert_string ("string fence"); break;
1370 insert_string ("invalid");
1374 if (!NILP (match_lisp
))
1376 insert_string (", matches ");
1377 insert_char (XINT (match_lisp
));
1381 insert_string (",\n\t is the first character of a comment-start sequence");
1383 insert_string (",\n\t is the second character of a comment-start sequence");
1386 insert_string (",\n\t is the first character of a comment-end sequence");
1388 insert_string (",\n\t is the second character of a comment-end sequence");
1390 insert_string (" (comment style b)");
1392 insert_string (" (comment style c)");
1394 insert_string (" (nestable)");
1398 AUTO_STRING (prefixdoc
,
1399 ",\n\t is a prefix character for `backward-prefix-chars'");
1400 insert1 (Fsubstitute_command_keys (prefixdoc
));
1406 /* Return the position across COUNT words from FROM.
1407 If that many words cannot be found before the end of the buffer, return 0.
1408 COUNT negative means scan backward and stop at word beginning. */
1411 scan_words (register ptrdiff_t from
, register EMACS_INT count
)
1413 register ptrdiff_t beg
= BEGV
;
1414 register ptrdiff_t end
= ZV
;
1415 register ptrdiff_t from_byte
= CHAR_TO_BYTE (from
);
1416 register enum syntaxcode code
;
1418 Lisp_Object func
, pos
;
1423 SETUP_SYNTAX_TABLE (from
, count
);
1434 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1435 ch0
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1436 code
= SYNTAX (ch0
);
1437 INC_BOTH (from
, from_byte
);
1438 if (words_include_escapes
1439 && (code
== Sescape
|| code
== Scharquote
))
1444 /* Now CH0 is a character which begins a word and FROM is the
1445 position of the next character. */
1446 func
= CHAR_TABLE_REF (Vfind_word_boundary_function_table
, ch0
);
1447 if (! NILP (Ffboundp (func
)))
1449 pos
= call2 (func
, make_number (from
- 1), make_number (end
));
1450 if (INTEGERP (pos
) && from
< XINT (pos
) && XINT (pos
) <= ZV
)
1453 from_byte
= CHAR_TO_BYTE (from
);
1460 if (from
== end
) break;
1461 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1462 ch1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1463 code
= SYNTAX (ch1
);
1465 && (! words_include_escapes
1466 || (code
!= Sescape
&& code
!= Scharquote
)))
1467 || word_boundary_p (ch0
, ch1
))
1469 INC_BOTH (from
, from_byte
);
1484 DEC_BOTH (from
, from_byte
);
1485 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1486 ch1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1487 code
= SYNTAX (ch1
);
1488 if (words_include_escapes
1489 && (code
== Sescape
|| code
== Scharquote
))
1494 /* Now CH1 is a character which ends a word and FROM is the
1496 func
= CHAR_TABLE_REF (Vfind_word_boundary_function_table
, ch1
);
1497 if (! NILP (Ffboundp (func
)))
1499 pos
= call2 (func
, make_number (from
), make_number (beg
));
1500 if (INTEGERP (pos
) && BEGV
<= XINT (pos
) && XINT (pos
) < from
)
1503 from_byte
= CHAR_TO_BYTE (from
);
1512 DEC_BOTH (from
, from_byte
);
1513 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1514 ch0
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1515 code
= SYNTAX (ch0
);
1517 && (! words_include_escapes
1518 || (code
!= Sescape
&& code
!= Scharquote
)))
1519 || word_boundary_p (ch0
, ch1
))
1521 INC_BOTH (from
, from_byte
);
1535 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 0, 1, "^p",
1536 doc
: /* Move point forward ARG words (backward if ARG is negative).
1537 If ARG is omitted or nil, move point forward one word.
1539 If an edge of the buffer or a field boundary is reached, point is left there
1540 and the function returns nil. Field boundaries are not noticed if
1541 `inhibit-field-text-motion' is non-nil. */)
1545 ptrdiff_t orig_val
, val
;
1548 XSETFASTINT (arg
, 1);
1552 val
= orig_val
= scan_words (PT
, XINT (arg
));
1554 val
= XINT (arg
) > 0 ? ZV
: BEGV
;
1556 /* Avoid jumping out of an input field. */
1557 tmp
= Fconstrain_to_field (make_number (val
), make_number (PT
),
1559 val
= XFASTINT (tmp
);
1562 return val
== orig_val
? Qt
: Qnil
;
1565 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1566 doc
: /* Move point forward, stopping before a char not in STRING, or at pos LIM.
1567 STRING is like the inside of a `[...]' in a regular expression
1568 except that `]' is never special and `\\' quotes `^', `-' or `\\'
1569 (but not at the end of a range; quoting is never needed there).
1570 Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
1571 With arg "^a-zA-Z", skips nonletters stopping before first letter.
1572 Char classes, e.g. `[:alpha:]', are supported.
1574 Returns the distance traveled, either zero or positive. */)
1575 (Lisp_Object string
, Lisp_Object lim
)
1577 return skip_chars (1, string
, lim
, 1);
1580 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1581 doc
: /* Move point backward, stopping after a char not in STRING, or at pos LIM.
1582 See `skip-chars-forward' for details.
1583 Returns the distance traveled, either zero or negative. */)
1584 (Lisp_Object string
, Lisp_Object lim
)
1586 return skip_chars (0, string
, lim
, 1);
1589 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1590 doc
: /* Move point forward across chars in specified syntax classes.
1591 SYNTAX is a string of syntax code characters.
1592 Stop before a char whose syntax is not in SYNTAX, or at position LIM.
1593 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1594 This function returns the distance traveled, either zero or positive. */)
1595 (Lisp_Object syntax
, Lisp_Object lim
)
1597 return skip_syntaxes (1, syntax
, lim
);
1600 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1601 doc
: /* Move point backward across chars in specified syntax classes.
1602 SYNTAX is a string of syntax code characters.
1603 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
1604 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1605 This function returns either zero or a negative number, and the absolute value
1606 of this is the distance traveled. */)
1607 (Lisp_Object syntax
, Lisp_Object lim
)
1609 return skip_syntaxes (0, syntax
, lim
);
1613 skip_chars (bool forwardp
, Lisp_Object string
, Lisp_Object lim
,
1614 bool handle_iso_classes
)
1618 /* Store the ranges of non-ASCII characters. */
1619 int *char_ranges
IF_LINT (= NULL
);
1620 int n_char_ranges
= 0;
1622 ptrdiff_t i
, i_byte
;
1623 /* True if the current buffer is multibyte and the region contains
1626 /* True if STRING is multibyte and it contains non-ASCII chars. */
1627 bool string_multibyte
;
1628 ptrdiff_t size_byte
;
1629 const unsigned char *str
;
1631 Lisp_Object iso_classes
;
1634 CHECK_STRING (string
);
1638 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1640 CHECK_NUMBER_COERCE_MARKER (lim
);
1642 /* In any case, don't allow scan outside bounds of buffer. */
1643 if (XINT (lim
) > ZV
)
1644 XSETFASTINT (lim
, ZV
);
1645 if (XINT (lim
) < BEGV
)
1646 XSETFASTINT (lim
, BEGV
);
1648 multibyte
= (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
1649 && (XINT (lim
) - PT
!= CHAR_TO_BYTE (XINT (lim
)) - PT_BYTE
));
1650 string_multibyte
= SBYTES (string
) > SCHARS (string
);
1652 memset (fastmap
, 0, sizeof fastmap
);
1654 str
= SDATA (string
);
1655 size_byte
= SBYTES (string
);
1658 if (i_byte
< size_byte
1659 && SREF (string
, 0) == '^')
1661 negate
= 1; i_byte
++;
1664 /* Find the characters specified and set their elements of fastmap.
1665 Handle backslashes and ranges specially.
1667 If STRING contains non-ASCII characters, setup char_ranges for
1668 them and use fastmap only for their leading codes. */
1670 if (! string_multibyte
)
1672 bool string_has_eight_bit
= 0;
1674 /* At first setup fastmap. */
1675 while (i_byte
< size_byte
)
1679 if (handle_iso_classes
&& c
== '['
1680 && i_byte
< size_byte
1681 && str
[i_byte
] == ':')
1683 const unsigned char *class_beg
= str
+ i_byte
+ 1;
1684 const unsigned char *class_end
= class_beg
;
1685 const unsigned char *class_limit
= str
+ size_byte
- 2;
1686 /* Leave room for the null. */
1687 unsigned char class_name
[CHAR_CLASS_MAX_LENGTH
+ 1];
1690 if (class_limit
- class_beg
> CHAR_CLASS_MAX_LENGTH
)
1691 class_limit
= class_beg
+ CHAR_CLASS_MAX_LENGTH
;
1693 while (class_end
< class_limit
1694 && *class_end
>= 'a' && *class_end
<= 'z')
1697 if (class_end
== class_beg
1698 || *class_end
!= ':' || class_end
[1] != ']')
1699 goto not_a_class_name
;
1701 memcpy (class_name
, class_beg
, class_end
- class_beg
);
1702 class_name
[class_end
- class_beg
] = 0;
1704 cc
= re_wctype (class_name
);
1706 error ("Invalid ISO C character class");
1708 iso_classes
= Fcons (make_number (cc
), iso_classes
);
1710 i_byte
= class_end
+ 2 - str
;
1717 if (i_byte
== size_byte
)
1722 /* Treat `-' as range character only if another character
1724 if (i_byte
+ 1 < size_byte
1725 && str
[i_byte
] == '-')
1729 /* Skip over the dash. */
1732 /* Get the end of the range. */
1735 && i_byte
< size_byte
)
1743 if (! ASCII_CHAR_P (c2
))
1744 string_has_eight_bit
= 1;
1750 if (! ASCII_CHAR_P (c
))
1751 string_has_eight_bit
= 1;
1755 /* If the current range is multibyte and STRING contains
1756 eight-bit chars, arrange fastmap and setup char_ranges for
1757 the corresponding multibyte chars. */
1758 if (multibyte
&& string_has_eight_bit
)
1761 char himap
[0200 + 1];
1762 memcpy (himap
, fastmap
+ 0200, 0200);
1764 memset (fastmap
+ 0200, 0, 0200);
1765 SAFE_NALLOCA (char_ranges
, 2, 128);
1768 while ((p1
= memchr (himap
+ i
, 1, 0200 - i
)))
1770 /* Deduce the next range C..C2 from the next clump of 1s
1771 in HIMAP starting with &HIMAP[I]. HIMAP is the high
1772 order half of the old FASTMAP. */
1773 int c2
, leading_code
;
1775 c
= BYTE8_TO_CHAR (i
+ 0200);
1777 c2
= BYTE8_TO_CHAR (i
+ 0200 - 1);
1779 char_ranges
[n_char_ranges
++] = c
;
1780 char_ranges
[n_char_ranges
++] = c2
;
1781 leading_code
= CHAR_LEADING_CODE (c
);
1782 memset (fastmap
+ leading_code
, 1,
1783 CHAR_LEADING_CODE (c2
) - leading_code
+ 1);
1787 else /* STRING is multibyte */
1789 SAFE_NALLOCA (char_ranges
, 2, SCHARS (string
));
1791 while (i_byte
< size_byte
)
1793 int leading_code
= str
[i_byte
];
1794 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
);
1797 if (handle_iso_classes
&& c
== '['
1798 && i_byte
< size_byte
1799 && STRING_CHAR (str
+ i_byte
) == ':')
1801 const unsigned char *class_beg
= str
+ i_byte
+ 1;
1802 const unsigned char *class_end
= class_beg
;
1803 const unsigned char *class_limit
= str
+ size_byte
- 2;
1804 /* Leave room for the null. */
1805 unsigned char class_name
[CHAR_CLASS_MAX_LENGTH
+ 1];
1808 if (class_limit
- class_beg
> CHAR_CLASS_MAX_LENGTH
)
1809 class_limit
= class_beg
+ CHAR_CLASS_MAX_LENGTH
;
1811 while (class_end
< class_limit
1812 && *class_end
>= 'a' && *class_end
<= 'z')
1815 if (class_end
== class_beg
1816 || *class_end
!= ':' || class_end
[1] != ']')
1817 goto not_a_class_name_multibyte
;
1819 memcpy (class_name
, class_beg
, class_end
- class_beg
);
1820 class_name
[class_end
- class_beg
] = 0;
1822 cc
= re_wctype (class_name
);
1824 error ("Invalid ISO C character class");
1826 iso_classes
= Fcons (make_number (cc
), iso_classes
);
1828 i_byte
= class_end
+ 2 - str
;
1832 not_a_class_name_multibyte
:
1835 if (i_byte
== size_byte
)
1838 leading_code
= str
[i_byte
];
1839 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
);
1842 /* Treat `-' as range character only if another character
1844 if (i_byte
+ 1 < size_byte
1845 && str
[i_byte
] == '-')
1847 int c2
, leading_code2
;
1849 /* Skip over the dash. */
1852 /* Get the end of the range. */
1853 leading_code2
= str
[i_byte
];
1854 c2
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
);
1858 && i_byte
< size_byte
)
1860 leading_code2
= str
[i_byte
];
1861 c2
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
);
1867 if (ASCII_CHAR_P (c
))
1869 while (c
<= c2
&& c
< 0x80)
1871 leading_code
= CHAR_LEADING_CODE (c
);
1873 if (! ASCII_CHAR_P (c
))
1875 int lim2
= leading_code2
+ 1;
1876 while (leading_code
< lim2
)
1877 fastmap
[leading_code
++] = 1;
1880 char_ranges
[n_char_ranges
++] = c
;
1881 char_ranges
[n_char_ranges
++] = c2
;
1887 if (ASCII_CHAR_P (c
))
1891 fastmap
[leading_code
] = 1;
1892 char_ranges
[n_char_ranges
++] = c
;
1893 char_ranges
[n_char_ranges
++] = c
;
1898 /* If the current range is unibyte and STRING contains non-ASCII
1899 chars, arrange fastmap for the corresponding unibyte
1902 if (! multibyte
&& n_char_ranges
> 0)
1904 memset (fastmap
+ 0200, 0, 0200);
1905 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1907 int c1
= char_ranges
[i
];
1908 int lim2
= char_ranges
[i
+ 1] + 1;
1910 for (; c1
< lim2
; c1
++)
1912 int b
= CHAR_TO_BYTE_SAFE (c1
);
1920 /* If ^ was the first character, complement the fastmap. */
1924 for (i
= 0; i
< sizeof fastmap
; i
++)
1928 for (i
= 0; i
< 0200; i
++)
1930 /* All non-ASCII chars possibly match. */
1931 for (; i
< sizeof fastmap
; i
++)
1937 ptrdiff_t start_point
= PT
;
1939 ptrdiff_t pos_byte
= PT_BYTE
;
1940 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
1944 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
1945 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
1949 endp
= CHAR_POS_ADDR (XINT (lim
));
1950 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
1954 /* This code may look up syntax tables using functions that rely on the
1955 gl_state object. To make sure this object is not out of date,
1956 let's initialize it manually.
1957 We ignore syntax-table text-properties for now, since that's
1958 what we've done in the past. */
1959 SETUP_BUFFER_SYNTAX_TABLE ();
1974 c
= STRING_CHAR_AND_LENGTH (p
, nbytes
);
1975 if (! NILP (iso_classes
) && in_classes (c
, iso_classes
))
1985 if (! ASCII_CHAR_P (c
))
1987 /* As we are looking at a multibyte character, we
1988 must look up the character in the table
1989 CHAR_RANGES. If there's no data in the table,
1990 that character is not what we want to skip. */
1992 /* The following code do the right thing even if
1993 n_char_ranges is zero (i.e. no data in
1995 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1996 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1998 if (!(negate
^ (i
< n_char_ranges
)))
2002 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
2015 if (!NILP (iso_classes
) && in_classes (*p
, iso_classes
))
2020 goto fwd_unibyte_ok
;
2026 p
++, pos
++, pos_byte
++;
2034 unsigned char *prev_p
;
2044 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
2045 c
= STRING_CHAR (p
);
2047 if (! NILP (iso_classes
) && in_classes (c
, iso_classes
))
2057 if (! ASCII_CHAR_P (c
))
2059 /* See the comment in the previous similar code. */
2060 for (i
= 0; i
< n_char_ranges
; i
+= 2)
2061 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
2063 if (!(negate
^ (i
< n_char_ranges
)))
2067 pos
--, pos_byte
-= prev_p
- p
;
2080 if (! NILP (iso_classes
) && in_classes (p
[-1], iso_classes
))
2085 goto back_unibyte_ok
;
2088 if (!fastmap
[p
[-1]])
2091 p
--, pos
--, pos_byte
--;
2095 SET_PT_BOTH (pos
, pos_byte
);
2099 return make_number (PT
- start_point
);
2105 skip_syntaxes (bool forwardp
, Lisp_Object string
, Lisp_Object lim
)
2108 unsigned char fastmap
[0400];
2110 ptrdiff_t i
, i_byte
;
2112 ptrdiff_t size_byte
;
2115 CHECK_STRING (string
);
2118 XSETINT (lim
, forwardp
? ZV
: BEGV
);
2120 CHECK_NUMBER_COERCE_MARKER (lim
);
2122 /* In any case, don't allow scan outside bounds of buffer. */
2123 if (XINT (lim
) > ZV
)
2124 XSETFASTINT (lim
, ZV
);
2125 if (XINT (lim
) < BEGV
)
2126 XSETFASTINT (lim
, BEGV
);
2128 if (forwardp
? (PT
>= XFASTINT (lim
)) : (PT
<= XFASTINT (lim
)))
2129 return make_number (0);
2131 multibyte
= (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
2132 && (XINT (lim
) - PT
!= CHAR_TO_BYTE (XINT (lim
)) - PT_BYTE
));
2134 memset (fastmap
, 0, sizeof fastmap
);
2136 if (SBYTES (string
) > SCHARS (string
))
2137 /* As this is very rare case (syntax spec is ASCII only), don't
2138 consider efficiency. */
2139 string
= string_make_unibyte (string
);
2141 str
= SDATA (string
);
2142 size_byte
= SBYTES (string
);
2145 if (i_byte
< size_byte
2146 && SREF (string
, 0) == '^')
2148 negate
= 1; i_byte
++;
2151 /* Find the syntaxes specified and set their elements of fastmap. */
2153 while (i_byte
< size_byte
)
2156 fastmap
[syntax_spec_code
[c
]] = 1;
2159 /* If ^ was the first character, complement the fastmap. */
2161 for (i
= 0; i
< sizeof fastmap
; i
++)
2165 ptrdiff_t start_point
= PT
;
2167 ptrdiff_t pos_byte
= PT_BYTE
;
2168 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
2172 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
2173 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
2177 endp
= CHAR_POS_ADDR (XINT (lim
));
2178 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
2182 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
2198 c
= STRING_CHAR_AND_LENGTH (p
, nbytes
);
2199 if (! fastmap
[SYNTAX (c
)])
2201 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
2202 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
2216 if (! fastmap
[SYNTAX (*p
)])
2218 p
++, pos
++, pos_byte
++;
2219 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
2229 unsigned char *prev_p
;
2238 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
2240 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
2241 c
= STRING_CHAR (p
);
2242 if (! fastmap
[SYNTAX (c
)])
2244 pos
--, pos_byte
-= prev_p
- p
;
2258 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
2259 if (! fastmap
[SYNTAX (p
[-1])])
2261 p
--, pos
--, pos_byte
--;
2266 SET_PT_BOTH (pos
, pos_byte
);
2269 return make_number (PT
- start_point
);
2273 /* Return true if character C belongs to one of the ISO classes
2274 in the list ISO_CLASSES. Each class is represented by an
2275 integer which is its type according to re_wctype. */
2278 in_classes (int c
, Lisp_Object iso_classes
)
2280 bool fits_class
= 0;
2282 while (CONSP (iso_classes
))
2285 elt
= XCAR (iso_classes
);
2286 iso_classes
= XCDR (iso_classes
);
2288 if (re_iswctype (c
, XFASTINT (elt
)))
2295 /* Jump over a comment, assuming we are at the beginning of one.
2296 FROM is the current position.
2297 FROM_BYTE is the bytepos corresponding to FROM.
2298 Do not move past STOP (a charpos).
2299 The comment over which we have to jump is of style STYLE
2300 (either SYNTAX_FLAGS_COMMENT_STYLE (foo) or ST_COMMENT_STYLE).
2301 NESTING should be positive to indicate the nesting at the beginning
2302 for nested comments and should be zero or negative else.
2303 ST_COMMENT_STYLE cannot be nested.
2304 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
2305 (or 0 If the search cannot start in the middle of a two-character).
2307 If successful, return true and store the charpos of the comment's end
2308 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
2309 Else, return false and store the charpos STOP into *CHARPOS_PTR, the
2310 corresponding bytepos into *BYTEPOS_PTR and the current nesting
2311 (as defined for state.incomment) in *INCOMMENT_PTR.
2313 The comment end is the last character of the comment rather than the
2314 character just after the comment.
2316 Global syntax data is assumed to initially be valid for FROM and
2317 remains valid for forward search starting at the returned position. */
2320 forw_comment (ptrdiff_t from
, ptrdiff_t from_byte
, ptrdiff_t stop
,
2321 EMACS_INT nesting
, int style
, int prev_syntax
,
2322 ptrdiff_t *charpos_ptr
, ptrdiff_t *bytepos_ptr
,
2323 EMACS_INT
*incomment_ptr
)
2326 register enum syntaxcode code
;
2327 register int syntax
, other_syntax
;
2329 if (nesting
<= 0) nesting
= -1;
2331 /* Enter the loop in the middle so that we find
2332 a 2-char comment ender if we start in the middle of it. */
2333 syntax
= prev_syntax
;
2334 if (syntax
!= 0) goto forw_incomment
;
2340 *incomment_ptr
= nesting
;
2341 *charpos_ptr
= from
;
2342 *bytepos_ptr
= from_byte
;
2345 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2346 syntax
= SYNTAX_WITH_FLAGS (c
);
2347 code
= syntax
& 0xff;
2348 if (code
== Sendcomment
2349 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
, 0) == style
2350 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ?
2351 (nesting
> 0 && --nesting
== 0) : nesting
< 0))
2352 /* We have encountered a comment end of the same style
2353 as the comment sequence which began this comment
2356 if (code
== Scomment_fence
2357 && style
== ST_COMMENT_STYLE
)
2358 /* We have encountered a comment end of the same style
2359 as the comment sequence which began this comment
2364 && SYNTAX_FLAGS_COMMENT_NESTED (syntax
)
2365 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
, 0) == style
)
2366 /* We have encountered a nested comment of the same style
2367 as the comment sequence which began this comment section. */
2369 INC_BOTH (from
, from_byte
);
2370 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2373 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
2374 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2375 other_syntax
= SYNTAX_WITH_FLAGS (c1
),
2376 SYNTAX_FLAGS_COMEND_SECOND (other_syntax
))
2377 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
, other_syntax
) == style
2378 && ((SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
2379 SYNTAX_FLAGS_COMMENT_NESTED (other_syntax
))
2380 ? nesting
> 0 : nesting
< 0))
2383 /* We have encountered a comment end of the same style
2384 as the comment sequence which began this comment section. */
2388 INC_BOTH (from
, from_byte
);
2389 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2394 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
2395 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2396 other_syntax
= SYNTAX_WITH_FLAGS (c1
),
2397 SYNTAX_FLAGS_COMMENT_STYLE (other_syntax
, syntax
) == style
2398 && SYNTAX_FLAGS_COMSTART_SECOND (other_syntax
))
2399 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
2400 SYNTAX_FLAGS_COMMENT_NESTED (other_syntax
)))
2401 /* We have encountered a nested comment of the same style
2402 as the comment sequence which began this comment section. */
2404 INC_BOTH (from
, from_byte
);
2405 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2409 *charpos_ptr
= from
;
2410 *bytepos_ptr
= from_byte
;
2414 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
2416 Move forward across up to COUNT comments. If COUNT is negative, move backward.
2417 Stop scanning if we find something other than a comment or whitespace.
2418 Set point to where scanning stops.
2419 If COUNT comments are found as expected, with nothing except whitespace
2420 between them, return t; otherwise return nil. */)
2423 ptrdiff_t from
, from_byte
, stop
;
2425 enum syntaxcode code
;
2426 int comstyle
= 0; /* style of comment encountered */
2427 bool comnested
= 0; /* whether the comment is nestable or not */
2430 ptrdiff_t out_charpos
, out_bytepos
;
2433 CHECK_NUMBER (count
);
2434 count1
= XINT (count
);
2435 stop
= count1
> 0 ? ZV
: BEGV
;
2441 from_byte
= PT_BYTE
;
2443 SETUP_SYNTAX_TABLE (from
, count1
);
2448 bool comstart_first
;
2449 int syntax
, other_syntax
;
2453 SET_PT_BOTH (from
, from_byte
);
2457 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2458 syntax
= SYNTAX_WITH_FLAGS (c
);
2460 comstart_first
= SYNTAX_FLAGS_COMSTART_FIRST (syntax
);
2461 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (syntax
);
2462 comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (syntax
, 0);
2463 INC_BOTH (from
, from_byte
);
2464 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2465 if (from
< stop
&& comstart_first
2466 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2467 other_syntax
= SYNTAX_WITH_FLAGS (c1
),
2468 SYNTAX_FLAGS_COMSTART_SECOND (other_syntax
)))
2470 /* We have encountered a comment start sequence and we
2471 are ignoring all text inside comments. We must record
2472 the comment style this sequence begins so that later,
2473 only a comment end of the same style actually ends
2474 the comment section. */
2476 comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (other_syntax
, syntax
);
2477 comnested
|= SYNTAX_FLAGS_COMMENT_NESTED (other_syntax
);
2478 INC_BOTH (from
, from_byte
);
2479 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2482 while (code
== Swhitespace
|| (code
== Sendcomment
&& c
== '\n'));
2484 if (code
== Scomment_fence
)
2485 comstyle
= ST_COMMENT_STYLE
;
2486 else if (code
!= Scomment
)
2489 DEC_BOTH (from
, from_byte
);
2490 SET_PT_BOTH (from
, from_byte
);
2493 /* We're at the start of a comment. */
2494 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
2495 &out_charpos
, &out_bytepos
, &dummy
);
2496 from
= out_charpos
; from_byte
= out_bytepos
;
2500 SET_PT_BOTH (from
, from_byte
);
2503 INC_BOTH (from
, from_byte
);
2504 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2505 /* We have skipped one comment. */
2518 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
2523 DEC_BOTH (from
, from_byte
);
2524 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
2525 quoted
= char_quoted (from
, from_byte
);
2526 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2527 syntax
= SYNTAX_WITH_FLAGS (c
);
2530 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (syntax
);
2531 if (code
== Sendcomment
)
2532 comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (syntax
, 0);
2533 if (from
> stop
&& SYNTAX_FLAGS_COMEND_SECOND (syntax
)
2534 && prev_char_comend_first (from
, from_byte
)
2535 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
2538 /* We must record the comment style encountered so that
2539 later, we can match only the proper comment begin
2540 sequence of the same style. */
2541 DEC_BOTH (from
, from_byte
);
2543 /* Calling char_quoted, above, set up global syntax position
2544 at the new value of FROM. */
2545 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2546 other_syntax
= SYNTAX_WITH_FLAGS (c1
);
2547 comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (other_syntax
, syntax
);
2548 comnested
|= SYNTAX_FLAGS_COMMENT_NESTED (other_syntax
);
2551 if (code
== Scomment_fence
)
2553 /* Skip until first preceding unquoted comment_fence. */
2554 bool fence_found
= 0;
2555 ptrdiff_t ini
= from
, ini_byte
= from_byte
;
2559 DEC_BOTH (from
, from_byte
);
2560 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2561 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2562 if (SYNTAX (c
) == Scomment_fence
2563 && !char_quoted (from
, from_byte
))
2568 else if (from
== stop
)
2571 if (fence_found
== 0)
2573 from
= ini
; /* Set point to ini + 1. */
2574 from_byte
= ini_byte
;
2578 /* We have skipped one comment. */
2581 else if (code
== Sendcomment
)
2583 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2584 &out_charpos
, &out_bytepos
);
2588 /* This end-of-line is not an end-of-comment.
2589 Treat it like a whitespace.
2590 CC-mode (and maybe others) relies on this behavior. */
2594 /* Failure: we should go back to the end of this
2595 not-quite-endcomment. */
2596 if (SYNTAX (c
) != code
)
2597 /* It was a two-char Sendcomment. */
2598 INC_BOTH (from
, from_byte
);
2604 /* We have skipped one comment. */
2605 from
= out_charpos
, from_byte
= out_bytepos
;
2609 else if (code
!= Swhitespace
|| quoted
)
2613 INC_BOTH (from
, from_byte
);
2614 SET_PT_BOTH (from
, from_byte
);
2622 SET_PT_BOTH (from
, from_byte
);
2627 /* Return syntax code of character C if C is an ASCII character
2628 or if MULTIBYTE_SYMBOL_P is false. Otherwise, return Ssymbol. */
2630 static enum syntaxcode
2631 syntax_multibyte (int c
, bool multibyte_symbol_p
)
2633 return ASCII_CHAR_P (c
) || !multibyte_symbol_p
? SYNTAX (c
) : Ssymbol
;
2637 scan_lists (EMACS_INT from
, EMACS_INT count
, EMACS_INT depth
, bool sexpflag
)
2640 ptrdiff_t stop
= count
> 0 ? ZV
: BEGV
;
2645 enum syntaxcode code
;
2646 EMACS_INT min_depth
= depth
; /* Err out if depth gets less than this. */
2647 int comstyle
= 0; /* Style of comment encountered. */
2648 bool comnested
= 0; /* Whether the comment is nestable or not. */
2650 EMACS_INT last_good
= from
;
2652 ptrdiff_t from_byte
;
2653 ptrdiff_t out_bytepos
, out_charpos
;
2655 bool multibyte_symbol_p
= sexpflag
&& multibyte_syntax_as_symbol
;
2657 if (depth
> 0) min_depth
= 0;
2659 if (from
> ZV
) from
= ZV
;
2660 if (from
< BEGV
) from
= BEGV
;
2662 from_byte
= CHAR_TO_BYTE (from
);
2667 SETUP_SYNTAX_TABLE (from
, count
);
2672 bool comstart_first
, prefix
;
2673 int syntax
, other_syntax
;
2674 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2675 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2676 syntax
= SYNTAX_WITH_FLAGS (c
);
2677 code
= syntax_multibyte (c
, multibyte_symbol_p
);
2678 comstart_first
= SYNTAX_FLAGS_COMSTART_FIRST (syntax
);
2679 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (syntax
);
2680 comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (syntax
, 0);
2681 prefix
= SYNTAX_FLAGS_PREFIX (syntax
);
2682 if (depth
== min_depth
)
2684 INC_BOTH (from
, from_byte
);
2685 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2686 if (from
< stop
&& comstart_first
2687 && (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2688 other_syntax
= SYNTAX_WITH_FLAGS (c
),
2689 SYNTAX_FLAGS_COMSTART_SECOND (other_syntax
))
2690 && parse_sexp_ignore_comments
)
2692 /* We have encountered a comment start sequence and we
2693 are ignoring all text inside comments. We must record
2694 the comment style this sequence begins so that later,
2695 only a comment end of the same style actually ends
2696 the comment section. */
2698 comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (other_syntax
, syntax
);
2699 comnested
|= SYNTAX_FLAGS_COMMENT_NESTED (other_syntax
);
2700 INC_BOTH (from
, from_byte
);
2701 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2713 INC_BOTH (from
, from_byte
);
2714 /* Treat following character as a word constituent. */
2717 if (depth
|| !sexpflag
) break;
2718 /* This word counts as a sexp; return at end of it. */
2721 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2723 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2724 switch (syntax_multibyte (c
, multibyte_symbol_p
))
2728 INC_BOTH (from
, from_byte
);
2739 INC_BOTH (from
, from_byte
);
2743 case Scomment_fence
:
2744 comstyle
= ST_COMMENT_STYLE
;
2747 if (!parse_sexp_ignore_comments
) break;
2748 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2749 found
= forw_comment (from
, from_byte
, stop
,
2750 comnested
, comstyle
, 0,
2751 &out_charpos
, &out_bytepos
, &dummy
);
2752 from
= out_charpos
, from_byte
= out_bytepos
;
2759 INC_BOTH (from
, from_byte
);
2760 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2766 if (from
!= stop
&& c
== FETCH_CHAR_AS_MULTIBYTE (from_byte
))
2768 INC_BOTH (from
, from_byte
);
2778 if (!++depth
) goto done
;
2783 if (!--depth
) goto done
;
2784 if (depth
< min_depth
)
2785 xsignal3 (Qscan_error
,
2786 build_string ("Containing expression ends prematurely"),
2787 make_number (last_good
), make_number (from
));
2792 temp_pos
= dec_bytepos (from_byte
);
2793 stringterm
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2796 enum syntaxcode c_code
;
2799 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2800 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2801 c_code
= syntax_multibyte (c
, multibyte_symbol_p
);
2803 ? c
== stringterm
&& c_code
== Sstring
2804 : c_code
== Sstring_fence
)
2807 if (c_code
== Scharquote
|| c_code
== Sescape
)
2808 INC_BOTH (from
, from_byte
);
2809 INC_BOTH (from
, from_byte
);
2811 INC_BOTH (from
, from_byte
);
2812 if (!depth
&& sexpflag
) goto done
;
2815 /* Ignore whitespace, punctuation, quote, endcomment. */
2820 /* Reached end of buffer. Error if within object, return nil if between */
2827 /* End of object reached */
2837 DEC_BOTH (from
, from_byte
);
2838 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2839 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2840 syntax
= SYNTAX_WITH_FLAGS (c
);
2841 code
= syntax_multibyte (c
, multibyte_symbol_p
);
2842 if (depth
== min_depth
)
2845 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (syntax
);
2846 if (code
== Sendcomment
)
2847 comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (syntax
, 0);
2848 if (from
> stop
&& SYNTAX_FLAGS_COMEND_SECOND (syntax
)
2849 && prev_char_comend_first (from
, from_byte
)
2850 && parse_sexp_ignore_comments
)
2852 /* We must record the comment style encountered so that
2853 later, we can match only the proper comment begin
2854 sequence of the same style. */
2855 int c2
, other_syntax
;
2856 DEC_BOTH (from
, from_byte
);
2857 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2859 c2
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2860 other_syntax
= SYNTAX_WITH_FLAGS (c2
);
2861 comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (other_syntax
, syntax
);
2862 comnested
|= SYNTAX_FLAGS_COMMENT_NESTED (other_syntax
);
2865 /* Quoting turns anything except a comment-ender
2866 into a word character. Note that this cannot be true
2867 if we decremented FROM in the if-statement above. */
2868 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2870 DEC_BOTH (from
, from_byte
);
2873 else if (SYNTAX_FLAGS_PREFIX (syntax
))
2882 if (depth
|| !sexpflag
) break;
2883 /* This word counts as a sexp; count object finished
2884 after passing it. */
2887 temp_pos
= from_byte
;
2888 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
2892 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2893 c1
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2894 /* Don't allow comment-end to be quoted. */
2895 if (syntax_multibyte (c1
, multibyte_symbol_p
) == Sendcomment
)
2897 quoted
= char_quoted (from
- 1, temp_pos
);
2900 DEC_BOTH (from
, from_byte
);
2901 temp_pos
= dec_bytepos (temp_pos
);
2902 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2904 c1
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2906 switch (syntax_multibyte (c1
, multibyte_symbol_p
))
2908 case Sword
: case Ssymbol
: case Squote
: break;
2909 default: goto done2
;
2911 DEC_BOTH (from
, from_byte
);
2920 temp_pos
= dec_bytepos (from_byte
);
2921 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2922 if (from
!= stop
&& c
== FETCH_CHAR_AS_MULTIBYTE (temp_pos
))
2923 DEC_BOTH (from
, from_byte
);
2933 if (!++depth
) goto done2
;
2938 if (!--depth
) goto done2
;
2939 if (depth
< min_depth
)
2940 xsignal3 (Qscan_error
,
2941 build_string ("Containing expression ends prematurely"),
2942 make_number (last_good
), make_number (from
));
2946 if (!parse_sexp_ignore_comments
)
2948 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2949 &out_charpos
, &out_bytepos
);
2950 /* FIXME: if !found, it really wasn't a comment-end.
2951 For single-char Sendcomment, we can't do much about it apart
2952 from skipping the char.
2953 For 2-char endcomments, we could try again, taking both
2954 chars as separate entities, but it's a lot of trouble
2955 for very little gain, so we don't bother either. -sm */
2957 from
= out_charpos
, from_byte
= out_bytepos
;
2960 case Scomment_fence
:
2966 DEC_BOTH (from
, from_byte
);
2967 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2968 if (!char_quoted (from
, from_byte
))
2970 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2971 if (syntax_multibyte (c
, multibyte_symbol_p
) == code
)
2975 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2979 stringterm
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2984 DEC_BOTH (from
, from_byte
);
2985 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2986 if (!char_quoted (from
, from_byte
))
2988 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2990 && (syntax_multibyte (c
, multibyte_symbol_p
)
2995 if (!depth
&& sexpflag
) goto done2
;
2998 /* Ignore whitespace, punctuation, quote, endcomment. */
3003 /* Reached start of buffer. Error if within object, return nil if between */
3016 XSETFASTINT (val
, from
);
3020 xsignal3 (Qscan_error
,
3021 build_string ("Unbalanced parentheses"),
3022 make_number (last_good
), make_number (from
));
3025 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
3026 doc
: /* Scan from character number FROM by COUNT lists.
3027 Scan forward if COUNT is positive, backward if COUNT is negative.
3028 Return the character number of the position thus found.
3030 A \"list", in this context, refers to a balanced parenthetical
3031 grouping, as determined by the syntax table.
3033 If DEPTH is nonzero, treat that as the nesting depth of the starting
3034 point (i.e. the starting point is DEPTH parentheses deep). This
3035 function scans over parentheses until the depth goes to zero COUNT
3036 times. Hence, positive DEPTH moves out that number of levels of
3037 parentheses, while negative DEPTH moves to a deeper level.
3039 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
3041 If we reach the beginning or end of the accessible part of the buffer
3042 before we have scanned over COUNT lists, return nil if the depth at
3043 that point is zero, and signal a error if the depth is nonzero. */)
3044 (Lisp_Object from
, Lisp_Object count
, Lisp_Object depth
)
3046 CHECK_NUMBER (from
);
3047 CHECK_NUMBER (count
);
3048 CHECK_NUMBER (depth
);
3050 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
3053 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
3054 doc
: /* Scan from character number FROM by COUNT balanced expressions.
3055 If COUNT is negative, scan backwards.
3056 Returns the character number of the position thus found.
3058 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
3060 If the beginning or end of (the accessible part of) the buffer is reached
3061 in the middle of a parenthetical grouping, an error is signaled.
3062 If the beginning or end is reached between groupings
3063 but before count is used up, nil is returned. */)
3064 (Lisp_Object from
, Lisp_Object count
)
3066 CHECK_NUMBER (from
);
3067 CHECK_NUMBER (count
);
3069 return scan_lists (XINT (from
), XINT (count
), 0, 1);
3072 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
3074 doc
: /* Move point backward over any number of chars with prefix syntax.
3075 This includes chars with expression prefix syntax class (') and those with
3076 the prefix syntax flag (p). */)
3079 ptrdiff_t beg
= BEGV
;
3080 ptrdiff_t opoint
= PT
;
3081 ptrdiff_t opoint_byte
= PT_BYTE
;
3083 ptrdiff_t pos_byte
= PT_BYTE
;
3088 SET_PT_BOTH (opoint
, opoint_byte
);
3093 SETUP_SYNTAX_TABLE (pos
, -1);
3095 DEC_BOTH (pos
, pos_byte
);
3097 while (!char_quoted (pos
, pos_byte
)
3098 /* Previous statement updates syntax table. */
3099 && ((c
= FETCH_CHAR_AS_MULTIBYTE (pos_byte
), SYNTAX (c
) == Squote
)
3100 || syntax_prefix_flag_p (c
)))
3103 opoint_byte
= pos_byte
;
3106 DEC_BOTH (pos
, pos_byte
);
3109 SET_PT_BOTH (opoint
, opoint_byte
);
3114 /* Parse forward from FROM / FROM_BYTE to END,
3115 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
3116 and return a description of the state of the parse at END.
3117 If STOPBEFORE, stop at the start of an atom.
3118 If COMMENTSTOP is 1, stop at the start of a comment.
3119 If COMMENTSTOP is -1, stop at the start or end of a comment,
3120 after the beginning of a string, or after the end of a string. */
3123 scan_sexps_forward (struct lisp_parse_state
*stateptr
,
3124 ptrdiff_t from
, ptrdiff_t from_byte
, ptrdiff_t end
,
3125 EMACS_INT targetdepth
, bool stopbefore
,
3126 Lisp_Object oldstate
, int commentstop
)
3128 struct lisp_parse_state state
;
3129 enum syntaxcode code
;
3132 struct level
{ ptrdiff_t last
, prev
; };
3133 struct level levelstart
[100];
3134 struct level
*curlevel
= levelstart
;
3135 struct level
*endlevel
= levelstart
+ 100;
3136 EMACS_INT depth
; /* Paren depth of current scanning location.
3137 level - levelstart equals this except
3138 when the depth becomes negative. */
3139 EMACS_INT mindepth
; /* Lowest DEPTH value seen. */
3140 bool start_quoted
= 0; /* True means starting after a char quote. */
3142 ptrdiff_t prev_from
; /* Keep one character before FROM. */
3143 ptrdiff_t prev_from_byte
;
3144 int prev_from_syntax
;
3145 bool boundary_stop
= commentstop
== -1;
3148 ptrdiff_t out_bytepos
, out_charpos
;
3152 prev_from_byte
= from_byte
;
3154 DEC_BOTH (prev_from
, prev_from_byte
);
3156 /* Use this macro instead of `from++'. */
3158 do { prev_from = from; \
3159 prev_from_byte = from_byte; \
3160 temp = FETCH_CHAR_AS_MULTIBYTE (prev_from_byte); \
3161 prev_from_syntax = SYNTAX_WITH_FLAGS (temp); \
3162 INC_BOTH (from, from_byte); \
3164 UPDATE_SYNTAX_TABLE_FORWARD (from); \
3170 if (NILP (oldstate
))
3173 state
.instring
= -1;
3174 state
.incomment
= 0;
3175 state
.comstyle
= 0; /* comment style a by default. */
3176 state
.comstr_start
= -1; /* no comment/string seen. */
3180 tem
= Fcar (oldstate
);
3186 oldstate
= Fcdr (oldstate
);
3187 oldstate
= Fcdr (oldstate
);
3188 oldstate
= Fcdr (oldstate
);
3189 tem
= Fcar (oldstate
);
3190 /* Check whether we are inside string_fence-style string: */
3191 state
.instring
= (!NILP (tem
)
3192 ? (CHARACTERP (tem
) ? XFASTINT (tem
) : ST_STRING_STYLE
)
3195 oldstate
= Fcdr (oldstate
);
3196 tem
= Fcar (oldstate
);
3197 state
.incomment
= (!NILP (tem
)
3198 ? (INTEGERP (tem
) ? XINT (tem
) : -1)
3201 oldstate
= Fcdr (oldstate
);
3202 tem
= Fcar (oldstate
);
3203 start_quoted
= !NILP (tem
);
3205 /* if the eighth element of the list is nil, we are in comment
3206 style a. If it is non-nil, we are in comment style b */
3207 oldstate
= Fcdr (oldstate
);
3208 oldstate
= Fcdr (oldstate
);
3209 tem
= Fcar (oldstate
);
3210 state
.comstyle
= (NILP (tem
)
3212 : (RANGED_INTEGERP (0, tem
, ST_COMMENT_STYLE
)
3214 : ST_COMMENT_STYLE
));
3216 oldstate
= Fcdr (oldstate
);
3217 tem
= Fcar (oldstate
);
3218 state
.comstr_start
=
3219 RANGED_INTEGERP (PTRDIFF_MIN
, tem
, PTRDIFF_MAX
) ? XINT (tem
) : -1;
3220 oldstate
= Fcdr (oldstate
);
3221 tem
= Fcar (oldstate
);
3222 while (!NILP (tem
)) /* >= second enclosing sexps. */
3224 Lisp_Object temhd
= Fcar (tem
);
3225 if (RANGED_INTEGERP (PTRDIFF_MIN
, temhd
, PTRDIFF_MAX
))
3226 curlevel
->last
= XINT (temhd
);
3227 if (++curlevel
== endlevel
)
3228 curlevel
--; /* error ("Nesting too deep for parser"); */
3229 curlevel
->prev
= -1;
3230 curlevel
->last
= -1;
3237 curlevel
->prev
= -1;
3238 curlevel
->last
= -1;
3240 SETUP_SYNTAX_TABLE (prev_from
, 1);
3241 temp
= FETCH_CHAR (prev_from_byte
);
3242 prev_from_syntax
= SYNTAX_WITH_FLAGS (temp
);
3243 UPDATE_SYNTAX_TABLE_FORWARD (from
);
3245 /* Enter the loop at a place appropriate for initial state. */
3247 if (state
.incomment
)
3248 goto startincomment
;
3249 if (state
.instring
>= 0)
3251 nofence
= state
.instring
!= ST_STRING_STYLE
;
3253 goto startquotedinstring
;
3256 else if (start_quoted
)
3263 code
= prev_from_syntax
& 0xff;
3266 && SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
)
3267 && (c1
= FETCH_CHAR (from_byte
),
3268 syntax
= SYNTAX_WITH_FLAGS (c1
),
3269 SYNTAX_FLAGS_COMSTART_SECOND (syntax
)))
3270 /* Duplicate code to avoid a complex if-expression
3271 which causes trouble for the SGI compiler. */
3273 /* Record the comment style we have entered so that only
3274 the comment-end sequence of the same style actually
3275 terminates the comment section. */
3277 = SYNTAX_FLAGS_COMMENT_STYLE (syntax
, prev_from_syntax
);
3278 comnested
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
)
3279 | SYNTAX_FLAGS_COMMENT_NESTED (syntax
));
3280 state
.incomment
= comnested
? 1 : -1;
3281 state
.comstr_start
= prev_from
;
3285 else if (code
== Scomment_fence
)
3287 /* Record the comment style we have entered so that only
3288 the comment-end sequence of the same style actually
3289 terminates the comment section. */
3290 state
.comstyle
= ST_COMMENT_STYLE
;
3291 state
.incomment
= -1;
3292 state
.comstr_start
= prev_from
;
3295 else if (code
== Scomment
)
3297 state
.comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax
, 0);
3298 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
3300 state
.comstr_start
= prev_from
;
3303 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
3309 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3310 curlevel
->last
= prev_from
;
3312 if (from
== end
) goto endquoted
;
3315 /* treat following character as a word constituent */
3318 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3319 curlevel
->last
= prev_from
;
3323 int symchar
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
3324 switch (SYNTAX (symchar
))
3329 if (from
== end
) goto endquoted
;
3341 curlevel
->prev
= curlevel
->last
;
3344 case Scomment_fence
: /* Can't happen because it's handled above. */
3346 if (commentstop
|| boundary_stop
) goto done
;
3348 /* The (from == BEGV) test was to enter the loop in the middle so
3349 that we find a 2-char comment ender even if we start in the
3350 middle of it. We don't want to do that if we're just at the
3351 beginning of the comment (think of (*) ... (*)). */
3352 found
= forw_comment (from
, from_byte
, end
,
3353 state
.incomment
, state
.comstyle
,
3354 (from
== BEGV
|| from
< state
.comstr_start
+ 3)
3355 ? 0 : prev_from_syntax
,
3356 &out_charpos
, &out_bytepos
, &state
.incomment
);
3357 from
= out_charpos
; from_byte
= out_bytepos
;
3358 /* Beware! prev_from and friends are invalid now.
3359 Luckily, the `done' doesn't use them and the INC_FROM
3360 sets them to a sane value without looking at them. */
3361 if (!found
) goto done
;
3363 state
.incomment
= 0;
3364 state
.comstyle
= 0; /* reset the comment style */
3365 if (boundary_stop
) goto done
;
3369 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3371 /* curlevel++->last ran into compiler bug on Apollo */
3372 curlevel
->last
= prev_from
;
3373 if (++curlevel
== endlevel
)
3374 curlevel
--; /* error ("Nesting too deep for parser"); */
3375 curlevel
->prev
= -1;
3376 curlevel
->last
= -1;
3377 if (targetdepth
== depth
) goto done
;
3382 if (depth
< mindepth
)
3384 if (curlevel
!= levelstart
)
3386 curlevel
->prev
= curlevel
->last
;
3387 if (targetdepth
== depth
) goto done
;
3392 state
.comstr_start
= from
- 1;
3393 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3394 curlevel
->last
= prev_from
;
3395 state
.instring
= (code
== Sstring
3396 ? (FETCH_CHAR_AS_MULTIBYTE (prev_from_byte
))
3398 if (boundary_stop
) goto done
;
3401 nofence
= state
.instring
!= ST_STRING_STYLE
;
3406 enum syntaxcode c_code
;
3408 if (from
>= end
) goto done
;
3409 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
3410 c_code
= SYNTAX (c
);
3412 /* Check C_CODE here so that if the char has
3413 a syntax-table property which says it is NOT
3414 a string character, it does not end the string. */
3415 if (nofence
&& c
== state
.instring
&& c_code
== Sstring
)
3421 if (!nofence
) goto string_end
;
3427 startquotedinstring
:
3428 if (from
>= end
) goto endquoted
;
3438 state
.instring
= -1;
3439 curlevel
->prev
= curlevel
->last
;
3441 if (boundary_stop
) goto done
;
3445 /* FIXME: We should do something with it. */
3448 /* Ignore whitespace, punctuation, quote, endcomment. */
3454 stop
: /* Here if stopping before start of sexp. */
3455 from
= prev_from
; /* We have just fetched the char that starts it; */
3456 from_byte
= prev_from_byte
;
3457 goto done
; /* but return the position before it. */
3462 state
.depth
= depth
;
3463 state
.mindepth
= mindepth
;
3464 state
.thislevelstart
= curlevel
->prev
;
3465 state
.prevlevelstart
3466 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
3467 state
.location
= from
;
3468 state
.location_byte
= from_byte
;
3469 state
.levelstarts
= Qnil
;
3470 while (curlevel
> levelstart
)
3471 state
.levelstarts
= Fcons (make_number ((--curlevel
)->last
),
3478 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
3479 doc
: /* Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
3480 Parsing stops at TO or when certain criteria are met;
3481 point is set to where parsing stops.
3482 If fifth arg OLDSTATE is omitted or nil,
3483 parsing assumes that FROM is the beginning of a function.
3484 Value is a list of elements describing final state of parsing:
3486 1. character address of start of innermost containing list; nil if none.
3487 2. character address of start of last complete sexp terminated.
3488 3. non-nil if inside a string.
3489 (it is the character that will terminate the string,
3490 or t if the string should be terminated by a generic string delimiter.)
3491 4. nil if outside a comment, t if inside a non-nestable comment,
3492 else an integer (the current comment nesting).
3493 5. t if following a quote character.
3494 6. the minimum paren-depth encountered during this scan.
3495 7. style of comment, if any.
3496 8. character address of start of comment or string; nil if not in one.
3497 9. Intermediate data for continuation of parsing (subject to change).
3498 If third arg TARGETDEPTH is non-nil, parsing stops if the depth
3499 in parentheses becomes equal to TARGETDEPTH.
3500 Fourth arg STOPBEFORE non-nil means stop when come to
3501 any character that starts a sexp.
3502 Fifth arg OLDSTATE is a list like what this function returns.
3503 It is used to initialize the state of the parse. Elements number 1, 2, 6
3505 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
3506 If it is symbol `syntax-table', stop after the start of a comment or a
3507 string, or after end of a comment or a string. */)
3508 (Lisp_Object from
, Lisp_Object to
, Lisp_Object targetdepth
,
3509 Lisp_Object stopbefore
, Lisp_Object oldstate
, Lisp_Object commentstop
)
3511 struct lisp_parse_state state
;
3514 if (!NILP (targetdepth
))
3516 CHECK_NUMBER (targetdepth
);
3517 target
= XINT (targetdepth
);
3520 target
= TYPE_MINIMUM (EMACS_INT
); /* We won't reach this depth. */
3522 validate_region (&from
, &to
);
3523 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
3525 target
, !NILP (stopbefore
), oldstate
,
3527 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
3529 SET_PT_BOTH (state
.location
, state
.location_byte
);
3531 return Fcons (make_number (state
.depth
),
3532 Fcons (state
.prevlevelstart
< 0
3533 ? Qnil
: make_number (state
.prevlevelstart
),
3534 Fcons (state
.thislevelstart
< 0
3535 ? Qnil
: make_number (state
.thislevelstart
),
3536 Fcons (state
.instring
>= 0
3537 ? (state
.instring
== ST_STRING_STYLE
3538 ? Qt
: make_number (state
.instring
)) : Qnil
,
3539 Fcons (state
.incomment
< 0 ? Qt
:
3540 (state
.incomment
== 0 ? Qnil
:
3541 make_number (state
.incomment
)),
3542 Fcons (state
.quoted
? Qt
: Qnil
,
3543 Fcons (make_number (state
.mindepth
),
3544 Fcons ((state
.comstyle
3545 ? (state
.comstyle
== ST_COMMENT_STYLE
3547 : make_number (state
.comstyle
))
3549 Fcons (((state
.incomment
3550 || (state
.instring
>= 0))
3551 ? make_number (state
.comstr_start
)
3553 Fcons (state
.levelstarts
, Qnil
))))))))));
3557 init_syntax_once (void)
3562 /* This has to be done here, before we call Fmake_char_table. */
3563 DEFSYM (Qsyntax_table
, "syntax-table");
3565 /* Create objects which can be shared among syntax tables. */
3566 Vsyntax_code_object
= make_uninit_vector (Smax
);
3567 for (i
= 0; i
< Smax
; i
++)
3568 ASET (Vsyntax_code_object
, i
, Fcons (make_number (i
), Qnil
));
3570 /* Now we are ready to set up this property, so we can
3571 create syntax tables. */
3572 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
3574 temp
= AREF (Vsyntax_code_object
, Swhitespace
);
3576 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
3578 /* Control characters should not be whitespace. */
3579 temp
= AREF (Vsyntax_code_object
, Spunct
);
3580 for (i
= 0; i
<= ' ' - 1; i
++)
3581 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3582 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, 0177, temp
);
3584 /* Except that a few really are whitespace. */
3585 temp
= AREF (Vsyntax_code_object
, Swhitespace
);
3586 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ' ', temp
);
3587 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\t', temp
);
3588 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\n', temp
);
3589 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, 015, temp
);
3590 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, 014, temp
);
3592 temp
= AREF (Vsyntax_code_object
, Sword
);
3593 for (i
= 'a'; i
<= 'z'; i
++)
3594 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3595 for (i
= 'A'; i
<= 'Z'; i
++)
3596 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3597 for (i
= '0'; i
<= '9'; i
++)
3598 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3600 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
3601 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
3603 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
3604 Fcons (make_number (Sopen
), make_number (')')));
3605 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
3606 Fcons (make_number (Sclose
), make_number ('(')));
3607 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
3608 Fcons (make_number (Sopen
), make_number (']')));
3609 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
3610 Fcons (make_number (Sclose
), make_number ('[')));
3611 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
3612 Fcons (make_number (Sopen
), make_number ('}')));
3613 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
3614 Fcons (make_number (Sclose
), make_number ('{')));
3615 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
3616 Fcons (make_number (Sstring
), Qnil
));
3617 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
3618 Fcons (make_number (Sescape
), Qnil
));
3620 temp
= AREF (Vsyntax_code_object
, Ssymbol
);
3621 for (i
= 0; i
< 10; i
++)
3623 c
= "_-+*/&|<>="[i
];
3624 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3627 temp
= AREF (Vsyntax_code_object
, Spunct
);
3628 for (i
= 0; i
< 12; i
++)
3630 c
= ".,;:?!#@~^'`"[i
];
3631 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3634 /* All multibyte characters have syntax `word' by default. */
3635 temp
= AREF (Vsyntax_code_object
, Sword
);
3636 char_table_set_range (Vstandard_syntax_table
, 0x80, MAX_CHAR
, temp
);
3640 syms_of_syntax (void)
3642 DEFSYM (Qsyntax_table_p
, "syntax-table-p");
3644 staticpro (&Vsyntax_code_object
);
3646 staticpro (&gl_state
.object
);
3647 staticpro (&gl_state
.global_code
);
3648 staticpro (&gl_state
.current_syntax_table
);
3649 staticpro (&gl_state
.old_prop
);
3651 /* Defined in regex.c. */
3652 staticpro (&re_match_object
);
3654 DEFSYM (Qscan_error
, "scan-error");
3655 Fput (Qscan_error
, Qerror_conditions
,
3656 listn (CONSTYPE_PURE
, 2, Qscan_error
, Qerror
));
3657 Fput (Qscan_error
, Qerror_message
,
3658 build_pure_c_string ("Scan error"));
3660 DEFVAR_BOOL ("parse-sexp-ignore-comments", parse_sexp_ignore_comments
,
3661 doc
: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace. */);
3663 DEFVAR_BOOL ("parse-sexp-lookup-properties", parse_sexp_lookup_properties
,
3664 doc
: /* Non-nil means `forward-sexp', etc., obey `syntax-table' property.
3665 Otherwise, that text property is simply ignored.
3666 See the info node `(elisp)Syntax Properties' for a description of the
3667 `syntax-table' property. */);
3669 DEFVAR_INT ("syntax-propertize--done", syntax_propertize__done
,
3670 doc
: /* Position up to which syntax-table properties have been set. */);
3671 syntax_propertize__done
= -1;
3672 DEFSYM (Qinternal__syntax_propertize
, "internal--syntax-propertize");
3673 Fmake_variable_buffer_local (intern ("syntax-propertize--done"));
3675 words_include_escapes
= 0;
3676 DEFVAR_BOOL ("words-include-escapes", words_include_escapes
,
3677 doc
: /* Non-nil means `forward-word', etc., should treat escape chars part of words. */);
3679 DEFVAR_BOOL ("multibyte-syntax-as-symbol", multibyte_syntax_as_symbol
,
3680 doc
: /* Non-nil means `scan-sexps' treats all multibyte characters as symbol. */);
3681 multibyte_syntax_as_symbol
= 0;
3683 DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
3684 open_paren_in_column_0_is_defun_start
,
3685 doc
: /* Non-nil means an open paren in column 0 denotes the start of a defun. */);
3686 open_paren_in_column_0_is_defun_start
= 1;
3689 DEFVAR_LISP ("find-word-boundary-function-table",
3690 Vfind_word_boundary_function_table
,
3692 Char table of functions to search for the word boundary.
3693 Each function is called with two arguments; POS and LIMIT.
3694 POS and LIMIT are character positions in the current buffer.
3696 If POS is less than LIMIT, POS is at the first character of a word,
3697 and the return value of a function is a position after the last
3698 character of that word.
3700 If POS is not less than LIMIT, POS is at the last character of a word,
3701 and the return value of a function is a position at the first
3702 character of that word.
3704 In both cases, LIMIT bounds the search. */);
3705 Vfind_word_boundary_function_table
= Fmake_char_table (Qnil
, Qnil
);
3707 defsubr (&Ssyntax_table_p
);
3708 defsubr (&Ssyntax_table
);
3709 defsubr (&Sstandard_syntax_table
);
3710 defsubr (&Scopy_syntax_table
);
3711 defsubr (&Sset_syntax_table
);
3712 defsubr (&Schar_syntax
);
3713 defsubr (&Smatching_paren
);
3714 defsubr (&Sstring_to_syntax
);
3715 defsubr (&Smodify_syntax_entry
);
3716 defsubr (&Sinternal_describe_syntax_value
);
3718 defsubr (&Sforward_word
);
3720 defsubr (&Sskip_chars_forward
);
3721 defsubr (&Sskip_chars_backward
);
3722 defsubr (&Sskip_syntax_forward
);
3723 defsubr (&Sskip_syntax_backward
);
3725 defsubr (&Sforward_comment
);
3726 defsubr (&Sscan_lists
);
3727 defsubr (&Sscan_sexps
);
3728 defsubr (&Sbackward_prefix_chars
);
3729 defsubr (&Sparse_partial_sexp
);