1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 87, 93, 94, 95, 1997 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
29 /* Make syntax table lookup grant data in gl_state. */
30 #define SYNTAX_ENTRY_VIA_PROPERTY
33 #include "intervals.h"
35 /* We use these constants in place for comment-style and
36 string-ender-char to distinguish comments/strings started by
37 comment_fence and string_fence codes. */
39 #define ST_COMMENT_STYLE (256 + 1)
40 #define ST_STRING_STYLE (256 + 2)
43 Lisp_Object Qsyntax_table_p
, Qsyntax_table
, Qscan_error
;
45 static void scan_sexps_forward ();
46 static int char_quoted ();
48 int words_include_escapes
;
49 int parse_sexp_lookup_properties
;
51 /* Used as a temporary in SYNTAX_ENTRY and other macros in syntax.h,
52 if not compiled with GCC. No need to mark it, since it is used
53 only very temporarily. */
54 Lisp_Object syntax_temp
;
56 /* This is the internal form of the parse state used in parse-partial-sexp. */
58 struct lisp_parse_state
60 int depth
; /* Depth at end of parsing. */
61 int instring
; /* -1 if not within string, else desired terminator. */
62 int incomment
; /* Nonzero if within a comment at end of parsing. */
63 int comstyle
; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
64 int quoted
; /* Nonzero if just after an escape char at end of parsing */
65 int thislevelstart
; /* Char number of most recent start-of-expression at current level */
66 int prevlevelstart
; /* Char number of start of containing expression */
67 int location
; /* Char number at which parsing stopped. */
68 int mindepth
; /* Minimum depth seen while scanning. */
69 int comstr_start
; /* Position just after last comment/string starter. */
72 /* These variables are a cache for finding the start of a defun.
73 find_start_pos is the place for which the defun start was found.
74 find_start_value is the defun start position found for it.
75 find_start_buffer is the buffer it was found in.
76 find_start_begv is the BEGV value when it was found.
77 find_start_modiff is the value of MODIFF when it was found. */
79 static int find_start_pos
;
80 static int find_start_value
;
81 static struct buffer
*find_start_buffer
;
82 static int find_start_begv
;
83 static int find_start_modiff
;
86 struct gl_state_s gl_state
; /* Global state of syntax parser. */
88 INTERVAL
interval_of ();
89 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
90 to scan to property-change. */
93 Update gl_state to an appropriate interval which contains POS. The
94 sign of COUNT give the relative position of POS wrt the previously
95 valid interval. If INIT, only [be]_property fields of gl_state are
96 valid at start, the rest is filled basing on OBJECT.
98 `gl_state.*_i' are the intervals, and pos is further in the search
99 direction than the intervals - or in an interval. We update the
100 current syntax-table basing on the property of this interval, and
101 update the interval to start further than POS - or be
102 NULL_INTERVAL. We also update lim_property to be the next value of
103 pos to call this subroutine again - or be before/after the
104 start/end of OBJECT. */
107 update_syntax_table (pos
, count
, init
, object
)
108 int pos
, count
, init
;
111 Lisp_Object tmp_table
;
112 int cnt
= 0, doing_extra
= 0, invalidate
= 1;
117 gl_state
.start
= gl_state
.b_property
;
118 gl_state
.stop
= gl_state
.e_property
;
119 gl_state
.forward_i
= interval_of (pos
, object
);
120 i
= gl_state
.backward_i
= gl_state
.forward_i
;
121 gl_state
.left_ok
= gl_state
.right_ok
= 1;
123 if (NULL_INTERVAL_P (i
))
125 gl_state
.b_property
= i
->position
- 1;
126 gl_state
.e_property
= INTERVAL_LAST_POS (i
);
129 oldi
= i
= count
> 0 ? gl_state
.forward_i
: gl_state
.backward_i
;
131 /* We are guarantied to be called with pos either in i, of further off. */
132 if (NULL_INTERVAL_P (i
))
133 error ("Error in syntax_table logic for to-the-end intervals");
134 else if (pos
< i
->position
) /* Move left. */
137 error ("Error in syntax_table logic for intervals <-.");
138 /* Update the interval. */
139 i
= update_interval (i
, pos
);
140 if (oldi
->position
!= INTERVAL_LAST_POS (i
))
143 gl_state
.right_ok
= 1; /* Invalidate the other end. */
144 gl_state
.forward_i
= i
;
145 gl_state
.e_property
= INTERVAL_LAST_POS (i
);
148 else if (pos
>= INTERVAL_LAST_POS (i
)) /* Move right. */
151 error ("Error in syntax_table logic for intervals ->.");
152 /* Update the interval. */
153 i
= update_interval (i
, pos
);
154 if (i
->position
!= INTERVAL_LAST_POS (oldi
))
157 gl_state
.left_ok
= 1; /* Invalidate the other end. */
158 gl_state
.backward_i
= i
;
159 gl_state
.b_property
= i
->position
- 1;
162 else if (count
> 0 ? gl_state
.right_ok
: gl_state
.left_ok
)
164 /* We do not need to recalculate tmp_table. */
165 tmp_table
= gl_state
.old_prop
;
169 tmp_table
= textget (i
->plist
, Qsyntax_table
);
172 invalidate
= !EQ (tmp_table
, gl_state
.old_prop
); /* Need to invalidate? */
174 if (invalidate
) /* Did not get to adjacent interval. */
175 { /* with the same table => */
176 /* invalidate the old range. */
179 gl_state
.backward_i
= i
;
180 gl_state
.left_ok
= 1; /* Invalidate the other end. */
181 gl_state
.b_property
= i
->position
- 1;
185 gl_state
.forward_i
= i
;
186 gl_state
.right_ok
= 1; /* Invalidate the other end. */
187 gl_state
.e_property
= INTERVAL_LAST_POS (i
);
191 gl_state
.current_syntax_table
= tmp_table
;
192 gl_state
.old_prop
= tmp_table
;
193 if (Fsyntax_table_p (tmp_table
) == Qt
)
195 gl_state
.use_global
= 0;
197 else if (CONSP (tmp_table
))
199 gl_state
.use_global
= 1;
200 gl_state
.global_code
= tmp_table
;
204 gl_state
.use_global
= 0;
205 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
208 while (!NULL_INTERVAL_P (i
))
210 if (cnt
&& !EQ (tmp_table
, textget (i
->plist
, Qsyntax_table
)))
213 gl_state
.right_ok
= 0;
215 gl_state
.left_ok
= 0;
218 else if (cnt
== INTERVALS_AT_ONCE
)
221 gl_state
.right_ok
= 1;
223 gl_state
.left_ok
= 1;
227 i
= count
> 0 ? next_interval (i
) : previous_interval (i
);
229 if (NULL_INTERVAL_P (i
))
230 { /* This property goes to the end. */
232 gl_state
.e_property
= gl_state
.stop
;
234 gl_state
.b_property
= gl_state
.start
;
240 gl_state
.e_property
= i
->position
;
241 gl_state
.forward_i
= i
;
245 gl_state
.b_property
= i
->position
+ LENGTH (i
) - 1;
246 gl_state
.backward_i
= i
;
251 /* Returns TRUE if char at POS is quoted.
252 Global syntax-table data should be set up already to be good at pos
253 or after. On return global syntax data is good for lookup at POS. */
259 register enum syntaxcode code
;
260 register int beg
= BEGV
;
261 register int quoted
= 0;
265 while (temp_pos
>= beg
266 && ( UPDATE_SYNTAX_TABLE_BACKWARD (temp_pos
), 1)
267 && ((code
= SYNTAX (FETCH_CHAR (temp_pos
))) == Scharquote
270 temp_pos
--, quoted
= !quoted
;
272 UPDATE_SYNTAX_TABLE (pos
);
276 /* Find a defun-start that is the last one before POS (or nearly the last).
277 We record what we find, so that another call in the same area
278 can return the same value right away.
280 There is no promise at which position the global syntax data is
281 valid on return from the subroutine, so the caller should explicitly
282 update the global data. */
285 find_defun_start (pos
)
291 /* Use previous finding, if it's valid and applies to this inquiry. */
292 if (current_buffer
== find_start_buffer
293 /* Reuse the defun-start even if POS is a little farther on.
294 POS might be in the next defun, but that's ok.
295 Our value may not be the best possible, but will still be usable. */
296 && pos
<= find_start_pos
+ 1000
297 && pos
>= find_start_value
298 && BEGV
== find_start_begv
299 && MODIFF
== find_start_modiff
)
300 return find_start_value
;
302 /* Back up to start of line. */
303 tem
= scan_buffer ('\n', pos
, BEGV
, -1, &shortage
, 1);
305 /* We optimize syntax-table lookup for rare updates. Thus we accept
306 only those `^\s(' which are good in global _and_ text-property
308 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
309 gl_state
.use_global
= 0;
312 /* Open-paren at start of line means we found our defun-start. */
313 if (SYNTAX (FETCH_CHAR (tem
)) == Sopen
)
315 SETUP_SYNTAX_TABLE (tem
+ 1, -1); /* Try again... */
316 if (SYNTAX (FETCH_CHAR (tem
)) == Sopen
)
318 /* Now fallback to the default value. */
319 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
320 gl_state
.use_global
= 0;
322 /* Move to beg of previous line. */
323 tem
= scan_buffer ('\n', tem
, BEGV
, -2, &shortage
, 1);
326 /* Record what we found, for the next try. */
327 find_start_value
= tem
;
328 find_start_buffer
= current_buffer
;
329 find_start_modiff
= MODIFF
;
330 find_start_begv
= BEGV
;
331 find_start_pos
= pos
;
333 return find_start_value
;
336 /* Checks whether FROM is the end of comment. Does not try to
337 fallback more than to STOP.
338 Returns -1 if cannot find comment ending at from, otherwise start
339 of comment. Global syntax data remains valid for
340 backward search starting at the returned value (or at FROM, if
341 the search was not successful). */
344 back_comment (from
, stop
)
347 /* Look back, counting the parity of string-quotes,
348 and recording the comment-starters seen.
349 When we reach a safe place, assume that's not in a string;
350 then step the main scan to the earliest comment-starter seen
351 an even number of string quotes away from the safe place.
353 OFROM[I] is position of the earliest comment-starter seen
354 which is I+2X quotes from the comment-end.
355 PARITY is current parity of quotes from the comment end. */
357 int my_stringend
= 0;
358 int string_lossage
= 0;
359 int comment_end
= from
;
360 int comstart_pos
= 0;
361 int comstart_parity
= 0;
362 int scanstart
= from
- 1;
363 register enum syntaxcode code
;
366 /* At beginning of range to scan, we're outside of strings;
367 that determines quote parity to the comment-end. */
370 /* Move back and examine a character. */
372 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
374 c
= FETCH_CHAR (from
);
377 /* If this char is the second of a 2-char comment sequence,
378 back up and give the pair the appropriate syntax. */
379 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
380 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from
- 1)))
384 /* This is apparently the best we can do: */
385 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
386 c
= FETCH_CHAR (from
);
389 /* If this char starts a 2-char comment start sequence,
390 treat it like a 1-char comment starter. */
391 if (from
< scanstart
&& SYNTAX_COMSTART_FIRST (c
)
392 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
+ 1))
393 && comstyle
== SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
+ 1)))
396 /* Ignore escaped characters. */
397 if (char_quoted (from
))
400 /* Track parity of quotes. */
404 if (my_stringend
== 0)
406 /* If we have two kinds of string delimiters.
407 There's no way to grok this scanning backwards. */
408 else if (my_stringend
!= c
)
412 if (code
== Sstring_fence
|| code
== Scomment_fence
)
415 if (my_stringend
== 0)
417 code
== Sstring_fence
? ST_STRING_STYLE
: ST_COMMENT_STYLE
;
418 /* If we have two kinds of string delimiters.
419 There's no way to grok this scanning backwards. */
420 else if (my_stringend
!= (code
== Sstring_fence
421 ? ST_STRING_STYLE
: ST_COMMENT_STYLE
))
425 /* Record comment-starters according to that
426 quote-parity to the comment-end. */
427 if (code
== Scomment
)
429 comstart_parity
= parity
;
433 /* If we find another earlier comment-ender,
434 any comment-starts earlier than that don't count
435 (because they go with the earlier comment-ender). */
436 if (code
== Sendcomment
437 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
)) == comstyle
)
440 /* Assume a defun-start point is outside of strings. */
442 && (from
== stop
|| FETCH_CHAR (from
- 1) == '\n'))
446 if (comstart_pos
== 0)
449 UPDATE_SYNTAX_TABLE_FORWARD (comment_end
- 1);
451 /* If the earliest comment starter
452 is followed by uniform paired string quotes or none,
453 we know it can't be inside a string
454 since if it were then the comment ender would be inside one.
455 So it does start a comment. Skip back to it. */
456 else if (comstart_parity
== 0 && !string_lossage
)
459 /* Globals are correct now. */
463 /* We had two kinds of string delimiters mixed up
464 together. Decode this going forwards.
465 Scan fwd from the previous comment ender
466 to the one in question; this records where we
467 last passed a comment starter. */
468 struct lisp_parse_state state
;
469 scan_sexps_forward (&state
, find_defun_start (comment_end
),
470 comment_end
- 1, -10000, 0, Qnil
, 0);
473 /* scan_sexps_forward changed the direction of search in
474 global variables, so we need to update it completely. */
476 from
= state
.comstr_start
;
482 UPDATE_SYNTAX_TABLE_FORWARD (from
- 1);
488 DEFUN ("syntax-table-p", Fsyntax_table_p
, Ssyntax_table_p
, 1, 1, 0,
489 "Return t if OBJECT is a syntax table.\n\
490 Currently, any char-table counts as a syntax table.")
494 if (CHAR_TABLE_P (object
)
495 && XCHAR_TABLE (object
)->purpose
== Qsyntax_table
)
501 check_syntax_table (obj
)
504 if (!(CHAR_TABLE_P (obj
)
505 && XCHAR_TABLE (obj
)->purpose
== Qsyntax_table
))
506 wrong_type_argument (Qsyntax_table_p
, obj
);
509 DEFUN ("syntax-table", Fsyntax_table
, Ssyntax_table
, 0, 0, 0,
510 "Return the current syntax table.\n\
511 This is the one specified by the current buffer.")
514 return current_buffer
->syntax_table
;
517 DEFUN ("standard-syntax-table", Fstandard_syntax_table
,
518 Sstandard_syntax_table
, 0, 0, 0,
519 "Return the standard syntax table.\n\
520 This is the one used for new buffers.")
523 return Vstandard_syntax_table
;
526 DEFUN ("copy-syntax-table", Fcopy_syntax_table
, Scopy_syntax_table
, 0, 1, 0,
527 "Construct a new syntax table and return it.\n\
528 It is a copy of the TABLE, which defaults to the standard syntax table.")
535 check_syntax_table (table
);
537 table
= Vstandard_syntax_table
;
539 copy
= Fcopy_sequence (table
);
541 /* Only the standard syntax table should have a default element.
542 Other syntax tables should inherit from parents instead. */
543 XCHAR_TABLE (copy
)->defalt
= Qnil
;
545 /* Copied syntax tables should all have parents.
546 If we copied one with no parent, such as the standard syntax table,
547 use the standard syntax table as the copy's parent. */
548 if (NILP (XCHAR_TABLE (copy
)->parent
))
549 Fset_char_table_parent (copy
, Vstandard_syntax_table
);
553 DEFUN ("set-syntax-table", Fset_syntax_table
, Sset_syntax_table
, 1, 1, 0,
554 "Select a new syntax table for the current buffer.\n\
555 One argument, a syntax table.")
559 check_syntax_table (table
);
560 current_buffer
->syntax_table
= table
;
561 /* Indicate that this buffer now has a specified syntax table. */
562 current_buffer
->local_var_flags
563 |= XFASTINT (buffer_local_flags
.syntax_table
);
567 /* Convert a letter which signifies a syntax code
568 into the code it signifies.
569 This is used by modify-syntax-entry, and other things. */
571 unsigned char syntax_spec_code
[0400] =
572 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
573 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
574 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
575 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
576 (char) Swhitespace
, (char) Scomment_fence
, (char) Sstring
, 0377,
577 (char) Smath
, 0377, 0377, (char) Squote
,
578 (char) Sopen
, (char) Sclose
, 0377, 0377,
579 0377, (char) Swhitespace
, (char) Spunct
, (char) Scharquote
,
580 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
581 0377, 0377, 0377, 0377,
582 (char) Scomment
, 0377, (char) Sendcomment
, 0377,
583 (char) Sinherit
, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
584 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
585 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
586 0377, 0377, 0377, 0377, (char) Sescape
, 0377, 0377, (char) Ssymbol
,
587 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
588 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
589 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword
,
590 0377, 0377, 0377, 0377, (char) Sstring_fence
, 0377, 0377, 0377
593 /* Indexed by syntax code, give the letter that describes it. */
595 char syntax_code_spec
[16] =
597 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
601 /* Indexed by syntax code, give the object (cons of syntax code and
602 nil) to be stored in syntax table. Since these objects can be
603 shared among syntax tables, we generate them in advance. By
604 sharing objects, the function `describe-syntax' can give a more
606 static Lisp_Object Vsyntax_code_object
;
609 /* Look up the value for CHARACTER in syntax table TABLE's parent
610 and its parents. SYNTAX_ENTRY calls this, when TABLE itself has nil
611 for CHARACTER. It's actually used only when not compiled with GCC. */
614 syntax_parent_lookup (table
, character
)
622 table
= XCHAR_TABLE (table
)->parent
;
626 value
= XCHAR_TABLE (table
)->contents
[character
];
632 DEFUN ("char-syntax", Fchar_syntax
, Schar_syntax
, 1, 1, 0,
633 "Return the syntax code of CHARACTER, described by a character.\n\
634 For example, if CHARACTER is a word constituent,\n\
635 the character `w' is returned.\n\
636 The characters that correspond to various syntax codes\n\
637 are listed in the documentation of `modify-syntax-entry'.")
639 Lisp_Object character
;
642 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
644 gl_state
.use_global
= 0;
645 CHECK_NUMBER (character
, 0);
646 char_int
= XINT (character
);
647 return make_number (syntax_code_spec
[(int) SYNTAX (char_int
)]);
650 DEFUN ("matching-paren", Fmatching_paren
, Smatching_paren
, 1, 1, 0,
651 "Return the matching parenthesis of CHARACTER, or nil if none.")
653 Lisp_Object character
;
656 gl_state
.current_syntax_table
= current_buffer
->syntax_table
;
657 gl_state
.use_global
= 0;
658 CHECK_NUMBER (character
, 0);
659 char_int
= XINT (character
);
660 code
= SYNTAX (char_int
);
661 if (code
== Sopen
|| code
== Sclose
)
662 return make_number (SYNTAX_MATCH (char_int
));
666 /* This comment supplies the doc string for modify-syntax-entry,
667 for make-docfile to see. We cannot put this in the real DEFUN
668 due to limits in the Unix cpp.
670 DEFUN ("modify-syntax-entry", foo, bar, 2, 3, 0,
671 "Set syntax for character CHAR according to string S.\n\
672 The syntax is changed only for table TABLE, which defaults to\n\
673 the current buffer's syntax table.\n\
674 The first character of S should be one of the following:\n\
675 Space or - whitespace syntax. w word constituent.\n\
676 _ symbol constituent. . punctuation.\n\
677 ( open-parenthesis. ) close-parenthesis.\n\
678 \" string quote. \\ escape.\n\
679 $ paired delimiter. ' expression quote or prefix operator.\n\
680 < comment starter. > comment ender.\n\
681 / character-quote. @ inherit from `standard-syntax-table'.\n\
683 Only single-character comment start and end sequences are represented thus.\n\
684 Two-character sequences are represented as described below.\n\
685 The second character of S is the matching parenthesis,\n\
686 used only if the first character is `(' or `)'.\n\
687 Any additional characters are flags.\n\
688 Defined flags are the characters 1, 2, 3, 4, b, and p.\n\
689 1 means CHAR is the start of a two-char comment start sequence.\n\
690 2 means CHAR is the second character of such a sequence.\n\
691 3 means CHAR is the start of a two-char comment end sequence.\n\
692 4 means CHAR is the second character of such a sequence.\n\
694 There can be up to two orthogonal comment sequences. This is to support\n\
695 language modes such as C++. By default, all comment sequences are of style\n\
696 a, but you can set the comment sequence style to b (on the second character\n\
697 of a comment-start, or the first character of a comment-end sequence) using\n\
699 b means CHAR is part of comment sequence b.\n\
701 p means CHAR is a prefix character for `backward-prefix-chars';\n\
702 such characters are treated as whitespace when they occur\n\
703 between expressions.")
707 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry
, Smodify_syntax_entry
, 2, 3,
708 /* I really don't know why this is interactive
709 help-form should at least be made useful whilst reading the second arg
711 "cSet syntax for character: \nsSet syntax for %s to: ",
712 0 /* See immediately above */)
713 (c
, newentry
, syntax_table
)
714 Lisp_Object c
, newentry
, syntax_table
;
716 register unsigned char *p
;
717 register enum syntaxcode code
;
722 CHECK_STRING (newentry
, 1);
724 if (NILP (syntax_table
))
725 syntax_table
= current_buffer
->syntax_table
;
727 check_syntax_table (syntax_table
);
729 p
= XSTRING (newentry
)->data
;
730 code
= (enum syntaxcode
) syntax_spec_code
[*p
++];
731 if (((int) code
& 0377) == 0377)
732 error ("invalid syntax description letter: %c", c
);
734 if (code
== Sinherit
)
736 SET_RAW_SYNTAX_ENTRY (syntax_table
, c
, Qnil
);
743 int character
= STRING_CHAR_AND_LENGTH (p
, XSTRING (newentry
)->size
- 1,
745 XSETINT (match
, character
);
746 if (XFASTINT (match
) == ' ')
782 if (val
< XVECTOR (Vsyntax_code_object
)->size
&& NILP (match
))
783 newentry
= XVECTOR (Vsyntax_code_object
)->contents
[val
];
785 /* Since we can't use a shared object, let's make a new one. */
786 newentry
= Fcons (make_number (val
), match
);
788 SET_RAW_SYNTAX_ENTRY (syntax_table
, c
, newentry
);
793 /* Dump syntax table to buffer in human-readable format */
796 describe_syntax (value
)
799 register enum syntaxcode code
;
800 char desc
, match
, start1
, start2
, end1
, end2
, prefix
, comstyle
;
802 Lisp_Object first
, match_lisp
;
804 Findent_to (make_number (16), make_number (1));
808 insert_string ("default\n");
812 if (CHAR_TABLE_P (value
))
814 insert_string ("deeper char-table ...\n");
820 insert_string ("invalid\n");
824 first
= XCONS (value
)->car
;
825 match_lisp
= XCONS (value
)->cdr
;
827 if (!INTEGERP (first
) || !(NILP (match_lisp
) || INTEGERP (match_lisp
)))
829 insert_string ("invalid\n");
833 code
= (enum syntaxcode
) (first
& 0377);
834 start1
= (XINT (first
) >> 16) & 1;
835 start2
= (XINT (first
) >> 17) & 1;
836 end1
= (XINT (first
) >> 18) & 1;
837 end2
= (XINT (first
) >> 19) & 1;
838 prefix
= (XINT (first
) >> 20) & 1;
839 comstyle
= (XINT (first
) >> 21) & 1;
841 if ((int) code
< 0 || (int) code
>= (int) Smax
)
843 insert_string ("invalid");
846 desc
= syntax_code_spec
[(int) code
];
848 str
[0] = desc
, str
[1] = 0;
851 if (NILP (match_lisp
))
854 insert_char (XINT (match_lisp
));
871 insert_string ("\twhich means: ");
873 switch (SWITCH_ENUM_CAST (code
))
876 insert_string ("whitespace"); break;
878 insert_string ("punctuation"); break;
880 insert_string ("word"); break;
882 insert_string ("symbol"); break;
884 insert_string ("open"); break;
886 insert_string ("close"); break;
888 insert_string ("quote"); break;
890 insert_string ("string"); break;
892 insert_string ("math"); break;
894 insert_string ("escape"); break;
896 insert_string ("charquote"); break;
898 insert_string ("comment"); break;
900 insert_string ("endcomment"); break;
902 insert_string ("invalid");
906 if (!NILP (match_lisp
))
908 insert_string (", matches ");
909 insert_char (XINT (match_lisp
));
913 insert_string (",\n\t is the first character of a comment-start sequence");
915 insert_string (",\n\t is the second character of a comment-start sequence");
918 insert_string (",\n\t is the first character of a comment-end sequence");
920 insert_string (",\n\t is the second character of a comment-end sequence");
922 insert_string (" (comment style b)");
925 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
927 insert_string ("\n");
931 describe_syntax_1 (vector
)
934 struct buffer
*old
= current_buffer
;
935 set_buffer_internal (XBUFFER (Vstandard_output
));
936 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
, (int *) 0, 0);
937 while (! NILP (XCHAR_TABLE (vector
)->parent
))
939 vector
= XCHAR_TABLE (vector
)->parent
;
940 insert_string ("\nThe parent syntax table is:");
941 describe_vector (vector
, Qnil
, describe_syntax
, 0, Qnil
, Qnil
,
945 call0 (intern ("help-mode"));
946 set_buffer_internal (old
);
950 DEFUN ("describe-syntax", Fdescribe_syntax
, Sdescribe_syntax
, 0, 0, "",
951 "Describe the syntax specifications in the syntax table.\n\
952 The descriptions are inserted in a buffer, which is then displayed.")
955 internal_with_output_to_temp_buffer
956 ("*Help*", describe_syntax_1
, current_buffer
->syntax_table
);
961 int parse_sexp_ignore_comments
;
963 /* Return the position across COUNT words from FROM.
964 If that many words cannot be found before the end of the buffer, return 0.
965 COUNT negative means scan backward and stop at word beginning. */
967 scan_words (from
, count
)
968 register int from
, count
;
970 register int beg
= BEGV
;
971 register int end
= ZV
;
972 register enum syntaxcode code
;
979 SETUP_SYNTAX_TABLE (from
, count
);
990 UPDATE_SYNTAX_TABLE_FORWARD (from
);
991 ch0
= FETCH_CHAR (from
);
994 if (words_include_escapes
995 && (code
== Sescape
|| code
== Scharquote
))
1000 /* Now CH0 is a character which begins a word and FROM is the
1001 position of the next character. */
1004 if (from
== end
) break;
1005 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1006 ch1
= FETCH_CHAR (from
);
1007 code
= SYNTAX (ch1
);
1008 if (!(words_include_escapes
1009 && (code
== Sescape
|| code
== Scharquote
)))
1010 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1027 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1028 ch1
= FETCH_CHAR (from
);
1029 code
= SYNTAX (ch1
);
1030 if (words_include_escapes
1031 && (code
== Sescape
|| code
== Scharquote
))
1036 /* Now CH1 is a character which ends a word and FROM is the
1040 if (from
== beg
) break;
1043 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1044 ch0
= FETCH_CHAR (temp_pos
);
1045 code
= SYNTAX (ch0
);
1046 if (!(words_include_escapes
1047 && (code
== Sescape
|| code
== Scharquote
)))
1048 if (code
!= Sword
|| WORD_BOUNDARY_P (ch0
, ch1
))
1061 DEFUN ("forward-word", Fforward_word
, Sforward_word
, 1, 1, "p",
1062 "Move point forward ARG words (backward if ARG is negative).\n\
1063 Normally returns t.\n\
1064 If an edge of the buffer is reached, point is left there\n\
1065 and nil is returned.")
1070 CHECK_NUMBER (count
, 0);
1072 if (!(val
= scan_words (PT
, XINT (count
))))
1074 SET_PT (XINT (count
) > 0 ? ZV
: BEGV
);
1081 Lisp_Object
skip_chars ();
1083 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
1084 "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
1085 STRING is like the inside of a `[...]' in a regular expression\n\
1086 except that `]' is never special and `\\' quotes `^', `-' or `\\'.\n\
1087 Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
1088 With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
1089 Returns the distance traveled, either zero or positive.")
1091 Lisp_Object string
, lim
;
1093 return skip_chars (1, 0, string
, lim
);
1096 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
1097 "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
1098 See `skip-chars-forward' for details.\n\
1099 Returns the distance traveled, either zero or negative.")
1101 Lisp_Object string
, lim
;
1103 return skip_chars (0, 0, string
, lim
);
1106 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
1107 "Move point forward across chars in specified syntax classes.\n\
1108 SYNTAX is a string of syntax code characters.\n\
1109 Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
1110 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1111 This function returns the distance traveled, either zero or positive.")
1113 Lisp_Object syntax
, lim
;
1115 return skip_chars (1, 1, syntax
, lim
);
1118 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
1119 "Move point backward across chars in specified syntax classes.\n\
1120 SYNTAX is a string of syntax code characters.\n\
1121 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
1122 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1123 This function returns the distance traveled, either zero or negative.")
1125 Lisp_Object syntax
, lim
;
1127 return skip_chars (0, 1, syntax
, lim
);
1131 skip_chars (forwardp
, syntaxp
, string
, lim
)
1132 int forwardp
, syntaxp
;
1133 Lisp_Object string
, lim
;
1135 register unsigned char *p
, *pend
;
1136 register unsigned int c
;
1138 unsigned char fastmap
[0400];
1139 /* If SYNTAXP is 0, STRING may contain multi-byte form of characters
1140 of which codes don't fit in FASTMAP. In that case, we set the
1141 first byte of multibyte form (i.e. base leading-code) in FASTMAP
1142 and set the actual ranges of characters in CHAR_RANGES. In the
1143 form "X-Y" of STRING, both X and Y must belong to the same
1144 character set because a range striding across character sets is
1147 = (int *) alloca (XSTRING (string
)->size
* (sizeof (int)) * 2);
1148 int n_char_ranges
= 0;
1151 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1153 CHECK_STRING (string
, 0);
1156 XSETINT (lim
, forwardp
? ZV
: BEGV
);
1158 CHECK_NUMBER_COERCE_MARKER (lim
, 1);
1160 /* In any case, don't allow scan outside bounds of buffer. */
1161 /* jla turned this off, for no known reason.
1162 bfox turned the ZV part on, and rms turned the
1163 BEGV part back on. */
1164 if (XINT (lim
) > ZV
)
1165 XSETFASTINT (lim
, ZV
);
1166 if (XINT (lim
) < BEGV
)
1167 XSETFASTINT (lim
, BEGV
);
1169 p
= XSTRING (string
)->data
;
1170 pend
= p
+ XSTRING (string
)->size
;
1171 bzero (fastmap
, sizeof fastmap
);
1173 if (p
!= pend
&& *p
== '^')
1178 /* Find the characters specified and set their elements of fastmap.
1179 If syntaxp, each character counts as itself.
1180 Otherwise, handle backslashes and ranges specially. */
1187 ch
= STRING_CHAR (p
, pend
- p
);
1188 p
+= BYTES_BY_CHAR_HEAD (*p
);
1196 fastmap
[syntax_spec_code
[c
]] = 1;
1201 if (p
== pend
) break;
1204 if (p
!= pend
&& *p
== '-')
1209 if (p
== pend
) break;
1210 if (SINGLE_BYTE_CHAR_P (ch
))
1218 fastmap
[c
] = 1; /* C is the base leading-code. */
1219 ch2
= STRING_CHAR (p
, pend
- p
);
1221 char_ranges
[n_char_ranges
++] = ch
,
1222 char_ranges
[n_char_ranges
++] = ch2
;
1224 p
+= multibyte
? BYTES_BY_CHAR_HEAD (*p
) : 1;
1229 if (!SINGLE_BYTE_CHAR_P (ch
))
1231 char_ranges
[n_char_ranges
++] = ch
;
1232 char_ranges
[n_char_ranges
++] = ch
;
1238 /* If ^ was the first character, complement the fastmap. In
1239 addition, as all multibyte characters have possibility of
1240 matching, set all entries for base leading codes, which is
1241 harmless even if SYNTAXP is 1. */
1244 for (i
= 0; i
< sizeof fastmap
; i
++)
1246 if (!multibyte
|| !BASE_LEADING_CODE_P (i
))
1253 int start_point
= PT
;
1259 SETUP_SYNTAX_TABLE (pos
, forwardp
? 1 : -1);
1264 while (pos
< XINT (lim
)
1265 && fastmap
[(int) SYNTAX (FETCH_CHAR (pos
))])
1268 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1273 while (pos
< XINT (lim
)
1274 && fastmap
[(int) SYNTAX (FETCH_BYTE (pos
))])
1277 UPDATE_SYNTAX_TABLE_FORWARD (pos
);
1285 while (pos
> XINT (lim
))
1289 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
1290 if (!fastmap
[(int) SYNTAX (FETCH_CHAR (pos
))])
1299 while (pos
> XINT (lim
))
1302 UPDATE_SYNTAX_TABLE_BACKWARD (pos
);
1303 if (!fastmap
[(int) SYNTAX (FETCH_BYTE (pos
))])
1317 while (pos
< XINT (lim
) && fastmap
[(c
= FETCH_BYTE (pos
))])
1319 if (!BASE_LEADING_CODE_P (c
))
1321 else if (n_char_ranges
)
1323 /* We much check CHAR_RANGES for a multibyte
1325 ch
= FETCH_MULTIBYTE_CHAR (pos
);
1326 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1327 if ((ch
>= char_ranges
[i
] && ch
<= char_ranges
[i
+ 1]))
1329 if (!(negate
^ (i
< n_char_ranges
)))
1341 while (pos
< XINT (lim
) && fastmap
[FETCH_BYTE (pos
)])
1347 while (pos
> XINT (lim
))
1351 if (fastmap
[(c
= FETCH_BYTE (pos
))])
1353 if (!BASE_LEADING_CODE_P (c
))
1355 else if (n_char_ranges
)
1357 /* We much check CHAR_RANGES for a multibyte
1359 ch
= FETCH_MULTIBYTE_CHAR (pos
);
1360 for (i
= 0; i
< n_char_ranges
; i
+= 2)
1361 if (ch
>= char_ranges
[i
] && ch
<= char_ranges
[i
+ 1])
1363 if (!(negate
^ (i
< n_char_ranges
)))
1383 while (pos
> XINT (lim
) && fastmap
[FETCH_BYTE (pos
- 1)])
1389 /* INC_POS or DEC_POS might have moved POS over LIM. */
1390 && (forwardp
? (pos
> XINT (lim
)) : (pos
< XINT (lim
))))
1396 return make_number (PT
- start_point
);
1400 DEFUN ("forward-comment", Fforward_comment
, Sforward_comment
, 1, 1, 0,
1401 "Move forward across up to N comments. If N is negative, move backward.\n\
1402 Stop scanning if we find something other than a comment or whitespace.\n\
1403 Set point to where scanning stops.\n\
1404 If N comments are found as expected, with nothing except whitespace\n\
1405 between them, return t; otherwise return nil.")
1412 register enum syntaxcode code
;
1413 int comstyle
= 0; /* style of comment encountered */
1418 CHECK_NUMBER (count
, 0);
1419 count1
= XINT (count
);
1420 stop
= count1
> 0 ? ZV
: BEGV
;
1427 SETUP_SYNTAX_TABLE (from
, count1
);
1438 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1439 c
= FETCH_CHAR (from
);
1443 if (from
< stop
&& SYNTAX_COMSTART_FIRST (c
)
1444 && (c1
= FETCH_CHAR (from
),
1445 SYNTAX_COMSTART_SECOND (c1
)))
1447 /* We have encountered a comment start sequence and we
1448 are ignoring all text inside comments. We must record
1449 the comment style this sequence begins so that later,
1450 only a comment end of the same style actually ends
1451 the comment section. */
1453 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1457 while (code
== Swhitespace
|| code
== Sendcomment
);
1458 if (code
!= Scomment
&& code
!= Scomment_fence
)
1465 /* We're at the start of a comment. */
1474 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1475 c
= FETCH_CHAR (from
);
1477 if (SYNTAX (c
) == Sendcomment
1478 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
1479 /* we have encountered a comment end of the same style
1480 as the comment sequence which began this comment
1483 if (SYNTAX (c
) == Scomment_fence
1484 && comstyle
== ST_COMMENT_STYLE
)
1485 /* we have encountered a comment end of the same style
1486 as the comment sequence which began this comment
1489 if (from
< stop
&& SYNTAX_COMEND_FIRST (c
)
1490 && (c1
= FETCH_CHAR (from
),
1491 SYNTAX_COMEND_SECOND (c1
))
1492 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
1493 /* we have encountered a comment end of the same style
1494 as the comment sequence which began this comment
1496 { INC_POS (from
); break; }
1498 /* We have skipped one comment. */
1509 quoted
= char_quoted (from
);
1513 goto leave
; /* ????? XXXXX */
1515 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1516 c
= FETCH_CHAR (from
);
1519 if (code
== Sendcomment
)
1520 comstyle
= SYNTAX_COMMENT_STYLE (c
);
1523 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1524 && (c1
= FETCH_CHAR (temp_pos
),
1525 SYNTAX_COMEND_FIRST (c1
))
1526 && !char_quoted (temp_pos
))
1528 /* We must record the comment style encountered so that
1529 later, we can match only the proper comment begin
1530 sequence of the same style. */
1532 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1536 if (code
== Scomment_fence
)
1538 /* Skip until first preceding unquoted comment_fence. */
1539 int found
= 0, ini
= from
;
1541 while (--from
!= stop
)
1543 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1544 c
= FETCH_CHAR (from
);
1545 if (SYNTAX (c
) == Scomment_fence
&& !char_quoted (from
))
1553 from
= ini
; /* Set point to ini + 1. */
1557 else if (code
== Sendcomment
)
1560 if (code
!= SYNTAX (c
))
1561 /* For a two-char comment ender, we can assume
1562 it does end a comment. So scan back in a simple way. */
1564 if (from
!= stop
) DEC_POS (from
);
1567 if ((c
= FETCH_CHAR (from
),
1568 SYNTAX (c
) == Scomment
)
1569 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
1578 if (SYNTAX_COMSTART_SECOND (c
)
1579 && (c1
= FETCH_CHAR (from
),
1580 SYNTAX_COMSTART_FIRST (c1
))
1581 && SYNTAX_COMMENT_STYLE (c
) == comstyle
1582 && !char_quoted (from
))
1588 found
= back_comment (from
, stop
);
1589 if (found
!= -1) from
= found
;
1591 /* Look back, counting the parity of string-quotes,
1592 and recording the comment-starters seen.
1593 When we reach a safe place, assume that's not in a string;
1594 then step the main scan to the earliest comment-starter seen
1595 an even number of string quotes away from the safe place.
1597 OFROM[I] is position of the earliest comment-starter seen
1598 which is I+2X quotes from the comment-end.
1599 PARITY is current parity of quotes from the comment end. */
1602 char my_stringend
= 0;
1603 int string_lossage
= 0;
1604 int comment_end
= from
;
1605 int comstart_pos
= 0;
1606 int comstart_parity
= 0;
1607 int scanstart
= from
;
1609 DEC_POS (scanstart
);
1610 /* At beginning of range to scan, we're outside of strings;
1611 that determines quote parity to the comment-end. */
1612 while (from
!= stop
)
1614 /* Move back and examine a character. */
1617 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1618 c
= FETCH_CHAR (from
);
1621 /* If this char is the second of a 2-char comment sequence,
1622 back up and give the pair the appropriate syntax. */
1625 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1626 && (c1
= FETCH_CHAR (temp_pos
),
1627 SYNTAX_COMEND_FIRST (c1
)))
1636 /* If this char starts a 2-char comment start sequence,
1637 treat it like a 1-char comment starter. */
1638 if (from
< scanstart
&& SYNTAX_COMSTART_FIRST (c
)
1639 && (c1
= FETCH_CHAR (temp_pos
),
1640 SYNTAX_COMSTART_SECOND (c1
))
1641 && comstyle
== SYNTAX_COMMENT_STYLE (c1
))
1644 /* Ignore escaped characters. */
1645 if (char_quoted (from
))
1648 /* Track parity of quotes. */
1649 if (code
== Sstring
)
1652 if (my_stringend
== 0)
1654 /* If we have two kinds of string delimiters.
1655 There's no way to grok this scanning backwards. */
1656 else if (my_stringend
!= c
)
1660 /* Record comment-starters according to that
1661 quote-parity to the comment-end. */
1662 if (code
== Scomment
)
1664 comstart_parity
= parity
;
1665 comstart_pos
= from
;
1668 /* If we find another earlier comment-ender,
1669 any comment-starts earlier than that don't count
1670 (because they go with the earlier comment-ender). */
1671 if (code
== Sendcomment
1672 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
)) == comstyle
)
1675 /* Assume a defun-start point is outside of strings. */
1677 && (from
== stop
|| FETCH_BYTE (from
- 1) == '\n'))
1681 if (comstart_pos
== 0)
1683 /* If the earliest comment starter
1684 is followed by uniform paired string quotes or none,
1685 we know it can't be inside a string
1686 since if it were then the comment ender would be inside one.
1687 So it does start a comment. Skip back to it. */
1688 else if (comstart_parity
== 0 && !string_lossage
)
1689 from
= comstart_pos
;
1692 /* We had two kinds of string delimiters mixed up
1693 together. Decode this going forwards.
1694 Scan fwd from the previous comment ender
1695 to the one in question; this records where we
1696 last passed a comment starter. */
1697 struct lisp_parse_state state
;
1698 scan_sexps_forward (&state
, find_defun_start (comment_end
),
1699 comment_end
- 1, -10000, 0, Qnil
, 0);
1700 if (state
.incomment
)
1701 from
= state
.comstr_start
;
1703 /* We can't grok this as a comment; scan it normally. */
1708 /* We have skipped one comment. */
1711 else if (code
!= Swhitespace
&& code
!= Scomment
)
1730 scan_lists (from
, count
, depth
, sexpflag
)
1732 int count
, depth
, sexpflag
;
1735 register int stop
= count
> 0 ? ZV
: BEGV
;
1740 register enum syntaxcode code
, temp_code
;
1741 int min_depth
= depth
; /* Err out if depth gets less than this. */
1742 int comstyle
= 0; /* style of comment encountered */
1744 int last_good
= from
;
1747 if (depth
> 0) min_depth
= 0;
1752 SETUP_SYNTAX_TABLE (from
, count
);
1757 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1758 c
= FETCH_CHAR (from
);
1760 if (depth
== min_depth
)
1763 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1764 if (from
< stop
&& SYNTAX_COMSTART_FIRST (c
)
1765 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
))
1766 && parse_sexp_ignore_comments
)
1768 /* we have encountered a comment start sequence and we
1769 are ignoring all text inside comments. We must record
1770 the comment style this sequence begins so that later,
1771 only a comment end of the same style actually ends
1772 the comment section */
1774 comstyle
= SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
));
1778 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1779 if (SYNTAX_PREFIX (c
))
1782 switch (SWITCH_ENUM_CAST (code
))
1786 if (from
== stop
) goto lose
;
1788 /* treat following character as a word constituent */
1791 if (depth
|| !sexpflag
) break;
1792 /* This word counts as a sexp; return at end of it. */
1795 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1796 switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from
))))
1801 if (from
== stop
) goto lose
;
1815 case Scomment_fence
:
1816 if (!parse_sexp_ignore_comments
) break;
1825 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1826 c
= FETCH_CHAR (from
);
1827 if (code
== Scomment
1828 ? (SYNTAX (c
) == Sendcomment
1829 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
1830 : (SYNTAX (c
) == Scomment_fence
))
1831 /* we have encountered a comment end of the same style
1832 as the comment sequence which began this comment
1836 if (from
< stop
&& SYNTAX_COMEND_FIRST (c
)
1837 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from
))
1838 && SYNTAX_COMMENT_STYLE (c
) == comstyle
1839 && code
== Scomment
)
1840 /* we have encountered a comment end of the same style
1841 as the comment sequence which began this comment
1843 { INC_POS (from
); break; }
1850 if (from
!= stop
&& c
== FETCH_CHAR (from
))
1860 if (!++depth
) goto done
;
1865 if (!--depth
) goto done
;
1866 if (depth
< min_depth
)
1867 Fsignal (Qscan_error
,
1868 Fcons (build_string ("Containing expression ends prematurely"),
1869 Fcons (make_number (last_good
),
1870 Fcons (make_number (from
), Qnil
))));
1877 stringterm
= FETCH_CHAR (temp_pos
);
1880 if (from
>= stop
) goto lose
;
1881 UPDATE_SYNTAX_TABLE_FORWARD (from
);
1883 ? (FETCH_CHAR (from
) == stringterm
)
1884 : SYNTAX (FETCH_CHAR (from
)) == Sstring_fence
)
1886 switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from
))))
1895 if (!depth
&& sexpflag
) goto done
;
1900 /* Reached end of buffer. Error if within object, return nil if between */
1901 if (depth
) goto lose
;
1906 /* End of object reached */
1916 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1917 if (quoted
= char_quoted (from
))
1920 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
1922 c
= FETCH_CHAR (from
);
1924 if (depth
== min_depth
)
1927 if (code
== Sendcomment
)
1928 comstyle
= SYNTAX_COMMENT_STYLE (c
);
1931 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
1932 && (c1
= FETCH_CHAR (temp_pos
), SYNTAX_COMEND_FIRST (c1
))
1933 && !char_quoted (temp_pos
)
1934 && parse_sexp_ignore_comments
)
1936 /* we must record the comment style encountered so that
1937 later, we can match only the proper comment begin
1938 sequence of the same style */
1940 comstyle
= SYNTAX_COMMENT_STYLE (c1
);
1944 if (SYNTAX_PREFIX (c
))
1947 switch (SWITCH_ENUM_CAST (quoted
? Sword
: code
))
1951 if (depth
|| !sexpflag
) break;
1952 /* This word counts as a sexp; count object finished
1953 after passing it. */
1958 UPDATE_SYNTAX_TABLE_BACKWARD (temp_pos
);
1959 quoted
= char_quoted (temp_pos
);
1964 UPDATE_SYNTAX_TABLE_BACKWARD (temp_pos
);
1966 c1
= FETCH_CHAR (temp_pos
);
1967 temp_code
= SYNTAX (c1
);
1968 if (! (quoted
|| temp_code
== Sword
1969 || temp_code
== Ssymbol
1970 || temp_code
== Squote
))
1981 UPDATE_SYNTAX_TABLE_BACKWARD (temp_pos
);
1982 if (from
!= stop
&& c
== FETCH_CHAR (temp_pos
))
1992 if (!++depth
) goto done2
;
1997 if (!--depth
) goto done2
;
1998 if (depth
< min_depth
)
1999 Fsignal (Qscan_error
,
2000 Fcons (build_string ("Containing expression ends prematurely"),
2001 Fcons (make_number (last_good
),
2002 Fcons (make_number (from
), Qnil
))));
2006 if (!parse_sexp_ignore_comments
)
2009 if (code
!= SYNTAX (c
))
2010 /* For a two-char comment ender, we can assume
2011 it does end a comment. So scan back in a simple way. */
2013 if (from
!= stop
) DEC_POS (from
);
2016 if (SYNTAX (c
= FETCH_CHAR (from
)) == Scomment
2017 && SYNTAX_COMMENT_STYLE (c
) == comstyle
)
2026 if (SYNTAX_COMSTART_SECOND (c
)
2027 && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from
))
2028 && SYNTAX_COMMENT_STYLE (c
) == comstyle
2029 && !char_quoted (from
))
2035 found
= back_comment (from
, stop
);
2036 if (found
!= -1) from
= found
;
2038 /* Look back, counting the parity of string-quotes,
2039 and recording the comment-starters seen.
2040 When we reach a safe place, assume that's not in a string;
2041 then step the main scan to the earliest comment-starter seen
2042 an even number of string quotes away from the safe place.
2044 OFROM[I] is position of the earliest comment-starter seen
2045 which is I+2X quotes from the comment-end.
2046 PARITY is current parity of quotes from the comment end. */
2049 char my_stringend
= 0;
2050 int string_lossage
= 0;
2051 int comment_end
= from
;
2052 int comstart_pos
= 0;
2053 int comstart_parity
= 0;
2054 int scanstart
= from
;
2056 DEC_POS (scanstart
);
2058 /* At beginning of range to scan, we're outside of strings;
2059 that determines quote parity to the comment-end. */
2060 while (from
!= stop
)
2062 /* Move back and examine a character. */
2065 c
= FETCH_CHAR (from
);
2068 /* If this char is the second of a 2-char comment sequence,
2069 back up and give the pair the appropriate syntax. */
2072 if (from
> stop
&& SYNTAX_COMEND_SECOND (c
)
2073 && (c1
= FETCH_CHAR (temp_pos
),
2074 SYNTAX_COMEND_FIRST (c1
)))
2081 /* If this char starts a 2-char comment start sequence,
2082 treat it like a 1-char comment starter. */
2085 if (from
< scanstart
&& SYNTAX_COMSTART_FIRST (c
)
2086 && (c1
= FETCH_CHAR (temp_pos
),
2087 SYNTAX_COMSTART_SECOND (c1
))
2088 && comstyle
== SYNTAX_COMMENT_STYLE (c1
))
2091 /* Ignore escaped characters. */
2092 if (char_quoted (from
))
2095 /* Track parity of quotes. */
2096 if (code
== Sstring
)
2099 if (my_stringend
== 0)
2101 /* If we have two kinds of string delimiters.
2102 There's no way to grok this scanning backwards. */
2103 else if (my_stringend
!= c
)
2107 /* Record comment-starters according to that
2108 quote-parity to the comment-end. */
2109 if (code
== Scomment
)
2111 comstart_parity
= parity
;
2112 comstart_pos
= from
;
2115 /* If we find another earlier comment-ender,
2116 any comment-starts earlier than that don't count
2117 (because they go with the earlier comment-ender). */
2118 if (code
== Sendcomment
2119 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
)) == comstyle
)
2122 /* Assume a defun-start point is outside of strings. */
2124 && (from
== stop
|| FETCH_BYTE (from
- 1) == '\n'))
2128 if (comstart_pos
== 0)
2130 /* If the earliest comment starter
2131 is followed by uniform paired string quotes or none,
2132 we know it can't be inside a string
2133 since if it were then the comment ender would be inside one.
2134 So it does start a comment. Skip back to it. */
2135 else if (comstart_parity
== 0 && !string_lossage
)
2136 from
= comstart_pos
;
2139 /* We had two kinds of string delimiters mixed up
2140 together. Decode this going forwards.
2141 Scan fwd from the previous comment ender
2142 to the one in question; this records where we
2143 last passed a comment starter. */
2144 struct lisp_parse_state state
;
2145 scan_sexps_forward (&state
, find_defun_start (comment_end
),
2146 comment_end
- 1, -10000, 0, Qnil
, 0);
2147 if (state
.incomment
)
2148 from
= state
.comstr_start
;
2150 /* We can't grok this as a comment; scan it normally. */
2157 case Scomment_fence
:
2162 if (from
== stop
) goto lose
;
2163 UPDATE_SYNTAX_TABLE_BACKWARD (from
);
2164 if (!char_quoted (from
)
2165 && SYNTAX (FETCH_CHAR (from
)) == code
)
2168 if (code
== Sstring_fence
&& !depth
&& sexpflag
) goto done2
;
2172 stringterm
= FETCH_CHAR (from
);
2175 if (from
== stop
) goto lose
;
2178 UPDATE_SYNTAX_TABLE_BACKWARD (temp_pos
);
2179 if (!char_quoted (temp_pos
)
2180 && stringterm
== FETCH_CHAR (temp_pos
))
2185 if (!depth
&& sexpflag
) goto done2
;
2190 /* Reached start of buffer. Error if within object, return nil if between */
2191 if (depth
) goto lose
;
2202 XSETFASTINT (val
, from
);
2206 Fsignal (Qscan_error
,
2207 Fcons (build_string ("Unbalanced parentheses"),
2208 Fcons (make_number (last_good
),
2209 Fcons (make_number (from
), Qnil
))));
2214 DEFUN ("scan-lists", Fscan_lists
, Sscan_lists
, 3, 3, 0,
2215 "Scan from character number FROM by COUNT lists.\n\
2216 Returns the character number of the position thus found.\n\
2218 If DEPTH is nonzero, paren depth begins counting from that value,\n\
2219 only places where the depth in parentheses becomes zero\n\
2220 are candidates for stopping; COUNT such places are counted.\n\
2221 Thus, a positive value for DEPTH means go out levels.\n\
2223 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2225 If the beginning or end of (the accessible part of) the buffer is reached\n\
2226 and the depth is wrong, an error is signaled.\n\
2227 If the depth is right but the count is not used up, nil is returned.")
2228 (from
, count
, depth
)
2229 Lisp_Object from
, count
, depth
;
2231 CHECK_NUMBER (from
, 0);
2232 CHECK_NUMBER (count
, 1);
2233 CHECK_NUMBER (depth
, 2);
2235 return scan_lists (XINT (from
), XINT (count
), XINT (depth
), 0);
2238 DEFUN ("scan-sexps", Fscan_sexps
, Sscan_sexps
, 2, 2, 0,
2239 "Scan from character number FROM by COUNT balanced expressions.\n\
2240 If COUNT is negative, scan backwards.\n\
2241 Returns the character number of the position thus found.\n\
2243 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2245 If the beginning or end of (the accessible part of) the buffer is reached\n\
2246 in the middle of a parenthetical grouping, an error is signaled.\n\
2247 If the beginning or end is reached between groupings\n\
2248 but before count is used up, nil is returned.")
2250 Lisp_Object from
, count
;
2252 CHECK_NUMBER (from
, 0);
2253 CHECK_NUMBER (count
, 1);
2255 return scan_lists (XINT (from
), XINT (count
), 0, 1);
2258 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars
, Sbackward_prefix_chars
,
2260 "Move point backward over any number of chars with prefix syntax.\n\
2261 This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
2271 SETUP_SYNTAX_TABLE (pos
, -1);
2275 while (pos
> beg
&& !char_quoted (temp_pos
)
2276 /* Previous statement updates syntax table. */
2277 && ((c
= FETCH_CHAR (temp_pos
), SYNTAX (c
) == Squote
)
2278 || SYNTAX_PREFIX (c
)))
2289 /* Parse forward from FROM to END,
2290 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2291 and return a description of the state of the parse at END.
2292 If STOPBEFORE is nonzero, stop at the start of an atom.
2293 If COMMENTSTOP is nonzero, stop at the start of a comment. */
2296 scan_sexps_forward (stateptr
, from
, end
, targetdepth
,
2297 stopbefore
, oldstate
, commentstop
)
2298 struct lisp_parse_state
*stateptr
;
2300 int end
, targetdepth
, stopbefore
;
2301 Lisp_Object oldstate
;
2304 struct lisp_parse_state state
;
2306 register enum syntaxcode code
;
2307 struct level
{ int last
, prev
; };
2308 struct level levelstart
[100];
2309 register struct level
*curlevel
= levelstart
;
2310 struct level
*endlevel
= levelstart
+ 100;
2312 register int depth
; /* Paren depth of current scanning location.
2313 level - levelstart equals this except
2314 when the depth becomes negative. */
2315 int mindepth
; /* Lowest DEPTH value seen. */
2316 int start_quoted
= 0; /* Nonzero means starting after a char quote */
2318 int prev_from
; /* Keep one character before FROM. */
2319 int boundary_stop
= commentstop
== -1;
2323 DEC_POS (prev_from
);
2325 /* Use this macro instead of `from++'. */
2326 #define INC_FROM do { prev_from = from; INC_POS (from); } while (0)
2331 SETUP_SYNTAX_TABLE (from
, 1);
2333 if (NILP (oldstate
))
2336 state
.instring
= -1;
2337 state
.incomment
= 0;
2338 state
.comstyle
= 0; /* comment style a by default. */
2339 state
.comstr_start
= -1; /* no comment/string seen. */
2343 tem
= Fcar (oldstate
);
2349 oldstate
= Fcdr (oldstate
);
2350 oldstate
= Fcdr (oldstate
);
2351 oldstate
= Fcdr (oldstate
);
2352 tem
= Fcar (oldstate
);
2353 /* Check whether we are inside string_fence-style string: */
2354 state
.instring
= ( !NILP (tem
)
2355 ? ( INTEGERP (tem
) ? XINT (tem
) : ST_STRING_STYLE
)
2358 oldstate
= Fcdr (oldstate
);
2359 tem
= Fcar (oldstate
);
2360 state
.incomment
= !NILP (tem
);
2362 oldstate
= Fcdr (oldstate
);
2363 tem
= Fcar (oldstate
);
2364 start_quoted
= !NILP (tem
);
2366 /* if the eight element of the list is nil, we are in comment
2367 style a. If it is non-nil, we are in comment style b */
2368 oldstate
= Fcdr (oldstate
);
2369 oldstate
= Fcdr (oldstate
);
2370 tem
= Fcar (oldstate
);
2371 state
.comstyle
= NILP (tem
) ? 0 : ( EQ (tem
, Qsyntax_table
)
2372 ? ST_COMMENT_STYLE
: 1 );
2374 oldstate
= Fcdr (oldstate
);
2375 tem
= Fcar (oldstate
);
2376 state
.comstr_start
= NILP (tem
) ? -1 : XINT (tem
) ;
2381 curlevel
->prev
= -1;
2382 curlevel
->last
= -1;
2384 /* Enter the loop at a place appropriate for initial state. */
2386 if (state
.incomment
) goto startincomment
;
2387 if (state
.instring
>= 0)
2389 nofence
= state
.instring
!= ST_STRING_STYLE
;
2390 if (start_quoted
) goto startquotedinstring
;
2393 if (start_quoted
) goto startquoted
;
2397 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2398 code
= SYNTAX (FETCH_CHAR (from
));
2400 if (code
== Scomment
)
2401 state
.comstr_start
= prev_from
;
2403 else if (code
== Scomment_fence
2404 || (from
< end
&& SYNTAX_COMSTART_FIRST (FETCH_CHAR (prev_from
))
2405 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from
))))
2407 /* Record the comment style we have entered so that only
2408 the comment-end sequence of the same style actually
2409 terminates the comment section. */
2410 state
.comstyle
= ( code
== Scomment_fence
2412 : SYNTAX_COMMENT_STYLE (FETCH_CHAR (from
)));
2413 state
.comstr_start
= prev_from
;
2414 if (code
!= Scomment_fence
) INC_FROM
;
2418 if (SYNTAX_PREFIX (FETCH_CHAR (prev_from
)))
2420 switch (SWITCH_ENUM_CAST (code
))
2424 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2425 curlevel
->last
= prev_from
;
2427 if (from
== end
) goto endquoted
;
2430 /* treat following character as a word constituent */
2433 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2434 curlevel
->last
= prev_from
;
2438 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2439 switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from
))))
2444 if (from
== end
) goto endquoted
;
2456 curlevel
->prev
= curlevel
->last
;
2460 if (commentstop
== 1)
2464 /* Enter the loop in the middle so that we find
2465 a 2-char comment ender if we start in the middle of it. */
2466 prev
= FETCH_CHAR (prev_from
);
2467 goto startincomment_1
;
2469 /* At beginning of buffer, enter the loop the ordinary way. */
2470 state
.incomment
= 1;
2474 state
.incomment
= 1;
2475 if (commentstop
|| boundary_stop
) goto done
;
2479 if (from
== end
) goto done
;
2480 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2481 prev
= FETCH_CHAR (from
);
2482 if (SYNTAX (prev
) == Sendcomment
2483 && SYNTAX_COMMENT_STYLE (prev
) == state
.comstyle
)
2484 /* Only terminate the comment section if the endcomment
2485 of the same style as the start sequence has been
2488 if (state
.comstyle
== ST_COMMENT_STYLE
2489 && SYNTAX (prev
) == Scomment_fence
)
2493 if (from
< end
&& SYNTAX_COMEND_FIRST (prev
)
2494 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from
))
2495 && SYNTAX_COMMENT_STYLE (prev
) == state
.comstyle
)
2496 /* Only terminate the comment section if the end-comment
2497 sequence of the same style as the start sequence has
2498 been encountered. */
2502 state
.incomment
= 0;
2503 state
.comstyle
= 0; /* reset the comment style */
2504 if (boundary_stop
) goto done
;
2508 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2510 /* curlevel++->last ran into compiler bug on Apollo */
2511 curlevel
->last
= prev_from
;
2512 if (++curlevel
== endlevel
)
2513 error ("Nesting too deep for parser");
2514 curlevel
->prev
= -1;
2515 curlevel
->last
= -1;
2516 if (targetdepth
== depth
) goto done
;
2521 if (depth
< mindepth
)
2523 if (curlevel
!= levelstart
)
2525 curlevel
->prev
= curlevel
->last
;
2526 if (targetdepth
== depth
) goto done
;
2531 state
.comstr_start
= from
- 1;
2532 if (stopbefore
) goto stop
; /* this arg means stop at sexp start */
2533 curlevel
->last
= prev_from
;
2534 state
.instring
= (code
== Sstring
2535 ? (FETCH_CHAR (prev_from
))
2537 if (boundary_stop
) goto done
;
2540 nofence
= state
.instring
!= ST_STRING_STYLE
;
2546 if (from
>= end
) goto done
;
2547 c
= FETCH_CHAR (from
);
2548 if (nofence
&& c
== state
.instring
) break;
2549 UPDATE_SYNTAX_TABLE_FORWARD (from
);
2550 switch (SWITCH_ENUM_CAST (SYNTAX (c
)))
2553 if (!nofence
) goto string_end
;
2558 startquotedinstring
:
2559 if (from
>= end
) goto endquoted
;
2565 state
.instring
= -1;
2566 curlevel
->prev
= curlevel
->last
;
2568 if (boundary_stop
) goto done
;
2577 stop
: /* Here if stopping before start of sexp. */
2578 from
= prev_from
; /* We have just fetched the char that starts it; */
2579 goto done
; /* but return the position before it. */
2584 state
.depth
= depth
;
2585 state
.mindepth
= mindepth
;
2586 state
.thislevelstart
= curlevel
->prev
;
2587 state
.prevlevelstart
2588 = (curlevel
== levelstart
) ? -1 : (curlevel
- 1)->last
;
2589 state
.location
= from
;
2595 /* This comment supplies the doc string for parse-partial-sexp,
2596 for make-docfile to see. We cannot put this in the real DEFUN
2597 due to limits in the Unix cpp.
2599 DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 6, 0,
2600 "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
2601 Parsing stops at TO or when certain criteria are met;\n\
2602 point is set to where parsing stops.\n\
2603 If fifth arg STATE is omitted or nil,\n\
2604 parsing assumes that FROM is the beginning of a function.\n\
2605 Value is a list of nine elements describing final state of parsing:\n\
2606 0. depth in parens.\n\
2607 1. character address of start of innermost containing list; nil if none.\n\
2608 2. character address of start of last complete sexp terminated.\n\
2609 3. non-nil if inside a string.\n\
2610 (it is the character that will terminate the string,\n\
2611 or t if the string should be terminated by an explicit\n\
2612 `syntax-table' property.)\n\
2613 4. t if inside a comment.\n\
2614 5. t if following a quote character.\n\
2615 6. the minimum paren-depth encountered during this scan.\n\
2616 7. t if in a comment of style `b'; `syntax-table' if given by an explicit\n\
2617 `syntax-table' property.\n\
2618 8. character address of start of last comment or string; nil if none.\n\
2619 If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
2620 in parentheses becomes equal to TARGETDEPTH.\n\
2621 Fourth arg STOPBEFORE non-nil means stop when come to\n\
2622 any character that starts a sexp.\n\
2623 Fifth arg STATE is an eight-list like what this function returns.\n\
2624 It is used to initialize the state of the parse. Its second and third
2625 elements are ignored.
2626 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment. If\n\
2627 it is `syntax-table', stop after the start of a comment or a string, or\n\
2628 after end of a comment or a string.")
2629 (from, to, targetdepth, stopbefore, state, commentstop)
2632 DEFUN ("parse-partial-sexp", Fparse_partial_sexp
, Sparse_partial_sexp
, 2, 6, 0,
2633 0 /* See immediately above */)
2634 (from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
)
2635 Lisp_Object from
, to
, targetdepth
, stopbefore
, oldstate
, commentstop
;
2637 struct lisp_parse_state state
;
2640 if (!NILP (targetdepth
))
2642 CHECK_NUMBER (targetdepth
, 3);
2643 target
= XINT (targetdepth
);
2646 target
= -100000; /* We won't reach this depth */
2648 validate_region (&from
, &to
);
2649 scan_sexps_forward (&state
, XINT (from
), XINT (to
),
2650 target
, !NILP (stopbefore
), oldstate
,
2652 ? 0 : (EQ (commentstop
, Qsyntax_table
) ? -1 : 1)));
2654 SET_PT (state
.location
);
2656 return Fcons (make_number (state
.depth
),
2657 Fcons (state
.prevlevelstart
< 0 ? Qnil
: make_number (state
.prevlevelstart
),
2658 Fcons (state
.thislevelstart
< 0 ? Qnil
: make_number (state
.thislevelstart
),
2659 Fcons (state
.instring
>= 0
2660 ? (state
.instring
== ST_STRING_STYLE
2661 ? Qt
: make_number (state
.instring
)) : Qnil
,
2662 Fcons (state
.incomment
? Qt
: Qnil
,
2663 Fcons (state
.quoted
? Qt
: Qnil
,
2664 Fcons (make_number (state
.mindepth
),
2665 Fcons (state
.comstyle
2666 ? (state
.comstyle
== ST_COMMENT_STYLE
2667 ? Qsyntax_table
: Qt
) : Qnil
,
2668 Fcons (state
.comstr_start
!= -1 ? make_number (state
.comstr_start
) : Qnil
,
2677 /* This has to be done here, before we call Fmake_char_table. */
2678 Qsyntax_table
= intern ("syntax-table");
2679 staticpro (&Qsyntax_table
);
2681 /* Intern this now in case it isn't already done.
2682 Setting this variable twice is harmless.
2683 But don't staticpro it here--that is done in alloc.c. */
2684 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
2686 /* Create objects which can be shared among syntax tables. */
2687 Vsyntax_code_object
= Fmake_vector (13, Qnil
);
2688 for (i
= 0; i
< XVECTOR (Vsyntax_code_object
)->size
; i
++)
2689 XVECTOR (Vsyntax_code_object
)->contents
[i
]
2690 = Fcons (make_number (i
), Qnil
);
2692 /* Now we are ready to set up this property, so we can
2693 create syntax tables. */
2694 Fput (Qsyntax_table
, Qchar_table_extra_slots
, make_number (0));
2696 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Swhitespace
];
2698 Vstandard_syntax_table
= Fmake_char_table (Qsyntax_table
, temp
);
2700 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Sword
];
2701 for (i
= 'a'; i
<= 'z'; i
++)
2702 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2703 for (i
= 'A'; i
<= 'Z'; i
++)
2704 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2705 for (i
= '0'; i
<= '9'; i
++)
2706 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, i
, temp
);
2708 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '$', temp
);
2709 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '%', temp
);
2711 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '(',
2712 Fcons (make_number (Sopen
), make_number (')')));
2713 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ')',
2714 Fcons (make_number (Sclose
), make_number ('(')));
2715 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '[',
2716 Fcons (make_number (Sopen
), make_number (']')));
2717 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, ']',
2718 Fcons (make_number (Sclose
), make_number ('[')));
2719 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '{',
2720 Fcons (make_number (Sopen
), make_number ('}')));
2721 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '}',
2722 Fcons (make_number (Sclose
), make_number ('{')));
2723 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '"',
2724 Fcons (make_number ((int) Sstring
), Qnil
));
2725 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, '\\',
2726 Fcons (make_number ((int) Sescape
), Qnil
));
2728 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Ssymbol
];
2729 for (i
= 0; i
< 10; i
++)
2731 c
= "_-+*/&|<>="[i
];
2732 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2735 temp
= XVECTOR (Vsyntax_code_object
)->contents
[(int) Spunct
];
2736 for (i
= 0; i
< 12; i
++)
2738 c
= ".,;:?!#@~^'`"[i
];
2739 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table
, c
, temp
);
2745 Qsyntax_table_p
= intern ("syntax-table-p");
2746 staticpro (&Qsyntax_table_p
);
2748 staticpro (&Vsyntax_code_object
);
2750 Qscan_error
= intern ("scan-error");
2751 staticpro (&Qscan_error
);
2752 Fput (Qscan_error
, Qerror_conditions
,
2753 Fcons (Qerror
, Qnil
));
2754 Fput (Qscan_error
, Qerror_message
,
2755 build_string ("Scan error"));
2757 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments
,
2758 "Non-nil means `forward-sexp', etc., should treat comments as whitespace.");
2760 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties
,
2761 "Non-nil means `forward-sexp', etc., grant `syntax-table' property.\n\
2762 The value of this property should be either a syntax table, or a cons\n\
2763 of the form (SYNTAXCODE . MATCHCHAR), SYNTAXCODE being the numeric\n\
2764 syntax code, MATCHCHAR being nil or the character to match (which is\n\
2765 relevant only for open/close type.");
2767 words_include_escapes
= 0;
2768 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes
,
2769 "Non-nil means `forward-word', etc., should treat escape chars part of words.");
2771 defsubr (&Ssyntax_table_p
);
2772 defsubr (&Ssyntax_table
);
2773 defsubr (&Sstandard_syntax_table
);
2774 defsubr (&Scopy_syntax_table
);
2775 defsubr (&Sset_syntax_table
);
2776 defsubr (&Schar_syntax
);
2777 defsubr (&Smatching_paren
);
2778 defsubr (&Smodify_syntax_entry
);
2779 defsubr (&Sdescribe_syntax
);
2781 defsubr (&Sforward_word
);
2783 defsubr (&Sskip_chars_forward
);
2784 defsubr (&Sskip_chars_backward
);
2785 defsubr (&Sskip_syntax_forward
);
2786 defsubr (&Sskip_syntax_backward
);
2788 defsubr (&Sforward_comment
);
2789 defsubr (&Sscan_lists
);
2790 defsubr (&Sscan_sexps
);
2791 defsubr (&Sbackward_prefix_chars
);
2792 defsubr (&Sparse_partial_sexp
);