]> code.delx.au - gnu-emacs/blob - src/syntax.h
delx.au / code / gnu-emacs / blob


03aad0a08dd9c524cbc8bdf2a6f3fe778cc92db1
[gnu-emacs] / src / syntax.h
1 /* Declarations having to do with GNU Emacs syntax tables.
2 Copyright (C) 1985, 1993, 1994, 1997, 1998, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
19
20
21 extern Lisp_Object Qsyntax_table_p;
22 extern void update_syntax_table P_ ((int, int, int, Lisp_Object));
23
24 /* The standard syntax table is stored where it will automatically
25 be used in all new buffers. */
26 #define Vstandard_syntax_table buffer_defaults.syntax_table
27
28 /* A syntax table is a chartable whose elements are cons cells
29 (CODE+FLAGS . MATCHING-CHAR). MATCHING-CHAR can be nil if the char
30 is not a kind of parenthesis.
31
32 The low 8 bits of CODE+FLAGS is a code, as follows: */
33
34 enum syntaxcode
35 {
36 Swhitespace, /* for a whitespace character */
37 Spunct, /* for random punctuation characters */
38 Sword, /* for a word constituent */
39 Ssymbol, /* symbol constituent but not word constituent */
40 Sopen, /* for a beginning delimiter */
41 Sclose, /* for an ending delimiter */
42 Squote, /* for a prefix character like Lisp ' */
43 Sstring, /* for a string-grouping character like Lisp " */
44 Smath, /* for delimiters like $ in Tex. */
45 Sescape, /* for a character that begins a C-style escape */
46 Scharquote, /* for a character that quotes the following character */
47 Scomment, /* for a comment-starting character */
48 Sendcomment, /* for a comment-ending character */
49 Sinherit, /* use the standard syntax table for this character */
50 Scomment_fence, /* Starts/ends comment which is delimited on the
51 other side by any char with the same syntaxcode. */
52 Sstring_fence, /* Starts/ends string which is delimited on the
53 other side by any char with the same syntaxcode. */
54 Smax /* Upper bound on codes that are meaningful */
55 };
56
57 /* Set the syntax entry VAL for char C in table TABLE. */
58
59 #define SET_RAW_SYNTAX_ENTRY(table, c, val) \
60 CHAR_TABLE_SET ((table), c, (val))
61
62 /* Set the syntax entry VAL for char-range RANGE in table TABLE.
63 RANGE is a cons (FROM . TO) specifying the range of characters. */
64
65 #define SET_RAW_SYNTAX_ENTRY_RANGE(table, range, val) \
66 Fset_char_table_range ((table), (range), (val))
67
68 /* SYNTAX_ENTRY fetches the information from the entry for character C
69 in syntax table TABLE, or from globally kept data (gl_state).
70 Does inheritance. */
71 /* CURRENT_SYNTAX_TABLE gives the syntax table valid for current
72 position, it is either the buffer's syntax table, or syntax table
73 found in text properties. */
74
75 #ifdef SYNTAX_ENTRY_VIA_PROPERTY
76 # define SYNTAX_ENTRY(c) \
77 (gl_state.use_global ? gl_state.global_code : SYNTAX_ENTRY_INT (c))
78 # define CURRENT_SYNTAX_TABLE gl_state.current_syntax_table
79 #else
80 # define SYNTAX_ENTRY SYNTAX_ENTRY_INT
81 # define CURRENT_SYNTAX_TABLE current_buffer->syntax_table
82 #endif
83
84 #define SYNTAX_ENTRY_INT(c) CHAR_TABLE_REF (CURRENT_SYNTAX_TABLE, (c))
85
86 /* Extract the information from the entry for character C
87 in the current syntax table. */
88
89 #ifdef __GNUC__
90 #define SYNTAX(c) \
91 ({ Lisp_Object _syntax_temp; \
92 _syntax_temp = SYNTAX_ENTRY (c); \
93 (CONSP (_syntax_temp) \
94 ? (enum syntaxcode) (XINT (XCAR (_syntax_temp)) & 0xff) \
95 : Swhitespace); })
96
97 #define SYNTAX_WITH_FLAGS(c) \
98 ({ Lisp_Object _syntax_temp; \
99 _syntax_temp = SYNTAX_ENTRY (c); \
100 (CONSP (_syntax_temp) \
101 ? XINT (XCAR (_syntax_temp)) \
102 : (int) Swhitespace); })
103
104 #define SYNTAX_MATCH(c) \
105 ({ Lisp_Object _syntax_temp; \
106 _syntax_temp = SYNTAX_ENTRY (c); \
107 (CONSP (_syntax_temp) \
108 ? XCDR (_syntax_temp) \
109 : Qnil); })
110 #else
111 extern Lisp_Object syntax_temp;
112 #define SYNTAX(c) \
113 (syntax_temp = SYNTAX_ENTRY ((c)), \
114 (CONSP (syntax_temp) \
115 ? (enum syntaxcode) (XINT (XCAR (syntax_temp)) & 0xff) \
116 : Swhitespace))
117
118 #define SYNTAX_WITH_FLAGS(c) \
119 (syntax_temp = SYNTAX_ENTRY ((c)), \
120 (CONSP (syntax_temp) \
121 ? XINT (XCAR (syntax_temp)) \
122 : (int) Swhitespace))
123
124 #define SYNTAX_MATCH(c) \
125 (syntax_temp = SYNTAX_ENTRY ((c)), \
126 (CONSP (syntax_temp) \
127 ? XCDR (syntax_temp) \
128 : Qnil))
129 #endif
130
131 /* Then there are seven single-bit flags that have the following meanings:
132 1. This character is the first of a two-character comment-start sequence.
133 2. This character is the second of a two-character comment-start sequence.
134 3. This character is the first of a two-character comment-end sequence.
135 4. This character is the second of a two-character comment-end sequence.
136 5. This character is a prefix, for backward-prefix-chars.
137 6. see below
138 7. This character is part of a nestable comment sequence.
139 Note that any two-character sequence whose first character has flag 1
140 and whose second character has flag 2 will be interpreted as a comment start.
141
142 bit 6 is used to discriminate between two different comment styles.
143 Languages such as C++ allow two orthogonal syntax start/end pairs
144 and bit 6 is used to determine whether a comment-end or Scommentend
145 ends style a or b. Comment start sequences can start style a or b.
146 Style a is always the default.
147 */
148
149 /* These macros extract a particular flag for a given character. */
150
151 #define SYNTAX_COMSTART_FIRST(c) ((SYNTAX_WITH_FLAGS (c) >> 16) & 1)
152
153 #define SYNTAX_COMSTART_SECOND(c) ((SYNTAX_WITH_FLAGS (c) >> 17) & 1)
154
155 #define SYNTAX_COMEND_FIRST(c) ((SYNTAX_WITH_FLAGS (c) >> 18) & 1)
156
157 #define SYNTAX_COMEND_SECOND(c) ((SYNTAX_WITH_FLAGS (c) >> 19) & 1)
158
159 #define SYNTAX_PREFIX(c) ((SYNTAX_WITH_FLAGS (c) >> 20) & 1)
160
161 #define SYNTAX_COMMENT_STYLE(c) ((SYNTAX_WITH_FLAGS (c) >> 21) & 1)
162
163 #define SYNTAX_COMMENT_NESTED(c) ((SYNTAX_WITH_FLAGS (c) >> 22) & 1)
164
165 /* These macros extract specific flags from an integer
166 that holds the syntax code and the flags. */
167
168 #define SYNTAX_FLAGS_COMSTART_FIRST(flags) (((flags) >> 16) & 1)
169
170 #define SYNTAX_FLAGS_COMSTART_SECOND(flags) (((flags) >> 17) & 1)
171
172 #define SYNTAX_FLAGS_COMEND_FIRST(flags) (((flags) >> 18) & 1)
173
174 #define SYNTAX_FLAGS_COMEND_SECOND(flags) (((flags) >> 19) & 1)
175
176 #define SYNTAX_FLAGS_PREFIX(flags) (((flags) >> 20) & 1)
177
178 #define SYNTAX_FLAGS_COMMENT_STYLE(flags) (((flags) >> 21) & 1)
179
180 #define SYNTAX_FLAGS_COMMENT_NESTED(flags) (((flags) >> 22) & 1)
181
182 /* This array, indexed by a character, contains the syntax code which that
183 character signifies (as a char). For example,
184 (enum syntaxcode) syntax_spec_code['w'] is Sword. */
185
186 extern unsigned char syntax_spec_code[0400];
187
188 /* Indexed by syntax code, give the letter that describes it. */
189
190 extern char syntax_code_spec[16];
191
192 /* Convert the byte offset BYTEPOS into a character position,
193 for the object recorded in gl_state with SETUP_SYNTAX_TABLE_FOR_OBJECT.
194
195 The value is meant for use in the UPDATE_SYNTAX_TABLE... macros.
196 These macros do nothing when parse_sexp_lookup_properties is 0,
197 so we return 0 in that case, for speed. */
198
199 #define SYNTAX_TABLE_BYTE_TO_CHAR(bytepos) \
200 (! parse_sexp_lookup_properties \
201 ? 0 \
202 : STRINGP (gl_state.object) \
203 ? string_byte_to_char (gl_state.object, (bytepos)) \
204 : BUFFERP (gl_state.object) \
205 ? buf_bytepos_to_charpos (XBUFFER (gl_state.object), \
206 (bytepos) + BUF_BEGV_BYTE (XBUFFER (gl_state.object)) - 1) - BUF_BEGV (XBUFFER (gl_state.object)) + 1 \
207 : NILP (gl_state.object) \
208 ? BYTE_TO_CHAR ((bytepos) + BEGV_BYTE - 1) - BEGV + 1 \
209 : (bytepos))
210
211 /* Make syntax table state (gl_state) good for CHARPOS, assuming it is
212 currently good for a position before CHARPOS. */
213
214 #define UPDATE_SYNTAX_TABLE_FORWARD(charpos) \
215 (parse_sexp_lookup_properties \
216 && (charpos) >= gl_state.e_property \
217 ? (update_syntax_table ((charpos) + gl_state.offset, 1, 0, \
218 gl_state.object), \
219 1) \
220 : 0)
221
222 /* Make syntax table state (gl_state) good for CHARPOS, assuming it is
223 currently good for a position after CHARPOS. */
224
225 #define UPDATE_SYNTAX_TABLE_BACKWARD(charpos) \
226 (parse_sexp_lookup_properties \
227 && (charpos) < gl_state.b_property \
228 ? (update_syntax_table ((charpos) + gl_state.offset, -1, 0, \
229 gl_state.object), \
230 1) \
231 : 0)
232
233 /* Make syntax table good for CHARPOS. */
234
235 #define UPDATE_SYNTAX_TABLE(charpos) \
236 (parse_sexp_lookup_properties \
237 && (charpos) < gl_state.b_property \
238 ? (update_syntax_table ((charpos) + gl_state.offset, -1, 0, \
239 gl_state.object), \
240 1) \
241 : (parse_sexp_lookup_properties \
242 && (charpos) >= gl_state.e_property \
243 ? (update_syntax_table ((charpos) + gl_state.offset, 1, 0,\
244 gl_state.object), \
245 1) \
246 : 0))
247
248 /* This macro should be called with FROM at the start of forward
249 search, or after the last position of the backward search. It
250 makes sure that the first char is picked up with correct table, so
251 one does not need to call UPDATE_SYNTAX_TABLE immediately after the
252 call.
253 Sign of COUNT gives the direction of the search.
254 */
255
256 #define SETUP_SYNTAX_TABLE(FROM, COUNT) \
257 do \
258 { \
259 gl_state.b_property = BEGV; \
260 gl_state.e_property = ZV + 1; \
261 gl_state.object = Qnil; \
262 gl_state.use_global = 0; \
263 gl_state.offset = 0; \
264 gl_state.current_syntax_table = current_buffer->syntax_table; \
265 if (parse_sexp_lookup_properties) \
266 if ((COUNT) > 0 || (FROM) > BEGV) \
267 update_syntax_table ((COUNT) > 0 ? (FROM) : (FROM) - 1, (COUNT),\
268 1, Qnil); \
269 } \
270 while (0)
271
272 /* Same as above, but in OBJECT. If OBJECT is nil, use current buffer.
273 If it is t, ignore properties altogether.
274
275 This is meant for regex.c to use. For buffers, regex.c passes arguments
276 to the UPDATE_SYNTAX_TABLE macros which are relative to BEGV.
277 So if it is a buffer, we set the offset field to BEGV. */
278
279 #define SETUP_SYNTAX_TABLE_FOR_OBJECT(OBJECT, FROM, COUNT) \
280 do \
281 { \
282 gl_state.object = (OBJECT); \
283 if (BUFFERP (gl_state.object)) \
284 { \
285 struct buffer *buf = XBUFFER (gl_state.object); \
286 gl_state.b_property = 1; \
287 gl_state.e_property = BUF_ZV (buf) - BUF_BEGV (buf) + 1; \
288 gl_state.offset = BUF_BEGV (buf) - 1; \
289 } \
290 else if (NILP (gl_state.object)) \
291 { \
292 gl_state.b_property = 1; \
293 gl_state.e_property = ZV - BEGV + 1; \
294 gl_state.offset = BEGV - 1; \
295 } \
296 else if (EQ (gl_state.object, Qt)) \
297 { \
298 gl_state.b_property = 0; \
299 gl_state.e_property = 1500000000; \
300 gl_state.offset = 0; \
301 } \
302 else \
303 { \
304 gl_state.b_property = 0; \
305 gl_state.e_property = 1 + SCHARS (gl_state.object); \
306 gl_state.offset = 0; \
307 } \
308 gl_state.use_global = 0; \
309 gl_state.current_syntax_table = current_buffer->syntax_table; \
310 if (parse_sexp_lookup_properties) \
311 update_syntax_table (((FROM) + gl_state.offset \
312 + (COUNT > 0 ? 0 : -1)), \
313 COUNT, 1, gl_state.object); \
314 } \
315 while (0)
316
317 struct gl_state_s
318 {
319 Lisp_Object object; /* The object we are scanning. */
320 int start; /* Where to stop. */
321 int stop; /* Where to stop. */
322 int use_global; /* Whether to use global_code
323 or c_s_t. */
324 Lisp_Object global_code; /* Syntax code of current char. */
325 Lisp_Object current_syntax_table; /* Syntax table for current pos. */
326 Lisp_Object old_prop; /* Syntax-table prop at prev pos. */
327 int b_property; /* First index where c_s_t is valid. */
328 int e_property; /* First index where c_s_t is
329 not valid. */
330 INTERVAL forward_i; /* Where to start lookup on forward */
331 INTERVAL backward_i; /* or backward movement. The
332 data in c_s_t is valid
333 between these intervals,
334 and possibly at the
335 intervals too, depending
336 on: */
337 /* Offset for positions specified to UPDATE_SYNTAX_TABLE. */
338 int offset;
339 };
340
341 extern struct gl_state_s gl_state;
342 extern int parse_sexp_lookup_properties;
343 extern INTERVAL interval_of P_ ((int, Lisp_Object));
344
345 extern int scan_words P_ ((int, int));
346
347 /* arch-tag: 28833cca-cd73-4741-8c85-a3111166a0e0
348 (do not change this comment) */