|
428
|
1 /* Routines to compute the current syntactic context, for font-lock mode.
|
|
|
2 Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
|
|
|
3 Copyright (C) 1995 Sun Microsystems, Inc.
|
|
826
|
4 Copyright (C) 2002 Ben Wing.
|
|
428
|
5
|
|
|
6 This file is part of XEmacs.
|
|
|
7
|
|
|
8 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
9 under the terms of the GNU General Public License as published by the
|
|
|
10 Free Software Foundation; either version 2, or (at your option) any
|
|
|
11 later version.
|
|
|
12
|
|
|
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 for more details.
|
|
|
17
|
|
|
18 You should have received a copy of the GNU General Public License
|
|
|
19 along with XEmacs; see the file COPYING. If not, write to
|
|
|
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
21 Boston, MA 02111-1307, USA. */
|
|
|
22
|
|
|
23 /* Synched up with: Not in FSF. */
|
|
|
24
|
|
|
25 /* This code computes the syntactic context of the current point, that is,
|
|
|
26 whether point is within a comment, a string, what have you. It does
|
|
|
27 this by picking a point "known" to be outside of any syntactic constructs
|
|
|
28 and moving forward, examining the syntax of each character.
|
|
|
29
|
|
|
30 Two caches are used: one caches the last point computed, and the other
|
|
|
31 caches the last point at the beginning of a line. This makes there
|
|
|
32 be little penalty for moving left-to-right on a line a character at a
|
|
|
33 time; makes starting over on a line be cheap; and makes random-accessing
|
|
|
34 within a line relatively cheap.
|
|
|
35
|
|
|
36 When we move to a different line farther down in the file (but within the
|
|
|
37 current top-level form) we simply continue computing forward. If we move
|
|
|
38 backward more than a line, or move beyond the end of the current tlf, or
|
|
|
39 switch buffers, then we call `beginning-of-defun' and start over from
|
|
|
40 there.
|
|
|
41
|
|
|
42 #### We should really rewrite this to keep extents over the buffer
|
|
|
43 that hold the current syntactic information. This would be a big win.
|
|
|
44 This way there would be no guessing or incorrect results.
|
|
|
45 */
|
|
|
46
|
|
838
|
47 #include <config.h>
|
|
826
|
48
|
|
838
|
49 #ifdef USE_C_FONT_LOCK
|
|
|
50
|
|
428
|
51 #include "lisp.h"
|
|
|
52
|
|
|
53 #include "buffer.h"
|
|
|
54 #include "insdel.h"
|
|
|
55 #include "syntax.h"
|
|
|
56
|
|
|
57 Lisp_Object Qcomment;
|
|
|
58 Lisp_Object Qblock_comment;
|
|
|
59 Lisp_Object Qbeginning_of_defun;
|
|
|
60
|
|
|
61 enum syntactic_context
|
|
|
62 {
|
|
|
63 context_none,
|
|
|
64 context_string,
|
|
|
65 context_comment,
|
|
460
|
66 context_block_comment,
|
|
|
67 context_generic_comment,
|
|
|
68 context_generic_string
|
|
428
|
69 };
|
|
|
70
|
|
|
71 enum block_comment_context
|
|
|
72 {
|
|
|
73 ccontext_none,
|
|
|
74 ccontext_start1,
|
|
|
75 ccontext_start2,
|
|
|
76 ccontext_end1
|
|
|
77 };
|
|
|
78
|
|
|
79 enum comment_style
|
|
|
80 {
|
|
|
81 comment_style_none,
|
|
|
82 comment_style_a,
|
|
|
83 comment_style_b
|
|
|
84 };
|
|
|
85
|
|
|
86 struct context_cache
|
|
|
87 {
|
|
665
|
88 Charbpos start_point; /* beginning of defun */
|
|
|
89 Charbpos cur_point; /* cache location */
|
|
|
90 Charbpos end_point; /* end of defun */
|
|
428
|
91 struct buffer *buffer; /* does this need to be staticpro'd? */
|
|
|
92 enum syntactic_context context; /* single-char-syntax state */
|
|
|
93 enum block_comment_context ccontext; /* block-comment state */
|
|
|
94 enum comment_style style; /* which comment group */
|
|
|
95 Emchar scontext; /* active string delimiter */
|
|
|
96 int depth; /* depth in parens */
|
|
|
97 int backslash_p; /* just read a backslash */
|
|
|
98 int needs_its_head_reexamined; /* we're apparently outside of
|
|
|
99 a top level form, and far away
|
|
|
100 from it. This is a bad situation
|
|
|
101 because it will lead to constant
|
|
|
102 slowness as we keep going way
|
|
|
103 back to that form and moving
|
|
|
104 forward again. In this case,
|
|
|
105 we try to compute a "pseudo-
|
|
|
106 top-level-form" where the
|
|
|
107 depth is 0 and the context
|
|
|
108 is none at both ends. */
|
|
|
109 };
|
|
|
110
|
|
|
111 /* We have two caches; one for the current point and one for
|
|
|
112 the beginning of line. We used to rely on the caller to
|
|
|
113 tell us when to invalidate them, but now we do it ourselves;
|
|
|
114 it lets us be smarter. */
|
|
|
115
|
|
|
116 static struct context_cache context_cache;
|
|
|
117
|
|
|
118 static struct context_cache bol_context_cache;
|
|
|
119
|
|
|
120 int font_lock_debug;
|
|
|
121
|
|
|
122 #define reset_context_cache(cc) memset (cc, 0, sizeof (struct context_cache))
|
|
|
123
|
|
|
124 /* This function is called from signal_after_change() to tell us when
|
|
|
125 textual changes are made so we can flush our caches when necessary.
|
|
|
126
|
|
|
127 We make the following somewhat heuristic assumptions:
|
|
|
128
|
|
|
129 (remember that current_point is always >= start_point, but may be
|
|
|
130 less than or greater than end_point (we might not be inside any
|
|
|
131 top-level form)).
|
|
|
132
|
|
|
133 1) Textual changes before the beginning of the current top-level form
|
|
|
134 don't affect anything; all we need to do is offset the caches
|
|
|
135 appropriately.
|
|
|
136 2) Textual changes right at the beginning of the current
|
|
|
137 top-level form messes things up and requires that we flush
|
|
|
138 the caches.
|
|
|
139 3) Textual changes after the beginning of the current top-level form
|
|
|
140 and before one or both or the caches invalidates the corresponding
|
|
|
141 cache(s).
|
|
|
142 4) Textual changes after the caches and before the end of the
|
|
|
143 current top-level form don't affect anything; all we need to do is
|
|
|
144 offset the caches appropriately.
|
|
|
145 5) Textual changes right at the end of the current top-level form
|
|
|
146 necessitate recomputing that end value.
|
|
|
147 6) Textual changes after the end of the current top-level form
|
|
|
148 are ignored. */
|
|
|
149
|
|
|
150
|
|
|
151 void
|
|
665
|
152 font_lock_maybe_update_syntactic_caches (struct buffer *buf, Charbpos start,
|
|
|
153 Charbpos orig_end, Charbpos new_end)
|
|
428
|
154 {
|
|
|
155 /* Note: either both context_cache and bol_context_cache are valid and
|
|
|
156 point to the same buffer, or both are invalid. If we have to
|
|
|
157 invalidate just context_cache, we recopy it from bol_context_cache.
|
|
|
158 */
|
|
|
159 if (context_cache.buffer != buf)
|
|
|
160 /* caches don't apply */
|
|
|
161 return;
|
|
|
162 /* NOTE: The order of the if statements below is important. If you
|
|
|
163 change them around unthinkingly, you will probably break something. */
|
|
|
164 if (orig_end <= context_cache.start_point - 1)
|
|
|
165 {
|
|
|
166 /* case 1: before the beginning of the current top-level form */
|
|
|
167 Charcount diff = new_end - orig_end;
|
|
|
168 if (font_lock_debug)
|
|
|
169 stderr_out ("font-lock; Case 1\n");
|
|
|
170 context_cache.start_point += diff;
|
|
|
171 context_cache.cur_point += diff;
|
|
|
172 context_cache.end_point += diff;
|
|
|
173 bol_context_cache.start_point += diff;
|
|
|
174 bol_context_cache.cur_point += diff;
|
|
|
175 bol_context_cache.end_point += diff;
|
|
|
176 }
|
|
|
177 else if (start <= context_cache.start_point)
|
|
|
178 {
|
|
|
179 if (font_lock_debug)
|
|
|
180 stderr_out ("font-lock; Case 2\n");
|
|
|
181 /* case 2: right at the current top-level form (paren that starts
|
|
|
182 top level form got deleted or moved away from the newline it
|
|
|
183 was touching) */
|
|
|
184 reset_context_cache (&context_cache);
|
|
|
185 reset_context_cache (&bol_context_cache);
|
|
|
186 }
|
|
|
187 /* OK, now we know that the start is after the beginning of the
|
|
|
188 current top-level form. */
|
|
|
189 else if (start < bol_context_cache.cur_point)
|
|
|
190 {
|
|
|
191 if (font_lock_debug)
|
|
|
192 stderr_out ("font-lock; Case 3 (1)\n");
|
|
|
193 /* case 3: after the beginning of the current top-level form
|
|
|
194 and before both of the caches */
|
|
|
195 reset_context_cache (&context_cache);
|
|
|
196 reset_context_cache (&bol_context_cache);
|
|
|
197 }
|
|
|
198 else if (start < context_cache.cur_point)
|
|
|
199 {
|
|
|
200 if (font_lock_debug)
|
|
|
201 stderr_out ("font-lock; Case 3 (2)\n");
|
|
|
202 /* case 3: but only need to invalidate one cache */
|
|
|
203 context_cache = bol_context_cache;
|
|
|
204 }
|
|
|
205 /* OK, now we know that the start is after the caches. */
|
|
|
206 else if (start >= context_cache.end_point)
|
|
|
207 {
|
|
|
208 if (font_lock_debug)
|
|
|
209 stderr_out ("font-lock; Case 6\n");
|
|
|
210 /* case 6: after the end of the current top-level form
|
|
|
211 and after the caches. */
|
|
|
212 }
|
|
|
213 else if (orig_end <= context_cache.end_point - 2)
|
|
|
214 {
|
|
|
215 /* case 4: after the caches and before the end of the
|
|
|
216 current top-level form */
|
|
|
217 Charcount diff = new_end - orig_end;
|
|
|
218 if (font_lock_debug)
|
|
|
219 stderr_out ("font-lock; Case 4\n");
|
|
|
220 context_cache.end_point += diff;
|
|
|
221 bol_context_cache.end_point += diff;
|
|
|
222 }
|
|
|
223 else
|
|
|
224 {
|
|
|
225 if (font_lock_debug)
|
|
|
226 stderr_out ("font-lock; Case 5\n");
|
|
|
227 /* case 5: right at the end of the current top-level form */
|
|
|
228 context_cache.end_point = context_cache.start_point - 1;
|
|
|
229 bol_context_cache.end_point = context_cache.start_point - 1;
|
|
|
230 }
|
|
|
231 }
|
|
|
232
|
|
|
233 /* This function is called from Fkill_buffer(). */
|
|
|
234
|
|
|
235 void
|
|
|
236 font_lock_buffer_was_killed (struct buffer *buf)
|
|
|
237 {
|
|
|
238 if (context_cache.buffer == buf)
|
|
|
239 {
|
|
|
240 reset_context_cache (&context_cache);
|
|
|
241 reset_context_cache (&bol_context_cache);
|
|
|
242 }
|
|
|
243 }
|
|
|
244
|
|
665
|
245 static Charbpos
|
|
|
246 beginning_of_defun (struct buffer *buf, Charbpos pt)
|
|
428
|
247 {
|
|
|
248 /* This function can GC */
|
|
665
|
249 Charbpos opt = BUF_PT (buf);
|
|
428
|
250 if (pt == BUF_BEGV (buf))
|
|
|
251 return pt;
|
|
|
252 BUF_SET_PT (buf, pt);
|
|
|
253 /* There used to be some kludginess to call c++-beginning-of-defun
|
|
|
254 if we're in C++ mode. There's no point in this any more;
|
|
|
255 we're using cc-mode. If you really want to get the old c++
|
|
|
256 mode working, fix it rather than the C code. */
|
|
|
257 call0_in_buffer (buf, Qbeginning_of_defun);
|
|
|
258 pt = BUF_PT (buf);
|
|
|
259 BUF_SET_PT (buf, opt);
|
|
|
260 return pt;
|
|
|
261 }
|
|
|
262
|
|
665
|
263 static Charbpos
|
|
|
264 end_of_defun (struct buffer *buf, Charbpos pt)
|
|
428
|
265 {
|
|
|
266 Lisp_Object retval = scan_lists (buf, pt, 1, 0, 0, 1);
|
|
|
267 if (NILP (retval))
|
|
|
268 return BUF_ZV (buf);
|
|
|
269 else
|
|
|
270 return XINT (retval);
|
|
|
271 }
|
|
|
272
|
|
|
273 /* Set up context_cache for attempting to determine the syntactic context
|
|
|
274 in buffer BUF at point PT. */
|
|
|
275
|
|
|
276 static void
|
|
665
|
277 setup_context_cache (struct buffer *buf, Charbpos pt)
|
|
428
|
278 {
|
|
|
279 int recomputed_start_point = 0;
|
|
|
280 /* This function can GC */
|
|
|
281 if (context_cache.buffer != buf || pt < context_cache.start_point)
|
|
|
282 {
|
|
|
283 start_over:
|
|
|
284 if (font_lock_debug)
|
|
|
285 stderr_out ("reset context cache\n");
|
|
|
286 /* OK, completely invalid. */
|
|
|
287 reset_context_cache (&context_cache);
|
|
|
288 reset_context_cache (&bol_context_cache);
|
|
|
289 }
|
|
|
290 if (!context_cache.buffer)
|
|
|
291 {
|
|
|
292 /* Need to recompute the start point. */
|
|
|
293 if (font_lock_debug)
|
|
|
294 stderr_out ("recompute start\n");
|
|
|
295 context_cache.start_point = beginning_of_defun (buf, pt);
|
|
|
296 recomputed_start_point = 1;
|
|
|
297 bol_context_cache.start_point = context_cache.start_point;
|
|
|
298 bol_context_cache.buffer = context_cache.buffer = buf;
|
|
|
299 }
|
|
|
300 if (context_cache.end_point < context_cache.start_point)
|
|
|
301 {
|
|
|
302 /* Need to recompute the end point. */
|
|
|
303 if (font_lock_debug)
|
|
|
304 stderr_out ("recompute end\n");
|
|
|
305 context_cache.end_point = end_of_defun (buf, context_cache.start_point);
|
|
|
306 bol_context_cache.end_point = context_cache.end_point;
|
|
|
307 }
|
|
|
308 if (bol_context_cache.cur_point == 0 ||
|
|
|
309 pt < bol_context_cache.cur_point)
|
|
|
310 {
|
|
|
311 if (font_lock_debug)
|
|
|
312 stderr_out ("reset to start\n");
|
|
|
313 if (pt > context_cache.end_point
|
|
|
314 /* 3000 is some arbitrary delta but seems reasonable;
|
|
|
315 about the size of a reasonable function */
|
|
|
316 && pt - context_cache.end_point > 3000)
|
|
|
317 /* If we're far past the end of the top level form,
|
|
|
318 don't trust it; recompute it. */
|
|
|
319 {
|
|
|
320 /* But don't get in an infinite loop doing this.
|
|
|
321 If we're really far past the end of the top level
|
|
|
322 form, try to compute a pseudo-top-level form. */
|
|
|
323 if (recomputed_start_point)
|
|
|
324 context_cache.needs_its_head_reexamined = 1;
|
|
|
325 else
|
|
|
326 /* force recomputation */
|
|
|
327 goto start_over;
|
|
|
328 }
|
|
|
329 /* Go to the nearest end of the top-level form that's before
|
|
|
330 us. */
|
|
|
331 if (pt > context_cache.end_point)
|
|
|
332 pt = context_cache.end_point;
|
|
|
333 else
|
|
|
334 pt = context_cache.start_point;
|
|
|
335 /* Reset current point to start of buffer. */
|
|
|
336 context_cache.cur_point = pt;
|
|
|
337 context_cache.context = context_none;
|
|
|
338 context_cache.ccontext = ccontext_none;
|
|
|
339 context_cache.style = comment_style_none;
|
|
|
340 context_cache.scontext = '\000';
|
|
|
341 context_cache.depth = 0;
|
|
460
|
342 /* #### shouldn't this be checking the character's syntax instead of
|
|
|
343 explicitly testing for backslash characters? */
|
|
428
|
344 context_cache.backslash_p = ((pt > 1) &&
|
|
|
345 (BUF_FETCH_CHAR (buf, pt - 1) == '\\'));
|
|
|
346 /* Note that the BOL context cache may not be at the beginning
|
|
|
347 of the line, but that should be OK, nobody's checking. */
|
|
|
348 bol_context_cache = context_cache;
|
|
|
349 return;
|
|
|
350 }
|
|
|
351 else if (pt < context_cache.cur_point)
|
|
|
352 {
|
|
|
353 if (font_lock_debug)
|
|
|
354 stderr_out ("reset to bol\n");
|
|
|
355 /* bol cache is OK but current_cache is not. */
|
|
|
356 context_cache = bol_context_cache;
|
|
|
357 return;
|
|
|
358 }
|
|
|
359 else if (pt <= context_cache.end_point)
|
|
|
360 {
|
|
|
361 if (font_lock_debug)
|
|
|
362 stderr_out ("everything is OK\n");
|
|
|
363 /* in same top-level form. */
|
|
|
364 return;
|
|
|
365 }
|
|
|
366 {
|
|
|
367 /* OK, we're past the end of the top-level form. */
|
|
665
|
368 Charbpos maxpt = max (context_cache.end_point, context_cache.cur_point);
|
|
428
|
369 #if 0
|
|
|
370 int shortage;
|
|
|
371 #endif
|
|
|
372
|
|
|
373 if (font_lock_debug)
|
|
|
374 stderr_out ("past end\n");
|
|
|
375 if (pt <= maxpt)
|
|
|
376 /* OK, fine. */
|
|
|
377 return;
|
|
|
378 #if 0
|
|
442
|
379 /* This appears to cause huge slowdowns in files which have no
|
|
|
380 top-level forms.
|
|
428
|
381
|
|
|
382 In any case, it's not really necessary that we know for
|
|
|
383 sure the top-level form we're in; if we're in a form
|
|
|
384 but the form we have recorded is the previous one,
|
|
|
385 it will be OK. */
|
|
|
386
|
|
|
387 scan_buffer (buf, '\n', maxpt, pt, 1, &shortage, 1);
|
|
|
388 if (!shortage)
|
|
|
389 /* If there was a newline in the region past the known universe,
|
|
|
390 we might be inside another top-level form, so start over.
|
|
|
391 Otherwise, we're outside of any top-level forms and we know
|
|
|
392 the one directly before us, so it's OK. */
|
|
|
393 goto start_over;
|
|
|
394 #endif
|
|
|
395 }
|
|
|
396 }
|
|
|
397
|
|
647
|
398 /* You'd think it wouldn't be necessary to cast something to the type
|
|
|
399 it's already defined is, but if you're GCC, you apparently think
|
|
|
400 differently */
|
|
460
|
401 #define SYNTAX_START_STYLE(c1, c2) \
|
|
647
|
402 ((enum comment_style) \
|
|
460
|
403 (SYNTAX_CODES_MATCH_START_P (c1, c2, SYNTAX_COMMENT_STYLE_A) ? \
|
|
428
|
404 comment_style_a : \
|
|
460
|
405 SYNTAX_CODES_MATCH_START_P (c1, c2, SYNTAX_COMMENT_STYLE_B) ? \
|
|
428
|
406 comment_style_b : \
|
|
647
|
407 comment_style_none))
|
|
428
|
408
|
|
460
|
409 #define SYNTAX_END_STYLE(c1, c2) \
|
|
647
|
410 ((enum comment_style) \
|
|
|
411 (SYNTAX_CODES_MATCH_END_P (c1, c2, SYNTAX_COMMENT_STYLE_A) ? \
|
|
460
|
412 comment_style_a : \
|
|
|
413 SYNTAX_CODES_MATCH_END_P (c1, c2, SYNTAX_COMMENT_STYLE_B) ? \
|
|
|
414 comment_style_b : \
|
|
647
|
415 comment_style_none))
|
|
460
|
416
|
|
|
417 #define SINGLE_SYNTAX_STYLE(c) \
|
|
647
|
418 ((enum comment_style) \
|
|
|
419 (SYNTAX_CODE_MATCHES_1CHAR_P (c, SYNTAX_COMMENT_STYLE_A) ? \
|
|
428
|
420 comment_style_a : \
|
|
460
|
421 SYNTAX_CODE_MATCHES_1CHAR_P (c, SYNTAX_COMMENT_STYLE_B) ? \
|
|
428
|
422 comment_style_b : \
|
|
647
|
423 comment_style_none))
|
|
428
|
424
|
|
|
425 /* Set up context_cache for position PT in BUF. */
|
|
|
426
|
|
|
427 static void
|
|
665
|
428 find_context (struct buffer *buf, Charbpos pt)
|
|
428
|
429 {
|
|
|
430 /* This function can GC */
|
|
|
431 Emchar prev_c, c;
|
|
460
|
432 int prev_syncode, syncode;
|
|
665
|
433 Charbpos target = pt;
|
|
826
|
434 struct syntax_cache *scache;
|
|
|
435
|
|
428
|
436 setup_context_cache (buf, pt);
|
|
|
437 pt = context_cache.cur_point;
|
|
|
438
|
|
826
|
439 scache = setup_buffer_syntax_cache (buf, pt - 1, 1);
|
|
428
|
440 if (pt > BUF_BEGV (buf))
|
|
460
|
441 {
|
|
|
442 c = BUF_FETCH_CHAR (buf, pt - 1);
|
|
826
|
443 syncode = SYNTAX_CODE_FROM_CACHE (scache, c);
|
|
460
|
444 }
|
|
428
|
445 else
|
|
460
|
446 {
|
|
|
447 c = '\n'; /* to get bol_context_cache at point-min */
|
|
|
448 syncode = Swhitespace;
|
|
|
449 }
|
|
428
|
450
|
|
|
451 for (; pt < target; pt++, context_cache.cur_point = pt)
|
|
|
452 {
|
|
|
453 if (context_cache.needs_its_head_reexamined)
|
|
|
454 {
|
|
|
455 if (context_cache.depth == 0
|
|
|
456 && context_cache.context == context_none)
|
|
|
457 {
|
|
|
458 /* We've found an anchor spot.
|
|
|
459 Try to put the start of defun within 6000 chars of
|
|
|
460 the target, and the end of defun as close as possible.
|
|
|
461 6000 is also arbitrary but tries to strike a balance
|
|
|
462 between two conflicting pulls when dealing with a
|
|
|
463 file that has lots of stuff sitting outside of a top-
|
|
|
464 level form:
|
|
|
465
|
|
|
466 a) If you move past the start of defun, you will
|
|
|
467 have to recompute defun, which in this case
|
|
|
468 means that start of defun goes all the way back
|
|
|
469 to the beginning of the file; so you want
|
|
|
470 to set start of defun a ways back from the
|
|
|
471 current point.
|
|
|
472 b) If you move a line backwards but within start of
|
|
|
473 defun, you have to move back to start of defun;
|
|
|
474 so you don't want start of defun too far from
|
|
|
475 the current point.
|
|
|
476 */
|
|
|
477 if (target - context_cache.start_point > 6000)
|
|
|
478 context_cache.start_point = pt;
|
|
|
479 context_cache.end_point = pt;
|
|
|
480 bol_context_cache = context_cache;
|
|
|
481 }
|
|
|
482 }
|
|
|
483
|
|
826
|
484 UPDATE_SYNTAX_CACHE_FORWARD (scache, pt);
|
|
428
|
485 prev_c = c;
|
|
460
|
486 prev_syncode = syncode;
|
|
428
|
487 c = BUF_FETCH_CHAR (buf, pt);
|
|
826
|
488 syncode = SYNTAX_CODE_FROM_CACHE (scache, c);
|
|
428
|
489
|
|
|
490 if (prev_c == '\n')
|
|
|
491 bol_context_cache = context_cache;
|
|
|
492
|
|
|
493 if (context_cache.backslash_p)
|
|
|
494 {
|
|
|
495 context_cache.backslash_p = 0;
|
|
|
496 continue;
|
|
|
497 }
|
|
|
498
|
|
826
|
499 switch (SYNTAX_FROM_CODE (syncode))
|
|
428
|
500 {
|
|
|
501 case Sescape:
|
|
|
502 context_cache.backslash_p = 1;
|
|
|
503 break;
|
|
|
504
|
|
|
505 case Sopen:
|
|
|
506 if (context_cache.context == context_none)
|
|
|
507 context_cache.depth++;
|
|
|
508 break;
|
|
|
509
|
|
|
510 case Sclose:
|
|
|
511 if (context_cache.context == context_none)
|
|
|
512 context_cache.depth--;
|
|
|
513 break;
|
|
|
514
|
|
|
515 case Scomment:
|
|
|
516 if (context_cache.context == context_none)
|
|
|
517 {
|
|
|
518 context_cache.context = context_comment;
|
|
|
519 context_cache.ccontext = ccontext_none;
|
|
460
|
520 context_cache.style = SINGLE_SYNTAX_STYLE (syncode);
|
|
428
|
521 if (context_cache.style == comment_style_none) abort ();
|
|
|
522 }
|
|
|
523 break;
|
|
|
524
|
|
|
525 case Sendcomment:
|
|
460
|
526 if (context_cache.style != SINGLE_SYNTAX_STYLE (syncode))
|
|
428
|
527 ;
|
|
|
528 else if (context_cache.context == context_comment)
|
|
|
529 {
|
|
|
530 context_cache.context = context_none;
|
|
|
531 context_cache.style = comment_style_none;
|
|
|
532 }
|
|
|
533 else if (context_cache.context == context_block_comment &&
|
|
|
534 (context_cache.ccontext == ccontext_start2 ||
|
|
|
535 context_cache.ccontext == ccontext_end1))
|
|
|
536 {
|
|
|
537 context_cache.context = context_none;
|
|
|
538 context_cache.ccontext = ccontext_none;
|
|
|
539 context_cache.style = comment_style_none;
|
|
|
540 }
|
|
|
541 break;
|
|
|
542
|
|
|
543 case Sstring:
|
|
|
544 {
|
|
|
545 if (context_cache.context == context_string &&
|
|
|
546 context_cache.scontext == c)
|
|
|
547 {
|
|
|
548 context_cache.context = context_none;
|
|
|
549 context_cache.scontext = '\000';
|
|
|
550 }
|
|
|
551 else if (context_cache.context == context_none)
|
|
|
552 {
|
|
460
|
553 Lisp_Object stringtermobj =
|
|
826
|
554 syntax_match (scache->current_syntax_table, c);
|
|
428
|
555 Emchar stringterm;
|
|
|
556
|
|
|
557 if (CHARP (stringtermobj))
|
|
|
558 stringterm = XCHAR (stringtermobj);
|
|
|
559 else
|
|
|
560 stringterm = c;
|
|
|
561 context_cache.context = context_string;
|
|
|
562 context_cache.scontext = stringterm;
|
|
|
563 context_cache.ccontext = ccontext_none;
|
|
|
564 }
|
|
|
565 break;
|
|
|
566 }
|
|
460
|
567
|
|
|
568 case Scomment_fence:
|
|
|
569 {
|
|
|
570 if (context_cache.context == context_generic_comment)
|
|
|
571 {
|
|
|
572 context_cache.context = context_none;
|
|
|
573 }
|
|
|
574 else if (context_cache.context == context_none)
|
|
|
575 {
|
|
|
576 context_cache.context = context_generic_comment;
|
|
|
577 context_cache.ccontext = ccontext_none;
|
|
|
578 }
|
|
|
579 break;
|
|
|
580 }
|
|
|
581
|
|
|
582 case Sstring_fence:
|
|
|
583 {
|
|
|
584 if (context_cache.context == context_generic_string)
|
|
|
585 {
|
|
|
586 context_cache.context = context_none;
|
|
|
587 }
|
|
|
588 else if (context_cache.context == context_none)
|
|
|
589 {
|
|
|
590 context_cache.context = context_generic_string;
|
|
|
591 context_cache.ccontext = ccontext_none;
|
|
|
592 }
|
|
|
593 break;
|
|
|
594 }
|
|
|
595
|
|
428
|
596 default:
|
|
|
597 ;
|
|
|
598 }
|
|
|
599
|
|
|
600 /* That takes care of the characters with manifest syntax.
|
|
|
601 Now we've got to hack multi-char sequences that start
|
|
|
602 and end block comments.
|
|
|
603 */
|
|
460
|
604 if ((SYNTAX_CODE_COMMENT_BITS (syncode) &
|
|
428
|
605 SYNTAX_SECOND_CHAR_START) &&
|
|
|
606 context_cache.context == context_none &&
|
|
|
607 context_cache.ccontext == ccontext_start1 &&
|
|
460
|
608 SYNTAX_CODES_START_P (prev_syncode, syncode) /* the two chars match */
|
|
428
|
609 )
|
|
|
610 {
|
|
|
611 context_cache.ccontext = ccontext_start2;
|
|
460
|
612 context_cache.style = SYNTAX_START_STYLE (prev_syncode, syncode);
|
|
428
|
613 if (context_cache.style == comment_style_none) abort ();
|
|
|
614 }
|
|
460
|
615 else if ((SYNTAX_CODE_COMMENT_BITS (syncode) &
|
|
428
|
616 SYNTAX_FIRST_CHAR_START) &&
|
|
|
617 context_cache.context == context_none &&
|
|
|
618 (context_cache.ccontext == ccontext_none ||
|
|
|
619 context_cache.ccontext == ccontext_start1))
|
|
|
620 {
|
|
|
621 context_cache.ccontext = ccontext_start1;
|
|
|
622 context_cache.style = comment_style_none; /* should be this already*/
|
|
|
623 }
|
|
460
|
624 else if ((SYNTAX_CODE_COMMENT_BITS (syncode) &
|
|
428
|
625 SYNTAX_SECOND_CHAR_END) &&
|
|
647
|
626 context_cache.context ==
|
|
|
627 (enum syntactic_context) context_block_comment &&
|
|
|
628 context_cache.ccontext ==
|
|
|
629 (enum block_comment_context) ccontext_end1 &&
|
|
460
|
630 SYNTAX_CODES_END_P (prev_syncode, syncode) &&
|
|
428
|
631 /* the two chars match */
|
|
|
632 context_cache.style ==
|
|
460
|
633 SYNTAX_END_STYLE (prev_syncode, syncode)
|
|
428
|
634 )
|
|
|
635 {
|
|
|
636 context_cache.context = context_none;
|
|
|
637 context_cache.ccontext = ccontext_none;
|
|
|
638 context_cache.style = comment_style_none;
|
|
|
639 }
|
|
460
|
640 else if ((SYNTAX_CODE_COMMENT_BITS (syncode) &
|
|
428
|
641 SYNTAX_FIRST_CHAR_END) &&
|
|
|
642 context_cache.context == context_block_comment &&
|
|
460
|
643 context_cache.style == SINGLE_SYNTAX_STYLE (syncode) &&
|
|
428
|
644 (context_cache.ccontext == ccontext_start2 ||
|
|
|
645 context_cache.ccontext == ccontext_end1))
|
|
460
|
646 /* #### is it right to check for end1 here??
|
|
|
647 yes, because this might be a repetition of the first char
|
|
|
648 of a comment-end sequence. ie, '/xxx foo xxx/' or
|
|
|
649 '/xxx foo x/', where 'x' = '*' -- mct */
|
|
428
|
650 {
|
|
|
651 if (context_cache.style == comment_style_none) abort ();
|
|
|
652 context_cache.ccontext = ccontext_end1;
|
|
|
653 }
|
|
|
654
|
|
|
655 else if (context_cache.ccontext == ccontext_start1)
|
|
|
656 {
|
|
|
657 if (context_cache.context != context_none) abort ();
|
|
|
658 context_cache.ccontext = ccontext_none;
|
|
|
659 }
|
|
|
660 else if (context_cache.ccontext == ccontext_end1)
|
|
|
661 {
|
|
|
662 if (context_cache.context != context_block_comment) abort ();
|
|
|
663 context_cache.context = context_none;
|
|
|
664 context_cache.ccontext = ccontext_start2;
|
|
|
665 }
|
|
|
666
|
|
|
667 if (context_cache.ccontext == ccontext_start2 &&
|
|
|
668 context_cache.context == context_none)
|
|
|
669 {
|
|
|
670 context_cache.context = context_block_comment;
|
|
|
671 if (context_cache.style == comment_style_none) abort ();
|
|
|
672 }
|
|
|
673 else if (context_cache.ccontext == ccontext_none &&
|
|
|
674 context_cache.context == context_block_comment)
|
|
|
675 {
|
|
|
676 context_cache.context = context_none;
|
|
|
677 }
|
|
|
678 }
|
|
|
679
|
|
|
680 context_cache.needs_its_head_reexamined = 0;
|
|
|
681 }
|
|
|
682
|
|
|
683 static Lisp_Object
|
|
|
684 context_to_symbol (enum syntactic_context context)
|
|
|
685 {
|
|
|
686 switch (context)
|
|
|
687 {
|
|
460
|
688 case context_none: return Qnil;
|
|
|
689 case context_string: return Qstring;
|
|
|
690 case context_comment: return Qcomment;
|
|
|
691 case context_block_comment: return Qblock_comment;
|
|
|
692 case context_generic_comment: return Qblock_comment;
|
|
|
693 case context_generic_string: return Qstring;
|
|
428
|
694 default: abort (); return Qnil; /* suppress compiler warning */
|
|
|
695 }
|
|
|
696 }
|
|
|
697
|
|
|
698 DEFUN ("buffer-syntactic-context", Fbuffer_syntactic_context, 0, 1, 0, /*
|
|
|
699 Return the syntactic context of BUFFER at point.
|
|
|
700 If BUFFER is nil or omitted, the current buffer is assumed.
|
|
|
701 The returned value is one of the following symbols:
|
|
|
702
|
|
|
703 nil ; meaning no special interpretation
|
|
|
704 string ; meaning point is within a string
|
|
|
705 comment ; meaning point is within a line comment
|
|
|
706 block-comment ; meaning point is within a block comment
|
|
|
707
|
|
|
708 See also the function `buffer-syntactic-context-depth', which returns
|
|
|
709 the current nesting-depth within all parenthesis-syntax delimiters
|
|
|
710 and the function `syntactically-sectionize', which will map a function
|
|
|
711 over each syntactic context in a region.
|
|
|
712
|
|
|
713 WARNING: this may alter match-data.
|
|
|
714 */
|
|
|
715 (buffer))
|
|
|
716 {
|
|
|
717 /* This function can GC */
|
|
|
718 struct buffer *buf = decode_buffer (buffer, 0);
|
|
|
719 find_context (buf, BUF_PT (buf));
|
|
|
720 return context_to_symbol (context_cache.context);
|
|
|
721 }
|
|
|
722
|
|
|
723 DEFUN ("buffer-syntactic-context-depth", Fbuffer_syntactic_context_depth,
|
|
|
724 0, 1, 0, /*
|
|
|
725 Return the depth within all parenthesis-syntax delimiters at point.
|
|
|
726 If BUFFER is nil or omitted, the current buffer is assumed.
|
|
|
727 WARNING: this may alter match-data.
|
|
|
728 */
|
|
|
729 (buffer))
|
|
|
730 {
|
|
|
731 /* This function can GC */
|
|
|
732 struct buffer *buf = decode_buffer (buffer, 0);
|
|
|
733 find_context (buf, BUF_PT (buf));
|
|
|
734 return make_int (context_cache.depth);
|
|
|
735 }
|
|
|
736
|
|
|
737
|
|
|
738 DEFUN ("syntactically-sectionize", Fsyntactically_sectionize, 3, 4, 0, /*
|
|
|
739 Call FUNCTION for each contiguous syntactic context in the region.
|
|
|
740 Call the given function with four arguments: the start and end of the
|
|
|
741 region, a symbol representing the syntactic context, and the current
|
|
|
742 depth (as returned by the functions `buffer-syntactic-context' and
|
|
|
743 `buffer-syntactic-context-depth'). When this function is called, the
|
|
|
744 current buffer will be set to BUFFER.
|
|
|
745
|
|
|
746 WARNING: this may alter match-data.
|
|
|
747 */
|
|
|
748 (function, start, end, buffer))
|
|
|
749 {
|
|
|
750 /* This function can GC */
|
|
665
|
751 Charbpos s, pt, e;
|
|
428
|
752 int edepth;
|
|
|
753 enum syntactic_context this_context;
|
|
|
754 Lisp_Object extent = Qnil;
|
|
|
755 struct gcpro gcpro1;
|
|
|
756 struct buffer *buf = decode_buffer (buffer, 0);
|
|
|
757
|
|
|
758 get_buffer_range_char (buf, start, end, &s, &e, 0);
|
|
|
759
|
|
|
760 pt = s;
|
|
|
761 find_context (buf, pt);
|
|
|
762
|
|
|
763 GCPRO1 (extent);
|
|
|
764 while (pt < e)
|
|
|
765 {
|
|
665
|
766 Charbpos estart, eend;
|
|
428
|
767 /* skip over "blank" areas, and bug out at end-of-buffer. */
|
|
|
768 while (context_cache.context == context_none)
|
|
|
769 {
|
|
|
770 pt++;
|
|
|
771 if (pt >= e) goto DONE_LABEL;
|
|
|
772 find_context (buf, pt);
|
|
|
773 }
|
|
|
774 /* We've found a non-blank area; keep going until we reach its end */
|
|
|
775 this_context = context_cache.context;
|
|
|
776 estart = pt;
|
|
|
777
|
|
|
778 /* Minor kludge: consider the comment-start character(s) a part of
|
|
|
779 the comment.
|
|
|
780 */
|
|
|
781 if (this_context == context_block_comment &&
|
|
|
782 context_cache.ccontext == ccontext_start2)
|
|
|
783 estart -= 2;
|
|
460
|
784 else if (this_context == context_comment
|
|
|
785 || this_context == context_generic_comment
|
|
|
786 )
|
|
428
|
787 estart -= 1;
|
|
|
788
|
|
|
789 edepth = context_cache.depth;
|
|
|
790 while (context_cache.context == this_context && pt < e)
|
|
|
791 {
|
|
|
792 pt++;
|
|
|
793 find_context (buf, pt);
|
|
|
794 }
|
|
|
795
|
|
|
796 eend = pt;
|
|
|
797
|
|
|
798 /* Minor kludge: consider the character which terminated the comment
|
|
|
799 a part of the comment.
|
|
|
800 */
|
|
|
801 if ((this_context == context_block_comment ||
|
|
460
|
802 this_context == context_comment
|
|
|
803 || this_context == context_generic_comment
|
|
|
804 )
|
|
428
|
805 && pt < e)
|
|
|
806 eend++;
|
|
|
807
|
|
|
808 if (estart == eend)
|
|
|
809 continue;
|
|
|
810 /* Make sure not to pass in values that are outside the
|
|
|
811 actual bounds of this function. */
|
|
|
812 call4_in_buffer (buf, function, make_int (max (s, estart)),
|
|
|
813 make_int (eend == e ? e : eend - 1),
|
|
|
814 context_to_symbol (this_context),
|
|
|
815 make_int (edepth));
|
|
|
816 }
|
|
|
817 DONE_LABEL:
|
|
|
818 UNGCPRO;
|
|
|
819 return Qnil;
|
|
|
820 }
|
|
|
821
|
|
|
822 void
|
|
|
823 syms_of_font_lock (void)
|
|
|
824 {
|
|
563
|
825 DEFSYMBOL (Qcomment);
|
|
|
826 DEFSYMBOL (Qblock_comment);
|
|
|
827 DEFSYMBOL (Qbeginning_of_defun);
|
|
428
|
828
|
|
|
829 DEFSUBR (Fbuffer_syntactic_context);
|
|
|
830 DEFSUBR (Fbuffer_syntactic_context_depth);
|
|
|
831 DEFSUBR (Fsyntactically_sectionize);
|
|
|
832 }
|
|
|
833
|
|
|
834 void
|
|
|
835 reinit_vars_of_font_lock (void)
|
|
|
836 {
|
|
|
837 xzero (context_cache);
|
|
|
838 xzero (bol_context_cache);
|
|
|
839 }
|
|
|
840
|
|
|
841 void
|
|
|
842 vars_of_font_lock (void)
|
|
|
843 {
|
|
|
844 reinit_vars_of_font_lock ();
|
|
|
845 }
|
|
838
|
846
|
|
|
847 #endif /* USE_C_FONT_LOCK */
|
