1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 87, 93, 94, 95, 97, 1998, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
27 #include "character.h"
30 /* Make syntax table lookup grant data in gl_state. */
31 #define SYNTAX_ENTRY_VIA_PROPERTY
34 #include "intervals.h"
36 /* We use these constants in place for comment-style and
37 string-ender-char to distinguish comments/strings started by
38 comment_fence and string_fence codes. */
40 #define ST_COMMENT_STYLE (256 + 1)
41 #define ST_STRING_STYLE (256 + 2)
44 Lisp_Object Qsyntax_table_p
, Qsyntax_table
, Qscan_error
;
46 int words_include_escapes
;
47 int parse_sexp_lookup_properties
;
49 /* Nonzero means `scan-sexps' treat all multibyte characters as symbol. */
50 int multibyte_syntax_as_symbol
;
52 /* Used as a temporary in SYNTAX_ENTRY and other macros in syntax.h,
53 if not compiled with GCC. No need to mark it, since it is used
54 only very temporarily. */
55 Lisp_Object syntax_temp
;
57 /* Non-zero means an open parenthesis in column 0 is always considered
58 to be the start of a defun. Zero means an open parenthesis in
59 column 0 has no special meaning. */
61 int open_paren_in_column_0_is_defun_start
;
63 /* This is the internal form of the parse state used in parse-partial-sexp. */
65 struct lisp_parse_state
67 int depth
; /* Depth at end of parsing. */
68 int instring
; /* -1 if not within string, else desired terminator. */
69 int incomment
; /* -1 if in unnestable comment else comment nesting */
70 int comstyle
; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
71 int quoted
; /* Nonzero if just after an escape char at end of parsing */
72 int thislevelstart
; /* Char number of most recent start-of-expression at current level */
73 int prevlevelstart
; /* Char number of start of containing expression */
74 int location
; /* Char number at which parsing stopped. */
75 int mindepth
; /* Minimum depth seen while scanning. */
76 int comstr_start
; /* Position just after last comment/string starter. */
77 Lisp_Object levelstarts
; /* Char numbers of starts-of-expression
78 of levels (starting from outermost). */
81 /* These variables are a cache for finding the start of a defun.
82 find_start_pos is the place for which the defun start was found.
83 find_start_value is the defun start position found for it.
84 find_start_value_byte is the corresponding byte position.
85 find_start_buffer is the buffer it was found in.
86 find_start_begv is the BEGV value when it was found.
87 find_start_modiff is the value of MODIFF when it was found. */
89 static int find_start_pos
;
90 static int find_start_value
;
91 static int find_start_value_byte
;
92 static struct buffer
*find_start_buffer
;
93 static int find_start_begv
;
94 static int find_start_modiff
;
97 static int find_defun_start
P_ ((int, int));
98 static int back_comment
P_ ((int, int, int, int, int, int *, int *));
99 static int char_quoted
P_ ((int, int));
100 static Lisp_Object skip_chars
P_ ((int, Lisp_Object
, Lisp_Object
));
101 static Lisp_Object skip_syntaxes
P_ ((int, Lisp_Object
, Lisp_Object
));
102 static Lisp_Object scan_lists
P_ ((int, int, int, int));
103 static void scan_sexps_forward
P_ ((struct lisp_parse_state
*,
105 int, Lisp_Object
, int));
108 struct gl_state_s gl_state
; /* Global state of syntax parser. */
110 INTERVAL
interval_of ();
111 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
112 to scan to property-change. */
114 /* Update gl_state to an appropriate interval which contains CHARPOS. The
115 sign of COUNT give the relative position of CHARPOS wrt the previously
116 valid interval. If INIT, only [be]_property fields of gl_state are
117 valid at start, the rest is filled basing on OBJECT.
119 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
120 direction than the intervals - or in an interval. We update the
121 current syntax-table basing on the property of this interval, and
122 update the interval to start further than CHARPOS - or be
123 NULL_INTERVAL. We also update lim_property to be the next value of
124 charpos to call this subroutine again - or be before/after the
125 start/end of OBJECT. */
128 update_syntax_table (charpos
, count
, init
, object
)
129 int charpos
, count
, init
;
132 Lisp_Object tmp_table
;
133 int cnt
= 0, invalidate
= 1;
138 gl_state
.old_prop
= Qnil
;
139 gl_state
.start
= gl_state
.b_property
;
140 gl_state
.stop
= gl_state
.e_property
;
141 i
= interval_of (charpos
, object
);
142 gl_state
.backward_i
= gl_state
.forward_i
= i
;
144 if (NULL_INTERVAL_P (i
))
146 /* interval_of updates only ->position of the return value, so
147 update the parents manually to speed up update_interval. */
148 while (!NULL_PARENT (i
))
150 if (AM_RIGHT_CHILD (i
))
151 INTERVAL_PARENT (i
)->position
= i
->position
152 - LEFT_TOTAL_LENGTH (i
) + TOTAL_LENGTH (i
) /* right end */
153 - TOTAL_LENGTH (INTERVAL_PARENT (i
))
154 + LEFT_TOTAL_LENGTH (INTERVAL_PARENT (i
));
156 INTERVAL_PARENT (i
)->position
= i
->position
- LEFT_TOTAL_LENGTH (i
)
158 i
= INTERVAL_PARENT (i
);
160 i
= gl_state
.forward_i
;
161 gl_state
.b_property
= i
->position
- gl_state
.offset
;
162 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
165 oldi
= i
= count
> 0 ? gl_state
.forward_i
: gl_state
.backward_i
;
167 /* We are guaranteed to be called with CHARPOS either in i,
169 if (NULL_INTERVAL_P (i
))
170 error ("Error in syntax_table logic for to-the-end intervals");
171 else if (charpos
< i
->position
) /* Move left. */
174 error ("Error in syntax_table logic for intervals <-");
175 /* Update the interval. */
176 i
= update_interval (i
, charpos
);
177 if (INTERVAL_LAST_POS (i
) != gl_state
.b_property
)
180 gl_state
.forward_i
= i
;
181 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
184 else if (charpos
>= INTERVAL_LAST_POS (i
)) /* Move right. */
187 error ("Error in syntax_table logic for intervals ->");
188 /* Update the interval. */
189 i
= update_interval (i
, charpos
);
190 if (i
->position
!= gl_state
.e_property
)
193 gl_state
.backward_i
= i
;
194 gl_state
.b_property
= i
->position
- gl_state
.offset
;
199 tmp_table
= textget (i
->plist
, Qsyntax_table
);
202 invalidate
= !EQ (tmp_table
, gl_state
.old_prop
); /* Need to invalidate? */
204 if (invalidate
) /* Did not get to adjacent interval. */
205 { /* with the same table => */
206 /* invalidate the old range. */
209 gl_state
.backward_i
= i
;
210 gl_state
.b_property
= i
->position
- gl_state
.offset
;
214 gl_state
.forward_i
= i
;
215 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
219 if (!EQ (tmp_table
, gl_state
.old_prop
))
221 gl_state
.current_syntax_table
= tmp_table
;
222 gl_state
.old_prop
= tmp_table
;
223 if (EQ (Fsyntax_table_p (tmp_table
), Qt
))
225 gl_state
.use_global
= 0;
227 else if (CONSP (tmp_table
))
229 gl_state
.use_global
= 1;
230 gl_state
.global_code
= tmp_table
;
234 gl_state
.use_global
= 0;
235 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
239 while (!NULL_INTERVAL_P (i
))
241 if (cnt
&& !EQ (tmp_table
, textget (i
->plist
, Qsyntax_table
)))
245 gl_state
.e_property
= i
->position
- gl_state
.offset
;
246 gl_state
.forward_i
= i
;
250 gl_state
.b_property
= i
->position
+ LENGTH (i
) - gl_state
.offset
;
251 gl_state
.backward_i
= i
;
255 else if (cnt
== INTERVALS_AT_ONCE
)
259 gl_state
.e_property
= i
->position
+ LENGTH (i
) - gl_state
.offset
;
260 gl_state
.forward_i
= i
;
264 gl_state
.b_property
= i
->position
- gl_state
.offset
;
265 gl_state
.backward_i
= i
;
270 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
272 eassert (NULL_INTERVAL_P (i
)); /* This property goes to the end. */
274 gl_state
.e_property
= gl_state
.stop
;
276 gl_state
.b_property
= gl_state
.start
;
279 /* Returns TRUE if char at CHARPOS is quoted.
280 Global syntax-table data should be set up already to be good at CHARPOS
281 or after. On return global syntax data is good for lookup at CHARPOS. */
284 char_quoted (charpos
, bytepos
)
285 register int charpos
, bytepos
;
287 register enum syntaxcode code
;
288 register int beg
= BEGV
;
289 register int quoted
= 0;
292 DEC_BOTH (charpos
, bytepos
);
294 while (bytepos
>= beg
)
296 UPDATE_SYNTAX_TABLE_BACKWARD (charpos
);
297 code
= SYNTAX (FETCH_CHAR_AS_MULTIBYTE (bytepos
));
298 if (! (code
== Scharquote
|| code
== Sescape
))
301 DEC_BOTH (charpos
, bytepos
);
305 UPDATE_SYNTAX_TABLE (orig
);
309 /* Return the bytepos one character after BYTEPOS.
310 We assume that BYTEPOS is not at the end of the buffer. */
313 inc_bytepos (bytepos
)
316 if (NILP (current_buffer
->enable_multibyte_characters
))
323 /* Return the bytepos one character before BYTEPOS.
324 We assume that BYTEPOS is not at the start of the buffer. */
327 dec_bytepos (bytepos
)
330 if (NILP (current_buffer
->enable_multibyte_characters
))
337 /* Return a defun-start position before before POS and not too far before.
338 It should be the last one before POS, or nearly the last.
340 When open_paren_in_column_0_is_defun_start is nonzero,
341 only the beginning of the buffer is treated as a defun-start.
343 We record the information about where the scan started
344 and what its result was, so that another call in the same area
345 can return the same value very quickly.
347 There is no promise at which position the global syntax data is
348 valid on return from the subroutine, so the caller should explicitly
349 update the global data. */
352 find_defun_start (pos
, pos_byte
)
355 int opoint
= PT
, opoint_byte
= PT_BYTE
;
357 if (!open_paren_in_column_0_is_defun_start
)
359 find_start_value_byte
= BEGV_BYTE
;
363 /* Use previous finding, if it's valid and applies to this inquiry. */
364 if (current_buffer
== find_start_buffer
365 /* Reuse the defun-start even if POS is a little farther on.
366 POS might be in the next defun, but that's ok.
367 Our value may not be the best possible, but will still be usable. */
368 && pos
<= find_start_pos
+ 1000
369 && pos
>= find_start_value
370 && BEGV
== find_start_begv
371 && MODIFF
== find_start_modiff
)
372 return find_start_value
;
374 /* Back up to start of line. */
375 scan_newline (pos
, pos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
377 /* We optimize syntax-table lookup for rare updates. Thus we accept
378 only those `^\s(' which are good in global _and_ text-property
380 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
381 gl_state
.use_global
= 0;
384 /* Open-paren at start of line means we may have found our
386 if (SYNTAX (FETCH_CHAR_AS_MULTIBYTE (PT_BYTE
)) == Sopen
)
388 SETUP_SYNTAX_TABLE (PT
+ 1, -1); /* Try again... */
389 if (SYNTAX (FETCH_CHAR_AS_MULTIBYTE (PT_BYTE
)) == Sopen
)
391 /* Now fallback to the default value. */
392 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
393 gl_state
.use_global
= 0;
395 /* Move to beg of previous line. */
396 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -2, 1);
399 /* Record what we found, for the next try. */
400 find_start_value
= PT
;
401 find_start_value_byte
= PT_BYTE
;
402 find_start_buffer
= current_buffer
;
403 find_start_modiff
= MODIFF
;
404 find_start_begv
= BEGV
;
405 find_start_pos
= pos
;
407 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
409 return find_start_value
;
412 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
415 prev_char_comend_first (pos
, pos_byte
)
420 DEC_BOTH (pos
, pos_byte
);
421 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
422 c
= FETCH_CHAR (pos_byte
);
423 val
= SYNTAX_COMEND_FIRST (c
);
424 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
428 /* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
431 * prev_char_comstart_first (pos, pos_byte)
436 * DEC_BOTH (pos, pos_byte);
437 * UPDATE_SYNTAX_TABLE_BACKWARD (pos);
438 * c = FETCH_CHAR (pos_byte);
439 * val = SYNTAX_COMSTART_FIRST (c);
440 * UPDATE_SYNTAX_TABLE_FORWARD (pos + 1);
444 /* Checks whether charpos FROM is at the end of a comment.
445 FROM_BYTE is the bytepos corresponding to FROM.
446 Do not move back before STOP.
448 Return a positive value if we find a comment ending at FROM/FROM_BYTE;
451 If successful, store the charpos of the comment's beginning
452 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
454 Global syntax data remains valid for backward search starting at
455 the returned value (or at FROM, if the search was not successful). */
458 back_comment (from
, from_byte
, stop
, comnested
, comstyle
, charpos_ptr
, bytepos_ptr
)
459 int from
, from_byte
, stop
;
460 int comnested
, comstyle
;
461 int *charpos_ptr
, *bytepos_ptr
;
463 /* Look back, counting the parity of string-quotes,
464 and recording the comment-starters seen.
465 When we reach a safe place, assume that's not in a string;
466 then step the main scan to the earliest comment-starter seen
467 an even number of string quotes away from the safe place.
469 OFROM[I] is position of the earliest comment-starter seen
470 which is I+2X quotes from the comment-end.
471 PARITY is current parity of quotes from the comment end. */
472 int string_style
= -1; /* Presumed outside of any string. */
473 int string_lossage
= 0;
474 /* Not a real lossage: indicates that we have passed a matching comment
475 starter plus a non-matching comment-ender, meaning that any matching
476 comment-starter we might see later could be a false positive (hidden
477 inside another comment).
478 Test case: { a (* b } c (* d *) */
479 int comment_lossage
= 0;
480 int comment_end
= from
;
481 int comment_end_byte
= from_byte
;
482 int comstart_pos
= 0;
484 /* Place where the containing defun starts,
485 or 0 if we didn't come across it yet. */
487 int defun_start_byte
= 0;
488 register enum syntaxcode code
;
489 int nesting
= 1; /* current comment nesting */
493 /* FIXME: A }} comment-ender style leads to incorrect behavior
494 in the case of {{ c }}} because we ignore the last two chars which are
495 assumed to be comment-enders although they aren't. */
497 /* At beginning of range to scan, we're outside of strings;
498 that determines quote parity to the comment-end. */
501 int temp_byte
, prev_syntax
;
502 int com2start
, com2end
;
504 /* Move back and examine a character. */
505 DEC_BOTH (from
, from_byte
);
506 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
508 prev_syntax
= syntax
;
509 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
510 syntax
= SYNTAX_WITH_FLAGS (c
);
513 /* Check for 2-char comment markers. */
514 com2start
= (SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
515 && SYNTAX_FLAGS_COMSTART_SECOND (prev_syntax
)
516 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax
)
517 && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
)
518 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
);
519 com2end
= (SYNTAX_FLAGS_COMEND_FIRST (syntax
)
520 && SYNTAX_FLAGS_COMEND_SECOND (prev_syntax
));
522 /* Nasty cases with overlapping 2-char comment markers:
523 - snmp-mode: -- c -- foo -- c --
531 /* If a 2-char comment sequence partly overlaps with another,
532 we don't try to be clever. */
533 if (from
> stop
&& (com2end
|| com2start
))
535 int next
= from
, next_byte
= from_byte
, next_c
, next_syntax
;
536 DEC_BOTH (next
, next_byte
);
537 UPDATE_SYNTAX_TABLE_BACKWARD (next
);
538 next_c
= FETCH_CHAR_AS_MULTIBYTE (next_byte
);
539 next_syntax
= SYNTAX_WITH_FLAGS (next_c
);
540 if (((com2start
|| comnested
)
541 && SYNTAX_FLAGS_COMEND_SECOND (syntax
)
542 && SYNTAX_FLAGS_COMEND_FIRST (next_syntax
))
543 || ((com2end
|| comnested
)
544 && SYNTAX_FLAGS_COMSTART_SECOND (syntax
)
545 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
546 && SYNTAX_FLAGS_COMSTART_FIRST (next_syntax
)))
548 /* UPDATE_SYNTAX_TABLE_FORWARD (next + 1); */
551 if (com2start
&& comstart_pos
== 0)
552 /* We're looking at a comment starter. But it might be a comment
553 ender as well (see snmp-mode). The first time we see one, we
554 need to consider it as a comment starter,
555 and the subsequent times as a comment ender. */
558 /* Turn a 2-char comment sequences into the appropriate syntax. */
563 /* Ignore comment starters of a different style. */
564 else if (code
== Scomment
565 && (comstyle
!= SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
566 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
) != comnested
))
569 /* Ignore escaped characters, except comment-enders. */
570 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
577 c
= (code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
);
579 /* Track parity of quotes. */
580 if (string_style
== -1)
581 /* Entering a string. */
583 else if (string_style
== c
)
584 /* Leaving the string. */
587 /* If we have two kinds of string delimiters.
588 There's no way to grok this scanning backwards. */
593 /* We've already checked that it is the relevant comstyle. */
594 if (string_style
!= -1 || comment_lossage
|| string_lossage
)
595 /* There are odd string quotes involved, so let's be careful.
596 Test case in Pascal: " { " a { " } */
601 /* Record best comment-starter so far. */
603 comstart_byte
= from_byte
;
605 else if (--nesting
<= 0)
606 /* nested comments have to be balanced, so we don't need to
607 keep looking for earlier ones. We use here the same (slightly
608 incorrect) reasoning as below: since it is followed by uniform
609 paired string quotes, this comment-start has to be outside of
610 strings, else the comment-end itself would be inside a string. */
615 if (SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == comstyle
616 && ((com2end
&& SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
))
617 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
)
618 /* This is the same style of comment ender as ours. */
623 /* Anything before that can't count because it would match
624 this comment-ender rather than ours. */
625 from
= stop
; /* Break out of the loop. */
627 else if (comstart_pos
!= 0 || c
!= '\n')
628 /* We're mixing comment styles here, so we'd better be careful.
629 The (comstart_pos != 0 || c != '\n') check is not quite correct
630 (we should just always set comment_lossage), but removing it
631 would imply that any multiline comment in C would go through
632 lossage, which seems overkill.
633 The failure should only happen in the rare cases such as
639 /* Assume a defun-start point is outside of strings. */
640 if (open_paren_in_column_0_is_defun_start
642 || (temp_byte
= dec_bytepos (from_byte
),
643 FETCH_CHAR (temp_byte
) == '\n')))
646 defun_start_byte
= from_byte
;
647 from
= stop
; /* Break out of the loop. */
656 if (comstart_pos
== 0)
659 from_byte
= comment_end_byte
;
660 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
662 /* If comstart_pos is set and we get here (ie. didn't jump to `lossage'
663 or `done'), then we've found the beginning of the non-nested comment. */
664 else if (1) /* !comnested */
667 from_byte
= comstart_byte
;
668 /* Globals are correct now. */
672 struct lisp_parse_state state
;
674 /* We had two kinds of string delimiters mixed up
675 together. Decode this going forwards.
676 Scan fwd from a known safe place (beginning-of-defun)
677 to the one in question; this records where we
678 last passed a comment starter. */
679 /* If we did not already find the defun start, find it now. */
680 if (defun_start
== 0)
682 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
683 defun_start_byte
= find_start_value_byte
;
687 scan_sexps_forward (&state
,
688 defun_start
, defun_start_byte
,
689 comment_end
, -10000, 0, Qnil
, 0);
690 defun_start
= comment_end
;
691 if (state
.incomment
== (comnested
? 1 : -1)
692 && state
.comstyle
== comstyle
)
693 from
= state
.comstr_start
;
698 /* If comment_end is inside some other comment, maybe ours
699 is nested, so we need to try again from within the
700 surrounding comment. Example: { a (* " *) */
702 /* FIXME: We should advance by one or two chars. */
703 defun_start
= state
.comstr_start
+ 2;
704 defun_start_byte
= CHAR_TO_BYTE (defun_start
);
707 } while (defun_start
< comment_end
);
709 from_byte
= CHAR_TO_BYTE (from
);
710 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
715 *bytepos_ptr
= from_byte
;
717 return (from
== comment_end
) ? -1 : from
;
720 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
721 doc
: /* Return t if OBJECT is a syntax table.
722 Currently, any char-table counts as a syntax table. */)
726 if (CHAR_TABLE_P (object
)
727 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
733 check_syntax_table (obj
)
736 if (!(CHAR_TABLE_P (obj
)
737 && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
)))
738 wrong_type_argument (Qsyntax_table_p
, obj
);
741 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
742 doc
: /* Return the current syntax table.
743 This is the one specified by the current buffer. */)
746 return current_buffer
->syntax_table
;
749 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
750 Sstandard_syntax_table
, 0, 0, 0,
751 doc
: /* Return the standard syntax table.
752 This is the one used for new buffers. */)
755 return Vstandard_syntax_table
;
758 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
759 doc
: /* Construct a new syntax table and return it.
760 It is a copy of the TABLE, which defaults to the standard syntax table. */)
767 check_syntax_table (table
);
769 table
= Vstandard_syntax_table
;
771 copy
= Fcopy_sequence (table
);
773 /* Only the standard syntax table should have a default element.
774 Other syntax tables should inherit from parents instead. */
775 XCHAR_TABLE (copy
)->defalt
= Qnil
;
777 /* Copied syntax tables should all have parents.
778 If we copied one with no parent, such as the standard syntax table,
779 use the standard syntax table as the copy's parent. */
780 if (NILP (XCHAR_TABLE (copy
)->parent
))
781 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
785 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
786 doc
: /* Select a new syntax table for the current buffer.
787 One argument, a syntax table. */)
792 check_syntax_table (table
);
793 current_buffer
->syntax_table
= table
;
794 /* Indicate that this buffer now has a specified syntax table. */
795 idx
= PER_BUFFER_VAR_IDX (syntax_table
);
796 SET_PER_BUFFER_VALUE_P (current_buffer
, idx
, 1);
800 /* Convert a letter which signifies a syntax code
801 into the code it signifies.
802 This is used by modify-syntax-entry, and other things. */
804 unsigned char syntax_spec_code
[0400] =
805 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
806 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
807 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
808 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
809 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
810 (char) Smath
, 0377, 0377, (char) Squote
,
811 (char) Sopen
, (char) Sclose
, 0377, 0377,
812 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
813 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
814 0377, 0377, 0377, 0377,
815 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
816 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
817 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
818 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
819 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
820 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
821 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
822 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
823 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
826 /* Indexed by syntax code, give the letter that describes it. */
828 char syntax_code_spec
[16] =
830 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
834 /* Indexed by syntax code, give the object (cons of syntax code and
835 nil) to be stored in syntax table. Since these objects can be
836 shared among syntax tables, we generate them in advance. By
837 sharing objects, the function `describe-syntax' can give a more
839 static Lisp_Object Vsyntax_code_object
;
842 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
843 doc
: /* Return the syntax code of CHARACTER, described by a character.
844 For example, if CHARACTER is a word constituent,
845 the character `w' is returned.
846 The characters that correspond to various syntax codes
847 are listed in the documentation of `modify-syntax-entry'. */)
849 Lisp_Object character
;
852 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
854 gl_state
.use_global
= 0;
855 CHECK_NUMBER (character
);
856 char_int
= XINT (character
);
857 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
860 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
861 doc
: /* Return the matching parenthesis of CHARACTER, or nil if none. */)
863 Lisp_Object character
;
866 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
867 gl_state
.use_global
= 0;
868 CHECK_NUMBER (character
);
869 char_int
= XINT (character
);
870 code
= SYNTAX (char_int
);
871 if (code
== Sopen
|| code
== Sclose
)
872 return SYNTAX_MATCH (char_int
);
876 DEFUN ("string-to-syntax", Fstring_to_syntax
, Sstring_to_syntax
, 1, 1, 0,
877 doc
: /* Convert a syntax specification STRING into syntax cell form.
878 STRING should be a string as it is allowed as argument of
879 `modify-syntax-entry'. Value is the equivalent cons cell
880 (CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'
885 register const unsigned char *p
;
886 register enum syntaxcode code
;
890 CHECK_STRING (string
);
893 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
894 if (((int) code
& 0377) == 0377)
895 error ("invalid syntax description letter: %c", p
[-1]);
897 if (code
== Sinherit
)
903 int character
= (STRING_CHAR_AND_LENGTH
904 (p
, SBYTES (string
) - 1, len
));
905 XSETINT (match
, character
);
906 if (XFASTINT (match
) == ' ')
946 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
947 return XVECTOR (Vsyntax_code_object
)->contents
[val
];
949 /* Since we can't use a shared object, let's make a new one. */
950 return Fcons (make_number (val
), match
);
953 /* I really don't know why this is interactive
954 help-form should at least be made useful whilst reading the second arg. */
955 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
956 "cSet syntax for character: \nsSet syntax for %s to: ",
957 doc
: /* Set syntax for character CHAR according to string NEWENTRY.
958 The syntax is changed only for table SYNTAX_TABLE, which defaults to
959 the current buffer's syntax table.
960 CHAR may be a cons (MIN . MAX), in which case, syntaxes of all characters
961 in the range MIN and MAX are changed.
962 The first character of NEWENTRY should be one of the following:
963 Space or - whitespace syntax. w word constituent.
964 _ symbol constituent. . punctuation.
965 ( open-parenthesis. ) close-parenthesis.
966 " string quote. \\ escape.
967 $ paired delimiter. ' expression quote or prefix operator.
968 < comment starter. > comment ender.
969 / character-quote. @ inherit from `standard-syntax-table'.
970 | generic string fence. ! generic comment fence.
972 Only single-character comment start and end sequences are represented thus.
973 Two-character sequences are represented as described below.
974 The second character of NEWENTRY is the matching parenthesis,
975 used only if the first character is `(' or `)'.
976 Any additional characters are flags.
977 Defined flags are the characters 1, 2, 3, 4, b, p, and n.
978 1 means CHAR is the start of a two-char comment start sequence.
979 2 means CHAR is the second character of such a sequence.
980 3 means CHAR is the start of a two-char comment end sequence.
981 4 means CHAR is the second character of such a sequence.
983 There can be up to two orthogonal comment sequences. This is to support
984 language modes such as C++. By default, all comment sequences are of style
985 a, but you can set the comment sequence style to b (on the second character
986 of a comment-start, or the first character of a comment-end sequence) using
988 b means CHAR is part of comment sequence b.
989 n means CHAR is part of a nestable comment sequence.
991 p means CHAR is a prefix character for `backward-prefix-chars';
992 such characters are treated as whitespace when they occur
994 usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE) */)
995 (c
, newentry
, syntax_table
)
996 Lisp_Object c
, newentry
, syntax_table
;
1000 CHECK_CHARACTER_CAR (c
);
1001 CHECK_CHARACTER_CDR (c
);
1004 CHECK_CHARACTER (c
);
1006 if (NILP (syntax_table
))
1007 syntax_table
= current_buffer
->syntax_table
;
1009 check_syntax_table (syntax_table
);
1011 newentry
= Fstring_to_syntax (newentry
);
1013 SET_RAW_SYNTAX_ENTRY_RANGE (syntax_table
, c
, newentry
);
1015 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), newentry
);
1019 /* Dump syntax table to buffer in human-readable format */
1021 DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value
,
1022 Sinternal_describe_syntax_value
, 1, 1, 0,
1023 doc
: /* Insert a description of the internal syntax description SYNTAX at point. */)
1027 register enum syntaxcode code
;
1028 char desc
, start1
, start2
, end1
, end2
, prefix
, comstyle
, comnested
;
1030 Lisp_Object first
, match_lisp
, value
= syntax
;
1034 insert_string ("default");
1038 if (CHAR_TABLE_P (value
))
1040 insert_string ("deeper char-table ...");
1046 insert_string ("invalid");
1050 first
= XCAR (value
);
1051 match_lisp
= XCDR (value
);
1053 if (!INTEGERP (first
) || !(NILP (match_lisp
) || INTEGERP (match_lisp
)))
1055 insert_string ("invalid");
1059 code
= (enum syntaxcode
) (XINT (first
) & 0377);
1060 start1
= (XINT (first
) >> 16) & 1;
1061 start2
= (XINT (first
) >> 17) & 1;
1062 end1
= (XINT (first
) >> 18) & 1;
1063 end2
= (XINT (first
) >> 19) & 1;
1064 prefix
= (XINT (first
) >> 20) & 1;
1065 comstyle
= (XINT (first
) >> 21) & 1;
1066 comnested
= (XINT (first
) >> 22) & 1;
1068 if ((int) code
< 0 || (int) code
>= (int) Smax
)
1070 insert_string ("invalid");
1073 desc
= syntax_code_spec
[(int) code
];
1075 str
[0] = desc
, str
[1] = 0;
1078 if (NILP (match_lisp
))
1081 insert_char (XINT (match_lisp
));
1100 insert_string ("\twhich means: ");
1102 switch (SWITCH_ENUM_CAST (code
))
1105 insert_string ("whitespace"); break;
1107 insert_string ("punctuation"); break;
1109 insert_string ("word"); break;
1111 insert_string ("symbol"); break;
1113 insert_string ("open"); break;
1115 insert_string ("close"); break;
1117 insert_string ("prefix"); break;
1119 insert_string ("string"); break;
1121 insert_string ("math"); break;
1123 insert_string ("escape"); break;
1125 insert_string ("charquote"); break;
1127 insert_string ("comment"); break;
1129 insert_string ("endcomment"); break;
1131 insert_string ("inherit"); break;
1132 case Scomment_fence
:
1133 insert_string ("comment fence"); break;
1135 insert_string ("string fence"); break;
1137 insert_string ("invalid");
1141 if (!NILP (match_lisp
))
1143 insert_string (", matches ");
1144 insert_char (XINT (match_lisp
));
1148 insert_string (",\n\t is the first character of a comment-start sequence");
1150 insert_string (",\n\t is the second character of a comment-start sequence");
1153 insert_string (",\n\t is the first character of a comment-end sequence");
1155 insert_string (",\n\t is the second character of a comment-end sequence");
1157 insert_string (" (comment style b)");
1159 insert_string (" (nestable)");
1162 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
1167 int parse_sexp_ignore_comments
;
1169 /* Char-table of functions that find the next or previous word
1171 Lisp_Object Vfind_word_boundary_function_table
;
1173 /* Return the position across COUNT words from FROM.
1174 If that many words cannot be found before the end of the buffer, return 0.
1175 COUNT negative means scan backward and stop at word beginning. */
1178 scan_words (from
, count
)
1179 register int from
, count
;
1181 register int beg
= BEGV
;
1182 register int end
= ZV
;
1183 register int from_byte
= CHAR_TO_BYTE (from
);
1184 register enum syntaxcode code
;
1186 Lisp_Object func
, script
, pos
;
1191 SETUP_SYNTAX_TABLE (from
, count
);
1202 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1203 ch0
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1204 code
= SYNTAX (ch0
);
1205 INC_BOTH (from
, from_byte
);
1206 if (words_include_escapes
1207 && (code
== Sescape
|| code
== Scharquote
))
1212 /* Now CH0 is a character which begins a word and FROM is the
1213 position of the next character. */
1214 func
= CHAR_TABLE_REF (Vfind_word_boundary_function_table
, ch0
);
1215 if (! NILP (Ffboundp (func
)))
1217 pos
= call2 (func
, make_number (from
- 1), make_number (end
));
1218 if (INTEGERP (pos
) && XINT (pos
) > from
)
1221 from_byte
= CHAR_TO_BYTE (from
);
1226 script
= CHAR_TABLE_REF (Vchar_script_table
, ch0
);
1229 if (from
== end
) break;
1230 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1231 ch1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1232 code
= SYNTAX (ch1
);
1234 && (! words_include_escapes
1235 || (code
!= Sescape
&& code
!= Scharquote
)))
1236 || ! EQ (CHAR_TABLE_REF (Vchar_script_table
, ch1
), script
))
1238 INC_BOTH (from
, from_byte
);
1253 DEC_BOTH (from
, from_byte
);
1254 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1255 ch1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1256 code
= SYNTAX (ch1
);
1257 if (words_include_escapes
1258 && (code
== Sescape
|| code
== Scharquote
))
1263 /* Now CH1 is a character which ends a word and FROM is the
1265 func
= CHAR_TABLE_REF (Vfind_word_boundary_function_table
, ch1
);
1266 if (! NILP (Ffboundp (func
)))
1268 pos
= call2 (func
, make_number (from
), make_number (beg
));
1269 if (INTEGERP (pos
) && XINT (pos
) < from
)
1272 from_byte
= CHAR_TO_BYTE (from
);
1277 script
= CHAR_TABLE_REF (Vchar_script_table
, ch1
);
1284 temp_byte
= dec_bytepos (from_byte
);
1285 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1286 ch0
= FETCH_CHAR_AS_MULTIBYTE (temp_byte
);
1287 code
= SYNTAX (ch0
);
1289 && (! words_include_escapes
1290 || (code
!= Sescape
&& code
!= Scharquote
)))
1291 || ! EQ (CHAR_TABLE_REF (Vchar_script_table
, ch0
), script
))
1293 DEC_BOTH (from
, from_byte
);
1305 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 1, 1, "p",
1306 doc
: /* Move point forward ARG words (backward if ARG is negative).
1308 If an edge of the buffer or a field boundary is reached, point is left there
1309 and the function returns nil. Field boundaries are not noticed if
1310 `inhibit-field-text-motion' is non-nil. */)
1315 CHECK_NUMBER (count
);
1317 val
= orig_val
= scan_words (PT
, XINT (count
));
1319 val
= XINT (count
) > 0 ? ZV
: BEGV
;
1321 /* Avoid jumping out of an input field. */
1322 val
= XFASTINT (Fconstrain_to_field (make_number (val
), make_number (PT
),
1326 return val
== orig_val
? Qt
: Qnil
;
1329 Lisp_Object
skip_chars ();
1331 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1332 doc
: /* Move point forward, stopping before a char not in STRING, or at pos LIM.
1333 STRING is like the inside of a `[...]' in a regular expression
1334 except that `]' is never special and `\\' quotes `^', `-' or `\\'
1335 (but not as the end of a range; quoting is never needed there).
1336 Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
1337 With arg "^a-zA-Z", skips nonletters stopping before first letter.
1338 Returns the distance traveled, either zero or positive.
1339 Note that char classes, e.g. `[:alpha:]', are not currently supported;
1340 they will be treated as literals. */)
1342 Lisp_Object string
, lim
;
1344 return skip_chars (1, string
, lim
);
1347 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1348 doc
: /* Move point backward, stopping after a char not in STRING, or at pos LIM.
1349 See `skip-chars-forward' for details.
1350 Returns the distance traveled, either zero or negative. */)
1352 Lisp_Object string
, lim
;
1354 return skip_chars (0, string
, lim
);
1357 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1358 doc
: /* Move point forward across chars in specified syntax classes.
1359 SYNTAX is a string of syntax code characters.
1360 Stop before a char whose syntax is not in SYNTAX, or at position LIM.
1361 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1362 This function returns the distance traveled, either zero or positive. */)
1364 Lisp_Object syntax
, lim
;
1366 return skip_syntaxes (1, syntax
, lim
);
1369 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1370 doc
: /* Move point backward across chars in specified syntax classes.
1371 SYNTAX is a string of syntax code characters.
1372 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
1373 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1374 This function returns the distance traveled, either zero or negative. */)
1376 Lisp_Object syntax
, lim
;
1378 return skip_syntaxes (0, syntax
, lim
);
1382 skip_chars (forwardp
, string
, lim
)
1384 Lisp_Object string
, lim
;
1386 register unsigned int c
;
1387 unsigned char fastmap
[0400];
1388 /* Store the ranges of non-ASCII characters. */
1390 int n_char_ranges
= 0;
1392 register int i
, i_byte
;
1393 /* Set to 1 if the current buffer is multibyte and the region
1394 contains non-ASCII chars. */
1396 /* Set to 1 if STRING is multibyte and it contains non-ASCII
1398 int string_multibyte
;
1400 const unsigned char *str
;
1403 CHECK_STRING (string
);
1406 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1408 CHECK_NUMBER_COERCE_MARKER (lim
);
1410 /* In any case, don't allow scan outside bounds of buffer. */
1411 if (XINT (lim
) > ZV
)
1412 XSETFASTINT (lim
, ZV
);
1413 if (XINT (lim
) < BEGV
)
1414 XSETFASTINT (lim
, BEGV
);
1416 multibyte
= (!NILP (current_buffer
->enable_multibyte_characters
)
1417 && (XINT (lim
) - PT
!= CHAR_TO_BYTE (XINT (lim
)) - PT_BYTE
));
1418 string_multibyte
= SBYTES (string
) > SCHARS (string
);
1420 bzero (fastmap
, sizeof fastmap
);
1422 char_ranges
= (int *) alloca (SCHARS (string
) * (sizeof (int)) * 2);
1424 str
= SDATA (string
);
1425 size_byte
= SBYTES (string
);
1428 if (i_byte
< size_byte
1429 && SREF (string
, 0) == '^')
1431 negate
= 1; i_byte
++;
1434 /* Find the characters specified and set their elements of fastmap.
1435 Handle backslashes and ranges specially.
1437 If STRING contains non-ASCII characters, setup char_ranges for
1438 them and use fastmap only for their leading codes. */
1440 if (! string_multibyte
)
1442 int string_has_eight_bit
= 0;
1444 /* At first setup fastmap. */
1445 while (i_byte
< size_byte
)
1451 if (i_byte
== size_byte
)
1456 if (i_byte
< size_byte
1457 && str
[i_byte
] == '-')
1461 /* Skip over the dash. */
1464 if (i_byte
== size_byte
)
1467 /* Get the end of the range. */
1470 && i_byte
< size_byte
)
1477 if (! ASCII_CHAR_P (c2
))
1478 string_has_eight_bit
= 1;
1484 if (! ASCII_CHAR_P (c
))
1485 string_has_eight_bit
= 1;
1489 /* If the current range is multibyte and STRING contains
1490 eight-bit chars, arrange fastmap and setup char_ranges for
1491 the corresponding multibyte chars. */
1492 if (multibyte
&& string_has_eight_bit
)
1494 unsigned char fastmap2
[0400];
1495 int range_start_byte
, range_start_char
;
1497 bcopy (fastmap2
+ 0200, fastmap
+ 0200, 0200);
1498 bzero (fastmap
+ 0200, 0200);
1499 /* We are sure that this loop stops. */
1500 for (i
= 0200; ! fastmap2
[i
]; i
++);
1501 c
= unibyte_char_to_multibyte (i
);
1502 fastmap
[CHAR_LEADING_CODE (c
)] = 1;
1503 range_start_byte
= i
;
1504 range_start_char
= c
;
1505 for (i
= 129; i
< 0400; i
++)
1507 c
= unibyte_char_to_multibyte (i
);
1508 fastmap
[CHAR_LEADING_CODE (c
)] = 1;
1509 if (i
- range_start_byte
!= c
- range_start_char
)
1511 char_ranges
[n_char_ranges
++] = range_start_char
;
1512 char_ranges
[n_char_ranges
++] = ((i
- 1 - range_start_byte
)
1513 + range_start_char
);
1514 range_start_byte
= i
;
1515 range_start_char
= c
;
1518 char_ranges
[n_char_ranges
++] = range_start_char
;
1519 char_ranges
[n_char_ranges
++] = ((i
- 1 - range_start_byte
)
1520 + range_start_char
);
1525 while (i_byte
< size_byte
)
1527 unsigned char leading_code
;
1529 leading_code
= str
[i_byte
];
1530 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, size_byte
-i_byte
, len
);
1535 if (i_byte
== size_byte
)
1538 leading_code
= str
[i_byte
];
1539 c
= STRING_CHAR_AND_LENGTH (str
+i_byte
, size_byte
-i_byte
, len
);
1542 if (i_byte
< size_byte
1543 && str
[i_byte
] == '-')
1546 unsigned char leading_code2
;
1548 /* Skip over the dash. */
1551 if (i_byte
== size_byte
)
1554 /* Get the end of the range. */
1555 leading_code2
= str
[i_byte
];
1556 c2
=STRING_CHAR_AND_LENGTH (str
+ i_byte
, size_byte
-i_byte
, len
);
1560 && i_byte
< size_byte
)
1562 leading_code2
= str
[i_byte
];
1563 c2
=STRING_CHAR_AND_LENGTH (str
+ i_byte
, size_byte
-i_byte
, len
);
1567 if (ASCII_CHAR_P (c
))
1569 while (c
<= c2
&& c
< 0x80)
1571 leading_code
= CHAR_LEADING_CODE (c
);
1573 if (! ASCII_CHAR_P (c
))
1575 while (leading_code
<= leading_code2
)
1576 fastmap
[leading_code
++] = 1;
1579 char_ranges
[n_char_ranges
++] = c
;
1580 char_ranges
[n_char_ranges
++] = c2
;
1586 if (ASCII_CHAR_P (c
))
1590 fastmap
[leading_code
] = 1;
1591 char_ranges
[n_char_ranges
++] = c
;
1592 char_ranges
[n_char_ranges
++] = c
;
1597 /* If the current range is unibyte and STRING contains non-ASCII
1598 chars, arrange fastmap for the corresponding unibyte
1601 if (! multibyte
&& n_char_ranges
> 0)
1603 bzero (fastmap
+ 0200, 0200);
1604 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1606 int c1
= char_ranges
[i
];
1607 int c2
= char_ranges
[i
+ 1];
1609 for (; c1
<= c2
; c1
++)
1610 fastmap
[CHAR_TO_BYTE8 (c1
)] = 1;
1615 /* If ^ was the first character, complement the fastmap. */
1619 for (i
= 0; i
< sizeof fastmap
; i
++)
1623 for (i
= 0; i
< 0200; i
++)
1625 /* All non-ASCII chars possibly match. */
1626 for (; i
< sizeof fastmap
; i
++)
1632 int start_point
= PT
;
1634 int pos_byte
= PT_BYTE
;
1635 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
1639 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
1640 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
1644 endp
= CHAR_POS_ADDR (XINT (lim
));
1645 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
1665 c
= STRING_CHAR_AND_LENGTH (p
, MAX_MULTIBYTE_LENGTH
, nbytes
);
1666 if (! ASCII_CHAR_P (c
))
1668 /* As we are looking at a multibyte character, we
1669 must look up the character in the table
1670 CHAR_RANGES. If there's no data in the table,
1671 that character is not what we want to skip. */
1673 /* The following code do the right thing even if
1674 n_char_ranges is zero (i.e. no data in
1676 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1677 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1679 if (!(negate
^ (i
< n_char_ranges
)))
1682 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
1696 p
++, pos
++, pos_byte
++;
1704 unsigned char *prev_p
;
1714 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
1717 c
= STRING_CHAR (p
, MAX_MULTIBYTE_LENGTH
);
1718 if (! ASCII_CHAR_P (c
))
1720 /* See the comment in the previous similar code. */
1721 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1722 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1724 if (!(negate
^ (i
< n_char_ranges
)))
1727 pos
--, pos_byte
-= prev_p
- p
;
1739 if (!fastmap
[p
[-1]])
1741 p
--, pos
--, pos_byte
--;
1745 SET_PT_BOTH (pos
, pos_byte
);
1748 return make_number (PT
- start_point
);
1754 skip_syntaxes (forwardp
, string
, lim
)
1756 Lisp_Object string
, lim
;
1758 register unsigned int c
;
1759 unsigned char fastmap
[0400];
1761 register int i
, i_byte
;
1766 CHECK_STRING (string
);
1769 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1771 CHECK_NUMBER_COERCE_MARKER (lim
);
1773 /* In any case, don't allow scan outside bounds of buffer. */
1774 if (XINT (lim
) > ZV
)
1775 XSETFASTINT (lim
, ZV
);
1776 if (XINT (lim
) < BEGV
)
1777 XSETFASTINT (lim
, BEGV
);
1779 if (forwardp
? (PT
>= XFASTINT (lim
)) : (PT
<= XFASTINT (lim
)))
1782 multibyte
= (!NILP (current_buffer
->enable_multibyte_characters
)
1783 && (XINT (lim
) - PT
!= CHAR_TO_BYTE (XINT (lim
)) - PT_BYTE
));
1785 bzero (fastmap
, sizeof fastmap
);
1787 if (SBYTES (string
) > SCHARS (string
))
1788 /* As this is very rare case (syntax spec is ASCII only), don't
1789 consider efficiency. */
1790 string
= string_make_unibyte (string
);
1792 str
= SDATA (string
);
1793 size_byte
= SBYTES (string
);
1796 if (i_byte
< size_byte
1797 && SREF (string
, 0) == '^')
1799 negate
= 1; i_byte
++;
1802 /* Find the syntaxes specified and set their elements of fastmap. */
1804 while (i_byte
< size_byte
)
1807 fastmap
[syntax_spec_code
[c
]] = 1;
1810 /* If ^ was the first character, complement the fastmap. */
1812 for (i
= 0; i
< sizeof fastmap
; i
++)
1816 int start_point
= PT
;
1818 int pos_byte
= PT_BYTE
;
1819 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
1823 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
1824 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
1828 endp
= CHAR_POS_ADDR (XINT (lim
));
1829 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
1833 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1849 c
= STRING_CHAR_AND_LENGTH (p
, MAX_MULTIBYTE_LENGTH
, nbytes
);
1850 if (! fastmap
[(int) SYNTAX (c
)])
1852 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
1853 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1867 if (! fastmap
[(int) SYNTAX (*p
)])
1869 p
++, pos
++, pos_byte
++;
1870 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1880 unsigned char *prev_p
;
1890 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
1891 c
= STRING_CHAR (p
, MAX_MULTIBYTE_LENGTH
);
1892 if (! fastmap
[(int) SYNTAX (c
)])
1894 pos
--, pos_byte
-= prev_p
- p
;
1895 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
1909 if (! fastmap
[(int) SYNTAX (p
[-1])])
1911 p
--, pos
--, pos_byte
--;
1912 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
1917 SET_PT_BOTH (pos
, pos_byte
);
1920 return make_number (PT
- start_point
);
1924 /* Jump over a comment, assuming we are at the beginning of one.
1925 FROM is the current position.
1926 FROM_BYTE is the bytepos corresponding to FROM.
1927 Do not move past STOP (a charpos).
1928 The comment over which we have to jump is of style STYLE
1929 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
1930 NESTING should be positive to indicate the nesting at the beginning
1931 for nested comments and should be zero or negative else.
1932 ST_COMMENT_STYLE cannot be nested.
1933 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
1934 (or 0 If the search cannot start in the middle of a two-character).
1936 If successful, return 1 and store the charpos of the comment's end
1937 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
1938 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
1939 corresponding bytepos into *BYTEPOS_PTR and the current nesting
1940 (as defined for state.incomment) in *INCOMMENT_PTR.
1942 The comment end is the last character of the comment rather than the
1943 character just after the comment.
1945 Global syntax data is assumed to initially be valid for FROM and
1946 remains valid for forward search starting at the returned position. */
1949 forw_comment (from
, from_byte
, stop
, nesting
, style
, prev_syntax
,
1950 charpos_ptr
, bytepos_ptr
, incomment_ptr
)
1951 int from
, from_byte
, stop
;
1952 int nesting
, style
, prev_syntax
;
1953 int *charpos_ptr
, *bytepos_ptr
, *incomment_ptr
;
1956 register enum syntaxcode code
;
1957 register int syntax
;
1959 if (nesting
<= 0) nesting
= -1;
1961 /* Enter the loop in the middle so that we find
1962 a 2-char comment ender if we start in the middle of it. */
1963 syntax
= prev_syntax
;
1964 if (syntax
!= 0) goto forw_incomment
;
1970 *incomment_ptr
= nesting
;
1971 *charpos_ptr
= from
;
1972 *bytepos_ptr
= from_byte
;
1975 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1976 syntax
= SYNTAX_WITH_FLAGS (c
);
1977 code
= syntax
& 0xff;
1978 if (code
== Sendcomment
1979 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
1980 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ?
1981 (nesting
> 0 && --nesting
== 0) : nesting
< 0))
1982 /* we have encountered a comment end of the same style
1983 as the comment sequence which began this comment
1986 if (code
== Scomment_fence
1987 && style
== ST_COMMENT_STYLE
)
1988 /* we have encountered a comment end of the same style
1989 as the comment sequence which began this comment
1994 && SYNTAX_FLAGS_COMMENT_NESTED (syntax
)
1995 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
)
1996 /* we have encountered a nested comment of the same style
1997 as the comment sequence which began this comment section */
1999 INC_BOTH (from
, from_byte
);
2000 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2003 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
2004 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
2005 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2006 SYNTAX_COMEND_SECOND (c1
))
2007 && ((SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
2008 SYNTAX_COMMENT_NESTED (c1
)) ? nesting
> 0 : nesting
< 0))
2011 /* we have encountered a comment end of the same style
2012 as the comment sequence which began this comment
2017 INC_BOTH (from
, from_byte
);
2018 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2023 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
2024 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2025 SYNTAX_COMMENT_STYLE (c1
) == style
2026 && SYNTAX_COMSTART_SECOND (c1
))
2027 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
2028 SYNTAX_COMMENT_NESTED (c1
)))
2029 /* we have encountered a nested comment of the same style
2030 as the comment sequence which began this comment
2033 INC_BOTH (from
, from_byte
);
2034 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2038 *charpos_ptr
= from
;
2039 *bytepos_ptr
= from_byte
;
2043 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
2045 Move forward across up to COUNT comments. If COUNT is negative, move backward.
2046 Stop scanning if we find something other than a comment or whitespace.
2047 Set point to where scanning stops.
2048 If COUNT comments are found as expected, with nothing except whitespace
2049 between them, return t; otherwise return nil. */)
2057 register enum syntaxcode code
;
2058 int comstyle
= 0; /* style of comment encountered */
2059 int comnested
= 0; /* whether the comment is nestable or not */
2062 int out_charpos
, out_bytepos
;
2065 CHECK_NUMBER (count
);
2066 count1
= XINT (count
);
2067 stop
= count1
> 0 ? ZV
: BEGV
;
2073 from_byte
= PT_BYTE
;
2075 SETUP_SYNTAX_TABLE (from
, count1
);
2084 SET_PT_BOTH (from
, from_byte
);
2088 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2090 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2091 comnested
= SYNTAX_COMMENT_NESTED (c
);
2092 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2093 INC_BOTH (from
, from_byte
);
2094 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2095 if (from
< stop
&& comstart_first
2096 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2097 SYNTAX_COMSTART_SECOND (c1
)))
2099 /* We have encountered a comment start sequence and we
2100 are ignoring all text inside comments. We must record
2101 the comment style this sequence begins so that later,
2102 only a comment end of the same style actually ends
2103 the comment section. */
2105 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2106 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2107 INC_BOTH (from
, from_byte
);
2108 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2111 while (code
== Swhitespace
|| (code
== Sendcomment
&& c
== '\n'));
2113 if (code
== Scomment_fence
)
2114 comstyle
= ST_COMMENT_STYLE
;
2115 else if (code
!= Scomment
)
2118 DEC_BOTH (from
, from_byte
);
2119 SET_PT_BOTH (from
, from_byte
);
2122 /* We're at the start of a comment. */
2123 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
2124 &out_charpos
, &out_bytepos
, &dummy
);
2125 from
= out_charpos
; from_byte
= out_bytepos
;
2129 SET_PT_BOTH (from
, from_byte
);
2132 INC_BOTH (from
, from_byte
);
2133 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2134 /* We have skipped one comment. */
2146 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
2151 DEC_BOTH (from
, from_byte
);
2152 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
2153 quoted
= char_quoted (from
, from_byte
);
2154 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2157 comnested
= SYNTAX_COMMENT_NESTED (c
);
2158 if (code
== Sendcomment
)
2159 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2160 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2161 && prev_char_comend_first (from
, from_byte
)
2162 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
2164 /* We must record the comment style encountered so that
2165 later, we can match only the proper comment begin
2166 sequence of the same style. */
2167 DEC_BOTH (from
, from_byte
);
2169 /* Calling char_quoted, above, set up global syntax position
2170 at the new value of FROM. */
2171 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2172 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2173 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2176 if (code
== Scomment_fence
)
2178 /* Skip until first preceding unquoted comment_fence. */
2179 int found
= 0, ini
= from
, ini_byte
= from_byte
;
2183 DEC_BOTH (from
, from_byte
);
2186 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2187 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2188 if (SYNTAX (c
) == Scomment_fence
2189 && !char_quoted (from
, from_byte
))
2197 from
= ini
; /* Set point to ini + 1. */
2198 from_byte
= ini_byte
;
2202 else if (code
== Sendcomment
)
2204 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2205 &out_charpos
, &out_bytepos
);
2209 /* This end-of-line is not an end-of-comment.
2210 Treat it like a whitespace.
2211 CC-mode (and maybe others) relies on this behavior. */
2215 /* Failure: we should go back to the end of this
2216 not-quite-endcomment. */
2217 if (SYNTAX(c
) != code
)
2218 /* It was a two-char Sendcomment. */
2219 INC_BOTH (from
, from_byte
);
2225 /* We have skipped one comment. */
2226 from
= out_charpos
, from_byte
= out_bytepos
;
2230 else if (code
!= Swhitespace
|| quoted
)
2234 INC_BOTH (from
, from_byte
);
2235 SET_PT_BOTH (from
, from_byte
);
2243 SET_PT_BOTH (from
, from_byte
);
2248 /* Return syntax code of character C if C is an ASCII character
2249 or `multibyte_symbol_p' is zero. Otherwise, return Ssymbol. */
2251 #define SYNTAX_WITH_MULTIBYTE_CHECK(c) \
2252 ((ASCII_CHAR_P (c) || !multibyte_symbol_p) \
2253 ? SYNTAX (c) : Ssymbol)
2256 scan_lists (from
, count
, depth
, sexpflag
)
2258 int count
, depth
, sexpflag
;
2261 register int stop
= count
> 0 ? ZV
: BEGV
;
2266 register enum syntaxcode code
, temp_code
;
2267 int min_depth
= depth
; /* Err out if depth gets less than this. */
2268 int comstyle
= 0; /* style of comment encountered */
2269 int comnested
= 0; /* whether the comment is nestable or not */
2271 int last_good
= from
;
2274 int out_bytepos
, out_charpos
;
2276 int multibyte_symbol_p
= sexpflag
&& multibyte_syntax_as_symbol
;
2278 if (depth
> 0) min_depth
= 0;
2280 if (from
> ZV
) from
= ZV
;
2281 if (from
< BEGV
) from
= BEGV
;
2283 from_byte
= CHAR_TO_BYTE (from
);
2288 SETUP_SYNTAX_TABLE (from
, count
);
2293 int comstart_first
, prefix
;
2294 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2295 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2296 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2297 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2298 comnested
= SYNTAX_COMMENT_NESTED (c
);
2299 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2300 prefix
= SYNTAX_PREFIX (c
);
2301 if (depth
== min_depth
)
2303 INC_BOTH (from
, from_byte
);
2304 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2305 if (from
< stop
&& comstart_first
2306 && SYNTAX_COMSTART_SECOND (FETCH_CHAR_AS_MULTIBYTE (from_byte
))
2307 && parse_sexp_ignore_comments
)
2309 /* we have encountered a comment start sequence and we
2310 are ignoring all text inside comments. We must record
2311 the comment style this sequence begins so that later,
2312 only a comment end of the same style actually ends
2313 the comment section */
2315 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2316 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2317 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2318 INC_BOTH (from
, from_byte
);
2319 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2325 switch (SWITCH_ENUM_CAST (code
))
2329 if (from
== stop
) goto lose
;
2330 INC_BOTH (from
, from_byte
);
2331 /* treat following character as a word constituent */
2334 if (depth
|| !sexpflag
) break;
2335 /* This word counts as a sexp; return at end of it. */
2338 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2340 /* Some compilers can't handle this inside the switch. */
2341 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2342 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2347 INC_BOTH (from
, from_byte
);
2348 if (from
== stop
) goto lose
;
2357 INC_BOTH (from
, from_byte
);
2361 case Scomment_fence
:
2362 comstyle
= ST_COMMENT_STYLE
;
2365 if (!parse_sexp_ignore_comments
) break;
2366 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2367 found
= forw_comment (from
, from_byte
, stop
,
2368 comnested
, comstyle
, 0,
2369 &out_charpos
, &out_bytepos
, &dummy
);
2370 from
= out_charpos
, from_byte
= out_bytepos
;
2377 INC_BOTH (from
, from_byte
);
2378 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2384 if (from
!= stop
&& c
== FETCH_CHAR_AS_MULTIBYTE (from_byte
))
2386 INC_BOTH (from
, from_byte
);
2396 if (!++depth
) goto done
;
2401 if (!--depth
) goto done
;
2402 if (depth
< min_depth
)
2403 Fsignal (Qscan_error
,
2404 Fcons (build_string ("Containing expression ends prematurely"),
2405 Fcons (make_number (last_good
),
2406 Fcons (make_number (from
), Qnil
))));
2411 temp_pos
= dec_bytepos (from_byte
);
2412 stringterm
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2415 if (from
>= stop
) goto lose
;
2416 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2417 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2420 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2421 : SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring_fence
)
2424 /* Some compilers can't handle this inside the switch. */
2425 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2430 INC_BOTH (from
, from_byte
);
2432 INC_BOTH (from
, from_byte
);
2434 INC_BOTH (from
, from_byte
);
2435 if (!depth
&& sexpflag
) goto done
;
2438 /* Ignore whitespace, punctuation, quote, endcomment. */
2443 /* Reached end of buffer. Error if within object, return nil if between */
2444 if (depth
) goto lose
;
2449 /* End of object reached */
2458 DEC_BOTH (from
, from_byte
);
2459 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2460 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2461 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2462 if (depth
== min_depth
)
2465 comnested
= SYNTAX_COMMENT_NESTED (c
);
2466 if (code
== Sendcomment
)
2467 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2468 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2469 && prev_char_comend_first (from
, from_byte
)
2470 && parse_sexp_ignore_comments
)
2472 /* We must record the comment style encountered so that
2473 later, we can match only the proper comment begin
2474 sequence of the same style. */
2475 DEC_BOTH (from
, from_byte
);
2476 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2478 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2479 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2480 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2483 /* Quoting turns anything except a comment-ender
2484 into a word character. Note that this cannot be true
2485 if we decremented FROM in the if-statement above. */
2486 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2488 DEC_BOTH (from
, from_byte
);
2491 else if (SYNTAX_PREFIX (c
))
2494 switch (SWITCH_ENUM_CAST (code
))
2500 if (depth
|| !sexpflag
) break;
2501 /* This word counts as a sexp; count object finished
2502 after passing it. */
2505 temp_pos
= from_byte
;
2506 if (! NILP (current_buffer
->enable_multibyte_characters
))
2510 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2511 c1
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2512 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2513 /* Don't allow comment-end to be quoted. */
2514 if (temp_code
== Sendcomment
)
2516 quoted
= char_quoted (from
- 1, temp_pos
);
2519 DEC_BOTH (from
, from_byte
);
2520 temp_pos
= dec_bytepos (temp_pos
);
2521 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2523 c1
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2524 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2525 if (! (quoted
|| temp_code
== Sword
2526 || temp_code
== Ssymbol
2527 || temp_code
== Squote
))
2529 DEC_BOTH (from
, from_byte
);
2536 temp_pos
= dec_bytepos (from_byte
);
2537 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2538 if (from
!= stop
&& c
== FETCH_CHAR_AS_MULTIBYTE (temp_pos
))
2539 DEC_BOTH (from
, from_byte
);
2548 if (!++depth
) goto done2
;
2553 if (!--depth
) goto done2
;
2554 if (depth
< min_depth
)
2555 Fsignal (Qscan_error
,
2556 Fcons (build_string ("Containing expression ends prematurely"),
2557 Fcons (make_number (last_good
),
2558 Fcons (make_number (from
), Qnil
))));
2562 if (!parse_sexp_ignore_comments
)
2564 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2565 &out_charpos
, &out_bytepos
);
2566 /* FIXME: if found == -1, then it really wasn't a comment-end.
2567 For single-char Sendcomment, we can't do much about it apart
2568 from skipping the char.
2569 For 2-char endcomments, we could try again, taking both
2570 chars as separate entities, but it's a lot of trouble
2571 for very little gain, so we don't bother either. -sm */
2573 from
= out_charpos
, from_byte
= out_bytepos
;
2576 case Scomment_fence
:
2580 DEC_BOTH (from
, from_byte
);
2581 if (from
== stop
) goto lose
;
2582 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2583 if (!char_quoted (from
, from_byte
)
2584 && (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2585 SYNTAX_WITH_MULTIBYTE_CHECK (c
) == code
))
2588 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2592 stringterm
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2595 if (from
== stop
) goto lose
;
2596 temp_pos
= from_byte
;
2597 if (! NILP (current_buffer
->enable_multibyte_characters
))
2601 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2602 if (!char_quoted (from
- 1, temp_pos
)
2603 && stringterm
== (c
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
))
2604 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2606 DEC_BOTH (from
, from_byte
);
2608 DEC_BOTH (from
, from_byte
);
2609 if (!depth
&& sexpflag
) goto done2
;
2612 /* Ignore whitespace, punctuation, quote, endcomment. */
2617 /* Reached start of buffer. Error if within object, return nil if between */
2618 if (depth
) goto lose
;
2629 XSETFASTINT (val
, from
);
2633 Fsignal (Qscan_error
,
2634 Fcons (build_string ("Unbalanced parentheses"),
2635 Fcons (make_number (last_good
),
2636 Fcons (make_number (from
), Qnil
))));
2641 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2642 doc
: /* Scan from character number FROM by COUNT lists.
2643 Returns the character number of the position thus found.
2645 If DEPTH is nonzero, paren depth begins counting from that value,
2646 only places where the depth in parentheses becomes zero
2647 are candidates for stopping; COUNT such places are counted.
2648 Thus, a positive value for DEPTH means go out levels.
2650 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2652 If the beginning or end of (the accessible part of) the buffer is reached
2653 and the depth is wrong, an error is signaled.
2654 If the depth is right but the count is not used up, nil is returned. */)
2655 (from
, count
, depth
)
2656 Lisp_Object from
, count
, depth
;
2658 CHECK_NUMBER (from
);
2659 CHECK_NUMBER (count
);
2660 CHECK_NUMBER (depth
);
2662 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2665 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2666 doc
: /* Scan from character number FROM by COUNT balanced expressions.
2667 If COUNT is negative, scan backwards.
2668 Returns the character number of the position thus found.
2670 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2672 If the beginning or end of (the accessible part of) the buffer is reached
2673 in the middle of a parenthetical grouping, an error is signaled.
2674 If the beginning or end is reached between groupings
2675 but before count is used up, nil is returned. */)
2677 Lisp_Object from
, count
;
2679 CHECK_NUMBER (from
);
2680 CHECK_NUMBER (count
);
2682 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2685 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2687 doc
: /* Move point backward over any number of chars with prefix syntax.
2688 This includes chars with "quote" or "prefix" syntax (' or p). */)
2693 int opoint_byte
= PT_BYTE
;
2695 int pos_byte
= PT_BYTE
;
2700 SET_PT_BOTH (opoint
, opoint_byte
);
2705 SETUP_SYNTAX_TABLE (pos
, -1);
2707 DEC_BOTH (pos
, pos_byte
);
2709 while (!char_quoted (pos
, pos_byte
)
2710 /* Previous statement updates syntax table. */
2711 && ((c
= FETCH_CHAR_AS_MULTIBYTE (pos_byte
), SYNTAX (c
) == Squote
)
2712 || SYNTAX_PREFIX (c
)))
2715 opoint_byte
= pos_byte
;
2718 DEC_BOTH (pos
, pos_byte
);
2721 SET_PT_BOTH (opoint
, opoint_byte
);
2726 /* Parse forward from FROM / FROM_BYTE to END,
2727 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2728 and return a description of the state of the parse at END.
2729 If STOPBEFORE is nonzero, stop at the start of an atom.
2730 If COMMENTSTOP is 1, stop at the start of a comment.
2731 If COMMENTSTOP is -1, stop at the start or end of a comment,
2732 after the beginning of a string, or after the end of a string. */
2735 scan_sexps_forward (stateptr
, from
, from_byte
, end
, targetdepth
,
2736 stopbefore
, oldstate
, commentstop
)
2737 struct lisp_parse_state
*stateptr
;
2740 int end
, targetdepth
, stopbefore
;
2741 Lisp_Object oldstate
;
2744 struct lisp_parse_state state
;
2746 register enum syntaxcode code
;
2749 struct level
{ int last
, prev
; };
2750 struct level levelstart
[100];
2751 register struct level
*curlevel
= levelstart
;
2752 struct level
*endlevel
= levelstart
+ 100;
2753 register int depth
; /* Paren depth of current scanning location.
2754 level - levelstart equals this except
2755 when the depth becomes negative. */
2756 int mindepth
; /* Lowest DEPTH value seen. */
2757 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2759 int prev_from
; /* Keep one character before FROM. */
2761 int prev_from_syntax
;
2762 int boundary_stop
= commentstop
== -1;
2765 int out_bytepos
, out_charpos
;
2769 prev_from_byte
= from_byte
;
2771 DEC_BOTH (prev_from
, prev_from_byte
);
2773 /* Use this macro instead of `from++'. */
2775 do { prev_from = from; \
2776 prev_from_byte = from_byte; \
2778 = SYNTAX_WITH_FLAGS (FETCH_CHAR_AS_MULTIBYTE (prev_from_byte)); \
2779 INC_BOTH (from, from_byte); \
2781 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2787 if (NILP (oldstate
))
2790 state
.instring
= -1;
2791 state
.incomment
= 0;
2792 state
.comstyle
= 0; /* comment style a by default. */
2793 state
.comstr_start
= -1; /* no comment/string seen. */
2797 tem
= Fcar (oldstate
);
2803 oldstate
= Fcdr (oldstate
);
2804 oldstate
= Fcdr (oldstate
);
2805 oldstate
= Fcdr (oldstate
);
2806 tem
= Fcar (oldstate
);
2807 /* Check whether we are inside string_fence-style string: */
2808 state
.instring
= (!NILP (tem
)
2809 ? (INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2812 oldstate
= Fcdr (oldstate
);
2813 tem
= Fcar (oldstate
);
2814 state
.incomment
= (!NILP (tem
)
2815 ? (INTEGERP (tem
) ? XINT (tem
) : -1)
2818 oldstate
= Fcdr (oldstate
);
2819 tem
= Fcar (oldstate
);
2820 start_quoted
= !NILP (tem
);
2822 /* if the eighth element of the list is nil, we are in comment
2823 style a. If it is non-nil, we are in comment style b */
2824 oldstate
= Fcdr (oldstate
);
2825 oldstate
= Fcdr (oldstate
);
2826 tem
= Fcar (oldstate
);
2827 state
.comstyle
= NILP (tem
) ? 0 : (EQ (tem
, Qsyntax_table
)
2828 ? ST_COMMENT_STYLE
: 1);
2830 oldstate
= Fcdr (oldstate
);
2831 tem
= Fcar (oldstate
);
2832 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2833 oldstate
= Fcdr (oldstate
);
2834 tem
= Fcar (oldstate
);
2835 while (!NILP (tem
)) /* >= second enclosing sexps. */
2837 /* curlevel++->last ran into compiler bug on Apollo */
2838 curlevel
->last
= XINT (Fcar (tem
));
2839 if (++curlevel
== endlevel
)
2840 curlevel
--; /* error ("Nesting too deep for parser"); */
2841 curlevel
->prev
= -1;
2842 curlevel
->last
= -1;
2849 curlevel
->prev
= -1;
2850 curlevel
->last
= -1;
2852 SETUP_SYNTAX_TABLE (prev_from
, 1);
2853 prev_from_syntax
= SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte
));
2854 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2856 /* Enter the loop at a place appropriate for initial state. */
2858 if (state
.incomment
)
2859 goto startincomment
;
2860 if (state
.instring
>= 0)
2862 nofence
= state
.instring
!= ST_STRING_STYLE
;
2864 goto startquotedinstring
;
2867 else if (start_quoted
)
2873 code
= prev_from_syntax
& 0xff;
2875 if (code
== Scomment
)
2877 state
.comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax
);
2878 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
2880 state
.comstr_start
= prev_from
;
2882 else if (code
== Scomment_fence
)
2884 /* Record the comment style we have entered so that only
2885 the comment-end sequence of the same style actually
2886 terminates the comment section. */
2887 state
.comstyle
= ST_COMMENT_STYLE
;
2888 state
.incomment
= -1;
2889 state
.comstr_start
= prev_from
;
2892 else if (from
< end
)
2893 if (SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
))
2894 if (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2895 SYNTAX_COMSTART_SECOND (c1
))
2896 /* Duplicate code to avoid a complex if-expression
2897 which causes trouble for the SGI compiler. */
2899 /* Record the comment style we have entered so that only
2900 the comment-end sequence of the same style actually
2901 terminates the comment section. */
2902 state
.comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2903 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
);
2904 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2905 state
.incomment
= comnested
? 1 : -1;
2906 state
.comstr_start
= prev_from
;
2911 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
2913 switch (SWITCH_ENUM_CAST (code
))
2917 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2918 curlevel
->last
= prev_from
;
2920 if (from
== end
) goto endquoted
;
2923 /* treat following character as a word constituent */
2926 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2927 curlevel
->last
= prev_from
;
2931 /* Some compilers can't handle this inside the switch. */
2932 temp
= SYNTAX (FETCH_CHAR_AS_MULTIBYTE (from_byte
));
2938 if (from
== end
) goto endquoted
;
2950 curlevel
->prev
= curlevel
->last
;
2953 case Scomment_fence
: /* Can't happen because it's handled above. */
2955 if (commentstop
|| boundary_stop
) goto done
;
2957 /* The (from == BEGV) test was to enter the loop in the middle so
2958 that we find a 2-char comment ender even if we start in the
2959 middle of it. We don't want to do that if we're just at the
2960 beginning of the comment (think of (*) ... (*)). */
2961 found
= forw_comment (from
, from_byte
, end
,
2962 state
.incomment
, state
.comstyle
,
2963 (from
== BEGV
|| from
< state
.comstr_start
+ 3)
2964 ? 0 : prev_from_syntax
,
2965 &out_charpos
, &out_bytepos
, &state
.incomment
);
2966 from
= out_charpos
; from_byte
= out_bytepos
;
2967 /* Beware! prev_from and friends are invalid now.
2968 Luckily, the `done' doesn't use them and the INC_FROM
2969 sets them to a sane value without looking at them. */
2970 if (!found
) goto done
;
2972 state
.incomment
= 0;
2973 state
.comstyle
= 0; /* reset the comment style */
2974 if (boundary_stop
) goto done
;
2978 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2980 /* curlevel++->last ran into compiler bug on Apollo */
2981 curlevel
->last
= prev_from
;
2982 if (++curlevel
== endlevel
)
2983 curlevel
--; /* error ("Nesting too deep for parser"); */
2984 curlevel
->prev
= -1;
2985 curlevel
->last
= -1;
2986 if (targetdepth
== depth
) goto done
;
2991 if (depth
< mindepth
)
2993 if (curlevel
!= levelstart
)
2995 curlevel
->prev
= curlevel
->last
;
2996 if (targetdepth
== depth
) goto done
;
3001 state
.comstr_start
= from
- 1;
3002 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3003 curlevel
->last
= prev_from
;
3004 state
.instring
= (code
== Sstring
3005 ? (FETCH_CHAR_AS_MULTIBYTE (prev_from_byte
))
3007 if (boundary_stop
) goto done
;
3010 nofence
= state
.instring
!= ST_STRING_STYLE
;
3016 if (from
>= end
) goto done
;
3017 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
3018 /* Some compilers can't handle this inside the switch. */
3021 /* Check TEMP here so that if the char has
3022 a syntax-table property which says it is NOT
3023 a string character, it does not end the string. */
3024 if (nofence
&& c
== state
.instring
&& temp
== Sstring
)
3030 if (!nofence
) goto string_end
;
3035 startquotedinstring
:
3036 if (from
>= end
) goto endquoted
;
3042 state
.instring
= -1;
3043 curlevel
->prev
= curlevel
->last
;
3045 if (boundary_stop
) goto done
;
3049 /* FIXME: We should do something with it. */
3052 /* Ignore whitespace, punctuation, quote, endcomment. */
3058 stop
: /* Here if stopping before start of sexp. */
3059 from
= prev_from
; /* We have just fetched the char that starts it; */
3060 goto done
; /* but return the position before it. */
3065 state
.depth
= depth
;
3066 state
.mindepth
= mindepth
;
3067 state
.thislevelstart
= curlevel
->prev
;
3068 state
.prevlevelstart
3069 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
3070 state
.location
= from
;
3071 state
.levelstarts
= Qnil
;
3072 while (--curlevel
>= levelstart
)
3073 state
.levelstarts
= Fcons (make_number (curlevel
->last
),
3080 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
3081 doc
: /* Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
3082 Parsing stops at TO or when certain criteria are met;
3083 point is set to where parsing stops.
3084 If fifth arg OLDSTATE is omitted or nil,
3085 parsing assumes that FROM is the beginning of a function.
3086 Value is a list of ten elements describing final state of parsing:
3088 1. character address of start of innermost containing list; nil if none.
3089 2. character address of start of last complete sexp terminated.
3090 3. non-nil if inside a string.
3091 (it is the character that will terminate the string,
3092 or t if the string should be terminated by a generic string delimiter.)
3093 4. nil if outside a comment, t if inside a non-nestable comment,
3094 else an integer (the current comment nesting).
3095 5. t if following a quote character.
3096 6. the minimum paren-depth encountered during this scan.
3097 7. t if in a comment of style b; symbol `syntax-table' if the comment
3098 should be terminated by a generic comment delimiter.
3099 8. character address of start of comment or string; nil if not in one.
3100 9. Intermediate data for continuation of parsing (subject to change).
3101 If third arg TARGETDEPTH is non-nil, parsing stops if the depth
3102 in parentheses becomes equal to TARGETDEPTH.
3103 Fourth arg STOPBEFORE non-nil means stop when come to
3104 any character that starts a sexp.
3105 Fifth arg OLDSTATE is a nine-element list like what this function returns.
3106 It is used to initialize the state of the parse. Elements number 1, 2, 6
3107 and 8 are ignored; you can leave off element 8 (the last) entirely.
3108 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
3109 If it is symbol `syntax-table', stop after the start of a comment or a
3110 string, or after end of a comment or a string. */)
3111 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
3112 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
3114 struct lisp_parse_state state
;
3117 if (!NILP (targetdepth
))
3119 CHECK_NUMBER (targetdepth
);
3120 target
= XINT (targetdepth
);
3123 target
= -100000; /* We won't reach this depth */
3125 validate_region (&from
, &to
);
3126 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
3128 target
, !NILP (stopbefore
), oldstate
,
3130 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
3132 SET_PT (state
.location
);
3134 return Fcons (make_number (state
.depth
),
3135 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
3136 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
3137 Fcons (state
.instring
>= 0
3138 ? (state
.instring
== ST_STRING_STYLE
3139 ? Qt
: make_number (state
.instring
)) : Qnil
,
3140 Fcons (state
.incomment
< 0 ? Qt
:
3141 (state
.incomment
== 0 ? Qnil
:
3142 make_number (state
.incomment
)),
3143 Fcons (state
.quoted
? Qt
: Qnil
,
3144 Fcons (make_number (state
.mindepth
),
3145 Fcons ((state
.comstyle
3146 ? (state
.comstyle
== ST_COMMENT_STYLE
3147 ? Qsyntax_table
: Qt
) :
3149 Fcons (((state
.incomment
3150 || (state
.instring
>= 0))
3151 ? make_number (state
.comstr_start
)
3153 Fcons (state
.levelstarts
, Qnil
))))))))));
3162 /* This has to be done here, before we call Fmake_char_table. */
3163 Qsyntax_table
= intern ("syntax-table");
3164 staticpro (&Qsyntax_table
);
3166 /* Intern this now in case it isn't already done.
3167 Setting this variable twice is harmless.
3168 But don't staticpro it here--that is done in alloc.c. */
3169 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
3171 /* Create objects which can be shared among syntax tables. */
3172 Vsyntax_code_object
= Fmake_vector (make_number (Smax
), Qnil
);
3173 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
3174 XVECTOR (Vsyntax_code_object
)->contents
[i
]
3175 = Fcons (make_number (i
), Qnil
);
3177 /* Now we are ready to set up this property, so we can
3178 create syntax tables. */
3179 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
3181 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
3183 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
3185 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
3186 for (i
= 'a'; i
<= 'z'; i
++)
3187 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3188 for (i
= 'A'; i
<= 'Z'; i
++)
3189 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3190 for (i
= '0'; i
<= '9'; i
++)
3191 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3193 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
3194 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
3196 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
3197 Fcons (make_number (Sopen
), make_number (')')));
3198 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
3199 Fcons (make_number (Sclose
), make_number ('(')));
3200 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
3201 Fcons (make_number (Sopen
), make_number (']')));
3202 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
3203 Fcons (make_number (Sclose
), make_number ('[')));
3204 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
3205 Fcons (make_number (Sopen
), make_number ('}')));
3206 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
3207 Fcons (make_number (Sclose
), make_number ('{')));
3208 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
3209 Fcons (make_number ((int) Sstring
), Qnil
));
3210 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
3211 Fcons (make_number ((int) Sescape
), Qnil
));
3213 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
3214 for (i
= 0; i
< 10; i
++)
3216 c
= "_-+*/&|<>="[i
];
3217 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3220 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
3221 for (i
= 0; i
< 12; i
++)
3223 c
= ".,;:?!#@~^'`"[i
];
3224 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3227 /* All multibyte characters have syntax `word' by default. */
3228 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
3229 char_table_set_range (Vstandard_syntax_table
, 0x80, MAX_CHAR
, temp
);
3235 Qsyntax_table_p
= intern ("syntax-table-p");
3236 staticpro (&Qsyntax_table_p
);
3238 staticpro (&Vsyntax_code_object
);
3240 Qscan_error
= intern ("scan-error");
3241 staticpro (&Qscan_error
);
3242 Fput (Qscan_error
, Qerror_conditions
,
3243 Fcons (Qscan_error
, Fcons (Qerror
, Qnil
)));
3244 Fput (Qscan_error
, Qerror_message
,
3245 build_string ("Scan error"));
3247 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
3248 doc
: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace. */);
3250 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
3251 doc
: /* Non-nil means `forward-sexp', etc., obey `syntax-table' property.
3252 Otherwise, that text property is simply ignored.
3253 See the info node `(elisp)Syntax Properties' for a description of the
3254 `syntax-table' property. */);
3256 words_include_escapes
= 0;
3257 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
3258 doc
: /* Non-nil means `forward-word', etc., should treat escape chars part of words. */);
3260 DEFVAR_BOOL ("multibyte-syntax-as-symbol", &multibyte_syntax_as_symbol
,
3261 doc
: /* Non-nil means `scan-sexps' treats all multibyte characters as symbol. */);
3262 multibyte_syntax_as_symbol
= 0;
3264 DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
3265 &open_paren_in_column_0_is_defun_start
,
3266 doc
: /* *Non-nil means an open paren in column 0 denotes the start of a defun. */);
3267 open_paren_in_column_0_is_defun_start
= 1;
3270 DEFVAR_LISP ("find-word-boundary-function-table",
3271 &Vfind_word_boundary_function_table
,
3273 Char table of functions to search for the word boundary.
3274 Each function is called with two arguments; POS and LIMIT.
3275 POS and LIMIT are character positions in the current buffer.
3277 If POS is less than LIMIT, POS is at the first character of a word,
3278 and the return value of a function is a position after the last
3279 character of that word.
3281 If POS is not less than LIMIT, POS is at the last character of a word,
3282 and the return value of a function is a position at the first
3283 character of that word.
3285 In both cases, LIMIT bounds the search. */);
3286 Vfind_word_boundary_function_table
= Fmake_char_table (Qnil
, Qnil
);
3288 defsubr (&Ssyntax_table_p
);
3289 defsubr (&Ssyntax_table
);
3290 defsubr (&Sstandard_syntax_table
);
3291 defsubr (&Scopy_syntax_table
);
3292 defsubr (&Sset_syntax_table
);
3293 defsubr (&Schar_syntax
);
3294 defsubr (&Smatching_paren
);
3295 defsubr (&Sstring_to_syntax
);
3296 defsubr (&Smodify_syntax_entry
);
3297 defsubr (&Sinternal_describe_syntax_value
);
3299 defsubr (&Sforward_word
);
3301 defsubr (&Sskip_chars_forward
);
3302 defsubr (&Sskip_chars_backward
);
3303 defsubr (&Sskip_syntax_forward
);
3304 defsubr (&Sskip_syntax_backward
);
3306 defsubr (&Sforward_comment
);
3307 defsubr (&Sscan_lists
);
3308 defsubr (&Sscan_sexps
);
3309 defsubr (&Sbackward_prefix_chars
);
3310 defsubr (&Sparse_partial_sexp
);