Mercurial > emacs
annotate src/syntax.c @ 1167:a9aeeaa9da8f
(scan_lists): When searching back for comment:
if comment-end is 2 chars, assume it does end a comment.
Otherwise, scan back to previous comment-end to see if there's
a comment starter between. Also record whether the string quotes
between the start and the end are paired and uniform.
If so, skip to comment starter. If not, scan from start of
defun to find comment starter if any.
(find_defun_start): New function.
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Sat, 19 Sep 1992 17:52:07 +0000 |
parents | 91a456e52db1 |
children | d9a103f4843e |
rev | line source |
---|---|
163 | 1 /* GNU Emacs routines to deal with syntax tables; also word and list parsing. |
726 | 2 Copyright (C) 1985, 1987, 1992 Free Software Foundation, Inc. |
163 | 3 |
4 This file is part of GNU Emacs. | |
5 | |
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 | |
726 | 8 the Free Software Foundation; either version 2, or (at your option) |
163 | 9 any later version. |
10 | |
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. | |
15 | |
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, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | |
20 | |
21 #include "config.h" | |
22 #include <ctype.h> | |
23 #include "lisp.h" | |
24 #include "commands.h" | |
25 #include "buffer.h" | |
26 #include "syntax.h" | |
27 | |
28 Lisp_Object Qsyntax_table_p; | |
29 | |
30 int words_include_escapes; | |
31 | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
32 /* This is the internal form of the parse state used in parse-partial-sexp. */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
33 |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
34 struct lisp_parse_state |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
35 { |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
36 int depth; /* Depth at end of parsing */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
37 int instring; /* -1 if not within string, else desired terminator. */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
38 int incomment; /* Nonzero if within a comment at end of parsing */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
39 int comstyle; /* comment style a=0, or b=1 */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
40 int quoted; /* Nonzero if just after an escape char at end of parsing */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
41 int thislevelstart; /* Char number of most recent start-of-expression at current level */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
42 int prevlevelstart; /* Char number of start of containing expression */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
43 int location; /* Char number at which parsing stopped. */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
44 int mindepth; /* Minimum depth seen while scanning. */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
45 int comstart; /* Position just after last comment starter. */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
46 }; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
47 |
1167
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
48 /* These variables are a cache for finding the start of a defun. |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
49 find_start_pos is the place for which the defun start was found. |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
50 find_start_value is the defun start position found for it. |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
51 find_start_buffer is the buffer it was found in. |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
52 find_start_begv is the BEGV value when it was found. |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
53 find_start_modiff is the value of MODIFF when it was found. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
54 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
55 static int find_start_pos; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
56 static int find_start_value; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
57 static struct buffer *find_start_buffer; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
58 static int find_start_begv; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
59 static int find_start_modiff; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
60 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
61 /* Find a defun-start that is the last one before POS (or nearly the last). |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
62 We record what we find, so that another call in the same area |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
63 can return the same value right away. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
64 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
65 static int |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
66 find_defun_start (pos) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
67 int pos; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
68 { |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
69 int tem; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
70 int shortage; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
71 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
72 /* Use previous finding, if it's valid and applies to this inquiry. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
73 if (current_buffer == find_start_buffer |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
74 /* Reuse the defun-start even if POS is a little farther on. |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
75 POS might be in the next defun, but that's ok. |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
76 Our value may not be the best possible, but will still be usable. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
77 && pos <= find_start_pos + 1000 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
78 && pos >= find_start_value |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
79 && BEGV == find_start_begv |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
80 && MODIFF == find_start_modiff) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
81 return find_start_value; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
82 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
83 /* Back up to start of line. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
84 tem = scan_buffer ('\n', pos, -1, &shortage); |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
85 /* If we found a newline, we moved back over it, so advance fwd past it. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
86 if (shortage == 0) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
87 tem++; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
88 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
89 while (tem > BEGV) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
90 { |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
91 /* Open-paren at start of line means we found our defun-start. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
92 if (SYNTAX (FETCH_CHAR (tem)) == Sopen) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
93 break; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
94 /* Move to beg of previous line. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
95 tem = scan_buffer ('\n', tem, -2, &shortage); |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
96 if (shortage == 0) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
97 tem++; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
98 } |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
99 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
100 /* Record what we found, for the next try. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
101 find_start_value = tem; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
102 find_start_buffer = current_buffer; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
103 find_start_modiff = MODIFF; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
104 find_start_begv = BEGV; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
105 find_start_pos = pos; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
106 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
107 return find_start_value; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
108 } |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
109 |
163 | 110 DEFUN ("syntax-table-p", Fsyntax_table_p, Ssyntax_table_p, 1, 1, 0, |
111 "Return t if ARG is a syntax table.\n\ | |
112 Any vector of 256 elements will do.") | |
113 (obj) | |
114 Lisp_Object obj; | |
115 { | |
116 if (XTYPE (obj) == Lisp_Vector && XVECTOR (obj)->size == 0400) | |
117 return Qt; | |
118 return Qnil; | |
119 } | |
120 | |
121 Lisp_Object | |
122 check_syntax_table (obj) | |
123 Lisp_Object obj; | |
124 { | |
125 register Lisp_Object tem; | |
126 while (tem = Fsyntax_table_p (obj), | |
485 | 127 NILP (tem)) |
163 | 128 obj = wrong_type_argument (Qsyntax_table_p, obj, 0); |
129 return obj; | |
130 } | |
131 | |
132 | |
133 DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 0, 0, | |
134 "Return the current syntax table.\n\ | |
135 This is the one specified by the current buffer.") | |
136 () | |
137 { | |
138 return current_buffer->syntax_table; | |
139 } | |
140 | |
141 DEFUN ("standard-syntax-table", Fstandard_syntax_table, | |
142 Sstandard_syntax_table, 0, 0, 0, | |
143 "Return the standard syntax table.\n\ | |
144 This is the one used for new buffers.") | |
145 () | |
146 { | |
147 return Vstandard_syntax_table; | |
148 } | |
149 | |
150 DEFUN ("copy-syntax-table", Fcopy_syntax_table, Scopy_syntax_table, 0, 1, 0, | |
151 "Construct a new syntax table and return it.\n\ | |
152 It is a copy of the TABLE, which defaults to the standard syntax table.") | |
153 (table) | |
154 Lisp_Object table; | |
155 { | |
156 Lisp_Object size, val; | |
157 XFASTINT (size) = 0400; | |
158 XFASTINT (val) = 0; | |
159 val = Fmake_vector (size, val); | |
485 | 160 if (!NILP (table)) |
163 | 161 table = check_syntax_table (table); |
485 | 162 else if (NILP (Vstandard_syntax_table)) |
163 | 163 /* Can only be null during initialization */ |
164 return val; | |
165 else table = Vstandard_syntax_table; | |
166 | |
167 bcopy (XVECTOR (table)->contents, | |
168 XVECTOR (val)->contents, 0400 * sizeof (Lisp_Object)); | |
169 return val; | |
170 } | |
171 | |
172 DEFUN ("set-syntax-table", Fset_syntax_table, Sset_syntax_table, 1, 1, 0, | |
173 "Select a new syntax table for the current buffer.\n\ | |
174 One argument, a syntax table.") | |
175 (table) | |
176 Lisp_Object table; | |
177 { | |
178 table = check_syntax_table (table); | |
179 current_buffer->syntax_table = table; | |
180 /* Indicate that this buffer now has a specified syntax table. */ | |
181 current_buffer->local_var_flags |= buffer_local_flags.syntax_table; | |
182 return table; | |
183 } | |
184 | |
185 /* Convert a letter which signifies a syntax code | |
186 into the code it signifies. | |
187 This is used by modify-syntax-entry, and other things. */ | |
188 | |
189 unsigned char syntax_spec_code[0400] = | |
190 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
191 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
192 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
193 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
194 (char) Swhitespace, 0377, (char) Sstring, 0377, | |
195 (char) Smath, 0377, 0377, (char) Squote, | |
196 (char) Sopen, (char) Sclose, 0377, 0377, | |
197 0377, (char) Swhitespace, (char) Spunct, (char) Scharquote, | |
198 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
199 0377, 0377, 0377, 0377, | |
200 (char) Scomment, 0377, (char) Sendcomment, 0377, | |
201 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A, ... */ | |
202 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
203 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword, | |
204 0377, 0377, 0377, 0377, (char) Sescape, 0377, 0377, (char) Ssymbol, | |
205 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */ | |
206 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
207 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword, | |
208 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377 | |
209 }; | |
210 | |
211 /* Indexed by syntax code, give the letter that describes it. */ | |
212 | |
213 char syntax_code_spec[13] = | |
214 { | |
215 ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>' | |
216 }; | |
217 | |
218 DEFUN ("char-syntax", Fchar_syntax, Schar_syntax, 1, 1, 0, | |
219 "Return the syntax code of CHAR, described by a character.\n\ | |
220 For example, if CHAR is a word constituent, the character `?w' is returned.\n\ | |
221 The characters that correspond to various syntax codes\n\ | |
222 are listed in the documentation of `modify-syntax-entry'.") | |
223 (ch) | |
224 Lisp_Object ch; | |
225 { | |
226 CHECK_NUMBER (ch, 0); | |
227 return make_number (syntax_code_spec[(int) SYNTAX (0xFF & XINT (ch))]); | |
228 } | |
229 | |
230 /* This comment supplies the doc string for modify-syntax-entry, | |
231 for make-docfile to see. We cannot put this in the real DEFUN | |
232 due to limits in the Unix cpp. | |
233 | |
234 DEFUN ("modify-syntax-entry", foo, bar, 0, 0, 0, | |
235 "Set syntax for character CHAR according to string S.\n\ | |
236 The syntax is changed only for table TABLE, which defaults to\n\ | |
237 the current buffer's syntax table.\n\ | |
238 The first character of S should be one of the following:\n\ | |
624 | 239 Space or - whitespace syntax. w word constituent.\n\ |
240 _ symbol constituent. . punctuation.\n\ | |
241 ( open-parenthesis. ) close-parenthesis.\n\ | |
242 \" string quote. \\ escape.\n\ | |
243 $ paired delimiter. ' expression quote or prefix operator.\n\ | |
244 < comment starter. > comment ender.\n\ | |
245 / character-quote.\n\ | |
163 | 246 Only single-character comment start and end sequences are represented thus.\n\ |
247 Two-character sequences are represented as described below.\n\ | |
248 The second character of S is the matching parenthesis,\n\ | |
249 used only if the first character is `(' or `)'.\n\ | |
250 Any additional characters are flags.\n\ | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
251 Defined flags are the characters 1, 2, 3, 4, b, and p.\n\ |
163 | 252 1 means C is the start of a two-char comment start sequence.\n\ |
253 2 means C is the second character of such a sequence.\n\ | |
254 3 means C is the start of a two-char comment end sequence.\n\ | |
255 4 means C is the second character of such a sequence.\n\ | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
256 \n\ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
257 There can be up to two orthogonal comment sequences. This is to support\n\ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
258 language modes such as C++. By default, all comment sequences are of style\n\ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
259 a, but you can set the comment sequence style to b (on the second character of a\n\ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
260 comment-start, or the first character of a comment-end sequence) by using\n\ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
261 this flag:\n\ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
262 b means C is part of comment sequence b.\n\ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
263 \n\ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
264 p means C is a prefix character for `backward-prefix-chars';\n\ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
265 such characters are treated as whitespace when they occur\n\ |
163 | 266 between expressions.") |
267 | |
268 */ | |
269 | |
270 DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3, | |
271 /* I really don't know why this is interactive | |
272 help-form should at least be made useful whilst reading the second arg | |
273 */ | |
274 "cSet syntax for character: \nsSet syntax for %s to: ", | |
275 0 /* See immediately above */) | |
276 (c, newentry, syntax_table) | |
277 Lisp_Object c, newentry, syntax_table; | |
278 { | |
279 register unsigned char *p, match; | |
280 register enum syntaxcode code; | |
281 Lisp_Object val; | |
282 | |
283 CHECK_NUMBER (c, 0); | |
284 CHECK_STRING (newentry, 1); | |
485 | 285 if (NILP (syntax_table)) |
163 | 286 syntax_table = current_buffer->syntax_table; |
287 else | |
288 syntax_table = check_syntax_table (syntax_table); | |
289 | |
290 p = XSTRING (newentry)->data; | |
291 code = (enum syntaxcode) syntax_spec_code[*p++]; | |
292 if (((int) code & 0377) == 0377) | |
293 error ("invalid syntax description letter: %c", c); | |
294 | |
295 match = *p; | |
296 if (match) p++; | |
297 if (match == ' ') match = 0; | |
298 | |
299 XFASTINT (val) = (match << 8) + (int) code; | |
300 while (*p) | |
301 switch (*p++) | |
302 { | |
303 case '1': | |
304 XFASTINT (val) |= 1 << 16; | |
305 break; | |
306 | |
307 case '2': | |
308 XFASTINT (val) |= 1 << 17; | |
309 break; | |
310 | |
311 case '3': | |
312 XFASTINT (val) |= 1 << 18; | |
313 break; | |
314 | |
315 case '4': | |
316 XFASTINT (val) |= 1 << 19; | |
317 break; | |
318 | |
319 case 'p': | |
320 XFASTINT (val) |= 1 << 20; | |
321 break; | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
322 |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
323 case 'b': |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
324 XFASTINT (val) |= 1 << 21; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
325 break; |
163 | 326 } |
327 | |
328 XVECTOR (syntax_table)->contents[0xFF & XINT (c)] = val; | |
329 | |
330 return Qnil; | |
331 } | |
332 | |
333 /* Dump syntax table to buffer in human-readable format */ | |
334 | |
335 describe_syntax (value) | |
336 Lisp_Object value; | |
337 { | |
338 register enum syntaxcode code; | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
339 char desc, match, start1, start2, end1, end2, prefix, comstyle; |
163 | 340 char str[2]; |
341 | |
342 Findent_to (make_number (16), make_number (1)); | |
343 | |
344 if (XTYPE (value) != Lisp_Int) | |
345 { | |
346 insert_string ("invalid"); | |
347 return; | |
348 } | |
349 | |
350 code = (enum syntaxcode) (XINT (value) & 0377); | |
351 match = (XINT (value) >> 8) & 0377; | |
352 start1 = (XINT (value) >> 16) & 1; | |
353 start2 = (XINT (value) >> 17) & 1; | |
354 end1 = (XINT (value) >> 18) & 1; | |
355 end2 = (XINT (value) >> 19) & 1; | |
356 prefix = (XINT (value) >> 20) & 1; | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
357 comstyle = (XINT (value) >> 21) & 1; |
163 | 358 |
359 if ((int) code < 0 || (int) code >= (int) Smax) | |
360 { | |
361 insert_string ("invalid"); | |
362 return; | |
363 } | |
364 desc = syntax_code_spec[(int) code]; | |
365 | |
366 str[0] = desc, str[1] = 0; | |
367 insert (str, 1); | |
368 | |
369 str[0] = match ? match : ' '; | |
370 insert (str, 1); | |
371 | |
372 | |
373 if (start1) | |
374 insert ("1", 1); | |
375 if (start2) | |
376 insert ("2", 1); | |
377 | |
378 if (end1) | |
379 insert ("3", 1); | |
380 if (end2) | |
381 insert ("4", 1); | |
382 | |
383 if (prefix) | |
384 insert ("p", 1); | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
385 if (comstyle) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
386 insert ("b", 1); |
163 | 387 |
388 insert_string ("\twhich means: "); | |
389 | |
390 #ifdef SWITCH_ENUM_BUG | |
391 switch ((int) code) | |
392 #else | |
393 switch (code) | |
394 #endif | |
395 { | |
396 case Swhitespace: | |
397 insert_string ("whitespace"); break; | |
398 case Spunct: | |
399 insert_string ("punctuation"); break; | |
400 case Sword: | |
401 insert_string ("word"); break; | |
402 case Ssymbol: | |
403 insert_string ("symbol"); break; | |
404 case Sopen: | |
405 insert_string ("open"); break; | |
406 case Sclose: | |
407 insert_string ("close"); break; | |
408 case Squote: | |
409 insert_string ("quote"); break; | |
410 case Sstring: | |
411 insert_string ("string"); break; | |
412 case Smath: | |
413 insert_string ("math"); break; | |
414 case Sescape: | |
415 insert_string ("escape"); break; | |
416 case Scharquote: | |
417 insert_string ("charquote"); break; | |
418 case Scomment: | |
419 insert_string ("comment"); break; | |
420 case Sendcomment: | |
421 insert_string ("endcomment"); break; | |
422 default: | |
423 insert_string ("invalid"); | |
424 return; | |
425 } | |
426 | |
427 if (match) | |
428 { | |
429 insert_string (", matches "); | |
430 | |
431 str[0] = match, str[1] = 0; | |
432 insert (str, 1); | |
433 } | |
434 | |
435 if (start1) | |
436 insert_string (",\n\t is the first character of a comment-start sequence"); | |
437 if (start2) | |
438 insert_string (",\n\t is the second character of a comment-start sequence"); | |
439 | |
440 if (end1) | |
441 insert_string (",\n\t is the first character of a comment-end sequence"); | |
442 if (end2) | |
443 insert_string (",\n\t is the second character of a comment-end sequence"); | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
444 if (comstyle) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
445 insert_string (" (comment style b)"); |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
446 |
163 | 447 if (prefix) |
448 insert_string (",\n\t is a prefix character for `backward-prefix-chars'"); | |
449 | |
450 insert_string ("\n"); | |
451 } | |
452 | |
453 Lisp_Object | |
454 describe_syntax_1 (vector) | |
455 Lisp_Object vector; | |
456 { | |
457 struct buffer *old = current_buffer; | |
458 set_buffer_internal (XBUFFER (Vstandard_output)); | |
459 describe_vector (vector, Qnil, describe_syntax, 0, Qnil, Qnil); | |
460 set_buffer_internal (old); | |
461 return Qnil; | |
462 } | |
463 | |
464 DEFUN ("describe-syntax", Fdescribe_syntax, Sdescribe_syntax, 0, 0, "", | |
465 "Describe the syntax specifications in the syntax table.\n\ | |
466 The descriptions are inserted in a buffer, which is then displayed.") | |
467 () | |
468 { | |
469 internal_with_output_to_temp_buffer | |
470 ("*Help*", describe_syntax_1, current_buffer->syntax_table); | |
471 | |
472 return Qnil; | |
473 } | |
474 | |
475 /* Return the position across COUNT words from FROM. | |
476 If that many words cannot be found before the end of the buffer, return 0. | |
477 COUNT negative means scan backward and stop at word beginning. */ | |
478 | |
479 scan_words (from, count) | |
480 register int from, count; | |
481 { | |
482 register int beg = BEGV; | |
483 register int end = ZV; | |
484 register int code; | |
485 | |
486 immediate_quit = 1; | |
487 QUIT; | |
488 | |
489 while (count > 0) | |
490 { | |
491 while (1) | |
492 { | |
493 if (from == end) | |
494 { | |
495 immediate_quit = 0; | |
496 return 0; | |
497 } | |
498 code = SYNTAX (FETCH_CHAR (from)); | |
499 if (words_include_escapes | |
500 && (code == Sescape || code == Scharquote)) | |
501 break; | |
502 if (code == Sword) | |
503 break; | |
504 from++; | |
505 } | |
506 while (1) | |
507 { | |
508 if (from == end) break; | |
509 code = SYNTAX (FETCH_CHAR (from)); | |
510 if (!(words_include_escapes | |
511 && (code == Sescape || code == Scharquote))) | |
512 if (code != Sword) | |
513 break; | |
514 from++; | |
515 } | |
516 count--; | |
517 } | |
518 while (count < 0) | |
519 { | |
520 while (1) | |
521 { | |
522 if (from == beg) | |
523 { | |
524 immediate_quit = 0; | |
525 return 0; | |
526 } | |
527 code = SYNTAX (FETCH_CHAR (from - 1)); | |
528 if (words_include_escapes | |
529 && (code == Sescape || code == Scharquote)) | |
530 break; | |
531 if (code == Sword) | |
532 break; | |
533 from--; | |
534 } | |
535 while (1) | |
536 { | |
537 if (from == beg) break; | |
538 code = SYNTAX (FETCH_CHAR (from - 1)); | |
539 if (!(words_include_escapes | |
540 && (code == Sescape || code == Scharquote))) | |
541 if (code != Sword) | |
542 break; | |
543 from--; | |
544 } | |
545 count++; | |
546 } | |
547 | |
548 immediate_quit = 0; | |
549 | |
550 return from; | |
551 } | |
552 | |
553 DEFUN ("forward-word", Fforward_word, Sforward_word, 1, 1, "p", | |
554 "Move point forward ARG words (backward if ARG is negative).\n\ | |
555 Normally returns t.\n\ | |
556 If an edge of the buffer is reached, point is left there\n\ | |
557 and nil is returned.") | |
558 (count) | |
559 Lisp_Object count; | |
560 { | |
561 int val; | |
562 CHECK_NUMBER (count, 0); | |
563 | |
564 if (!(val = scan_words (point, XINT (count)))) | |
565 { | |
566 SET_PT (XINT (count) > 0 ? ZV : BEGV); | |
567 return Qnil; | |
568 } | |
569 SET_PT (val); | |
570 return Qt; | |
571 } | |
572 | |
573 int parse_sexp_ignore_comments; | |
574 | |
575 Lisp_Object | |
576 scan_lists (from, count, depth, sexpflag) | |
577 register int from; | |
578 int count, depth, sexpflag; | |
579 { | |
580 Lisp_Object val; | |
581 register int stop; | |
582 register int c; | |
583 char stringterm; | |
584 int quoted; | |
585 int mathexit = 0; | |
586 register enum syntaxcode code; | |
587 int min_depth = depth; /* Err out if depth gets less than this. */ | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
588 int comstyle = 0; /* style of comment encountered */ |
163 | 589 |
590 if (depth > 0) min_depth = 0; | |
591 | |
592 immediate_quit = 1; | |
593 QUIT; | |
594 | |
595 while (count > 0) | |
596 { | |
597 stop = ZV; | |
598 while (from < stop) | |
599 { | |
600 c = FETCH_CHAR (from); | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
601 code = SYNTAX (c); |
163 | 602 from++; |
603 if (from < stop && SYNTAX_COMSTART_FIRST (c) | |
604 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from)) | |
605 && parse_sexp_ignore_comments) | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
606 { |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
607 /* we have encountered a comment start sequence and we |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
608 are ignoring all text inside comments. we must record |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
609 the comment style this sequence begins so that later, |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
610 only a comment end of the same style actually ends |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
611 the comment section */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
612 code = Scomment; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
613 comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)); |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
614 from++; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
615 } |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
616 |
163 | 617 if (SYNTAX_PREFIX (c)) |
618 continue; | |
619 | |
620 #ifdef SWITCH_ENUM_BUG | |
621 switch ((int) code) | |
622 #else | |
623 switch (code) | |
624 #endif | |
625 { | |
626 case Sescape: | |
627 case Scharquote: | |
628 if (from == stop) goto lose; | |
629 from++; | |
630 /* treat following character as a word constituent */ | |
631 case Sword: | |
632 case Ssymbol: | |
633 if (depth || !sexpflag) break; | |
634 /* This word counts as a sexp; return at end of it. */ | |
635 while (from < stop) | |
636 { | |
637 #ifdef SWITCH_ENUM_BUG | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
638 switch ((int) SYNTAX (FETCH_CHAR (from))) |
163 | 639 #else |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
640 switch (SYNTAX (FETCH_CHAR (from))) |
163 | 641 #endif |
642 { | |
643 case Scharquote: | |
644 case Sescape: | |
645 from++; | |
646 if (from == stop) goto lose; | |
647 break; | |
648 case Sword: | |
649 case Ssymbol: | |
650 case Squote: | |
651 break; | |
652 default: | |
653 goto done; | |
654 } | |
655 from++; | |
656 } | |
657 goto done; | |
658 | |
659 case Scomment: | |
660 if (!parse_sexp_ignore_comments) break; | |
661 while (1) | |
662 { | |
663 if (from == stop) goto done; | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
664 c = FETCH_CHAR (from); |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
665 if (SYNTAX (c) == Sendcomment |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
666 && SYNTAX_COMMENT_STYLE (c) == comstyle) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
667 /* we have encountered a comment end of the same style |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
668 as the comment sequence which began this comment |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
669 section */ |
163 | 670 break; |
671 from++; | |
672 if (from < stop && SYNTAX_COMEND_FIRST (c) | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
673 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from)) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
674 && SYNTAX_COMMENT_STYLE (c) == comstyle) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
675 /* we have encountered a comment end of the same style |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
676 as the comment sequence which began this comment |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
677 section */ |
163 | 678 { from++; break; } |
679 } | |
680 break; | |
681 | |
682 case Smath: | |
683 if (!sexpflag) | |
684 break; | |
685 if (from != stop && c == FETCH_CHAR (from)) | |
686 from++; | |
687 if (mathexit) | |
688 { | |
689 mathexit = 0; | |
690 goto close1; | |
691 } | |
692 mathexit = 1; | |
693 | |
694 case Sopen: | |
695 if (!++depth) goto done; | |
696 break; | |
697 | |
698 case Sclose: | |
699 close1: | |
700 if (!--depth) goto done; | |
701 if (depth < min_depth) | |
702 error ("Containing expression ends prematurely"); | |
703 break; | |
704 | |
705 case Sstring: | |
706 stringterm = FETCH_CHAR (from - 1); | |
707 while (1) | |
708 { | |
709 if (from >= stop) goto lose; | |
710 if (FETCH_CHAR (from) == stringterm) break; | |
711 #ifdef SWITCH_ENUM_BUG | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
712 switch ((int) SYNTAX (FETCH_CHAR (from))) |
163 | 713 #else |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
714 switch (SYNTAX (FETCH_CHAR (from))) |
163 | 715 #endif |
716 { | |
717 case Scharquote: | |
718 case Sescape: | |
719 from++; | |
720 } | |
721 from++; | |
722 } | |
723 from++; | |
724 if (!depth && sexpflag) goto done; | |
725 break; | |
726 } | |
727 } | |
728 | |
729 /* Reached end of buffer. Error if within object, return nil if between */ | |
730 if (depth) goto lose; | |
731 | |
732 immediate_quit = 0; | |
733 return Qnil; | |
734 | |
735 /* End of object reached */ | |
736 done: | |
737 count--; | |
738 } | |
739 | |
740 while (count < 0) | |
741 { | |
742 stop = BEGV; | |
743 while (from > stop) | |
744 { | |
745 from--; | |
746 if (quoted = char_quoted (from)) | |
747 from--; | |
748 c = FETCH_CHAR (from); | |
749 code = SYNTAX (c); | |
750 if (from > stop && SYNTAX_COMEND_SECOND (c) | |
751 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1)) | |
752 && !char_quoted (from - 1) | |
753 && parse_sexp_ignore_comments) | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
754 { |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
755 /* we must record the comment style encountered so that |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
756 later, we can match only the proper comment begin |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
757 sequence of the same style */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
758 code = Sendcomment; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
759 comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from - 1)); |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
760 from--; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
761 } |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
762 |
163 | 763 if (SYNTAX_PREFIX (c)) |
764 continue; | |
765 | |
766 #ifdef SWITCH_ENUM_BUG | |
767 switch ((int) (quoted ? Sword : code)) | |
768 #else | |
769 switch (quoted ? Sword : code) | |
770 #endif | |
771 { | |
772 case Sword: | |
773 case Ssymbol: | |
774 if (depth || !sexpflag) break; | |
775 /* This word counts as a sexp; count object finished after passing it. */ | |
776 while (from > stop) | |
777 { | |
778 quoted = char_quoted (from - 1); | |
779 if (quoted) | |
780 from--; | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
781 if (! (quoted || SYNTAX (FETCH_CHAR (from - 1)) == Sword |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
782 || SYNTAX (FETCH_CHAR (from - 1)) == Ssymbol |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
783 || SYNTAX (FETCH_CHAR (from - 1)) == Squote)) |
163 | 784 goto done2; |
785 from--; | |
786 } | |
787 goto done2; | |
788 | |
789 case Smath: | |
790 if (!sexpflag) | |
791 break; | |
792 if (from != stop && c == FETCH_CHAR (from - 1)) | |
793 from--; | |
794 if (mathexit) | |
795 { | |
796 mathexit = 0; | |
797 goto open2; | |
798 } | |
799 mathexit = 1; | |
800 | |
801 case Sclose: | |
802 if (!++depth) goto done2; | |
803 break; | |
804 | |
805 case Sopen: | |
806 open2: | |
807 if (!--depth) goto done2; | |
808 if (depth < min_depth) | |
809 error ("Containing expression ends prematurely"); | |
810 break; | |
811 | |
812 case Sendcomment: | |
813 if (!parse_sexp_ignore_comments) | |
814 break; | |
1167
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
815 if (code != SYNTAX (c)) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
816 /* For a two-char comment ender, we can assume |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
817 it does end a comment. So scan back in a simple way. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
818 { |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
819 if (from != stop) from--; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
820 while (1) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
821 { |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
822 if (SYNTAX (c = FETCH_CHAR (from)) == Scomment |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
823 && SYNTAX_COMMENT_STYLE (c) == comstyle) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
824 break; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
825 if (from == stop) goto done; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
826 from--; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
827 if (SYNTAX_COMSTART_SECOND (c) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
828 && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from)) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
829 && SYNTAX_COMMENT_STYLE (c) == comstyle |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
830 && !char_quoted (from)) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
831 break; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
832 } |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
833 break; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
834 } |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
835 |
163 | 836 /* Look back, counting the parity of string-quotes, |
837 and recording the comment-starters seen. | |
838 When we reach a safe place, assume that's not in a string; | |
839 then step the main scan to the earliest comment-starter seen | |
840 an even number of string quotes away from the safe place. | |
841 | |
842 OFROM[I] is position of the earliest comment-starter seen | |
843 which is I+2X quotes from the comment-end. | |
844 PARITY is current parity of quotes from the comment end. */ | |
845 { | |
846 int parity = 0; | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
847 char my_stringend = 0; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
848 int string_lossage = 0; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
849 int comment_end = from; |
1167
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
850 int comstart_pos = 0; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
851 int comstart_parity = 0; |
163 | 852 |
853 /* At beginning of range to scan, we're outside of strings; | |
854 that determines quote parity to the comment-end. */ | |
855 while (from != stop) | |
856 { | |
857 /* Move back and examine a character. */ | |
858 from--; | |
859 | |
860 c = FETCH_CHAR (from); | |
861 code = SYNTAX (c); | |
862 | |
863 /* If this char is the second of a 2-char comment sequence, | |
864 back up and give the pair the appropriate syntax. */ | |
865 if (from > stop && SYNTAX_COMEND_SECOND (c) | |
866 && SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1))) | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
867 { |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
868 code = Sendcomment; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
869 from--; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
870 } |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
871 |
163 | 872 else if (from > stop && SYNTAX_COMSTART_SECOND (c) |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
873 && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from - 1)) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
874 && comstyle == SYNTAX_COMMENT_STYLE (c)) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
875 { |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
876 code = Scomment; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
877 from--; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
878 } |
163 | 879 |
880 /* Ignore escaped characters. */ | |
881 if (char_quoted (from)) | |
882 continue; | |
883 | |
1167
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
884 /* Track parity of quotes. */ |
163 | 885 if (code == Sstring) |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
886 { |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
887 parity ^= 1; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
888 if (my_stringend == 0) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
889 my_stringend = c; |
1167
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
890 /* If we have two kinds of string delimiters. |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
891 There's no way to grok this scanning backwards. */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
892 else if (my_stringend != c) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
893 string_lossage = 1; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
894 } |
163 | 895 |
896 /* Record comment-starters according to that | |
897 quote-parity to the comment-end. */ | |
898 if (code == Scomment) | |
1167
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
899 { |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
900 comstart_parity = parity; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
901 comstart_pos = from; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
902 } |
163 | 903 |
1167
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
904 /* If we find another earlier comment-ender, |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
905 any comment-starts earier than that don't count |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
906 (because they go with the earlier comment-ender). */ |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
907 if (code == Sendcomment |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
908 && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)) == comstyle) |
163 | 909 break; |
1167
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
910 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
911 /* Assume a defun-start point is outside of strings. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
912 if (code == Sopen |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
913 && (from == stop || FETCH_CHAR (from - 1) == '\n')) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
914 break; |
163 | 915 } |
1167
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
916 |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
917 if (comstart_pos == 0) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
918 from = comment_end; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
919 /* If the earliest comment starter |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
920 is followed by uniform paired string quotes or none, |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
921 we know it can't be inside a string |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
922 since if it were then the comment ender would be inside one. |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
923 So it does start a comment. Skip back to it. */ |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
924 else if (comstart_parity == 0 && !string_lossage) |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
925 from = comstart_pos; |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
926 else |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
927 { |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
928 /* We had two kinds of string delimiters mixed up |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
929 together. Decode this going forwards. |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
930 Scan fwd from the previous comment ender |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
931 to the one in question; this records where we |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
932 last passed a comment starter. */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
933 struct lisp_parse_state state; |
1167
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
934 scan_sexps_forward (&state, find_defun_start (comment_end), |
a9aeeaa9da8f
(scan_lists): When searching back for comment:
Richard M. Stallman <rms@gnu.org>
parents:
1085
diff
changeset
|
935 comment_end - 1, -10000, 0, Qnil); |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
936 if (state.incomment) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
937 from = state.comstart; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
938 else |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
939 /* We can't grok this as a comment; scan it normally. */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
940 from = comment_end; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
941 } |
163 | 942 } |
943 break; | |
944 | |
945 case Sstring: | |
946 stringterm = FETCH_CHAR (from); | |
947 while (1) | |
948 { | |
949 if (from == stop) goto lose; | |
950 if (!char_quoted (from - 1) | |
951 && stringterm == FETCH_CHAR (from - 1)) | |
952 break; | |
953 from--; | |
954 } | |
955 from--; | |
956 if (!depth && sexpflag) goto done2; | |
957 break; | |
958 } | |
959 } | |
960 | |
961 /* Reached start of buffer. Error if within object, return nil if between */ | |
962 if (depth) goto lose; | |
963 | |
964 immediate_quit = 0; | |
965 return Qnil; | |
966 | |
967 done2: | |
968 count++; | |
969 } | |
970 | |
971 | |
972 immediate_quit = 0; | |
973 XFASTINT (val) = from; | |
974 return val; | |
975 | |
976 lose: | |
977 error ("Unbalanced parentheses"); | |
978 /* NOTREACHED */ | |
979 } | |
980 | |
981 char_quoted (pos) | |
982 register int pos; | |
983 { | |
984 register enum syntaxcode code; | |
985 register int beg = BEGV; | |
986 register int quoted = 0; | |
987 | |
988 while (pos > beg | |
989 && ((code = SYNTAX (FETCH_CHAR (pos - 1))) == Scharquote | |
990 || code == Sescape)) | |
991 pos--, quoted = !quoted; | |
992 return quoted; | |
993 } | |
994 | |
995 DEFUN ("scan-lists", Fscan_lists, Sscan_lists, 3, 3, 0, | |
996 "Scan from character number FROM by COUNT lists.\n\ | |
997 Returns the character number of the position thus found.\n\ | |
998 \n\ | |
999 If DEPTH is nonzero, paren depth begins counting from that value,\n\ | |
1000 only places where the depth in parentheses becomes zero\n\ | |
1001 are candidates for stopping; COUNT such places are counted.\n\ | |
1002 Thus, a positive value for DEPTH means go out levels.\n\ | |
1003 \n\ | |
1004 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\ | |
1005 \n\ | |
1006 If the beginning or end of (the accessible part of) the buffer is reached\n\ | |
1007 and the depth is wrong, an error is signaled.\n\ | |
1008 If the depth is right but the count is not used up, nil is returned.") | |
1009 (from, count, depth) | |
1010 Lisp_Object from, count, depth; | |
1011 { | |
1012 CHECK_NUMBER (from, 0); | |
1013 CHECK_NUMBER (count, 1); | |
1014 CHECK_NUMBER (depth, 2); | |
1015 | |
1016 return scan_lists (XINT (from), XINT (count), XINT (depth), 0); | |
1017 } | |
1018 | |
1019 DEFUN ("scan-sexps", Fscan_sexps, Sscan_sexps, 2, 2, 0, | |
1020 "Scan from character number FROM by COUNT balanced expressions.\n\ | |
1021 If COUNT is negative, scan backwards.\n\ | |
1022 Returns the character number of the position thus found.\n\ | |
1023 \n\ | |
1024 Comments are ignored if `parse-sexp-ignore-comments' is non-nil.\n\ | |
1025 \n\ | |
1026 If the beginning or end of (the accessible part of) the buffer is reached\n\ | |
1027 in the middle of a parenthetical grouping, an error is signaled.\n\ | |
1028 If the beginning or end is reached between groupings\n\ | |
1029 but before count is used up, nil is returned.") | |
1030 (from, count) | |
1031 Lisp_Object from, count; | |
1032 { | |
1033 CHECK_NUMBER (from, 0); | |
1034 CHECK_NUMBER (count, 1); | |
1035 | |
1036 return scan_lists (XINT (from), XINT (count), 0, 1); | |
1037 } | |
1038 | |
1039 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, Sbackward_prefix_chars, | |
1040 0, 0, 0, | |
1041 "Move point backward over any number of chars with prefix syntax.\n\ | |
1042 This includes chars with \"quote\" or \"prefix\" syntax (' or p).") | |
1043 () | |
1044 { | |
1045 int beg = BEGV; | |
1046 int pos = point; | |
1047 | |
1048 while (pos > beg && !char_quoted (pos - 1) | |
1049 && (SYNTAX (FETCH_CHAR (pos - 1)) == Squote | |
1050 || SYNTAX_PREFIX (FETCH_CHAR (pos - 1)))) | |
1051 pos--; | |
1052 | |
1053 SET_PT (pos); | |
1054 | |
1055 return Qnil; | |
1056 } | |
1057 | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1058 /* Parse forward from FROM to END, |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1059 assuming that FROM has state OLDSTATE (nil means FROM is start of function), |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1060 and return a description of the state of the parse at END. |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1061 If STOPBEFORE is nonzero, stop at the start of an atom. */ |
163 | 1062 |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1063 scan_sexps_forward (stateptr, from, end, targetdepth, stopbefore, oldstate) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1064 struct lisp_parse_state *stateptr; |
163 | 1065 register int from; |
1066 int end, targetdepth, stopbefore; | |
1067 Lisp_Object oldstate; | |
1068 { | |
1069 struct lisp_parse_state state; | |
1070 | |
1071 register enum syntaxcode code; | |
1072 struct level { int last, prev; }; | |
1073 struct level levelstart[100]; | |
1074 register struct level *curlevel = levelstart; | |
1075 struct level *endlevel = levelstart + 100; | |
1076 char prev; | |
1077 register int depth; /* Paren depth of current scanning location. | |
1078 level - levelstart equals this except | |
1079 when the depth becomes negative. */ | |
1080 int mindepth; /* Lowest DEPTH value seen. */ | |
1081 int start_quoted = 0; /* Nonzero means starting after a char quote */ | |
1082 Lisp_Object tem; | |
1083 | |
1084 immediate_quit = 1; | |
1085 QUIT; | |
1086 | |
485 | 1087 if (NILP (oldstate)) |
163 | 1088 { |
1089 depth = 0; | |
1090 state.instring = -1; | |
1091 state.incomment = 0; | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1092 state.comstyle = 0; /* comment style a by default */ |
163 | 1093 } |
1094 else | |
1095 { | |
1096 tem = Fcar (oldstate); | |
485 | 1097 if (!NILP (tem)) |
163 | 1098 depth = XINT (tem); |
1099 else | |
1100 depth = 0; | |
1101 | |
1102 oldstate = Fcdr (oldstate); | |
1103 oldstate = Fcdr (oldstate); | |
1104 oldstate = Fcdr (oldstate); | |
1105 tem = Fcar (oldstate); | |
485 | 1106 state.instring = !NILP (tem) ? XINT (tem) : -1; |
163 | 1107 |
1108 oldstate = Fcdr (oldstate); | |
1109 tem = Fcar (oldstate); | |
485 | 1110 state.incomment = !NILP (tem); |
163 | 1111 |
1112 oldstate = Fcdr (oldstate); | |
1113 tem = Fcar (oldstate); | |
485 | 1114 start_quoted = !NILP (tem); |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1115 |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1116 /* if the eight element of the list is nil, we are in comment |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1117 style a. if it is non-nil, we are in comment style b */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1118 oldstate = Fcdr (oldstate); |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1119 oldstate = Fcdr (oldstate); |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1120 oldstate = Fcdr (oldstate); |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1121 tem = Fcar (oldstate); |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1122 state.comstyle = !NILP (tem); |
163 | 1123 } |
1124 state.quoted = 0; | |
1125 mindepth = depth; | |
1126 | |
1127 curlevel->prev = -1; | |
1128 curlevel->last = -1; | |
1129 | |
1130 /* Enter the loop at a place appropriate for initial state. */ | |
1131 | |
1132 if (state.incomment) goto startincomment; | |
1133 if (state.instring >= 0) | |
1134 { | |
1135 if (start_quoted) goto startquotedinstring; | |
1136 goto startinstring; | |
1137 } | |
1138 if (start_quoted) goto startquoted; | |
1139 | |
1140 while (from < end) | |
1141 { | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1142 code = SYNTAX (FETCH_CHAR (from)); |
163 | 1143 from++; |
1144 if (from < end && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from - 1)) | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1145 && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from))) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1146 { |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1147 /* Record the comment style we have entered so that only |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1148 the comment-end sequence of the same style actually |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1149 terminates the comment section. */ |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1150 code = Scomment; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1151 state.comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)); |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1152 from++; |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1153 } |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1154 |
163 | 1155 if (SYNTAX_PREFIX (FETCH_CHAR (from - 1))) |
1156 continue; | |
1157 #ifdef SWITCH_ENUM_BUG | |
1158 switch ((int) code) | |
1159 #else | |
1160 switch (code) | |
1161 #endif | |
1162 { | |
1163 case Sescape: | |
1164 case Scharquote: | |
1165 if (stopbefore) goto stop; /* this arg means stop at sexp start */ | |
1166 curlevel->last = from - 1; | |
1167 startquoted: | |
1168 if (from == end) goto endquoted; | |
1169 from++; | |
1170 goto symstarted; | |
1171 /* treat following character as a word constituent */ | |
1172 case Sword: | |
1173 case Ssymbol: | |
1174 if (stopbefore) goto stop; /* this arg means stop at sexp start */ | |
1175 curlevel->last = from - 1; | |
1176 symstarted: | |
1177 while (from < end) | |
1178 { | |
1179 #ifdef SWITCH_ENUM_BUG | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1180 switch ((int) SYNTAX (FETCH_CHAR (from))) |
163 | 1181 #else |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1182 switch (SYNTAX (FETCH_CHAR (from))) |
163 | 1183 #endif |
1184 { | |
1185 case Scharquote: | |
1186 case Sescape: | |
1187 from++; | |
1188 if (from == end) goto endquoted; | |
1189 break; | |
1190 case Sword: | |
1191 case Ssymbol: | |
1192 case Squote: | |
1193 break; | |
1194 default: | |
1195 goto symdone; | |
1196 } | |
1197 from++; | |
1198 } | |
1199 symdone: | |
1200 curlevel->prev = curlevel->last; | |
1201 break; | |
1202 | |
1203 case Scomment: | |
1204 state.incomment = 1; | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1205 state.comstart = from; |
163 | 1206 startincomment: |
1207 while (1) | |
1208 { | |
1209 if (from == end) goto done; | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1210 prev = FETCH_CHAR (from); |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1211 if (SYNTAX (prev) == Sendcomment |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1212 && SYNTAX_COMMENT_STYLE (prev) == state.comstyle) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1213 /* Only terminate the comment section if the endcomment |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1214 of the same style as the start sequence has been |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1215 encountered. */ |
163 | 1216 break; |
1217 from++; | |
1218 if (from < end && SYNTAX_COMEND_FIRST (prev) | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1219 && SYNTAX_COMEND_SECOND (FETCH_CHAR (from)) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1220 && SYNTAX_COMMENT_STYLE (prev) == state.comstyle) |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1221 /* Only terminate the comment section if the end-comment |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1222 sequence of the same style as the start sequence has |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1223 been encountered. */ |
163 | 1224 { from++; break; } |
1225 } | |
1226 state.incomment = 0; | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1227 state.comstyle = 0; /* reset the comment style */ |
163 | 1228 break; |
1229 | |
1230 case Sopen: | |
1231 if (stopbefore) goto stop; /* this arg means stop at sexp start */ | |
1232 depth++; | |
1233 /* curlevel++->last ran into compiler bug on Apollo */ | |
1234 curlevel->last = from - 1; | |
1235 if (++curlevel == endlevel) | |
1236 error ("Nesting too deep for parser"); | |
1237 curlevel->prev = -1; | |
1238 curlevel->last = -1; | |
1239 if (!--targetdepth) goto done; | |
1240 break; | |
1241 | |
1242 case Sclose: | |
1243 depth--; | |
1244 if (depth < mindepth) | |
1245 mindepth = depth; | |
1246 if (curlevel != levelstart) | |
1247 curlevel--; | |
1248 curlevel->prev = curlevel->last; | |
1249 if (!++targetdepth) goto done; | |
1250 break; | |
1251 | |
1252 case Sstring: | |
1253 if (stopbefore) goto stop; /* this arg means stop at sexp start */ | |
1254 curlevel->last = from - 1; | |
1255 state.instring = FETCH_CHAR (from - 1); | |
1256 startinstring: | |
1257 while (1) | |
1258 { | |
1259 if (from >= end) goto done; | |
1260 if (FETCH_CHAR (from) == state.instring) break; | |
1261 #ifdef SWITCH_ENUM_BUG | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1262 switch ((int) SYNTAX (FETCH_CHAR (from))) |
163 | 1263 #else |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1264 switch (SYNTAX (FETCH_CHAR (from))) |
163 | 1265 #endif |
1266 { | |
1267 case Scharquote: | |
1268 case Sescape: | |
1269 from++; | |
1270 startquotedinstring: | |
1271 if (from >= end) goto endquoted; | |
1272 } | |
1273 from++; | |
1274 } | |
1275 state.instring = -1; | |
1276 curlevel->prev = curlevel->last; | |
1277 from++; | |
1278 break; | |
1279 | |
1280 case Smath: | |
1281 break; | |
1282 } | |
1283 } | |
1284 goto done; | |
1285 | |
1286 stop: /* Here if stopping before start of sexp. */ | |
1287 from--; /* We have just fetched the char that starts it; */ | |
1288 goto done; /* but return the position before it. */ | |
1289 | |
1290 endquoted: | |
1291 state.quoted = 1; | |
1292 done: | |
1293 state.depth = depth; | |
1294 state.mindepth = mindepth; | |
1295 state.thislevelstart = curlevel->prev; | |
1296 state.prevlevelstart | |
1297 = (curlevel == levelstart) ? -1 : (curlevel - 1)->last; | |
1298 state.location = from; | |
1299 immediate_quit = 0; | |
1300 | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1301 *stateptr = state; |
163 | 1302 } |
1303 | |
1304 /* This comment supplies the doc string for parse-partial-sexp, | |
1305 for make-docfile to see. We cannot put this in the real DEFUN | |
1306 due to limits in the Unix cpp. | |
1307 | |
726 | 1308 DEFUN ("parse-partial-sexp", Ffoo, Sfoo, 2, 5, 0, |
163 | 1309 "Parse Lisp syntax starting at FROM until TO; return status of parse at TO.\n\ |
1310 Parsing stops at TO or when certain criteria are met;\n\ | |
1311 point is set to where parsing stops.\n\ | |
1312 If fifth arg STATE is omitted or nil,\n\ | |
1313 parsing assumes that FROM is the beginning of a function.\n\ | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1314 Value is a list of eight elements describing final state of parsing:\n\ |
163 | 1315 1. depth in parens.\n\ |
1316 2. character address of start of innermost containing list; nil if none.\n\ | |
1317 3. character address of start of last complete sexp terminated.\n\ | |
1318 4. non-nil if inside a string.\n\ | |
1319 (it is the character that will terminate the string.)\n\ | |
1320 5. t if inside a comment.\n\ | |
1321 6. t if following a quote character.\n\ | |
1322 7. the minimum paren-depth encountered during this scan.\n\ | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1323 8. t if in a comment of style `b'.\n\ |
163 | 1324 If third arg TARGETDEPTH is non-nil, parsing stops if the depth\n\ |
1325 in parentheses becomes equal to TARGETDEPTH.\n\ | |
1326 Fourth arg STOPBEFORE non-nil means stop when come to\n\ | |
1327 any character that starts a sexp.\n\ | |
1328 Fifth arg STATE is a seven-list like what this function returns.\n\ | |
726 | 1329 It is used to initialize the state of the parse. Its second and third |
1330 elements are ignored.") | |
1331 (from, to, targetdepth, stopbefore, state) | |
163 | 1332 */ |
1333 | |
1334 DEFUN ("parse-partial-sexp", Fparse_partial_sexp, Sparse_partial_sexp, 2, 5, 0, | |
1335 0 /* See immediately above */) | |
1336 (from, to, targetdepth, stopbefore, oldstate) | |
1337 Lisp_Object from, to, targetdepth, stopbefore, oldstate; | |
1338 { | |
1339 struct lisp_parse_state state; | |
1340 int target; | |
1341 | |
485 | 1342 if (!NILP (targetdepth)) |
163 | 1343 { |
1344 CHECK_NUMBER (targetdepth, 3); | |
1345 target = XINT (targetdepth); | |
1346 } | |
1347 else | |
1348 target = -100000; /* We won't reach this depth */ | |
1349 | |
1350 validate_region (&from, &to); | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1351 scan_sexps_forward (&state, XINT (from), XINT (to), |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1352 target, !NILP (stopbefore), oldstate); |
163 | 1353 |
1354 SET_PT (state.location); | |
1355 | |
1356 return Fcons (make_number (state.depth), | |
1357 Fcons (state.prevlevelstart < 0 ? Qnil : make_number (state.prevlevelstart), | |
1358 Fcons (state.thislevelstart < 0 ? Qnil : make_number (state.thislevelstart), | |
1359 Fcons (state.instring >= 0 ? make_number (state.instring) : Qnil, | |
1360 Fcons (state.incomment ? Qt : Qnil, | |
1361 Fcons (state.quoted ? Qt : Qnil, | |
1085
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1362 Fcons (make_number (state.mindepth), |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1363 Fcons (state.comstyle ? Qt : Qnil, |
91a456e52db1
(scan_lists): Improve smarts for backwards scan of comments.
Richard M. Stallman <rms@gnu.org>
parents:
726
diff
changeset
|
1364 Qnil)))))))); |
163 | 1365 } |
1366 | |
1367 init_syntax_once () | |
1368 { | |
1369 register int i; | |
1370 register struct Lisp_Vector *v; | |
1371 | |
1372 /* Set this now, so first buffer creation can refer to it. */ | |
1373 /* Make it nil before calling copy-syntax-table | |
1374 so that copy-syntax-table will know not to try to copy from garbage */ | |
1375 Vstandard_syntax_table = Qnil; | |
1376 Vstandard_syntax_table = Fcopy_syntax_table (Qnil); | |
1377 | |
1378 v = XVECTOR (Vstandard_syntax_table); | |
1379 | |
1380 for (i = 'a'; i <= 'z'; i++) | |
1381 XFASTINT (v->contents[i]) = (int) Sword; | |
1382 for (i = 'A'; i <= 'Z'; i++) | |
1383 XFASTINT (v->contents[i]) = (int) Sword; | |
1384 for (i = '0'; i <= '9'; i++) | |
1385 XFASTINT (v->contents[i]) = (int) Sword; | |
1386 XFASTINT (v->contents['$']) = (int) Sword; | |
1387 XFASTINT (v->contents['%']) = (int) Sword; | |
1388 | |
1389 XFASTINT (v->contents['(']) = (int) Sopen + (')' << 8); | |
1390 XFASTINT (v->contents[')']) = (int) Sclose + ('(' << 8); | |
1391 XFASTINT (v->contents['[']) = (int) Sopen + (']' << 8); | |
1392 XFASTINT (v->contents[']']) = (int) Sclose + ('[' << 8); | |
1393 XFASTINT (v->contents['{']) = (int) Sopen + ('}' << 8); | |
1394 XFASTINT (v->contents['}']) = (int) Sclose + ('{' << 8); | |
1395 XFASTINT (v->contents['"']) = (int) Sstring; | |
1396 XFASTINT (v->contents['\\']) = (int) Sescape; | |
1397 | |
1398 for (i = 0; i < 10; i++) | |
1399 XFASTINT (v->contents["_-+*/&|<>="[i]]) = (int) Ssymbol; | |
1400 | |
1401 for (i = 0; i < 12; i++) | |
1402 XFASTINT (v->contents[".,;:?!#@~^'`"[i]]) = (int) Spunct; | |
1403 } | |
1404 | |
1405 syms_of_syntax () | |
1406 { | |
1407 Qsyntax_table_p = intern ("syntax-table-p"); | |
1408 staticpro (&Qsyntax_table_p); | |
1409 | |
1410 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments, | |
1411 "Non-nil means `forward-sexp', etc., should treat comments as whitespace."); | |
1412 | |
1413 words_include_escapes = 0; | |
1414 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes, | |
1415 "Non-nil means `forward-word', etc., should treat escape chars part of words."); | |
1416 | |
1417 defsubr (&Ssyntax_table_p); | |
1418 defsubr (&Ssyntax_table); | |
1419 defsubr (&Sstandard_syntax_table); | |
1420 defsubr (&Scopy_syntax_table); | |
1421 defsubr (&Sset_syntax_table); | |
1422 defsubr (&Schar_syntax); | |
1423 defsubr (&Smodify_syntax_entry); | |
1424 defsubr (&Sdescribe_syntax); | |
1425 | |
1426 defsubr (&Sforward_word); | |
1427 | |
1428 defsubr (&Sscan_lists); | |
1429 defsubr (&Sscan_sexps); | |
1430 defsubr (&Sbackward_prefix_chars); | |
1431 defsubr (&Sparse_partial_sexp); | |
1432 } |