(cvs-enabledp): Ignore errors.
[emacs.git] / src / syntax.c
blob758bec2cf92a5b8db36ba3cc8f86e4c413751a30
1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
2 Copyright (C) 1985, 87, 93, 94, 95, 97, 1998, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
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. */
22 #include <config.h>
23 #include <ctype.h>
24 #include "lisp.h"
25 #include "commands.h"
26 #include "buffer.h"
27 #include "charset.h"
29 /* Make syntax table lookup grant data in gl_state. */
30 #define SYNTAX_ENTRY_VIA_PROPERTY
32 #include "syntax.h"
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)
41 #include "category.h"
43 Lisp_Object Qsyntax_table_p, Qsyntax_table, Qscan_error;
45 int words_include_escapes;
46 int parse_sexp_lookup_properties;
48 /* Nonzero means `scan-sexps' treat all multibyte characters as symbol. */
49 int multibyte_syntax_as_symbol;
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 /* Non-zero means an open parenthesis in column 0 is always considered
57 to be the start of a defun. Zero means an open parenthesis in
58 column 0 has no special meaning. */
60 int open_paren_in_column_0_is_defun_start;
62 /* This is the internal form of the parse state used in parse-partial-sexp. */
64 struct lisp_parse_state
66 int depth; /* Depth at end of parsing. */
67 int instring; /* -1 if not within string, else desired terminator. */
68 int incomment; /* -1 if in unnestable comment else comment nesting */
69 int comstyle; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
70 int quoted; /* Nonzero if just after an escape char at end of parsing */
71 int thislevelstart; /* Char number of most recent start-of-expression at current level */
72 int prevlevelstart; /* Char number of start of containing expression */
73 int location; /* Char number at which parsing stopped. */
74 int mindepth; /* Minimum depth seen while scanning. */
75 int comstr_start; /* Position just after last comment/string starter. */
76 Lisp_Object levelstarts; /* Char numbers of starts-of-expression
77 of levels (starting from outermost). */
80 /* These variables are a cache for finding the start of a defun.
81 find_start_pos is the place for which the defun start was found.
82 find_start_value is the defun start position found for it.
83 find_start_value_byte is the corresponding byte position.
84 find_start_buffer is the buffer it was found in.
85 find_start_begv is the BEGV value when it was found.
86 find_start_modiff is the value of MODIFF when it was found. */
88 static int find_start_pos;
89 static int find_start_value;
90 static int find_start_value_byte;
91 static struct buffer *find_start_buffer;
92 static int find_start_begv;
93 static int find_start_modiff;
96 static int find_defun_start P_ ((int, int));
97 static int back_comment P_ ((int, int, int, int, int, int *, int *));
98 static int char_quoted P_ ((int, int));
99 static Lisp_Object skip_chars P_ ((int, int, Lisp_Object, Lisp_Object));
100 static Lisp_Object scan_lists P_ ((int, int, int, int));
101 static void scan_sexps_forward P_ ((struct lisp_parse_state *,
102 int, int, int, int,
103 int, Lisp_Object, int));
106 struct gl_state_s gl_state; /* Global state of syntax parser. */
108 INTERVAL interval_of ();
109 #define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
110 to scan to property-change. */
112 /* Update gl_state to an appropriate interval which contains CHARPOS. The
113 sign of COUNT give the relative position of CHARPOS wrt the previously
114 valid interval. If INIT, only [be]_property fields of gl_state are
115 valid at start, the rest is filled basing on OBJECT.
117 `gl_state.*_i' are the intervals, and CHARPOS is further in the search
118 direction than the intervals - or in an interval. We update the
119 current syntax-table basing on the property of this interval, and
120 update the interval to start further than CHARPOS - or be
121 NULL_INTERVAL. We also update lim_property to be the next value of
122 charpos to call this subroutine again - or be before/after the
123 start/end of OBJECT. */
125 void
126 update_syntax_table (charpos, count, init, object)
127 int charpos, count, init;
128 Lisp_Object object;
130 Lisp_Object tmp_table;
131 int cnt = 0, invalidate = 1;
132 INTERVAL i, oldi;
134 if (init)
136 gl_state.start = gl_state.b_property;
137 gl_state.stop = gl_state.e_property;
138 gl_state.forward_i = interval_of (charpos, object);
139 i = gl_state.backward_i = gl_state.forward_i;
140 gl_state.left_ok = gl_state.right_ok = 1;
141 invalidate = 0;
142 if (NULL_INTERVAL_P (i))
143 return;
144 /* interval_of updates only ->position of the return value, so
145 update the parents manually to speed up update_interval. */
146 while (!NULL_PARENT (i))
148 if (AM_RIGHT_CHILD (i))
149 INTERVAL_PARENT (i)->position = i->position
150 - LEFT_TOTAL_LENGTH (i) + TOTAL_LENGTH (i) /* right end */
151 - TOTAL_LENGTH (INTERVAL_PARENT (i))
152 + LEFT_TOTAL_LENGTH (INTERVAL_PARENT (i));
153 else
154 INTERVAL_PARENT (i)->position = i->position - LEFT_TOTAL_LENGTH (i)
155 + TOTAL_LENGTH (i);
156 i = INTERVAL_PARENT (i);
158 i = gl_state.forward_i;
159 gl_state.b_property = i->position - 1 - gl_state.offset;
160 gl_state.e_property = INTERVAL_LAST_POS (i) - gl_state.offset;
161 goto update;
163 oldi = i = count > 0 ? gl_state.forward_i : gl_state.backward_i;
165 /* We are guarantied to be called with CHARPOS either in i,
166 or further off. */
167 if (NULL_INTERVAL_P (i))
168 error ("Error in syntax_table logic for to-the-end intervals");
169 else if (charpos < i->position) /* Move left. */
171 if (count > 0)
172 error ("Error in syntax_table logic for intervals <-");
173 /* Update the interval. */
174 i = update_interval (i, charpos);
175 if (oldi->position != INTERVAL_LAST_POS (i))
177 invalidate = 0;
178 gl_state.right_ok = 1; /* Invalidate the other end. */
179 gl_state.forward_i = i;
180 gl_state.e_property = INTERVAL_LAST_POS (i) - gl_state.offset;
183 else if (charpos >= INTERVAL_LAST_POS (i)) /* Move right. */
185 if (count < 0)
186 error ("Error in syntax_table logic for intervals ->");
187 /* Update the interval. */
188 i = update_interval (i, charpos);
189 if (i->position != INTERVAL_LAST_POS (oldi))
191 invalidate = 0;
192 gl_state.left_ok = 1; /* Invalidate the other end. */
193 gl_state.backward_i = i;
194 gl_state.b_property = i->position - 1 - gl_state.offset;
197 else if (count > 0 ? gl_state.right_ok : gl_state.left_ok)
199 /* We do not need to recalculate tmp_table. */
200 tmp_table = gl_state.old_prop;
203 update:
204 tmp_table = textget (i->plist, Qsyntax_table);
206 if (invalidate)
207 invalidate = !EQ (tmp_table, gl_state.old_prop); /* Need to invalidate? */
209 if (invalidate) /* Did not get to adjacent interval. */
210 { /* with the same table => */
211 /* invalidate the old range. */
212 if (count > 0)
214 gl_state.backward_i = i;
215 gl_state.left_ok = 1; /* Invalidate the other end. */
216 gl_state.b_property = i->position - 1 - gl_state.offset;
218 else
220 gl_state.forward_i = i;
221 gl_state.right_ok = 1; /* Invalidate the other end. */
222 gl_state.e_property = INTERVAL_LAST_POS (i) - gl_state.offset;
226 gl_state.current_syntax_table = tmp_table;
227 gl_state.old_prop = tmp_table;
228 if (EQ (Fsyntax_table_p (tmp_table), Qt))
230 gl_state.use_global = 0;
232 else if (CONSP (tmp_table))
234 gl_state.use_global = 1;
235 gl_state.global_code = tmp_table;
237 else
239 gl_state.use_global = 0;
240 gl_state.current_syntax_table = current_buffer->syntax_table;
243 while (!NULL_INTERVAL_P (i))
245 if (cnt && !EQ (tmp_table, textget (i->plist, Qsyntax_table)))
247 if (count > 0)
248 gl_state.right_ok = 0;
249 else
250 gl_state.left_ok = 0;
251 break;
253 else if (cnt == INTERVALS_AT_ONCE)
255 if (count > 0)
256 gl_state.right_ok = 1;
257 else
258 gl_state.left_ok = 1;
259 break;
261 cnt++;
262 i = count > 0 ? next_interval (i) : previous_interval (i);
264 if (NULL_INTERVAL_P (i))
265 { /* This property goes to the end. */
266 if (count > 0)
267 gl_state.e_property = gl_state.stop;
268 else
269 gl_state.b_property = gl_state.start;
271 else
273 if (count > 0)
275 gl_state.e_property = i->position - gl_state.offset;
276 gl_state.forward_i = i;
278 else
280 gl_state.b_property = i->position + LENGTH (i) - 1 - gl_state.offset;
281 gl_state.backward_i = i;
286 /* Returns TRUE if char at CHARPOS is quoted.
287 Global syntax-table data should be set up already to be good at CHARPOS
288 or after. On return global syntax data is good for lookup at CHARPOS. */
290 static int
291 char_quoted (charpos, bytepos)
292 register int charpos, bytepos;
294 register enum syntaxcode code;
295 register int beg = BEGV;
296 register int quoted = 0;
297 int orig = charpos;
299 DEC_BOTH (charpos, bytepos);
301 while (bytepos >= beg)
303 UPDATE_SYNTAX_TABLE_BACKWARD (charpos);
304 code = SYNTAX (FETCH_CHAR (bytepos));
305 if (! (code == Scharquote || code == Sescape))
306 break;
308 DEC_BOTH (charpos, bytepos);
309 quoted = !quoted;
312 UPDATE_SYNTAX_TABLE (orig);
313 return quoted;
316 /* Return the bytepos one character after BYTEPOS.
317 We assume that BYTEPOS is not at the end of the buffer. */
319 INLINE int
320 inc_bytepos (bytepos)
321 int bytepos;
323 if (NILP (current_buffer->enable_multibyte_characters))
324 return bytepos + 1;
326 INC_POS (bytepos);
327 return bytepos;
330 /* Return the bytepos one character before BYTEPOS.
331 We assume that BYTEPOS is not at the start of the buffer. */
333 INLINE int
334 dec_bytepos (bytepos)
335 int bytepos;
337 if (NILP (current_buffer->enable_multibyte_characters))
338 return bytepos - 1;
340 DEC_POS (bytepos);
341 return bytepos;
344 /* Find a defun-start that is the last one before POS (or nearly the last).
345 We record what we find, so that another call in the same area
346 can return the same value right away.
348 There is no promise at which position the global syntax data is
349 valid on return from the subroutine, so the caller should explicitly
350 update the global data. */
352 static int
353 find_defun_start (pos, pos_byte)
354 int pos, pos_byte;
356 int opoint = PT, opoint_byte = PT_BYTE;
358 /* Use previous finding, if it's valid and applies to this inquiry. */
359 if (current_buffer == find_start_buffer
360 /* Reuse the defun-start even if POS is a little farther on.
361 POS might be in the next defun, but that's ok.
362 Our value may not be the best possible, but will still be usable. */
363 && pos <= find_start_pos + 1000
364 && pos >= find_start_value
365 && BEGV == find_start_begv
366 && MODIFF == find_start_modiff)
367 return find_start_value;
369 /* Back up to start of line. */
370 scan_newline (pos, pos_byte, BEGV, BEGV_BYTE, -1, 1);
372 /* We optimize syntax-table lookup for rare updates. Thus we accept
373 only those `^\s(' which are good in global _and_ text-property
374 syntax-tables. */
375 gl_state.current_syntax_table = current_buffer->syntax_table;
376 gl_state.use_global = 0;
377 if (open_paren_in_column_0_is_defun_start)
379 while (PT > BEGV)
381 /* Open-paren at start of line means we may have found our
382 defun-start. */
383 if (SYNTAX (FETCH_CHAR (PT_BYTE)) == Sopen)
385 SETUP_SYNTAX_TABLE (PT + 1, -1); /* Try again... */
386 if (SYNTAX (FETCH_CHAR (PT_BYTE)) == Sopen)
387 break;
388 /* Now fallback to the default value. */
389 gl_state.current_syntax_table = current_buffer->syntax_table;
390 gl_state.use_global = 0;
392 /* Move to beg of previous line. */
393 scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -2, 1);
397 /* Record what we found, for the next try. */
398 find_start_value = PT;
399 find_start_value_byte = PT_BYTE;
400 find_start_buffer = current_buffer;
401 find_start_modiff = MODIFF;
402 find_start_begv = BEGV;
403 find_start_pos = pos;
405 TEMP_SET_PT_BOTH (opoint, opoint_byte);
407 return find_start_value;
410 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
412 static int
413 prev_char_comend_first (pos, pos_byte)
414 int pos, pos_byte;
416 int c, val;
418 DEC_BOTH (pos, pos_byte);
419 UPDATE_SYNTAX_TABLE_BACKWARD (pos);
420 c = FETCH_CHAR (pos_byte);
421 val = SYNTAX_COMEND_FIRST (c);
422 UPDATE_SYNTAX_TABLE_FORWARD (pos + 1);
423 return val;
426 /* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
428 /* static int
429 * prev_char_comstart_first (pos, pos_byte)
430 * int pos, pos_byte;
432 * int c, val;
434 * DEC_BOTH (pos, pos_byte);
435 * UPDATE_SYNTAX_TABLE_BACKWARD (pos);
436 * c = FETCH_CHAR (pos_byte);
437 * val = SYNTAX_COMSTART_FIRST (c);
438 * UPDATE_SYNTAX_TABLE_FORWARD (pos + 1);
439 * return val;
440 * } */
442 /* Checks whether charpos FROM is at the end of a comment.
443 FROM_BYTE is the bytepos corresponding to FROM.
444 Do not move back before STOP.
446 Return a positive value if we find a comment ending at FROM/FROM_BYTE;
447 return -1 otherwise.
449 If successful, store the charpos of the comment's beginning
450 into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
452 Global syntax data remains valid for backward search starting at
453 the returned value (or at FROM, if the search was not successful). */
455 static int
456 back_comment (from, from_byte, stop, comnested, comstyle, charpos_ptr, bytepos_ptr)
457 int from, from_byte, stop;
458 int comnested, comstyle;
459 int *charpos_ptr, *bytepos_ptr;
461 /* Look back, counting the parity of string-quotes,
462 and recording the comment-starters seen.
463 When we reach a safe place, assume that's not in a string;
464 then step the main scan to the earliest comment-starter seen
465 an even number of string quotes away from the safe place.
467 OFROM[I] is position of the earliest comment-starter seen
468 which is I+2X quotes from the comment-end.
469 PARITY is current parity of quotes from the comment end. */
470 int string_style = -1; /* Presumed outside of any string. */
471 int string_lossage = 0;
472 /* Not a real lossage: indicates that we have passed a matching comment
473 starter plus an non-matching comment-ender, meaning that any matching
474 comment-starter we might see later could be a false positive (hidden
475 inside another comment).
476 Test case: { a (* b } c (* d *) */
477 int comment_lossage = 0;
478 int comment_end = from;
479 int comment_end_byte = from_byte;
480 int comstart_pos = 0;
481 int comstart_byte;
482 /* Place where the containing defun starts,
483 or 0 if we didn't come across it yet. */
484 int defun_start = 0;
485 int defun_start_byte = 0;
486 register enum syntaxcode code;
487 int nesting = 1; /* current comment nesting */
488 int c;
489 int syntax = 0;
491 /* FIXME: A }} comment-ender style leads to incorrect behavior
492 in the case of {{ c }}} because we ignore the last two chars which are
493 assumed to be comment-enders although they aren't. */
495 /* At beginning of range to scan, we're outside of strings;
496 that determines quote parity to the comment-end. */
497 while (from != stop)
499 int temp_byte, prev_syntax;
500 int com2start, com2end;
502 /* Move back and examine a character. */
503 DEC_BOTH (from, from_byte);
504 UPDATE_SYNTAX_TABLE_BACKWARD (from);
506 prev_syntax = syntax;
507 c = FETCH_CHAR (from_byte);
508 syntax = SYNTAX_WITH_FLAGS (c);
509 code = SYNTAX (c);
511 /* Check for 2-char comment markers. */
512 com2start = (SYNTAX_FLAGS_COMSTART_FIRST (syntax)
513 && SYNTAX_FLAGS_COMSTART_SECOND (prev_syntax)
514 && comstyle == SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax)
515 && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax)
516 || SYNTAX_FLAGS_COMMENT_NESTED (syntax)) == comnested);
517 com2end = (SYNTAX_FLAGS_COMEND_FIRST (syntax)
518 && SYNTAX_FLAGS_COMEND_SECOND (prev_syntax));
520 /* Nasty cases with overlapping 2-char comment markers:
521 - snmp-mode: -- c -- foo -- c --
522 --- c --
523 ------ c --
524 - c-mode: *||*
525 |* *|* *|
526 |*| |* |*|
527 /// */
529 /* If a 2-char comment sequence partly overlaps with another,
530 we don't try to be clever. */
531 if (from > stop && (com2end || com2start))
533 int next = from, next_byte = from_byte, next_c, next_syntax;
534 DEC_BOTH (next, next_byte);
535 UPDATE_SYNTAX_TABLE_BACKWARD (next);
536 next_c = FETCH_CHAR (next_byte);
537 next_syntax = SYNTAX_WITH_FLAGS (next_c);
538 if (((com2start || comnested)
539 && SYNTAX_FLAGS_COMEND_SECOND (syntax)
540 && SYNTAX_FLAGS_COMEND_FIRST (next_syntax))
541 || ((com2end || comnested)
542 && SYNTAX_FLAGS_COMSTART_SECOND (syntax)
543 && comstyle == SYNTAX_FLAGS_COMMENT_STYLE (syntax)
544 && SYNTAX_FLAGS_COMSTART_FIRST (next_syntax)))
545 goto lossage;
546 /* UPDATE_SYNTAX_TABLE_FORWARD (next + 1); */
549 if (com2start && comstart_pos == 0)
550 /* We're looking at a comment starter. But it might be a comment
551 ender as well (see snmp-mode). The first time we see one, we
552 need to consider it as a comment starter,
553 and the subsequent times as a comment ender. */
554 com2end = 0;
556 /* Turn a 2-char comment sequences into the appropriate syntax. */
557 if (com2end)
558 code = Sendcomment;
559 else if (com2start)
560 code = Scomment;
561 /* Ignore comment starters of a different style. */
562 else if (code == Scomment
563 && (comstyle != SYNTAX_FLAGS_COMMENT_STYLE (syntax)
564 || SYNTAX_FLAGS_COMMENT_NESTED (syntax) != comnested))
565 continue;
567 /* Ignore escaped characters, except comment-enders. */
568 if (code != Sendcomment && char_quoted (from, from_byte))
569 continue;
571 switch (code)
573 case Sstring_fence:
574 case Scomment_fence:
575 c = (code == Sstring_fence ? ST_STRING_STYLE : ST_COMMENT_STYLE);
576 case Sstring:
577 /* Track parity of quotes. */
578 if (string_style == -1)
579 /* Entering a string. */
580 string_style = c;
581 else if (string_style == c)
582 /* Leaving the string. */
583 string_style = -1;
584 else
585 /* If we have two kinds of string delimiters.
586 There's no way to grok this scanning backwards. */
587 string_lossage = 1;
588 break;
590 case Scomment:
591 /* We've already checked that it is the relevant comstyle. */
592 if (string_style != -1 || comment_lossage || string_lossage)
593 /* There are odd string quotes involved, so let's be careful.
594 Test case in Pascal: " { " a { " } */
595 goto lossage;
597 if (!comnested)
599 /* Record best comment-starter so far. */
600 comstart_pos = from;
601 comstart_byte = from_byte;
603 else if (--nesting <= 0)
604 /* nested comments have to be balanced, so we don't need to
605 keep looking for earlier ones. We use here the same (slightly
606 incorrect) reasoning as below: since it is followed by uniform
607 paired string quotes, this comment-start has to be outside of
608 strings, else the comment-end itself would be inside a string. */
609 goto done;
610 break;
612 case Sendcomment:
613 if (SYNTAX_FLAGS_COMMENT_STYLE (syntax) == comstyle
614 && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax)
615 || SYNTAX_FLAGS_COMMENT_NESTED (syntax)) == comnested)
616 /* This is the same style of comment ender as ours. */
618 if (comnested)
619 nesting++;
620 else
621 /* Anything before that can't count because it would match
622 this comment-ender rather than ours. */
623 from = stop; /* Break out of the loop. */
625 else if (comstart_pos != 0 || c != '\n')
626 /* We're mixing comment styles here, so we'd better be careful.
627 The (comstart_pos != 0 || c != '\n') check is not quite correct
628 (we should just always set comment_lossage), but removing it
629 would imply that any multiline comment in C would go through
630 lossage, which seems overkill.
631 The failure should only happen in the rare cases such as
632 { (* } *) */
633 comment_lossage = 1;
634 break;
636 case Sopen:
637 /* Assume a defun-start point is outside of strings. */
638 if (open_paren_in_column_0_is_defun_start
639 && (from == stop
640 || (temp_byte = dec_bytepos (from_byte),
641 FETCH_CHAR (temp_byte) == '\n')))
643 defun_start = from;
644 defun_start_byte = from_byte;
645 from = stop; /* Break out of the loop. */
647 break;
649 default:
650 break;
654 if (comstart_pos == 0)
656 from = comment_end;
657 from_byte = comment_end_byte;
658 UPDATE_SYNTAX_TABLE_FORWARD (comment_end - 1);
660 /* If comstart_pos is set and we get here (ie. didn't jump to `lossage'
661 or `done'), then we've found the beginning of the non-nested comment. */
662 else if (1) /* !comnested */
664 from = comstart_pos;
665 from_byte = comstart_byte;
666 /* Globals are correct now. */
668 else
670 struct lisp_parse_state state;
671 lossage:
672 /* We had two kinds of string delimiters mixed up
673 together. Decode this going forwards.
674 Scan fwd from a known safe place (beginning-of-defun)
675 to the one in question; this records where we
676 last passed a comment starter. */
677 /* If we did not already find the defun start, find it now. */
678 if (defun_start == 0)
680 defun_start = find_defun_start (comment_end, comment_end_byte);
681 defun_start_byte = find_start_value_byte;
685 scan_sexps_forward (&state,
686 defun_start, defun_start_byte,
687 comment_end, -10000, 0, Qnil, 0);
688 defun_start = comment_end;
689 if (state.incomment == (comnested ? 1 : -1)
690 && state.comstyle == comstyle)
691 from = state.comstr_start;
692 else
694 from = comment_end;
695 if (state.incomment)
696 /* If comment_end is inside some other comment, maybe ours
697 is nested, so we need to try again from within the
698 surrounding comment. Example: { a (* " *) */
700 /* FIXME: We should advance by one or two chars. */
701 defun_start = state.comstr_start + 2;
702 defun_start_byte = CHAR_TO_BYTE (defun_start);
705 } while (defun_start < comment_end);
707 from_byte = CHAR_TO_BYTE (from);
708 UPDATE_SYNTAX_TABLE_FORWARD (from - 1);
711 done:
712 *charpos_ptr = from;
713 *bytepos_ptr = from_byte;
715 return (from == comment_end) ? -1 : from;
718 DEFUN ("syntax-table-p", Fsyntax_table_p, Ssyntax_table_p, 1, 1, 0,
719 "Return t if OBJECT is a syntax table.\n\
720 Currently, any char-table counts as a syntax table.")
721 (object)
722 Lisp_Object object;
724 if (CHAR_TABLE_P (object)
725 && EQ (XCHAR_TABLE (object)->purpose, Qsyntax_table))
726 return Qt;
727 return Qnil;
730 static void
731 check_syntax_table (obj)
732 Lisp_Object obj;
734 if (!(CHAR_TABLE_P (obj)
735 && EQ (XCHAR_TABLE (obj)->purpose, Qsyntax_table)))
736 wrong_type_argument (Qsyntax_table_p, obj);
739 DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 0, 0,
740 "Return the current syntax table.\n\
741 This is the one specified by the current buffer.")
744 return current_buffer->syntax_table;
747 DEFUN ("standard-syntax-table", Fstandard_syntax_table,
748 Sstandard_syntax_table, 0, 0, 0,
749 "Return the standard syntax table.\n\
750 This is the one used for new buffers.")
753 return Vstandard_syntax_table;
756 DEFUN ("copy-syntax-table", Fcopy_syntax_table, Scopy_syntax_table, 0, 1, 0,
757 "Construct a new syntax table and return it.\n\
758 It is a copy of the TABLE, which defaults to the standard syntax table.")
759 (table)
760 Lisp_Object table;
762 Lisp_Object copy;
764 if (!NILP (table))
765 check_syntax_table (table);
766 else
767 table = Vstandard_syntax_table;
769 copy = Fcopy_sequence (table);
771 /* Only the standard syntax table should have a default element.
772 Other syntax tables should inherit from parents instead. */
773 XCHAR_TABLE (copy)->defalt = Qnil;
775 /* Copied syntax tables should all have parents.
776 If we copied one with no parent, such as the standard syntax table,
777 use the standard syntax table as the copy's parent. */
778 if (NILP (XCHAR_TABLE (copy)->parent))
779 Fset_char_table_parent (copy, Vstandard_syntax_table);
780 return copy;
783 DEFUN ("set-syntax-table", Fset_syntax_table, Sset_syntax_table, 1, 1, 0,
784 "Select a new syntax table for the current buffer.\n\
785 One argument, a syntax table.")
786 (table)
787 Lisp_Object table;
789 int idx;
790 check_syntax_table (table);
791 current_buffer->syntax_table = table;
792 /* Indicate that this buffer now has a specified syntax table. */
793 idx = PER_BUFFER_VAR_IDX (syntax_table);
794 SET_PER_BUFFER_VALUE_P (current_buffer, idx, 1);
795 return table;
798 /* Convert a letter which signifies a syntax code
799 into the code it signifies.
800 This is used by modify-syntax-entry, and other things. */
802 unsigned char syntax_spec_code[0400] =
803 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
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 (char) Swhitespace, (char) Scomment_fence, (char) Sstring, 0377,
808 (char) Smath, 0377, 0377, (char) Squote,
809 (char) Sopen, (char) Sclose, 0377, 0377,
810 0377, (char) Swhitespace, (char) Spunct, (char) Scharquote,
811 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
812 0377, 0377, 0377, 0377,
813 (char) Scomment, 0377, (char) Sendcomment, 0377,
814 (char) Sinherit, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
815 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
816 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword,
817 0377, 0377, 0377, 0377, (char) Sescape, 0377, 0377, (char) Ssymbol,
818 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
819 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
820 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword,
821 0377, 0377, 0377, 0377, (char) Sstring_fence, 0377, 0377, 0377
824 /* Indexed by syntax code, give the letter that describes it. */
826 char syntax_code_spec[16] =
828 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
829 '!', '|'
832 /* Indexed by syntax code, give the object (cons of syntax code and
833 nil) to be stored in syntax table. Since these objects can be
834 shared among syntax tables, we generate them in advance. By
835 sharing objects, the function `describe-syntax' can give a more
836 compact listing. */
837 static Lisp_Object Vsyntax_code_object;
840 /* Look up the value for CHARACTER in syntax table TABLE's parent
841 and its parents. SYNTAX_ENTRY calls this, when TABLE itself has nil
842 for CHARACTER. It's actually used only when not compiled with GCC. */
844 Lisp_Object
845 syntax_parent_lookup (table, character)
846 Lisp_Object table;
847 int character;
849 Lisp_Object value;
851 while (1)
853 table = XCHAR_TABLE (table)->parent;
854 if (NILP (table))
855 return Qnil;
857 value = XCHAR_TABLE (table)->contents[character];
858 if (!NILP (value))
859 return value;
863 DEFUN ("char-syntax", Fchar_syntax, Schar_syntax, 1, 1, 0,
864 "Return the syntax code of CHARACTER, described by a character.\n\
865 For example, if CHARACTER is a word constituent,\n\
866 the character `w' is returned.\n\
867 The characters that correspond to various syntax codes\n\
868 are listed in the documentation of `modify-syntax-entry'.")
869 (character)
870 Lisp_Object character;
872 int char_int;
873 gl_state.current_syntax_table = current_buffer->syntax_table;
875 gl_state.use_global = 0;
876 CHECK_NUMBER (character, 0);
877 char_int = XINT (character);
878 return make_number (syntax_code_spec[(int) SYNTAX (char_int)]);
881 DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 1, 0,
882 "Return the matching parenthesis of CHARACTER, or nil if none.")
883 (character)
884 Lisp_Object character;
886 int char_int, code;
887 gl_state.current_syntax_table = current_buffer->syntax_table;
888 gl_state.use_global = 0;
889 CHECK_NUMBER (character, 0);
890 char_int = XINT (character);
891 code = SYNTAX (char_int);
892 if (code == Sopen || code == Sclose)
893 return SYNTAX_MATCH (char_int);
894 return Qnil;
897 DEFUN ("string-to-syntax", Fstring_to_syntax, Sstring_to_syntax, 1, 1, 0,
898 "Convert a syntax specification STRING into syntax cell form.\n\
899 STRING should be a string as it is allowed as argument of\n\
900 `modify-syntax-entry'. Value is the equivalent cons cell\n\
901 \(CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'\n\
902 text property.")
903 (string)
904 Lisp_Object string;
906 register unsigned char *p;
907 register enum syntaxcode code;
908 int val;
909 Lisp_Object match;
911 CHECK_STRING (string, 0);
913 p = XSTRING (string)->data;
914 code = (enum syntaxcode) syntax_spec_code[*p++];
915 if (((int) code & 0377) == 0377)
916 error ("invalid syntax description letter: %c", p[-1]);
918 if (code == Sinherit)
919 return Qnil;
921 if (*p)
923 int len;
924 int character = (STRING_CHAR_AND_LENGTH
925 (p, STRING_BYTES (XSTRING (string)) - 1, len));
926 XSETINT (match, character);
927 if (XFASTINT (match) == ' ')
928 match = Qnil;
929 p += len;
931 else
932 match = Qnil;
934 val = (int) code;
935 while (*p)
936 switch (*p++)
938 case '1':
939 val |= 1 << 16;
940 break;
942 case '2':
943 val |= 1 << 17;
944 break;
946 case '3':
947 val |= 1 << 18;
948 break;
950 case '4':
951 val |= 1 << 19;
952 break;
954 case 'p':
955 val |= 1 << 20;
956 break;
958 case 'b':
959 val |= 1 << 21;
960 break;
962 case 'n':
963 val |= 1 << 22;
964 break;
967 if (val < XVECTOR (Vsyntax_code_object)->size && NILP (match))
968 return XVECTOR (Vsyntax_code_object)->contents[val];
969 else
970 /* Since we can't use a shared object, let's make a new one. */
971 return Fcons (make_number (val), match);
974 /* This comment supplies the doc string for modify-syntax-entry,
975 for make-docfile to see. We cannot put this in the real DEFUN
976 due to limits in the Unix cpp.
978 DEFUN ("modify-syntax-entry", foo, bar, 2, 3, 0,
979 "Set syntax for character CHAR according to string S.\n\
980 The syntax is changed only for table TABLE, which defaults to\n\
981 the current buffer's syntax table.\n\
982 The first character of S should be one of the following:\n\
983 Space or - whitespace syntax. w word constituent.\n\
984 _ symbol constituent. . punctuation.\n\
985 ( open-parenthesis. ) close-parenthesis.\n\
986 \" string quote. \\ escape.\n\
987 $ paired delimiter. ' expression quote or prefix operator.\n\
988 < comment starter. > comment ender.\n\
989 / character-quote. @ inherit from `standard-syntax-table'.\n\
990 | generic string fence. ! generic comment fence.\n\
992 Only single-character comment start and end sequences are represented thus.\n\
993 Two-character sequences are represented as described below.\n\
994 The second character of S is the matching parenthesis,\n\
995 used only if the first character is `(' or `)'.\n\
996 Any additional characters are flags.\n\
997 Defined flags are the characters 1, 2, 3, 4, b, p, and n.\n\
998 1 means CHAR is the start of a two-char comment start sequence.\n\
999 2 means CHAR is the second character of such a sequence.\n\
1000 3 means CHAR is the start of a two-char comment end sequence.\n\
1001 4 means CHAR is the second character of such a sequence.\n\
1003 There can be up to two orthogonal comment sequences. This is to support\n\
1004 language modes such as C++. By default, all comment sequences are of style\n\
1005 a, but you can set the comment sequence style to b (on the second character\n\
1006 of a comment-start, or the first character of a comment-end sequence) using\n\
1007 this flag:\n\
1008 b means CHAR is part of comment sequence b.\n\
1009 n means CHAR is part of a nestable comment sequence.\n\
1011 p means CHAR is a prefix character for `backward-prefix-chars';\n\
1012 such characters are treated as whitespace when they occur\n\
1013 between expressions.")
1014 (char, s, table)
1017 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3,
1018 /* I really don't know why this is interactive
1019 help-form should at least be made useful whilst reading the second arg
1021 "cSet syntax for character: \nsSet syntax for %s to: ",
1022 0 /* See immediately above */)
1023 (c, newentry, syntax_table)
1024 Lisp_Object c, newentry, syntax_table;
1026 CHECK_NUMBER (c, 0);
1028 if (NILP (syntax_table))
1029 syntax_table = current_buffer->syntax_table;
1030 else
1031 check_syntax_table (syntax_table);
1033 SET_RAW_SYNTAX_ENTRY (syntax_table, XINT (c), Fstring_to_syntax (newentry));
1034 return Qnil;
1037 /* Dump syntax table to buffer in human-readable format */
1039 static void
1040 describe_syntax (value)
1041 Lisp_Object value;
1043 register enum syntaxcode code;
1044 char desc, start1, start2, end1, end2, prefix, comstyle, comnested;
1045 char str[2];
1046 Lisp_Object first, match_lisp;
1048 Findent_to (make_number (16), make_number (1));
1050 if (NILP (value))
1052 insert_string ("default\n");
1053 return;
1056 if (CHAR_TABLE_P (value))
1058 insert_string ("deeper char-table ...\n");
1059 return;
1062 if (!CONSP (value))
1064 insert_string ("invalid\n");
1065 return;
1068 first = XCAR (value);
1069 match_lisp = XCDR (value);
1071 if (!INTEGERP (first) || !(NILP (match_lisp) || INTEGERP (match_lisp)))
1073 insert_string ("invalid\n");
1074 return;
1077 code = (enum syntaxcode) (XINT (first) & 0377);
1078 start1 = (XINT (first) >> 16) & 1;
1079 start2 = (XINT (first) >> 17) & 1;
1080 end1 = (XINT (first) >> 18) & 1;
1081 end2 = (XINT (first) >> 19) & 1;
1082 prefix = (XINT (first) >> 20) & 1;
1083 comstyle = (XINT (first) >> 21) & 1;
1084 comnested = (XINT (first) >> 22) & 1;
1086 if ((int) code < 0 || (int) code >= (int) Smax)
1088 insert_string ("invalid");
1089 return;
1091 desc = syntax_code_spec[(int) code];
1093 str[0] = desc, str[1] = 0;
1094 insert (str, 1);
1096 if (NILP (match_lisp))
1097 insert (" ", 1);
1098 else
1099 insert_char (XINT (match_lisp));
1101 if (start1)
1102 insert ("1", 1);
1103 if (start2)
1104 insert ("2", 1);
1106 if (end1)
1107 insert ("3", 1);
1108 if (end2)
1109 insert ("4", 1);
1111 if (prefix)
1112 insert ("p", 1);
1113 if (comstyle)
1114 insert ("b", 1);
1115 if (comnested)
1116 insert ("n", 1);
1118 insert_string ("\twhich means: ");
1120 switch (SWITCH_ENUM_CAST (code))
1122 case Swhitespace:
1123 insert_string ("whitespace"); break;
1124 case Spunct:
1125 insert_string ("punctuation"); break;
1126 case Sword:
1127 insert_string ("word"); break;
1128 case Ssymbol:
1129 insert_string ("symbol"); break;
1130 case Sopen:
1131 insert_string ("open"); break;
1132 case Sclose:
1133 insert_string ("close"); break;
1134 case Squote:
1135 insert_string ("prefix"); break;
1136 case Sstring:
1137 insert_string ("string"); break;
1138 case Smath:
1139 insert_string ("math"); break;
1140 case Sescape:
1141 insert_string ("escape"); break;
1142 case Scharquote:
1143 insert_string ("charquote"); break;
1144 case Scomment:
1145 insert_string ("comment"); break;
1146 case Sendcomment:
1147 insert_string ("endcomment"); break;
1148 case Sinherit:
1149 insert_string ("inherit"); break;
1150 case Scomment_fence:
1151 insert_string ("comment fence"); break;
1152 case Sstring_fence:
1153 insert_string ("string fence"); break;
1154 default:
1155 insert_string ("invalid");
1156 return;
1159 if (!NILP (match_lisp))
1161 insert_string (", matches ");
1162 insert_char (XINT (match_lisp));
1165 if (start1)
1166 insert_string (",\n\t is the first character of a comment-start sequence");
1167 if (start2)
1168 insert_string (",\n\t is the second character of a comment-start sequence");
1170 if (end1)
1171 insert_string (",\n\t is the first character of a comment-end sequence");
1172 if (end2)
1173 insert_string (",\n\t is the second character of a comment-end sequence");
1174 if (comstyle)
1175 insert_string (" (comment style b)");
1176 if (comnested)
1177 insert_string (" (nestable)");
1179 if (prefix)
1180 insert_string (",\n\t is a prefix character for `backward-prefix-chars'");
1182 insert_string ("\n");
1185 static Lisp_Object
1186 describe_syntax_1 (vector)
1187 Lisp_Object vector;
1189 struct buffer *old = current_buffer;
1190 set_buffer_internal (XBUFFER (Vstandard_output));
1191 describe_vector (vector, Qnil, describe_syntax, 0, Qnil, Qnil, (int *) 0, 0);
1192 while (! NILP (XCHAR_TABLE (vector)->parent))
1194 vector = XCHAR_TABLE (vector)->parent;
1195 insert_string ("\nThe parent syntax table is:");
1196 describe_vector (vector, Qnil, describe_syntax, 0, Qnil, Qnil,
1197 (int *) 0, 0);
1200 call0 (intern ("help-mode"));
1201 set_buffer_internal (old);
1202 return Qnil;
1205 DEFUN ("describe-syntax", Fdescribe_syntax, Sdescribe_syntax, 0, 0, "",
1206 "Describe the syntax specifications in the syntax table.\n\
1207 The descriptions are inserted in a buffer, which is then displayed.")
1210 internal_with_output_to_temp_buffer
1211 ("*Help*", describe_syntax_1, current_buffer->syntax_table);
1213 return Qnil;
1216 int parse_sexp_ignore_comments;
1218 /* Return the position across COUNT words from FROM.
1219 If that many words cannot be found before the end of the buffer, return 0.
1220 COUNT negative means scan backward and stop at word beginning. */
1223 scan_words (from, count)
1224 register int from, count;
1226 register int beg = BEGV;
1227 register int end = ZV;
1228 register int from_byte = CHAR_TO_BYTE (from);
1229 register enum syntaxcode code;
1230 int ch0, ch1;
1232 immediate_quit = 1;
1233 QUIT;
1235 SETUP_SYNTAX_TABLE (from, count);
1237 while (count > 0)
1239 while (1)
1241 if (from == end)
1243 immediate_quit = 0;
1244 return 0;
1246 UPDATE_SYNTAX_TABLE_FORWARD (from);
1247 ch0 = FETCH_CHAR (from_byte);
1248 code = SYNTAX (ch0);
1249 INC_BOTH (from, from_byte);
1250 if (words_include_escapes
1251 && (code == Sescape || code == Scharquote))
1252 break;
1253 if (code == Sword)
1254 break;
1256 /* Now CH0 is a character which begins a word and FROM is the
1257 position of the next character. */
1258 while (1)
1260 if (from == end) break;
1261 UPDATE_SYNTAX_TABLE_FORWARD (from);
1262 ch1 = FETCH_CHAR (from_byte);
1263 code = SYNTAX (ch1);
1264 if (!(words_include_escapes
1265 && (code == Sescape || code == Scharquote)))
1266 if (code != Sword || WORD_BOUNDARY_P (ch0, ch1))
1267 break;
1268 INC_BOTH (from, from_byte);
1269 ch0 = ch1;
1271 count--;
1273 while (count < 0)
1275 while (1)
1277 if (from == beg)
1279 immediate_quit = 0;
1280 return 0;
1282 DEC_BOTH (from, from_byte);
1283 UPDATE_SYNTAX_TABLE_BACKWARD (from);
1284 ch1 = FETCH_CHAR (from_byte);
1285 code = SYNTAX (ch1);
1286 if (words_include_escapes
1287 && (code == Sescape || code == Scharquote))
1288 break;
1289 if (code == Sword)
1290 break;
1292 /* Now CH1 is a character which ends a word and FROM is the
1293 position of it. */
1294 while (1)
1296 int temp_byte;
1298 if (from == beg)
1299 break;
1300 temp_byte = dec_bytepos (from_byte);
1301 UPDATE_SYNTAX_TABLE_BACKWARD (from);
1302 ch0 = FETCH_CHAR (temp_byte);
1303 code = SYNTAX (ch0);
1304 if (!(words_include_escapes
1305 && (code == Sescape || code == Scharquote)))
1306 if (code != Sword || WORD_BOUNDARY_P (ch0, ch1))
1307 break;
1308 DEC_BOTH (from, from_byte);
1309 ch1 = ch0;
1311 count++;
1314 immediate_quit = 0;
1316 return from;
1319 DEFUN ("forward-word", Fforward_word, Sforward_word, 1, 1, "p",
1320 "Move point forward ARG words (backward if ARG is negative).\n\
1321 Normally returns t.\n\
1322 If an edge of the buffer or a field boundary is reached, point is left there\n\
1323 and the function returns nil. Field boundaries are not noticed if\n\
1324 `inhibit-field-text-motion' is non-nil.")
1325 (count)
1326 Lisp_Object count;
1328 int orig_val, val;
1329 CHECK_NUMBER (count, 0);
1331 val = orig_val = scan_words (PT, XINT (count));
1332 if (! orig_val)
1333 val = XINT (count) > 0 ? ZV : BEGV;
1335 /* Avoid jumping out of an input field. */
1336 val = XFASTINT (Fconstrain_to_field (make_number (val), make_number (PT),
1337 Qt, Qnil, Qnil));
1339 SET_PT (val);
1340 return val == orig_val ? Qt : Qnil;
1343 Lisp_Object skip_chars ();
1345 DEFUN ("skip-chars-forward", Fskip_chars_forward, Sskip_chars_forward, 1, 2, 0,
1346 "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
1347 STRING is like the inside of a `[...]' in a regular expression\n\
1348 except that `]' is never special and `\\' quotes `^', `-' or `\\'\n\
1349 (but not as the end of a range; quoting is never needed there).\n\
1350 Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
1351 With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
1352 Returns the distance traveled, either zero or positive.")
1353 (string, lim)
1354 Lisp_Object string, lim;
1356 return skip_chars (1, 0, string, lim);
1359 DEFUN ("skip-chars-backward", Fskip_chars_backward, Sskip_chars_backward, 1, 2, 0,
1360 "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
1361 See `skip-chars-forward' for details.\n\
1362 Returns the distance traveled, either zero or negative.")
1363 (string, lim)
1364 Lisp_Object string, lim;
1366 return skip_chars (0, 0, string, lim);
1369 DEFUN ("skip-syntax-forward", Fskip_syntax_forward, Sskip_syntax_forward, 1, 2, 0,
1370 "Move point forward across chars in specified syntax classes.\n\
1371 SYNTAX is a string of syntax code characters.\n\
1372 Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
1373 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1374 This function returns the distance traveled, either zero or positive.")
1375 (syntax, lim)
1376 Lisp_Object syntax, lim;
1378 return skip_chars (1, 1, syntax, lim);
1381 DEFUN ("skip-syntax-backward", Fskip_syntax_backward, Sskip_syntax_backward, 1, 2, 0,
1382 "Move point backward across chars in specified syntax classes.\n\
1383 SYNTAX is a string of syntax code characters.\n\
1384 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
1385 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
1386 This function returns the distance traveled, either zero or negative.")
1387 (syntax, lim)
1388 Lisp_Object syntax, lim;
1390 return skip_chars (0, 1, syntax, lim);
1393 static Lisp_Object
1394 skip_chars (forwardp, syntaxp, string, lim)
1395 int forwardp, syntaxp;
1396 Lisp_Object string, lim;
1398 register unsigned int c;
1399 unsigned char fastmap[0400];
1400 /* If SYNTAXP is 0, STRING may contain multi-byte form of characters
1401 of which codes don't fit in FASTMAP. In that case, set the
1402 ranges of characters in CHAR_RANGES. */
1403 int *char_ranges;
1404 int n_char_ranges = 0;
1405 int negate = 0;
1406 register int i, i_byte;
1407 int multibyte = !NILP (current_buffer->enable_multibyte_characters);
1408 int string_multibyte;
1409 int size_byte;
1410 unsigned char *str;
1411 int len;
1413 CHECK_STRING (string, 0);
1414 char_ranges = (int *) alloca (XSTRING (string)->size * (sizeof (int)) * 2);
1415 string_multibyte = STRING_MULTIBYTE (string);
1416 str = XSTRING (string)->data;
1417 size_byte = STRING_BYTES (XSTRING (string));
1419 /* Adjust the multibyteness of the string to that of the buffer. */
1420 if (multibyte != string_multibyte)
1422 int nbytes;
1424 if (multibyte)
1425 nbytes = count_size_as_multibyte (XSTRING (string)->data,
1426 XSTRING (string)->size);
1427 else
1428 nbytes = XSTRING (string)->size;
1429 if (nbytes != size_byte)
1431 str = (unsigned char *) alloca (nbytes);
1432 copy_text (XSTRING (string)->data, str, size_byte,
1433 string_multibyte, multibyte);
1434 size_byte = nbytes;
1438 if (NILP (lim))
1439 XSETINT (lim, forwardp ? ZV : BEGV);
1440 else
1441 CHECK_NUMBER_COERCE_MARKER (lim, 0);
1443 /* In any case, don't allow scan outside bounds of buffer. */
1444 if (XINT (lim) > ZV)
1445 XSETFASTINT (lim, ZV);
1446 if (XINT (lim) < BEGV)
1447 XSETFASTINT (lim, BEGV);
1449 bzero (fastmap, sizeof fastmap);
1451 i_byte = 0;
1453 if (i_byte < size_byte
1454 && XSTRING (string)->data[0] == '^')
1456 negate = 1; i_byte++;
1459 /* Find the characters specified and set their elements of fastmap.
1460 If syntaxp, each character counts as itself.
1461 Otherwise, handle backslashes and ranges specially. */
1463 while (i_byte < size_byte)
1465 c = STRING_CHAR_AND_LENGTH (str + i_byte, size_byte - i_byte, len);
1466 i_byte += len;
1468 if (syntaxp)
1469 fastmap[syntax_spec_code[c & 0377]] = 1;
1470 else
1472 if (c == '\\')
1474 if (i_byte == size_byte)
1475 break;
1477 c = STRING_CHAR_AND_LENGTH (str+i_byte, size_byte-i_byte, len);
1478 i_byte += len;
1480 if (i_byte < size_byte
1481 && str[i_byte] == '-')
1483 unsigned int c2;
1485 /* Skip over the dash. */
1486 i_byte++;
1488 if (i_byte == size_byte)
1489 break;
1491 /* Get the end of the range. */
1492 c2 =STRING_CHAR_AND_LENGTH (str+i_byte, size_byte-i_byte, len);
1493 i_byte += len;
1495 if (SINGLE_BYTE_CHAR_P (c))
1497 if (! SINGLE_BYTE_CHAR_P (c2))
1499 /* Handle a range starting with a character of
1500 less than 256, and ending with a character of
1501 not less than 256. Split that into two
1502 ranges, the low one ending at 0377, and the
1503 high one starting at the smallest character
1504 in the charset of C2 and ending at C2. */
1505 int charset = CHAR_CHARSET (c2);
1506 int c1 = MAKE_CHAR (charset, 0, 0);
1508 char_ranges[n_char_ranges++] = c1;
1509 char_ranges[n_char_ranges++] = c2;
1510 c2 = 0377;
1512 while (c <= c2)
1514 fastmap[c] = 1;
1515 c++;
1518 else if (c <= c2) /* Both C and C2 are multibyte char. */
1520 char_ranges[n_char_ranges++] = c;
1521 char_ranges[n_char_ranges++] = c2;
1524 else
1526 if (SINGLE_BYTE_CHAR_P (c))
1527 fastmap[c] = 1;
1528 else
1530 char_ranges[n_char_ranges++] = c;
1531 char_ranges[n_char_ranges++] = c;
1537 /* If ^ was the first character, complement the fastmap. */
1538 if (negate)
1539 for (i = 0; i < sizeof fastmap; i++)
1540 fastmap[i] ^= 1;
1543 int start_point = PT;
1544 int pos = PT;
1545 int pos_byte = PT_BYTE;
1547 immediate_quit = 1;
1548 if (syntaxp)
1550 SETUP_SYNTAX_TABLE (pos, forwardp ? 1 : -1);
1551 if (forwardp)
1553 if (multibyte)
1555 if (pos < XINT (lim))
1556 while (fastmap[(int) SYNTAX (FETCH_CHAR (pos_byte))])
1558 /* Since we already checked for multibyteness,
1559 avoid using INC_BOTH which checks again. */
1560 INC_POS (pos_byte);
1561 pos++;
1562 if (pos >= XINT (lim))
1563 break;
1564 UPDATE_SYNTAX_TABLE_FORWARD (pos);
1567 else
1569 while (pos < XINT (lim)
1570 && fastmap[(int) SYNTAX (FETCH_BYTE (pos))])
1572 pos++;
1573 UPDATE_SYNTAX_TABLE_FORWARD (pos);
1577 else
1579 if (multibyte)
1581 while (pos > XINT (lim))
1583 int savepos = pos_byte;
1584 /* Since we already checked for multibyteness,
1585 avoid using DEC_BOTH which checks again. */
1586 pos--;
1587 DEC_POS (pos_byte);
1588 UPDATE_SYNTAX_TABLE_BACKWARD (pos);
1589 if (!fastmap[(int) SYNTAX (FETCH_CHAR (pos_byte))])
1591 pos++;
1592 pos_byte = savepos;
1593 break;
1597 else
1599 if (pos > XINT (lim))
1600 while (fastmap[(int) SYNTAX (FETCH_BYTE (pos - 1))])
1602 pos--;
1603 if (pos <= XINT (lim))
1604 break;
1605 UPDATE_SYNTAX_TABLE_BACKWARD (pos - 1);
1610 else
1612 if (forwardp)
1614 if (multibyte)
1615 while (pos < XINT (lim))
1617 c = FETCH_MULTIBYTE_CHAR (pos_byte);
1618 if (SINGLE_BYTE_CHAR_P (c))
1620 if (!fastmap[c])
1621 break;
1623 else
1625 /* If we are looking at a multibyte character,
1626 we must look up the character in the table
1627 CHAR_RANGES. If there's no data in the
1628 table, that character is not what we want to
1629 skip. */
1631 /* The following code do the right thing even if
1632 n_char_ranges is zero (i.e. no data in
1633 CHAR_RANGES). */
1634 for (i = 0; i < n_char_ranges; i += 2)
1635 if (c >= char_ranges[i] && c <= char_ranges[i + 1])
1636 break;
1637 if (!(negate ^ (i < n_char_ranges)))
1638 break;
1640 INC_BOTH (pos, pos_byte);
1642 else
1643 while (pos < XINT (lim) && fastmap[FETCH_BYTE (pos)])
1644 pos++;
1646 else
1648 if (multibyte)
1649 while (pos > XINT (lim))
1651 int prev_pos_byte = pos_byte;
1653 DEC_POS (prev_pos_byte);
1654 c = FETCH_MULTIBYTE_CHAR (prev_pos_byte);
1655 if (SINGLE_BYTE_CHAR_P (c))
1657 if (!fastmap[c])
1658 break;
1660 else
1662 /* See the comment in the previous similar code. */
1663 for (i = 0; i < n_char_ranges; i += 2)
1664 if (c >= char_ranges[i] && c <= char_ranges[i + 1])
1665 break;
1666 if (!(negate ^ (i < n_char_ranges)))
1667 break;
1669 pos--;
1670 pos_byte = prev_pos_byte;
1672 else
1673 while (pos > XINT (lim) && fastmap[FETCH_BYTE (pos - 1)])
1674 pos--;
1678 #if 0 /* Not needed now that a position in mid-character
1679 cannot be specified in Lisp. */
1680 if (multibyte
1681 /* INC_POS or DEC_POS might have moved POS over LIM. */
1682 && (forwardp ? (pos > XINT (lim)) : (pos < XINT (lim))))
1683 pos = XINT (lim);
1684 #endif
1686 if (! multibyte)
1687 pos_byte = pos;
1689 SET_PT_BOTH (pos, pos_byte);
1690 immediate_quit = 0;
1692 return make_number (PT - start_point);
1696 /* Jump over a comment, assuming we are at the beginning of one.
1697 FROM is the current position.
1698 FROM_BYTE is the bytepos corresponding to FROM.
1699 Do not move past STOP (a charpos).
1700 The comment over which we have to jump is of style STYLE
1701 (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
1702 NESTING should be positive to indicate the nesting at the beginning
1703 for nested comments and should be zero or negative else.
1704 ST_COMMENT_STYLE cannot be nested.
1705 PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
1706 (or 0 If the search cannot start in the middle of a two-character).
1708 If successful, return 1 and store the charpos of the comment's end
1709 into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
1710 Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
1711 corresponding bytepos into *BYTEPOS_PTR and the current nesting
1712 (as defined for state.incomment) in *INCOMMENT_PTR.
1714 The comment end is the last character of the comment rather than the
1715 character just after the comment.
1717 Global syntax data is assumed to initially be valid for FROM and
1718 remains valid for forward search starting at the returned position. */
1720 static int
1721 forw_comment (from, from_byte, stop, nesting, style, prev_syntax,
1722 charpos_ptr, bytepos_ptr, incomment_ptr)
1723 int from, from_byte, stop;
1724 int nesting, style, prev_syntax;
1725 int *charpos_ptr, *bytepos_ptr, *incomment_ptr;
1727 register int c, c1;
1728 register enum syntaxcode code;
1729 register int syntax;
1731 if (nesting <= 0) nesting = -1;
1733 /* Enter the loop in the middle so that we find
1734 a 2-char comment ender if we start in the middle of it. */
1735 syntax = prev_syntax;
1736 if (syntax != 0) goto forw_incomment;
1738 while (1)
1740 if (from == stop)
1742 *incomment_ptr = nesting;
1743 *charpos_ptr = from;
1744 *bytepos_ptr = from_byte;
1745 return 0;
1747 c = FETCH_CHAR (from_byte);
1748 syntax = SYNTAX_WITH_FLAGS (c);
1749 code = syntax & 0xff;
1750 if (code == Sendcomment
1751 && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style
1752 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax) ?
1753 (nesting > 0 && --nesting == 0) : nesting < 0))
1754 /* we have encountered a comment end of the same style
1755 as the comment sequence which began this comment
1756 section */
1757 break;
1758 if (code == Scomment_fence
1759 && style == ST_COMMENT_STYLE)
1760 /* we have encountered a comment end of the same style
1761 as the comment sequence which began this comment
1762 section. */
1763 break;
1764 if (nesting > 0
1765 && code == Scomment
1766 && SYNTAX_FLAGS_COMMENT_NESTED (syntax)
1767 && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style)
1768 /* we have encountered a nested comment of the same style
1769 as the comment sequence which began this comment section */
1770 nesting++;
1771 INC_BOTH (from, from_byte);
1772 UPDATE_SYNTAX_TABLE_FORWARD (from);
1774 forw_incomment:
1775 if (from < stop && SYNTAX_FLAGS_COMEND_FIRST (syntax)
1776 && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style
1777 && (c1 = FETCH_CHAR (from_byte),
1778 SYNTAX_COMEND_SECOND (c1))
1779 && ((SYNTAX_FLAGS_COMMENT_NESTED (syntax) ||
1780 SYNTAX_COMMENT_NESTED (c1)) ? nesting > 0 : nesting < 0))
1782 if (--nesting <= 0)
1783 /* we have encountered a comment end of the same style
1784 as the comment sequence which began this comment
1785 section */
1786 break;
1787 else
1789 INC_BOTH (from, from_byte);
1790 UPDATE_SYNTAX_TABLE_FORWARD (from);
1793 if (nesting > 0
1794 && from < stop
1795 && SYNTAX_FLAGS_COMSTART_FIRST (syntax)
1796 && (c1 = FETCH_CHAR (from_byte),
1797 SYNTAX_COMMENT_STYLE (c1) == style
1798 && SYNTAX_COMSTART_SECOND (c1))
1799 && (SYNTAX_FLAGS_COMMENT_NESTED (syntax) ||
1800 SYNTAX_COMMENT_NESTED (c1)))
1801 /* we have encountered a nested comment of the same style
1802 as the comment sequence which began this comment
1803 section */
1805 INC_BOTH (from, from_byte);
1806 UPDATE_SYNTAX_TABLE_FORWARD (from);
1807 nesting++;
1810 *charpos_ptr = from;
1811 *bytepos_ptr = from_byte;
1812 return 1;
1815 DEFUN ("forward-comment", Fforward_comment, Sforward_comment, 1, 1, 0,
1816 "Move forward across up to N comments. If N is negative, move backward.\n\
1817 Stop scanning if we find something other than a comment or whitespace.\n\
1818 Set point to where scanning stops.\n\
1819 If N comments are found as expected, with nothing except whitespace\n\
1820 between them, return t; otherwise return nil.")
1821 (count)
1822 Lisp_Object count;
1824 register int from;
1825 int from_byte;
1826 register int stop;
1827 register int c, c1;
1828 register enum syntaxcode code;
1829 int comstyle = 0; /* style of comment encountered */
1830 int comnested = 0; /* whether the comment is nestable or not */
1831 int found;
1832 int count1;
1833 int out_charpos, out_bytepos;
1834 int dummy;
1836 CHECK_NUMBER (count, 0);
1837 count1 = XINT (count);
1838 stop = count1 > 0 ? ZV : BEGV;
1840 immediate_quit = 1;
1841 QUIT;
1843 from = PT;
1844 from_byte = PT_BYTE;
1846 SETUP_SYNTAX_TABLE (from, count1);
1847 while (count1 > 0)
1851 int comstart_first;
1853 if (from == stop)
1855 SET_PT_BOTH (from, from_byte);
1856 immediate_quit = 0;
1857 return Qnil;
1859 c = FETCH_CHAR (from_byte);
1860 code = SYNTAX (c);
1861 comstart_first = SYNTAX_COMSTART_FIRST (c);
1862 comnested = SYNTAX_COMMENT_NESTED (c);
1863 comstyle = SYNTAX_COMMENT_STYLE (c);
1864 INC_BOTH (from, from_byte);
1865 UPDATE_SYNTAX_TABLE_FORWARD (from);
1866 if (from < stop && comstart_first
1867 && (c1 = FETCH_CHAR (from_byte),
1868 SYNTAX_COMSTART_SECOND (c1)))
1870 /* We have encountered a comment start sequence and we
1871 are ignoring all text inside comments. We must record
1872 the comment style this sequence begins so that later,
1873 only a comment end of the same style actually ends
1874 the comment section. */
1875 code = Scomment;
1876 comstyle = SYNTAX_COMMENT_STYLE (c1);
1877 comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
1878 INC_BOTH (from, from_byte);
1879 UPDATE_SYNTAX_TABLE_FORWARD (from);
1882 while (code == Swhitespace || (code == Sendcomment && c == '\n'));
1884 if (code == Scomment_fence)
1885 comstyle = ST_COMMENT_STYLE;
1886 else if (code != Scomment)
1888 immediate_quit = 0;
1889 DEC_BOTH (from, from_byte);
1890 SET_PT_BOTH (from, from_byte);
1891 return Qnil;
1893 /* We're at the start of a comment. */
1894 found = forw_comment (from, from_byte, stop, comnested, comstyle, 0,
1895 &out_charpos, &out_bytepos, &dummy);
1896 from = out_charpos; from_byte = out_bytepos;
1897 if (!found)
1899 immediate_quit = 0;
1900 SET_PT_BOTH (from, from_byte);
1901 return Qnil;
1903 INC_BOTH (from, from_byte);
1904 UPDATE_SYNTAX_TABLE_FORWARD (from);
1905 /* We have skipped one comment. */
1906 count1--;
1909 while (count1 < 0)
1911 while (1)
1913 int quoted;
1915 if (from <= stop)
1917 SET_PT_BOTH (BEGV, BEGV_BYTE);
1918 immediate_quit = 0;
1919 return Qnil;
1922 DEC_BOTH (from, from_byte);
1923 /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from). */
1924 quoted = char_quoted (from, from_byte);
1925 if (quoted)
1927 DEC_BOTH (from, from_byte);
1928 goto leave;
1930 c = FETCH_CHAR (from_byte);
1931 code = SYNTAX (c);
1932 comstyle = 0;
1933 comnested = SYNTAX_COMMENT_NESTED (c);
1934 if (code == Sendcomment)
1935 comstyle = SYNTAX_COMMENT_STYLE (c);
1936 if (from > stop && SYNTAX_COMEND_SECOND (c)
1937 && prev_char_comend_first (from, from_byte)
1938 && !char_quoted (from - 1, dec_bytepos (from_byte)))
1940 /* We must record the comment style encountered so that
1941 later, we can match only the proper comment begin
1942 sequence of the same style. */
1943 DEC_BOTH (from, from_byte);
1944 code = Sendcomment;
1945 /* Calling char_quoted, above, set up global syntax position
1946 at the new value of FROM. */
1947 c1 = FETCH_CHAR (from_byte);
1948 comstyle = SYNTAX_COMMENT_STYLE (c1);
1949 comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
1952 if (code == Scomment_fence)
1954 /* Skip until first preceding unquoted comment_fence. */
1955 int found = 0, ini = from, ini_byte = from_byte;
1957 while (1)
1959 DEC_BOTH (from, from_byte);
1960 if (from == stop)
1961 break;
1962 UPDATE_SYNTAX_TABLE_BACKWARD (from);
1963 c = FETCH_CHAR (from_byte);
1964 if (SYNTAX (c) == Scomment_fence
1965 && !char_quoted (from, from_byte))
1967 found = 1;
1968 break;
1971 if (found == 0)
1973 from = ini; /* Set point to ini + 1. */
1974 from_byte = ini_byte;
1975 goto leave;
1978 else if (code == Sendcomment)
1980 found = back_comment (from, from_byte, stop, comnested, comstyle,
1981 &out_charpos, &out_bytepos);
1982 if (found == -1)
1984 if (c == '\n')
1985 /* This end-of-line is not an end-of-comment.
1986 Treat it like a whitespace.
1987 CC-mode (and maybe others) relies on this behavior. */
1989 else
1991 /* Failure: we should go back to the end of this
1992 not-quite-endcomment. */
1993 if (SYNTAX(c) != code)
1994 /* It was a two-char Sendcomment. */
1995 INC_BOTH (from, from_byte);
1996 goto leave;
1999 else
2001 /* We have skipped one comment. */
2002 from = out_charpos, from_byte = out_bytepos;
2003 break;
2006 else if (code != Swhitespace)
2008 leave:
2009 immediate_quit = 0;
2010 INC_BOTH (from, from_byte);
2011 SET_PT_BOTH (from, from_byte);
2012 return Qnil;
2016 count1++;
2019 SET_PT_BOTH (from, from_byte);
2020 immediate_quit = 0;
2021 return Qt;
2024 /* Return syntax code of character C if C is a single byte character
2025 or `multibyte_symbol_p' is zero. Otherwise, retrun Ssymbol. */
2027 #define SYNTAX_WITH_MULTIBYTE_CHECK(c) \
2028 ((SINGLE_BYTE_CHAR_P (c) || !multibyte_symbol_p) \
2029 ? SYNTAX (c) : Ssymbol)
2031 static Lisp_Object
2032 scan_lists (from, count, depth, sexpflag)
2033 register int from;
2034 int count, depth, sexpflag;
2036 Lisp_Object val;
2037 register int stop = count > 0 ? ZV : BEGV;
2038 register int c, c1;
2039 int stringterm;
2040 int quoted;
2041 int mathexit = 0;
2042 register enum syntaxcode code, temp_code;
2043 int min_depth = depth; /* Err out if depth gets less than this. */
2044 int comstyle = 0; /* style of comment encountered */
2045 int comnested = 0; /* whether the comment is nestable or not */
2046 int temp_pos;
2047 int last_good = from;
2048 int found;
2049 int from_byte;
2050 int out_bytepos, out_charpos;
2051 int temp, dummy;
2052 int multibyte_symbol_p = sexpflag && multibyte_syntax_as_symbol;
2054 if (depth > 0) min_depth = 0;
2056 if (from > ZV) from = ZV;
2057 if (from < BEGV) from = BEGV;
2059 from_byte = CHAR_TO_BYTE (from);
2061 immediate_quit = 1;
2062 QUIT;
2064 SETUP_SYNTAX_TABLE (from, count);
2065 while (count > 0)
2067 while (from < stop)
2069 int comstart_first, prefix;
2070 UPDATE_SYNTAX_TABLE_FORWARD (from);
2071 c = FETCH_CHAR (from_byte);
2072 code = SYNTAX_WITH_MULTIBYTE_CHECK (c);
2073 comstart_first = SYNTAX_COMSTART_FIRST (c);
2074 comnested = SYNTAX_COMMENT_NESTED (c);
2075 comstyle = SYNTAX_COMMENT_STYLE (c);
2076 prefix = SYNTAX_PREFIX (c);
2077 if (depth == min_depth)
2078 last_good = from;
2079 INC_BOTH (from, from_byte);
2080 UPDATE_SYNTAX_TABLE_FORWARD (from);
2081 if (from < stop && comstart_first
2082 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte))
2083 && parse_sexp_ignore_comments)
2085 /* we have encountered a comment start sequence and we
2086 are ignoring all text inside comments. We must record
2087 the comment style this sequence begins so that later,
2088 only a comment end of the same style actually ends
2089 the comment section */
2090 code = Scomment;
2091 c1 = FETCH_CHAR (from_byte);
2092 comstyle = SYNTAX_COMMENT_STYLE (c1);
2093 comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
2094 INC_BOTH (from, from_byte);
2095 UPDATE_SYNTAX_TABLE_FORWARD (from);
2098 if (prefix)
2099 continue;
2101 switch (SWITCH_ENUM_CAST (code))
2103 case Sescape:
2104 case Scharquote:
2105 if (from == stop) goto lose;
2106 INC_BOTH (from, from_byte);
2107 /* treat following character as a word constituent */
2108 case Sword:
2109 case Ssymbol:
2110 if (depth || !sexpflag) break;
2111 /* This word counts as a sexp; return at end of it. */
2112 while (from < stop)
2114 UPDATE_SYNTAX_TABLE_FORWARD (from);
2116 /* Some compilers can't handle this inside the switch. */
2117 c = FETCH_CHAR (from_byte);
2118 temp = SYNTAX_WITH_MULTIBYTE_CHECK (c);
2119 switch (temp)
2121 case Scharquote:
2122 case Sescape:
2123 INC_BOTH (from, from_byte);
2124 if (from == stop) goto lose;
2125 break;
2126 case Sword:
2127 case Ssymbol:
2128 case Squote:
2129 break;
2130 default:
2131 goto done;
2133 INC_BOTH (from, from_byte);
2135 goto done;
2137 case Scomment_fence:
2138 comstyle = ST_COMMENT_STYLE;
2139 /* FALLTHROUGH */
2140 case Scomment:
2141 if (!parse_sexp_ignore_comments) break;
2142 UPDATE_SYNTAX_TABLE_FORWARD (from);
2143 found = forw_comment (from, from_byte, stop,
2144 comnested, comstyle, 0,
2145 &out_charpos, &out_bytepos, &dummy);
2146 from = out_charpos, from_byte = out_bytepos;
2147 if (!found)
2149 if (depth == 0)
2150 goto done;
2151 goto lose;
2153 INC_BOTH (from, from_byte);
2154 UPDATE_SYNTAX_TABLE_FORWARD (from);
2155 break;
2157 case Smath:
2158 if (!sexpflag)
2159 break;
2160 if (from != stop && c == FETCH_CHAR (from_byte))
2162 INC_BOTH (from, from_byte);
2164 if (mathexit)
2166 mathexit = 0;
2167 goto close1;
2169 mathexit = 1;
2171 case Sopen:
2172 if (!++depth) goto done;
2173 break;
2175 case Sclose:
2176 close1:
2177 if (!--depth) goto done;
2178 if (depth < min_depth)
2179 Fsignal (Qscan_error,
2180 Fcons (build_string ("Containing expression ends prematurely"),
2181 Fcons (make_number (last_good),
2182 Fcons (make_number (from), Qnil))));
2183 break;
2185 case Sstring:
2186 case Sstring_fence:
2187 temp_pos = dec_bytepos (from_byte);
2188 stringterm = FETCH_CHAR (temp_pos);
2189 while (1)
2191 if (from >= stop) goto lose;
2192 UPDATE_SYNTAX_TABLE_FORWARD (from);
2193 c = FETCH_CHAR (from_byte);
2194 if (code == Sstring
2195 ? c == stringterm
2196 : SYNTAX_WITH_MULTIBYTE_CHECK (c) == Sstring_fence)
2197 break;
2199 /* Some compilers can't handle this inside the switch. */
2200 temp = SYNTAX_WITH_MULTIBYTE_CHECK (c);
2201 switch (temp)
2203 case Scharquote:
2204 case Sescape:
2205 INC_BOTH (from, from_byte);
2207 INC_BOTH (from, from_byte);
2209 INC_BOTH (from, from_byte);
2210 if (!depth && sexpflag) goto done;
2211 break;
2215 /* Reached end of buffer. Error if within object, return nil if between */
2216 if (depth) goto lose;
2218 immediate_quit = 0;
2219 return Qnil;
2221 /* End of object reached */
2222 done:
2223 count--;
2226 while (count < 0)
2228 while (from > stop)
2230 DEC_BOTH (from, from_byte);
2231 UPDATE_SYNTAX_TABLE_BACKWARD (from);
2232 c = FETCH_CHAR (from_byte);
2233 code = SYNTAX_WITH_MULTIBYTE_CHECK (c);
2234 if (depth == min_depth)
2235 last_good = from;
2236 comstyle = 0;
2237 comnested = SYNTAX_COMMENT_NESTED (c);
2238 if (code == Sendcomment)
2239 comstyle = SYNTAX_COMMENT_STYLE (c);
2240 if (from > stop && SYNTAX_COMEND_SECOND (c)
2241 && prev_char_comend_first (from, from_byte)
2242 && parse_sexp_ignore_comments)
2244 /* We must record the comment style encountered so that
2245 later, we can match only the proper comment begin
2246 sequence of the same style. */
2247 DEC_BOTH (from, from_byte);
2248 UPDATE_SYNTAX_TABLE_BACKWARD (from);
2249 code = Sendcomment;
2250 c1 = FETCH_CHAR (from_byte);
2251 comstyle = SYNTAX_COMMENT_STYLE (c1);
2252 comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
2255 /* Quoting turns anything except a comment-ender
2256 into a word character. Note that this cannot be true
2257 if we decremented FROM in the if-statement above. */
2258 if (code != Sendcomment && char_quoted (from, from_byte))
2259 code = Sword;
2260 else if (SYNTAX_PREFIX (c))
2261 continue;
2263 switch (SWITCH_ENUM_CAST (code))
2265 case Sword:
2266 case Ssymbol:
2267 case Sescape:
2268 case Scharquote:
2269 if (depth || !sexpflag) break;
2270 /* This word counts as a sexp; count object finished
2271 after passing it. */
2272 while (from > stop)
2274 temp_pos = from_byte;
2275 if (! NILP (current_buffer->enable_multibyte_characters))
2276 DEC_POS (temp_pos);
2277 else
2278 temp_pos--;
2279 UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
2280 c1 = FETCH_CHAR (temp_pos);
2281 temp_code = SYNTAX_WITH_MULTIBYTE_CHECK (c1);
2282 /* Don't allow comment-end to be quoted. */
2283 if (temp_code == Sendcomment)
2284 goto done2;
2285 quoted = char_quoted (from - 1, temp_pos);
2286 if (quoted)
2288 DEC_BOTH (from, from_byte);
2289 temp_pos = dec_bytepos (temp_pos);
2290 UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
2292 c1 = FETCH_CHAR (temp_pos);
2293 temp_code = SYNTAX_WITH_MULTIBYTE_CHECK (c1);
2294 if (! (quoted || temp_code == Sword
2295 || temp_code == Ssymbol
2296 || temp_code == Squote))
2297 goto done2;
2298 DEC_BOTH (from, from_byte);
2300 goto done2;
2302 case Smath:
2303 if (!sexpflag)
2304 break;
2305 temp_pos = dec_bytepos (from_byte);
2306 UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
2307 if (from != stop && c == FETCH_CHAR (temp_pos))
2308 DEC_BOTH (from, from_byte);
2309 if (mathexit)
2311 mathexit = 0;
2312 goto open2;
2314 mathexit = 1;
2316 case Sclose:
2317 if (!++depth) goto done2;
2318 break;
2320 case Sopen:
2321 open2:
2322 if (!--depth) goto done2;
2323 if (depth < min_depth)
2324 Fsignal (Qscan_error,
2325 Fcons (build_string ("Containing expression ends prematurely"),
2326 Fcons (make_number (last_good),
2327 Fcons (make_number (from), Qnil))));
2328 break;
2330 case Sendcomment:
2331 if (!parse_sexp_ignore_comments)
2332 break;
2333 found = back_comment (from, from_byte, stop, comnested, comstyle,
2334 &out_charpos, &out_bytepos);
2335 /* FIXME: if found == -1, then it really wasn't a comment-end.
2336 For single-char Sendcomment, we can't do much about it apart
2337 from skipping the char.
2338 For 2-char endcomments, we could try again, taking both
2339 chars as separate entities, but it's a lot of trouble
2340 for very little gain, so we don't bother either. -sm */
2341 if (found != -1)
2342 from = out_charpos, from_byte = out_bytepos;
2343 break;
2345 case Scomment_fence:
2346 case Sstring_fence:
2347 while (1)
2349 DEC_BOTH (from, from_byte);
2350 if (from == stop) goto lose;
2351 UPDATE_SYNTAX_TABLE_BACKWARD (from);
2352 if (!char_quoted (from, from_byte)
2353 && (c = FETCH_CHAR (from_byte),
2354 SYNTAX_WITH_MULTIBYTE_CHECK (c) == code))
2355 break;
2357 if (code == Sstring_fence && !depth && sexpflag) goto done2;
2358 break;
2360 case Sstring:
2361 stringterm = FETCH_CHAR (from_byte);
2362 while (1)
2364 if (from == stop) goto lose;
2365 temp_pos = from_byte;
2366 if (! NILP (current_buffer->enable_multibyte_characters))
2367 DEC_POS (temp_pos);
2368 else
2369 temp_pos--;
2370 UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
2371 if (!char_quoted (from - 1, temp_pos)
2372 && stringterm == FETCH_CHAR (temp_pos))
2373 break;
2374 DEC_BOTH (from, from_byte);
2376 DEC_BOTH (from, from_byte);
2377 if (!depth && sexpflag) goto done2;
2378 break;
2382 /* Reached start of buffer. Error if within object, return nil if between */
2383 if (depth) goto lose;
2385 immediate_quit = 0;
2386 return Qnil;
2388 done2:
2389 count++;
2393 immediate_quit = 0;
2394 XSETFASTINT (val, from);
2395 return val;
2397 lose:
2398 Fsignal (Qscan_error,
2399 Fcons (build_string ("Unbalanced parentheses"),
2400 Fcons (make_number (last_good),
2401 Fcons (make_number (from), Qnil))));
2403 /* NOTREACHED */
2406 DEFUN ("scan-lists", Fscan_lists, Sscan_lists, 3, 3, 0,
2407 "Scan from character number FROM by COUNT lists.\n\
2408 Returns the character number of the position thus found.\n\
2410 If DEPTH is nonzero, paren depth begins counting from that value,\n\
2411 only places where the depth in parentheses becomes zero\n\
2412 are candidates for stopping; COUNT such places are counted.\n\
2413 Thus, a positive value for DEPTH means go out levels.\n\
2415 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2417 If the beginning or end of (the accessible part of) the buffer is reached\n\
2418 and the depth is wrong, an error is signaled.\n\
2419 If the depth is right but the count is not used up, nil is returned.")
2420 (from, count, depth)
2421 Lisp_Object from, count, depth;
2423 CHECK_NUMBER (from, 0);
2424 CHECK_NUMBER (count, 1);
2425 CHECK_NUMBER (depth, 2);
2427 return scan_lists (XINT (from), XINT (count), XINT (depth), 0);
2430 DEFUN ("scan-sexps", Fscan_sexps, Sscan_sexps, 2, 2, 0,
2431 "Scan from character number FROM by COUNT balanced expressions.\n\
2432 If COUNT is negative, scan backwards.\n\
2433 Returns the character number of the position thus found.\n\
2435 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\
2437 If the beginning or end of (the accessible part of) the buffer is reached\n\
2438 in the middle of a parenthetical grouping, an error is signaled.\n\
2439 If the beginning or end is reached between groupings\n\
2440 but before count is used up, nil is returned.")
2441 (from, count)
2442 Lisp_Object from, count;
2444 CHECK_NUMBER (from, 0);
2445 CHECK_NUMBER (count, 1);
2447 return scan_lists (XINT (from), XINT (count), 0, 1);
2450 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, Sbackward_prefix_chars,
2451 0, 0, 0,
2452 "Move point backward over any number of chars with prefix syntax.\n\
2453 This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
2456 int beg = BEGV;
2457 int opoint = PT;
2458 int opoint_byte = PT_BYTE;
2459 int pos = PT;
2460 int pos_byte = PT_BYTE;
2461 int c;
2463 if (pos <= beg)
2465 SET_PT_BOTH (opoint, opoint_byte);
2467 return Qnil;
2470 SETUP_SYNTAX_TABLE (pos, -1);
2472 DEC_BOTH (pos, pos_byte);
2474 while (!char_quoted (pos, pos_byte)
2475 /* Previous statement updates syntax table. */
2476 && ((c = FETCH_CHAR (pos_byte), SYNTAX (c) == Squote)
2477 || SYNTAX_PREFIX (c)))
2479 opoint = pos;
2480 opoint_byte = pos_byte;
2482 if (pos + 1 > beg)
2483 DEC_BOTH (pos, pos_byte);
2486 SET_PT_BOTH (opoint, opoint_byte);
2488 return Qnil;
2491 /* Parse forward from FROM / FROM_BYTE to END,
2492 assuming that FROM has state OLDSTATE (nil means FROM is start of function),
2493 and return a description of the state of the parse at END.
2494 If STOPBEFORE is nonzero, stop at the start of an atom.
2495 If COMMENTSTOP is 1, stop at the start of a comment.
2496 If COMMENTSTOP is -1, stop at the start or end of a comment,
2497 after the beginning of a string, or after the end of a string. */
2499 static void
2500 scan_sexps_forward (stateptr, from, from_byte, end, targetdepth,
2501 stopbefore, oldstate, commentstop)
2502 struct lisp_parse_state *stateptr;
2503 register int from;
2504 int end, targetdepth, stopbefore;
2505 Lisp_Object oldstate;
2506 int commentstop;
2508 struct lisp_parse_state state;
2510 register enum syntaxcode code;
2511 int c1;
2512 int comnested;
2513 struct level { int last, prev; };
2514 struct level levelstart[100];
2515 register struct level *curlevel = levelstart;
2516 struct level *endlevel = levelstart + 100;
2517 register int depth; /* Paren depth of current scanning location.
2518 level - levelstart equals this except
2519 when the depth becomes negative. */
2520 int mindepth; /* Lowest DEPTH value seen. */
2521 int start_quoted = 0; /* Nonzero means starting after a char quote */
2522 Lisp_Object tem;
2523 int prev_from; /* Keep one character before FROM. */
2524 int prev_from_byte;
2525 int prev_from_syntax;
2526 int boundary_stop = commentstop == -1;
2527 int nofence;
2528 int found;
2529 int out_bytepos, out_charpos;
2530 int temp;
2532 prev_from = from;
2533 prev_from_byte = from_byte;
2534 if (from != BEGV)
2535 DEC_BOTH (prev_from, prev_from_byte);
2537 /* Use this macro instead of `from++'. */
2538 #define INC_FROM \
2539 do { prev_from = from; \
2540 prev_from_byte = from_byte; \
2541 prev_from_syntax \
2542 = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte)); \
2543 INC_BOTH (from, from_byte); \
2544 UPDATE_SYNTAX_TABLE_FORWARD (from); \
2545 } while (0)
2547 immediate_quit = 1;
2548 QUIT;
2550 if (NILP (oldstate))
2552 depth = 0;
2553 state.instring = -1;
2554 state.incomment = 0;
2555 state.comstyle = 0; /* comment style a by default. */
2556 state.comstr_start = -1; /* no comment/string seen. */
2558 else
2560 tem = Fcar (oldstate);
2561 if (!NILP (tem))
2562 depth = XINT (tem);
2563 else
2564 depth = 0;
2566 oldstate = Fcdr (oldstate);
2567 oldstate = Fcdr (oldstate);
2568 oldstate = Fcdr (oldstate);
2569 tem = Fcar (oldstate);
2570 /* Check whether we are inside string_fence-style string: */
2571 state.instring = (!NILP (tem)
2572 ? (INTEGERP (tem) ? XINT (tem) : ST_STRING_STYLE)
2573 : -1);
2575 oldstate = Fcdr (oldstate);
2576 tem = Fcar (oldstate);
2577 state.incomment = (!NILP (tem)
2578 ? (INTEGERP (tem) ? XINT (tem) : -1)
2579 : 0);
2581 oldstate = Fcdr (oldstate);
2582 tem = Fcar (oldstate);
2583 start_quoted = !NILP (tem);
2585 /* if the eighth element of the list is nil, we are in comment
2586 style a. If it is non-nil, we are in comment style b */
2587 oldstate = Fcdr (oldstate);
2588 oldstate = Fcdr (oldstate);
2589 tem = Fcar (oldstate);
2590 state.comstyle = NILP (tem) ? 0 : (EQ (tem, Qsyntax_table)
2591 ? ST_COMMENT_STYLE : 1);
2593 oldstate = Fcdr (oldstate);
2594 tem = Fcar (oldstate);
2595 state.comstr_start = NILP (tem) ? -1 : XINT (tem) ;
2596 oldstate = Fcdr (oldstate);
2597 tem = Fcar (oldstate);
2598 while (!NILP (tem)) /* >= second enclosing sexps. */
2600 /* curlevel++->last ran into compiler bug on Apollo */
2601 curlevel->last = XINT (Fcar (tem));
2602 if (++curlevel == endlevel)
2603 curlevel--; /* error ("Nesting too deep for parser"); */
2604 curlevel->prev = -1;
2605 curlevel->last = -1;
2606 tem = Fcdr (tem);
2609 state.quoted = 0;
2610 mindepth = depth;
2612 curlevel->prev = -1;
2613 curlevel->last = -1;
2615 SETUP_SYNTAX_TABLE (prev_from, 1);
2616 prev_from_syntax = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte));
2617 UPDATE_SYNTAX_TABLE_FORWARD (from);
2619 /* Enter the loop at a place appropriate for initial state. */
2621 if (state.incomment)
2622 goto startincomment;
2623 if (state.instring >= 0)
2625 nofence = state.instring != ST_STRING_STYLE;
2626 if (start_quoted)
2627 goto startquotedinstring;
2628 goto startinstring;
2630 else if (start_quoted)
2631 goto startquoted;
2633 #if 0 /* This seems to be redundant with the identical code above. */
2634 SETUP_SYNTAX_TABLE (prev_from, 1);
2635 prev_from_syntax = SYNTAX_WITH_FLAGS (FETCH_CHAR (prev_from_byte));
2636 UPDATE_SYNTAX_TABLE_FORWARD (from);
2637 #endif
2639 while (from < end)
2641 INC_FROM;
2642 code = prev_from_syntax & 0xff;
2644 if (code == Scomment)
2646 state.comstyle = SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax);
2647 state.incomment = (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax) ?
2648 1 : -1);
2649 state.comstr_start = prev_from;
2651 else if (code == Scomment_fence)
2653 /* Record the comment style we have entered so that only
2654 the comment-end sequence of the same style actually
2655 terminates the comment section. */
2656 state.comstyle = ST_COMMENT_STYLE;
2657 state.incomment = -1;
2658 state.comstr_start = prev_from;
2659 code = Scomment;
2661 else if (from < end)
2662 if (SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax))
2663 if (c1 = FETCH_CHAR (from_byte),
2664 SYNTAX_COMSTART_SECOND (c1))
2665 /* Duplicate code to avoid a complex if-expression
2666 which causes trouble for the SGI compiler. */
2668 /* Record the comment style we have entered so that only
2669 the comment-end sequence of the same style actually
2670 terminates the comment section. */
2671 state.comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte));
2672 comnested = SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax);
2673 comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
2674 state.incomment = comnested ? 1 : -1;
2675 state.comstr_start = prev_from;
2676 INC_FROM;
2677 code = Scomment;
2680 if (SYNTAX_FLAGS_PREFIX (prev_from_syntax))
2681 continue;
2682 switch (SWITCH_ENUM_CAST (code))
2684 case Sescape:
2685 case Scharquote:
2686 if (stopbefore) goto stop; /* this arg means stop at sexp start */
2687 curlevel->last = prev_from;
2688 startquoted:
2689 if (from == end) goto endquoted;
2690 INC_FROM;
2691 goto symstarted;
2692 /* treat following character as a word constituent */
2693 case Sword:
2694 case Ssymbol:
2695 if (stopbefore) goto stop; /* this arg means stop at sexp start */
2696 curlevel->last = prev_from;
2697 symstarted:
2698 while (from < end)
2700 /* Some compilers can't handle this inside the switch. */
2701 temp = SYNTAX (FETCH_CHAR (from_byte));
2702 switch (temp)
2704 case Scharquote:
2705 case Sescape:
2706 INC_FROM;
2707 if (from == end) goto endquoted;
2708 break;
2709 case Sword:
2710 case Ssymbol:
2711 case Squote:
2712 break;
2713 default:
2714 goto symdone;
2716 INC_FROM;
2718 symdone:
2719 curlevel->prev = curlevel->last;
2720 break;
2722 case Scomment:
2723 if (commentstop || boundary_stop) goto done;
2724 startincomment:
2725 /* The (from == BEGV) test was to enter the loop in the middle so
2726 that we find a 2-char comment ender even if we start in the
2727 middle of it. We don't want to do that if we're just at the
2728 beginning of the comment (think of (*) ... (*)). */
2729 found = forw_comment (from, from_byte, end,
2730 state.incomment, state.comstyle,
2731 (from == BEGV || from < state.comstr_start + 3)
2732 ? 0 : prev_from_syntax,
2733 &out_charpos, &out_bytepos, &state.incomment);
2734 from = out_charpos; from_byte = out_bytepos;
2735 /* Beware! prev_from and friends are invalid now.
2736 Luckily, the `done' doesn't use them and the INC_FROM
2737 sets them to a sane value without looking at them. */
2738 if (!found) goto done;
2739 INC_FROM;
2740 state.incomment = 0;
2741 state.comstyle = 0; /* reset the comment style */
2742 if (boundary_stop) goto done;
2743 break;
2745 case Sopen:
2746 if (stopbefore) goto stop; /* this arg means stop at sexp start */
2747 depth++;
2748 /* curlevel++->last ran into compiler bug on Apollo */
2749 curlevel->last = prev_from;
2750 if (++curlevel == endlevel)
2751 curlevel--; /* error ("Nesting too deep for parser"); */
2752 curlevel->prev = -1;
2753 curlevel->last = -1;
2754 if (targetdepth == depth) goto done;
2755 break;
2757 case Sclose:
2758 depth--;
2759 if (depth < mindepth)
2760 mindepth = depth;
2761 if (curlevel != levelstart)
2762 curlevel--;
2763 curlevel->prev = curlevel->last;
2764 if (targetdepth == depth) goto done;
2765 break;
2767 case Sstring:
2768 case Sstring_fence:
2769 state.comstr_start = from - 1;
2770 if (stopbefore) goto stop; /* this arg means stop at sexp start */
2771 curlevel->last = prev_from;
2772 state.instring = (code == Sstring
2773 ? (FETCH_CHAR (prev_from_byte))
2774 : ST_STRING_STYLE);
2775 if (boundary_stop) goto done;
2776 startinstring:
2778 nofence = state.instring != ST_STRING_STYLE;
2780 while (1)
2782 int c;
2784 if (from >= end) goto done;
2785 c = FETCH_CHAR (from_byte);
2786 /* Some compilers can't handle this inside the switch. */
2787 temp = SYNTAX (c);
2789 /* Check TEMP here so that if the char has
2790 a syntax-table property which says it is NOT
2791 a string character, it does not end the string. */
2792 if (nofence && c == state.instring && temp == Sstring)
2793 break;
2795 switch (temp)
2797 case Sstring_fence:
2798 if (!nofence) goto string_end;
2799 break;
2800 case Scharquote:
2801 case Sescape:
2802 INC_FROM;
2803 startquotedinstring:
2804 if (from >= end) goto endquoted;
2806 INC_FROM;
2809 string_end:
2810 state.instring = -1;
2811 curlevel->prev = curlevel->last;
2812 INC_FROM;
2813 if (boundary_stop) goto done;
2814 break;
2816 case Smath:
2817 break;
2820 goto done;
2822 stop: /* Here if stopping before start of sexp. */
2823 from = prev_from; /* We have just fetched the char that starts it; */
2824 goto done; /* but return the position before it. */
2826 endquoted:
2827 state.quoted = 1;
2828 done:
2829 state.depth = depth;
2830 state.mindepth = mindepth;
2831 state.thislevelstart = curlevel->prev;
2832 state.prevlevelstart
2833 = (curlevel == levelstart) ? -1 : (curlevel - 1)->last;
2834 state.location = from;
2835 state.levelstarts = Qnil;
2836 while (--curlevel >= levelstart)
2837 state.levelstarts = Fcons (make_number (curlevel->last),
2838 state.levelstarts);
2839 immediate_quit = 0;
2841 *stateptr = state;
2844 /* This comment supplies the doc string for parse-partial-sexp,
2845 for make-docfile to see. We cannot put this in the real DEFUN
2846 due to limits in the Unix cpp.
2848 DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 6, 0,
2849 "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\
2850 Parsing stops at TO or when certain criteria are met;\n\
2851 point is set to where parsing stops.\n\
2852 If fifth arg STATE is omitted or nil,\n\
2853 parsing assumes that FROM is the beginning of a function.\n\
2854 Value is a list of ten elements describing final state of parsing:\n\
2855 0. depth in parens.\n\
2856 1. character address of start of innermost containing list; nil if none.\n\
2857 2. character address of start of last complete sexp terminated.\n\
2858 3. non-nil if inside a string.\n\
2859 (it is the character that will terminate the string,\n\
2860 or t if the string should be terminated by a generic string delimiter.)\n\
2861 4. nil if outside a comment, t if inside a non-nestable comment, \n\
2862 else an integer (the current comment nesting).\n\
2863 5. t if following a quote character.\n\
2864 6. the minimum paren-depth encountered during this scan.\n\
2865 7. t if in a comment of style b; symbol `syntax-table' if the comment\n\
2866 should be terminated by a generic comment delimiter.\n\
2867 8. character address of start of comment or string; nil if not in one.\n\
2868 9. Intermediate data for continuation of parsing (subject to change).\n\
2869 If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\
2870 in parentheses becomes equal to TARGETDEPTH.\n\
2871 Fourth arg STOPBEFORE non-nil means stop when come to\n\
2872 any character that starts a sexp.\n\
2873 Fifth arg STATE is a nine-element list like what this function returns.\n\
2874 It is used to initialize the state of the parse. Elements number 1, 2, 6\n\
2875 and 8 are ignored; you can leave off element 8 (the last) entirely.\n\
2876 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.\n\
2877 If it is symbol `syntax-table', stop after the start of a comment or a\n\
2878 string, or after end of a comment or a string.")
2879 (from, to, targetdepth, stopbefore, state, commentstop)
2882 DEFUN ("parse-partial-sexp", Fparse_partial_sexp, Sparse_partial_sexp, 2, 6, 0,
2883 0 /* See immediately above */)
2884 (from, to, targetdepth, stopbefore, oldstate, commentstop)
2885 Lisp_Object from, to, targetdepth, stopbefore, oldstate, commentstop;
2887 struct lisp_parse_state state;
2888 int target;
2890 if (!NILP (targetdepth))
2892 CHECK_NUMBER (targetdepth, 3);
2893 target = XINT (targetdepth);
2895 else
2896 target = -100000; /* We won't reach this depth */
2898 validate_region (&from, &to);
2899 scan_sexps_forward (&state, XINT (from), CHAR_TO_BYTE (XINT (from)),
2900 XINT (to),
2901 target, !NILP (stopbefore), oldstate,
2902 (NILP (commentstop)
2903 ? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)));
2905 SET_PT (state.location);
2907 return Fcons (make_number (state.depth),
2908 Fcons (state.prevlevelstart < 0 ? Qnil : make_number (state.prevlevelstart),
2909 Fcons (state.thislevelstart < 0 ? Qnil : make_number (state.thislevelstart),
2910 Fcons (state.instring >= 0
2911 ? (state.instring == ST_STRING_STYLE
2912 ? Qt : make_number (state.instring)) : Qnil,
2913 Fcons (state.incomment < 0 ? Qt :
2914 (state.incomment == 0 ? Qnil :
2915 make_number (state.incomment)),
2916 Fcons (state.quoted ? Qt : Qnil,
2917 Fcons (make_number (state.mindepth),
2918 Fcons ((state.comstyle
2919 ? (state.comstyle == ST_COMMENT_STYLE
2920 ? Qsyntax_table : Qt) :
2921 Qnil),
2922 Fcons (((state.incomment
2923 || (state.instring >= 0))
2924 ? make_number (state.comstr_start)
2925 : Qnil),
2926 Fcons (state.levelstarts, Qnil))))))))));
2929 void
2930 init_syntax_once ()
2932 register int i, c;
2933 Lisp_Object temp;
2935 /* This has to be done here, before we call Fmake_char_table. */
2936 Qsyntax_table = intern ("syntax-table");
2937 staticpro (&Qsyntax_table);
2939 /* Intern this now in case it isn't already done.
2940 Setting this variable twice is harmless.
2941 But don't staticpro it here--that is done in alloc.c. */
2942 Qchar_table_extra_slots = intern ("char-table-extra-slots");
2944 /* Create objects which can be shared among syntax tables. */
2945 Vsyntax_code_object = Fmake_vector (make_number (13), Qnil);
2946 for (i = 0; i < XVECTOR (Vsyntax_code_object)->size; i++)
2947 XVECTOR (Vsyntax_code_object)->contents[i]
2948 = Fcons (make_number (i), Qnil);
2950 /* Now we are ready to set up this property, so we can
2951 create syntax tables. */
2952 Fput (Qsyntax_table, Qchar_table_extra_slots, make_number (0));
2954 temp = XVECTOR (Vsyntax_code_object)->contents[(int) Swhitespace];
2956 Vstandard_syntax_table = Fmake_char_table (Qsyntax_table, temp);
2958 temp = XVECTOR (Vsyntax_code_object)->contents[(int) Sword];
2959 for (i = 'a'; i <= 'z'; i++)
2960 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
2961 for (i = 'A'; i <= 'Z'; i++)
2962 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
2963 for (i = '0'; i <= '9'; i++)
2964 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
2966 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '$', temp);
2967 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '%', temp);
2969 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '(',
2970 Fcons (make_number (Sopen), make_number (')')));
2971 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, ')',
2972 Fcons (make_number (Sclose), make_number ('(')));
2973 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '[',
2974 Fcons (make_number (Sopen), make_number (']')));
2975 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, ']',
2976 Fcons (make_number (Sclose), make_number ('[')));
2977 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '{',
2978 Fcons (make_number (Sopen), make_number ('}')));
2979 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '}',
2980 Fcons (make_number (Sclose), make_number ('{')));
2981 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '"',
2982 Fcons (make_number ((int) Sstring), Qnil));
2983 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '\\',
2984 Fcons (make_number ((int) Sescape), Qnil));
2986 temp = XVECTOR (Vsyntax_code_object)->contents[(int) Ssymbol];
2987 for (i = 0; i < 10; i++)
2989 c = "_-+*/&|<>="[i];
2990 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, c, temp);
2993 temp = XVECTOR (Vsyntax_code_object)->contents[(int) Spunct];
2994 for (i = 0; i < 12; i++)
2996 c = ".,;:?!#@~^'`"[i];
2997 SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, c, temp);
3000 /* All multibyte characters have syntax `word' by default. */
3001 temp = XVECTOR (Vsyntax_code_object)->contents[(int) Sword];
3002 for (i = CHAR_TABLE_SINGLE_BYTE_SLOTS; i < CHAR_TABLE_ORDINARY_SLOTS; i++)
3003 XCHAR_TABLE (Vstandard_syntax_table)->contents[i] = temp;
3006 void
3007 syms_of_syntax ()
3009 Qsyntax_table_p = intern ("syntax-table-p");
3010 staticpro (&Qsyntax_table_p);
3012 staticpro (&Vsyntax_code_object);
3014 Qscan_error = intern ("scan-error");
3015 staticpro (&Qscan_error);
3016 Fput (Qscan_error, Qerror_conditions,
3017 Fcons (Qscan_error, Fcons (Qerror, Qnil)));
3018 Fput (Qscan_error, Qerror_message,
3019 build_string ("Scan error"));
3021 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments,
3022 "Non-nil means `forward-sexp', etc., should treat comments as whitespace.");
3024 DEFVAR_BOOL ("parse-sexp-lookup-properties", &parse_sexp_lookup_properties,
3025 "Non-nil means `forward-sexp', etc., grant `syntax-table' property.\n\
3026 The value of this property should be either a syntax table, or a cons\n\
3027 of the form (SYNTAXCODE . MATCHCHAR), SYNTAXCODE being the numeric\n\
3028 syntax code, MATCHCHAR being nil or the character to match (which is\n\
3029 relevant only for open/close type.");
3031 words_include_escapes = 0;
3032 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes,
3033 "Non-nil means `forward-word', etc., should treat escape chars part of words.");
3035 DEFVAR_BOOL ("multibyte-syntax-as-symbol", &multibyte_syntax_as_symbol,
3036 "Non-nil means `scan-sexps' treats all multibyte characters as symbol.");
3037 multibyte_syntax_as_symbol = 0;
3039 DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
3040 &open_paren_in_column_0_is_defun_start,
3041 "Non-nil means an open paren in column 0 denotes the start of a defun.");
3042 open_paren_in_column_0_is_defun_start = 1;
3044 defsubr (&Ssyntax_table_p);
3045 defsubr (&Ssyntax_table);
3046 defsubr (&Sstandard_syntax_table);
3047 defsubr (&Scopy_syntax_table);
3048 defsubr (&Sset_syntax_table);
3049 defsubr (&Schar_syntax);
3050 defsubr (&Smatching_paren);
3051 defsubr (&Sstring_to_syntax);
3052 defsubr (&Smodify_syntax_entry);
3053 defsubr (&Sdescribe_syntax);
3055 defsubr (&Sforward_word);
3057 defsubr (&Sskip_chars_forward);
3058 defsubr (&Sskip_chars_backward);
3059 defsubr (&Sskip_syntax_forward);
3060 defsubr (&Sskip_syntax_backward);
3062 defsubr (&Sforward_comment);
3063 defsubr (&Sscan_lists);
3064 defsubr (&Sscan_sexps);
3065 defsubr (&Sbackward_prefix_chars);
3066 defsubr (&Sparse_partial_sexp);