Mercurial > hg > xemacs-beta
annotate src/syntax.h @ 5124:623d57b7fbe8 ben-lisp-object
separate regular and disksave finalization, print method fixes.
Create separate disksave method and make the finalize method only be for
actual object finalization, not disksave finalization.
Fix places where 0 was given in place of a printer -- print methods are
mandatory, and internal objects formerly without a print method now must
explicitly specify internal_object_printer().
Change the defn of CONSOLE_LIVE_P to avoid problems in some weird situations.
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-01-20 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (very_old_free_lcrecord):
* alloc.c (disksave_object_finalization_1):
* alloc.c (make_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (sweep_lcrecords_1):
* buffer.c:
* bytecode.c:
* bytecode.c (Fcompiled_function_p):
* chartab.c:
* console-impl.h:
* console-impl.h (CONSOLE_TYPE_P):
* console.c:
* console.c (set_quit_events):
* data.c:
* data.c (Fmake_ephemeron):
* database.c:
* database.c (finalize_database):
* database.c (Fclose_database):
* device-msw.c:
* device-msw.c (finalize_devmode):
* device-msw.c (allocate_devmode):
* device.c:
* elhash.c:
* elhash.c (finalize_hash_table):
* eval.c:
* eval.c (bind_multiple_value_limits):
* event-stream.c:
* event-stream.c (finalize_command_builder):
* events.c:
* events.c (mark_event):
* extents.c:
* extents.c (finalize_extent_info):
* extents.c (uninit_buffer_extents):
* faces.c:
* file-coding.c:
* file-coding.c (finalize_coding_system):
* file-coding.h:
* file-coding.h (struct coding_system_methods):
* file-coding.h (struct detector):
* floatfns.c:
* floatfns.c (extract_float):
* fns.c:
* fns.c (Fidentity):
* font-mgr.c (finalize_fc_pattern):
* font-mgr.c (finalize_fc_config):
* frame.c:
* glyphs.c:
* glyphs.c (finalize_image_instance):
* glyphs.c (unmap_subwindow_instance_cache_mapper):
* gui.c:
* gui.c (gui_error):
* keymap.c:
* lisp.h (struct Lisp_Symbol):
* lrecord.h:
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* lrecord.h (MC_ALLOC_CALL_FINALIZER_FOR_DISKSAVE):
* lrecord.h (DEFINE_DUMPABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (MAKE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (MAKE_MODULE_LISP_OBJECT):
* lstream.c:
* lstream.c (finalize_lstream):
* lstream.c (disksave_lstream):
* marker.c:
* marker.c (finalize_marker):
* mule-charset.c (make_charset):
* number.c:
* objects.c:
* objects.c (finalize_color_instance):
* objects.c (finalize_font_instance):
* opaque.c:
* opaque.c (make_opaque_ptr):
* process-nt.c:
* process-nt.c (nt_finalize_process_data):
* process-nt.c (nt_deactivate_process):
* process.c:
* process.c (finalize_process):
* procimpl.h (struct process_methods):
* scrollbar.c:
* scrollbar.c (free_scrollbar_instance):
* specifier.c (finalize_specifier):
* symbols.c:
* toolbar.c:
* toolbar.c (Ftoolbar_button_p):
* tooltalk.c:
* ui-gtk.c:
* ui-gtk.c (emacs_gtk_object_finalizer):
* ui-gtk.c (allocate_emacs_gtk_boxed_data):
* window.c:
* window.c (finalize_window):
* window.c (mark_window_as_deleted):
Separate out regular and disksave finalization. Instead of a
FOR_DISKSAVE argument to the finalizer, create a separate object
method `disksaver'. Make `finalizer' have only one argument.
Go through and separate out all finalize methods into finalize
and disksave. Delete lots of thereby redundant disksave checking.
Delete places that signal an error if we attempt to disksave --
all of these objects are non-dumpable and we will get an error
from pdump anyway if we attempt to dump them. After this is done,
only one object remains that has a disksave method -- lstream.
Change DEFINE_*_LISP_OBJECT_WITH_PROPS to DEFINE_*_GENERAL_LISP_OBJECT,
which is used for specifying either property methods or disksave
methods (or in the future, any other less-used methods).
Remove the for_disksave argument to finalize_process_data. Don't
provide a disksaver for processes because no one currently needs
it.
Clean up various places where objects didn't provide a print method.
It was made mandatory in previous changes, and all methods now
either provide their own print method or use internal_object_printer
or external_object_printer.
Change the definition of CONSOLE_LIVE_P to use the contype enum
rather than looking into the conmeths structure -- in some weird
situations with dead objects, the conmeths structure is NULL,
and printing such objects from debug_print() will crash if we try
to look into the conmeths structure.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Wed, 20 Jan 2010 07:05:57 -0600 |
| parents | d1247f3cc363 |
| children | a9c41067dd88 |
| rev | line source |
|---|---|
| 428 | 1 /* Declarations having to do with XEmacs syntax tables. |
| 2 Copyright (C) 1985, 1992, 1993 Free Software Foundation, Inc. | |
| 1296 | 3 Copyright (C) 2002, 2003 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: FSF 19.28. */ | |
| 23 | |
| 440 | 24 #ifndef INCLUDED_syntax_h_ |
| 25 #define INCLUDED_syntax_h_ | |
| 428 | 26 |
| 27 #include "chartab.h" | |
| 28 | |
| 29 /* A syntax table is a type of char table. | |
| 30 | |
| 31 The low 7 bits of the integer is a code, as follows. The 8th bit is | |
| 32 used as the prefix bit flag (see below). | |
| 33 | |
| 34 The values in a syntax table are either integers or conses of | |
| 35 integers and chars. The lowest 7 bits of the integer are the syntax | |
| 36 class. If this is Sinherit, then the actual syntax value needs to | |
| 37 be retrieved from the standard syntax table. | |
| 38 | |
| 39 Since the logic involved in finding the actual integer isn't very | |
| 40 complex, you'd think the time required to retrieve it is not a | |
| 41 factor. If you thought that, however, you'd be wrong, due to the | |
| 42 high number of times (many per character) that the syntax value is | |
| 43 accessed in functions such as scan_lists(). To speed this up, | |
| 44 we maintain a mirror syntax table that contains the actual | |
| 45 integers. We can do this successfully because syntax tables are | |
| 46 now an abstract type, where we control all access. | |
| 47 */ | |
| 48 | |
| 49 enum syntaxcode | |
| 50 { | |
| 51 Swhitespace, /* whitespace character */ | |
| 52 Spunct, /* random punctuation character */ | |
| 53 Sword, /* word constituent */ | |
| 54 Ssymbol, /* symbol constituent but not word constituent */ | |
| 55 Sopen, /* a beginning delimiter */ | |
| 56 Sclose, /* an ending delimiter */ | |
| 57 Squote, /* a prefix character like Lisp ' */ | |
| 58 Sstring, /* a string-grouping character like Lisp " */ | |
| 59 Smath, /* delimiters like $ in TeX. */ | |
| 60 Sescape, /* a character that begins a C-style escape */ | |
| 61 Scharquote, /* a character that quotes the following character */ | |
| 62 Scomment, /* a comment-starting character */ | |
| 63 Sendcomment, /* a comment-ending character */ | |
| 64 Sinherit, /* use the standard syntax table for this character */ | |
| 460 | 65 Scomment_fence, /* Starts/ends comment which is delimited on the |
| 66 other side by a char with the same syntaxcode. */ | |
| 67 Sstring_fence, /* Starts/ends string which is delimited on the | |
| 68 other side by a char with the same syntaxcode. */ | |
| 428 | 69 Smax /* Upper bound on codes that are meaningful */ |
| 70 }; | |
| 71 | |
| 72 enum syntaxcode charset_syntax (struct buffer *buf, Lisp_Object charset, | |
| 73 int *multi_p_out); | |
| 74 | |
| 1296 | 75 void update_syntax_table (Lisp_Object table); |
| 76 | |
| 77 DECLARE_INLINE_HEADER ( | |
| 78 void | |
| 79 update_mirror_syntax_if_dirty (Lisp_Object table) | |
| 80 ) | |
| 81 { | |
| 82 if (XCHAR_TABLE (table)->dirty) | |
| 83 update_syntax_table (table); | |
| 84 } | |
| 85 | |
| 428 | 86 /* Return the syntax code for a particular character and mirror table. */ |
| 87 | |
| 1296 | 88 DECLARE_INLINE_HEADER ( |
| 1315 | 89 int |
| 1296 | 90 SYNTAX_CODE (Lisp_Object table, Ichar c) |
| 91 ) | |
| 92 { | |
| 93 type_checking_assert (XCHAR_TABLE (table)->mirror_table_p); | |
| 94 update_mirror_syntax_if_dirty (table); | |
| 1315 | 95 return XINT (get_char_table_1 (c, table)); |
| 1296 | 96 } |
| 97 | |
| 98 #ifdef NOT_WORTH_THE_EFFORT | |
| 99 | |
| 100 /* Same but skip the dirty check. */ | |
| 101 | |
| 102 DECLARE_INLINE_HEADER ( | |
| 1315 | 103 int |
| 1296 | 104 SYNTAX_CODE_1 (Lisp_Object table, Ichar c) |
| 105 ) | |
| 106 { | |
| 107 type_checking_assert (XCHAR_TABLE (table)->mirror_table_p); | |
| 108 return (enum syntaxcode) XINT (get_char_table_1 (c, table)); | |
| 109 } | |
| 110 | |
| 111 #endif /* NOT_WORTH_THE_EFFORT */ | |
| 428 | 112 |
| 113 #define SYNTAX_FROM_CODE(code) ((enum syntaxcode) ((code) & 0177)) | |
| 826 | 114 |
| 428 | 115 #define SYNTAX(table, c) SYNTAX_FROM_CODE (SYNTAX_CODE (table, c)) |
| 116 | |
| 826 | 117 DECLARE_INLINE_HEADER ( |
| 118 int | |
| 867 | 119 WORD_SYNTAX_P (Lisp_Object table, Ichar c) |
| 826 | 120 ) |
| 428 | 121 { |
| 122 return SYNTAX (table, c) == Sword; | |
| 123 } | |
| 124 | |
| 125 /* OK, here's a graphic diagram of the format of the syntax values: | |
| 126 | |
| 127 Bit number: | |
| 128 | |
| 129 [ 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 ] | |
| 130 [ 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 ] | |
| 131 | |
| 132 <-----> <-----> <-------------> <-------------> ^ <-----------> | |
| 133 ELisp unused |comment bits | unused | syntax code | |
| 134 tag | | | | | | | | | | |
| 135 stuff | | | | | | | | | | |
| 136 | | | | | | | | | | |
| 137 | | | | | | | | `--> prefix flag | |
| 138 | | | | | | | | | |
| 139 | | | | | | | `--> comment end style B, second char | |
| 140 | | | | | | `----> comment end style A, second char | |
| 141 | | | | | `------> comment end style B, first char | |
| 142 | | | | `--------> comment end style A, first char | |
| 143 | | | `----------> comment start style B, second char | |
| 144 | | `------------> comment start style A, second char | |
| 145 | `--------------> comment start style B, first char | |
| 146 `----------------> comment start style A, first char | |
| 147 | |
| 148 In a 64-bit integer, there would be 32 more unused bits between | |
| 149 the tag and the comment bits. | |
| 150 | |
| 151 Clearly, such a scheme will not work for Mule, because the matching | |
| 3498 | 152 paren could be any character and as such requires 21 bits, which |
| 428 | 153 we don't got. |
| 154 | |
| 155 Remember that under Mule we use char tables instead of vectors. | |
| 156 So what we do is use another char table for the matching paren | |
| 157 and store a pointer to it in the first char table. (This frees | |
| 158 code from having to worry about passing two tables around.) | |
| 159 */ | |
| 160 | |
| 161 | |
| 162 /* The prefix flag bit for backward-prefix-chars is now put into bit 7. */ | |
| 163 | |
| 164 #define SYNTAX_PREFIX(table, c) \ | |
| 165 ((SYNTAX_CODE (table, c) >> 7) & 1) | |
| 166 | |
| 167 /* Bits 23-16 are used to implement up to two comment styles | |
| 168 in a single buffer. They have the following meanings: | |
| 169 | |
| 170 1. first of a one or two character comment-start sequence of style a. | |
| 171 2. first of a one or two character comment-start sequence of style b. | |
| 172 3. second of a two-character comment-start sequence of style a. | |
| 173 4. second of a two-character comment-start sequence of style b. | |
| 174 5. first of a one or two character comment-end sequence of style a. | |
| 175 6. first of a one or two character comment-end sequence of style b. | |
| 176 7. second of a two-character comment-end sequence of style a. | |
| 177 8. second of a two-character comment-end sequence of style b. | |
| 178 */ | |
| 179 | |
| 180 #define SYNTAX_COMMENT_BITS(table, c) \ | |
| 181 ((SYNTAX_CODE (table, c) >> 16) &0xff) | |
| 182 | |
| 183 #define SYNTAX_FIRST_OF_START_A 0x80 | |
| 184 #define SYNTAX_FIRST_OF_START_B 0x40 | |
| 185 #define SYNTAX_SECOND_OF_START_A 0x20 | |
| 186 #define SYNTAX_SECOND_OF_START_B 0x10 | |
| 187 #define SYNTAX_FIRST_OF_END_A 0x08 | |
| 188 #define SYNTAX_FIRST_OF_END_B 0x04 | |
| 189 #define SYNTAX_SECOND_OF_END_A 0x02 | |
| 190 #define SYNTAX_SECOND_OF_END_B 0x01 | |
| 191 | |
| 192 #define SYNTAX_COMMENT_STYLE_A 0xaa | |
| 193 #define SYNTAX_COMMENT_STYLE_B 0x55 | |
| 194 #define SYNTAX_FIRST_CHAR_START 0xc0 | |
| 195 #define SYNTAX_FIRST_CHAR_END 0x0c | |
| 196 #define SYNTAX_FIRST_CHAR 0xcc | |
| 197 #define SYNTAX_SECOND_CHAR_START 0x30 | |
| 198 #define SYNTAX_SECOND_CHAR_END 0x03 | |
| 199 #define SYNTAX_SECOND_CHAR 0x33 | |
| 200 | |
| 826 | 201 #if 0 |
| 202 | |
| 203 /* #### Entirely unused. Should they be deleted? */ | |
| 428 | 204 |
| 442 | 205 /* #### These are now more or less equivalent to |
| 206 SYNTAX_COMMENT_MATCH_START ...*/ | |
| 207 /* a and b must be first and second start chars for a common type */ | |
| 208 #define SYNTAX_START_P(table, a, b) \ | |
| 209 (((SYNTAX_COMMENT_BITS (table, a) & SYNTAX_FIRST_CHAR_START) >> 2) \ | |
| 210 & (SYNTAX_COMMENT_BITS (table, b) & SYNTAX_SECOND_CHAR_START)) | |
| 211 | |
| 212 /* ... and SYNTAX_COMMENT_MATCH_END */ | |
| 213 /* a and b must be first and second end chars for a common type */ | |
| 214 #define SYNTAX_END_P(table, a, b) \ | |
| 215 (((SYNTAX_COMMENT_BITS (table, a) & SYNTAX_FIRST_CHAR_END) >> 2) \ | |
| 216 & (SYNTAX_COMMENT_BITS (table, b) & SYNTAX_SECOND_CHAR_END)) | |
| 428 | 217 |
| 218 #define SYNTAX_STYLES_MATCH_START_P(table, a, b, mask) \ | |
| 219 ((SYNTAX_COMMENT_BITS (table, a) & SYNTAX_FIRST_CHAR_START & (mask)) \ | |
| 220 && (SYNTAX_COMMENT_BITS (table, b) & SYNTAX_SECOND_CHAR_START & (mask))) | |
| 221 | |
| 222 #define SYNTAX_STYLES_MATCH_END_P(table, a, b, mask) \ | |
| 223 ((SYNTAX_COMMENT_BITS (table, a) & SYNTAX_FIRST_CHAR_END & (mask)) \ | |
| 224 && (SYNTAX_COMMENT_BITS (table, b) & SYNTAX_SECOND_CHAR_END & (mask))) | |
| 225 | |
| 226 #define SYNTAX_STYLES_MATCH_1CHAR_P(table, a, mask) \ | |
| 227 ((SYNTAX_COMMENT_BITS (table, a) & (mask))) | |
| 228 | |
| 229 #define STYLE_FOUND_P(table, a, b, startp, style) \ | |
| 230 ((SYNTAX_COMMENT_BITS (table, a) & \ | |
| 231 ((startp) ? SYNTAX_FIRST_CHAR_START : \ | |
| 232 SYNTAX_FIRST_CHAR_END) & (style)) \ | |
| 233 && (SYNTAX_COMMENT_BITS (table, b) & \ | |
| 234 ((startp) ? SYNTAX_SECOND_CHAR_START : \ | |
| 235 SYNTAX_SECOND_CHAR_END) & (style))) | |
| 236 | |
| 237 #define SYNTAX_COMMENT_MASK_START(table, a, b) \ | |
| 238 ((STYLE_FOUND_P (table, a, b, 1, SYNTAX_COMMENT_STYLE_A) \ | |
| 239 ? SYNTAX_COMMENT_STYLE_A \ | |
| 240 : (STYLE_FOUND_P (table, a, b, 1, SYNTAX_COMMENT_STYLE_B) \ | |
| 241 ? SYNTAX_COMMENT_STYLE_B \ | |
| 242 : 0))) | |
| 243 | |
| 244 #define SYNTAX_COMMENT_MASK_END(table, a, b) \ | |
| 245 ((STYLE_FOUND_P (table, a, b, 0, SYNTAX_COMMENT_STYLE_A) \ | |
| 246 ? SYNTAX_COMMENT_STYLE_A \ | |
| 247 : (STYLE_FOUND_P (table, a, b, 0, SYNTAX_COMMENT_STYLE_B) \ | |
| 248 ? SYNTAX_COMMENT_STYLE_B \ | |
| 249 : 0))) | |
| 250 | |
| 251 #define STYLE_FOUND_1CHAR_P(table, a, style) \ | |
| 252 ((SYNTAX_COMMENT_BITS (table, a) & (style))) | |
| 253 | |
| 254 #define SYNTAX_COMMENT_1CHAR_MASK(table, a) \ | |
| 255 ((STYLE_FOUND_1CHAR_P (table, a, SYNTAX_COMMENT_STYLE_A) \ | |
| 256 ? SYNTAX_COMMENT_STYLE_A \ | |
| 257 : (STYLE_FOUND_1CHAR_P (table, a, SYNTAX_COMMENT_STYLE_B) \ | |
| 258 ? SYNTAX_COMMENT_STYLE_B \ | |
| 259 : 0))) | |
| 260 | |
| 826 | 261 #endif /* 0 */ |
| 428 | 262 |
| 263 /* This array, indexed by a character, contains the syntax code which | |
| 264 that character signifies (as a char). | |
| 265 For example, (enum syntaxcode) syntax_spec_code['w'] is Sword. */ | |
| 266 | |
| 442 | 267 extern const unsigned char syntax_spec_code[0400]; |
| 428 | 268 |
| 269 /* Indexed by syntax code, give the letter that describes it. */ | |
| 270 | |
| 442 | 271 extern const unsigned char syntax_code_spec[]; |
| 428 | 272 |
| 665 | 273 Lisp_Object scan_lists (struct buffer *buf, Charbpos from, int count, |
| 428 | 274 int depth, int sexpflag, int no_error); |
| 665 | 275 int char_quoted (struct buffer *buf, Charbpos pos); |
| 428 | 276 |
| 277 /* NOTE: This does not refer to the mirror table, but to the | |
| 278 syntax table itself. */ | |
| 867 | 279 Lisp_Object syntax_match (Lisp_Object table, Ichar ch); |
| 428 | 280 |
| 281 extern int no_quit_in_re_search; | |
| 826 | 282 |
| 283 | |
| 284 /****************************** syntax caches ********************************/ | |
| 460 | 285 |
| 286 extern int lookup_syntax_properties; | |
| 287 | |
| 826 | 288 /* Now that the `syntax-table' property exists, and can override the syntax |
| 289 table or directly specify the syntax, we cache the last place we | |
| 290 retrieved the syntax-table property. This is because, when moving | |
| 291 linearly through text (e.g. in the regex routines or the scanning | |
| 292 routines in syntax.c), we only need to recalculate at the next place the | |
| 293 syntax-table property changes (i.e. not every position), and when we do | |
| 294 need to recalculate, we can update the info from the previous info | |
| 295 faster than if we did the whole calculation from scratch. */ | |
| 460 | 296 struct syntax_cache |
| 297 { | |
| 3092 | 298 #ifdef NEW_GC |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
299 LISP_OBJECT_HEADER header; |
| 3092 | 300 #endif /* NEW_GC */ |
| 826 | 301 int use_code; /* Whether to use syntax_code or |
| 1296 | 302 syntax_table. This is set |
| 303 depending on whether the | |
| 826 | 304 syntax-table property is a |
| 305 syntax table or a syntax | |
| 306 code. */ | |
| 307 int no_syntax_table_prop; /* If non-zero, there was no | |
| 308 `syntax-table' property on the | |
| 309 current range, and so we're | |
| 310 using the buffer's syntax table. | |
| 311 This is important to note because | |
| 312 sometimes the buffer's syntax | |
| 313 table can be changed. */ | |
| 460 | 314 Lisp_Object object; /* The buffer or string the current |
| 826 | 315 syntax cache applies to, or |
| 316 Qnil for a string of text not | |
| 317 coming from a buffer or string. */ | |
| 318 struct buffer *buffer; /* The buffer that supplies the | |
| 319 syntax tables, or 0 for the | |
| 320 standard syntax table. If | |
| 321 OBJECT is a buffer, this will | |
| 322 always be the same buffer. */ | |
| 460 | 323 int syntax_code; /* Syntax code of current char. */ |
| 1296 | 324 Lisp_Object syntax_table; /* Syntax table for current pos. */ |
| 325 Lisp_Object mirror_table; /* Mirror table for this table. */ | |
| 826 | 326 Lisp_Object start, end; /* Markers to keep track of the |
| 327 known region in a buffer. | |
| 328 Formerly we used an internal | |
| 329 extent, but it seems that having | |
| 330 an extent over the entire buffer | |
| 331 causes serious slowdowns in | |
| 332 extent operations! Yuck! */ | |
| 333 Charxpos next_change; /* Position of the next extent | |
| 460 | 334 change. */ |
| 826 | 335 Charxpos prev_change; /* Position of the previous extent |
| 336 change. */ | |
| 460 | 337 }; |
| 826 | 338 |
| 3092 | 339 #ifdef NEW_GC |
| 340 typedef struct syntax_cache Lisp_Syntax_Cache; | |
| 341 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
3498
diff
changeset
|
342 DECLARE_LISP_OBJECT (syntax_cache, Lisp_Syntax_Cache); |
| 3092 | 343 |
| 344 #define XSYNTAX_CACHE(x) \ | |
| 345 XRECORD (x, syntax_cache, Lisp_Syntax_Cache) | |
| 346 #define wrap_syntax_cache(p) wrap_record (p, syntax_cache) | |
| 347 #define SYNTAX_CACHE_P(x) RECORDP (x, syntax_cache) | |
| 348 #define CHECK_SYNTAX_CACHE(x) CHECK_RECORD (x, syntax_cache) | |
| 349 #define CONCHECK_SYNTAX_CACHE(x) CONCHECK_RECORD (x, syntax_cache) | |
| 350 #endif /* NEW_GC */ | |
| 351 | |
| 352 | |
| 353 | |
| 1296 | 354 extern const struct sized_memory_description syntax_cache_description; |
| 355 | |
| 826 | 356 /* Note that the external interface to the syntax-cache uses charpos's, but |
| 3250 | 357 internally we use bytepos's, for speed. */ |
| 460 | 358 |
| 826 | 359 void update_syntax_cache (struct syntax_cache *cache, Charxpos pos, int count); |
| 360 struct syntax_cache *setup_syntax_cache (struct syntax_cache *cache, | |
| 361 Lisp_Object object, | |
| 362 struct buffer *buffer, | |
| 363 Charxpos from, int count); | |
| 364 struct syntax_cache *setup_buffer_syntax_cache (struct buffer *buffer, | |
| 365 Charxpos from, int count); | |
| 460 | 366 |
| 367 /* Make syntax cache state good for CHARPOS, assuming it is | |
| 368 currently good for a position before CHARPOS. */ | |
| 826 | 369 DECLARE_INLINE_HEADER ( |
| 370 void | |
| 371 UPDATE_SYNTAX_CACHE_FORWARD (struct syntax_cache *cache, Charxpos pos) | |
| 372 ) | |
| 373 { | |
| 1315 | 374 /* #### Formerly this function, and the next one, had |
| 375 | |
| 376 if (pos < cache->prev_change || pos >= cache->next_change) | |
| 377 | |
| 378 just like for plain UPDATE_SYNTAX_CACHE. However, sometimes the | |
| 379 value of POS may be invalid (particularly, it may be 0 for a buffer). | |
| 380 FSF has the check at only one end, so let's try the same. */ | |
| 381 if (pos >= cache->next_change) | |
| 826 | 382 update_syntax_cache (cache, pos, 1); |
| 383 } | |
| 460 | 384 |
| 385 /* Make syntax cache state good for CHARPOS, assuming it is | |
| 386 currently good for a position after CHARPOS. */ | |
| 826 | 387 DECLARE_INLINE_HEADER ( |
| 388 void | |
| 389 UPDATE_SYNTAX_CACHE_BACKWARD (struct syntax_cache *cache, Charxpos pos) | |
| 390 ) | |
| 391 { | |
| 1315 | 392 if (pos < cache->prev_change) |
| 826 | 393 update_syntax_cache (cache, pos, -1); |
| 394 } | |
| 460 | 395 |
| 396 /* Make syntax cache state good for CHARPOS */ | |
| 826 | 397 DECLARE_INLINE_HEADER ( |
| 398 void | |
| 399 UPDATE_SYNTAX_CACHE (struct syntax_cache *cache, Charxpos pos) | |
| 400 ) | |
| 401 { | |
| 1315 | 402 if (pos < cache->prev_change || pos >= cache->next_change) |
| 826 | 403 update_syntax_cache (cache, pos, 0); |
| 404 } | |
| 460 | 405 |
| 826 | 406 #define SYNTAX_FROM_CACHE(cache, c) \ |
| 407 SYNTAX_FROM_CODE (SYNTAX_CODE_FROM_CACHE (cache, c)) | |
| 460 | 408 |
| 826 | 409 #define SYNTAX_CODE_FROM_CACHE(cache, c) \ |
| 410 ((cache)->use_code ? (cache)->syntax_code \ | |
| 1296 | 411 : SYNTAX_CODE ((cache)->mirror_table, c)) |
| 412 | |
| 413 #ifdef NOT_WORTH_THE_EFFORT | |
| 414 /* If we really cared about the theoretical performance hit of the dirty | |
| 415 check in SYNTAX_CODE, we could use SYNTAX_CODE_1 and endeavor to always | |
| 416 keep the mirror table clean, e.g. by checking for dirtiness at the time | |
| 417 we set up the syntax cache. There are lots of potential problems, of | |
| 418 course -- incomplete understanding of the possible pathways into the | |
| 419 code, with some that are bypassing the setups, Lisp code being executed | |
| 420 in the meantime that could change things (e.g. QUIT is called in many | |
| 421 functions and could execute arbitrary Lisp very easily), etc. The QUIT | |
| 422 problem is the biggest one, probably, and one of the main reasons it's | |
| 423 probably just not worth it. */ | |
| 424 #define SYNTAX_CODE_FROM_CACHE(cache, c) \ | |
| 425 ((cache)->use_code ? (cache)->syntax_code \ | |
| 426 : SYNTAX_CODE_1 ((cache)->mirror_table, c)) | |
| 427 #endif | |
| 826 | 428 |
| 429 | |
| 430 /***************************** syntax code macros ****************************/ | |
| 460 | 431 |
| 432 #define SYNTAX_CODE_PREFIX(c) \ | |
| 433 ((c >> 7) & 1) | |
| 434 | |
| 435 #define SYNTAX_CODE_COMMENT_BITS(c) \ | |
| 436 ((c >> 16) &0xff) | |
| 437 | |
| 438 #define SYNTAX_CODES_START_P(a, b) \ | |
| 439 (((SYNTAX_CODE_COMMENT_BITS (a) & SYNTAX_FIRST_CHAR_START) >> 2) \ | |
| 440 & (SYNTAX_CODE_COMMENT_BITS (b) & SYNTAX_SECOND_CHAR_START)) | |
| 441 | |
| 442 #define SYNTAX_CODES_END_P(a, b) \ | |
| 443 (((SYNTAX_CODE_COMMENT_BITS (a) & SYNTAX_FIRST_CHAR_END) >> 2) \ | |
| 444 & (SYNTAX_CODE_COMMENT_BITS (b) & SYNTAX_SECOND_CHAR_END)) | |
| 445 | |
| 446 #define SYNTAX_CODES_COMMENT_MASK_START(a, b) \ | |
| 447 (SYNTAX_CODES_MATCH_START_P (a, b, SYNTAX_COMMENT_STYLE_A) \ | |
| 448 ? SYNTAX_COMMENT_STYLE_A \ | |
| 449 : (SYNTAX_CODES_MATCH_START_P (a, b, SYNTAX_COMMENT_STYLE_B) \ | |
| 450 ? SYNTAX_COMMENT_STYLE_B \ | |
| 451 : 0)) | |
| 452 #define SYNTAX_CODES_COMMENT_MASK_END(a, b) \ | |
| 453 (SYNTAX_CODES_MATCH_END_P (a, b, SYNTAX_COMMENT_STYLE_A) \ | |
| 454 ? SYNTAX_COMMENT_STYLE_A \ | |
| 455 : (SYNTAX_CODES_MATCH_END_P (a, b, SYNTAX_COMMENT_STYLE_B) \ | |
| 456 ? SYNTAX_COMMENT_STYLE_B \ | |
| 457 : 0)) | |
| 458 | |
| 459 #define SYNTAX_CODE_START_FIRST_P(a) \ | |
| 460 (SYNTAX_CODE_COMMENT_BITS (a) & SYNTAX_FIRST_CHAR_START) | |
| 461 | |
| 462 #define SYNTAX_CODE_START_SECOND_P(a) \ | |
| 463 (SYNTAX_CODE_COMMENT_BITS (a) & SYNTAX_SECOND_CHAR_START) | |
| 464 | |
| 465 #define SYNTAX_CODE_END_FIRST_P(a) \ | |
| 466 (SYNTAX_CODE_COMMENT_BITS (a) & SYNTAX_FIRST_CHAR_END) | |
| 467 | |
| 468 #define SYNTAX_CODE_END_SECOND_P(a) \ | |
| 469 (SYNTAX_CODE_COMMENT_BITS (a) & SYNTAX_SECOND_CHAR_END) | |
| 470 | |
| 471 | |
| 472 #define SYNTAX_CODES_MATCH_START_P(a, b, mask) \ | |
| 473 ((SYNTAX_CODE_COMMENT_BITS (a) & SYNTAX_FIRST_CHAR_START & (mask)) \ | |
| 474 && (SYNTAX_CODE_COMMENT_BITS (b) \ | |
| 475 & SYNTAX_SECOND_CHAR_START & (mask))) | |
| 476 | |
| 477 #define SYNTAX_CODES_MATCH_END_P(a, b, mask) \ | |
| 478 ((SYNTAX_CODE_COMMENT_BITS (a) & SYNTAX_FIRST_CHAR_END & (mask)) \ | |
| 479 && (SYNTAX_CODE_COMMENT_BITS (b) & SYNTAX_SECOND_CHAR_END & (mask))) | |
| 480 | |
| 481 #define SYNTAX_CODE_MATCHES_1CHAR_P(a, mask) \ | |
| 482 ((SYNTAX_CODE_COMMENT_BITS (a) & (mask))) | |
| 483 | |
| 484 #define SYNTAX_CODE_COMMENT_1CHAR_MASK(a) \ | |
| 485 ((SYNTAX_CODE_MATCHES_1CHAR_P (a, SYNTAX_COMMENT_STYLE_A) \ | |
| 486 ? SYNTAX_COMMENT_STYLE_A \ | |
| 487 : (SYNTAX_CODE_MATCHES_1CHAR_P (a, SYNTAX_COMMENT_STYLE_B) \ | |
| 488 ? SYNTAX_COMMENT_STYLE_B \ | |
| 489 : 0))) | |
| 490 | |
| 491 | |
| 440 | 492 #endif /* INCLUDED_syntax_h_ */ |