1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 1987, 1993, 1994, 1995, 1997, 1998, 1999, 2002,
3 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
28 #include "character.h"
32 /* Make syntax table lookup grant data in gl_state. */
33 #define SYNTAX_ENTRY_VIA_PROPERTY
36 #include "intervals.h"
38 /* We use these constants in place for comment-style and
39 string-ender-char to distinguish comments/strings started by
40 comment_fence and string_fence codes. */
42 #define ST_COMMENT_STYLE (256 + 1)
43 #define ST_STRING_STYLE (256 + 2)
46 Lisp_Object Qsyntax_table_p
, Qsyntax_table
, Qscan_error
;
48 int words_include_escapes
;
49 int parse_sexp_lookup_properties
;
51 /* Nonzero means `scan-sexps' treat all multibyte characters as symbol. */
52 int multibyte_syntax_as_symbol
;
54 /* Used as a temporary in SYNTAX_ENTRY and other macros in syntax.h,
55 if not compiled with GCC. No need to mark it, since it is used
56 only very temporarily. */
57 Lisp_Object syntax_temp
;
59 /* Non-zero means an open parenthesis in column 0 is always considered
60 to be the start of a defun. Zero means an open parenthesis in
61 column 0 has no special meaning. */
63 int open_paren_in_column_0_is_defun_start
;
65 /* This is the internal form of the parse state used in parse-partial-sexp. */
67 struct lisp_parse_state
69 int depth
; /* Depth at end of parsing. */
70 int instring
; /* -1 if not within string, else desired terminator. */
71 int incomment
; /* -1 if in unnestable comment else comment nesting */
72 int comstyle
; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
73 int quoted
; /* Nonzero if just after an escape char at end of parsing */
74 int thislevelstart
; /* Char number of most recent start-of-expression at current level */
75 int prevlevelstart
; /* Char number of start of containing expression */
76 int location
; /* Char number at which parsing stopped. */
77 int mindepth
; /* Minimum depth seen while scanning. */
78 int comstr_start
; /* Position just after last comment/string starter. */
79 Lisp_Object levelstarts
; /* Char numbers of starts-of-expression
80 of levels (starting from outermost). */
83 /* These variables are a cache for finding the start of a defun.
84 find_start_pos is the place for which the defun start was found.
85 find_start_value is the defun start position found for it.
86 find_start_value_byte is the corresponding byte position.
87 find_start_buffer is the buffer it was found in.
88 find_start_begv is the BEGV value when it was found.
89 find_start_modiff is the value of MODIFF when it was found. */
91 static int find_start_pos
;
92 static int find_start_value
;
93 static int find_start_value_byte
;
94 static struct buffer
*find_start_buffer
;
95 static int find_start_begv
;
96 static int find_start_modiff
;
99 static int find_defun_start
P_ ((int, int));
100 static int back_comment
P_ ((EMACS_INT
, EMACS_INT
, EMACS_INT
, int, int,
101 EMACS_INT
*, EMACS_INT
*));
102 static int char_quoted
P_ ((int, int));
103 static Lisp_Object skip_chars
P_ ((int, Lisp_Object
, Lisp_Object
, int));
104 static Lisp_Object skip_syntaxes
P_ ((int, Lisp_Object
, Lisp_Object
));
105 static Lisp_Object scan_lists
P_ ((EMACS_INT
, EMACS_INT
, EMACS_INT
, int));
106 static void scan_sexps_forward
P_ ((struct lisp_parse_state
*,
108 int, Lisp_Object
, int));
109 static int in_classes
P_ ((int, Lisp_Object
));
112 struct gl_state_s gl_state
; /* Global state of syntax parser. */
114 INTERVAL
interval_of ();
115 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
116 to scan to property-change. */
118 /* Update gl_state to an appropriate interval which contains CHARPOS. The
119 sign of COUNT give the relative position of CHARPOS wrt the previously
120 valid interval. If INIT, only [be]_property fields of gl_state are
121 valid at start, the rest is filled basing on OBJECT.
123 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
124 direction than the intervals - or in an interval. We update the
125 current syntax-table basing on the property of this interval, and
126 update the interval to start further than CHARPOS - or be
127 NULL_INTERVAL. We also update lim_property to be the next value of
128 charpos to call this subroutine again - or be before/after the
129 start/end of OBJECT. */
132 update_syntax_table (charpos
, count
, init
, object
)
133 int charpos
, count
, init
;
136 Lisp_Object tmp_table
;
137 int cnt
= 0, invalidate
= 1;
142 gl_state
.old_prop
= Qnil
;
143 gl_state
.start
= gl_state
.b_property
;
144 gl_state
.stop
= gl_state
.e_property
;
145 i
= interval_of (charpos
, object
);
146 gl_state
.backward_i
= gl_state
.forward_i
= i
;
148 if (NULL_INTERVAL_P (i
))
150 /* interval_of updates only ->position of the return value, so
151 update the parents manually to speed up update_interval. */
152 while (!NULL_PARENT (i
))
154 if (AM_RIGHT_CHILD (i
))
155 INTERVAL_PARENT (i
)->position
= i
->position
156 - LEFT_TOTAL_LENGTH (i
) + TOTAL_LENGTH (i
) /* right end */
157 - TOTAL_LENGTH (INTERVAL_PARENT (i
))
158 + LEFT_TOTAL_LENGTH (INTERVAL_PARENT (i
));
160 INTERVAL_PARENT (i
)->position
= i
->position
- LEFT_TOTAL_LENGTH (i
)
162 i
= INTERVAL_PARENT (i
);
164 i
= gl_state
.forward_i
;
165 gl_state
.b_property
= i
->position
- gl_state
.offset
;
166 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
169 i
= count
> 0 ? gl_state
.forward_i
: gl_state
.backward_i
;
171 /* We are guaranteed to be called with CHARPOS either in i,
173 if (NULL_INTERVAL_P (i
))
174 error ("Error in syntax_table logic for to-the-end intervals");
175 else if (charpos
< i
->position
) /* Move left. */
178 error ("Error in syntax_table logic for intervals <-");
179 /* Update the interval. */
180 i
= update_interval (i
, charpos
);
181 if (INTERVAL_LAST_POS (i
) != gl_state
.b_property
)
184 gl_state
.forward_i
= i
;
185 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
188 else if (charpos
>= INTERVAL_LAST_POS (i
)) /* Move right. */
191 error ("Error in syntax_table logic for intervals ->");
192 /* Update the interval. */
193 i
= update_interval (i
, charpos
);
194 if (i
->position
!= gl_state
.e_property
)
197 gl_state
.backward_i
= i
;
198 gl_state
.b_property
= i
->position
- gl_state
.offset
;
203 tmp_table
= textget (i
->plist
, Qsyntax_table
);
206 invalidate
= !EQ (tmp_table
, gl_state
.old_prop
); /* Need to invalidate? */
208 if (invalidate
) /* Did not get to adjacent interval. */
209 { /* with the same table => */
210 /* invalidate the old range. */
213 gl_state
.backward_i
= i
;
214 gl_state
.b_property
= i
->position
- gl_state
.offset
;
218 gl_state
.forward_i
= i
;
219 gl_state
.e_property
= INTERVAL_LAST_POS (i
) - gl_state
.offset
;
223 if (!EQ (tmp_table
, gl_state
.old_prop
))
225 gl_state
.current_syntax_table
= tmp_table
;
226 gl_state
.old_prop
= tmp_table
;
227 if (EQ (Fsyntax_table_p (tmp_table
), Qt
))
229 gl_state
.use_global
= 0;
231 else if (CONSP (tmp_table
))
233 gl_state
.use_global
= 1;
234 gl_state
.global_code
= tmp_table
;
238 gl_state
.use_global
= 0;
239 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
243 while (!NULL_INTERVAL_P (i
))
245 if (cnt
&& !EQ (tmp_table
, textget (i
->plist
, Qsyntax_table
)))
249 gl_state
.e_property
= i
->position
- gl_state
.offset
;
250 gl_state
.forward_i
= i
;
255 = i
->position
+ LENGTH (i
) - gl_state
.offset
;
256 gl_state
.backward_i
= i
;
260 else if (cnt
== INTERVALS_AT_ONCE
)
265 = i
->position
+ LENGTH (i
) - gl_state
.offset
266 /* e_property at EOB is not set to ZV but to ZV+1, so that
267 we can do INC(from);UPDATE_SYNTAX_TABLE_FORWARD without
268 having to check eob between the two. */
269 + (NULL_INTERVAL_P (next_interval (i
)) ? 1 : 0);
270 gl_state
.forward_i
= i
;
274 gl_state
.b_property
= i
->position
- gl_state
.offset
;
275 gl_state
.backward_i
= i
;
280 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
282 eassert (NULL_INTERVAL_P (i
)); /* This property goes to the end. */
284 gl_state
.e_property
= gl_state
.stop
;
286 gl_state
.b_property
= gl_state
.start
;
289 /* Returns TRUE if char at CHARPOS is quoted.
290 Global syntax-table data should be set up already to be good at CHARPOS
291 or after. On return global syntax data is good for lookup at CHARPOS. */
294 char_quoted (charpos
, bytepos
)
295 register int charpos
, bytepos
;
297 register enum syntaxcode code
;
298 register int beg
= BEGV
;
299 register int quoted
= 0;
302 DEC_BOTH (charpos
, bytepos
);
304 while (charpos
>= beg
)
308 UPDATE_SYNTAX_TABLE_BACKWARD (charpos
);
309 c
= FETCH_CHAR_AS_MULTIBYTE (bytepos
);
311 if (! (code
== Scharquote
|| code
== Sescape
))
314 DEC_BOTH (charpos
, bytepos
);
318 UPDATE_SYNTAX_TABLE (orig
);
322 /* Return the bytepos one character after BYTEPOS.
323 We assume that BYTEPOS is not at the end of the buffer. */
326 inc_bytepos (bytepos
)
329 if (NILP (current_buffer
->enable_multibyte_characters
))
336 /* Return the bytepos one character before BYTEPOS.
337 We assume that BYTEPOS is not at the start of the buffer. */
340 dec_bytepos (bytepos
)
343 if (NILP (current_buffer
->enable_multibyte_characters
))
350 /* Return a defun-start position before before POS and not too far before.
351 It should be the last one before POS, or nearly the last.
353 When open_paren_in_column_0_is_defun_start is nonzero,
354 only the beginning of the buffer is treated as a defun-start.
356 We record the information about where the scan started
357 and what its result was, so that another call in the same area
358 can return the same value very quickly.
360 There is no promise at which position the global syntax data is
361 valid on return from the subroutine, so the caller should explicitly
362 update the global data. */
365 find_defun_start (pos
, pos_byte
)
368 int opoint
= PT
, opoint_byte
= PT_BYTE
;
370 if (!open_paren_in_column_0_is_defun_start
)
372 find_start_value_byte
= BEGV_BYTE
;
376 /* Use previous finding, if it's valid and applies to this inquiry. */
377 if (current_buffer
== find_start_buffer
378 /* Reuse the defun-start even if POS is a little farther on.
379 POS might be in the next defun, but that's ok.
380 Our value may not be the best possible, but will still be usable. */
381 && pos
<= find_start_pos
+ 1000
382 && pos
>= find_start_value
383 && BEGV
== find_start_begv
384 && MODIFF
== find_start_modiff
)
385 return find_start_value
;
387 /* Back up to start of line. */
388 scan_newline (pos
, pos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
390 /* We optimize syntax-table lookup for rare updates. Thus we accept
391 only those `^\s(' which are good in global _and_ text-property
393 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
394 gl_state
.use_global
= 0;
399 /* Open-paren at start of line means we may have found our
401 c
= FETCH_CHAR_AS_MULTIBYTE (PT_BYTE
);
402 if (SYNTAX (c
) == Sopen
)
404 SETUP_SYNTAX_TABLE (PT
+ 1, -1); /* Try again... */
405 c
= FETCH_CHAR_AS_MULTIBYTE (PT_BYTE
);
406 if (SYNTAX (c
) == Sopen
)
408 /* Now fallback to the default value. */
409 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
410 gl_state
.use_global
= 0;
412 /* Move to beg of previous line. */
413 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -2, 1);
416 /* Record what we found, for the next try. */
417 find_start_value
= PT
;
418 find_start_value_byte
= PT_BYTE
;
419 find_start_buffer
= current_buffer
;
420 find_start_modiff
= MODIFF
;
421 find_start_begv
= BEGV
;
422 find_start_pos
= pos
;
424 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
426 return find_start_value
;
429 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
432 prev_char_comend_first (pos
, pos_byte
)
437 DEC_BOTH (pos
, pos_byte
);
438 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
439 c
= FETCH_CHAR (pos_byte
);
440 val
= SYNTAX_COMEND_FIRST (c
);
441 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
445 /* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
448 * prev_char_comstart_first (pos, pos_byte)
453 * DEC_BOTH (pos, pos_byte);
454 * UPDATE_SYNTAX_TABLE_BACKWARD (pos);
455 * c = FETCH_CHAR (pos_byte);
456 * val = SYNTAX_COMSTART_FIRST (c);
457 * UPDATE_SYNTAX_TABLE_FORWARD (pos + 1);
461 /* Checks whether charpos FROM is at the end of a comment.
462 FROM_BYTE is the bytepos corresponding to FROM.
463 Do not move back before STOP.
465 Return a positive value if we find a comment ending at FROM/FROM_BYTE;
468 If successful, store the charpos of the comment's beginning
469 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
471 Global syntax data remains valid for backward search starting at
472 the returned value (or at FROM, if the search was not successful). */
475 back_comment (from
, from_byte
, stop
, comnested
, comstyle
, charpos_ptr
, bytepos_ptr
)
476 EMACS_INT from
, from_byte
, stop
;
477 int comnested
, comstyle
;
478 EMACS_INT
*charpos_ptr
, *bytepos_ptr
;
480 /* Look back, counting the parity of string-quotes,
481 and recording the comment-starters seen.
482 When we reach a safe place, assume that's not in a string;
483 then step the main scan to the earliest comment-starter seen
484 an even number of string quotes away from the safe place.
486 OFROM[I] is position of the earliest comment-starter seen
487 which is I+2X quotes from the comment-end.
488 PARITY is current parity of quotes from the comment end. */
489 int string_style
= -1; /* Presumed outside of any string. */
490 int string_lossage
= 0;
491 /* Not a real lossage: indicates that we have passed a matching comment
492 starter plus a non-matching comment-ender, meaning that any matching
493 comment-starter we might see later could be a false positive (hidden
494 inside another comment).
495 Test case: { a (* b } c (* d *) */
496 int comment_lossage
= 0;
497 int comment_end
= from
;
498 int comment_end_byte
= from_byte
;
499 int comstart_pos
= 0;
501 /* Place where the containing defun starts,
502 or 0 if we didn't come across it yet. */
504 int defun_start_byte
= 0;
505 register enum syntaxcode code
;
506 int nesting
= 1; /* current comment nesting */
510 /* FIXME: A }} comment-ender style leads to incorrect behavior
511 in the case of {{ c }}} because we ignore the last two chars which are
512 assumed to be comment-enders although they aren't. */
514 /* At beginning of range to scan, we're outside of strings;
515 that determines quote parity to the comment-end. */
518 int temp_byte
, prev_syntax
;
519 int com2start
, com2end
;
521 /* Move back and examine a character. */
522 DEC_BOTH (from
, from_byte
);
523 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
525 prev_syntax
= syntax
;
526 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
527 syntax
= SYNTAX_WITH_FLAGS (c
);
530 /* Check for 2-char comment markers. */
531 com2start
= (SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
532 && SYNTAX_FLAGS_COMSTART_SECOND (prev_syntax
)
533 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax
)
534 && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
)
535 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
);
536 com2end
= (SYNTAX_FLAGS_COMEND_FIRST (syntax
)
537 && SYNTAX_FLAGS_COMEND_SECOND (prev_syntax
));
539 /* Nasty cases with overlapping 2-char comment markers:
540 - snmp-mode: -- c -- foo -- c --
548 /* If a 2-char comment sequence partly overlaps with another,
549 we don't try to be clever. */
550 if (from
> stop
&& (com2end
|| com2start
))
552 int next
= from
, next_byte
= from_byte
, next_c
, next_syntax
;
553 DEC_BOTH (next
, next_byte
);
554 UPDATE_SYNTAX_TABLE_BACKWARD (next
);
555 next_c
= FETCH_CHAR_AS_MULTIBYTE (next_byte
);
556 next_syntax
= SYNTAX_WITH_FLAGS (next_c
);
557 if (((com2start
|| comnested
)
558 && SYNTAX_FLAGS_COMEND_SECOND (syntax
)
559 && SYNTAX_FLAGS_COMEND_FIRST (next_syntax
))
560 || ((com2end
|| comnested
)
561 && SYNTAX_FLAGS_COMSTART_SECOND (syntax
)
562 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
563 && SYNTAX_FLAGS_COMSTART_FIRST (next_syntax
)))
565 /* UPDATE_SYNTAX_TABLE_FORWARD (next + 1); */
568 if (com2start
&& comstart_pos
== 0)
569 /* We're looking at a comment starter. But it might be a comment
570 ender as well (see snmp-mode). The first time we see one, we
571 need to consider it as a comment starter,
572 and the subsequent times as a comment ender. */
575 /* Turn a 2-char comment sequences into the appropriate syntax. */
580 /* Ignore comment starters of a different style. */
581 else if (code
== Scomment
582 && (comstyle
!= SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
583 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
) != comnested
))
586 /* Ignore escaped characters, except comment-enders. */
587 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
594 c
= (code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
);
596 /* Track parity of quotes. */
597 if (string_style
== -1)
598 /* Entering a string. */
600 else if (string_style
== c
)
601 /* Leaving the string. */
604 /* If we have two kinds of string delimiters.
605 There's no way to grok this scanning backwards. */
610 /* We've already checked that it is the relevant comstyle. */
611 if (string_style
!= -1 || comment_lossage
|| string_lossage
)
612 /* There are odd string quotes involved, so let's be careful.
613 Test case in Pascal: " { " a { " } */
618 /* Record best comment-starter so far. */
620 comstart_byte
= from_byte
;
622 else if (--nesting
<= 0)
623 /* nested comments have to be balanced, so we don't need to
624 keep looking for earlier ones. We use here the same (slightly
625 incorrect) reasoning as below: since it is followed by uniform
626 paired string quotes, this comment-start has to be outside of
627 strings, else the comment-end itself would be inside a string. */
632 if (SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == comstyle
633 && ((com2end
&& SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
))
634 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
)
635 /* This is the same style of comment ender as ours. */
640 /* Anything before that can't count because it would match
641 this comment-ender rather than ours. */
642 from
= stop
; /* Break out of the loop. */
644 else if (comstart_pos
!= 0 || c
!= '\n')
645 /* We're mixing comment styles here, so we'd better be careful.
646 The (comstart_pos != 0 || c != '\n') check is not quite correct
647 (we should just always set comment_lossage), but removing it
648 would imply that any multiline comment in C would go through
649 lossage, which seems overkill.
650 The failure should only happen in the rare cases such as
656 /* Assume a defun-start point is outside of strings. */
657 if (open_paren_in_column_0_is_defun_start
659 || (temp_byte
= dec_bytepos (from_byte
),
660 FETCH_CHAR (temp_byte
) == '\n')))
663 defun_start_byte
= from_byte
;
664 from
= stop
; /* Break out of the loop. */
673 if (comstart_pos
== 0)
676 from_byte
= comment_end_byte
;
677 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
679 /* If comstart_pos is set and we get here (ie. didn't jump to `lossage'
680 or `done'), then we've found the beginning of the non-nested comment. */
681 else if (1) /* !comnested */
684 from_byte
= comstart_byte
;
685 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
689 struct lisp_parse_state state
;
691 /* We had two kinds of string delimiters mixed up
692 together. Decode this going forwards.
693 Scan fwd from a known safe place (beginning-of-defun)
694 to the one in question; this records where we
695 last passed a comment starter. */
696 /* If we did not already find the defun start, find it now. */
697 if (defun_start
== 0)
699 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
700 defun_start_byte
= find_start_value_byte
;
704 scan_sexps_forward (&state
,
705 defun_start
, defun_start_byte
,
706 comment_end
, -10000, 0, Qnil
, 0);
707 defun_start
= comment_end
;
708 if (state
.incomment
== (comnested
? 1 : -1)
709 && state
.comstyle
== comstyle
)
710 from
= state
.comstr_start
;
715 /* If comment_end is inside some other comment, maybe ours
716 is nested, so we need to try again from within the
717 surrounding comment. Example: { a (* " *) */
719 /* FIXME: We should advance by one or two chars. */
720 defun_start
= state
.comstr_start
+ 2;
721 defun_start_byte
= CHAR_TO_BYTE (defun_start
);
724 } while (defun_start
< comment_end
);
726 from_byte
= CHAR_TO_BYTE (from
);
727 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
732 *bytepos_ptr
= from_byte
;
734 return (from
== comment_end
) ? -1 : from
;
737 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
738 doc
: /* Return t if OBJECT is a syntax table.
739 Currently, any char-table counts as a syntax table. */)
743 if (CHAR_TABLE_P (object
)
744 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
750 check_syntax_table (obj
)
753 CHECK_TYPE (CHAR_TABLE_P (obj
) && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
),
754 Qsyntax_table_p
, obj
);
757 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
758 doc
: /* Return the current syntax table.
759 This is the one specified by the current buffer. */)
762 return current_buffer
->syntax_table
;
765 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
766 Sstandard_syntax_table
, 0, 0, 0,
767 doc
: /* Return the standard syntax table.
768 This is the one used for new buffers. */)
771 return Vstandard_syntax_table
;
774 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
775 doc
: /* Construct a new syntax table and return it.
776 It is a copy of the TABLE, which defaults to the standard syntax table. */)
783 check_syntax_table (table
);
785 table
= Vstandard_syntax_table
;
787 copy
= Fcopy_sequence (table
);
789 /* Only the standard syntax table should have a default element.
790 Other syntax tables should inherit from parents instead. */
791 XCHAR_TABLE (copy
)->defalt
= Qnil
;
793 /* Copied syntax tables should all have parents.
794 If we copied one with no parent, such as the standard syntax table,
795 use the standard syntax table as the copy's parent. */
796 if (NILP (XCHAR_TABLE (copy
)->parent
))
797 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
801 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
802 doc
: /* Select a new syntax table for the current buffer.
803 One argument, a syntax table. */)
808 check_syntax_table (table
);
809 current_buffer
->syntax_table
= table
;
810 /* Indicate that this buffer now has a specified syntax table. */
811 idx
= PER_BUFFER_VAR_IDX (syntax_table
);
812 SET_PER_BUFFER_VALUE_P (current_buffer
, idx
, 1);
816 /* Convert a letter which signifies a syntax code
817 into the code it signifies.
818 This is used by modify-syntax-entry, and other things. */
820 unsigned char syntax_spec_code
[0400] =
821 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
822 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
823 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
824 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
825 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
826 (char) Smath
, 0377, 0377, (char) Squote
,
827 (char) Sopen
, (char) Sclose
, 0377, 0377,
828 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
829 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
830 0377, 0377, 0377, 0377,
831 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
832 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
833 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
834 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
835 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
836 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
837 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
838 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
839 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
842 /* Indexed by syntax code, give the letter that describes it. */
844 char syntax_code_spec
[16] =
846 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
850 /* Indexed by syntax code, give the object (cons of syntax code and
851 nil) to be stored in syntax table. Since these objects can be
852 shared among syntax tables, we generate them in advance. By
853 sharing objects, the function `describe-syntax' can give a more
855 static Lisp_Object Vsyntax_code_object
;
858 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
859 doc
: /* Return the syntax code of CHARACTER, described by a character.
860 For example, if CHARACTER is a word constituent,
861 the character `w' is returned.
862 The characters that correspond to various syntax codes
863 are listed in the documentation of `modify-syntax-entry'. */)
865 Lisp_Object character
;
868 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
870 gl_state
.use_global
= 0;
871 CHECK_NUMBER (character
);
872 char_int
= XINT (character
);
873 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
876 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
877 doc
: /* Return the matching parenthesis of CHARACTER, or nil if none. */)
879 Lisp_Object character
;
882 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
883 gl_state
.use_global
= 0;
884 CHECK_NUMBER (character
);
885 char_int
= XINT (character
);
886 code
= SYNTAX (char_int
);
887 if (code
== Sopen
|| code
== Sclose
)
888 return SYNTAX_MATCH (char_int
);
892 DEFUN ("string-to-syntax", Fstring_to_syntax
, Sstring_to_syntax
, 1, 1, 0,
893 doc
: /* Convert a syntax specification STRING into syntax cell form.
894 STRING should be a string as it is allowed as argument of
895 `modify-syntax-entry'. Value is the equivalent cons cell
896 (CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'
901 register const unsigned char *p
;
902 register enum syntaxcode code
;
906 CHECK_STRING (string
);
909 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
910 if (((int) code
& 0377) == 0377)
911 error ("Invalid syntax description letter: %c", p
[-1]);
913 if (code
== Sinherit
)
919 int character
= (STRING_CHAR_AND_LENGTH
920 (p
, SBYTES (string
) - 1, len
));
921 XSETINT (match
, character
);
922 if (XFASTINT (match
) == ' ')
962 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
963 return XVECTOR (Vsyntax_code_object
)->contents
[val
];
965 /* Since we can't use a shared object, let's make a new one. */
966 return Fcons (make_number (val
), match
);
969 /* I really don't know why this is interactive
970 help-form should at least be made useful whilst reading the second arg. */
971 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
972 "cSet syntax for character: \nsSet syntax for %s to: ",
973 doc
: /* Set syntax for character CHAR according to string NEWENTRY.
974 The syntax is changed only for table SYNTAX-TABLE, which defaults to
975 the current buffer's syntax table.
976 CHAR may be a cons (MIN . MAX), in which case, syntaxes of all characters
977 in the range MIN and MAX are changed.
978 The first character of NEWENTRY should be one of the following:
979 Space or - whitespace syntax. w word constituent.
980 _ symbol constituent. . punctuation.
981 ( open-parenthesis. ) close-parenthesis.
982 " string quote. \\ escape.
983 $ paired delimiter. ' expression quote or prefix operator.
984 < comment starter. > comment ender.
985 / character-quote. @ inherit from `standard-syntax-table'.
986 | generic string fence. ! generic comment fence.
988 Only single-character comment start and end sequences are represented thus.
989 Two-character sequences are represented as described below.
990 The second character of NEWENTRY is the matching parenthesis,
991 used only if the first character is `(' or `)'.
992 Any additional characters are flags.
993 Defined flags are the characters 1, 2, 3, 4, b, p, and n.
994 1 means CHAR is the start of a two-char comment start sequence.
995 2 means CHAR is the second character of such a sequence.
996 3 means CHAR is the start of a two-char comment end sequence.
997 4 means CHAR is the second character of such a sequence.
999 There can be up to two orthogonal comment sequences. This is to support
1000 language modes such as C++. By default, all comment sequences are of style
1001 a, but you can set the comment sequence style to b (on the second character
1002 of a comment-start, or the first character of a comment-end sequence) using
1004 b means CHAR is part of comment sequence b.
1005 n means CHAR is part of a nestable comment sequence.
1007 p means CHAR is a prefix character for `backward-prefix-chars';
1008 such characters are treated as whitespace when they occur
1009 between expressions.
1010 usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE) */)
1011 (c
, newentry
, syntax_table
)
1012 Lisp_Object c
, newentry
, syntax_table
;
1016 CHECK_CHARACTER_CAR (c
);
1017 CHECK_CHARACTER_CDR (c
);
1020 CHECK_CHARACTER (c
);
1022 if (NILP (syntax_table
))
1023 syntax_table
= current_buffer
->syntax_table
;
1025 check_syntax_table (syntax_table
);
1027 newentry
= Fstring_to_syntax (newentry
);
1029 SET_RAW_SYNTAX_ENTRY_RANGE (syntax_table
, c
, newentry
);
1031 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), newentry
);
1033 /* We clear the regexp cache, since character classes can now have
1034 different values from those in the compiled regexps.*/
1035 clear_regexp_cache ();
1040 /* Dump syntax table to buffer in human-readable format */
1042 DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value
,
1043 Sinternal_describe_syntax_value
, 1, 1, 0,
1044 doc
: /* Insert a description of the internal syntax description SYNTAX at point. */)
1048 register enum syntaxcode code
;
1049 char desc
, start1
, start2
, end1
, end2
, prefix
, comstyle
, comnested
;
1051 Lisp_Object first
, match_lisp
, value
= syntax
;
1055 insert_string ("default");
1059 if (CHAR_TABLE_P (value
))
1061 insert_string ("deeper char-table ...");
1067 insert_string ("invalid");
1071 first
= XCAR (value
);
1072 match_lisp
= XCDR (value
);
1074 if (!INTEGERP (first
) || !(NILP (match_lisp
) || INTEGERP (match_lisp
)))
1076 insert_string ("invalid");
1080 code
= (enum syntaxcode
) (XINT (first
) & 0377);
1081 start1
= (XINT (first
) >> 16) & 1;
1082 start2
= (XINT (first
) >> 17) & 1;
1083 end1
= (XINT (first
) >> 18) & 1;
1084 end2
= (XINT (first
) >> 19) & 1;
1085 prefix
= (XINT (first
) >> 20) & 1;
1086 comstyle
= (XINT (first
) >> 21) & 1;
1087 comnested
= (XINT (first
) >> 22) & 1;
1089 if ((int) code
< 0 || (int) code
>= (int) Smax
)
1091 insert_string ("invalid");
1094 desc
= syntax_code_spec
[(int) code
];
1096 str
[0] = desc
, str
[1] = 0;
1099 if (NILP (match_lisp
))
1102 insert_char (XINT (match_lisp
));
1121 insert_string ("\twhich means: ");
1123 switch (SWITCH_ENUM_CAST (code
))
1126 insert_string ("whitespace"); break;
1128 insert_string ("punctuation"); break;
1130 insert_string ("word"); break;
1132 insert_string ("symbol"); break;
1134 insert_string ("open"); break;
1136 insert_string ("close"); break;
1138 insert_string ("prefix"); break;
1140 insert_string ("string"); break;
1142 insert_string ("math"); break;
1144 insert_string ("escape"); break;
1146 insert_string ("charquote"); break;
1148 insert_string ("comment"); break;
1150 insert_string ("endcomment"); break;
1152 insert_string ("inherit"); break;
1153 case Scomment_fence
:
1154 insert_string ("comment fence"); break;
1156 insert_string ("string fence"); break;
1158 insert_string ("invalid");
1162 if (!NILP (match_lisp
))
1164 insert_string (", matches ");
1165 insert_char (XINT (match_lisp
));
1169 insert_string (",\n\t is the first character of a comment-start sequence");
1171 insert_string (",\n\t is the second character of a comment-start sequence");
1174 insert_string (",\n\t is the first character of a comment-end sequence");
1176 insert_string (",\n\t is the second character of a comment-end sequence");
1178 insert_string (" (comment style b)");
1180 insert_string (" (nestable)");
1183 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
1188 int parse_sexp_ignore_comments
;
1190 /* Char-table of functions that find the next or previous word
1192 Lisp_Object Vfind_word_boundary_function_table
;
1194 /* Return the position across COUNT words from FROM.
1195 If that many words cannot be found before the end of the buffer, return 0.
1196 COUNT negative means scan backward and stop at word beginning. */
1199 scan_words (from
, count
)
1200 register int from
, count
;
1202 register int beg
= BEGV
;
1203 register int end
= ZV
;
1204 register int from_byte
= CHAR_TO_BYTE (from
);
1205 register enum syntaxcode code
;
1207 Lisp_Object func
, script
, pos
;
1212 SETUP_SYNTAX_TABLE (from
, count
);
1223 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1224 ch0
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1225 code
= SYNTAX (ch0
);
1226 INC_BOTH (from
, from_byte
);
1227 if (words_include_escapes
1228 && (code
== Sescape
|| code
== Scharquote
))
1233 /* Now CH0 is a character which begins a word and FROM is the
1234 position of the next character. */
1235 func
= CHAR_TABLE_REF (Vfind_word_boundary_function_table
, ch0
);
1236 if (! NILP (Ffboundp (func
)))
1238 pos
= call2 (func
, make_number (from
- 1), make_number (end
));
1239 if (INTEGERP (pos
) && XINT (pos
) > from
)
1242 from_byte
= CHAR_TO_BYTE (from
);
1247 script
= CHAR_TABLE_REF (Vchar_script_table
, ch0
);
1250 if (from
== end
) break;
1251 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1252 ch1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1253 code
= SYNTAX (ch1
);
1255 && (! words_include_escapes
1256 || (code
!= Sescape
&& code
!= Scharquote
)))
1257 || ! EQ (CHAR_TABLE_REF (Vchar_script_table
, ch1
), script
))
1259 INC_BOTH (from
, from_byte
);
1274 DEC_BOTH (from
, from_byte
);
1275 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1276 ch1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1277 code
= SYNTAX (ch1
);
1278 if (words_include_escapes
1279 && (code
== Sescape
|| code
== Scharquote
))
1284 /* Now CH1 is a character which ends a word and FROM is the
1286 func
= CHAR_TABLE_REF (Vfind_word_boundary_function_table
, ch1
);
1287 if (! NILP (Ffboundp (func
)))
1289 pos
= call2 (func
, make_number (from
), make_number (beg
));
1290 if (INTEGERP (pos
) && XINT (pos
) < from
)
1293 from_byte
= CHAR_TO_BYTE (from
);
1298 script
= CHAR_TABLE_REF (Vchar_script_table
, ch1
);
1305 temp_byte
= dec_bytepos (from_byte
);
1306 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1307 ch0
= FETCH_CHAR_AS_MULTIBYTE (temp_byte
);
1308 code
= SYNTAX (ch0
);
1310 && (! words_include_escapes
1311 || (code
!= Sescape
&& code
!= Scharquote
)))
1312 || ! EQ (CHAR_TABLE_REF (Vchar_script_table
, ch0
), script
))
1314 DEC_BOTH (from
, from_byte
);
1326 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 0, 1, "p",
1327 doc
: /* Move point forward ARG words (backward if ARG is negative).
1329 If an edge of the buffer or a field boundary is reached, point is left there
1330 and the function returns nil. Field boundaries are not noticed if
1331 `inhibit-field-text-motion' is non-nil. */)
1339 XSETFASTINT (arg
, 1);
1343 val
= orig_val
= scan_words (PT
, XINT (arg
));
1345 val
= XINT (arg
) > 0 ? ZV
: BEGV
;
1347 /* Avoid jumping out of an input field. */
1348 tmp
= Fconstrain_to_field (make_number (val
), make_number (PT
),
1350 val
= XFASTINT (tmp
);
1353 return val
== orig_val
? Qt
: Qnil
;
1356 Lisp_Object
skip_chars ();
1358 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1359 doc
: /* Move point forward, stopping before a char not in STRING, or at pos LIM.
1360 STRING is like the inside of a `[...]' in a regular expression
1361 except that `]' is never special and `\\' quotes `^', `-' or `\\'
1362 (but not as the end of a range; quoting is never needed there).
1363 Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
1364 With arg "^a-zA-Z", skips nonletters stopping before first letter.
1365 Char classes, e.g. `[:alpha:]', are supported.
1367 Returns the distance traveled, either zero or positive. */)
1369 Lisp_Object string
, lim
;
1371 return skip_chars (1, string
, lim
, 1);
1374 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1375 doc
: /* Move point backward, stopping after a char not in STRING, or at pos LIM.
1376 See `skip-chars-forward' for details.
1377 Returns the distance traveled, either zero or negative. */)
1379 Lisp_Object string
, lim
;
1381 return skip_chars (0, string
, lim
, 1);
1384 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1385 doc
: /* Move point forward across chars in specified syntax classes.
1386 SYNTAX is a string of syntax code characters.
1387 Stop before a char whose syntax is not in SYNTAX, or at position LIM.
1388 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1389 This function returns the distance traveled, either zero or positive. */)
1391 Lisp_Object syntax
, lim
;
1393 return skip_syntaxes (1, syntax
, lim
);
1396 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1397 doc
: /* Move point backward across chars in specified syntax classes.
1398 SYNTAX is a string of syntax code characters.
1399 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
1400 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1401 This function returns the distance traveled, either zero or negative. */)
1403 Lisp_Object syntax
, lim
;
1405 return skip_syntaxes (0, syntax
, lim
);
1409 skip_chars (forwardp
, string
, lim
, handle_iso_classes
)
1411 Lisp_Object string
, lim
;
1412 int handle_iso_classes
;
1414 register unsigned int c
;
1415 unsigned char fastmap
[0400];
1416 /* Store the ranges of non-ASCII characters. */
1418 int n_char_ranges
= 0;
1420 register int i
, i_byte
;
1421 /* Set to 1 if the current buffer is multibyte and the region
1422 contains non-ASCII chars. */
1424 /* Set to 1 if STRING is multibyte and it contains non-ASCII
1426 int string_multibyte
;
1428 const unsigned char *str
;
1430 Lisp_Object iso_classes
;
1432 CHECK_STRING (string
);
1436 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1438 CHECK_NUMBER_COERCE_MARKER (lim
);
1440 /* In any case, don't allow scan outside bounds of buffer. */
1441 if (XINT (lim
) > ZV
)
1442 XSETFASTINT (lim
, ZV
);
1443 if (XINT (lim
) < BEGV
)
1444 XSETFASTINT (lim
, BEGV
);
1446 multibyte
= (!NILP (current_buffer
->enable_multibyte_characters
)
1447 && (XINT (lim
) - PT
!= CHAR_TO_BYTE (XINT (lim
)) - PT_BYTE
));
1448 string_multibyte
= SBYTES (string
) > SCHARS (string
);
1450 bzero (fastmap
, sizeof fastmap
);
1452 str
= SDATA (string
);
1453 size_byte
= SBYTES (string
);
1456 if (i_byte
< size_byte
1457 && SREF (string
, 0) == '^')
1459 negate
= 1; i_byte
++;
1462 /* Find the characters specified and set their elements of fastmap.
1463 Handle backslashes and ranges specially.
1465 If STRING contains non-ASCII characters, setup char_ranges for
1466 them and use fastmap only for their leading codes. */
1468 if (! string_multibyte
)
1470 int string_has_eight_bit
= 0;
1472 /* At first setup fastmap. */
1473 while (i_byte
< size_byte
)
1477 if (handle_iso_classes
&& c
== '['
1478 && i_byte
< size_byte
1479 && str
[i_byte
] == ':')
1481 const unsigned char *class_beg
= str
+ i_byte
+ 1;
1482 const unsigned char *class_end
= class_beg
;
1483 const unsigned char *class_limit
= str
+ size_byte
- 2;
1484 /* Leave room for the null. */
1485 unsigned char class_name
[CHAR_CLASS_MAX_LENGTH
+ 1];
1488 if (class_limit
- class_beg
> CHAR_CLASS_MAX_LENGTH
)
1489 class_limit
= class_beg
+ CHAR_CLASS_MAX_LENGTH
;
1491 while (class_end
< class_limit
1492 && *class_end
>= 'a' && *class_end
<= 'z')
1495 if (class_end
== class_beg
1496 || *class_end
!= ':' || class_end
[1] != ']')
1497 goto not_a_class_name
;
1499 bcopy (class_beg
, class_name
, class_end
- class_beg
);
1500 class_name
[class_end
- class_beg
] = 0;
1502 cc
= re_wctype (class_name
);
1504 error ("Invalid ISO C character class");
1506 iso_classes
= Fcons (make_number (cc
), iso_classes
);
1508 i_byte
= class_end
+ 2 - str
;
1515 if (i_byte
== size_byte
)
1520 /* Treat `-' as range character only if another character
1522 if (i_byte
+ 1 < size_byte
1523 && str
[i_byte
] == '-')
1527 /* Skip over the dash. */
1530 /* Get the end of the range. */
1533 && i_byte
< size_byte
)
1540 if (! ASCII_CHAR_P (c2
))
1541 string_has_eight_bit
= 1;
1547 if (! ASCII_CHAR_P (c
))
1548 string_has_eight_bit
= 1;
1552 /* If the current range is multibyte and STRING contains
1553 eight-bit chars, arrange fastmap and setup char_ranges for
1554 the corresponding multibyte chars. */
1555 if (multibyte
&& string_has_eight_bit
)
1557 unsigned char fastmap2
[0400];
1558 int range_start_byte
, range_start_char
;
1560 bcopy (fastmap2
+ 0200, fastmap
+ 0200, 0200);
1561 bzero (fastmap
+ 0200, 0200);
1562 /* We are sure that this loop stops. */
1563 for (i
= 0200; ! fastmap2
[i
]; i
++);
1564 c
= unibyte_char_to_multibyte (i
);
1565 fastmap
[CHAR_LEADING_CODE (c
)] = 1;
1566 range_start_byte
= i
;
1567 range_start_char
= c
;
1568 char_ranges
= (int *) alloca (sizeof (int) * 128 * 2);
1569 for (i
= 129; i
< 0400; i
++)
1571 c
= unibyte_char_to_multibyte (i
);
1572 fastmap
[CHAR_LEADING_CODE (c
)] = 1;
1573 if (i
- range_start_byte
!= c
- range_start_char
)
1575 char_ranges
[n_char_ranges
++] = range_start_char
;
1576 char_ranges
[n_char_ranges
++] = ((i
- 1 - range_start_byte
)
1577 + range_start_char
);
1578 range_start_byte
= i
;
1579 range_start_char
= c
;
1582 char_ranges
[n_char_ranges
++] = range_start_char
;
1583 char_ranges
[n_char_ranges
++] = ((i
- 1 - range_start_byte
)
1584 + range_start_char
);
1587 else /* STRING is multibyte */
1589 char_ranges
= (int *) alloca (sizeof (int) * SCHARS (string
) * 2);
1591 while (i_byte
< size_byte
)
1593 unsigned char leading_code
;
1595 leading_code
= str
[i_byte
];
1596 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, size_byte
-i_byte
, len
);
1599 if (handle_iso_classes
&& c
== '['
1600 && i_byte
< size_byte
1601 && STRING_CHAR (str
+ i_byte
, size_byte
- i_byte
) == ':')
1603 const unsigned char *class_beg
= str
+ i_byte
+ 1;
1604 const unsigned char *class_end
= class_beg
;
1605 const unsigned char *class_limit
= str
+ size_byte
- 2;
1606 /* Leave room for the null. */
1607 unsigned char class_name
[CHAR_CLASS_MAX_LENGTH
+ 1];
1610 if (class_limit
- class_beg
> CHAR_CLASS_MAX_LENGTH
)
1611 class_limit
= class_beg
+ CHAR_CLASS_MAX_LENGTH
;
1613 while (class_end
< class_limit
1614 && *class_end
>= 'a' && *class_end
<= 'z')
1617 if (class_end
== class_beg
1618 || *class_end
!= ':' || class_end
[1] != ']')
1619 goto not_a_class_name_multibyte
;
1621 bcopy (class_beg
, class_name
, class_end
- class_beg
);
1622 class_name
[class_end
- class_beg
] = 0;
1624 cc
= re_wctype (class_name
);
1626 error ("Invalid ISO C character class");
1628 iso_classes
= Fcons (make_number (cc
), iso_classes
);
1630 i_byte
= class_end
+ 2 - str
;
1634 not_a_class_name_multibyte
:
1637 if (i_byte
== size_byte
)
1640 leading_code
= str
[i_byte
];
1641 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
,
1642 size_byte
- i_byte
, len
);
1645 /* Treat `-' as range character only if another character
1647 if (i_byte
+ 1 < size_byte
1648 && str
[i_byte
] == '-')
1651 unsigned char leading_code2
;
1653 /* Skip over the dash. */
1656 /* Get the end of the range. */
1657 leading_code2
= str
[i_byte
];
1658 c2
= STRING_CHAR_AND_LENGTH (str
+ i_byte
,
1659 size_byte
- i_byte
, len
);
1663 && i_byte
< size_byte
)
1665 leading_code2
= str
[i_byte
];
1666 c2
=STRING_CHAR_AND_LENGTH (str
+ i_byte
, size_byte
-i_byte
, len
);
1672 if (ASCII_CHAR_P (c
))
1674 while (c
<= c2
&& c
< 0x80)
1676 leading_code
= CHAR_LEADING_CODE (c
);
1678 if (! ASCII_CHAR_P (c
))
1680 while (leading_code
<= leading_code2
)
1681 fastmap
[leading_code
++] = 1;
1684 char_ranges
[n_char_ranges
++] = c
;
1685 char_ranges
[n_char_ranges
++] = c2
;
1691 if (ASCII_CHAR_P (c
))
1695 fastmap
[leading_code
] = 1;
1696 char_ranges
[n_char_ranges
++] = c
;
1697 char_ranges
[n_char_ranges
++] = c
;
1702 /* If the current range is unibyte and STRING contains non-ASCII
1703 chars, arrange fastmap for the corresponding unibyte
1706 if (! multibyte
&& n_char_ranges
> 0)
1708 bzero (fastmap
+ 0200, 0200);
1709 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1711 int c1
= char_ranges
[i
];
1712 int c2
= char_ranges
[i
+ 1];
1714 for (; c1
<= c2
; c1
++)
1715 fastmap
[CHAR_TO_BYTE8 (c1
)] = 1;
1720 /* If ^ was the first character, complement the fastmap. */
1724 for (i
= 0; i
< sizeof fastmap
; i
++)
1728 for (i
= 0; i
< 0200; i
++)
1730 /* All non-ASCII chars possibly match. */
1731 for (; i
< sizeof fastmap
; i
++)
1737 int start_point
= PT
;
1739 int pos_byte
= PT_BYTE
;
1740 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
1744 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
1745 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
1749 endp
= CHAR_POS_ADDR (XINT (lim
));
1750 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
1768 c
= STRING_CHAR_AND_LENGTH (p
, MAX_MULTIBYTE_LENGTH
, nbytes
);
1769 if (! NILP (iso_classes
) && in_classes (c
, iso_classes
))
1779 if (! ASCII_CHAR_P (c
))
1781 /* As we are looking at a multibyte character, we
1782 must look up the character in the table
1783 CHAR_RANGES. If there's no data in the table,
1784 that character is not what we want to skip. */
1786 /* The following code do the right thing even if
1787 n_char_ranges is zero (i.e. no data in
1789 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1790 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1792 if (!(negate
^ (i
< n_char_ranges
)))
1796 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
1809 if (!NILP (iso_classes
) && in_classes (*p
, iso_classes
))
1814 goto fwd_unibyte_ok
;
1820 p
++, pos
++, pos_byte
++;
1828 unsigned char *prev_p
;
1838 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
1839 c
= STRING_CHAR (p
, MAX_MULTIBYTE_LENGTH
);
1841 if (! NILP (iso_classes
) && in_classes (c
, iso_classes
))
1851 if (! ASCII_CHAR_P (c
))
1853 /* See the comment in the previous similar code. */
1854 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1855 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1857 if (!(negate
^ (i
< n_char_ranges
)))
1861 pos
--, pos_byte
-= prev_p
- p
;
1874 if (! NILP (iso_classes
) && in_classes (p
[-1], iso_classes
))
1879 goto back_unibyte_ok
;
1882 if (!fastmap
[p
[-1]])
1885 p
--, pos
--, pos_byte
--;
1889 SET_PT_BOTH (pos
, pos_byte
);
1892 return make_number (PT
- start_point
);
1898 skip_syntaxes (forwardp
, string
, lim
)
1900 Lisp_Object string
, lim
;
1902 register unsigned int c
;
1903 unsigned char fastmap
[0400];
1905 register int i
, i_byte
;
1910 CHECK_STRING (string
);
1913 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1915 CHECK_NUMBER_COERCE_MARKER (lim
);
1917 /* In any case, don't allow scan outside bounds of buffer. */
1918 if (XINT (lim
) > ZV
)
1919 XSETFASTINT (lim
, ZV
);
1920 if (XINT (lim
) < BEGV
)
1921 XSETFASTINT (lim
, BEGV
);
1923 if (forwardp
? (PT
>= XFASTINT (lim
)) : (PT
<= XFASTINT (lim
)))
1924 return make_number (0);
1926 multibyte
= (!NILP (current_buffer
->enable_multibyte_characters
)
1927 && (XINT (lim
) - PT
!= CHAR_TO_BYTE (XINT (lim
)) - PT_BYTE
));
1929 bzero (fastmap
, sizeof fastmap
);
1931 if (SBYTES (string
) > SCHARS (string
))
1932 /* As this is very rare case (syntax spec is ASCII only), don't
1933 consider efficiency. */
1934 string
= string_make_unibyte (string
);
1936 str
= SDATA (string
);
1937 size_byte
= SBYTES (string
);
1940 if (i_byte
< size_byte
1941 && SREF (string
, 0) == '^')
1943 negate
= 1; i_byte
++;
1946 /* Find the syntaxes specified and set their elements of fastmap. */
1948 while (i_byte
< size_byte
)
1951 fastmap
[syntax_spec_code
[c
]] = 1;
1954 /* If ^ was the first character, complement the fastmap. */
1956 for (i
= 0; i
< sizeof fastmap
; i
++)
1960 int start_point
= PT
;
1962 int pos_byte
= PT_BYTE
;
1963 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
1967 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
1968 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
1972 endp
= CHAR_POS_ADDR (XINT (lim
));
1973 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
1977 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1993 c
= STRING_CHAR_AND_LENGTH (p
, MAX_MULTIBYTE_LENGTH
, nbytes
);
1994 if (! fastmap
[(int) SYNTAX (c
)])
1996 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
1997 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
2011 if (! fastmap
[(int) SYNTAX (*p
)])
2013 p
++, pos
++, pos_byte
++;
2014 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
2024 unsigned char *prev_p
;
2034 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
2035 c
= STRING_CHAR (p
, MAX_MULTIBYTE_LENGTH
);
2036 if (! fastmap
[(int) SYNTAX (c
)])
2038 pos
--, pos_byte
-= prev_p
- p
;
2039 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
2053 if (! fastmap
[(int) SYNTAX (p
[-1])])
2055 p
--, pos
--, pos_byte
--;
2056 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
2061 SET_PT_BOTH (pos
, pos_byte
);
2064 return make_number (PT
- start_point
);
2068 /* Return 1 if character C belongs to one of the ISO classes
2069 in the list ISO_CLASSES. Each class is represented by an
2070 integer which is its type according to re_wctype. */
2073 in_classes (c
, iso_classes
)
2075 Lisp_Object iso_classes
;
2079 while (! NILP (iso_classes
))
2082 elt
= XCAR (iso_classes
);
2083 iso_classes
= XCDR (iso_classes
);
2085 if (re_iswctype (c
, XFASTINT (elt
)))
2092 /* Jump over a comment, assuming we are at the beginning of one.
2093 FROM is the current position.
2094 FROM_BYTE is the bytepos corresponding to FROM.
2095 Do not move past STOP (a charpos).
2096 The comment over which we have to jump is of style STYLE
2097 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
2098 NESTING should be positive to indicate the nesting at the beginning
2099 for nested comments and should be zero or negative else.
2100 ST_COMMENT_STYLE cannot be nested.
2101 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
2102 (or 0 If the search cannot start in the middle of a two-character).
2104 If successful, return 1 and store the charpos of the comment's end
2105 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
2106 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
2107 corresponding bytepos into *BYTEPOS_PTR and the current nesting
2108 (as defined for state.incomment) in *INCOMMENT_PTR.
2110 The comment end is the last character of the comment rather than the
2111 character just after the comment.
2113 Global syntax data is assumed to initially be valid for FROM and
2114 remains valid for forward search starting at the returned position. */
2117 forw_comment (from
, from_byte
, stop
, nesting
, style
, prev_syntax
,
2118 charpos_ptr
, bytepos_ptr
, incomment_ptr
)
2119 EMACS_INT from
, from_byte
, stop
;
2120 int nesting
, style
, prev_syntax
;
2121 EMACS_INT
*charpos_ptr
, *bytepos_ptr
;
2125 register enum syntaxcode code
;
2126 register int syntax
;
2128 if (nesting
<= 0) nesting
= -1;
2130 /* Enter the loop in the middle so that we find
2131 a 2-char comment ender if we start in the middle of it. */
2132 syntax
= prev_syntax
;
2133 if (syntax
!= 0) goto forw_incomment
;
2139 *incomment_ptr
= nesting
;
2140 *charpos_ptr
= from
;
2141 *bytepos_ptr
= from_byte
;
2144 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2145 syntax
= SYNTAX_WITH_FLAGS (c
);
2146 code
= syntax
& 0xff;
2147 if (code
== Sendcomment
2148 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
2149 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ?
2150 (nesting
> 0 && --nesting
== 0) : nesting
< 0))
2151 /* we have encountered a comment end of the same style
2152 as the comment sequence which began this comment
2155 if (code
== Scomment_fence
2156 && style
== ST_COMMENT_STYLE
)
2157 /* we have encountered a comment end of the same style
2158 as the comment sequence which began this comment
2163 && SYNTAX_FLAGS_COMMENT_NESTED (syntax
)
2164 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
)
2165 /* we have encountered a nested comment of the same style
2166 as the comment sequence which began this comment section */
2168 INC_BOTH (from
, from_byte
);
2169 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2172 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
2173 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
2174 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2175 SYNTAX_COMEND_SECOND (c1
))
2176 && ((SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
2177 SYNTAX_COMMENT_NESTED (c1
)) ? nesting
> 0 : nesting
< 0))
2180 /* we have encountered a comment end of the same style
2181 as the comment sequence which began this comment
2186 INC_BOTH (from
, from_byte
);
2187 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2192 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
2193 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2194 SYNTAX_COMMENT_STYLE (c1
) == style
2195 && SYNTAX_COMSTART_SECOND (c1
))
2196 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
2197 SYNTAX_COMMENT_NESTED (c1
)))
2198 /* we have encountered a nested comment of the same style
2199 as the comment sequence which began this comment
2202 INC_BOTH (from
, from_byte
);
2203 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2207 *charpos_ptr
= from
;
2208 *bytepos_ptr
= from_byte
;
2212 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
2214 Move forward across up to COUNT comments. If COUNT is negative, move backward.
2215 Stop scanning if we find something other than a comment or whitespace.
2216 Set point to where scanning stops.
2217 If COUNT comments are found as expected, with nothing except whitespace
2218 between them, return t; otherwise return nil. */)
2222 register EMACS_INT from
;
2223 EMACS_INT from_byte
;
2224 register EMACS_INT stop
;
2226 register enum syntaxcode code
;
2227 int comstyle
= 0; /* style of comment encountered */
2228 int comnested
= 0; /* whether the comment is nestable or not */
2231 EMACS_INT out_charpos
, out_bytepos
;
2234 CHECK_NUMBER (count
);
2235 count1
= XINT (count
);
2236 stop
= count1
> 0 ? ZV
: BEGV
;
2242 from_byte
= PT_BYTE
;
2244 SETUP_SYNTAX_TABLE (from
, count1
);
2253 SET_PT_BOTH (from
, from_byte
);
2257 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2259 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2260 comnested
= SYNTAX_COMMENT_NESTED (c
);
2261 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2262 INC_BOTH (from
, from_byte
);
2263 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2264 if (from
< stop
&& comstart_first
2265 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2266 SYNTAX_COMSTART_SECOND (c1
)))
2268 /* We have encountered a comment start sequence and we
2269 are ignoring all text inside comments. We must record
2270 the comment style this sequence begins so that later,
2271 only a comment end of the same style actually ends
2272 the comment section. */
2274 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2275 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2276 INC_BOTH (from
, from_byte
);
2277 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2280 while (code
== Swhitespace
|| (code
== Sendcomment
&& c
== '\n'));
2282 if (code
== Scomment_fence
)
2283 comstyle
= ST_COMMENT_STYLE
;
2284 else if (code
!= Scomment
)
2287 DEC_BOTH (from
, from_byte
);
2288 SET_PT_BOTH (from
, from_byte
);
2291 /* We're at the start of a comment. */
2292 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
2293 &out_charpos
, &out_bytepos
, &dummy
);
2294 from
= out_charpos
; from_byte
= out_bytepos
;
2298 SET_PT_BOTH (from
, from_byte
);
2301 INC_BOTH (from
, from_byte
);
2302 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2303 /* We have skipped one comment. */
2315 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
2320 DEC_BOTH (from
, from_byte
);
2321 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
2322 quoted
= char_quoted (from
, from_byte
);
2323 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2326 comnested
= SYNTAX_COMMENT_NESTED (c
);
2327 if (code
== Sendcomment
)
2328 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2329 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2330 && prev_char_comend_first (from
, from_byte
)
2331 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
2333 /* We must record the comment style encountered so that
2334 later, we can match only the proper comment begin
2335 sequence of the same style. */
2336 DEC_BOTH (from
, from_byte
);
2338 /* Calling char_quoted, above, set up global syntax position
2339 at the new value of FROM. */
2340 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2341 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2342 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2345 if (code
== Scomment_fence
)
2347 /* Skip until first preceding unquoted comment_fence. */
2348 int found
= 0, ini
= from
, ini_byte
= from_byte
;
2352 DEC_BOTH (from
, from_byte
);
2353 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2354 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2355 if (SYNTAX (c
) == Scomment_fence
2356 && !char_quoted (from
, from_byte
))
2361 else if (from
== stop
)
2366 from
= ini
; /* Set point to ini + 1. */
2367 from_byte
= ini_byte
;
2371 /* We have skipped one comment. */
2374 else if (code
== Sendcomment
)
2376 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2377 &out_charpos
, &out_bytepos
);
2381 /* This end-of-line is not an end-of-comment.
2382 Treat it like a whitespace.
2383 CC-mode (and maybe others) relies on this behavior. */
2387 /* Failure: we should go back to the end of this
2388 not-quite-endcomment. */
2389 if (SYNTAX(c
) != code
)
2390 /* It was a two-char Sendcomment. */
2391 INC_BOTH (from
, from_byte
);
2397 /* We have skipped one comment. */
2398 from
= out_charpos
, from_byte
= out_bytepos
;
2402 else if (code
!= Swhitespace
|| quoted
)
2406 INC_BOTH (from
, from_byte
);
2407 SET_PT_BOTH (from
, from_byte
);
2415 SET_PT_BOTH (from
, from_byte
);
2420 /* Return syntax code of character C if C is an ASCII character
2421 or `multibyte_symbol_p' is zero. Otherwise, return Ssymbol. */
2423 #define SYNTAX_WITH_MULTIBYTE_CHECK(c) \
2424 ((ASCII_CHAR_P (c) || !multibyte_symbol_p) \
2425 ? SYNTAX (c) : Ssymbol)
2428 scan_lists (from
, count
, depth
, sexpflag
)
2429 register EMACS_INT from
;
2430 EMACS_INT count
, depth
;
2434 register EMACS_INT stop
= count
> 0 ? ZV
: BEGV
;
2439 register enum syntaxcode code
, temp_code
;
2440 int min_depth
= depth
; /* Err out if depth gets less than this. */
2441 int comstyle
= 0; /* style of comment encountered */
2442 int comnested
= 0; /* whether the comment is nestable or not */
2444 EMACS_INT last_good
= from
;
2446 EMACS_INT from_byte
;
2447 EMACS_INT out_bytepos
, out_charpos
;
2449 int multibyte_symbol_p
= sexpflag
&& multibyte_syntax_as_symbol
;
2451 if (depth
> 0) min_depth
= 0;
2453 if (from
> ZV
) from
= ZV
;
2454 if (from
< BEGV
) from
= BEGV
;
2456 from_byte
= CHAR_TO_BYTE (from
);
2461 SETUP_SYNTAX_TABLE (from
, count
);
2466 int comstart_first
, prefix
;
2467 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2468 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2469 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2470 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2471 comnested
= SYNTAX_COMMENT_NESTED (c
);
2472 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2473 prefix
= SYNTAX_PREFIX (c
);
2474 if (depth
== min_depth
)
2476 INC_BOTH (from
, from_byte
);
2477 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2478 if (from
< stop
&& comstart_first
2479 && (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2480 SYNTAX_COMSTART_SECOND (c
))
2481 && parse_sexp_ignore_comments
)
2483 /* we have encountered a comment start sequence and we
2484 are ignoring all text inside comments. We must record
2485 the comment style this sequence begins so that later,
2486 only a comment end of the same style actually ends
2487 the comment section */
2489 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2490 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2491 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2492 INC_BOTH (from
, from_byte
);
2493 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2499 switch (SWITCH_ENUM_CAST (code
))
2503 if (from
== stop
) goto lose
;
2504 INC_BOTH (from
, from_byte
);
2505 /* treat following character as a word constituent */
2508 if (depth
|| !sexpflag
) break;
2509 /* This word counts as a sexp; return at end of it. */
2512 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2514 /* Some compilers can't handle this inside the switch. */
2515 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2516 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2521 INC_BOTH (from
, from_byte
);
2522 if (from
== stop
) goto lose
;
2531 INC_BOTH (from
, from_byte
);
2535 case Scomment_fence
:
2536 comstyle
= ST_COMMENT_STYLE
;
2539 if (!parse_sexp_ignore_comments
) break;
2540 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2541 found
= forw_comment (from
, from_byte
, stop
,
2542 comnested
, comstyle
, 0,
2543 &out_charpos
, &out_bytepos
, &dummy
);
2544 from
= out_charpos
, from_byte
= out_bytepos
;
2551 INC_BOTH (from
, from_byte
);
2552 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2558 if (from
!= stop
&& c
== FETCH_CHAR_AS_MULTIBYTE (from_byte
))
2560 INC_BOTH (from
, from_byte
);
2570 if (!++depth
) goto done
;
2575 if (!--depth
) goto done
;
2576 if (depth
< min_depth
)
2577 xsignal3 (Qscan_error
,
2578 build_string ("Containing expression ends prematurely"),
2579 make_number (last_good
), make_number (from
));
2584 temp_pos
= dec_bytepos (from_byte
);
2585 stringterm
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2588 if (from
>= stop
) goto lose
;
2589 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2590 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2593 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2594 : SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring_fence
)
2597 /* Some compilers can't handle this inside the switch. */
2598 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2603 INC_BOTH (from
, from_byte
);
2605 INC_BOTH (from
, from_byte
);
2607 INC_BOTH (from
, from_byte
);
2608 if (!depth
&& sexpflag
) goto done
;
2611 /* Ignore whitespace, punctuation, quote, endcomment. */
2616 /* Reached end of buffer. Error if within object, return nil if between */
2617 if (depth
) goto lose
;
2622 /* End of object reached */
2631 DEC_BOTH (from
, from_byte
);
2632 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2633 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2634 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2635 if (depth
== min_depth
)
2638 comnested
= SYNTAX_COMMENT_NESTED (c
);
2639 if (code
== Sendcomment
)
2640 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2641 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2642 && prev_char_comend_first (from
, from_byte
)
2643 && parse_sexp_ignore_comments
)
2645 /* We must record the comment style encountered so that
2646 later, we can match only the proper comment begin
2647 sequence of the same style. */
2648 DEC_BOTH (from
, from_byte
);
2649 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2651 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2652 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2653 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2656 /* Quoting turns anything except a comment-ender
2657 into a word character. Note that this cannot be true
2658 if we decremented FROM in the if-statement above. */
2659 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2661 DEC_BOTH (from
, from_byte
);
2664 else if (SYNTAX_PREFIX (c
))
2667 switch (SWITCH_ENUM_CAST (code
))
2673 if (depth
|| !sexpflag
) break;
2674 /* This word counts as a sexp; count object finished
2675 after passing it. */
2678 temp_pos
= from_byte
;
2679 if (! NILP (current_buffer
->enable_multibyte_characters
))
2683 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2684 c1
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2685 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2686 /* Don't allow comment-end to be quoted. */
2687 if (temp_code
== Sendcomment
)
2689 quoted
= char_quoted (from
- 1, temp_pos
);
2692 DEC_BOTH (from
, from_byte
);
2693 temp_pos
= dec_bytepos (temp_pos
);
2694 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2696 c1
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2697 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2698 if (! (quoted
|| temp_code
== Sword
2699 || temp_code
== Ssymbol
2700 || temp_code
== Squote
))
2702 DEC_BOTH (from
, from_byte
);
2709 temp_pos
= dec_bytepos (from_byte
);
2710 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2711 if (from
!= stop
&& c
== FETCH_CHAR_AS_MULTIBYTE (temp_pos
))
2712 DEC_BOTH (from
, from_byte
);
2721 if (!++depth
) goto done2
;
2726 if (!--depth
) goto done2
;
2727 if (depth
< min_depth
)
2728 xsignal3 (Qscan_error
,
2729 build_string ("Containing expression ends prematurely"),
2730 make_number (last_good
), make_number (from
));
2734 if (!parse_sexp_ignore_comments
)
2736 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2737 &out_charpos
, &out_bytepos
);
2738 /* FIXME: if found == -1, then it really wasn't a comment-end.
2739 For single-char Sendcomment, we can't do much about it apart
2740 from skipping the char.
2741 For 2-char endcomments, we could try again, taking both
2742 chars as separate entities, but it's a lot of trouble
2743 for very little gain, so we don't bother either. -sm */
2745 from
= out_charpos
, from_byte
= out_bytepos
;
2748 case Scomment_fence
:
2752 if (from
== stop
) goto lose
;
2753 DEC_BOTH (from
, from_byte
);
2754 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2755 if (!char_quoted (from
, from_byte
)
2756 && (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2757 SYNTAX_WITH_MULTIBYTE_CHECK (c
) == code
))
2760 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2764 stringterm
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2767 if (from
== stop
) goto lose
;
2768 DEC_BOTH (from
, from_byte
);
2769 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2770 if (!char_quoted (from
, from_byte
)
2772 == (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
)))
2773 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2776 if (!depth
&& sexpflag
) goto done2
;
2779 /* Ignore whitespace, punctuation, quote, endcomment. */
2784 /* Reached start of buffer. Error if within object, return nil if between */
2785 if (depth
) goto lose
;
2796 XSETFASTINT (val
, from
);
2800 xsignal3 (Qscan_error
,
2801 build_string ("Unbalanced parentheses"),
2802 make_number (last_good
), make_number (from
));
2805 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2806 doc
: /* Scan from character number FROM by COUNT lists.
2807 Returns the character number of the position thus found.
2809 If DEPTH is nonzero, paren depth begins counting from that value,
2810 only places where the depth in parentheses becomes zero
2811 are candidates for stopping; COUNT such places are counted.
2812 Thus, a positive value for DEPTH means go out levels.
2814 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2816 If the beginning or end of (the accessible part of) the buffer is reached
2817 and the depth is wrong, an error is signaled.
2818 If the depth is right but the count is not used up, nil is returned. */)
2819 (from
, count
, depth
)
2820 Lisp_Object from
, count
, depth
;
2822 CHECK_NUMBER (from
);
2823 CHECK_NUMBER (count
);
2824 CHECK_NUMBER (depth
);
2826 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2829 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2830 doc
: /* Scan from character number FROM by COUNT balanced expressions.
2831 If COUNT is negative, scan backwards.
2832 Returns the character number of the position thus found.
2834 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2836 If the beginning or end of (the accessible part of) the buffer is reached
2837 in the middle of a parenthetical grouping, an error is signaled.
2838 If the beginning or end is reached between groupings
2839 but before count is used up, nil is returned. */)
2841 Lisp_Object from
, count
;
2843 CHECK_NUMBER (from
);
2844 CHECK_NUMBER (count
);
2846 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2849 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2851 doc
: /* Move point backward over any number of chars with prefix syntax.
2852 This includes chars with "quote" or "prefix" syntax (' or p). */)
2857 int opoint_byte
= PT_BYTE
;
2859 int pos_byte
= PT_BYTE
;
2864 SET_PT_BOTH (opoint
, opoint_byte
);
2869 SETUP_SYNTAX_TABLE (pos
, -1);
2871 DEC_BOTH (pos
, pos_byte
);
2873 while (!char_quoted (pos
, pos_byte
)
2874 /* Previous statement updates syntax table. */
2875 && ((c
= FETCH_CHAR_AS_MULTIBYTE (pos_byte
), SYNTAX (c
) == Squote
)
2876 || SYNTAX_PREFIX (c
)))
2879 opoint_byte
= pos_byte
;
2882 DEC_BOTH (pos
, pos_byte
);
2885 SET_PT_BOTH (opoint
, opoint_byte
);
2890 /* Parse forward from FROM / FROM_BYTE to END,
2891 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2892 and return a description of the state of the parse at END.
2893 If STOPBEFORE is nonzero, stop at the start of an atom.
2894 If COMMENTSTOP is 1, stop at the start of a comment.
2895 If COMMENTSTOP is -1, stop at the start or end of a comment,
2896 after the beginning of a string, or after the end of a string. */
2899 scan_sexps_forward (stateptr
, from
, from_byte
, end
, targetdepth
,
2900 stopbefore
, oldstate
, commentstop
)
2901 struct lisp_parse_state
*stateptr
;
2904 int end
, targetdepth
, stopbefore
;
2905 Lisp_Object oldstate
;
2908 struct lisp_parse_state state
;
2910 register enum syntaxcode code
;
2913 struct level
{ int last
, prev
; };
2914 struct level levelstart
[100];
2915 register struct level
*curlevel
= levelstart
;
2916 struct level
*endlevel
= levelstart
+ 100;
2917 register int depth
; /* Paren depth of current scanning location.
2918 level - levelstart equals this except
2919 when the depth becomes negative. */
2920 int mindepth
; /* Lowest DEPTH value seen. */
2921 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2923 int prev_from
; /* Keep one character before FROM. */
2925 int prev_from_syntax
;
2926 int boundary_stop
= commentstop
== -1;
2929 EMACS_INT out_bytepos
, out_charpos
;
2933 prev_from_byte
= from_byte
;
2935 DEC_BOTH (prev_from
, prev_from_byte
);
2937 /* Use this macro instead of `from++'. */
2939 do { prev_from = from; \
2940 prev_from_byte = from_byte; \
2941 temp = FETCH_CHAR_AS_MULTIBYTE (prev_from_byte); \
2942 prev_from_syntax = SYNTAX_WITH_FLAGS (temp); \
2943 INC_BOTH (from, from_byte); \
2945 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2951 if (NILP (oldstate
))
2954 state
.instring
= -1;
2955 state
.incomment
= 0;
2956 state
.comstyle
= 0; /* comment style a by default. */
2957 state
.comstr_start
= -1; /* no comment/string seen. */
2961 tem
= Fcar (oldstate
);
2967 oldstate
= Fcdr (oldstate
);
2968 oldstate
= Fcdr (oldstate
);
2969 oldstate
= Fcdr (oldstate
);
2970 tem
= Fcar (oldstate
);
2971 /* Check whether we are inside string_fence-style string: */
2972 state
.instring
= (!NILP (tem
)
2973 ? (INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2976 oldstate
= Fcdr (oldstate
);
2977 tem
= Fcar (oldstate
);
2978 state
.incomment
= (!NILP (tem
)
2979 ? (INTEGERP (tem
) ? XINT (tem
) : -1)
2982 oldstate
= Fcdr (oldstate
);
2983 tem
= Fcar (oldstate
);
2984 start_quoted
= !NILP (tem
);
2986 /* if the eighth element of the list is nil, we are in comment
2987 style a. If it is non-nil, we are in comment style b */
2988 oldstate
= Fcdr (oldstate
);
2989 oldstate
= Fcdr (oldstate
);
2990 tem
= Fcar (oldstate
);
2991 state
.comstyle
= NILP (tem
) ? 0 : (EQ (tem
, Qsyntax_table
)
2992 ? ST_COMMENT_STYLE
: 1);
2994 oldstate
= Fcdr (oldstate
);
2995 tem
= Fcar (oldstate
);
2996 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2997 oldstate
= Fcdr (oldstate
);
2998 tem
= Fcar (oldstate
);
2999 while (!NILP (tem
)) /* >= second enclosing sexps. */
3001 /* curlevel++->last ran into compiler bug on Apollo */
3002 curlevel
->last
= XINT (Fcar (tem
));
3003 if (++curlevel
== endlevel
)
3004 curlevel
--; /* error ("Nesting too deep for parser"); */
3005 curlevel
->prev
= -1;
3006 curlevel
->last
= -1;
3013 curlevel
->prev
= -1;
3014 curlevel
->last
= -1;
3016 SETUP_SYNTAX_TABLE (prev_from
, 1);
3017 temp
= FETCH_CHAR (prev_from_byte
);
3018 prev_from_syntax
= SYNTAX_WITH_FLAGS (temp
);
3019 UPDATE_SYNTAX_TABLE_FORWARD (from
);
3021 /* Enter the loop at a place appropriate for initial state. */
3023 if (state
.incomment
)
3024 goto startincomment
;
3025 if (state
.instring
>= 0)
3027 nofence
= state
.instring
!= ST_STRING_STYLE
;
3029 goto startquotedinstring
;
3032 else if (start_quoted
)
3038 code
= prev_from_syntax
& 0xff;
3041 && SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
)
3042 && (c1
= FETCH_CHAR (from_byte
),
3043 SYNTAX_COMSTART_SECOND (c1
)))
3044 /* Duplicate code to avoid a complex if-expression
3045 which causes trouble for the SGI compiler. */
3047 /* Record the comment style we have entered so that only
3048 the comment-end sequence of the same style actually
3049 terminates the comment section. */
3050 state
.comstyle
= SYNTAX_COMMENT_STYLE (c1
);
3051 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
);
3052 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
3053 state
.incomment
= comnested
? 1 : -1;
3054 state
.comstr_start
= prev_from
;
3058 else if (code
== Scomment_fence
)
3060 /* Record the comment style we have entered so that only
3061 the comment-end sequence of the same style actually
3062 terminates the comment section. */
3063 state
.comstyle
= ST_COMMENT_STYLE
;
3064 state
.incomment
= -1;
3065 state
.comstr_start
= prev_from
;
3068 else if (code
== Scomment
)
3070 state
.comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax
);
3071 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
3073 state
.comstr_start
= prev_from
;
3076 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
3078 switch (SWITCH_ENUM_CAST (code
))
3082 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3083 curlevel
->last
= prev_from
;
3085 if (from
== end
) goto endquoted
;
3088 /* treat following character as a word constituent */
3091 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3092 curlevel
->last
= prev_from
;
3096 /* Some compilers can't handle this inside the switch. */
3097 temp
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
3098 temp
= SYNTAX (temp
);
3104 if (from
== end
) goto endquoted
;
3116 curlevel
->prev
= curlevel
->last
;
3119 case Scomment_fence
: /* Can't happen because it's handled above. */
3121 if (commentstop
|| boundary_stop
) goto done
;
3123 /* The (from == BEGV) test was to enter the loop in the middle so
3124 that we find a 2-char comment ender even if we start in the
3125 middle of it. We don't want to do that if we're just at the
3126 beginning of the comment (think of (*) ... (*)). */
3127 found
= forw_comment (from
, from_byte
, end
,
3128 state
.incomment
, state
.comstyle
,
3129 (from
== BEGV
|| from
< state
.comstr_start
+ 3)
3130 ? 0 : prev_from_syntax
,
3131 &out_charpos
, &out_bytepos
, &state
.incomment
);
3132 from
= out_charpos
; from_byte
= out_bytepos
;
3133 /* Beware! prev_from and friends are invalid now.
3134 Luckily, the `done' doesn't use them and the INC_FROM
3135 sets them to a sane value without looking at them. */
3136 if (!found
) goto done
;
3138 state
.incomment
= 0;
3139 state
.comstyle
= 0; /* reset the comment style */
3140 if (boundary_stop
) goto done
;
3144 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3146 /* curlevel++->last ran into compiler bug on Apollo */
3147 curlevel
->last
= prev_from
;
3148 if (++curlevel
== endlevel
)
3149 curlevel
--; /* error ("Nesting too deep for parser"); */
3150 curlevel
->prev
= -1;
3151 curlevel
->last
= -1;
3152 if (targetdepth
== depth
) goto done
;
3157 if (depth
< mindepth
)
3159 if (curlevel
!= levelstart
)
3161 curlevel
->prev
= curlevel
->last
;
3162 if (targetdepth
== depth
) goto done
;
3167 state
.comstr_start
= from
- 1;
3168 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3169 curlevel
->last
= prev_from
;
3170 state
.instring
= (code
== Sstring
3171 ? (FETCH_CHAR_AS_MULTIBYTE (prev_from_byte
))
3173 if (boundary_stop
) goto done
;
3176 nofence
= state
.instring
!= ST_STRING_STYLE
;
3182 if (from
>= end
) goto done
;
3183 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
3184 /* Some compilers can't handle this inside the switch. */
3187 /* Check TEMP here so that if the char has
3188 a syntax-table property which says it is NOT
3189 a string character, it does not end the string. */
3190 if (nofence
&& c
== state
.instring
&& temp
== Sstring
)
3196 if (!nofence
) goto string_end
;
3201 startquotedinstring
:
3202 if (from
>= end
) goto endquoted
;
3208 state
.instring
= -1;
3209 curlevel
->prev
= curlevel
->last
;
3211 if (boundary_stop
) goto done
;
3215 /* FIXME: We should do something with it. */
3218 /* Ignore whitespace, punctuation, quote, endcomment. */
3224 stop
: /* Here if stopping before start of sexp. */
3225 from
= prev_from
; /* We have just fetched the char that starts it; */
3226 goto done
; /* but return the position before it. */
3231 state
.depth
= depth
;
3232 state
.mindepth
= mindepth
;
3233 state
.thislevelstart
= curlevel
->prev
;
3234 state
.prevlevelstart
3235 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
3236 state
.location
= from
;
3237 state
.levelstarts
= Qnil
;
3238 while (--curlevel
>= levelstart
)
3239 state
.levelstarts
= Fcons (make_number (curlevel
->last
),
3246 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
3247 doc
: /* Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
3248 Parsing stops at TO or when certain criteria are met;
3249 point is set to where parsing stops.
3250 If fifth arg OLDSTATE is omitted or nil,
3251 parsing assumes that FROM is the beginning of a function.
3252 Value is a list of elements describing final state of parsing:
3254 1. character address of start of innermost containing list; nil if none.
3255 2. character address of start of last complete sexp terminated.
3256 3. non-nil if inside a string.
3257 (it is the character that will terminate the string,
3258 or t if the string should be terminated by a generic string delimiter.)
3259 4. nil if outside a comment, t if inside a non-nestable comment,
3260 else an integer (the current comment nesting).
3261 5. t if following a quote character.
3262 6. the minimum paren-depth encountered during this scan.
3263 7. t if in a comment of style b; symbol `syntax-table' if the comment
3264 should be terminated by a generic comment delimiter.
3265 8. character address of start of comment or string; nil if not in one.
3266 9. Intermediate data for continuation of parsing (subject to change).
3267 If third arg TARGETDEPTH is non-nil, parsing stops if the depth
3268 in parentheses becomes equal to TARGETDEPTH.
3269 Fourth arg STOPBEFORE non-nil means stop when come to
3270 any character that starts a sexp.
3271 Fifth arg OLDSTATE is a list like what this function returns.
3272 It is used to initialize the state of the parse. Elements number 1, 2, 6
3273 and 8 are ignored; you can leave off element 8 (the last) entirely.
3274 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
3275 If it is symbol `syntax-table', stop after the start of a comment or a
3276 string, or after end of a comment or a string. */)
3277 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
3278 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
3280 struct lisp_parse_state state
;
3283 if (!NILP (targetdepth
))
3285 CHECK_NUMBER (targetdepth
);
3286 target
= XINT (targetdepth
);
3289 target
= -100000; /* We won't reach this depth */
3291 validate_region (&from
, &to
);
3292 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
3294 target
, !NILP (stopbefore
), oldstate
,
3296 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
3298 SET_PT (state
.location
);
3300 return Fcons (make_number (state
.depth
),
3301 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
3302 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
3303 Fcons (state
.instring
>= 0
3304 ? (state
.instring
== ST_STRING_STYLE
3305 ? Qt
: make_number (state
.instring
)) : Qnil
,
3306 Fcons (state
.incomment
< 0 ? Qt
:
3307 (state
.incomment
== 0 ? Qnil
:
3308 make_number (state
.incomment
)),
3309 Fcons (state
.quoted
? Qt
: Qnil
,
3310 Fcons (make_number (state
.mindepth
),
3311 Fcons ((state
.comstyle
3312 ? (state
.comstyle
== ST_COMMENT_STYLE
3313 ? Qsyntax_table
: Qt
) :
3315 Fcons (((state
.incomment
3316 || (state
.instring
>= 0))
3317 ? make_number (state
.comstr_start
)
3319 Fcons (state
.levelstarts
, Qnil
))))))))));
3328 /* This has to be done here, before we call Fmake_char_table. */
3329 Qsyntax_table
= intern ("syntax-table");
3330 staticpro (&Qsyntax_table
);
3332 /* Intern this now in case it isn't already done.
3333 Setting this variable twice is harmless.
3334 But don't staticpro it here--that is done in alloc.c. */
3335 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
3337 /* Create objects which can be shared among syntax tables. */
3338 Vsyntax_code_object
= Fmake_vector (make_number (Smax
), Qnil
);
3339 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
3340 XVECTOR (Vsyntax_code_object
)->contents
[i
]
3341 = Fcons (make_number (i
), Qnil
);
3343 /* Now we are ready to set up this property, so we can
3344 create syntax tables. */
3345 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
3347 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
3349 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
3351 /* Control characters should not be whitespace. */
3352 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
3353 for (i
= 0; i
<= ' ' - 1; i
++)
3354 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3355 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, 0177, temp
);
3357 /* Except that a few really are whitespace. */
3358 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
3359 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ' ', temp
);
3360 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\t', temp
);
3361 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\n', temp
);
3362 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, 015, temp
);
3363 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, 014, temp
);
3365 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
3366 for (i
= 'a'; i
<= 'z'; i
++)
3367 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3368 for (i
= 'A'; i
<= 'Z'; i
++)
3369 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3370 for (i
= '0'; i
<= '9'; i
++)
3371 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3373 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
3374 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
3376 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
3377 Fcons (make_number (Sopen
), make_number (')')));
3378 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
3379 Fcons (make_number (Sclose
), make_number ('(')));
3380 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
3381 Fcons (make_number (Sopen
), make_number (']')));
3382 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
3383 Fcons (make_number (Sclose
), make_number ('[')));
3384 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
3385 Fcons (make_number (Sopen
), make_number ('}')));
3386 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
3387 Fcons (make_number (Sclose
), make_number ('{')));
3388 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
3389 Fcons (make_number ((int) Sstring
), Qnil
));
3390 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
3391 Fcons (make_number ((int) Sescape
), Qnil
));
3393 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
3394 for (i
= 0; i
< 10; i
++)
3396 c
= "_-+*/&|<>="[i
];
3397 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3400 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
3401 for (i
= 0; i
< 12; i
++)
3403 c
= ".,;:?!#@~^'`"[i
];
3404 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3407 /* All multibyte characters have syntax `word' by default. */
3408 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
3409 char_table_set_range (Vstandard_syntax_table
, 0x80, MAX_CHAR
, temp
);
3415 Qsyntax_table_p
= intern ("syntax-table-p");
3416 staticpro (&Qsyntax_table_p
);
3418 staticpro (&Vsyntax_code_object
);
3420 staticpro (&gl_state
.object
);
3421 staticpro (&gl_state
.global_code
);
3422 staticpro (&gl_state
.current_syntax_table
);
3423 staticpro (&gl_state
.old_prop
);
3425 /* Defined in regex.c */
3426 staticpro (&re_match_object
);
3428 Qscan_error
= intern ("scan-error");
3429 staticpro (&Qscan_error
);
3430 Fput (Qscan_error
, Qerror_conditions
,
3431 Fcons (Qscan_error
, Fcons (Qerror
, Qnil
)));
3432 Fput (Qscan_error
, Qerror_message
,
3433 build_string ("Scan error"));
3435 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
3436 doc
: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace. */);
3438 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
3439 doc
: /* Non-nil means `forward-sexp', etc., obey `syntax-table' property.
3440 Otherwise, that text property is simply ignored.
3441 See the info node `(elisp)Syntax Properties' for a description of the
3442 `syntax-table' property. */);
3444 words_include_escapes
= 0;
3445 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
3446 doc
: /* Non-nil means `forward-word', etc., should treat escape chars part of words. */);
3448 DEFVAR_BOOL ("multibyte-syntax-as-symbol", &multibyte_syntax_as_symbol
,
3449 doc
: /* Non-nil means `scan-sexps' treats all multibyte characters as symbol. */);
3450 multibyte_syntax_as_symbol
= 0;
3452 DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
3453 &open_paren_in_column_0_is_defun_start
,
3454 doc
: /* *Non-nil means an open paren in column 0 denotes the start of a defun. */);
3455 open_paren_in_column_0_is_defun_start
= 1;
3458 DEFVAR_LISP ("find-word-boundary-function-table",
3459 &Vfind_word_boundary_function_table
,
3461 Char table of functions to search for the word boundary.
3462 Each function is called with two arguments; POS and LIMIT.
3463 POS and LIMIT are character positions in the current buffer.
3465 If POS is less than LIMIT, POS is at the first character of a word,
3466 and the return value of a function is a position after the last
3467 character of that word.
3469 If POS is not less than LIMIT, POS is at the last character of a word,
3470 and the return value of a function is a position at the first
3471 character of that word.
3473 In both cases, LIMIT bounds the search. */);
3474 Vfind_word_boundary_function_table
= Fmake_char_table (Qnil
, Qnil
);
3476 defsubr (&Ssyntax_table_p
);
3477 defsubr (&Ssyntax_table
);
3478 defsubr (&Sstandard_syntax_table
);
3479 defsubr (&Scopy_syntax_table
);
3480 defsubr (&Sset_syntax_table
);
3481 defsubr (&Schar_syntax
);
3482 defsubr (&Smatching_paren
);
3483 defsubr (&Sstring_to_syntax
);
3484 defsubr (&Smodify_syntax_entry
);
3485 defsubr (&Sinternal_describe_syntax_value
);
3487 defsubr (&Sforward_word
);
3489 defsubr (&Sskip_chars_forward
);
3490 defsubr (&Sskip_chars_backward
);
3491 defsubr (&Sskip_syntax_forward
);
3492 defsubr (&Sskip_syntax_backward
);
3494 defsubr (&Sforward_comment
);
3495 defsubr (&Sscan_lists
);
3496 defsubr (&Sscan_sexps
);
3497 defsubr (&Sbackward_prefix_chars
);
3498 defsubr (&Sparse_partial_sexp
);
3501 /* arch-tag: 3e297b9f-088e-4b64-8f4c-fb0b3443e412
3502 (do not change this comment) */