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, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
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 mindepth
; /* Minimum depth seen while scanning. */
75 /* Char number of most recent start-of-expression at current level */
76 EMACS_INT thislevelstart
;
77 /* Char number of start of containing expression */
78 EMACS_INT prevlevelstart
;
79 EMACS_INT location
; /* Char number at which parsing stopped. */
80 EMACS_INT comstr_start
; /* Position of last comment/string starter. */
81 Lisp_Object levelstarts
; /* Char numbers of starts-of-expression
82 of levels (starting from outermost). */
85 /* These variables are a cache for finding the start of a defun.
86 find_start_pos is the place for which the defun start was found.
87 find_start_value is the defun start position found for it.
88 find_start_value_byte is the corresponding byte position.
89 find_start_buffer is the buffer it was found in.
90 find_start_begv is the BEGV value when it was found.
91 find_start_modiff is the value of MODIFF when it was found. */
93 static EMACS_INT find_start_pos
;
94 static EMACS_INT find_start_value
;
95 static EMACS_INT find_start_value_byte
;
96 static struct buffer
*find_start_buffer
;
97 static EMACS_INT find_start_begv
;
98 static int find_start_modiff
;
101 static Lisp_Object
skip_chars (int, Lisp_Object
, Lisp_Object
, int);
102 static Lisp_Object
skip_syntaxes (int, Lisp_Object
, Lisp_Object
);
103 static Lisp_Object
scan_lists (EMACS_INT
, EMACS_INT
, EMACS_INT
, int);
104 static void scan_sexps_forward (struct lisp_parse_state
*,
105 EMACS_INT
, EMACS_INT
, EMACS_INT
, int,
106 int, Lisp_Object
, int);
107 static int in_classes (int, Lisp_Object
);
110 struct gl_state_s gl_state
; /* Global state of syntax parser. */
112 INTERVAL
interval_of (int, Lisp_Object
);
113 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
114 to scan to property-change. */
116 /* Update gl_state to an appropriate interval which contains CHARPOS. The
117 sign of COUNT give the relative position of CHARPOS wrt the previously
118 valid interval. If INIT, only [be]_property fields of gl_state are
119 valid at start, the rest is filled basing on OBJECT.
121 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
122 direction than the intervals - or in an interval. We update the
123 current syntax-table basing on the property of this interval, and
124 update the interval to start further than CHARPOS - or be
125 NULL_INTERVAL. We also update lim_property to be the next value of
126 charpos to call this subroutine again - or be before/after the
127 start/end of OBJECT. */
130 update_syntax_table (int charpos
, int count
, int init
, Lisp_Object object
)
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 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
;
251 = i
->position
+ LENGTH (i
) - gl_state
.offset
;
252 gl_state
.backward_i
= i
;
256 else if (cnt
== INTERVALS_AT_ONCE
)
261 = i
->position
+ LENGTH (i
) - gl_state
.offset
262 /* e_property at EOB is not set to ZV but to ZV+1, so that
263 we can do INC(from);UPDATE_SYNTAX_TABLE_FORWARD without
264 having to check eob between the two. */
265 + (NULL_INTERVAL_P (next_interval (i
)) ? 1 : 0);
266 gl_state
.forward_i
= i
;
270 gl_state
.b_property
= i
->position
- gl_state
.offset
;
271 gl_state
.backward_i
= i
;
276 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
278 eassert (NULL_INTERVAL_P (i
)); /* This property goes to the end. */
280 gl_state
.e_property
= gl_state
.stop
;
282 gl_state
.b_property
= gl_state
.start
;
285 /* Returns TRUE if char at CHARPOS is quoted.
286 Global syntax-table data should be set up already to be good at CHARPOS
287 or after. On return global syntax data is good for lookup at CHARPOS. */
290 char_quoted (EMACS_INT charpos
, EMACS_INT bytepos
)
292 register enum syntaxcode code
;
293 register EMACS_INT beg
= BEGV
;
294 register int quoted
= 0;
295 EMACS_INT orig
= charpos
;
297 while (charpos
> beg
)
300 DEC_BOTH (charpos
, bytepos
);
302 UPDATE_SYNTAX_TABLE_BACKWARD (charpos
);
303 c
= FETCH_CHAR_AS_MULTIBYTE (bytepos
);
305 if (! (code
== Scharquote
|| code
== Sescape
))
311 UPDATE_SYNTAX_TABLE (orig
);
315 /* Return the bytepos one character after BYTEPOS.
316 We assume that BYTEPOS is not at the end of the buffer. */
319 inc_bytepos (EMACS_INT bytepos
)
321 if (NILP (current_buffer
->enable_multibyte_characters
))
328 /* Return the bytepos one character before BYTEPOS.
329 We assume that BYTEPOS is not at the start of the buffer. */
332 dec_bytepos (EMACS_INT bytepos
)
334 if (NILP (current_buffer
->enable_multibyte_characters
))
341 /* Return a defun-start position before POS and not too far before.
342 It should be the last one before POS, or nearly the last.
344 When open_paren_in_column_0_is_defun_start is nonzero,
345 only the beginning of the buffer is treated as a defun-start.
347 We record the information about where the scan started
348 and what its result was, so that another call in the same area
349 can return the same value very quickly.
351 There is no promise at which position the global syntax data is
352 valid on return from the subroutine, so the caller should explicitly
353 update the global data. */
356 find_defun_start (EMACS_INT pos
, EMACS_INT pos_byte
)
358 EMACS_INT opoint
= PT
, opoint_byte
= PT_BYTE
;
360 if (!open_paren_in_column_0_is_defun_start
)
362 find_start_value_byte
= BEGV_BYTE
;
366 /* Use previous finding, if it's valid and applies to this inquiry. */
367 if (current_buffer
== find_start_buffer
368 /* Reuse the defun-start even if POS is a little farther on.
369 POS might be in the next defun, but that's ok.
370 Our value may not be the best possible, but will still be usable. */
371 && pos
<= find_start_pos
+ 1000
372 && pos
>= find_start_value
373 && BEGV
== find_start_begv
374 && MODIFF
== find_start_modiff
)
375 return find_start_value
;
377 /* Back up to start of line. */
378 scan_newline (pos
, pos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
380 /* We optimize syntax-table lookup for rare updates. Thus we accept
381 only those `^\s(' which are good in global _and_ text-property
383 SETUP_BUFFER_SYNTAX_TABLE ();
388 /* Open-paren at start of line means we may have found our
390 c
= FETCH_CHAR_AS_MULTIBYTE (PT_BYTE
);
391 if (SYNTAX (c
) == Sopen
)
393 SETUP_SYNTAX_TABLE (PT
+ 1, -1); /* Try again... */
394 c
= FETCH_CHAR_AS_MULTIBYTE (PT_BYTE
);
395 if (SYNTAX (c
) == Sopen
)
397 /* Now fallback to the default value. */
398 SETUP_BUFFER_SYNTAX_TABLE ();
400 /* Move to beg of previous line. */
401 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -2, 1);
404 /* Record what we found, for the next try. */
405 find_start_value
= PT
;
406 find_start_value_byte
= PT_BYTE
;
407 find_start_buffer
= current_buffer
;
408 find_start_modiff
= MODIFF
;
409 find_start_begv
= BEGV
;
410 find_start_pos
= pos
;
412 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
414 return find_start_value
;
417 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
420 prev_char_comend_first (int pos
, int pos_byte
)
424 DEC_BOTH (pos
, pos_byte
);
425 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
426 c
= FETCH_CHAR (pos_byte
);
427 val
= SYNTAX_COMEND_FIRST (c
);
428 UPDATE_SYNTAX_TABLE_FORWARD (pos
+ 1);
432 /* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
435 * prev_char_comstart_first (pos, pos_byte)
440 * DEC_BOTH (pos, pos_byte);
441 * UPDATE_SYNTAX_TABLE_BACKWARD (pos);
442 * c = FETCH_CHAR (pos_byte);
443 * val = SYNTAX_COMSTART_FIRST (c);
444 * UPDATE_SYNTAX_TABLE_FORWARD (pos + 1);
448 /* Checks whether charpos FROM is at the end of a comment.
449 FROM_BYTE is the bytepos corresponding to FROM.
450 Do not move back before STOP.
452 Return a positive value if we find a comment ending at FROM/FROM_BYTE;
455 If successful, store the charpos of the comment's beginning
456 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
458 Global syntax data remains valid for backward search starting at
459 the returned value (or at FROM, if the search was not successful). */
462 back_comment (EMACS_INT from
, EMACS_INT from_byte
, EMACS_INT stop
, int comnested
, int comstyle
, EMACS_INT
*charpos_ptr
, EMACS_INT
*bytepos_ptr
)
464 /* Look back, counting the parity of string-quotes,
465 and recording the comment-starters seen.
466 When we reach a safe place, assume that's not in a string;
467 then step the main scan to the earliest comment-starter seen
468 an even number of string quotes away from the safe place.
470 OFROM[I] is position of the earliest comment-starter seen
471 which is I+2X quotes from the comment-end.
472 PARITY is current parity of quotes from the comment end. */
473 int string_style
= -1; /* Presumed outside of any string. */
474 int string_lossage
= 0;
475 /* Not a real lossage: indicates that we have passed a matching comment
476 starter plus a non-matching comment-ender, meaning that any matching
477 comment-starter we might see later could be a false positive (hidden
478 inside another comment).
479 Test case: { a (* b } c (* d *) */
480 int comment_lossage
= 0;
481 EMACS_INT comment_end
= from
;
482 EMACS_INT comment_end_byte
= from_byte
;
483 EMACS_INT comstart_pos
= 0;
484 EMACS_INT comstart_byte
;
485 /* Place where the containing defun starts,
486 or 0 if we didn't come across it yet. */
487 EMACS_INT defun_start
= 0;
488 EMACS_INT defun_start_byte
= 0;
489 register enum syntaxcode code
;
490 int nesting
= 1; /* current comment nesting */
494 /* FIXME: A }} comment-ender style leads to incorrect behavior
495 in the case of {{ c }}} because we ignore the last two chars which are
496 assumed to be comment-enders although they aren't. */
498 /* At beginning of range to scan, we're outside of strings;
499 that determines quote parity to the comment-end. */
502 int temp_byte
, prev_syntax
;
503 int com2start
, com2end
;
505 /* Move back and examine a character. */
506 DEC_BOTH (from
, from_byte
);
507 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
509 prev_syntax
= syntax
;
510 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
511 syntax
= SYNTAX_WITH_FLAGS (c
);
514 /* Check for 2-char comment markers. */
515 com2start
= (SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
516 && SYNTAX_FLAGS_COMSTART_SECOND (prev_syntax
)
517 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax
)
518 && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
)
519 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
);
520 com2end
= (SYNTAX_FLAGS_COMEND_FIRST (syntax
)
521 && SYNTAX_FLAGS_COMEND_SECOND (prev_syntax
));
523 /* Nasty cases with overlapping 2-char comment markers:
524 - snmp-mode: -- c -- foo -- c --
532 /* If a 2-char comment sequence partly overlaps with another,
533 we don't try to be clever. */
534 if (from
> stop
&& (com2end
|| com2start
))
536 int next
= from
, next_byte
= from_byte
, next_c
, next_syntax
;
537 DEC_BOTH (next
, next_byte
);
538 UPDATE_SYNTAX_TABLE_BACKWARD (next
);
539 next_c
= FETCH_CHAR_AS_MULTIBYTE (next_byte
);
540 next_syntax
= SYNTAX_WITH_FLAGS (next_c
);
541 if (((com2start
|| comnested
)
542 && SYNTAX_FLAGS_COMEND_SECOND (syntax
)
543 && SYNTAX_FLAGS_COMEND_FIRST (next_syntax
))
544 || ((com2end
|| comnested
)
545 && SYNTAX_FLAGS_COMSTART_SECOND (syntax
)
546 && comstyle
== SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
547 && SYNTAX_FLAGS_COMSTART_FIRST (next_syntax
)))
549 /* UPDATE_SYNTAX_TABLE_FORWARD (next + 1); */
552 if (com2start
&& comstart_pos
== 0)
553 /* We're looking at a comment starter. But it might be a comment
554 ender as well (see snmp-mode). The first time we see one, we
555 need to consider it as a comment starter,
556 and the subsequent times as a comment ender. */
559 /* Turn a 2-char comment sequences into the appropriate syntax. */
564 /* Ignore comment starters of a different style. */
565 else if (code
== Scomment
566 && (comstyle
!= SYNTAX_FLAGS_COMMENT_STYLE (syntax
)
567 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
) != comnested
))
570 /* Ignore escaped characters, except comment-enders. */
571 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
578 c
= (code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
);
580 /* Track parity of quotes. */
581 if (string_style
== -1)
582 /* Entering a string. */
584 else if (string_style
== c
)
585 /* Leaving the string. */
588 /* If we have two kinds of string delimiters.
589 There's no way to grok this scanning backwards. */
594 /* We've already checked that it is the relevant comstyle. */
595 if (string_style
!= -1 || comment_lossage
|| string_lossage
)
596 /* There are odd string quotes involved, so let's be careful.
597 Test case in Pascal: " { " a { " } */
602 /* Record best comment-starter so far. */
604 comstart_byte
= from_byte
;
606 else if (--nesting
<= 0)
607 /* nested comments have to be balanced, so we don't need to
608 keep looking for earlier ones. We use here the same (slightly
609 incorrect) reasoning as below: since it is followed by uniform
610 paired string quotes, this comment-start has to be outside of
611 strings, else the comment-end itself would be inside a string. */
616 if (SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == comstyle
617 && ((com2end
&& SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax
))
618 || SYNTAX_FLAGS_COMMENT_NESTED (syntax
)) == comnested
)
619 /* This is the same style of comment ender as ours. */
624 /* Anything before that can't count because it would match
625 this comment-ender rather than ours. */
626 from
= stop
; /* Break out of the loop. */
628 else if (comstart_pos
!= 0 || c
!= '\n')
629 /* We're mixing comment styles here, so we'd better be careful.
630 The (comstart_pos != 0 || c != '\n') check is not quite correct
631 (we should just always set comment_lossage), but removing it
632 would imply that any multiline comment in C would go through
633 lossage, which seems overkill.
634 The failure should only happen in the rare cases such as
640 /* Assume a defun-start point is outside of strings. */
641 if (open_paren_in_column_0_is_defun_start
643 || (temp_byte
= dec_bytepos (from_byte
),
644 FETCH_CHAR (temp_byte
) == '\n')))
647 defun_start_byte
= from_byte
;
648 from
= stop
; /* Break out of the loop. */
657 if (comstart_pos
== 0)
660 from_byte
= comment_end_byte
;
661 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
663 /* If comstart_pos is set and we get here (ie. didn't jump to `lossage'
664 or `done'), then we've found the beginning of the non-nested comment. */
665 else if (1) /* !comnested */
668 from_byte
= comstart_byte
;
669 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
673 struct lisp_parse_state state
;
675 /* We had two kinds of string delimiters mixed up
676 together. Decode this going forwards.
677 Scan fwd from a known safe place (beginning-of-defun)
678 to the one in question; this records where we
679 last passed a comment starter. */
680 /* If we did not already find the defun start, find it now. */
681 if (defun_start
== 0)
683 defun_start
= find_defun_start (comment_end
, comment_end_byte
);
684 defun_start_byte
= find_start_value_byte
;
688 scan_sexps_forward (&state
,
689 defun_start
, defun_start_byte
,
690 comment_end
, -10000, 0, Qnil
, 0);
691 defun_start
= comment_end
;
692 if (state
.incomment
== (comnested
? 1 : -1)
693 && state
.comstyle
== comstyle
)
694 from
= state
.comstr_start
;
699 /* If comment_end is inside some other comment, maybe ours
700 is nested, so we need to try again from within the
701 surrounding comment. Example: { a (* " *) */
703 /* FIXME: We should advance by one or two chars. */
704 defun_start
= state
.comstr_start
+ 2;
705 defun_start_byte
= CHAR_TO_BYTE (defun_start
);
708 } while (defun_start
< comment_end
);
710 from_byte
= CHAR_TO_BYTE (from
);
711 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
716 *bytepos_ptr
= from_byte
;
718 return (from
== comment_end
) ? -1 : from
;
721 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
722 doc
: /* Return t if OBJECT is a syntax table.
723 Currently, any char-table counts as a syntax table. */)
727 if (CHAR_TABLE_P (object
)
728 && EQ (XCHAR_TABLE (object
)->purpose
, Qsyntax_table
))
734 check_syntax_table (Lisp_Object obj
)
736 CHECK_TYPE (CHAR_TABLE_P (obj
) && EQ (XCHAR_TABLE (obj
)->purpose
, Qsyntax_table
),
737 Qsyntax_table_p
, obj
);
740 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
741 doc
: /* Return the current syntax table.
742 This is the one specified by the current buffer. */)
745 return current_buffer
->syntax_table
;
748 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
749 Sstandard_syntax_table
, 0, 0, 0,
750 doc
: /* Return the standard syntax table.
751 This is the one used for new buffers. */)
754 return Vstandard_syntax_table
;
757 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
758 doc
: /* Construct a new syntax table and return it.
759 It is a copy of the TABLE, which defaults to the standard syntax table. */)
766 check_syntax_table (table
);
768 table
= Vstandard_syntax_table
;
770 copy
= Fcopy_sequence (table
);
772 /* Only the standard syntax table should have a default element.
773 Other syntax tables should inherit from parents instead. */
774 XCHAR_TABLE (copy
)->defalt
= Qnil
;
776 /* Copied syntax tables should all have parents.
777 If we copied one with no parent, such as the standard syntax table,
778 use the standard syntax table as the copy's parent. */
779 if (NILP (XCHAR_TABLE (copy
)->parent
))
780 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
784 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
785 doc
: /* Select a new syntax table for the current buffer.
786 One argument, a syntax table. */)
791 check_syntax_table (table
);
792 current_buffer
->syntax_table
= table
;
793 /* Indicate that this buffer now has a specified syntax table. */
794 idx
= PER_BUFFER_VAR_IDX (syntax_table
);
795 SET_PER_BUFFER_VALUE_P (current_buffer
, idx
, 1);
799 /* Convert a letter which signifies a syntax code
800 into the code it signifies.
801 This is used by modify-syntax-entry, and other things. */
803 unsigned char syntax_spec_code
[0400] =
804 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
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 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
809 (char) Smath
, 0377, 0377, (char) Squote
,
810 (char) Sopen
, (char) Sclose
, 0377, 0377,
811 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
812 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
813 0377, 0377, 0377, 0377,
814 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
815 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
816 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
817 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
818 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
819 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
820 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
821 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
822 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
825 /* Indexed by syntax code, give the letter that describes it. */
827 char syntax_code_spec
[16] =
829 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
833 /* Indexed by syntax code, give the object (cons of syntax code and
834 nil) to be stored in syntax table. Since these objects can be
835 shared among syntax tables, we generate them in advance. By
836 sharing objects, the function `describe-syntax' can give a more
838 static Lisp_Object Vsyntax_code_object
;
841 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
842 doc
: /* Return the syntax code of CHARACTER, described by a character.
843 For example, if CHARACTER is a word constituent, the
844 character `w' (119) is returned.
845 The characters that correspond to various syntax codes
846 are listed in the documentation of `modify-syntax-entry'. */)
848 Lisp_Object character
;
851 CHECK_CHARACTER (character
);
852 char_int
= XINT (character
);
853 SETUP_BUFFER_SYNTAX_TABLE ();
854 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
857 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
858 doc
: /* Return the matching parenthesis of CHARACTER, or nil if none. */)
860 Lisp_Object character
;
863 CHECK_NUMBER (character
);
864 char_int
= XINT (character
);
865 SETUP_BUFFER_SYNTAX_TABLE ();
866 code
= SYNTAX (char_int
);
867 if (code
== Sopen
|| code
== Sclose
)
868 return SYNTAX_MATCH (char_int
);
872 DEFUN ("string-to-syntax", Fstring_to_syntax
, Sstring_to_syntax
, 1, 1, 0,
873 doc
: /* Convert a syntax specification STRING into syntax cell form.
874 STRING should be a string as it is allowed as argument of
875 `modify-syntax-entry'. Value is the equivalent cons cell
876 \(CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'
881 register const unsigned char *p
;
882 register enum syntaxcode code
;
886 CHECK_STRING (string
);
889 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
890 if (((int) code
& 0377) == 0377)
891 error ("Invalid syntax description letter: %c", p
[-1]);
893 if (code
== Sinherit
)
899 int character
= STRING_CHAR_AND_LENGTH (p
, len
);
900 XSETINT (match
, character
);
901 if (XFASTINT (match
) == ' ')
941 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
942 return XVECTOR (Vsyntax_code_object
)->contents
[val
];
944 /* Since we can't use a shared object, let's make a new one. */
945 return Fcons (make_number (val
), match
);
948 /* I really don't know why this is interactive
949 help-form should at least be made useful whilst reading the second arg. */
950 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
951 "cSet syntax for character: \nsSet syntax for %s to: ",
952 doc
: /* Set syntax for character CHAR according to string NEWENTRY.
953 The syntax is changed only for table SYNTAX-TABLE, which defaults to
954 the current buffer's syntax table.
955 CHAR may be a cons (MIN . MAX), in which case, syntaxes of all characters
956 in the range MIN to MAX are changed.
957 The first character of NEWENTRY should be one of the following:
958 Space or - whitespace syntax. w word constituent.
959 _ symbol constituent. . punctuation.
960 ( open-parenthesis. ) close-parenthesis.
961 " string quote. \\ escape.
962 $ paired delimiter. ' expression quote or prefix operator.
963 < comment starter. > comment ender.
964 / character-quote. @ inherit from `standard-syntax-table'.
965 | generic string fence. ! generic comment fence.
967 Only single-character comment start and end sequences are represented thus.
968 Two-character sequences are represented as described below.
969 The second character of NEWENTRY is the matching parenthesis,
970 used only if the first character is `(' or `)'.
971 Any additional characters are flags.
972 Defined flags are the characters 1, 2, 3, 4, b, p, and n.
973 1 means CHAR is the start of a two-char comment start sequence.
974 2 means CHAR is the second character of such a sequence.
975 3 means CHAR is the start of a two-char comment end sequence.
976 4 means CHAR is the second character of such a sequence.
978 There can be up to two orthogonal comment sequences. This is to support
979 language modes such as C++. By default, all comment sequences are of style
980 a, but you can set the comment sequence style to b (on the second character
981 of a comment-start, or the first character of a comment-end sequence) using
983 b means CHAR is part of comment sequence b.
984 n means CHAR is part of a nestable comment sequence.
986 p means CHAR is a prefix character for `backward-prefix-chars';
987 such characters are treated as whitespace when they occur
989 usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE) */)
990 (c
, newentry
, syntax_table
)
991 Lisp_Object c
, newentry
, syntax_table
;
995 CHECK_CHARACTER_CAR (c
);
996 CHECK_CHARACTER_CDR (c
);
1001 if (NILP (syntax_table
))
1002 syntax_table
= current_buffer
->syntax_table
;
1004 check_syntax_table (syntax_table
);
1006 newentry
= Fstring_to_syntax (newentry
);
1008 SET_RAW_SYNTAX_ENTRY_RANGE (syntax_table
, c
, newentry
);
1010 SET_RAW_SYNTAX_ENTRY (syntax_table
, XINT (c
), newentry
);
1012 /* We clear the regexp cache, since character classes can now have
1013 different values from those in the compiled regexps.*/
1014 clear_regexp_cache ();
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 (register int from
, register int count
)
1180 register int beg
= BEGV
;
1181 register int end
= ZV
;
1182 register int from_byte
= CHAR_TO_BYTE (from
);
1183 register enum syntaxcode code
;
1185 Lisp_Object func
, script
, pos
;
1190 SETUP_SYNTAX_TABLE (from
, count
);
1201 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1202 ch0
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1203 code
= SYNTAX (ch0
);
1204 INC_BOTH (from
, from_byte
);
1205 if (words_include_escapes
1206 && (code
== Sescape
|| code
== Scharquote
))
1211 /* Now CH0 is a character which begins a word and FROM is the
1212 position of the next character. */
1213 func
= CHAR_TABLE_REF (Vfind_word_boundary_function_table
, ch0
);
1214 if (! NILP (Ffboundp (func
)))
1216 pos
= call2 (func
, make_number (from
- 1), make_number (end
));
1217 if (INTEGERP (pos
) && XINT (pos
) > from
)
1220 from_byte
= CHAR_TO_BYTE (from
);
1225 script
= CHAR_TABLE_REF (Vchar_script_table
, ch0
);
1228 if (from
== end
) break;
1229 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1230 ch1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1231 code
= SYNTAX (ch1
);
1233 && (! words_include_escapes
1234 || (code
!= Sescape
&& code
!= Scharquote
)))
1235 || word_boundary_p (ch0
, ch1
))
1237 INC_BOTH (from
, from_byte
);
1252 DEC_BOTH (from
, from_byte
);
1253 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1254 ch1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1255 code
= SYNTAX (ch1
);
1256 if (words_include_escapes
1257 && (code
== Sescape
|| code
== Scharquote
))
1262 /* Now CH1 is a character which ends a word and FROM is the
1264 func
= CHAR_TABLE_REF (Vfind_word_boundary_function_table
, ch1
);
1265 if (! NILP (Ffboundp (func
)))
1267 pos
= call2 (func
, make_number (from
), make_number (beg
));
1268 if (INTEGERP (pos
) && XINT (pos
) < from
)
1271 from_byte
= CHAR_TO_BYTE (from
);
1276 script
= CHAR_TABLE_REF (Vchar_script_table
, ch1
);
1281 DEC_BOTH (from
, from_byte
);
1282 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1283 ch0
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
1284 code
= SYNTAX (ch0
);
1286 && (! words_include_escapes
1287 || (code
!= Sescape
&& code
!= Scharquote
)))
1288 || word_boundary_p (ch0
, ch1
))
1290 INC_BOTH (from
, from_byte
);
1304 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 0, 1, "^p",
1305 doc
: /* Move point forward ARG words (backward if ARG is negative).
1307 If an edge of the buffer or a field boundary is reached, point is left there
1308 and the function returns nil. Field boundaries are not noticed if
1309 `inhibit-field-text-motion' is non-nil. */)
1317 XSETFASTINT (arg
, 1);
1321 val
= orig_val
= scan_words (PT
, XINT (arg
));
1323 val
= XINT (arg
) > 0 ? ZV
: BEGV
;
1325 /* Avoid jumping out of an input field. */
1326 tmp
= Fconstrain_to_field (make_number (val
), make_number (PT
),
1328 val
= XFASTINT (tmp
);
1331 return val
== orig_val
? Qt
: Qnil
;
1334 Lisp_Object
skip_chars ();
1336 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1337 doc
: /* Move point forward, stopping before a char not in STRING, or at pos LIM.
1338 STRING is like the inside of a `[...]' in a regular expression
1339 except that `]' is never special and `\\' quotes `^', `-' or `\\'
1340 (but not at the end of a range; quoting is never needed there).
1341 Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
1342 With arg "^a-zA-Z", skips nonletters stopping before first letter.
1343 Char classes, e.g. `[:alpha:]', are supported.
1345 Returns the distance traveled, either zero or positive. */)
1347 Lisp_Object string
, lim
;
1349 return skip_chars (1, string
, lim
, 1);
1352 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1353 doc
: /* Move point backward, stopping after a char not in STRING, or at pos LIM.
1354 See `skip-chars-forward' for details.
1355 Returns the distance traveled, either zero or negative. */)
1357 Lisp_Object string
, lim
;
1359 return skip_chars (0, string
, lim
, 1);
1362 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1363 doc
: /* Move point forward across chars in specified syntax classes.
1364 SYNTAX is a string of syntax code characters.
1365 Stop before a char whose syntax is not in SYNTAX, or at position LIM.
1366 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1367 This function returns the distance traveled, either zero or positive. */)
1369 Lisp_Object syntax
, lim
;
1371 return skip_syntaxes (1, syntax
, lim
);
1374 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1375 doc
: /* Move point backward across chars in specified syntax classes.
1376 SYNTAX is a string of syntax code characters.
1377 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
1378 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
1379 This function returns the distance traveled, either zero or negative. */)
1381 Lisp_Object syntax
, lim
;
1383 return skip_syntaxes (0, syntax
, lim
);
1387 skip_chars (int forwardp
, Lisp_Object string
, Lisp_Object lim
, int handle_iso_classes
)
1389 register unsigned int c
;
1390 unsigned char fastmap
[0400];
1391 /* Store the ranges of non-ASCII characters. */
1393 int n_char_ranges
= 0;
1395 register int i
, i_byte
;
1396 /* Set to 1 if the current buffer is multibyte and the region
1397 contains non-ASCII chars. */
1399 /* Set to 1 if STRING is multibyte and it contains non-ASCII
1401 int string_multibyte
;
1403 const unsigned char *str
;
1405 Lisp_Object iso_classes
;
1407 CHECK_STRING (string
);
1411 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1413 CHECK_NUMBER_COERCE_MARKER (lim
);
1415 /* In any case, don't allow scan outside bounds of buffer. */
1416 if (XINT (lim
) > ZV
)
1417 XSETFASTINT (lim
, ZV
);
1418 if (XINT (lim
) < BEGV
)
1419 XSETFASTINT (lim
, BEGV
);
1421 multibyte
= (!NILP (current_buffer
->enable_multibyte_characters
)
1422 && (XINT (lim
) - PT
!= CHAR_TO_BYTE (XINT (lim
)) - PT_BYTE
));
1423 string_multibyte
= SBYTES (string
) > SCHARS (string
);
1425 bzero (fastmap
, sizeof fastmap
);
1427 str
= SDATA (string
);
1428 size_byte
= SBYTES (string
);
1431 if (i_byte
< size_byte
1432 && SREF (string
, 0) == '^')
1434 negate
= 1; i_byte
++;
1437 /* Find the characters specified and set their elements of fastmap.
1438 Handle backslashes and ranges specially.
1440 If STRING contains non-ASCII characters, setup char_ranges for
1441 them and use fastmap only for their leading codes. */
1443 if (! string_multibyte
)
1445 int string_has_eight_bit
= 0;
1447 /* At first setup fastmap. */
1448 while (i_byte
< size_byte
)
1452 if (handle_iso_classes
&& c
== '['
1453 && i_byte
< size_byte
1454 && str
[i_byte
] == ':')
1456 const unsigned char *class_beg
= str
+ i_byte
+ 1;
1457 const unsigned char *class_end
= class_beg
;
1458 const unsigned char *class_limit
= str
+ size_byte
- 2;
1459 /* Leave room for the null. */
1460 unsigned char class_name
[CHAR_CLASS_MAX_LENGTH
+ 1];
1463 if (class_limit
- class_beg
> CHAR_CLASS_MAX_LENGTH
)
1464 class_limit
= class_beg
+ CHAR_CLASS_MAX_LENGTH
;
1466 while (class_end
< class_limit
1467 && *class_end
>= 'a' && *class_end
<= 'z')
1470 if (class_end
== class_beg
1471 || *class_end
!= ':' || class_end
[1] != ']')
1472 goto not_a_class_name
;
1474 bcopy (class_beg
, class_name
, class_end
- class_beg
);
1475 class_name
[class_end
- class_beg
] = 0;
1477 cc
= re_wctype (class_name
);
1479 error ("Invalid ISO C character class");
1481 iso_classes
= Fcons (make_number (cc
), iso_classes
);
1483 i_byte
= class_end
+ 2 - str
;
1490 if (i_byte
== size_byte
)
1495 /* Treat `-' as range character only if another character
1497 if (i_byte
+ 1 < size_byte
1498 && str
[i_byte
] == '-')
1502 /* Skip over the dash. */
1505 /* Get the end of the range. */
1508 && i_byte
< size_byte
)
1515 if (! ASCII_CHAR_P (c2
))
1516 string_has_eight_bit
= 1;
1522 if (! ASCII_CHAR_P (c
))
1523 string_has_eight_bit
= 1;
1527 /* If the current range is multibyte and STRING contains
1528 eight-bit chars, arrange fastmap and setup char_ranges for
1529 the corresponding multibyte chars. */
1530 if (multibyte
&& string_has_eight_bit
)
1532 unsigned char fastmap2
[0400];
1533 int range_start_byte
, range_start_char
;
1535 bcopy (fastmap2
+ 0200, fastmap
+ 0200, 0200);
1536 bzero (fastmap
+ 0200, 0200);
1537 /* We are sure that this loop stops. */
1538 for (i
= 0200; ! fastmap2
[i
]; i
++);
1539 c
= BYTE8_TO_CHAR (i
);
1540 fastmap
[CHAR_LEADING_CODE (c
)] = 1;
1541 range_start_byte
= i
;
1542 range_start_char
= c
;
1543 char_ranges
= (int *) alloca (sizeof (int) * 128 * 2);
1544 for (i
= 129; i
< 0400; i
++)
1546 c
= BYTE8_TO_CHAR (i
);
1547 fastmap
[CHAR_LEADING_CODE (c
)] = 1;
1548 if (i
- range_start_byte
!= c
- range_start_char
)
1550 char_ranges
[n_char_ranges
++] = range_start_char
;
1551 char_ranges
[n_char_ranges
++] = ((i
- 1 - range_start_byte
)
1552 + range_start_char
);
1553 range_start_byte
= i
;
1554 range_start_char
= c
;
1557 char_ranges
[n_char_ranges
++] = range_start_char
;
1558 char_ranges
[n_char_ranges
++] = ((i
- 1 - range_start_byte
)
1559 + range_start_char
);
1562 else /* STRING is multibyte */
1564 char_ranges
= (int *) alloca (sizeof (int) * SCHARS (string
) * 2);
1566 while (i_byte
< size_byte
)
1568 unsigned char leading_code
;
1570 leading_code
= str
[i_byte
];
1571 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
);
1574 if (handle_iso_classes
&& c
== '['
1575 && i_byte
< size_byte
1576 && STRING_CHAR (str
+ i_byte
) == ':')
1578 const unsigned char *class_beg
= str
+ i_byte
+ 1;
1579 const unsigned char *class_end
= class_beg
;
1580 const unsigned char *class_limit
= str
+ size_byte
- 2;
1581 /* Leave room for the null. */
1582 unsigned char class_name
[CHAR_CLASS_MAX_LENGTH
+ 1];
1585 if (class_limit
- class_beg
> CHAR_CLASS_MAX_LENGTH
)
1586 class_limit
= class_beg
+ CHAR_CLASS_MAX_LENGTH
;
1588 while (class_end
< class_limit
1589 && *class_end
>= 'a' && *class_end
<= 'z')
1592 if (class_end
== class_beg
1593 || *class_end
!= ':' || class_end
[1] != ']')
1594 goto not_a_class_name_multibyte
;
1596 bcopy (class_beg
, class_name
, class_end
- class_beg
);
1597 class_name
[class_end
- class_beg
] = 0;
1599 cc
= re_wctype (class_name
);
1601 error ("Invalid ISO C character class");
1603 iso_classes
= Fcons (make_number (cc
), iso_classes
);
1605 i_byte
= class_end
+ 2 - str
;
1609 not_a_class_name_multibyte
:
1612 if (i_byte
== size_byte
)
1615 leading_code
= str
[i_byte
];
1616 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
);
1619 /* Treat `-' as range character only if another character
1621 if (i_byte
+ 1 < size_byte
1622 && str
[i_byte
] == '-')
1625 unsigned char leading_code2
;
1627 /* Skip over the dash. */
1630 /* Get the end of the range. */
1631 leading_code2
= str
[i_byte
];
1632 c2
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
);
1636 && i_byte
< size_byte
)
1638 leading_code2
= str
[i_byte
];
1639 c2
=STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
);
1645 if (ASCII_CHAR_P (c
))
1647 while (c
<= c2
&& c
< 0x80)
1649 leading_code
= CHAR_LEADING_CODE (c
);
1651 if (! ASCII_CHAR_P (c
))
1653 while (leading_code
<= leading_code2
)
1654 fastmap
[leading_code
++] = 1;
1657 char_ranges
[n_char_ranges
++] = c
;
1658 char_ranges
[n_char_ranges
++] = c2
;
1664 if (ASCII_CHAR_P (c
))
1668 fastmap
[leading_code
] = 1;
1669 char_ranges
[n_char_ranges
++] = c
;
1670 char_ranges
[n_char_ranges
++] = c
;
1675 /* If the current range is unibyte and STRING contains non-ASCII
1676 chars, arrange fastmap for the corresponding unibyte
1679 if (! multibyte
&& n_char_ranges
> 0)
1681 bzero (fastmap
+ 0200, 0200);
1682 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1684 int c1
= char_ranges
[i
];
1685 int c2
= char_ranges
[i
+ 1];
1687 for (; c1
<= c2
; c1
++)
1689 int b
= CHAR_TO_BYTE_SAFE (c1
);
1697 /* If ^ was the first character, complement the fastmap. */
1701 for (i
= 0; i
< sizeof fastmap
; i
++)
1705 for (i
= 0; i
< 0200; i
++)
1707 /* All non-ASCII chars possibly match. */
1708 for (; i
< sizeof fastmap
; i
++)
1714 int start_point
= PT
;
1716 int pos_byte
= PT_BYTE
;
1717 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
1721 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
1722 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
1726 endp
= CHAR_POS_ADDR (XINT (lim
));
1727 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
1731 /* This code may look up syntax tables using macros that rely on the
1732 gl_state object. To make sure this object is not out of date,
1733 let's initialize it manually.
1734 We ignore syntax-table text-properties for now, since that's
1735 what we've done in the past. */
1736 SETUP_BUFFER_SYNTAX_TABLE ();
1751 c
= STRING_CHAR_AND_LENGTH (p
, nbytes
);
1752 if (! NILP (iso_classes
) && in_classes (c
, iso_classes
))
1762 if (! ASCII_CHAR_P (c
))
1764 /* As we are looking at a multibyte character, we
1765 must look up the character in the table
1766 CHAR_RANGES. If there's no data in the table,
1767 that character is not what we want to skip. */
1769 /* The following code do the right thing even if
1770 n_char_ranges is zero (i.e. no data in
1772 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1773 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1775 if (!(negate
^ (i
< n_char_ranges
)))
1779 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
1792 if (!NILP (iso_classes
) && in_classes (*p
, iso_classes
))
1797 goto fwd_unibyte_ok
;
1803 p
++, pos
++, pos_byte
++;
1811 unsigned char *prev_p
;
1821 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
1822 c
= STRING_CHAR (p
);
1824 if (! NILP (iso_classes
) && in_classes (c
, iso_classes
))
1834 if (! ASCII_CHAR_P (c
))
1836 /* See the comment in the previous similar code. */
1837 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1838 if (c
>= char_ranges
[i
] && c
<= char_ranges
[i
+ 1])
1840 if (!(negate
^ (i
< n_char_ranges
)))
1844 pos
--, pos_byte
-= prev_p
- p
;
1857 if (! NILP (iso_classes
) && in_classes (p
[-1], iso_classes
))
1862 goto back_unibyte_ok
;
1865 if (!fastmap
[p
[-1]])
1868 p
--, pos
--, pos_byte
--;
1872 SET_PT_BOTH (pos
, pos_byte
);
1875 return make_number (PT
- start_point
);
1881 skip_syntaxes (int forwardp
, Lisp_Object string
, Lisp_Object lim
)
1883 register unsigned int c
;
1884 unsigned char fastmap
[0400];
1886 register int i
, i_byte
;
1891 CHECK_STRING (string
);
1894 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1896 CHECK_NUMBER_COERCE_MARKER (lim
);
1898 /* In any case, don't allow scan outside bounds of buffer. */
1899 if (XINT (lim
) > ZV
)
1900 XSETFASTINT (lim
, ZV
);
1901 if (XINT (lim
) < BEGV
)
1902 XSETFASTINT (lim
, BEGV
);
1904 if (forwardp
? (PT
>= XFASTINT (lim
)) : (PT
<= XFASTINT (lim
)))
1905 return make_number (0);
1907 multibyte
= (!NILP (current_buffer
->enable_multibyte_characters
)
1908 && (XINT (lim
) - PT
!= CHAR_TO_BYTE (XINT (lim
)) - PT_BYTE
));
1910 bzero (fastmap
, sizeof fastmap
);
1912 if (SBYTES (string
) > SCHARS (string
))
1913 /* As this is very rare case (syntax spec is ASCII only), don't
1914 consider efficiency. */
1915 string
= string_make_unibyte (string
);
1917 str
= SDATA (string
);
1918 size_byte
= SBYTES (string
);
1921 if (i_byte
< size_byte
1922 && SREF (string
, 0) == '^')
1924 negate
= 1; i_byte
++;
1927 /* Find the syntaxes specified and set their elements of fastmap. */
1929 while (i_byte
< size_byte
)
1932 fastmap
[syntax_spec_code
[c
]] = 1;
1935 /* If ^ was the first character, complement the fastmap. */
1937 for (i
= 0; i
< sizeof fastmap
; i
++)
1941 int start_point
= PT
;
1943 int pos_byte
= PT_BYTE
;
1944 unsigned char *p
= PT_ADDR
, *endp
, *stop
;
1948 endp
= (XINT (lim
) == GPT
) ? GPT_ADDR
: CHAR_POS_ADDR (XINT (lim
));
1949 stop
= (pos
< GPT
&& GPT
< XINT (lim
)) ? GPT_ADDR
: endp
;
1953 endp
= CHAR_POS_ADDR (XINT (lim
));
1954 stop
= (pos
>= GPT
&& GPT
> XINT (lim
)) ? GAP_END_ADDR
: endp
;
1958 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1974 c
= STRING_CHAR_AND_LENGTH (p
, nbytes
);
1975 if (! fastmap
[(int) SYNTAX (c
)])
1977 p
+= nbytes
, pos
++, pos_byte
+= nbytes
;
1978 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1992 if (! fastmap
[(int) SYNTAX (*p
)])
1994 p
++, pos
++, pos_byte
++;
1995 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
2005 unsigned char *prev_p
;
2014 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
2016 while (--p
>= stop
&& ! CHAR_HEAD_P (*p
));
2017 c
= STRING_CHAR (p
);
2018 if (! fastmap
[(int) SYNTAX (c
)])
2020 pos
--, pos_byte
-= prev_p
- p
;
2034 UPDATE_SYNTAX_TABLE_BACKWARD (pos
- 1);
2035 if (! fastmap
[(int) SYNTAX (p
[-1])])
2037 p
--, pos
--, pos_byte
--;
2042 SET_PT_BOTH (pos
, pos_byte
);
2045 return make_number (PT
- start_point
);
2049 /* Return 1 if character C belongs to one of the ISO classes
2050 in the list ISO_CLASSES. Each class is represented by an
2051 integer which is its type according to re_wctype. */
2054 in_classes (int c
, Lisp_Object iso_classes
)
2058 while (CONSP (iso_classes
))
2061 elt
= XCAR (iso_classes
);
2062 iso_classes
= XCDR (iso_classes
);
2064 if (re_iswctype (c
, XFASTINT (elt
)))
2071 /* Jump over a comment, assuming we are at the beginning of one.
2072 FROM is the current position.
2073 FROM_BYTE is the bytepos corresponding to FROM.
2074 Do not move past STOP (a charpos).
2075 The comment over which we have to jump is of style STYLE
2076 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
2077 NESTING should be positive to indicate the nesting at the beginning
2078 for nested comments and should be zero or negative else.
2079 ST_COMMENT_STYLE cannot be nested.
2080 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
2081 (or 0 If the search cannot start in the middle of a two-character).
2083 If successful, return 1 and store the charpos of the comment's end
2084 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
2085 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
2086 corresponding bytepos into *BYTEPOS_PTR and the current nesting
2087 (as defined for state.incomment) in *INCOMMENT_PTR.
2089 The comment end is the last character of the comment rather than the
2090 character just after the comment.
2092 Global syntax data is assumed to initially be valid for FROM and
2093 remains valid for forward search starting at the returned position. */
2096 forw_comment (from
, from_byte
, stop
, nesting
, style
, prev_syntax
,
2097 charpos_ptr
, bytepos_ptr
, incomment_ptr
)
2098 EMACS_INT from
, from_byte
, stop
;
2099 int nesting
, style
, prev_syntax
;
2100 EMACS_INT
*charpos_ptr
, *bytepos_ptr
;
2104 register enum syntaxcode code
;
2105 register int syntax
;
2107 if (nesting
<= 0) nesting
= -1;
2109 /* Enter the loop in the middle so that we find
2110 a 2-char comment ender if we start in the middle of it. */
2111 syntax
= prev_syntax
;
2112 if (syntax
!= 0) goto forw_incomment
;
2118 *incomment_ptr
= nesting
;
2119 *charpos_ptr
= from
;
2120 *bytepos_ptr
= from_byte
;
2123 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2124 syntax
= SYNTAX_WITH_FLAGS (c
);
2125 code
= syntax
& 0xff;
2126 if (code
== Sendcomment
2127 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
2128 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ?
2129 (nesting
> 0 && --nesting
== 0) : nesting
< 0))
2130 /* we have encountered a comment end of the same style
2131 as the comment sequence which began this comment
2134 if (code
== Scomment_fence
2135 && style
== ST_COMMENT_STYLE
)
2136 /* we have encountered a comment end of the same style
2137 as the comment sequence which began this comment
2142 && SYNTAX_FLAGS_COMMENT_NESTED (syntax
)
2143 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
)
2144 /* we have encountered a nested comment of the same style
2145 as the comment sequence which began this comment section */
2147 INC_BOTH (from
, from_byte
);
2148 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2151 if (from
< stop
&& SYNTAX_FLAGS_COMEND_FIRST (syntax
)
2152 && SYNTAX_FLAGS_COMMENT_STYLE (syntax
) == style
2153 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2154 SYNTAX_COMEND_SECOND (c1
))
2155 && ((SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
2156 SYNTAX_COMMENT_NESTED (c1
)) ? nesting
> 0 : nesting
< 0))
2159 /* we have encountered a comment end of the same style
2160 as the comment sequence which began this comment
2165 INC_BOTH (from
, from_byte
);
2166 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2171 && SYNTAX_FLAGS_COMSTART_FIRST (syntax
)
2172 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2173 SYNTAX_COMMENT_STYLE (c1
) == style
2174 && SYNTAX_COMSTART_SECOND (c1
))
2175 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax
) ||
2176 SYNTAX_COMMENT_NESTED (c1
)))
2177 /* we have encountered a nested comment of the same style
2178 as the comment sequence which began this comment
2181 INC_BOTH (from
, from_byte
);
2182 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2186 *charpos_ptr
= from
;
2187 *bytepos_ptr
= from_byte
;
2191 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
2193 Move forward across up to COUNT comments. If COUNT is negative, move backward.
2194 Stop scanning if we find something other than a comment or whitespace.
2195 Set point to where scanning stops.
2196 If COUNT comments are found as expected, with nothing except whitespace
2197 between them, return t; otherwise return nil. */)
2201 register EMACS_INT from
;
2202 EMACS_INT from_byte
;
2203 register EMACS_INT stop
;
2205 register enum syntaxcode code
;
2206 int comstyle
= 0; /* style of comment encountered */
2207 int comnested
= 0; /* whether the comment is nestable or not */
2210 EMACS_INT out_charpos
, out_bytepos
;
2213 CHECK_NUMBER (count
);
2214 count1
= XINT (count
);
2215 stop
= count1
> 0 ? ZV
: BEGV
;
2221 from_byte
= PT_BYTE
;
2223 SETUP_SYNTAX_TABLE (from
, count1
);
2232 SET_PT_BOTH (from
, from_byte
);
2236 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2238 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2239 comnested
= SYNTAX_COMMENT_NESTED (c
);
2240 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2241 INC_BOTH (from
, from_byte
);
2242 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2243 if (from
< stop
&& comstart_first
2244 && (c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2245 SYNTAX_COMSTART_SECOND (c1
)))
2247 /* We have encountered a comment start sequence and we
2248 are ignoring all text inside comments. We must record
2249 the comment style this sequence begins so that later,
2250 only a comment end of the same style actually ends
2251 the comment section. */
2253 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2254 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2255 INC_BOTH (from
, from_byte
);
2256 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2259 while (code
== Swhitespace
|| (code
== Sendcomment
&& c
== '\n'));
2261 if (code
== Scomment_fence
)
2262 comstyle
= ST_COMMENT_STYLE
;
2263 else if (code
!= Scomment
)
2266 DEC_BOTH (from
, from_byte
);
2267 SET_PT_BOTH (from
, from_byte
);
2270 /* We're at the start of a comment. */
2271 found
= forw_comment (from
, from_byte
, stop
, comnested
, comstyle
, 0,
2272 &out_charpos
, &out_bytepos
, &dummy
);
2273 from
= out_charpos
; from_byte
= out_bytepos
;
2277 SET_PT_BOTH (from
, from_byte
);
2280 INC_BOTH (from
, from_byte
);
2281 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2282 /* We have skipped one comment. */
2294 SET_PT_BOTH (BEGV
, BEGV_BYTE
);
2299 DEC_BOTH (from
, from_byte
);
2300 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
2301 quoted
= char_quoted (from
, from_byte
);
2302 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2305 comnested
= SYNTAX_COMMENT_NESTED (c
);
2306 if (code
== Sendcomment
)
2307 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2308 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2309 && prev_char_comend_first (from
, from_byte
)
2310 && !char_quoted (from
- 1, dec_bytepos (from_byte
)))
2312 /* We must record the comment style encountered so that
2313 later, we can match only the proper comment begin
2314 sequence of the same style. */
2315 DEC_BOTH (from
, from_byte
);
2317 /* Calling char_quoted, above, set up global syntax position
2318 at the new value of FROM. */
2319 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2320 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2321 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2324 if (code
== Scomment_fence
)
2326 /* Skip until first preceding unquoted comment_fence. */
2327 int found
= 0, ini
= from
, ini_byte
= from_byte
;
2331 DEC_BOTH (from
, from_byte
);
2332 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2333 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2334 if (SYNTAX (c
) == Scomment_fence
2335 && !char_quoted (from
, from_byte
))
2340 else if (from
== stop
)
2345 from
= ini
; /* Set point to ini + 1. */
2346 from_byte
= ini_byte
;
2350 /* We have skipped one comment. */
2353 else if (code
== Sendcomment
)
2355 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2356 &out_charpos
, &out_bytepos
);
2360 /* This end-of-line is not an end-of-comment.
2361 Treat it like a whitespace.
2362 CC-mode (and maybe others) relies on this behavior. */
2366 /* Failure: we should go back to the end of this
2367 not-quite-endcomment. */
2368 if (SYNTAX(c
) != code
)
2369 /* It was a two-char Sendcomment. */
2370 INC_BOTH (from
, from_byte
);
2376 /* We have skipped one comment. */
2377 from
= out_charpos
, from_byte
= out_bytepos
;
2381 else if (code
!= Swhitespace
|| quoted
)
2385 INC_BOTH (from
, from_byte
);
2386 SET_PT_BOTH (from
, from_byte
);
2394 SET_PT_BOTH (from
, from_byte
);
2399 /* Return syntax code of character C if C is an ASCII character
2400 or `multibyte_symbol_p' is zero. Otherwise, return Ssymbol. */
2402 #define SYNTAX_WITH_MULTIBYTE_CHECK(c) \
2403 ((ASCII_CHAR_P (c) || !multibyte_symbol_p) \
2404 ? SYNTAX (c) : Ssymbol)
2407 scan_lists (register EMACS_INT from
, EMACS_INT count
, EMACS_INT depth
, int sexpflag
)
2410 register EMACS_INT stop
= count
> 0 ? ZV
: BEGV
;
2415 register enum syntaxcode code
, temp_code
;
2416 int min_depth
= depth
; /* Err out if depth gets less than this. */
2417 int comstyle
= 0; /* style of comment encountered */
2418 int comnested
= 0; /* whether the comment is nestable or not */
2420 EMACS_INT last_good
= from
;
2422 EMACS_INT from_byte
;
2423 EMACS_INT out_bytepos
, out_charpos
;
2425 int multibyte_symbol_p
= sexpflag
&& multibyte_syntax_as_symbol
;
2427 if (depth
> 0) min_depth
= 0;
2429 if (from
> ZV
) from
= ZV
;
2430 if (from
< BEGV
) from
= BEGV
;
2432 from_byte
= CHAR_TO_BYTE (from
);
2437 SETUP_SYNTAX_TABLE (from
, count
);
2442 int comstart_first
, prefix
;
2443 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2444 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2445 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2446 comstart_first
= SYNTAX_COMSTART_FIRST (c
);
2447 comnested
= SYNTAX_COMMENT_NESTED (c
);
2448 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2449 prefix
= SYNTAX_PREFIX (c
);
2450 if (depth
== min_depth
)
2452 INC_BOTH (from
, from_byte
);
2453 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2454 if (from
< stop
&& comstart_first
2455 && (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2456 SYNTAX_COMSTART_SECOND (c
))
2457 && parse_sexp_ignore_comments
)
2459 /* we have encountered a comment start sequence and we
2460 are ignoring all text inside comments. We must record
2461 the comment style this sequence begins so that later,
2462 only a comment end of the same style actually ends
2463 the comment section */
2465 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2466 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2467 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2468 INC_BOTH (from
, from_byte
);
2469 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2475 switch (SWITCH_ENUM_CAST (code
))
2481 INC_BOTH (from
, from_byte
);
2482 /* treat following character as a word constituent */
2485 if (depth
|| !sexpflag
) break;
2486 /* This word counts as a sexp; return at end of it. */
2489 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2491 /* Some compilers can't handle this inside the switch. */
2492 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2493 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2498 INC_BOTH (from
, from_byte
);
2509 INC_BOTH (from
, from_byte
);
2513 case Scomment_fence
:
2514 comstyle
= ST_COMMENT_STYLE
;
2517 if (!parse_sexp_ignore_comments
) break;
2518 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2519 found
= forw_comment (from
, from_byte
, stop
,
2520 comnested
, comstyle
, 0,
2521 &out_charpos
, &out_bytepos
, &dummy
);
2522 from
= out_charpos
, from_byte
= out_bytepos
;
2529 INC_BOTH (from
, from_byte
);
2530 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2536 if (from
!= stop
&& c
== FETCH_CHAR_AS_MULTIBYTE (from_byte
))
2538 INC_BOTH (from
, from_byte
);
2548 if (!++depth
) goto done
;
2553 if (!--depth
) goto done
;
2554 if (depth
< min_depth
)
2555 xsignal3 (Qscan_error
,
2556 build_string ("Containing expression ends prematurely"),
2557 make_number (last_good
), make_number (from
));
2562 temp_pos
= dec_bytepos (from_byte
);
2563 stringterm
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2568 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2569 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2572 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2573 : SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring_fence
)
2576 /* Some compilers can't handle this inside the switch. */
2577 temp
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2582 INC_BOTH (from
, from_byte
);
2584 INC_BOTH (from
, from_byte
);
2586 INC_BOTH (from
, from_byte
);
2587 if (!depth
&& sexpflag
) goto done
;
2590 /* Ignore whitespace, punctuation, quote, endcomment. */
2595 /* Reached end of buffer. Error if within object, return nil if between */
2602 /* End of object reached */
2611 DEC_BOTH (from
, from_byte
);
2612 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2613 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2614 code
= SYNTAX_WITH_MULTIBYTE_CHECK (c
);
2615 if (depth
== min_depth
)
2618 comnested
= SYNTAX_COMMENT_NESTED (c
);
2619 if (code
== Sendcomment
)
2620 comstyle
= SYNTAX_COMMENT_STYLE (c
);
2621 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2622 && prev_char_comend_first (from
, from_byte
)
2623 && parse_sexp_ignore_comments
)
2625 /* We must record the comment style encountered so that
2626 later, we can match only the proper comment begin
2627 sequence of the same style. */
2628 DEC_BOTH (from
, from_byte
);
2629 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2631 c1
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2632 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
2633 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
2636 /* Quoting turns anything except a comment-ender
2637 into a word character. Note that this cannot be true
2638 if we decremented FROM in the if-statement above. */
2639 if (code
!= Sendcomment
&& char_quoted (from
, from_byte
))
2641 DEC_BOTH (from
, from_byte
);
2644 else if (SYNTAX_PREFIX (c
))
2647 switch (SWITCH_ENUM_CAST (code
))
2653 if (depth
|| !sexpflag
) break;
2654 /* This word counts as a sexp; count object finished
2655 after passing it. */
2658 temp_pos
= from_byte
;
2659 if (! NILP (current_buffer
->enable_multibyte_characters
))
2663 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2664 c1
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2665 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2666 /* Don't allow comment-end to be quoted. */
2667 if (temp_code
== Sendcomment
)
2669 quoted
= char_quoted (from
- 1, temp_pos
);
2672 DEC_BOTH (from
, from_byte
);
2673 temp_pos
= dec_bytepos (temp_pos
);
2674 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2676 c1
= FETCH_CHAR_AS_MULTIBYTE (temp_pos
);
2677 temp_code
= SYNTAX_WITH_MULTIBYTE_CHECK (c1
);
2678 if (! (quoted
|| temp_code
== Sword
2679 || temp_code
== Ssymbol
2680 || temp_code
== Squote
))
2682 DEC_BOTH (from
, from_byte
);
2689 temp_pos
= dec_bytepos (from_byte
);
2690 UPDATE_SYNTAX_TABLE_BACKWARD (from
- 1);
2691 if (from
!= stop
&& c
== FETCH_CHAR_AS_MULTIBYTE (temp_pos
))
2692 DEC_BOTH (from
, from_byte
);
2701 if (!++depth
) goto done2
;
2706 if (!--depth
) goto done2
;
2707 if (depth
< min_depth
)
2708 xsignal3 (Qscan_error
,
2709 build_string ("Containing expression ends prematurely"),
2710 make_number (last_good
), make_number (from
));
2714 if (!parse_sexp_ignore_comments
)
2716 found
= back_comment (from
, from_byte
, stop
, comnested
, comstyle
,
2717 &out_charpos
, &out_bytepos
);
2718 /* FIXME: if found == -1, then it really wasn't a comment-end.
2719 For single-char Sendcomment, we can't do much about it apart
2720 from skipping the char.
2721 For 2-char endcomments, we could try again, taking both
2722 chars as separate entities, but it's a lot of trouble
2723 for very little gain, so we don't bother either. -sm */
2725 from
= out_charpos
, from_byte
= out_bytepos
;
2728 case Scomment_fence
:
2734 DEC_BOTH (from
, from_byte
);
2735 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2736 if (!char_quoted (from
, from_byte
)
2737 && (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
),
2738 SYNTAX_WITH_MULTIBYTE_CHECK (c
) == code
))
2741 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2745 stringterm
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
2750 DEC_BOTH (from
, from_byte
);
2751 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2752 if (!char_quoted (from
, from_byte
)
2754 == (c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
)))
2755 && SYNTAX_WITH_MULTIBYTE_CHECK (c
) == Sstring
)
2758 if (!depth
&& sexpflag
) goto done2
;
2761 /* Ignore whitespace, punctuation, quote, endcomment. */
2766 /* Reached start of buffer. Error if within object, return nil if between */
2779 XSETFASTINT (val
, from
);
2783 xsignal3 (Qscan_error
,
2784 build_string ("Unbalanced parentheses"),
2785 make_number (last_good
), make_number (from
));
2788 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2789 doc
: /* Scan from character number FROM by COUNT lists.
2790 Returns the character number of the position thus found.
2792 If DEPTH is nonzero, paren depth begins counting from that value,
2793 only places where the depth in parentheses becomes zero
2794 are candidates for stopping; COUNT such places are counted.
2795 Thus, a positive value for DEPTH means go out levels.
2797 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2799 If the beginning or end of (the accessible part of) the buffer is reached
2800 and the depth is wrong, an error is signaled.
2801 If the depth is right but the count is not used up, nil is returned. */)
2802 (from
, count
, depth
)
2803 Lisp_Object from
, count
, depth
;
2805 CHECK_NUMBER (from
);
2806 CHECK_NUMBER (count
);
2807 CHECK_NUMBER (depth
);
2809 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2812 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2813 doc
: /* Scan from character number FROM by COUNT balanced expressions.
2814 If COUNT is negative, scan backwards.
2815 Returns the character number of the position thus found.
2817 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
2819 If the beginning or end of (the accessible part of) the buffer is reached
2820 in the middle of a parenthetical grouping, an error is signaled.
2821 If the beginning or end is reached between groupings
2822 but before count is used up, nil is returned. */)
2824 Lisp_Object from
, count
;
2826 CHECK_NUMBER (from
);
2827 CHECK_NUMBER (count
);
2829 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2832 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2834 doc
: /* Move point backward over any number of chars with prefix syntax.
2835 This includes chars with "quote" or "prefix" syntax (' or p). */)
2840 int opoint_byte
= PT_BYTE
;
2842 int pos_byte
= PT_BYTE
;
2847 SET_PT_BOTH (opoint
, opoint_byte
);
2852 SETUP_SYNTAX_TABLE (pos
, -1);
2854 DEC_BOTH (pos
, pos_byte
);
2856 while (!char_quoted (pos
, pos_byte
)
2857 /* Previous statement updates syntax table. */
2858 && ((c
= FETCH_CHAR_AS_MULTIBYTE (pos_byte
), SYNTAX (c
) == Squote
)
2859 || SYNTAX_PREFIX (c
)))
2862 opoint_byte
= pos_byte
;
2865 DEC_BOTH (pos
, pos_byte
);
2868 SET_PT_BOTH (opoint
, opoint_byte
);
2873 /* Parse forward from FROM / FROM_BYTE to END,
2874 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2875 and return a description of the state of the parse at END.
2876 If STOPBEFORE is nonzero, stop at the start of an atom.
2877 If COMMENTSTOP is 1, stop at the start of a comment.
2878 If COMMENTSTOP is -1, stop at the start or end of a comment,
2879 after the beginning of a string, or after the end of a string. */
2882 scan_sexps_forward (stateptr
, from
, from_byte
, end
, targetdepth
,
2883 stopbefore
, oldstate
, commentstop
)
2884 struct lisp_parse_state
*stateptr
;
2885 register EMACS_INT from
;
2886 EMACS_INT from_byte
, end
;
2887 int targetdepth
, stopbefore
;
2888 Lisp_Object oldstate
;
2891 struct lisp_parse_state state
;
2893 register enum syntaxcode code
;
2896 struct level
{ int last
, prev
; };
2897 struct level levelstart
[100];
2898 register struct level
*curlevel
= levelstart
;
2899 struct level
*endlevel
= levelstart
+ 100;
2900 register int depth
; /* Paren depth of current scanning location.
2901 level - levelstart equals this except
2902 when the depth becomes negative. */
2903 int mindepth
; /* Lowest DEPTH value seen. */
2904 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2906 EMACS_INT prev_from
; /* Keep one character before FROM. */
2907 EMACS_INT prev_from_byte
;
2908 int prev_from_syntax
;
2909 int boundary_stop
= commentstop
== -1;
2912 EMACS_INT out_bytepos
, out_charpos
;
2916 prev_from_byte
= from_byte
;
2918 DEC_BOTH (prev_from
, prev_from_byte
);
2920 /* Use this macro instead of `from++'. */
2922 do { prev_from = from; \
2923 prev_from_byte = from_byte; \
2924 temp = FETCH_CHAR_AS_MULTIBYTE (prev_from_byte); \
2925 prev_from_syntax = SYNTAX_WITH_FLAGS (temp); \
2926 INC_BOTH (from, from_byte); \
2928 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2934 if (NILP (oldstate
))
2937 state
.instring
= -1;
2938 state
.incomment
= 0;
2939 state
.comstyle
= 0; /* comment style a by default. */
2940 state
.comstr_start
= -1; /* no comment/string seen. */
2944 tem
= Fcar (oldstate
);
2950 oldstate
= Fcdr (oldstate
);
2951 oldstate
= Fcdr (oldstate
);
2952 oldstate
= Fcdr (oldstate
);
2953 tem
= Fcar (oldstate
);
2954 /* Check whether we are inside string_fence-style string: */
2955 state
.instring
= (!NILP (tem
)
2956 ? (INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2959 oldstate
= Fcdr (oldstate
);
2960 tem
= Fcar (oldstate
);
2961 state
.incomment
= (!NILP (tem
)
2962 ? (INTEGERP (tem
) ? XINT (tem
) : -1)
2965 oldstate
= Fcdr (oldstate
);
2966 tem
= Fcar (oldstate
);
2967 start_quoted
= !NILP (tem
);
2969 /* if the eighth element of the list is nil, we are in comment
2970 style a. If it is non-nil, we are in comment style b */
2971 oldstate
= Fcdr (oldstate
);
2972 oldstate
= Fcdr (oldstate
);
2973 tem
= Fcar (oldstate
);
2974 state
.comstyle
= NILP (tem
) ? 0 : (EQ (tem
, Qsyntax_table
)
2975 ? ST_COMMENT_STYLE
: 1);
2977 oldstate
= Fcdr (oldstate
);
2978 tem
= Fcar (oldstate
);
2979 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2980 oldstate
= Fcdr (oldstate
);
2981 tem
= Fcar (oldstate
);
2982 while (!NILP (tem
)) /* >= second enclosing sexps. */
2984 /* curlevel++->last ran into compiler bug on Apollo */
2985 curlevel
->last
= XINT (Fcar (tem
));
2986 if (++curlevel
== endlevel
)
2987 curlevel
--; /* error ("Nesting too deep for parser"); */
2988 curlevel
->prev
= -1;
2989 curlevel
->last
= -1;
2996 curlevel
->prev
= -1;
2997 curlevel
->last
= -1;
2999 SETUP_SYNTAX_TABLE (prev_from
, 1);
3000 temp
= FETCH_CHAR (prev_from_byte
);
3001 prev_from_syntax
= SYNTAX_WITH_FLAGS (temp
);
3002 UPDATE_SYNTAX_TABLE_FORWARD (from
);
3004 /* Enter the loop at a place appropriate for initial state. */
3006 if (state
.incomment
)
3007 goto startincomment
;
3008 if (state
.instring
>= 0)
3010 nofence
= state
.instring
!= ST_STRING_STYLE
;
3012 goto startquotedinstring
;
3015 else if (start_quoted
)
3021 code
= prev_from_syntax
& 0xff;
3024 && SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax
)
3025 && (c1
= FETCH_CHAR (from_byte
),
3026 SYNTAX_COMSTART_SECOND (c1
)))
3027 /* Duplicate code to avoid a complex if-expression
3028 which causes trouble for the SGI compiler. */
3030 /* Record the comment style we have entered so that only
3031 the comment-end sequence of the same style actually
3032 terminates the comment section. */
3033 state
.comstyle
= SYNTAX_COMMENT_STYLE (c1
);
3034 comnested
= SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
);
3035 comnested
= comnested
|| SYNTAX_COMMENT_NESTED (c1
);
3036 state
.incomment
= comnested
? 1 : -1;
3037 state
.comstr_start
= prev_from
;
3041 else if (code
== Scomment_fence
)
3043 /* Record the comment style we have entered so that only
3044 the comment-end sequence of the same style actually
3045 terminates the comment section. */
3046 state
.comstyle
= ST_COMMENT_STYLE
;
3047 state
.incomment
= -1;
3048 state
.comstr_start
= prev_from
;
3051 else if (code
== Scomment
)
3053 state
.comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax
);
3054 state
.incomment
= (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax
) ?
3056 state
.comstr_start
= prev_from
;
3059 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax
))
3061 switch (SWITCH_ENUM_CAST (code
))
3065 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3066 curlevel
->last
= prev_from
;
3068 if (from
== end
) goto endquoted
;
3071 /* treat following character as a word constituent */
3074 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3075 curlevel
->last
= prev_from
;
3079 /* Some compilers can't handle this inside the switch. */
3080 temp
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
3081 temp
= SYNTAX (temp
);
3087 if (from
== end
) goto endquoted
;
3099 curlevel
->prev
= curlevel
->last
;
3102 case Scomment_fence
: /* Can't happen because it's handled above. */
3104 if (commentstop
|| boundary_stop
) goto done
;
3106 /* The (from == BEGV) test was to enter the loop in the middle so
3107 that we find a 2-char comment ender even if we start in the
3108 middle of it. We don't want to do that if we're just at the
3109 beginning of the comment (think of (*) ... (*)). */
3110 found
= forw_comment (from
, from_byte
, end
,
3111 state
.incomment
, state
.comstyle
,
3112 (from
== BEGV
|| from
< state
.comstr_start
+ 3)
3113 ? 0 : prev_from_syntax
,
3114 &out_charpos
, &out_bytepos
, &state
.incomment
);
3115 from
= out_charpos
; from_byte
= out_bytepos
;
3116 /* Beware! prev_from and friends are invalid now.
3117 Luckily, the `done' doesn't use them and the INC_FROM
3118 sets them to a sane value without looking at them. */
3119 if (!found
) goto done
;
3121 state
.incomment
= 0;
3122 state
.comstyle
= 0; /* reset the comment style */
3123 if (boundary_stop
) goto done
;
3127 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3129 /* curlevel++->last ran into compiler bug on Apollo */
3130 curlevel
->last
= prev_from
;
3131 if (++curlevel
== endlevel
)
3132 curlevel
--; /* error ("Nesting too deep for parser"); */
3133 curlevel
->prev
= -1;
3134 curlevel
->last
= -1;
3135 if (targetdepth
== depth
) goto done
;
3140 if (depth
< mindepth
)
3142 if (curlevel
!= levelstart
)
3144 curlevel
->prev
= curlevel
->last
;
3145 if (targetdepth
== depth
) goto done
;
3150 state
.comstr_start
= from
- 1;
3151 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
3152 curlevel
->last
= prev_from
;
3153 state
.instring
= (code
== Sstring
3154 ? (FETCH_CHAR_AS_MULTIBYTE (prev_from_byte
))
3156 if (boundary_stop
) goto done
;
3159 nofence
= state
.instring
!= ST_STRING_STYLE
;
3165 if (from
>= end
) goto done
;
3166 c
= FETCH_CHAR_AS_MULTIBYTE (from_byte
);
3167 /* Some compilers can't handle this inside the switch. */
3170 /* Check TEMP here so that if the char has
3171 a syntax-table property which says it is NOT
3172 a string character, it does not end the string. */
3173 if (nofence
&& c
== state
.instring
&& temp
== Sstring
)
3179 if (!nofence
) goto string_end
;
3184 startquotedinstring
:
3185 if (from
>= end
) goto endquoted
;
3191 state
.instring
= -1;
3192 curlevel
->prev
= curlevel
->last
;
3194 if (boundary_stop
) goto done
;
3198 /* FIXME: We should do something with it. */
3201 /* Ignore whitespace, punctuation, quote, endcomment. */
3207 stop
: /* Here if stopping before start of sexp. */
3208 from
= prev_from
; /* We have just fetched the char that starts it; */
3209 goto done
; /* but return the position before it. */
3214 state
.depth
= depth
;
3215 state
.mindepth
= mindepth
;
3216 state
.thislevelstart
= curlevel
->prev
;
3217 state
.prevlevelstart
3218 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
3219 state
.location
= from
;
3220 state
.levelstarts
= Qnil
;
3221 while (--curlevel
>= levelstart
)
3222 state
.levelstarts
= Fcons (make_number (curlevel
->last
),
3229 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
3230 doc
: /* Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
3231 Parsing stops at TO or when certain criteria are met;
3232 point is set to where parsing stops.
3233 If fifth arg OLDSTATE is omitted or nil,
3234 parsing assumes that FROM is the beginning of a function.
3235 Value is a list of elements describing final state of parsing:
3237 1. character address of start of innermost containing list; nil if none.
3238 2. character address of start of last complete sexp terminated.
3239 3. non-nil if inside a string.
3240 (it is the character that will terminate the string,
3241 or t if the string should be terminated by a generic string delimiter.)
3242 4. nil if outside a comment, t if inside a non-nestable comment,
3243 else an integer (the current comment nesting).
3244 5. t if following a quote character.
3245 6. the minimum paren-depth encountered during this scan.
3246 7. t if in a comment of style b; symbol `syntax-table' if the comment
3247 should be terminated by a generic comment delimiter.
3248 8. character address of start of comment or string; nil if not in one.
3249 9. Intermediate data for continuation of parsing (subject to change).
3250 If third arg TARGETDEPTH is non-nil, parsing stops if the depth
3251 in parentheses becomes equal to TARGETDEPTH.
3252 Fourth arg STOPBEFORE non-nil means stop when come to
3253 any character that starts a sexp.
3254 Fifth arg OLDSTATE is a list like what this function returns.
3255 It is used to initialize the state of the parse. Elements number 1, 2, 6
3257 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
3258 If it is symbol `syntax-table', stop after the start of a comment or a
3259 string, or after end of a comment or a string. */)
3260 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
3261 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
3263 struct lisp_parse_state state
;
3266 if (!NILP (targetdepth
))
3268 CHECK_NUMBER (targetdepth
);
3269 target
= XINT (targetdepth
);
3272 target
= -100000; /* We won't reach this depth */
3274 validate_region (&from
, &to
);
3275 scan_sexps_forward (&state
, XINT (from
), CHAR_TO_BYTE (XINT (from
)),
3277 target
, !NILP (stopbefore
), oldstate
,
3279 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
3281 SET_PT (state
.location
);
3283 return Fcons (make_number (state
.depth
),
3284 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
3285 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
3286 Fcons (state
.instring
>= 0
3287 ? (state
.instring
== ST_STRING_STYLE
3288 ? Qt
: make_number (state
.instring
)) : Qnil
,
3289 Fcons (state
.incomment
< 0 ? Qt
:
3290 (state
.incomment
== 0 ? Qnil
:
3291 make_number (state
.incomment
)),
3292 Fcons (state
.quoted
? Qt
: Qnil
,
3293 Fcons (make_number (state
.mindepth
),
3294 Fcons ((state
.comstyle
3295 ? (state
.comstyle
== ST_COMMENT_STYLE
3296 ? Qsyntax_table
: Qt
) :
3298 Fcons (((state
.incomment
3299 || (state
.instring
>= 0))
3300 ? make_number (state
.comstr_start
)
3302 Fcons (state
.levelstarts
, Qnil
))))))))));
3306 init_syntax_once (void)
3311 /* This has to be done here, before we call Fmake_char_table. */
3312 Qsyntax_table
= intern_c_string ("syntax-table");
3313 staticpro (&Qsyntax_table
);
3315 /* Intern_C_String this now in case it isn't already done.
3316 Setting this variable twice is harmless.
3317 But don't staticpro it here--that is done in alloc.c. */
3318 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
3320 /* Create objects which can be shared among syntax tables. */
3321 Vsyntax_code_object
= Fmake_vector (make_number (Smax
), Qnil
);
3322 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
3323 XVECTOR (Vsyntax_code_object
)->contents
[i
]
3324 = Fcons (make_number (i
), Qnil
);
3326 /* Now we are ready to set up this property, so we can
3327 create syntax tables. */
3328 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
3330 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
3332 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
3334 /* Control characters should not be whitespace. */
3335 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
3336 for (i
= 0; i
<= ' ' - 1; i
++)
3337 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3338 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, 0177, temp
);
3340 /* Except that a few really are whitespace. */
3341 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
3342 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ' ', temp
);
3343 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\t', temp
);
3344 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\n', temp
);
3345 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, 015, temp
);
3346 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, 014, temp
);
3348 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
3349 for (i
= 'a'; i
<= 'z'; i
++)
3350 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3351 for (i
= 'A'; i
<= 'Z'; i
++)
3352 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3353 for (i
= '0'; i
<= '9'; i
++)
3354 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
3356 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
3357 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
3359 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
3360 Fcons (make_number (Sopen
), make_number (')')));
3361 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
3362 Fcons (make_number (Sclose
), make_number ('(')));
3363 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
3364 Fcons (make_number (Sopen
), make_number (']')));
3365 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
3366 Fcons (make_number (Sclose
), make_number ('[')));
3367 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
3368 Fcons (make_number (Sopen
), make_number ('}')));
3369 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
3370 Fcons (make_number (Sclose
), make_number ('{')));
3371 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
3372 Fcons (make_number ((int) Sstring
), Qnil
));
3373 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
3374 Fcons (make_number ((int) Sescape
), Qnil
));
3376 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
3377 for (i
= 0; i
< 10; i
++)
3379 c
= "_-+*/&|<>="[i
];
3380 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3383 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
3384 for (i
= 0; i
< 12; i
++)
3386 c
= ".,;:?!#@~^'`"[i
];
3387 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
3390 /* All multibyte characters have syntax `word' by default. */
3391 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
3392 char_table_set_range (Vstandard_syntax_table
, 0x80, MAX_CHAR
, temp
);
3396 syms_of_syntax (void)
3398 Qsyntax_table_p
= intern_c_string ("syntax-table-p");
3399 staticpro (&Qsyntax_table_p
);
3401 staticpro (&Vsyntax_code_object
);
3403 staticpro (&gl_state
.object
);
3404 staticpro (&gl_state
.global_code
);
3405 staticpro (&gl_state
.current_syntax_table
);
3406 staticpro (&gl_state
.old_prop
);
3408 /* Defined in regex.c */
3409 staticpro (&re_match_object
);
3411 Qscan_error
= intern_c_string ("scan-error");
3412 staticpro (&Qscan_error
);
3413 Fput (Qscan_error
, Qerror_conditions
,
3414 pure_cons (Qscan_error
, pure_cons (Qerror
, Qnil
)));
3415 Fput (Qscan_error
, Qerror_message
,
3416 make_pure_c_string ("Scan error"));
3418 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
3419 doc
: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace. */);
3421 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
3422 doc
: /* Non-nil means `forward-sexp', etc., obey `syntax-table' property.
3423 Otherwise, that text property is simply ignored.
3424 See the info node `(elisp)Syntax Properties' for a description of the
3425 `syntax-table' property. */);
3427 words_include_escapes
= 0;
3428 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
3429 doc
: /* Non-nil means `forward-word', etc., should treat escape chars part of words. */);
3431 DEFVAR_BOOL ("multibyte-syntax-as-symbol", &multibyte_syntax_as_symbol
,
3432 doc
: /* Non-nil means `scan-sexps' treats all multibyte characters as symbol. */);
3433 multibyte_syntax_as_symbol
= 0;
3435 DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
3436 &open_paren_in_column_0_is_defun_start
,
3437 doc
: /* *Non-nil means an open paren in column 0 denotes the start of a defun. */);
3438 open_paren_in_column_0_is_defun_start
= 1;
3441 DEFVAR_LISP ("find-word-boundary-function-table",
3442 &Vfind_word_boundary_function_table
,
3444 Char table of functions to search for the word boundary.
3445 Each function is called with two arguments; POS and LIMIT.
3446 POS and LIMIT are character positions in the current buffer.
3448 If POS is less than LIMIT, POS is at the first character of a word,
3449 and the return value of a function is a position after the last
3450 character of that word.
3452 If POS is not less than LIMIT, POS is at the last character of a word,
3453 and the return value of a function is a position at the first
3454 character of that word.
3456 In both cases, LIMIT bounds the search. */);
3457 Vfind_word_boundary_function_table
= Fmake_char_table (Qnil
, Qnil
);
3459 defsubr (&Ssyntax_table_p
);
3460 defsubr (&Ssyntax_table
);
3461 defsubr (&Sstandard_syntax_table
);
3462 defsubr (&Scopy_syntax_table
);
3463 defsubr (&Sset_syntax_table
);
3464 defsubr (&Schar_syntax
);
3465 defsubr (&Smatching_paren
);
3466 defsubr (&Sstring_to_syntax
);
3467 defsubr (&Smodify_syntax_entry
);
3468 defsubr (&Sinternal_describe_syntax_value
);
3470 defsubr (&Sforward_word
);
3472 defsubr (&Sskip_chars_forward
);
3473 defsubr (&Sskip_chars_backward
);
3474 defsubr (&Sskip_syntax_forward
);
3475 defsubr (&Sskip_syntax_backward
);
3477 defsubr (&Sforward_comment
);
3478 defsubr (&Sscan_lists
);
3479 defsubr (&Sscan_sexps
);
3480 defsubr (&Sbackward_prefix_chars
);
3481 defsubr (&Sparse_partial_sexp
);
3484 /* arch-tag: 3e297b9f-088e-4b64-8f4c-fb0b3443e412
3485 (do not change this comment) */