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