Mercurial > hg > xemacs-beta
annotate src/syntax.c @ 5673:900a0a8796c3 r21-5-32
XEmacs 21.5.32 "habanero" is released.
| author | Stephen J. Turnbull <stephen@xemacs.org> |
|---|---|
| date | Fri, 03 Aug 2012 02:43:45 +0900 |
| parents | 56144c8593a8 |
| children |
| rev | line source |
|---|---|
| 428 | 1 /* XEmacs routines to deal with syntax tables; also word and list parsing. |
| 2 Copyright (C) 1985-1994 Free Software Foundation, Inc. | |
| 3 Copyright (C) 1995 Sun Microsystems, Inc. | |
|
5169
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
5127
diff
changeset
|
4 Copyright (C) 2001, 2002, 2003, 2010 Ben Wing. |
| 428 | 5 |
| 6 This file is part of XEmacs. | |
| 7 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5169
diff
changeset
|
8 XEmacs is free software: you can redistribute it and/or modify it |
| 428 | 9 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5169
diff
changeset
|
10 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5169
diff
changeset
|
11 option) any later version. |
| 428 | 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 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5169
diff
changeset
|
19 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 428 | 20 |
| 21 /* Synched up with: FSF 19.28. */ | |
| 22 | |
| 23 /* This file has been Mule-ized. */ | |
| 24 | |
| 25 #include <config.h> | |
| 26 #include "lisp.h" | |
| 27 | |
| 28 #include "buffer.h" | |
| 29 #include "syntax.h" | |
| 460 | 30 #include "extents.h" |
| 428 | 31 |
| 460 | 32 #define ST_COMMENT_STYLE 0x101 |
| 33 #define ST_STRING_STYLE 0x102 | |
| 34 | |
| 35 Lisp_Object Qsyntax_table; | |
| 36 int lookup_syntax_properties; | |
| 37 | |
| 428 | 38 Lisp_Object Qsyntax_table_p; |
| 39 | |
| 40 int words_include_escapes; | |
| 41 | |
| 42 int parse_sexp_ignore_comments; | |
| 43 | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
44 /* Tell the regex routines not to QUIT. Normally there is a QUIT each |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
45 iteration in re_search_2(). We do it this way rather than change |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
46 the arguments to re_search_2() in an attempt to maintain some call |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
47 compatibility with other versions of the regex code. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
48 #### Surely this is no longer a consideration. Last sync was 19.28! */ |
| 428 | 49 int no_quit_in_re_search; |
| 50 | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
51 /* The standard syntax table is automatically used in all new buffers. */ |
| 428 | 52 Lisp_Object Vstandard_syntax_table; |
| 53 | |
| 54 Lisp_Object Vsyntax_designator_chars_string; | |
| 55 | |
| 826 | 56 Lisp_Object Vtemp_table_for_use_updating_syntax_tables; |
| 57 | |
| 1296 | 58 /* A value that is guaranteed not be in a syntax table. */ |
| 59 Lisp_Object Vbogus_syntax_table_value; | |
| 60 | |
|
4912
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
61 Lisp_Object Qscan_error; |
|
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
62 |
| 826 | 63 static void syntax_cache_table_was_changed (struct buffer *buf); |
| 64 | |
| 428 | 65 /* This is the internal form of the parse state used in parse-partial-sexp. */ |
| 66 | |
| 67 struct lisp_parse_state | |
| 68 { | |
| 69 int depth; /* Depth at end of parsing */ | |
| 867 | 70 Ichar instring; /* -1 if not within string, else desired terminator */ |
| 428 | 71 int incomment; /* Nonzero if within a comment at end of parsing */ |
| 460 | 72 int comstyle; /* comment style a=0, or b=1, or ST_COMMENT_STYLE */ |
| 428 | 73 int quoted; /* Nonzero if just after an escape char at end of |
| 74 parsing */ | |
| 665 | 75 Charbpos thislevelstart;/* Char number of most recent start-of-expression |
| 428 | 76 at current level */ |
| 665 | 77 Charbpos prevlevelstart;/* Char number of start of containing expression */ |
| 78 Charbpos location; /* Char number at which parsing stopped */ | |
| 428 | 79 int mindepth; /* Minimum depth seen while scanning */ |
| 826 | 80 Charbpos comstr_start;/* Position just after last comment/string starter */ |
| 81 Lisp_Object levelstarts;/* Char numbers of starts-of-expression | |
| 82 of levels (starting from outermost). */ | |
| 428 | 83 }; |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
84 |
| 428 | 85 |
| 86 /* These variables are a cache for finding the start of a defun. | |
| 87 find_start_pos is the place for which the defun start was found. | |
| 88 find_start_value is the defun start position found for it. | |
| 89 find_start_buffer is the buffer it was found in. | |
| 90 find_start_begv is the BEGV value when it was found. | |
| 91 find_start_modiff is the value of MODIFF when it was found. */ | |
| 92 | |
| 665 | 93 static Charbpos find_start_pos; |
| 94 static Charbpos find_start_value; | |
| 428 | 95 static struct buffer *find_start_buffer; |
| 665 | 96 static Charbpos find_start_begv; |
| 428 | 97 static int find_start_modiff; |
| 98 | |
| 99 /* Find a defun-start that is the last one before POS (or nearly the last). | |
| 100 We record what we find, so that another call in the same area | |
| 101 can return the same value right away. */ | |
| 102 | |
| 665 | 103 static Charbpos |
| 104 find_defun_start (struct buffer *buf, Charbpos pos) | |
| 428 | 105 { |
| 665 | 106 Charbpos tem; |
| 826 | 107 struct syntax_cache *scache; |
| 108 | |
| 428 | 109 /* Use previous finding, if it's valid and applies to this inquiry. */ |
| 110 if (buf == find_start_buffer | |
| 111 /* Reuse the defun-start even if POS is a little farther on. | |
| 112 POS might be in the next defun, but that's ok. | |
| 113 Our value may not be the best possible, but will still be usable. */ | |
| 114 && pos <= find_start_pos + 1000 | |
| 115 && pos >= find_start_value | |
| 116 && BUF_BEGV (buf) == find_start_begv | |
| 117 && BUF_MODIFF (buf) == find_start_modiff) | |
| 118 return find_start_value; | |
| 119 | |
| 120 /* Back up to start of line. */ | |
| 121 tem = find_next_newline (buf, pos, -1); | |
| 122 | |
| 826 | 123 scache = setup_buffer_syntax_cache (buf, tem, 1); |
| 428 | 124 while (tem > BUF_BEGV (buf)) |
| 125 { | |
| 826 | 126 UPDATE_SYNTAX_CACHE_BACKWARD (scache, tem); |
| 460 | 127 |
| 428 | 128 /* Open-paren at start of line means we found our defun-start. */ |
| 826 | 129 if (SYNTAX_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, tem)) == Sopen) |
| 428 | 130 break; |
| 131 /* Move to beg of previous line. */ | |
| 132 tem = find_next_newline (buf, tem, -2); | |
| 133 } | |
| 134 | |
| 135 /* Record what we found, for the next try. */ | |
| 136 find_start_value = tem; | |
| 137 find_start_buffer = buf; | |
| 138 find_start_modiff = BUF_MODIFF (buf); | |
| 139 find_start_begv = BUF_BEGV (buf); | |
| 140 find_start_pos = pos; | |
| 141 | |
| 142 return find_start_value; | |
| 143 } | |
| 144 | |
| 145 DEFUN ("syntax-table-p", Fsyntax_table_p, 1, 1, 0, /* | |
| 444 | 146 Return t if OBJECT is a syntax table. |
| 428 | 147 */ |
| 444 | 148 (object)) |
| 428 | 149 { |
| 444 | 150 return (CHAR_TABLEP (object) |
| 151 && XCHAR_TABLE_TYPE (object) == CHAR_TABLE_TYPE_SYNTAX) | |
| 428 | 152 ? Qt : Qnil; |
| 153 } | |
| 154 | |
| 155 static Lisp_Object | |
| 156 check_syntax_table (Lisp_Object obj, Lisp_Object default_) | |
| 157 { | |
| 158 if (NILP (obj)) | |
| 159 obj = default_; | |
| 160 while (NILP (Fsyntax_table_p (obj))) | |
| 161 obj = wrong_type_argument (Qsyntax_table_p, obj); | |
| 162 return obj; | |
| 163 } | |
| 164 | |
| 165 DEFUN ("syntax-table", Fsyntax_table, 0, 1, 0, /* | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
166 Return the current syntax table of BUFFER. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
167 BUFFER defaults to the current buffer. |
| 428 | 168 */ |
| 169 (buffer)) | |
| 170 { | |
| 171 return decode_buffer (buffer, 0)->syntax_table; | |
| 172 } | |
| 173 | |
| 826 | 174 #ifdef DEBUG_XEMACS |
| 175 | |
| 176 DEFUN ("mirror-syntax-table", Fmirror_syntax_table, 0, 1, 0, /* | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
177 Return the current mirror syntax table of BUFFER. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
178 BUFFER defaults to the current buffer. Only useful in debugging internals. |
| 826 | 179 */ |
| 180 (buffer)) | |
| 181 { | |
| 182 return decode_buffer (buffer, 0)->mirror_syntax_table; | |
| 183 } | |
| 184 | |
| 185 DEFUN ("syntax-cache-info", Fsyntax_cache_info, 0, 1, 0, /* | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
186 Return a list (START END PREV_CHANGE NEXT_CHANGE) for BUFFER's syntax cache. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
187 BUFFER defaults to the current buffer. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
188 |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
189 The elements correspond to members of struct syntax_cache of the same names. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
190 START and END should be markers. PREV_CHANGE and NEXT_CHANGE are integers. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
191 Only useful in debugging internals. |
| 826 | 192 */ |
| 193 (buffer)) | |
| 194 { | |
| 195 struct buffer *buf = decode_buffer (buffer, 0); | |
| 196 struct syntax_cache *cache = buf->syntax_cache; | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
197 return list4 (cache->start, cache->end, make_fixnum (cache->prev_change), |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
198 make_fixnum (cache->next_change)); |
| 826 | 199 } |
| 200 | |
| 201 #endif /* DEBUG_XEMACS */ | |
| 202 | |
| 428 | 203 DEFUN ("standard-syntax-table", Fstandard_syntax_table, 0, 0, 0, /* |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
204 Return the standard syntax table, used for new buffers. |
| 428 | 205 */ |
| 206 ()) | |
| 207 { | |
| 208 return Vstandard_syntax_table; | |
| 209 } | |
| 210 | |
| 211 DEFUN ("copy-syntax-table", Fcopy_syntax_table, 0, 1, 0, /* | |
| 444 | 212 Return a new syntax table which is a copy of SYNTAX-TABLE. |
| 213 SYNTAX-TABLE defaults to the standard syntax table. | |
| 428 | 214 */ |
| 444 | 215 (syntax_table)) |
| 428 | 216 { |
| 217 if (NILP (Vstandard_syntax_table)) | |
| 218 return Fmake_char_table (Qsyntax); | |
| 219 | |
| 444 | 220 syntax_table = check_syntax_table (syntax_table, Vstandard_syntax_table); |
| 221 return Fcopy_char_table (syntax_table); | |
| 428 | 222 } |
| 223 | |
| 224 DEFUN ("set-syntax-table", Fset_syntax_table, 1, 2, 0, /* | |
| 444 | 225 Select SYNTAX-TABLE as the new syntax table for BUFFER. |
| 428 | 226 BUFFER defaults to the current buffer if omitted. |
| 227 */ | |
| 444 | 228 (syntax_table, buffer)) |
| 428 | 229 { |
| 230 struct buffer *buf = decode_buffer (buffer, 0); | |
| 444 | 231 syntax_table = check_syntax_table (syntax_table, Qnil); |
| 232 buf->syntax_table = syntax_table; | |
| 233 buf->mirror_syntax_table = XCHAR_TABLE (syntax_table)->mirror_table; | |
| 826 | 234 syntax_cache_table_was_changed (buf); |
| 428 | 235 /* Indicate that this buffer now has a specified syntax table. */ |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
236 buf->local_var_flags |= XFIXNUM (buffer_local_flags.syntax_table); |
| 444 | 237 return syntax_table; |
| 428 | 238 } |
| 3252 | 239 |
| 240 | |
| 428 | 241 |
| 3252 | 242 /* |
| 243 * Syntax caching | |
| 244 */ | |
| 245 | |
| 246 /* syntax_cache object implementation */ | |
| 247 | |
| 248 static const struct memory_description syntax_cache_description_1 [] = { | |
| 249 { XD_LISP_OBJECT, offsetof (struct syntax_cache, object) }, | |
| 250 { XD_LISP_OBJECT, offsetof (struct syntax_cache, buffer) }, | |
| 251 { XD_LISP_OBJECT, offsetof (struct syntax_cache, syntax_table) }, | |
| 252 { XD_LISP_OBJECT, offsetof (struct syntax_cache, mirror_table) }, | |
| 253 { XD_LISP_OBJECT, offsetof (struct syntax_cache, start) }, | |
| 254 { XD_LISP_OBJECT, offsetof (struct syntax_cache, end) }, | |
| 255 { XD_END } | |
| 256 }; | |
| 257 | |
| 258 #ifdef NEW_GC | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
259 DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT ("syntax-cache", syntax_cache, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
260 0, syntax_cache_description_1, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
261 Lisp_Syntax_Cache); |
| 3252 | 262 #else /* not NEW_GC */ |
| 263 | |
| 264 const struct sized_memory_description syntax_cache_description = { | |
| 265 sizeof (struct syntax_cache), | |
| 266 syntax_cache_description_1 | |
| 267 }; | |
| 268 #endif /* not NEW_GC */ | |
| 269 | |
| 270 /* static syntax cache utilities */ | |
| 271 | |
| 272 static void | |
| 273 syntax_cache_table_was_changed (struct buffer *buf) | |
| 274 { | |
| 275 struct syntax_cache *cache = buf->syntax_cache; | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
276 if (cache->source == syntax_source_buffer_table) |
| 3252 | 277 { |
| 278 cache->syntax_table = | |
| 279 BUFFER_SYNTAX_TABLE (buf); | |
| 280 cache->mirror_table = | |
| 281 BUFFER_MIRROR_SYNTAX_TABLE (buf); | |
| 282 } | |
| 283 } | |
| 284 | |
| 285 static void | |
|
5543
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
286 reset_syntax_cache_range (struct syntax_cache *cache, /* initialized cache */ |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
287 int valid_everywhere) /* non-zero if we can assume |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
288 syntax-table properties |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
289 never need be respected |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
290 in the life of the cache */ |
| 3252 | 291 { |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
292 if (BUFFERP (cache->object)) |
|
5543
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
293 { |
|
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
294 /* make known region zero-length and reset insertion behavior */ |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
295 Fset_marker (cache->start, make_fixnum (1), cache->object); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
296 Fset_marker (cache->end, make_fixnum (1), cache->object); |
|
5545
69de75c48efa
Alan Mackenzie's syntax cache bounds fix.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5544
diff
changeset
|
297 Fset_marker_insertion_type (cache->start, Qnil); |
|
69de75c48efa
Alan Mackenzie's syntax cache bounds fix.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5544
diff
changeset
|
298 Fset_marker_insertion_type (cache->end, Qt); |
|
5543
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
299 } |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
300 /* #### Should reset "cache->source" here? |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
301 If so, also reset tables. */ |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
302 if (valid_everywhere) |
|
5543
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
303 { |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
304 cache->prev_change = MOST_NEGATIVE_FIXNUM; |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
305 cache->next_change = MOST_POSITIVE_FIXNUM; |
|
5543
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
306 } |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
307 else /* valid nowhere */ |
|
5543
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
308 { |
|
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
309 cache->prev_change = -1; |
|
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
310 cache->next_change = -1; |
|
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
311 } |
| 3252 | 312 } |
| 826 | 313 |
| 314 static void | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
315 init_syntax_cache (struct syntax_cache *cache, /* xzero'ed memory */ |
|
5543
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
316 Lisp_Object object, /* string or buffer */ |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
317 struct buffer *buffer) /* buffer; if OBJECT is a |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
318 buffer, this is the same */ |
| 826 | 319 { |
| 320 cache->object = object; | |
| 321 cache->buffer = buffer; | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
322 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
323 cache->source = syntax_source_buffer_table; |
| 1296 | 324 cache->syntax_table = |
| 325 BUFFER_SYNTAX_TABLE (cache->buffer); | |
| 326 cache->mirror_table = | |
| 826 | 327 BUFFER_MIRROR_SYNTAX_TABLE (cache->buffer); |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
328 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
329 /* Qnil avoids GC'ing markers, which are useless for strings. */ |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
330 cache->start = BUFFERP (object) ? Fmake_marker () : Qnil; |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
331 cache->end = BUFFERP (object) ? Fmake_marker () : Qnil; |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
332 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
333 reset_syntax_cache_range (cache, 0); |
| 826 | 334 } |
| 335 | |
| 3252 | 336 /* external syntax cache API */ |
| 337 | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
338 /* At this time (hg rev 5551:dab422055bab) setup_syntax_cache() is called |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
339 directly once in setup_buffer_syntax_cache and twice in regex.c. The |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
340 calls in regex.c are obfuscated, so it's hard to tell, but it looks like |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
341 they can be called with OBJECT being a buffer. |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
342 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
343 "You are in a confusing maze of initializations, all alike." |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
344 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
345 reset_syntax_cache_range (3 uses in setup_syntax_cache, |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
346 signal_syntax_cache_extent_changed, and init_buffer_syntax_cache) |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
347 reinitializes: |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
348 1. if BUFFERP(OBJECT), marker positions to 1 (giving a null range) |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
349 2. if BUFFERP(OBJECT), marker movement type |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
350 3. cache range per VALID_EVERYWHERE |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
351 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
352 init_syntax_cache (2 uses in init_buffer_syntax_cache and |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
353 setup_syntax_cache) initializes: |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
354 1. source to syntax_source_buffer_table |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
355 2. syntax_table and mirror_syntax table to BUFFER's tables |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
356 3. marker members to BUFFERP(OBJECT) ? markers w/o position : Qnil |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
357 4. cache range with VALID_EVERYWHERE==0 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
358 5. object and buffer to corresponding arguments. |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
359 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
360 init_buffer_syntax_cache (1 use in buffer.c) initializes: |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
361 0. allocation of buffer's cache memory (done by allocator) |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
362 1. cache memory to zero (done by allocator) |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
363 2. cache to buffer's cache |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
364 3. cache members by init_syntax_cache with object==buffer==BUF. |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
365 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
366 setup_buffer_syntax_cache (1 call in font-lock.c, 1 use in search.c, |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
367 and 7 uses in this file) initializes: |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
368 0. buffer's syntax cache by calling setup_syntax_cache. |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
369 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
370 setup_buffer_syntax_cache and setup_syntax_cache are called by functions |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
371 that analyze text using character syntax. They are called repeatedly on |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
372 the same cache. init_syntax_cache and init_buffer_syntax_cache are |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
373 conceptually called once for each cache. reset_syntax_cache_range may |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
374 be called repeatedly on the same cache. The last three are for internal |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
375 use by the syntax setup code and buffer initialization. */ |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
376 |
| 3250 | 377 struct syntax_cache * /* return CACHE or the cache of OBJECT */ |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
378 setup_syntax_cache (struct syntax_cache *cache, /* may be NULL only if |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
379 OBJECT is a buffer */ |
| 3250 | 380 Lisp_Object object, /* the object (if any) cache |
| 381 is associated with */ | |
| 382 struct buffer *buffer, /* the buffer to use as source | |
| 383 of the syntax table */ | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
384 Charxpos from, /* initial position of cache */ |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
385 int count) /* direction? see code */ |
| 826 | 386 { |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
387 /* If OBJECT is a buffer, use its cache; else use CACHE and initialize it. |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
388 Invalidate the cache if the syntax-table property is being respected; |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
389 else make it valid for the whole object. */ |
| 826 | 390 if (BUFFERP (object)) |
| 3250 | 391 { |
| 392 cache = XBUFFER (object)->syntax_cache; | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
393 if (!lookup_syntax_properties) |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
394 reset_syntax_cache_range (cache, 1); |
| 3250 | 395 } |
| 396 else | |
| 826 | 397 { |
|
5543
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
398 xzero (*cache); |
|
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
399 init_syntax_cache (cache, object, buffer); |
| 826 | 400 } |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
401 |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
402 if (lookup_syntax_properties) |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
403 { |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
404 if (count <= 0) |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
405 { |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
406 --from; |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
407 from = buffer_or_string_clip_to_accessible_char (cache->object, |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
408 from); |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
409 } |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
410 /* If lookup_syntax_properties && BUFFERP (object), this |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
411 optimization may matter. */ |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
412 if (!(from >= cache->prev_change && from < cache->next_change)) |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
413 update_syntax_cache (cache, from, count); |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
414 } |
|
5543
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
415 |
| 1296 | 416 #ifdef NOT_WORTH_THE_EFFORT |
| 417 update_mirror_syntax_if_dirty (cache->mirror_table); | |
| 418 #endif /* NOT_WORTH_THE_EFFORT */ | |
| 826 | 419 return cache; |
| 420 } | |
| 421 | |
| 422 struct syntax_cache * | |
| 423 setup_buffer_syntax_cache (struct buffer *buffer, Charxpos from, int count) | |
| 424 { | |
| 425 return setup_syntax_cache (NULL, wrap_buffer (buffer), buffer, from, count); | |
| 426 } | |
| 427 | |
| 460 | 428 /* |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
429 Update syntax_cache CACHE to an appropriate setting for position CPOS. |
| 460 | 430 |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
431 The sign of COUNT gives the relative position of CPOS wrt the |
| 460 | 432 previously valid interval. (not currently used) |
| 433 | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
434 `syntax_cache.*_change' are the next and previous positions at which |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
435 syntax_code and c_s_t will need to be recalculated. |
| 460 | 436 |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
437 #### Currently this code uses `get-char-property', which will return |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
438 the "last smallest" extent at a given position. In cases where |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
439 overlapping extents are defined, this code will simply use whatever |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
440 is returned by get-char-property. */ |
| 460 | 441 |
| 442 void | |
| 2286 | 443 update_syntax_cache (struct syntax_cache *cache, Charxpos cpos, |
| 444 int UNUSED (count)) | |
| 460 | 445 { |
| 446 Lisp_Object tmp_table; | |
| 826 | 447 Bytexpos pos; |
| 448 Bytexpos lim; | |
| 449 Bytexpos next, prev; | |
| 450 int at_begin = 0, at_end = 0; | |
| 460 | 451 |
| 826 | 452 if (NILP (cache->object)) |
| 453 return; | |
| 454 | |
| 455 pos = buffer_or_string_charxpos_to_bytexpos (cache->object, cpos); | |
| 456 | |
| 457 tmp_table = get_char_property (pos, Qsyntax_table, cache->object, | |
| 458 EXTENT_AT_AFTER, 0); | |
| 2506 | 459 lim = next_previous_single_property_change (pos, Qsyntax_table, |
| 460 cache->object, -1, 1, 0); | |
| 826 | 461 if (lim < 0) |
| 460 | 462 { |
|
5545
69de75c48efa
Alan Mackenzie's syntax cache bounds fix.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5544
diff
changeset
|
463 next = buffer_or_string_accessible_end_byte (cache->object); |
| 826 | 464 at_begin = 1; |
| 460 | 465 } |
| 826 | 466 else |
| 467 next = lim; | |
| 460 | 468 |
|
5545
69de75c48efa
Alan Mackenzie's syntax cache bounds fix.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5544
diff
changeset
|
469 if (pos < buffer_or_string_accessible_end_byte (cache->object)) |
| 826 | 470 pos = next_bytexpos (cache->object, pos); |
| 2506 | 471 lim = next_previous_single_property_change (pos, Qsyntax_table, |
| 472 cache->object, -1, 0, 0); | |
| 826 | 473 if (lim < 0) |
| 460 | 474 { |
|
5545
69de75c48efa
Alan Mackenzie's syntax cache bounds fix.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5544
diff
changeset
|
475 prev = buffer_or_string_accessible_begin_byte (cache->object); |
| 826 | 476 at_end = 1; |
| 460 | 477 } |
| 478 else | |
| 826 | 479 prev = lim; |
| 460 | 480 |
| 826 | 481 cache->prev_change = |
| 482 buffer_or_string_bytexpos_to_charxpos (cache->object, prev); | |
| 483 cache->next_change = | |
| 484 buffer_or_string_bytexpos_to_charxpos (cache->object, next); | |
| 460 | 485 |
| 826 | 486 if (BUFFERP (cache->object)) |
| 487 { | |
| 488 /* If we are at the beginning or end of buffer, check to see if there's | |
| 489 a zero-length `syntax-table' extent there (highly unlikely); if not, | |
| 490 then we can safely make the end closed, so it will take in newly | |
| 491 inserted text. (If such an extent is inserted, we will be informed | |
| 3250 | 492 through signal_syntax_cache_extent_changed().) */ |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
493 Fset_marker (cache->start, make_fixnum (cache->prev_change), cache->object); |
| 826 | 494 Fset_marker_insertion_type |
| 495 (cache->start, | |
| 496 at_begin && NILP (extent_at (prev, cache->object, Qsyntax_table, | |
| 497 NULL, EXTENT_AT_AT, 0)) | |
| 498 ? Qnil : Qt); | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
499 Fset_marker (cache->end, make_fixnum (cache->next_change), cache->object); |
| 826 | 500 Fset_marker_insertion_type |
| 501 (cache->end, | |
| 502 at_end && NILP (extent_at (next, cache->object, Qsyntax_table, | |
| 503 NULL, EXTENT_AT_AT, 0)) | |
| 504 ? Qt : Qnil); | |
| 505 } | |
| 506 | |
| 507 if (!NILP (Fsyntax_table_p (tmp_table))) | |
| 508 { | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
509 cache->source = syntax_source_property_table; |
| 1296 | 510 cache->syntax_table = tmp_table; |
| 511 cache->mirror_table = XCHAR_TABLE (tmp_table)->mirror_table; | |
| 512 #ifdef NOT_WORTH_THE_EFFORT | |
| 513 update_mirror_syntax_if_dirty (cache->mirror_table); | |
| 514 #endif /* NOT_WORTH_THE_EFFORT */ | |
| 826 | 515 } |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
516 else if (CONSP (tmp_table) && FIXNUMP (XCAR (tmp_table))) |
| 826 | 517 { |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
518 cache->source = syntax_source_property_code; |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
519 cache->syntax_code = XFIXNUM (XCAR (tmp_table)); |
| 826 | 520 } |
| 521 else | |
| 522 { | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
523 cache->source = syntax_source_buffer_table; |
| 1296 | 524 cache->syntax_table = BUFFER_SYNTAX_TABLE (cache->buffer); |
| 525 cache->mirror_table = BUFFER_MIRROR_SYNTAX_TABLE (cache->buffer); | |
| 526 #ifdef NOT_WORTH_THE_EFFORT | |
| 527 update_mirror_syntax_if_dirty (cache->mirror_table); | |
| 528 #endif /* NOT_WORTH_THE_EFFORT */ | |
| 460 | 529 } |
| 530 } | |
| 3252 | 531 |
| 532 /* buffer-specific APIs used in buffer.c | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
533 #### Really unclean; the syntax cache should just be a LISP object. */ |
| 3252 | 534 |
| 535 void | |
| 536 mark_buffer_syntax_cache (struct buffer *buf) | |
| 537 { | |
| 538 struct syntax_cache *cache = buf->syntax_cache; | |
| 539 if (!cache) /* Vbuffer_defaults and such don't have caches */ | |
| 540 return; | |
| 541 mark_object (cache->object); | |
| 542 if (cache->buffer) | |
| 543 mark_object (wrap_buffer (cache->buffer)); | |
| 544 mark_object (cache->syntax_table); | |
| 545 mark_object (cache->mirror_table); | |
| 546 mark_object (cache->start); | |
| 547 mark_object (cache->end); | |
| 548 } | |
| 549 | |
| 550 void | |
| 551 init_buffer_syntax_cache (struct buffer *buf) | |
| 552 { | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
553 struct syntax_cache *cache; |
| 3252 | 554 #ifdef NEW_GC |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
555 cache = XSYNTAX_CACHE (ALLOC_NORMAL_LISP_OBJECT (syntax_cache)); |
| 3252 | 556 #else /* not NEW_GC */ |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
557 cache = xnew_and_zero (struct syntax_cache); |
| 3252 | 558 #endif /* not NEW_GC */ |
|
5543
fbe90e6f7a43
Initialize start and end properly (to new markers, not Qnil).
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5542
diff
changeset
|
559 |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
560 init_syntax_cache (cache, wrap_buffer (buf), buf); |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
561 buf->syntax_cache = cache; |
| 3252 | 562 } |
| 563 | |
| 564 /* finalize the syntax cache for BUF */ | |
| 565 | |
| 566 void | |
|
4710
3a87551bfeb5
Fixes for a number of minor warnings issued by gcc. See xemacs-patches message
Jerry James <james@xemacs.org>
parents:
4653
diff
changeset
|
567 uninit_buffer_syntax_cache (struct buffer *UNUSED_IF_NEW_GC (buf)) |
| 3252 | 568 { |
| 4141 | 569 #ifndef NEW_GC |
|
5169
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
5127
diff
changeset
|
570 if (buf->syntax_cache) |
|
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
5127
diff
changeset
|
571 { |
|
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
5127
diff
changeset
|
572 xfree (buf->syntax_cache); |
|
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
5127
diff
changeset
|
573 buf->syntax_cache = 0; |
|
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
5127
diff
changeset
|
574 } |
| 4141 | 575 #endif /* not NEW_GC */ |
| 3252 | 576 } |
| 577 | |
| 578 /* extent-specific APIs used in extents.c and insdel.c */ | |
| 579 | |
| 580 /* The syntax-table property on the range covered by EXTENT may be changing, | |
| 581 either because EXTENT has a syntax-table property and is being attached | |
| 582 or detached (this includes having its endpoints changed), or because | |
| 583 the value of EXTENT's syntax-table property is changing. */ | |
| 584 | |
| 585 void | |
| 586 signal_syntax_cache_extent_changed (EXTENT extent) | |
| 587 { | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
588 Lisp_Object object = Fextent_object (wrap_extent (extent)); |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
589 if (BUFFERP (object)) |
| 3252 | 590 { |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
591 struct syntax_cache *cache = XBUFFER (object)->syntax_cache; |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
592 Bytexpos extent_start = extent_endpoint_byte (extent, 0); |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
593 Bytexpos extent_end = extent_endpoint_byte (extent, 1); |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
594 Bytexpos cache_start = byte_marker_position (cache->start); |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
595 Bytexpos cache_end = byte_marker_position (cache->end); |
| 3252 | 596 /* If the extent is entirely before or entirely after the cache |
| 597 range, it doesn't overlap. Otherwise, invalidate the range. */ | |
|
5552
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
598 if (!(extent_end < cache_start || extent_start > cache_end)) |
|
85210c453a97
Fix performance regression in refactored syntax cache setup.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5545
diff
changeset
|
599 reset_syntax_cache_range (cache, 0); |
| 3252 | 600 } |
| 601 } | |
| 602 | |
| 603 /* Extents have been adjusted for insertion or deletion, so we need to | |
| 604 refetch the start and end position of the extent */ | |
| 605 void | |
| 606 signal_syntax_cache_extent_adjust (struct buffer *buf) | |
| 607 { | |
| 608 struct syntax_cache *cache = buf->syntax_cache; | |
| 609 /* If the cache was invalid before, leave it that way. We only want | |
| 610 to update the limits of validity when they were actually valid. */ | |
| 611 if (cache->prev_change < 0) | |
| 612 return; | |
| 613 cache->prev_change = marker_position (cache->start); | |
| 614 cache->next_change = marker_position (cache->end); | |
| 615 } | |
| 616 | |
| 617 | |
| 460 | 618 |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
619 /* Convert an ASCII character which represents a syntax class |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
620 into the corresponding syntax code. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
621 This is used by (search.c) skip_chars and (regex.c) regex_compile. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
622 regex_compile indexes with `c' of type int, but promises that it |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
623 is positive. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
624 #### skip_chars indexes with an Ichar, a signed type. Presumably |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
625 this is guaranteed non-negative. */ |
| 428 | 626 |
|
5542
dab422055bab
Correct array bound for syntax_code_spec.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5402
diff
changeset
|
627 const unsigned char syntax_spec_code[0200] = |
| 428 | 628 { 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, |
| 629 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
| 630 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
| 631 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
| 632 (char) Swhitespace, 0377, (char) Sstring, 0377, | |
| 633 (char) Smath, 0377, 0377, (char) Squote, | |
| 634 (char) Sopen, (char) Sclose, 0377, 0377, | |
| 635 0377, (char) Swhitespace, (char) Spunct, (char) Scharquote, | |
| 636 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
| 637 0377, 0377, 0377, 0377, | |
| 638 (char) Scomment, 0377, (char) Sendcomment, 0377, | |
| 639 (char) Sinherit, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */ | |
| 640 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
| 641 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword, | |
| 642 0377, 0377, 0377, 0377, (char) Sescape, 0377, 0377, (char) Ssymbol, | |
| 643 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */ | |
| 644 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, | |
| 645 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword, | |
| 460 | 646 0377, 0377, 0377, 0377, (char) Sstring_fence, 0377, 0377, 0377 |
| 428 | 647 }; |
| 648 | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
649 /* The inverse mapping for syntax_spec_code. */ |
| 460 | 650 const unsigned char syntax_code_spec[] = " .w_()'\"$\\/<>@!|"; |
| 428 | 651 |
| 652 DEFUN ("syntax-designator-chars", Fsyntax_designator_chars, 0, 0, 0, /* | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
653 Return the string of the recognized syntax designator chars. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
654 The chars are indexed by their internal syntax codes, starting at 0. |
| 428 | 655 */ |
| 656 ()) | |
| 657 { | |
| 658 return Vsyntax_designator_chars_string; | |
| 659 } | |
| 660 | |
| 661 DEFUN ("char-syntax", Fchar_syntax, 1, 2, 0, /* | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
662 Return the syntax code of CHARACTER, designated by a character. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
663 Optional SYNTAX-TABLE defaults to the current buffer's syntax table. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
664 See `modify-syntax-entry' for the designators of the defined syntax codes. |
| 428 | 665 */ |
| 444 | 666 (character, syntax_table)) |
| 428 | 667 { |
| 826 | 668 Lisp_Object mirrortab; |
| 428 | 669 |
| 444 | 670 if (NILP (character)) |
| 428 | 671 { |
| 444 | 672 character = make_char ('\000'); |
| 428 | 673 } |
| 444 | 674 CHECK_CHAR_COERCE_INT (character); |
| 826 | 675 syntax_table = check_syntax_table (syntax_table, |
| 676 current_buffer->syntax_table); | |
| 677 mirrortab = XCHAR_TABLE (syntax_table)->mirror_table; | |
| 678 return make_char (syntax_code_spec[(int) SYNTAX (mirrortab, | |
| 679 XCHAR (character))]); | |
| 428 | 680 } |
| 681 | |
| 682 #ifdef MULE | |
| 683 | |
| 684 enum syntaxcode | |
| 2286 | 685 charset_syntax (struct buffer *UNUSED (buf), Lisp_Object UNUSED (charset), |
| 686 int *multi_p_out) | |
| 428 | 687 { |
| 688 *multi_p_out = 1; | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
689 /* !!#### get this right |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
690 Maybe not worth it until we have Unicode inside. */ |
| 3152 | 691 return Sword; |
| 428 | 692 } |
| 693 | |
| 694 #endif | |
| 695 | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
696 /* #### Outside of this file, only used once, in font-lock.c. Make static? |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
697 If so, remove prototype from syntax.h. */ |
| 428 | 698 Lisp_Object |
| 867 | 699 syntax_match (Lisp_Object syntax_table, Ichar ch) |
| 428 | 700 { |
| 826 | 701 Lisp_Object code = get_char_table (ch, syntax_table); |
| 428 | 702 Lisp_Object code2 = code; |
| 703 | |
| 704 if (CONSP (code)) | |
| 705 code2 = XCAR (code); | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
706 if (SYNTAX_FROM_CODE (XFIXNUM (code2)) == Sinherit) |
| 826 | 707 code = get_char_table (ch, Vstandard_syntax_table); |
| 428 | 708 |
| 709 return CONSP (code) ? XCDR (code) : Qnil; | |
| 710 } | |
| 711 | |
| 712 DEFUN ("matching-paren", Fmatching_paren, 1, 2, 0, /* | |
| 444 | 713 Return the matching parenthesis of CHARACTER, or nil if none. |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
714 Optional SYNTAX-TABLE defaults to the current buffer's syntax table. |
| 428 | 715 */ |
| 444 | 716 (character, syntax_table)) |
| 428 | 717 { |
| 826 | 718 Lisp_Object mirrortab; |
| 1315 | 719 enum syntaxcode code; |
| 428 | 720 |
| 444 | 721 CHECK_CHAR_COERCE_INT (character); |
| 826 | 722 syntax_table = check_syntax_table (syntax_table, |
| 723 current_buffer->syntax_table); | |
| 724 mirrortab = XCHAR_TABLE (syntax_table)->mirror_table; | |
| 444 | 725 code = SYNTAX (mirrortab, XCHAR (character)); |
| 428 | 726 if (code == Sopen || code == Sclose || code == Sstring) |
| 444 | 727 return syntax_match (syntax_table, XCHAR (character)); |
| 428 | 728 return Qnil; |
| 729 } | |
| 730 | |
| 731 | |
| 732 | |
| 733 #ifdef MULE | |
| 734 /* Return 1 if there is a word boundary between two word-constituent | |
| 735 characters C1 and C2 if they appear in this order, else return 0. | |
| 736 There is no word boundary between two word-constituent ASCII | |
| 737 characters. */ | |
| 738 #define WORD_BOUNDARY_P(c1, c2) \ | |
| 867 | 739 (!(ichar_ascii_p (c1) && ichar_ascii_p (c2)) \ |
| 428 | 740 && word_boundary_p (c1, c2)) |
| 741 #endif | |
| 742 | |
| 743 /* Return the position across COUNT words from FROM. | |
| 744 If that many words cannot be found before the end of the buffer, return 0. | |
| 745 COUNT negative means scan backward and stop at word beginning. */ | |
| 746 | |
| 665 | 747 Charbpos |
| 748 scan_words (struct buffer *buf, Charbpos from, int count) | |
| 428 | 749 { |
| 665 | 750 Charbpos limit = count > 0 ? BUF_ZV (buf) : BUF_BEGV (buf); |
| 867 | 751 Ichar ch0, ch1; |
| 428 | 752 enum syntaxcode code; |
| 826 | 753 struct syntax_cache *scache = setup_buffer_syntax_cache (buf, from, count); |
| 460 | 754 |
| 428 | 755 /* #### is it really worth it to hand expand both cases? JV */ |
| 756 while (count > 0) | |
| 757 { | |
| 758 QUIT; | |
| 759 | |
| 760 while (1) | |
| 761 { | |
| 762 if (from == limit) | |
| 763 return 0; | |
| 764 | |
| 826 | 765 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 428 | 766 ch0 = BUF_FETCH_CHAR (buf, from); |
| 826 | 767 code = SYNTAX_FROM_CACHE (scache, ch0); |
| 428 | 768 |
| 442 | 769 from++; |
| 428 | 770 if (words_include_escapes |
| 771 && (code == Sescape || code == Scharquote)) | |
| 772 break; | |
| 773 if (code == Sword) | |
| 774 break; | |
| 775 } | |
| 776 | |
| 777 QUIT; | |
| 778 | |
| 779 while (from != limit) | |
| 780 { | |
| 826 | 781 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 428 | 782 ch1 = BUF_FETCH_CHAR (buf, from); |
| 826 | 783 code = SYNTAX_FROM_CACHE (scache, ch1); |
| 428 | 784 if (!(words_include_escapes |
| 785 && (code == Sescape || code == Scharquote))) | |
| 786 if (code != Sword | |
| 787 #ifdef MULE | |
| 788 || WORD_BOUNDARY_P (ch0, ch1) | |
| 434 | 789 #endif |
| 428 | 790 ) |
| 791 break; | |
| 792 #ifdef MULE | |
| 793 ch0 = ch1; | |
| 434 | 794 #endif |
| 428 | 795 from++; |
| 796 } | |
| 797 count--; | |
| 798 } | |
| 799 | |
| 800 while (count < 0) | |
| 801 { | |
| 802 QUIT; | |
| 803 | |
| 804 while (1) | |
| 805 { | |
| 806 if (from == limit) | |
| 807 return 0; | |
| 808 | |
| 826 | 809 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from - 1); |
| 428 | 810 ch1 = BUF_FETCH_CHAR (buf, from - 1); |
| 826 | 811 code = SYNTAX_FROM_CACHE (scache, ch1); |
| 460 | 812 from--; |
| 442 | 813 |
| 428 | 814 if (words_include_escapes |
| 815 && (code == Sescape || code == Scharquote)) | |
| 816 break; | |
| 817 if (code == Sword) | |
| 818 break; | |
| 819 } | |
| 820 | |
| 821 QUIT; | |
| 822 | |
| 823 while (from != limit) | |
| 824 { | |
| 826 | 825 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from - 1); |
| 428 | 826 ch0 = BUF_FETCH_CHAR (buf, from - 1); |
| 826 | 827 code = SYNTAX_FROM_CACHE (scache, ch0); |
| 460 | 828 |
| 428 | 829 if (!(words_include_escapes |
| 830 && (code == Sescape || code == Scharquote))) | |
| 831 if (code != Sword | |
| 832 #ifdef MULE | |
| 833 || WORD_BOUNDARY_P (ch0, ch1) | |
| 834 #endif | |
| 835 ) | |
| 836 break; | |
| 837 #ifdef MULE | |
| 838 ch1 = ch0; | |
| 839 #endif | |
| 840 from--; | |
| 841 } | |
| 842 count++; | |
| 843 } | |
| 844 | |
| 845 return from; | |
| 846 } | |
| 847 | |
| 446 | 848 DEFUN ("forward-word", Fforward_word, 0, 2, "_p", /* |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
849 Move point forward COUNT words in BUFFER (backward if COUNT is negative). |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
850 COUNT defaults to 1, and BUFFER defaults to the current buffer. |
| 428 | 851 |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
852 Return t if the motion successfully crosses COUNT words, otherwise nil (if |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
853 the motion would cross the buffer boundary). |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
854 |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
855 The characters that are moved over are added to the region if the region |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
856 is active, the Shift key is held down, a motion key is used to invoke this |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
857 command, and `shifted-motion-keys-select-region' is non-nil; see |
| 462 | 858 the documentation for this variable for more details. |
| 428 | 859 */ |
| 860 (count, buffer)) | |
| 861 { | |
| 665 | 862 Charbpos val; |
| 428 | 863 struct buffer *buf = decode_buffer (buffer, 0); |
| 446 | 864 EMACS_INT n; |
| 865 | |
| 866 if (NILP (count)) | |
| 867 n = 1; | |
| 868 else | |
| 869 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
870 CHECK_FIXNUM (count); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
871 n = XFIXNUM (count); |
| 446 | 872 } |
| 428 | 873 |
| 446 | 874 val = scan_words (buf, BUF_PT (buf), n); |
| 875 if (val) | |
| 428 | 876 { |
| 446 | 877 BUF_SET_PT (buf, val); |
| 878 return Qt; | |
| 879 } | |
| 880 else | |
| 881 { | |
| 882 BUF_SET_PT (buf, n > 0 ? BUF_ZV (buf) : BUF_BEGV (buf)); | |
| 428 | 883 return Qnil; |
| 884 } | |
| 885 } | |
| 886 | |
| 887 static void scan_sexps_forward (struct buffer *buf, | |
| 888 struct lisp_parse_state *, | |
| 665 | 889 Charbpos from, Charbpos end, |
| 428 | 890 int targetdepth, int stopbefore, |
| 891 Lisp_Object oldstate, | |
| 892 int commentstop); | |
| 893 | |
| 894 static int | |
| 665 | 895 find_start_of_comment (struct buffer *buf, Charbpos from, Charbpos stop, |
| 460 | 896 int comstyle) |
| 428 | 897 { |
| 867 | 898 Ichar c; |
| 428 | 899 enum syntaxcode code; |
| 900 | |
| 901 /* Look back, counting the parity of string-quotes, | |
| 902 and recording the comment-starters seen. | |
| 903 When we reach a safe place, assume that's not in a string; | |
| 904 then step the main scan to the earliest comment-starter seen | |
| 905 an even number of string quotes away from the safe place. | |
| 906 | |
| 907 OFROM[I] is position of the earliest comment-starter seen | |
| 908 which is I+2X quotes from the comment-end. | |
| 909 PARITY is current parity of quotes from the comment end. */ | |
| 910 int parity = 0; | |
| 867 | 911 Ichar my_stringend = 0; |
| 428 | 912 int string_lossage = 0; |
| 665 | 913 Charbpos comment_end = from; |
| 914 Charbpos comstart_pos = 0; | |
| 428 | 915 int comstart_parity = 0; |
| 916 int styles_match_p = 0; | |
| 460 | 917 /* mask to match comment styles against; for ST_COMMENT_STYLE, this |
| 918 will get set to SYNTAX_COMMENT_STYLE_B, but never get checked */ | |
| 919 int mask = comstyle ? SYNTAX_COMMENT_STYLE_B : SYNTAX_COMMENT_STYLE_A; | |
| 826 | 920 struct syntax_cache *scache = buf->syntax_cache; |
| 428 | 921 |
| 922 /* At beginning of range to scan, we're outside of strings; | |
| 923 that determines quote parity to the comment-end. */ | |
| 924 while (from != stop) | |
| 925 { | |
| 460 | 926 int syncode; |
| 927 | |
| 428 | 928 /* Move back and examine a character. */ |
| 929 from--; | |
| 826 | 930 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from); |
| 428 | 931 |
| 932 c = BUF_FETCH_CHAR (buf, from); | |
| 826 | 933 syncode = SYNTAX_CODE_FROM_CACHE (scache, c); |
| 934 code = SYNTAX_FROM_CODE (syncode); | |
| 428 | 935 |
| 936 /* is this a 1-char comment end sequence? if so, try | |
| 937 to see if style matches previously extracted mask */ | |
| 938 if (code == Sendcomment) | |
| 939 { | |
| 940 styles_match_p = | |
| 460 | 941 SYNTAX_CODE_COMMENT_1CHAR_MASK (syncode) & mask; |
| 428 | 942 } |
| 943 | |
| 944 /* or are we looking at a 1-char comment start sequence | |
| 945 of the style matching mask? */ | |
| 460 | 946 else if (code == Scomment) |
| 428 | 947 { |
| 460 | 948 styles_match_p = |
| 949 SYNTAX_CODE_COMMENT_1CHAR_MASK (syncode) & mask; | |
| 428 | 950 } |
| 951 | |
| 460 | 952 /* otherwise, is this a 2-char comment end or start sequence? */ |
| 953 else if (from > stop) | |
| 954 do | |
| 955 { | |
| 956 /* 2-char comment end sequence? */ | |
| 957 if (SYNTAX_CODE_END_SECOND_P (syncode)) | |
| 958 { | |
| 959 int prev_syncode; | |
| 826 | 960 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from - 1); |
| 460 | 961 prev_syncode = |
| 1315 | 962 SYNTAX_CODE_FROM_CACHE (scache, |
| 963 BUF_FETCH_CHAR (buf, from - 1)); | |
| 460 | 964 |
| 965 if (SYNTAX_CODES_END_P (prev_syncode, syncode)) | |
| 966 { | |
| 967 code = Sendcomment; | |
| 968 styles_match_p = | |
| 826 | 969 SYNTAX_CODES_COMMENT_MASK_END (prev_syncode, |
| 970 syncode) & mask; | |
| 460 | 971 from--; |
| 826 | 972 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from); |
| 460 | 973 c = BUF_FETCH_CHAR (buf, from); |
| 974 | |
| 975 /* Found a comment-end sequence, so skip past the | |
| 976 check for a comment-start */ | |
| 977 break; | |
| 978 } | |
| 979 } | |
| 980 | |
| 981 /* 2-char comment start sequence? */ | |
| 982 if (SYNTAX_CODE_START_SECOND_P (syncode)) | |
| 983 { | |
| 984 int prev_syncode; | |
| 826 | 985 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from - 1); |
| 460 | 986 prev_syncode = |
| 1315 | 987 SYNTAX_CODE_FROM_CACHE (scache, |
| 988 BUF_FETCH_CHAR (buf, from - 1)); | |
| 460 | 989 |
| 990 if (SYNTAX_CODES_START_P (prev_syncode, syncode)) | |
| 991 { | |
| 992 code = Scomment; | |
| 993 styles_match_p = | |
| 826 | 994 SYNTAX_CODES_COMMENT_MASK_START (prev_syncode, |
| 995 syncode) & mask; | |
| 460 | 996 from--; |
| 826 | 997 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from); |
| 460 | 998 c = BUF_FETCH_CHAR (buf, from); |
| 999 } | |
| 1000 } | |
| 1001 } while (0); | |
| 428 | 1002 |
| 1003 /* Ignore escaped characters. */ | |
| 1004 if (char_quoted (buf, from)) | |
| 1005 continue; | |
| 1006 | |
| 1007 /* Track parity of quotes. */ | |
| 1008 if (code == Sstring) | |
| 1009 { | |
| 1010 parity ^= 1; | |
| 1011 if (my_stringend == 0) | |
| 1012 my_stringend = c; | |
| 1013 /* If we have two kinds of string delimiters. | |
| 1014 There's no way to grok this scanning backwards. */ | |
| 1015 else if (my_stringend != c) | |
| 1016 string_lossage = 1; | |
| 1017 } | |
| 1018 | |
| 460 | 1019 if (code == Sstring_fence || code == Scomment_fence) |
| 1020 { | |
| 1021 parity ^= 1; | |
| 1022 if (my_stringend == 0) | |
| 1023 my_stringend = | |
| 1024 code == Sstring_fence ? ST_STRING_STYLE : ST_COMMENT_STYLE; | |
| 1025 /* If we have two kinds of string delimiters. | |
| 1026 There's no way to grok this scanning backwards. */ | |
| 1027 else if (my_stringend != (code == Sstring_fence | |
| 1028 ? ST_STRING_STYLE : ST_COMMENT_STYLE)) | |
| 1029 string_lossage = 1; | |
| 1030 } | |
| 1031 | |
| 428 | 1032 /* Record comment-starters according to that |
| 1033 quote-parity to the comment-end. */ | |
| 1034 if (code == Scomment && styles_match_p) | |
| 1035 { | |
| 1036 comstart_parity = parity; | |
| 1037 comstart_pos = from; | |
| 1038 } | |
| 1039 | |
| 1040 /* If we find another earlier comment-ender, | |
| 1041 any comment-starts earlier than that don't count | |
| 1042 (because they go with the earlier comment-ender). */ | |
| 1043 if (code == Sendcomment && styles_match_p) | |
| 1044 break; | |
| 1045 | |
| 1046 /* Assume a defun-start point is outside of strings. */ | |
| 1047 if (code == Sopen | |
| 1048 && (from == stop || BUF_FETCH_CHAR (buf, from - 1) == '\n')) | |
| 1049 break; | |
| 1050 } | |
| 1051 | |
| 1052 if (comstart_pos == 0) | |
| 1053 from = comment_end; | |
| 1054 /* If the earliest comment starter | |
| 1055 is followed by uniform paired string quotes or none, | |
| 1056 we know it can't be inside a string | |
| 1057 since if it were then the comment ender would be inside one. | |
| 1058 So it does start a comment. Skip back to it. */ | |
| 1059 else if (comstart_parity == 0 && !string_lossage) | |
| 1060 from = comstart_pos; | |
| 1061 else | |
| 1062 { | |
| 1063 /* We had two kinds of string delimiters mixed up | |
| 1064 together. Decode this going forwards. | |
| 1065 Scan fwd from the previous comment ender | |
| 1066 to the one in question; this records where we | |
| 1067 last passed a comment starter. */ | |
| 1068 | |
| 1069 struct lisp_parse_state state; | |
| 1070 scan_sexps_forward (buf, &state, find_defun_start (buf, comment_end), | |
| 1071 comment_end - 1, -10000, 0, Qnil, 0); | |
| 1072 if (state.incomment) | |
| 460 | 1073 from = state.comstr_start; |
| 428 | 1074 else |
| 1075 /* We can't grok this as a comment; scan it normally. */ | |
| 1076 from = comment_end; | |
| 826 | 1077 UPDATE_SYNTAX_CACHE_FORWARD (scache, from - 1); |
| 428 | 1078 } |
| 1079 return from; | |
| 1080 } | |
| 1081 | |
| 665 | 1082 static Charbpos |
| 826 | 1083 find_end_of_comment (struct buffer *buf, Charbpos from, Charbpos stop, |
| 1084 int comstyle) | |
| 428 | 1085 { |
| 1086 int c; | |
| 460 | 1087 int prev_code; |
| 1088 /* mask to match comment styles against; for ST_COMMENT_STYLE, this | |
| 1089 will get set to SYNTAX_COMMENT_STYLE_B, but never get checked */ | |
| 1090 int mask = comstyle ? SYNTAX_COMMENT_STYLE_B : SYNTAX_COMMENT_STYLE_A; | |
| 826 | 1091 struct syntax_cache *scache = buf->syntax_cache; |
| 428 | 1092 |
| 460 | 1093 /* This is only called by functions which have already set up the |
| 1094 syntax_cache and are keeping it up-to-date */ | |
| 428 | 1095 while (1) |
| 1096 { | |
| 1097 if (from == stop) | |
| 1098 { | |
| 1099 return -1; | |
| 1100 } | |
| 460 | 1101 |
| 826 | 1102 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 428 | 1103 c = BUF_FETCH_CHAR (buf, from); |
| 460 | 1104 |
| 1105 /* Test for generic comments */ | |
| 1106 if (comstyle == ST_COMMENT_STYLE) | |
| 1107 { | |
| 826 | 1108 if (SYNTAX_FROM_CACHE (scache, c) == Scomment_fence) |
| 460 | 1109 { |
| 1110 from++; | |
| 826 | 1111 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 460 | 1112 break; |
| 1113 } | |
| 1114 from++; | |
| 1115 continue; /* No need to test other comment styles in a | |
| 1116 generic comment */ | |
| 1117 } | |
| 1118 else | |
| 1119 | |
| 826 | 1120 if (SYNTAX_FROM_CACHE (scache, c) == Sendcomment |
| 460 | 1121 && SYNTAX_CODE_MATCHES_1CHAR_P |
| 826 | 1122 (SYNTAX_CODE_FROM_CACHE (scache, c), mask)) |
| 428 | 1123 /* we have encountered a comment end of the same style |
| 1124 as the comment sequence which began this comment | |
| 1125 section */ | |
| 460 | 1126 { |
| 1127 from++; | |
| 826 | 1128 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 460 | 1129 break; |
| 1130 } | |
| 428 | 1131 |
| 826 | 1132 prev_code = SYNTAX_CODE_FROM_CACHE (scache, c); |
| 428 | 1133 from++; |
| 826 | 1134 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 428 | 1135 if (from < stop |
| 460 | 1136 && SYNTAX_CODES_MATCH_END_P |
| 1137 (prev_code, | |
| 826 | 1138 SYNTAX_CODE_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, from)), |
| 460 | 1139 mask) |
| 1140 | |
| 1141 ) | |
| 428 | 1142 /* we have encountered a comment end of the same style |
| 1143 as the comment sequence which began this comment | |
| 1144 section */ | |
| 460 | 1145 { |
| 1146 from++; | |
| 826 | 1147 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 460 | 1148 break; |
| 1149 } | |
| 428 | 1150 } |
| 1151 return from; | |
| 1152 } | |
| 1153 | |
| 1154 | |
| 1155 /* #### between FSF 19.23 and 19.28 there are some changes to the logic | |
| 1156 in this function (and minor changes to find_start_of_comment(), | |
| 1157 above, which is part of Fforward_comment() in FSF). Attempts to port | |
| 1158 that logic made this function break, so I'm leaving it out. If anyone | |
| 1159 ever complains about this function not working properly, take a look | |
| 1160 at those changes. --ben */ | |
| 1161 | |
| 446 | 1162 DEFUN ("forward-comment", Fforward_comment, 0, 2, 0, /* |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1163 Move forward across COUNT comments in BUFFER (backwards if COUNT is negative). |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1164 COUNT defaults to 1, and BUFFER defaults to the current buffer. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1165 |
| 428 | 1166 Stop scanning if we find something other than a comment or whitespace. |
| 1167 Set point to where scanning stops. | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1168 Return t if the motion successfully crosses COUNT comments, otherwise nil (if |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1169 the motion would cross the buffer boundary or encounters a noncomment token). |
| 428 | 1170 */ |
| 444 | 1171 (count, buffer)) |
| 428 | 1172 { |
| 665 | 1173 Charbpos from; |
| 1174 Charbpos stop; | |
| 867 | 1175 Ichar c; |
| 428 | 1176 enum syntaxcode code; |
| 460 | 1177 int syncode; |
| 444 | 1178 EMACS_INT n; |
| 428 | 1179 struct buffer *buf = decode_buffer (buffer, 0); |
| 826 | 1180 struct syntax_cache *scache; |
| 1181 | |
| 446 | 1182 if (NILP (count)) |
| 1183 n = 1; | |
| 1184 else | |
| 1185 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1186 CHECK_FIXNUM (count); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1187 n = XFIXNUM (count); |
| 446 | 1188 } |
| 428 | 1189 |
| 1190 from = BUF_PT (buf); | |
| 1191 | |
| 826 | 1192 scache = setup_buffer_syntax_cache (buf, from, n); |
| 444 | 1193 while (n > 0) |
| 428 | 1194 { |
| 1195 QUIT; | |
| 1196 | |
| 1197 stop = BUF_ZV (buf); | |
| 1198 while (from < stop) | |
| 1199 { | |
| 460 | 1200 int comstyle = 0; /* mask for finding matching comment style */ |
| 428 | 1201 |
| 1202 if (char_quoted (buf, from)) | |
| 1203 { | |
| 1204 from++; | |
| 1205 continue; | |
| 1206 } | |
| 1207 | |
| 826 | 1208 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 428 | 1209 c = BUF_FETCH_CHAR (buf, from); |
| 826 | 1210 syncode = SYNTAX_CODE_FROM_CACHE (scache, c); |
| 1211 code = SYNTAX_FROM_CODE (syncode); | |
| 428 | 1212 |
| 1213 if (code == Scomment) | |
| 1214 { | |
| 1215 /* we have encountered a single character comment start | |
| 1216 sequence, and we are ignoring all text inside comments. | |
| 1217 we must record the comment style this character begins | |
| 1218 so that later, only a comment end of the same style actually | |
| 1219 ends the comment section */ | |
| 460 | 1220 comstyle = SYNTAX_CODE_COMMENT_1CHAR_MASK (syncode) |
| 1221 == SYNTAX_COMMENT_STYLE_A ? 0 : 1; | |
| 428 | 1222 } |
| 1223 | |
| 460 | 1224 else if (code == Scomment_fence) |
| 1225 { | |
| 1226 from++; | |
| 1227 code = Scomment; | |
| 1228 comstyle = ST_COMMENT_STYLE; | |
| 1229 } | |
| 1230 | |
| 428 | 1231 else if (from < stop |
| 460 | 1232 && SYNTAX_CODE_START_FIRST_P (syncode)) |
| 428 | 1233 { |
| 460 | 1234 int next_syncode; |
| 826 | 1235 UPDATE_SYNTAX_CACHE_FORWARD (scache, from + 1); |
| 460 | 1236 next_syncode = |
| 826 | 1237 SYNTAX_CODE_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, from + 1)); |
| 460 | 1238 |
| 1239 if (SYNTAX_CODES_START_P (syncode, next_syncode)) | |
| 1240 { | |
| 1241 /* we have encountered a 2char comment start sequence and we | |
| 1242 are ignoring all text inside comments. we must record | |
| 1243 the comment style this sequence begins so that later, | |
| 1244 only a comment end of the same style actually ends | |
| 1245 the comment section */ | |
| 1246 code = Scomment; | |
| 1247 comstyle = | |
| 1248 SYNTAX_CODES_COMMENT_MASK_START (syncode, next_syncode) | |
| 1249 == SYNTAX_COMMENT_STYLE_A ? 0 : 1; | |
| 1250 from++; | |
| 1251 } | |
| 428 | 1252 } |
| 1253 | |
| 1254 if (code == Scomment) | |
| 1255 { | |
| 826 | 1256 Charbpos newfrom = find_end_of_comment (buf, from, stop, |
| 1257 comstyle); | |
| 428 | 1258 if (newfrom < 0) |
| 1259 { | |
| 1260 /* we stopped because from==stop */ | |
| 1261 BUF_SET_PT (buf, stop); | |
| 1262 return Qnil; | |
| 1263 } | |
| 1264 from = newfrom; | |
| 1265 | |
| 1266 /* We have skipped one comment. */ | |
| 1267 break; | |
| 1268 } | |
| 1269 else if (code != Swhitespace | |
| 1270 && code != Sendcomment | |
| 1271 && code != Scomment ) | |
| 1272 { | |
| 1273 BUF_SET_PT (buf, from); | |
| 1274 return Qnil; | |
| 1275 } | |
| 1276 from++; | |
| 1277 } | |
| 1278 | |
| 1279 /* End of comment reached */ | |
| 444 | 1280 n--; |
| 428 | 1281 } |
| 1282 | |
| 444 | 1283 while (n < 0) |
| 428 | 1284 { |
| 1285 QUIT; | |
| 1286 | |
| 1287 stop = BUF_BEGV (buf); | |
| 1288 while (from > stop) | |
| 1289 { | |
| 460 | 1290 int comstyle = 0; /* mask for finding matching comment style */ |
| 428 | 1291 |
| 1292 from--; | |
| 1293 if (char_quoted (buf, from)) | |
| 1294 { | |
| 1295 from--; | |
| 1296 continue; | |
| 1297 } | |
| 1298 | |
| 1299 c = BUF_FETCH_CHAR (buf, from); | |
| 826 | 1300 syncode = SYNTAX_CODE_FROM_CACHE (scache, c); |
| 1301 code = SYNTAX_FROM_CODE (syncode); | |
| 428 | 1302 |
| 1303 if (code == Sendcomment) | |
| 1304 { | |
| 1305 /* we have found a single char end comment. we must record | |
| 1306 the comment style encountered so that later, we can match | |
| 1307 only the proper comment begin sequence of the same style */ | |
| 460 | 1308 comstyle = SYNTAX_CODE_COMMENT_1CHAR_MASK (syncode) |
| 1309 == SYNTAX_COMMENT_STYLE_A ? 0 : 1; | |
| 1310 } | |
| 1311 | |
| 1312 else if (code == Scomment_fence) | |
| 1313 { | |
| 1314 code = Sendcomment; | |
| 1315 comstyle = ST_COMMENT_STYLE; | |
| 428 | 1316 } |
| 1317 | |
| 1318 else if (from > stop | |
| 460 | 1319 && SYNTAX_CODE_END_SECOND_P (syncode)) |
| 428 | 1320 { |
| 460 | 1321 int prev_syncode; |
| 826 | 1322 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from - 1); |
| 460 | 1323 prev_syncode = |
| 826 | 1324 SYNTAX_CODE_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, from - 1)); |
| 460 | 1325 if (SYNTAX_CODES_END_P (prev_syncode, syncode)) |
| 1326 { | |
| 1327 /* We must record the comment style encountered so that | |
| 1328 later, we can match only the proper comment begin | |
| 1329 sequence of the same style. */ | |
| 1330 code = Sendcomment; | |
| 1331 comstyle = SYNTAX_CODES_COMMENT_MASK_END | |
| 1332 (prev_syncode, syncode) == SYNTAX_COMMENT_STYLE_A ? 0 : 1; | |
| 1333 from--; | |
| 1334 } | |
| 428 | 1335 } |
| 1336 | |
| 1337 if (code == Sendcomment) | |
| 1338 { | |
| 460 | 1339 from = find_start_of_comment (buf, from, stop, comstyle); |
| 428 | 1340 break; |
| 1341 } | |
| 1342 | |
| 1343 else if (code != Swhitespace | |
| 460 | 1344 && code != Scomment |
| 1345 && code != Sendcomment) | |
| 428 | 1346 { |
| 1347 BUF_SET_PT (buf, from + 1); | |
| 1348 return Qnil; | |
| 1349 } | |
| 1350 } | |
| 1351 | |
| 444 | 1352 n++; |
| 428 | 1353 } |
| 1354 | |
| 1355 BUF_SET_PT (buf, from); | |
| 1356 return Qt; | |
| 1357 } | |
| 1358 | |
| 1359 | |
| 1360 Lisp_Object | |
| 665 | 1361 scan_lists (struct buffer *buf, Charbpos from, int count, int depth, |
| 444 | 1362 int sexpflag, int noerror) |
| 428 | 1363 { |
| 665 | 1364 Charbpos stop; |
| 867 | 1365 Ichar c; |
| 428 | 1366 int quoted; |
| 1367 int mathexit = 0; | |
| 1368 enum syntaxcode code; | |
| 460 | 1369 int syncode; |
| 428 | 1370 int min_depth = depth; /* Err out if depth gets less than this. */ |
| 826 | 1371 struct syntax_cache *scache; |
|
4912
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
1372 Charbpos last_good = from; |
| 826 | 1373 |
| 428 | 1374 if (depth > 0) min_depth = 0; |
| 1375 | |
| 826 | 1376 scache = setup_buffer_syntax_cache (buf, from, count); |
| 428 | 1377 while (count > 0) |
| 1378 { | |
| 1379 QUIT; | |
| 1380 | |
| 1381 stop = BUF_ZV (buf); | |
| 1382 while (from < stop) | |
| 1383 { | |
| 460 | 1384 int comstyle = 0; /* mask for finding matching comment style */ |
| 428 | 1385 |
| 826 | 1386 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 428 | 1387 c = BUF_FETCH_CHAR (buf, from); |
| 826 | 1388 syncode = SYNTAX_CODE_FROM_CACHE (scache, c); |
| 1389 code = SYNTAX_FROM_CODE (syncode); | |
|
4912
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
1390 if (depth == min_depth) |
|
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
1391 last_good = from; |
| 428 | 1392 from++; |
| 1393 | |
| 1394 /* a 1-char comment start sequence */ | |
| 1395 if (code == Scomment && parse_sexp_ignore_comments) | |
| 1396 { | |
| 460 | 1397 comstyle = SYNTAX_CODE_COMMENT_1CHAR_MASK (syncode) == |
| 1398 SYNTAX_COMMENT_STYLE_A ? 0 : 1; | |
| 428 | 1399 } |
| 1400 | |
| 1401 /* else, a 2-char comment start sequence? */ | |
| 1402 else if (from < stop | |
| 460 | 1403 && SYNTAX_CODE_START_FIRST_P (syncode) |
| 428 | 1404 && parse_sexp_ignore_comments) |
| 1405 { | |
| 460 | 1406 int next_syncode; |
| 826 | 1407 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 460 | 1408 next_syncode = |
| 826 | 1409 SYNTAX_CODE_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, from)); |
| 460 | 1410 |
| 1411 if (SYNTAX_CODES_START_P (syncode, next_syncode)) | |
| 1412 { | |
| 826 | 1413 /* we have encountered a comment start sequence and we |
| 1414 are ignoring all text inside comments. we must record | |
| 1415 the comment style this sequence begins so that later, | |
| 1416 only a comment end of the same style actually ends | |
| 1417 the comment section */ | |
| 1418 code = Scomment; | |
| 460 | 1419 comstyle = SYNTAX_CODES_COMMENT_MASK_START |
| 1420 (syncode, next_syncode) == SYNTAX_COMMENT_STYLE_A ? 0 : 1; | |
| 826 | 1421 from++; |
| 1422 } | |
| 428 | 1423 } |
| 826 | 1424 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 428 | 1425 |
| 460 | 1426 if (SYNTAX_CODE_PREFIX (syncode)) |
| 428 | 1427 continue; |
| 1428 | |
| 1429 switch (code) | |
| 1430 { | |
| 1431 case Sescape: | |
| 1432 case Scharquote: | |
| 1433 if (from == stop) goto lose; | |
| 1434 from++; | |
| 1435 /* treat following character as a word constituent */ | |
| 1436 case Sword: | |
| 1437 case Ssymbol: | |
| 1438 if (depth || !sexpflag) break; | |
| 1439 /* This word counts as a sexp; return at end of it. */ | |
| 1440 while (from < stop) | |
| 1441 { | |
| 826 | 1442 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 1443 switch (SYNTAX_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, from))) | |
| 428 | 1444 { |
| 1445 case Scharquote: | |
| 1446 case Sescape: | |
| 1447 from++; | |
| 1448 if (from == stop) goto lose; | |
| 1449 break; | |
| 1450 case Sword: | |
| 1451 case Ssymbol: | |
| 1452 case Squote: | |
| 1453 break; | |
| 1454 default: | |
| 1455 goto done; | |
| 1456 } | |
| 1457 from++; | |
| 1458 } | |
| 1459 goto done; | |
| 1460 | |
| 460 | 1461 case Scomment_fence: |
| 1462 comstyle = ST_COMMENT_STYLE; | |
| 428 | 1463 case Scomment: |
| 1464 if (!parse_sexp_ignore_comments) | |
| 1465 break; | |
| 826 | 1466 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 428 | 1467 { |
| 665 | 1468 Charbpos newfrom = |
| 460 | 1469 find_end_of_comment (buf, from, stop, comstyle); |
| 428 | 1470 if (newfrom < 0) |
| 1471 { | |
| 1472 /* we stopped because from == stop in search forward */ | |
| 1473 from = stop; | |
| 1474 if (depth == 0) | |
| 1475 goto done; | |
| 1476 goto lose; | |
| 1477 } | |
| 1478 from = newfrom; | |
| 1479 } | |
| 1480 break; | |
| 1481 | |
| 1482 case Smath: | |
| 1483 if (!sexpflag) | |
| 1484 break; | |
| 1485 if (from != stop && c == BUF_FETCH_CHAR (buf, from)) | |
| 1486 from++; | |
| 1487 if (mathexit) | |
| 1488 { | |
| 1489 mathexit = 0; | |
| 1490 goto close1; | |
| 1491 } | |
| 1492 mathexit = 1; | |
| 1493 | |
| 1494 case Sopen: | |
| 1495 if (!++depth) goto done; | |
| 1496 break; | |
| 1497 | |
| 1498 case Sclose: | |
| 1499 close1: | |
| 1500 if (!--depth) goto done; | |
| 1501 if (depth < min_depth) | |
| 1502 { | |
| 444 | 1503 if (noerror) |
| 428 | 1504 return Qnil; |
|
4912
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
1505 signal_error_2 (Qscan_error, |
|
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
1506 "Containing expression ends prematurely", |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1507 make_fixnum (last_good), make_fixnum (from)); |
| 428 | 1508 } |
| 1509 break; | |
| 1510 | |
| 460 | 1511 case Sstring_fence: |
| 428 | 1512 case Sstring: |
| 1513 { | |
| 867 | 1514 Ichar stringterm; |
| 460 | 1515 |
| 1516 if (code != Sstring_fence) | |
| 1517 { | |
| 826 | 1518 /* XEmacs change: call syntax_match on character */ |
| 867 | 1519 Ichar ch = BUF_FETCH_CHAR (buf, from - 1); |
| 460 | 1520 Lisp_Object stermobj = |
| 1296 | 1521 syntax_match (scache->syntax_table, ch); |
| 428 | 1522 |
| 1523 if (CHARP (stermobj)) | |
| 1524 stringterm = XCHAR (stermobj); | |
| 1525 else | |
| 1526 stringterm = ch; | |
| 460 | 1527 } |
| 1528 else | |
| 1529 stringterm = '\0'; /* avoid compiler warnings */ | |
| 428 | 1530 |
| 1531 while (1) | |
| 1532 { | |
| 1533 if (from >= stop) | |
| 1534 goto lose; | |
| 826 | 1535 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 460 | 1536 c = BUF_FETCH_CHAR (buf, from); |
| 1537 if (code == Sstring | |
| 1538 ? c == stringterm | |
| 826 | 1539 : SYNTAX_FROM_CACHE (scache, c) == Sstring_fence) |
| 428 | 1540 break; |
| 460 | 1541 |
| 826 | 1542 switch (SYNTAX_FROM_CACHE (scache, c)) |
| 428 | 1543 { |
| 1544 case Scharquote: | |
| 1545 case Sescape: | |
| 1546 from++; | |
| 1547 break; | |
| 1548 default: | |
| 1549 break; | |
| 1550 } | |
| 1551 from++; | |
| 1552 } | |
| 1553 from++; | |
| 1554 if (!depth && sexpflag) goto done; | |
| 1555 break; | |
| 1556 } | |
| 1557 | |
| 1558 default: | |
| 1559 break; | |
| 1560 } | |
| 1561 } | |
| 1562 | |
| 1563 /* Reached end of buffer. Error if within object, | |
| 1564 return nil if between */ | |
| 1565 if (depth) goto lose; | |
| 1566 | |
| 1567 return Qnil; | |
| 1568 | |
| 1569 /* End of object reached */ | |
| 1570 done: | |
| 1571 count--; | |
| 1572 } | |
| 1573 | |
| 1574 while (count < 0) | |
| 1575 { | |
| 1576 QUIT; | |
| 1577 | |
| 1578 stop = BUF_BEGV (buf); | |
| 1579 while (from > stop) | |
| 1580 { | |
| 460 | 1581 int comstyle = 0; /* mask for finding matching comment style */ |
| 428 | 1582 |
| 1583 from--; | |
| 826 | 1584 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from); |
| 428 | 1585 quoted = char_quoted (buf, from); |
| 1586 if (quoted) | |
| 460 | 1587 { |
| 428 | 1588 from--; |
| 826 | 1589 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from); |
| 460 | 1590 } |
| 428 | 1591 |
| 1592 c = BUF_FETCH_CHAR (buf, from); | |
| 826 | 1593 syncode = SYNTAX_CODE_FROM_CACHE (scache, c); |
| 1594 code = SYNTAX_FROM_CODE (syncode); | |
| 428 | 1595 |
| 1596 if (code == Sendcomment && parse_sexp_ignore_comments) | |
| 1597 { | |
| 1598 /* we have found a single char end comment. we must record | |
| 1599 the comment style encountered so that later, we can match | |
| 1600 only the proper comment begin sequence of the same style */ | |
| 460 | 1601 comstyle = SYNTAX_CODE_COMMENT_1CHAR_MASK (syncode) |
| 1602 == SYNTAX_COMMENT_STYLE_A ? 0 : 1; | |
| 428 | 1603 } |
| 1604 | |
| 1605 else if (from > stop | |
| 460 | 1606 && SYNTAX_CODE_END_SECOND_P (syncode) |
| 428 | 1607 && !char_quoted (buf, from - 1) |
| 1608 && parse_sexp_ignore_comments) | |
| 1609 { | |
| 460 | 1610 int prev_syncode; |
| 826 | 1611 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from - 1); |
| 1612 prev_syncode = | |
| 1613 SYNTAX_CODE_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, from - 1)); | |
| 460 | 1614 |
| 1615 if (SYNTAX_CODES_END_P (prev_syncode, syncode)) | |
| 1616 { | |
| 428 | 1617 /* we must record the comment style encountered so that |
| 1618 later, we can match only the proper comment begin | |
| 1619 sequence of the same style */ | |
| 1620 code = Sendcomment; | |
| 460 | 1621 comstyle = SYNTAX_CODES_COMMENT_MASK_END |
| 1622 (prev_syncode, syncode) == SYNTAX_COMMENT_STYLE_A ? 0 : 1; | |
| 428 | 1623 from--; |
| 1624 } | |
| 460 | 1625 } |
| 428 | 1626 |
| 460 | 1627 if (SYNTAX_CODE_PREFIX (syncode)) |
| 428 | 1628 continue; |
| 1629 | |
| 434 | 1630 switch (quoted ? Sword : code) |
| 428 | 1631 { |
| 1632 case Sword: | |
| 1633 case Ssymbol: | |
| 1634 if (depth || !sexpflag) break; | |
| 1635 /* This word counts as a sexp; count object finished after | |
| 1636 passing it. */ | |
| 1637 while (from > stop) | |
| 1638 { | |
| 826 | 1639 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from); |
| 428 | 1640 quoted = char_quoted (buf, from - 1); |
| 1641 | |
| 1642 if (quoted) | |
| 1643 from--; | |
| 1644 if (! (quoted | |
| 1645 || (syncode = | |
| 826 | 1646 SYNTAX_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, |
| 1647 from - 1))) | |
| 428 | 1648 == Sword |
| 1649 || syncode == Ssymbol | |
| 1650 || syncode == Squote)) | |
| 1651 goto done2; | |
| 1652 from--; | |
| 1653 } | |
| 1654 goto done2; | |
| 1655 | |
| 1656 case Smath: | |
| 1657 if (!sexpflag) | |
| 1658 break; | |
| 1659 if (from != stop && c == BUF_FETCH_CHAR (buf, from - 1)) | |
| 1660 from--; | |
| 1661 if (mathexit) | |
| 1662 { | |
| 1663 mathexit = 0; | |
| 1664 goto open2; | |
| 1665 } | |
| 1666 mathexit = 1; | |
| 1667 | |
| 1668 case Sclose: | |
| 1669 if (!++depth) goto done2; | |
| 1670 break; | |
| 1671 | |
| 1672 case Sopen: | |
| 1673 open2: | |
| 1674 if (!--depth) goto done2; | |
| 1675 if (depth < min_depth) | |
| 1676 { | |
| 444 | 1677 if (noerror) |
| 428 | 1678 return Qnil; |
|
4912
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
1679 signal_error_2 (Qscan_error, |
|
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
1680 "Containing expression ends prematurely", |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1681 make_fixnum (last_good), make_fixnum (from)); |
| 428 | 1682 } |
| 1683 break; | |
| 1684 | |
| 460 | 1685 case Scomment_fence: |
| 1686 comstyle = ST_COMMENT_STYLE; | |
| 428 | 1687 case Sendcomment: |
| 1688 if (parse_sexp_ignore_comments) | |
| 460 | 1689 from = find_start_of_comment (buf, from, stop, comstyle); |
| 428 | 1690 break; |
| 1691 | |
| 460 | 1692 case Sstring_fence: |
| 428 | 1693 case Sstring: |
| 1694 { | |
| 867 | 1695 Ichar stringterm; |
| 460 | 1696 |
| 1697 if (code != Sstring_fence) | |
| 1698 { | |
| 428 | 1699 /* XEmacs change: call syntax_match() on character */ |
| 867 | 1700 Ichar ch = BUF_FETCH_CHAR (buf, from); |
| 460 | 1701 Lisp_Object stermobj = |
| 1296 | 1702 syntax_match (scache->syntax_table, ch); |
| 428 | 1703 |
| 1704 if (CHARP (stermobj)) | |
| 1705 stringterm = XCHAR (stermobj); | |
| 1706 else | |
| 1707 stringterm = ch; | |
| 460 | 1708 } |
| 1709 else | |
| 1710 stringterm = '\0'; /* avoid compiler warnings */ | |
| 428 | 1711 |
| 1712 while (1) | |
| 1713 { | |
| 1714 if (from == stop) goto lose; | |
| 460 | 1715 |
| 826 | 1716 UPDATE_SYNTAX_CACHE_BACKWARD (scache, from - 1); |
| 460 | 1717 c = BUF_FETCH_CHAR (buf, from - 1); |
| 1718 | |
| 1719 if ((code == Sstring | |
| 1720 ? c == stringterm | |
| 826 | 1721 : SYNTAX_FROM_CACHE (scache, c) == Sstring_fence) |
| 460 | 1722 && !char_quoted (buf, from - 1)) |
| 1723 { | |
| 428 | 1724 break; |
| 460 | 1725 } |
| 1726 | |
| 428 | 1727 from--; |
| 1728 } | |
| 1729 from--; | |
| 1730 if (!depth && sexpflag) goto done2; | |
| 1731 break; | |
| 1732 } | |
| 1733 } | |
| 1734 } | |
| 1735 | |
| 1736 /* Reached start of buffer. Error if within object, | |
| 1737 return nil if between */ | |
| 1738 if (depth) goto lose; | |
| 1739 | |
| 1740 return Qnil; | |
| 1741 | |
| 1742 done2: | |
| 1743 count++; | |
| 1744 } | |
| 1745 | |
| 1746 | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1747 return (make_fixnum (from)); |
| 428 | 1748 |
| 1749 lose: | |
| 444 | 1750 if (!noerror) |
|
4912
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
1751 signal_error_2 (Qscan_error, "Unbalanced parentheses", |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1752 make_fixnum (last_good), make_fixnum (from)); |
| 428 | 1753 return Qnil; |
| 1754 } | |
| 1755 | |
| 1756 int | |
| 665 | 1757 char_quoted (struct buffer *buf, Charbpos pos) |
| 428 | 1758 { |
| 1759 enum syntaxcode code; | |
| 665 | 1760 Charbpos beg = BUF_BEGV (buf); |
| 428 | 1761 int quoted = 0; |
| 665 | 1762 Charbpos startpos = pos; |
| 826 | 1763 struct syntax_cache *scache = buf->syntax_cache; |
| 460 | 1764 |
| 1765 while (pos > beg) | |
| 1766 { | |
| 826 | 1767 UPDATE_SYNTAX_CACHE_BACKWARD (scache, pos - 1); |
| 1768 code = SYNTAX_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, pos - 1)); | |
| 428 | 1769 |
| 460 | 1770 if (code != Scharquote && code != Sescape) |
| 1771 break; | |
| 1772 pos--; | |
| 1773 quoted = !quoted; | |
| 1774 } | |
| 1775 | |
| 826 | 1776 UPDATE_SYNTAX_CACHE (scache, startpos); |
| 428 | 1777 return quoted; |
| 1778 } | |
| 1779 | |
| 1780 DEFUN ("scan-lists", Fscan_lists, 3, 5, 0, /* | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1781 Scan from position FROM across COUNT lists starting from nesting DEPTH. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1782 Returns the position thus found. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1783 Optional BUFFER defaults to the current buffer. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1784 If optional NOERROR is non-nil, scan-lists will return nil instead of |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1785 signalling an error when attempting to cross a buffer boundary. |
| 428 | 1786 |
| 1787 If DEPTH is nonzero, paren depth begins counting from that value, | |
| 1788 only places where the depth in parentheses becomes zero | |
| 1789 are candidates for stopping; COUNT such places are counted. | |
| 1790 Thus, a positive value for DEPTH means go out levels. | |
| 1791 | |
| 1792 Comments are ignored if `parse-sexp-ignore-comments' is non-nil. | |
| 1793 | |
| 1794 If the beginning or end of (the accessible part of) the buffer is reached | |
| 1795 and the depth is wrong, an error is signaled. | |
| 1796 If the depth is right but the count is not used up, nil is returned. | |
| 1797 | |
| 1798 */ | |
| 444 | 1799 (from, count, depth, buffer, noerror)) |
| 428 | 1800 { |
| 1801 struct buffer *buf; | |
| 1802 | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1803 CHECK_FIXNUM (from); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1804 CHECK_FIXNUM (count); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1805 CHECK_FIXNUM (depth); |
| 428 | 1806 buf = decode_buffer (buffer, 0); |
| 1807 | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1808 return scan_lists (buf, XFIXNUM (from), XFIXNUM (count), XFIXNUM (depth), 0, |
| 444 | 1809 !NILP (noerror)); |
| 428 | 1810 } |
| 1811 | |
| 1812 DEFUN ("scan-sexps", Fscan_sexps, 2, 4, 0, /* | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1813 Scan from position FROM by COUNT balanced expressions. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1814 Returns the position thus found. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1815 |
| 428 | 1816 If COUNT is negative, scan backwards. |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1817 Optional BUFFER defaults to the current buffer. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1818 If optional NOERROR is non-nil, scan-sexps will return nil instead of |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1819 signalling an error. |
| 428 | 1820 |
| 1821 Comments are ignored if `parse-sexp-ignore-comments' is non-nil. | |
| 1822 | |
| 1823 If the beginning or end of (the accessible part of) the buffer is reached | |
| 1824 in the middle of a parenthetical grouping, an error is signaled. | |
| 1825 If the beginning or end is reached between groupings | |
| 1826 but before count is used up, nil is returned. | |
| 1827 */ | |
| 444 | 1828 (from, count, buffer, noerror)) |
| 428 | 1829 { |
| 1830 struct buffer *buf = decode_buffer (buffer, 0); | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1831 CHECK_FIXNUM (from); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1832 CHECK_FIXNUM (count); |
| 428 | 1833 |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1834 return scan_lists (buf, XFIXNUM (from), XFIXNUM (count), 0, 1, !NILP (noerror)); |
| 428 | 1835 } |
| 1836 | |
| 1837 DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, 0, 1, 0, /* | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1838 Move point backward over any number of chars with quote or prefix syntax. |
|
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
1839 Optional BUFFER defaults to the current buffer. |
| 428 | 1840 */ |
| 1841 (buffer)) | |
| 1842 { | |
| 1843 struct buffer *buf = decode_buffer (buffer, 0); | |
| 665 | 1844 Charbpos beg = BUF_BEGV (buf); |
| 1845 Charbpos pos = BUF_PT (buf); | |
| 867 | 1846 Ichar c = '\0'; /* initialize to avoid compiler warnings */ |
| 826 | 1847 struct syntax_cache *scache; |
| 1848 | |
| 1849 scache = setup_buffer_syntax_cache (buf, pos, -1); | |
| 428 | 1850 |
| 1851 while (pos > beg && !char_quoted (buf, pos - 1) | |
| 460 | 1852 /* Previous statement updates syntax table. */ |
| 826 | 1853 && (SYNTAX_FROM_CACHE (scache, c = BUF_FETCH_CHAR (buf, pos - 1)) == Squote |
| 1854 || SYNTAX_CODE_PREFIX (SYNTAX_CODE_FROM_CACHE (scache, c)))) | |
| 428 | 1855 pos--; |
| 1856 | |
| 1857 BUF_SET_PT (buf, pos); | |
| 1858 | |
| 1859 return Qnil; | |
| 1860 } | |
| 1861 | |
| 1862 /* Parse forward from FROM to END, | |
| 1863 assuming that FROM has state OLDSTATE (nil means FROM is start of function), | |
| 1864 and return a description of the state of the parse at END. | |
| 1865 If STOPBEFORE is nonzero, stop at the start of an atom. | |
| 1866 If COMMENTSTOP is nonzero, stop at the start of a comment. */ | |
| 1867 | |
| 1868 static void | |
| 1869 scan_sexps_forward (struct buffer *buf, struct lisp_parse_state *stateptr, | |
| 665 | 1870 Charbpos from, Charbpos end, |
| 428 | 1871 int targetdepth, int stopbefore, |
| 1872 Lisp_Object oldstate, | |
| 1873 int commentstop) | |
| 1874 { | |
| 1875 struct lisp_parse_state state; | |
| 1876 | |
| 1877 enum syntaxcode code; | |
| 1878 struct level { int last, prev; }; | |
| 1879 struct level levelstart[100]; | |
| 1880 struct level *curlevel = levelstart; | |
| 1881 struct level *endlevel = levelstart + 100; | |
| 1882 int depth; /* Paren depth of current scanning location. | |
| 1883 level - levelstart equals this except | |
| 1884 when the depth becomes negative. */ | |
| 1885 int mindepth; /* Lowest DEPTH value seen. */ | |
| 1886 int start_quoted = 0; /* Nonzero means starting after a char quote */ | |
| 460 | 1887 int boundary_stop = commentstop == -1; |
| 428 | 1888 Lisp_Object tem; |
| 826 | 1889 struct syntax_cache *scache; |
| 1890 | |
| 1891 scache = setup_buffer_syntax_cache (buf, from, 1); | |
| 428 | 1892 if (NILP (oldstate)) |
| 1893 { | |
| 1894 depth = 0; | |
| 1895 state.instring = -1; | |
| 1896 state.incomment = 0; | |
| 1897 state.comstyle = 0; /* comment style a by default */ | |
| 460 | 1898 state.comstr_start = -1; /* no comment/string seen. */ |
| 428 | 1899 } |
| 1900 else | |
| 1901 { | |
| 1902 tem = Fcar (oldstate); /* elt 0, depth */ | |
| 1903 if (!NILP (tem)) | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1904 depth = XFIXNUM (tem); |
| 428 | 1905 else |
| 1906 depth = 0; | |
| 1907 | |
| 1908 oldstate = Fcdr (oldstate); | |
| 1909 oldstate = Fcdr (oldstate); | |
| 1910 oldstate = Fcdr (oldstate); | |
| 1911 tem = Fcar (oldstate); /* elt 3, instring */ | |
| 460 | 1912 state.instring = ( !NILP (tem) |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1913 ? ( FIXNUMP (tem) ? XFIXNUM (tem) : ST_STRING_STYLE) |
| 460 | 1914 : -1); |
| 428 | 1915 |
| 460 | 1916 oldstate = Fcdr (oldstate); |
| 1917 tem = Fcar (oldstate); /* elt 4, incomment */ | |
| 428 | 1918 state.incomment = !NILP (tem); |
| 1919 | |
| 1920 oldstate = Fcdr (oldstate); | |
| 1921 tem = Fcar (oldstate); /* elt 5, follows-quote */ | |
| 1922 start_quoted = !NILP (tem); | |
| 1923 | |
| 1924 /* if the eighth element of the list is nil, we are in comment style | |
| 3025 | 1925 a; if it is t, we are in comment style b; if it is `syntax-table', |
| 460 | 1926 we are in a generic comment */ |
| 428 | 1927 oldstate = Fcdr (oldstate); |
| 1928 oldstate = Fcdr (oldstate); | |
| 460 | 1929 tem = Fcar (oldstate); /* elt 7, comment style a/b/fence */ |
| 1930 state.comstyle = NILP (tem) ? 0 : ( EQ (tem, Qsyntax_table) | |
| 1931 ? ST_COMMENT_STYLE : 1 ); | |
| 1932 | |
| 1933 oldstate = Fcdr (oldstate); /* elt 8, start of last comment/string */ | |
| 1934 tem = Fcar (oldstate); | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1935 state.comstr_start = NILP (tem) ? -1 : XFIXNUM (tem); |
| 460 | 1936 |
| 1937 /* elt 9, char numbers of starts-of-expression of levels | |
| 1938 (starting from outermost). */ | |
| 1939 oldstate = Fcdr (oldstate); | |
| 1940 tem = Fcar (oldstate); /* elt 9, intermediate data for | |
| 1941 continuation of parsing (subject | |
| 1942 to change). */ | |
| 1943 while (!NILP (tem)) /* >= second enclosing sexps. */ | |
| 1944 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1945 curlevel->last = XFIXNUM (Fcar (tem)); |
| 460 | 1946 if (++curlevel == endlevel) |
| 826 | 1947 stack_overflow ("Nesting too deep for parser", |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
1948 make_fixnum (curlevel - levelstart)); |
| 460 | 1949 curlevel->prev = -1; |
| 1950 curlevel->last = -1; | |
| 1951 tem = Fcdr (tem); | |
| 1952 } | |
| 428 | 1953 } |
| 1954 state.quoted = 0; | |
| 1955 mindepth = depth; | |
| 1956 | |
| 1957 curlevel->prev = -1; | |
| 1958 curlevel->last = -1; | |
| 1959 | |
| 1960 /* Enter the loop at a place appropriate for initial state. */ | |
| 1961 | |
| 1962 if (state.incomment) goto startincomment; | |
| 1963 if (state.instring >= 0) | |
| 1964 { | |
| 1965 if (start_quoted) goto startquotedinstring; | |
| 1966 goto startinstring; | |
| 1967 } | |
| 1968 if (start_quoted) goto startquoted; | |
| 1969 | |
| 1970 while (from < end) | |
| 1971 { | |
| 867 | 1972 Ichar c; |
| 460 | 1973 int syncode; |
| 1974 | |
| 428 | 1975 QUIT; |
| 1976 | |
| 826 | 1977 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 460 | 1978 c = BUF_FETCH_CHAR (buf, from); |
| 826 | 1979 syncode = SYNTAX_CODE_FROM_CACHE (scache, c); |
| 1980 code = SYNTAX_FROM_CODE (syncode); | |
| 428 | 1981 from++; |
| 1982 | |
| 1983 /* record the comment style we have entered so that only the | |
| 1984 comment-ender sequence (or single char) of the same style | |
| 1985 actually terminates the comment section. */ | |
| 460 | 1986 if (code == Scomment) |
| 1987 { | |
| 1988 state.comstyle = | |
| 1989 SYNTAX_CODE_COMMENT_1CHAR_MASK (syncode) | |
| 1990 == SYNTAX_COMMENT_STYLE_A ? 0 : 1; | |
| 1991 state.comstr_start = from - 1; | |
| 1992 } | |
| 1993 | |
| 1994 /* a generic comment delimiter? */ | |
| 1995 else if (code == Scomment_fence) | |
| 1996 { | |
| 1997 state.comstyle = ST_COMMENT_STYLE; | |
| 1998 state.comstr_start = from - 1; | |
| 1999 code = Scomment; | |
| 428 | 2000 } |
| 2001 | |
| 2002 else if (from < end && | |
| 460 | 2003 SYNTAX_CODE_START_FIRST_P (syncode)) |
| 428 | 2004 { |
| 460 | 2005 int next_syncode; |
| 826 | 2006 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 460 | 2007 next_syncode = |
| 826 | 2008 SYNTAX_CODE_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, from)); |
| 460 | 2009 |
| 2010 if (SYNTAX_CODES_START_P (syncode, next_syncode)) | |
| 2011 { | |
| 428 | 2012 code = Scomment; |
| 460 | 2013 state.comstyle = SYNTAX_CODES_COMMENT_MASK_START |
| 2014 (syncode, next_syncode) == SYNTAX_COMMENT_STYLE_A ? 0 : 1; | |
| 2015 state.comstr_start = from - 1; | |
| 428 | 2016 from++; |
| 826 | 2017 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 460 | 2018 } |
| 428 | 2019 } |
| 2020 | |
| 460 | 2021 if (SYNTAX_CODE_PREFIX (syncode)) |
| 428 | 2022 continue; |
| 2023 switch (code) | |
| 2024 { | |
| 2025 case Sescape: | |
| 2026 case Scharquote: | |
| 2027 if (stopbefore) goto stop; /* this arg means stop at sexp start */ | |
| 2028 curlevel->last = from - 1; | |
| 2029 startquoted: | |
| 2030 if (from == end) goto endquoted; | |
| 2031 from++; | |
| 2032 goto symstarted; | |
| 2033 /* treat following character as a word constituent */ | |
| 2034 case Sword: | |
| 2035 case Ssymbol: | |
| 2036 if (stopbefore) goto stop; /* this arg means stop at sexp start */ | |
| 2037 curlevel->last = from - 1; | |
| 2038 symstarted: | |
| 2039 while (from < end) | |
| 2040 { | |
| 826 | 2041 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 2042 switch (SYNTAX_FROM_CACHE (scache, BUF_FETCH_CHAR (buf, from))) | |
| 428 | 2043 { |
| 2044 case Scharquote: | |
| 2045 case Sescape: | |
| 2046 from++; | |
| 2047 if (from == end) goto endquoted; | |
| 2048 break; | |
| 2049 case Sword: | |
| 2050 case Ssymbol: | |
| 2051 case Squote: | |
| 2052 break; | |
| 2053 default: | |
| 2054 goto symdone; | |
| 2055 } | |
| 2056 from++; | |
| 2057 } | |
| 2058 symdone: | |
| 2059 curlevel->prev = curlevel->last; | |
| 2060 break; | |
| 2061 | |
| 2062 case Scomment: | |
| 2063 state.incomment = 1; | |
| 460 | 2064 if (commentstop || boundary_stop) goto done; |
| 428 | 2065 startincomment: |
| 460 | 2066 if (commentstop == 1) |
| 428 | 2067 goto done; |
| 826 | 2068 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 428 | 2069 { |
| 826 | 2070 Charbpos newfrom = find_end_of_comment (buf, from, end, |
| 2071 state.comstyle); | |
| 428 | 2072 if (newfrom < 0) |
| 2073 { | |
| 2074 /* we terminated search because from == end */ | |
| 2075 from = end; | |
| 2076 goto done; | |
| 2077 } | |
| 2078 from = newfrom; | |
| 2079 } | |
| 2080 state.incomment = 0; | |
| 2081 state.comstyle = 0; /* reset the comment style */ | |
| 460 | 2082 if (boundary_stop) goto done; |
| 428 | 2083 break; |
| 2084 | |
| 2085 case Sopen: | |
| 2086 if (stopbefore) goto stop; /* this arg means stop at sexp start */ | |
| 2087 depth++; | |
| 2088 curlevel->last = from - 1; | |
| 2089 if (++curlevel == endlevel) | |
| 826 | 2090 stack_overflow ("Nesting too deep for parser", |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2091 make_fixnum (curlevel - levelstart)); |
| 428 | 2092 curlevel->prev = -1; |
| 2093 curlevel->last = -1; | |
| 2094 if (targetdepth == depth) goto done; | |
| 2095 break; | |
| 2096 | |
| 2097 case Sclose: | |
| 2098 depth--; | |
| 2099 if (depth < mindepth) | |
| 2100 mindepth = depth; | |
| 2101 if (curlevel != levelstart) | |
| 2102 curlevel--; | |
| 2103 curlevel->prev = curlevel->last; | |
| 2104 if (targetdepth == depth) goto done; | |
| 2105 break; | |
| 2106 | |
| 2107 case Sstring: | |
| 460 | 2108 case Sstring_fence: |
| 2109 state.comstr_start = from - 1; | |
| 428 | 2110 if (stopbefore) goto stop; /* this arg means stop at sexp start */ |
| 2111 curlevel->last = from - 1; | |
| 460 | 2112 if (code == Sstring_fence) |
| 428 | 2113 { |
| 460 | 2114 state.instring = ST_STRING_STYLE; |
| 2115 } | |
| 2116 else | |
| 2117 { | |
| 2118 /* XEmacs change: call syntax_match() on character */ | |
| 867 | 2119 Ichar ch = BUF_FETCH_CHAR (buf, from - 1); |
| 460 | 2120 Lisp_Object stermobj = |
| 1296 | 2121 syntax_match (scache->syntax_table, ch); |
| 428 | 2122 |
| 2123 if (CHARP (stermobj)) | |
| 2124 state.instring = XCHAR (stermobj); | |
| 2125 else | |
| 2126 state.instring = ch; | |
| 2127 } | |
| 460 | 2128 if (boundary_stop) goto done; |
| 428 | 2129 startinstring: |
| 2130 while (1) | |
| 2131 { | |
| 460 | 2132 enum syntaxcode temp_code; |
| 2133 | |
| 428 | 2134 if (from >= end) goto done; |
| 460 | 2135 |
| 826 | 2136 UPDATE_SYNTAX_CACHE_FORWARD (scache, from); |
| 460 | 2137 c = BUF_FETCH_CHAR (buf, from); |
| 826 | 2138 temp_code = SYNTAX_FROM_CACHE (scache, c); |
| 460 | 2139 |
| 2140 if ( | |
| 2141 state.instring != ST_STRING_STYLE && | |
| 2142 temp_code == Sstring && | |
| 2143 c == state.instring) break; | |
| 2144 | |
| 2145 switch (temp_code) | |
| 428 | 2146 { |
| 460 | 2147 case Sstring_fence: |
| 2148 if (state.instring == ST_STRING_STYLE) | |
| 2149 goto string_end; | |
| 2150 break; | |
| 428 | 2151 case Scharquote: |
| 2152 case Sescape: | |
| 2153 { | |
| 2154 from++; | |
| 2155 startquotedinstring: | |
| 2156 if (from >= end) goto endquoted; | |
| 2157 break; | |
| 2158 } | |
| 2159 default: | |
| 2160 break; | |
| 2161 } | |
| 2162 from++; | |
| 2163 } | |
| 460 | 2164 string_end: |
| 428 | 2165 state.instring = -1; |
| 2166 curlevel->prev = curlevel->last; | |
| 2167 from++; | |
| 460 | 2168 if (boundary_stop) goto done; |
| 428 | 2169 break; |
| 2170 | |
| 2171 case Smath: | |
| 2172 break; | |
| 2173 | |
| 2174 case Swhitespace: | |
| 2175 case Spunct: | |
| 2176 case Squote: | |
| 2177 case Sendcomment: | |
| 460 | 2178 case Scomment_fence: |
| 428 | 2179 case Sinherit: |
| 2180 case Smax: | |
| 2181 break; | |
| 2182 } | |
| 2183 } | |
| 2184 goto done; | |
| 2185 | |
| 2186 stop: /* Here if stopping before start of sexp. */ | |
| 2187 from--; /* We have just fetched the char that starts it; */ | |
| 2188 goto done; /* but return the position before it. */ | |
| 2189 | |
| 2190 endquoted: | |
| 2191 state.quoted = 1; | |
| 2192 done: | |
| 2193 state.depth = depth; | |
| 2194 state.mindepth = mindepth; | |
| 2195 state.thislevelstart = curlevel->prev; | |
| 2196 state.prevlevelstart | |
| 2197 = (curlevel == levelstart) ? -1 : (curlevel - 1)->last; | |
| 2198 state.location = from; | |
| 460 | 2199 state.levelstarts = Qnil; |
| 2200 while (--curlevel >= levelstart) | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2201 state.levelstarts = Fcons (make_fixnum (curlevel->last), |
| 460 | 2202 state.levelstarts); |
| 428 | 2203 |
| 2204 *stateptr = state; | |
| 2205 } | |
| 2206 | |
| 2207 DEFUN ("parse-partial-sexp", Fparse_partial_sexp, 2, 7, 0, /* | |
| 2208 Parse Lisp syntax starting at FROM until TO; return status of parse at TO. | |
| 2209 Parsing stops at TO or when certain criteria are met; | |
| 2210 point is set to where parsing stops. | |
| 444 | 2211 If fifth arg OLDSTATE is omitted or nil, |
| 428 | 2212 parsing assumes that FROM is the beginning of a function. |
| 460 | 2213 Value is a list of nine elements describing final state of parsing: |
| 428 | 2214 0. depth in parens. |
| 2215 1. character address of start of innermost containing list; nil if none. | |
| 2216 2. character address of start of last complete sexp terminated. | |
| 2217 3. non-nil if inside a string. | |
| 460 | 2218 (It is the character that will terminate the string, |
| 2219 or t if the string should be terminated by an explicit | |
| 2220 `syntax-table' property.) | |
| 428 | 2221 4. t if inside a comment. |
| 2222 5. t if following a quote character. | |
| 2223 6. the minimum paren-depth encountered during this scan. | |
| 460 | 2224 7. nil if in comment style a, or not in a comment; t if in comment style b; |
| 2225 `syntax-table' if given by an explicit `syntax-table' property. | |
| 2226 8. character address of start of last comment or string; nil if none. | |
| 2227 9. Intermediate data for continuation of parsing (subject to change). | |
| 428 | 2228 If third arg TARGETDEPTH is non-nil, parsing stops if the depth |
| 2229 in parentheses becomes equal to TARGETDEPTH. | |
| 2230 Fourth arg STOPBEFORE non-nil means stop when come to | |
| 2231 any character that starts a sexp. | |
| 460 | 2232 Fifth arg OLDSTATE is a nine-element list like what this function returns. |
| 428 | 2233 It is used to initialize the state of the parse. Its second and third |
| 2234 elements are ignored. | |
| 460 | 2235 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment. If it |
| 2236 is `syntax-table', stop after the start of a comment or a string, or after | |
| 2237 the end of a comment or string. | |
| 826 | 2238 Seventh arg BUFFER specifies the buffer to do the parsing in, and defaults |
| 2239 to the current buffer. | |
| 428 | 2240 */ |
| 2241 (from, to, targetdepth, stopbefore, oldstate, commentstop, buffer)) | |
| 2242 { | |
| 2243 struct lisp_parse_state state; | |
| 2244 int target; | |
| 665 | 2245 Charbpos start, end; |
| 428 | 2246 struct buffer *buf = decode_buffer (buffer, 0); |
| 2247 Lisp_Object val; | |
| 2248 | |
| 2249 if (!NILP (targetdepth)) | |
| 2250 { | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2251 CHECK_FIXNUM (targetdepth); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2252 target = XFIXNUM (targetdepth); |
| 428 | 2253 } |
| 2254 else | |
| 2255 target = -100000; /* We won't reach this depth */ | |
| 2256 | |
| 2257 get_buffer_range_char (buf, from, to, &start, &end, 0); | |
| 2258 scan_sexps_forward (buf, &state, start, end, | |
| 2259 target, !NILP (stopbefore), oldstate, | |
| 460 | 2260 (NILP (commentstop) |
| 2261 ? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1))); | |
| 428 | 2262 BUF_SET_PT (buf, state.location); |
| 2263 | |
| 2264 /* reverse order */ | |
| 2265 val = Qnil; | |
| 460 | 2266 val = Fcons (state.levelstarts, val); |
| 2267 val = Fcons ((state.incomment || (state.instring >= 0)) | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2268 ? make_fixnum (state.comstr_start) : Qnil, val); |
| 460 | 2269 val = Fcons (state.comstyle ? (state.comstyle == ST_COMMENT_STYLE |
| 2270 ? Qsyntax_table : Qt) : Qnil, val); | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2271 val = Fcons (make_fixnum (state.mindepth), val); |
| 428 | 2272 val = Fcons (state.quoted ? Qt : Qnil, val); |
| 2273 val = Fcons (state.incomment ? Qt : Qnil, val); | |
| 460 | 2274 val = Fcons (state.instring < 0 |
| 2275 ? Qnil | |
| 2276 : (state.instring == ST_STRING_STYLE | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2277 ? Qt : make_fixnum (state.instring)), val); |
| 826 | 2278 val = Fcons (state.thislevelstart < 0 ? Qnil : |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2279 make_fixnum (state.thislevelstart), val); |
| 826 | 2280 val = Fcons (state.prevlevelstart < 0 ? Qnil : |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2281 make_fixnum (state.prevlevelstart), val); |
|
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2282 val = Fcons (make_fixnum (state.depth), val); |
| 428 | 2283 |
| 2284 return val; | |
| 2285 } | |
| 2286 | |
| 2287 | |
| 2288 /* Updating of the mirror syntax table. | |
| 2289 | |
| 1296 | 2290 Each syntax table has a corresponding mirror table in it. Whenever we |
| 2291 make a change to a syntax table, we set a dirty flag. When accessing a | |
| 2292 value from the mirror table and the table is dirty, we call | |
| 2293 update_syntax_table() to clean it up. | |
| 428 | 2294 |
| 2295 #### We really only need to map over the changed range. | |
| 2296 | |
| 2297 If we change the standard syntax table, we need to map over | |
| 2298 all tables because any of them could be inheriting from the | |
| 2299 standard syntax table. | |
| 2300 | |
| 2301 When `set-syntax-table' is called, we set the buffer's mirror | |
| 2302 syntax table as well. | |
| 2303 */ | |
| 2304 | |
| 826 | 2305 static int |
| 2286 | 2306 copy_to_mirrortab (struct chartab_range *range, Lisp_Object UNUSED (table), |
| 826 | 2307 Lisp_Object val, void *arg) |
| 428 | 2308 { |
| 5013 | 2309 Lisp_Object mirrortab = GET_LISP_FROM_VOID (arg); |
| 428 | 2310 |
| 2311 if (CONSP (val)) | |
| 2312 val = XCAR (val); | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2313 if (SYNTAX_FROM_CODE (XFIXNUM (val)) != Sinherit) |
| 826 | 2314 put_char_table (mirrortab, range, val); |
| 2315 return 0; | |
| 2316 } | |
| 2317 | |
| 2318 static int | |
| 2286 | 2319 copy_if_not_already_present (struct chartab_range *range, |
| 2320 Lisp_Object UNUSED (table), | |
| 826 | 2321 Lisp_Object val, void *arg) |
| 2322 { | |
| 5013 | 2323 Lisp_Object mirrortab = GET_LISP_FROM_VOID (arg); |
| 826 | 2324 if (CONSP (val)) |
| 2325 val = XCAR (val); | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2326 if (SYNTAX_FROM_CODE (XFIXNUM (val)) != Sinherit) |
| 826 | 2327 { |
| 2328 Lisp_Object existing = | |
| 1296 | 2329 updating_mirror_get_range_char_table (range, mirrortab, |
| 2330 Vbogus_syntax_table_value); | |
| 826 | 2331 if (NILP (existing)) |
| 2332 /* nothing at all */ | |
| 1296 | 2333 put_char_table (mirrortab, range, val); |
| 2334 else if (!EQ (existing, Vbogus_syntax_table_value)) | |
| 826 | 2335 /* full */ |
| 2336 ; | |
| 2337 else | |
| 2338 { | |
| 2339 Freset_char_table (Vtemp_table_for_use_updating_syntax_tables); | |
| 2340 copy_char_table_range | |
| 1296 | 2341 (mirrortab, Vtemp_table_for_use_updating_syntax_tables, range); |
| 2342 put_char_table (mirrortab, range, val); | |
| 826 | 2343 copy_char_table_range |
| 1296 | 2344 (Vtemp_table_for_use_updating_syntax_tables, mirrortab, range); |
| 826 | 2345 } |
| 428 | 2346 } |
| 826 | 2347 |
| 428 | 2348 return 0; |
| 2349 } | |
| 2350 | |
| 2351 static void | |
| 826 | 2352 update_just_this_syntax_table (Lisp_Object table) |
| 428 | 2353 { |
| 2354 struct chartab_range range; | |
| 826 | 2355 Lisp_Object mirrortab = XCHAR_TABLE (table)->mirror_table; |
| 2356 | |
| 1296 | 2357 assert (!XCHAR_TABLE (table)->mirror_table_p); |
| 826 | 2358 range.type = CHARTAB_RANGE_ALL; |
| 2359 Freset_char_table (mirrortab); | |
| 1296 | 2360 |
| 826 | 2361 /* First, copy the tables values other than inherit into the mirror |
| 2362 table. Then, for tables other than the standard syntax table, map | |
| 2363 over the standard table, copying values into the mirror table only if | |
| 2364 entries don't already exist in that table. (The copying step requires | |
| 2365 another mapping.) | |
| 2366 */ | |
| 428 | 2367 |
| 5013 | 2368 map_char_table (table, &range, copy_to_mirrortab, STORE_LISP_IN_VOID (mirrortab)); |
| 826 | 2369 /* second clause catches bootstrapping problems when initializing the |
| 2370 standard syntax table */ | |
| 2371 if (!EQ (table, Vstandard_syntax_table) && !NILP (Vstandard_syntax_table)) | |
| 1296 | 2372 map_char_table (Vstandard_syntax_table, &range, |
| 5013 | 2373 copy_if_not_already_present, STORE_LISP_IN_VOID (mirrortab)); |
| 3152 | 2374 /* The resetting made the default be Qnil. Put it back to Sword. */ |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2375 set_char_table_default (mirrortab, make_fixnum (Sword)); |
| 1296 | 2376 XCHAR_TABLE (mirrortab)->dirty = 0; |
| 428 | 2377 } |
| 2378 | |
| 2379 /* Called from chartab.c when a change is made to a syntax table. | |
| 2380 If this is the standard syntax table, we need to recompute | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
2381 *all* syntax tables. Otherwise we just recompute this one. */ |
| 428 | 2382 |
| 2383 void | |
| 826 | 2384 update_syntax_table (Lisp_Object table) |
| 428 | 2385 { |
| 1296 | 2386 Lisp_Object nonmirror = XCHAR_TABLE (table)->mirror_table; |
| 2387 assert (XCHAR_TABLE (table)->mirror_table_p); | |
| 2388 if (EQ (nonmirror, Vstandard_syntax_table)) | |
| 428 | 2389 { |
| 2390 Lisp_Object syntab; | |
| 2391 | |
| 2392 for (syntab = Vall_syntax_tables; !NILP (syntab); | |
| 2393 syntab = XCHAR_TABLE (syntab)->next_table) | |
| 826 | 2394 update_just_this_syntax_table (syntab); |
| 428 | 2395 } |
| 2396 else | |
| 1296 | 2397 update_just_this_syntax_table (nonmirror); |
| 428 | 2398 } |
| 2399 | |
| 2400 | |
| 2401 /************************************************************************/ | |
| 2402 /* initialization */ | |
| 2403 /************************************************************************/ | |
| 2404 | |
| 2405 void | |
| 2406 syms_of_syntax (void) | |
| 2407 { | |
| 3092 | 2408 #ifdef NEW_GC |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
2409 INIT_LISP_OBJECT (syntax_cache); |
| 3092 | 2410 #endif /* NEW_GC */ |
| 563 | 2411 DEFSYMBOL (Qsyntax_table_p); |
| 2412 DEFSYMBOL (Qsyntax_table); | |
| 428 | 2413 |
| 2414 DEFSUBR (Fsyntax_table_p); | |
| 2415 DEFSUBR (Fsyntax_table); | |
| 826 | 2416 #ifdef DEBUG_XEMACS |
| 2417 DEFSUBR (Fmirror_syntax_table); | |
| 2418 DEFSUBR (Fsyntax_cache_info); | |
| 2419 #endif /* DEBUG_XEMACS */ | |
| 428 | 2420 DEFSUBR (Fstandard_syntax_table); |
| 2421 DEFSUBR (Fcopy_syntax_table); | |
| 2422 DEFSUBR (Fset_syntax_table); | |
| 2423 DEFSUBR (Fsyntax_designator_chars); | |
| 2424 DEFSUBR (Fchar_syntax); | |
| 2425 DEFSUBR (Fmatching_paren); | |
| 2426 /* DEFSUBR (Fmodify_syntax_entry); now in Lisp. */ | |
| 2427 /* DEFSUBR (Fdescribe_syntax); now in Lisp. */ | |
| 2428 | |
| 2429 DEFSUBR (Fforward_word); | |
| 2430 | |
| 2431 DEFSUBR (Fforward_comment); | |
| 2432 DEFSUBR (Fscan_lists); | |
| 2433 DEFSUBR (Fscan_sexps); | |
| 2434 DEFSUBR (Fbackward_prefix_chars); | |
| 2435 DEFSUBR (Fparse_partial_sexp); | |
|
4912
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
2436 |
|
e99033b7e05c
use more specific `scan-error' in scan-lists to be GNU compatible
Ben Wing <ben@xemacs.org>
parents:
4759
diff
changeset
|
2437 DEFERROR_STANDARD (Qscan_error, Qsyntax_error); |
| 428 | 2438 } |
| 2439 | |
| 2440 void | |
| 2441 vars_of_syntax (void) | |
| 2442 { | |
| 2443 DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments /* | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
2444 If non-nil, `forward-sexp' etc. treat comments as whitespace. |
| 428 | 2445 */ ); |
| 434 | 2446 parse_sexp_ignore_comments = 0; |
| 428 | 2447 |
| 460 | 2448 DEFVAR_BOOL ("lookup-syntax-properties", &lookup_syntax_properties /* |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
2449 If non-nil, `forward-sexp' etc. respect the `syntax-table' text property. |
| 826 | 2450 This property can be placed on buffers or strings and can be used to explicitly |
| 2451 specify the syntax table to be used for looking up the syntax of the chars | |
| 2452 having this property, or to directly specify the syntax of the chars. | |
| 2453 | |
| 460 | 2454 The value of this property should be either a syntax table, or a cons |
| 2455 of the form (SYNTAXCODE . MATCHCHAR), SYNTAXCODE being the numeric | |
| 2456 syntax code, MATCHCHAR being nil or the character to match (which is | |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
2457 relevant only when the syntax code is of an open or close type). |
| 460 | 2458 */ ); |
| 2459 lookup_syntax_properties = 1; | |
| 2460 | |
| 428 | 2461 DEFVAR_BOOL ("words-include-escapes", &words_include_escapes /* |
|
5544
c2301b2c88c8
Improve documentation of syntax table internals.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5543
diff
changeset
|
2462 If non-nil, `forward-word' etc. treat escape characters as parts of words. |
| 428 | 2463 */ ); |
| 434 | 2464 words_include_escapes = 0; |
| 428 | 2465 |
| 2466 no_quit_in_re_search = 0; | |
| 1296 | 2467 |
| 2468 Vbogus_syntax_table_value = make_float (0.0); | |
| 2469 staticpro (&Vbogus_syntax_table_value); | |
| 428 | 2470 } |
| 2471 | |
| 2472 static void | |
| 3540 | 2473 define_standard_syntax (const UExtbyte *p, enum syntaxcode syn) |
| 428 | 2474 { |
| 2475 for (; *p; p++) | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2476 Fput_char_table (make_char (*p), make_fixnum (syn), Vstandard_syntax_table); |
| 428 | 2477 } |
| 2478 | |
| 2479 void | |
| 2480 complex_vars_of_syntax (void) | |
| 2481 { | |
| 867 | 2482 Ichar i; |
| 3540 | 2483 const UExtbyte *p; /* Latin-1, not internal format. */ |
| 2484 | |
| 2485 #define SET_RANGE_SYNTAX(start, end, syntax) \ | |
| 2486 do { \ | |
| 2487 for (i = start; i <= end; i++) \ | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2488 Fput_char_table(make_char(i), make_fixnum(syntax), \ |
| 3540 | 2489 Vstandard_syntax_table); \ |
| 2490 } while (0) | |
| 2491 | |
| 2492 /* Set this now, so first buffer creation can refer to it. | |
| 2493 | |
| 2494 Make it nil before calling copy-syntax-table so that copy-syntax-table | |
| 2495 will know not to try to copy from garbage */ | |
| 428 | 2496 Vstandard_syntax_table = Qnil; |
| 2497 Vstandard_syntax_table = Fcopy_syntax_table (Qnil); | |
| 2498 staticpro (&Vstandard_syntax_table); | |
| 2499 | |
| 826 | 2500 Vtemp_table_for_use_updating_syntax_tables = Fmake_char_table (Qgeneric); |
| 2501 staticpro (&Vtemp_table_for_use_updating_syntax_tables); | |
| 2502 | |
| 428 | 2503 Vsyntax_designator_chars_string = make_string_nocopy (syntax_code_spec, |
| 2504 Smax); | |
| 2505 staticpro (&Vsyntax_designator_chars_string); | |
| 2506 | |
| 3540 | 2507 /* Default character syntax is word. */ |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2508 set_char_table_default (Vstandard_syntax_table, make_fixnum (Sword)); |
| 428 | 2509 |
| 3540 | 2510 /* Control 0; treat as punctuation */ |
| 2511 SET_RANGE_SYNTAX(0, 32, Spunct); | |
| 428 | 2512 |
| 3544 | 2513 /* The whitespace--overwriting some of the above changes. |
| 2514 | |
| 2515 String literals are const char *s, not const unsigned char *s. */ | |
|
4653
25e5e5346d31
?\012 is whitespace, as it always should have been, thank you Karl Kleinpaste.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4141
diff
changeset
|
2516 define_standard_syntax((const UExtbyte *)" \t\015\014\012", Swhitespace); |
| 3540 | 2517 |
| 2518 /* DEL plus Control 1 */ | |
| 2519 SET_RANGE_SYNTAX(127, 159, Spunct); | |
| 2520 | |
| 3544 | 2521 define_standard_syntax ((const UExtbyte *)"\"", Sstring); |
| 2522 define_standard_syntax ((const UExtbyte *)"\\", Sescape); | |
| 2523 define_standard_syntax ((const UExtbyte *)"_-+*/&|<>=", Ssymbol); | |
| 2524 define_standard_syntax ((const UExtbyte *)".,;:?!#@~^'`", Spunct); | |
| 428 | 2525 |
| 3544 | 2526 for (p = (const UExtbyte *)"()[]{}"; *p; p+=2) |
| 428 | 2527 { |
| 2528 Fput_char_table (make_char (p[0]), | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2529 Fcons (make_fixnum (Sopen), make_char (p[1])), |
| 428 | 2530 Vstandard_syntax_table); |
| 2531 Fput_char_table (make_char (p[1]), | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5552
diff
changeset
|
2532 Fcons (make_fixnum (Sclose), make_char (p[0])), |
| 428 | 2533 Vstandard_syntax_table); |
| 2534 } | |
| 3540 | 2535 |
| 2536 /* Latin 1 "symbols." This contrasts with the FSF, where they're word | |
| 2537 constituents. */ | |
| 2538 SET_RANGE_SYNTAX(0240, 0277, Ssymbol); | |
| 2539 | |
| 2540 /* The guillemets. These are not parentheses, in contrast to what the old | |
| 2541 code did. */ | |
| 3569 | 2542 define_standard_syntax((const UExtbyte *)"\253\273", Spunct); |
| 3540 | 2543 |
| 2544 /* The inverted exclamation mark, and the multiplication and division | |
| 2545 signs. */ | |
| 3544 | 2546 define_standard_syntax((const UExtbyte *)"\241\327\367", Spunct); |
| 3540 | 2547 |
| 2548 #undef SET_RANGE_SYNTAX | |
| 428 | 2549 } |