Mercurial > hg > xemacs-beta
annotate src/extents-impl.h @ 5882:bbe4146603db
Reduce regexp usage, now CL-oriented non-regexp code available, core Lisp
lisp/ChangeLog addition:
2015-04-01 Aidan Kehoe <kehoea@parhasard.net>
When calling #'string-match with a REGEXP without regular
expression special characters, call #'search, #'mismatch, #'find,
etc. instead, making our code less likely to side-effect other
functions' match data and a little faster.
* apropos.el (apropos-command):
* apropos.el (apropos):
Call (position ?\n ...) rather than (string-match "\n" ...) here.
* buff-menu.el:
* buff-menu.el (buffers-menu-omit-invisible-buffers):
Don't fire up the regexp engine just to check if a string starts
with a space.
* buff-menu.el (select-buffers-tab-buffers-by-mode):
Don't fire up the regexp engine just to compare mode basenames.
* buff-menu.el (format-buffers-tab-line):
* buff-menu.el (build-buffers-tab-internal): Moved to being a
label within the following.
* buff-menu.el (buffers-tab-items): Use the label.
* bytecomp.el (byte-compile-log-1):
Don't fire up the regexp engine just to look for a newline.
* cus-edit.el (get):
Ditto.
* cus-edit.el (custom-variable-value-create):
Ditto, but for a colon.
* descr-text.el (describe-text-sexp):
Ditto.
* descr-text.el (describe-char-unicode-data):
Use #'split-string-by-char given that we're just looking for a
semicolon.
* descr-text.el (describe-char):
Don't fire up the regexp engine just to look for a newline.
* disass.el (disassemble-internal):
Ditto.
* files.el (file-name-sans-extension):
Implement this using #'position.
* files.el (file-name-extension):
Correct this function's docstring, implement it in terms of
#'position.
* files.el (insert-directory):
Don't fire up the regexp engine to split a string by space; don't
reverse the list of switches, this is actually a longstand bug as
far as I can see.
* gnuserv.el (gnuserv-process-filter):
Use #'position here, instead of consing inside #'split-string
needlessly.
* gtk-file-dialog.el (gtk-file-dialog-update-dropdown):
Use #'split-string-by-char here, don't fire up #'split-string for
directory-sep-char.
* gtk-font-menu.el (hack-font-truename):
Implement this more cheaply in terms of #'find,
#'split-string-by-char, #'equal, rather than #'string-match,
#'split-string, #'string-equal.
* hyper-apropos.el (hyper-apropos-grok-functions):
* hyper-apropos.el (hyper-apropos-grok-variables):
Look for a newline using #'position rather than #'string-match in
these functions.
* info.el (Info-insert-dir):
* info.el (Info-insert-file-contents):
* info.el (Info-follow-reference):
* info.el (Info-extract-menu-node-name):
* info.el (Info-menu):
Look for fixed strings using #'position or #'search as appropriate
in this file.
* ldap.el (ldap-decode-string):
* ldap.el (ldap-encode-string):
#'encode-coding-string, #'decode-coding-string are always
available, don't check if they're fboundp.
* ldap.el (ldap-decode-address):
* ldap.el (ldap-encode-address):
Use #'split-string-by-char in these functions.
* lisp-mnt.el (lm-creation-date):
* lisp-mnt.el (lm-last-modified-date):
Don't fire up the regexp engine just to look for spaces in this file.
* menubar-items.el (default-menubar):
Use (not (mismatch ...)) rather than #'string-match here, for
simple regexp.
Use (search "beta" ...) rather than (string-match "beta" ...)
* menubar-items.el (sort-buffers-menu-alphabetically):
* menubar-items.el (sort-buffers-menu-by-mode-then-alphabetically):
* menubar-items.el (group-buffers-menu-by-mode-then-alphabetically):
Don't fire up the regexp engine to check if a string starts with
a space or an asterisk.
Use the more fine-grained results of #'compare-strings; compare
case-insensitively for the buffer menu.
* menubar-items.el (list-all-buffers):
* menubar-items.el (tutorials-menu-filter):
Use #'equal rather than #'string-equal, which, in this context,
has the drawback of not having a bytecode, and no redeeming
features.
* minibuf.el:
* minibuf.el (un-substitute-in-file-name):
Use #'count, rather than counting the occurences of $ using the
regexp engine.
* minibuf.el (read-file-name-internal-1):
Don't fire up the regexp engine to search for ?=.
* mouse.el (mouse-eval-sexp):
Check for newline with #'find.
* msw-font-menu.el (mswindows-reset-device-font-menus):
Split a string by newline with #'split-string-by-char.
* mule/japanese.el:
* mule/japanese.el ("Japanese"):
Use #'search rather than #'string-match; canoncase before
comparing; fix a bug I had introduced where I had been making case
insensitive comparisons where the case mattered.
* mule/korea-util.el (default-korean-keyboard):
Look for ?3 using #'find, not #'string-march.
* mule/korea-util.el (quail-hangul-switch-hanja):
Search for a fixed string using #'search.
* mule/mule-cmds.el (set-locale-for-language-environment):
#'position, #'substitute rather than #'string-match,
#'replace-in-string.
* newcomment.el (comment-make-extra-lines):
Use #'search rather than #'string-match for a simple string.
* package-get.el (package-get-remote-filename):
Use #'position when looking for ?@
* process.el (setenv):
* process.el (read-envvar-name):
Use #'position when looking for ?=.
* replace.el (map-query-replace-regexp):
Use #'split-string-by-char instead of using an inline
implementation of it.
* select.el (select-convert-from-cf-text):
* select.el (select-convert-from-cf-unicodetext):
Use #'position rather than #'string-match in these functions.
* setup-paths.el (paths-emacs-data-root-p):
Use #'search when looking for simple string.
* sound.el (load-sound-file):
Use #'split-string-by-char rather than an inline reimplementation
of same.
* startup.el (splash-screen-window-body):
* startup.el (splash-screen-tty-body):
Search for simple strings using #'search.
* version.el (emacs-version):
Ditto.
* x-font-menu.el (hack-font-truename):
Implement this more cheaply in terms of #'find,
#'split-string-by-char, #'equal, rather than #'string-match,
#'split-string, #'string-equal.
* x-font-menu.el (x-reset-device-font-menus-core):
Use #'split-string-by-char here.
* x-init.el (x-initialize-keyboard):
Search for a simple string using #'search.
author | Aidan Kehoe <kehoea@parhasard.net> |
---|---|
date | Wed, 01 Apr 2015 14:28:20 +0100 |
parents | 308d34e9f07d |
children |
rev | line source |
---|---|
872 | 1 /* Copyright (c) 1994, 1995 Free Software Foundation. |
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
2 Copyright (c) 1995, 1996, 2002, 2010 Ben Wing. |
872 | 3 |
4 This file is part of XEmacs. | |
5 | |
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5127
diff
changeset
|
6 XEmacs is free software: you can redistribute it and/or modify it |
872 | 7 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:
5127
diff
changeset
|
8 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:
5127
diff
changeset
|
9 option) any later version. |
872 | 10 |
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
14 for more details. | |
15 | |
16 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:
5127
diff
changeset
|
17 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
872 | 18 |
19 /* Synched up with: Not in FSF. */ | |
20 | |
21 #ifndef INCLUDED_extents_impl_h_ | |
22 #define INCLUDED_extents_impl_h_ | |
23 | |
24 #include "extents.h" | |
25 | |
26 struct extent | |
27 { | |
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
3017
diff
changeset
|
28 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
872 | 29 |
30 Memxpos start; | |
31 Memxpos end; | |
32 Lisp_Object object; /* A buffer, string, Qnil (extent detached from no | |
33 buffer), Qt (destroyed extent) */ | |
34 | |
35 /* Extent properties are conceptually a plist, but the most common | |
36 props are implemented as bits instead of conses. */ | |
37 struct | |
38 { | |
39 Lisp_Object face; | |
40 | |
41 /* These flags are simply an optimization for common boolean properties | |
42 which go onto the extent's property list. Any of them would work if | |
43 done in the normal way, but the space savings of doing these in this | |
44 way is significant. Note that if you add a flag, there are numerous | |
45 places in extents.c that need to know about it. | |
46 | |
47 Another consideration is that some of these properties are accessed | |
48 during redisplay, so it's good for access to them to be fast (a bit | |
49 reference instead of a search down a plist). | |
50 | |
51 `begin_glyph_layout' and `end_glyph_layout' are unusual in that | |
52 they have 4 states instead of 2. | |
53 | |
54 Other special extent properties are stored in an auxiliary | |
55 structure that sits at the beginning of the plist. The has_aux | |
56 flag indicates whether this structure exists. The has_parent | |
57 flag is an optimization indicating whether the extent has a parent | |
58 (this could also be determined by looking in the aux structure). */ | |
59 | |
60 enum_field (glyph_layout) begin_glyph_layout :2; | |
61 /* 2 text, margins, or whitespace */ | |
62 enum_field (glyph_layout) end_glyph_layout :2; | |
63 /* 4 text, margins, or whitespace */ | |
64 unsigned int has_parent :1; /* 5 extent has a parent */ | |
65 unsigned int has_aux :1; /* 6 extent has an aux. structure */ | |
66 unsigned int start_open :1; /* 7 insertion behavior at start */ | |
67 unsigned int end_open :1; /* 8 insertion behavior at end */ | |
68 unsigned int unique :1; /* 9 there may be only one attached */ | |
69 unsigned int duplicable :1; /* 10 copied to strings by kill/undo */ | |
70 unsigned int detachable :1; /* 11 extent detaches if text deleted */ | |
71 unsigned int internal :1; /* 12 used by map-extents etc. */ | |
72 unsigned int in_red_event :1; /* 13 An event has been spawned for | |
73 initial redisplay. | |
74 (not exported to lisp) */ | |
75 unsigned int unused16 :1; /* 16 unused bits */ | |
76 /* --- Adding more flags will cause the extent struct to grow by another | |
77 word. It's not clear that this would make a difference, however, | |
78 because on 32-bit machines things tend to get allocated in chunks | |
79 of 4 bytes. */ | |
80 } flags; | |
81 /* The plist may have an auxiliary structure as its first element */ | |
82 Lisp_Object plist; | |
83 }; | |
84 | |
85 /* Basic properties of an extent (not affected by the extent's parent) */ | |
86 #define extent_object(e) ((e)->object) | |
87 #define extent_start(e) ((e)->start + 0) | |
88 #define extent_end(e) ((e)->end + 0) | |
89 #define set_extent_start(e, val) ((void) ((e)->start = (val))) | |
90 #define set_extent_end(e, val) ((void) ((e)->end = (val))) | |
91 #define extent_endpoint(e, endp) ((endp) ? extent_end (e) : extent_start (e)) | |
92 #define set_extent_endpoint(e, val, endp) \ | |
93 ((endp) ? set_extent_end (e, val) : set_extent_start (e, val)) | |
94 #define extent_detached_p(e) (extent_start (e) < 0) | |
95 | |
96 /* Additional information that may be present in an extent. The idea is | |
97 that fast access is provided to this information, but since (hopefully) | |
98 most extents won't have this set on them, we usually don't need to | |
99 have this structure around and thus the size of an extent is smaller. */ | |
100 | |
101 typedef struct extent_auxiliary extent_auxiliary; | |
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
102 |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
103 #define EXTENT_AUXILIARY_SLOTS \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
104 SLOT (begin_glyph) \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
105 SLOT (end_glyph) \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
106 SLOT (parent) \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
107 /* We use a weak list here. Originally I didn't do this and \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
108 depended on having the extent's finalization method remove \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
109 itself from its parent's children list. This runs into \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
110 lots and lots of problems though because everything is in \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
111 a really really bizarre state when an extent's finalization \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
112 method is called (it happens in sweep_extents() by way of \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
113 ADDITIONAL_FREE_extent()) and it's extremely difficult to \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
114 avoid getting hosed by just-freed objects. */ \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
115 SLOT (children) \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
116 SLOT (invisible) \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
117 SLOT (read_only) \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
118 SLOT (mouse_face) \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
119 SLOT (initial_redisplay_function) \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
120 SLOT (before_change_functions) \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
121 SLOT (after_change_functions) |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
122 |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
123 |
872 | 124 struct extent_auxiliary |
125 { | |
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
126 NORMAL_LISP_OBJECT_HEADER header; |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
127 #define SLOT(x) Lisp_Object x; |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
128 EXTENT_AUXILIARY_SLOTS |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
129 #undef SLOT |
872 | 130 int priority; |
131 }; | |
132 | |
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
133 extern Lisp_Object Vextent_auxiliary_defaults; |
872 | 134 |
135 struct extent_info | |
136 { | |
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
137 NORMAL_LISP_OBJECT_HEADER header; |
872 | 138 |
139 struct extent_list *extents; | |
140 struct stack_of_extents *soe; | |
141 }; | |
142 | |
143 /* A "normal" field is one that is stored in the `struct flags' structure | |
144 in an extent. an "aux" field is one that is stored in the extent's | |
145 auxiliary structure. | |
146 | |
147 The functions below that have `extent_no_chase' in their name operate | |
148 on an extent directly (ignoring its parent), and should normally | |
149 only be used on extents known not to have a parent. The other | |
150 versions chase down any parent links. */ | |
151 | |
152 #define extent_no_chase_normal_field(e, field) ((e)->flags.field) | |
153 | |
154 DECLARE_INLINE_HEADER ( | |
155 struct extent_auxiliary * | |
156 extent_aux_or_default (EXTENT e) | |
157 ) | |
158 { | |
159 return e->flags.has_aux ? | |
160 XEXTENT_AUXILIARY (XCAR (e->plist)) : | |
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
161 XEXTENT_AUXILIARY (Vextent_auxiliary_defaults); |
872 | 162 } |
163 | |
164 #define extent_no_chase_aux_field(e, field) (extent_aux_or_default(e)->field) | |
165 | |
166 #define extent_normal_field(e, field) \ | |
167 extent_no_chase_normal_field (extent_ancestor (e), field) | |
168 | |
169 #define extent_aux_field(e, field) \ | |
170 extent_no_chase_aux_field (extent_ancestor (e), field) | |
171 | |
172 #define set_extent_no_chase_aux_field(e, field, value) do { \ | |
173 EXTENT sencaf_e = (e); \ | |
174 if (! sencaf_e->flags.has_aux) \ | |
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
175 attach_extent_auxiliary (sencaf_e); \ |
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
176 XEXTENT_AUXILIARY (XCAR (sencaf_e->plist))->field = (value); \ |
872 | 177 } while (0) |
178 | |
179 #define set_extent_no_chase_normal_field(e, field, value) \ | |
180 extent_no_chase_normal_field (e, field) = (value) | |
181 | |
182 #define set_extent_aux_field(e, field, value) \ | |
183 set_extent_no_chase_aux_field (extent_ancestor (e), field, value) | |
184 | |
185 #define set_extent_normal_field(e, field, value) \ | |
186 set_extent_no_chase_normal_field (extent_ancestor (e), field, value) | |
187 | |
188 /* The `parent' and `children' fields are not affected by any | |
189 parent links. We don't provide any settors for these fields | |
190 because they need special handling and it's cleaner just to | |
191 do this in the particular functions that need to do this. */ | |
192 | |
193 #define extent_parent(e) extent_no_chase_aux_field (e, parent) | |
194 #define extent_children(e) extent_no_chase_aux_field (e, children) | |
195 | |
196 EXTENT extent_ancestor_1 (EXTENT e); | |
197 | |
198 /* extent_ancestor() chases all the parent links until there aren't any | |
199 more. extent_ancestor_1() does the same thing but it a function; | |
200 the following optimizes the most common case. */ | |
201 DECLARE_INLINE_HEADER ( | |
202 EXTENT | |
203 extent_ancestor (EXTENT e) | |
204 ) | |
205 { | |
206 return e->flags.has_parent ? extent_ancestor_1 (e) : e; | |
207 } | |
208 | |
209 #define extent_begin_glyph(e) extent_aux_field (e, begin_glyph) | |
210 #define extent_end_glyph(e) extent_aux_field (e, end_glyph) | |
211 #define extent_priority(e) extent_aux_field (e, priority) | |
212 #define extent_invisible(e) extent_aux_field (e, invisible) | |
213 #define extent_read_only(e) extent_aux_field (e, read_only) | |
214 #define extent_mouse_face(e) extent_aux_field (e, mouse_face) | |
215 #define extent_initial_redisplay_function(e) extent_aux_field (e, initial_redisplay_function) | |
216 #define extent_before_change_functions(e) extent_aux_field (e, before_change_functions) | |
217 #define extent_after_change_functions(e) extent_aux_field (e, after_change_functions) | |
218 | |
219 #define set_extent_begin_glyph(e, value) \ | |
220 set_extent_aux_field (e, begin_glyph, value) | |
221 #define set_extent_end_glyph(e, value) \ | |
222 set_extent_aux_field (e, end_glyph, value) | |
223 #define set_extent_priority(e, value) \ | |
224 set_extent_aux_field (e, priority, value) | |
225 #define set_extent_invisible_1(e, value) \ | |
226 set_extent_aux_field (e, invisible, value) | |
227 #define set_extent_read_only(e, value) \ | |
228 set_extent_aux_field (e, read_only, value) | |
229 #define set_extent_mouse_face(e, value) \ | |
230 set_extent_aux_field (e, mouse_face, value) | |
231 /* Use Fset_extent_initial_redisplay_function unless you know what you're doing */ | |
232 #define set_extent_initial_redisplay_function(e, value) \ | |
233 set_extent_aux_field (e, initial_redisplay_function, value) | |
234 #define set_extent_before_change_functions(e, value) \ | |
235 set_extent_aux_field (e, before_change_functions, value) | |
236 #define set_extent_after_change_functions(e, value) \ | |
237 set_extent_aux_field (e, after_change_functions, value) | |
238 | |
239 #define extent_face(e) extent_normal_field (e, face) | |
240 #define extent_begin_glyph_layout(e) ((enum glyph_layout) extent_normal_field (e, begin_glyph_layout)) | |
241 #define extent_end_glyph_layout(e) ((enum glyph_layout) extent_normal_field (e, end_glyph_layout)) | |
242 #define extent_start_open_p(e) extent_normal_field (e, start_open) | |
243 #define extent_end_open_p(e) extent_normal_field (e, end_open) | |
244 #define extent_unique_p(e) extent_normal_field (e, unique) | |
245 #define extent_duplicable_p(e) extent_normal_field (e, duplicable) | |
246 #define extent_detachable_p(e) extent_normal_field (e, detachable) | |
247 #define extent_internal_p(e) extent_normal_field (e, internal) | |
248 #define extent_in_red_event_p(e) extent_normal_field (e, in_red_event) | |
249 | |
250 #define set_extent_face(e, val) \ | |
251 set_extent_normal_field (e, face, val) | |
252 #define set_extent_begin_glyph_layout(e, val) \ | |
253 set_extent_normal_field (e, begin_glyph_layout, val) | |
254 #define set_extent_end_glyph_layout(e, val) \ | |
255 set_extent_normal_field (e, end_glyph_layout, val) | |
256 #define set_extent_start_open_p(e, val) \ | |
257 set_extent_normal_field (e, start_open, val) | |
258 #define set_extent_end_open_p(e, val) \ | |
259 set_extent_normal_field (e, end_open, val) | |
260 #define set_extent_unique_p(e, val) \ | |
261 set_extent_normal_field (e, unique, val) | |
262 #define set_extent_duplicable_p(e, val) \ | |
263 set_extent_normal_field (e, duplicable, val) | |
264 #define set_extent_detachable_p(e, val) \ | |
265 set_extent_normal_field (e, detachable, val) | |
266 #define set_extent_internal_p(e, val) \ | |
267 set_extent_normal_field (e, internal, val) | |
268 #define set_extent_in_red_event_p(e, val) \ | |
269 set_extent_normal_field (e, in_red_event, val) | |
270 | |
271 DECLARE_INLINE_HEADER ( | |
272 Lisp_Object * | |
273 extent_no_chase_plist_addr (EXTENT e) | |
274 ) | |
275 { | |
276 return e->flags.has_aux ? &XCDR (e->plist) : &e->plist; | |
277 } | |
278 | |
279 #define extent_no_chase_plist(e) (*extent_no_chase_plist_addr (e)) | |
280 | |
281 #define extent_plist_addr(e) extent_no_chase_plist_addr (extent_ancestor (e)) | |
282 #define extent_plist_slot(e) extent_no_chase_plist (extent_ancestor (e)) | |
283 | |
284 | |
285 #define EXTENT_LIVE_P(e) (!EQ (extent_object (e), Qt)) | |
286 | |
287 #define CHECK_LIVE_EXTENT(x) do { \ | |
288 CHECK_EXTENT (x); \ | |
289 if (!EXTENT_LIVE_P (XEXTENT (x))) \ | |
290 dead_wrong_type_argument (Qextent_live_p, (x)); \ | |
291 } while (0) | |
292 #define CONCHECK_LIVE_EXTENT(x) do { \ | |
293 CONCHECK_EXTENT (x); \ | |
294 if (!EXTENT_LIVE_P (XEXTENT (x))) \ | |
295 x = wrong_type_argument (Qextent_live_p, (x)); \ | |
296 } while (0) | |
297 | |
298 #endif /* INCLUDED_extents_impl_h_ */ |