|
428
|
1 /* Generic specifier list implementation
|
|
|
2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
|
|
|
3 Copyright (C) 1995 Ben Wing
|
|
|
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: Not in FSF. */
|
|
|
23
|
|
440
|
24 #ifndef INCLUDED_specifier_h_
|
|
|
25 #define INCLUDED_specifier_h_
|
|
428
|
26
|
|
|
27 /*
|
|
|
28 MAGIC SPECIFIERS
|
|
|
29 ================
|
|
|
30
|
|
|
31 Magic specifiers are used to provide fallback values for window
|
|
|
32 system provided specifications, reflecting user preferences on the
|
|
|
33 window system, such as default fonts, colors, scrollbar thickness
|
|
|
34 etc.
|
|
|
35
|
|
|
36 A magic specifier consists of two specifier objects. The first one
|
|
|
37 behaves like a normal specifier in all senses. The second one, a
|
|
|
38 ghost specifier, is a fallback value for the first one, and contains
|
|
|
39 values provided by window system, resources etc. which reflect
|
|
|
40 default settings for values being specified.
|
|
|
41
|
|
|
42 A magic specifier has an "ultimate" fallback value, as any usual
|
|
|
43 specifier does. This value, an inst-list, is stored in the fallback
|
|
|
44 slot of the ghost specifier object.
|
|
|
45
|
|
|
46 Ghost specifiers have the following properties:
|
|
|
47 - Have back pointers to their parent specifiers.
|
|
|
48 - Do not have instance data. Instead, they share parent's instance
|
|
|
49 data.
|
|
|
50 - Have the same methods structure pointer.
|
|
|
51 - Share parent's caching scheme.
|
|
|
52 - Store fallback value instead of their parents.
|
|
|
53
|
|
|
54 Ghost specifiers normally are not modifiable at the lisp level, and
|
|
|
55 only used to supply fallback instance values. They are accessible
|
|
|
56 via (specifier-fallback), but are read-only. Although, under
|
|
|
57 certain rare conditions, modification of ghost objects is allowed.
|
|
|
58 This behavior is controlled by the global variable
|
|
|
59 Vunlock_ghost_specifiers. It is not exposed to lisp, and is set
|
|
|
60 during calls to lisp functions which initialize global, device and
|
|
|
61 frame defaults, such as
|
|
|
62 init-{global,frame,device}-{faces,toolbars,etc}.
|
|
|
63
|
|
|
64 Thus, values supplied by resources or other means of a window system
|
|
|
65 stored in externally unmodifiable ghost objects. Regular lisp code
|
|
|
66 may thus freely modify the normal part of a magic specifier, and
|
|
|
67 removing a specification for a particular domain causes the
|
|
|
68 specification to consider ghost-provided fallback values, or its own
|
|
|
69 fallback value.
|
|
|
70
|
|
|
71 Rules of conduct for magic specifiers
|
|
|
72 -------------------------------------
|
|
|
73 1. recompute_*() functions always operate on the whole specifier
|
|
|
74 when passed only a ghost object, by substituting it with their
|
|
|
75 parent bodily object.
|
|
|
76 2. All specifier methods, except for instantiate method, are passed
|
|
|
77 the bodily object of the magic specifier. Instantiate method is
|
|
|
78 passed the specifier being instantiated.
|
|
|
79 3. Only bodily objects are passed to set_specifier_caching function,
|
|
|
80 and only these may be cached.
|
|
|
81 4. All specifiers are added to Vall_specifiers list, both bodily and
|
|
|
82 ghost. The pair of objects is always removed from the list at the
|
|
|
83 same time.
|
|
|
84 */
|
|
|
85
|
|
|
86 extern const struct struct_description specifier_methods_description;
|
|
|
87
|
|
|
88 struct specifier_methods
|
|
|
89 {
|
|
442
|
90 const char *name;
|
|
428
|
91 Lisp_Object predicate_symbol;
|
|
|
92
|
|
|
93 /* Implementation specific methods: */
|
|
|
94
|
|
|
95 /* Create method: Initialize specifier data. Optional. */
|
|
|
96 void (*create_method) (Lisp_Object specifier);
|
|
|
97
|
|
|
98 /* Mark method: Mark any lisp object within specifier data
|
|
|
99 structure. Not required if no specifier data are Lisp_Objects. */
|
|
|
100 void (*mark_method) (Lisp_Object specifier);
|
|
|
101
|
|
|
102 /* Equal method: Compare two specifiers. This is called after
|
|
|
103 ensuring that the two specifiers are of the same type, and have
|
|
|
104 the same specs. Quit is inhibited during the call so it is safe
|
|
|
105 to call internal_equal().
|
|
|
106
|
|
|
107 If this function is not present, specifiers considered equal when
|
|
|
108 the above conditions are met, i.e. as if the method returned
|
|
|
109 non-zero. */
|
|
|
110 int (*equal_method) (Lisp_Object sp1, Lisp_Object sp2, int depth);
|
|
|
111
|
|
|
112 /* Hash method: Hash specifier instance data. This has to hash only
|
|
|
113 data structure of the specifier, as specs are hashed by the core
|
|
|
114 code.
|
|
|
115
|
|
|
116 If this function is not present, hashing behaves as if it
|
|
|
117 returned zero. */
|
|
|
118 unsigned long (*hash_method) (Lisp_Object specifier, int depth);
|
|
|
119
|
|
|
120 /* Validate method: Given an instantiator, verify that it's
|
|
|
121 valid for this specifier type. If not, signal an error.
|
|
|
122
|
|
|
123 If this function is not present, all instantiators are considered
|
|
|
124 valid. */
|
|
|
125 void (*validate_method) (Lisp_Object instantiator);
|
|
|
126
|
|
434
|
127
|
|
|
128 /* Copy method: Given an instantiator, copy the bits that we need to
|
|
|
129 for this specifier type.
|
|
|
130
|
|
|
131 If this function is not present, then Fcopy_tree is used. */
|
|
|
132 Lisp_Object (*copy_instantiator_method) (Lisp_Object instantiator);
|
|
|
133
|
|
428
|
134 /* Validate-matchspec method: Given a matchspec, verify that it's
|
|
|
135 valid for this specifier type. If not, signal an error.
|
|
|
136
|
|
|
137 If this function is not present, *no* matchspecs are considered
|
|
|
138 valid. Note that this differs from validate_method(). */
|
|
|
139 void (*validate_matchspec_method) (Lisp_Object matchspec);
|
|
|
140
|
|
|
141 /* Instantiate method: Return SPECIFIER instance in DOMAIN,
|
|
|
142 specified by INSTANTIATOR. MATCHSPEC specifies an additional
|
|
|
143 constraints on the instance value (see the docstring for
|
|
|
144 Fspecifier_matching_instance function). MATCHSPEC is passed
|
|
|
145 Qunbound when no matching constraints are imposed. The method is
|
|
|
146 called via call_with_suspended_errors(), so allowed to eval
|
|
|
147 safely.
|
|
|
148
|
|
|
149 DEPTH is a lisp integer denoting current depth of instantiation
|
|
|
150 calls. This parameter should be passed as the initial depth value
|
|
|
151 to functions which also instantiate specifiers (of which I can
|
|
|
152 name specifier_instance) to avoid creating "external"
|
|
|
153 specification loops.
|
|
|
154
|
|
442
|
155 This method must presume that both INSTANTIATOR and MATCHSPEC are
|
|
428
|
156 already validated by the corresponding validate_* methods, and
|
|
|
157 may abort if they are invalid.
|
|
|
158
|
|
|
159 Return value is an instance, which is returned immediately to the
|
|
|
160 caller, or Qunbound to continue instantiation lookup chain.
|
|
|
161
|
|
|
162 If this function is not present, INSTANTIATOR is used as the
|
|
|
163 specifier instance. This is the usual case for "simple"
|
|
|
164 specifiers, like integer and boolean. */
|
|
|
165 Lisp_Object (*instantiate_method) (Lisp_Object specifier,
|
|
|
166 Lisp_Object matchspec,
|
|
|
167 Lisp_Object domain,
|
|
|
168 Lisp_Object instantiator,
|
|
|
169 Lisp_Object depth);
|
|
|
170
|
|
|
171 /* Going-to-add method: Called when an instantiator is about
|
|
|
172 to be added to a specifier. This function can specify
|
|
|
173 that different instantiators should be used instead by
|
|
|
174 returning an inst-list (possibly containing zero elements).
|
|
|
175 If the instantiator is fine as-is, return Qt. The
|
|
|
176 instantiator has been copied with copy-tree, so feel
|
|
|
177 free to reuse parts of it to create a new instantiator.
|
|
|
178 The tag-set, however, is not copied and is not canonicalized
|
|
|
179 (that will be done on the result of this function). */
|
|
|
180 Lisp_Object (*going_to_add_method) (Lisp_Object specifier,
|
|
|
181 Lisp_Object locale,
|
|
|
182 Lisp_Object tag_set,
|
|
|
183 Lisp_Object instantiator);
|
|
|
184
|
|
|
185 /* After-change method: Called when the SPECIFIER has just been
|
|
|
186 changed in LOCALE. The method is called upon:
|
|
|
187 * Removing and adding specs to/from the specifier;
|
|
|
188 * Changing the specifier fallback.
|
|
|
189
|
|
|
190 #### The method may have called more than once per each specifier
|
|
|
191 change.
|
|
|
192
|
|
|
193 #### Do not still know if this can safely eval. */
|
|
|
194 void (*after_change_method) (Lisp_Object specifier,
|
|
|
195 Lisp_Object locale);
|
|
|
196
|
|
771
|
197 /* Specifier extra data: Specifier objects can have extra data,
|
|
|
198 specific to the type of specifier, stored at the end of the
|
|
|
199 object. To have this, a specifier declares a structure of type
|
|
|
200 `struct TYPE_specifier' containing the data and uses
|
|
|
201 INITIALIZE_SPECIFIER_TYPE_WITH_DATA instead of
|
|
|
202 INITIALIZE_SPECIFIER_TYPE. Then, a pointer to the `struct
|
|
|
203 TYPE_specifier' can be obtained from a specifier object using
|
|
|
204 SPECIFIER_TYPE_DATA. */
|
|
|
205
|
|
|
206 /* Pdump description of the extra data; required, and must be named
|
|
|
207 TYPE_specifier_description. Initialized when
|
|
|
208 INITIALIZE_SPECIFIER_TYPE_WITH_DATA is called. */
|
|
428
|
209 const struct lrecord_description *extra_description;
|
|
771
|
210
|
|
|
211 /* Size of extra data structure; initialized when
|
|
|
212 INITIALIZE_SPECIFIER_TYPE_WITH_DATA is called. */
|
|
428
|
213 int extra_data_size;
|
|
|
214 };
|
|
|
215
|
|
|
216 struct Lisp_Specifier
|
|
|
217 {
|
|
|
218 struct lcrecord_header header;
|
|
|
219 struct specifier_methods *methods;
|
|
|
220
|
|
|
221 /* we keep a chained list of all current specifiers, for GC cleanup
|
|
|
222 purposes. Do NOT mark through this, or specifiers will never
|
|
|
223 be GC'd. */
|
|
|
224 Lisp_Object next_specifier;
|
|
|
225
|
|
|
226 /* This is a straight list of instantiators. */
|
|
|
227 Lisp_Object global_specs;
|
|
|
228
|
|
|
229 /* These are all assoc lists where the key is the type of object the
|
|
|
230 list represents (buffer, window, etc.) and the associated list is
|
|
|
231 the actual list of instantiators. */
|
|
|
232 Lisp_Object device_specs;
|
|
|
233 Lisp_Object frame_specs;
|
|
|
234 /* window_specs is actually a key-assoc weak list. See specifier.c
|
|
|
235 for an explanation of why (it boils down to the fact that
|
|
|
236 dead windows can become live again through window configurations).
|
|
|
237 */
|
|
|
238 Lisp_Object window_specs;
|
|
|
239 Lisp_Object buffer_specs;
|
|
|
240
|
|
|
241 struct specifier_caching *caching;
|
|
|
242
|
|
|
243 /* This can be either nil, for a plain, non-magic specifier object,
|
|
|
244 t for the normal part of the magic specifier, or #<specifier> for
|
|
|
245 the ghost part of the magic specifier, a pointer to its parent
|
|
|
246 object */
|
|
|
247 Lisp_Object magic_parent;
|
|
|
248
|
|
|
249 /* Fallback value. For magic specifiers, it is a pointer to the ghost. */
|
|
|
250 Lisp_Object fallback;
|
|
|
251
|
|
|
252 /* type-specific extra data attached to a specifier */
|
|
456
|
253 max_align_t data[1];
|
|
428
|
254 };
|
|
440
|
255 typedef struct Lisp_Specifier Lisp_Specifier;
|
|
428
|
256
|
|
440
|
257 DECLARE_LRECORD (specifier, Lisp_Specifier);
|
|
|
258 #define XSPECIFIER(x) XRECORD (x, specifier, Lisp_Specifier)
|
|
428
|
259 #define XSETSPECIFIER(x, p) XSETRECORD (x, p, specifier)
|
|
617
|
260 #define wrap_specifier(p) wrap_record (p, specifier)
|
|
428
|
261 #define SPECIFIERP(x) RECORDP (x, specifier)
|
|
|
262 #define CHECK_SPECIFIER(x) CHECK_RECORD (x, specifier)
|
|
|
263 #define CONCHECK_SPECIFIER(x) CONCHECK_RECORD (x, specifier)
|
|
|
264
|
|
|
265 /***** Calling a specifier method *****/
|
|
|
266
|
|
|
267 #define RAW_SPECMETH(sp, m) ((sp)->methods->m##_method)
|
|
|
268 #define HAS_SPECMETH_P(sp, m) (!!RAW_SPECMETH (sp, m))
|
|
|
269 #define SPECMETH(sp, m, args) (((sp)->methods->m##_method) args)
|
|
|
270
|
|
|
271 /* Call a void-returning specifier method, if it exists. */
|
|
440
|
272 #define MAYBE_SPECMETH(sp, m, args) do { \
|
|
|
273 Lisp_Specifier *maybe_specmeth_sp = (sp); \
|
|
|
274 if (HAS_SPECMETH_P (maybe_specmeth_sp, m)) \
|
|
|
275 SPECMETH (maybe_specmeth_sp, m, args); \
|
|
428
|
276 } while (0)
|
|
|
277
|
|
|
278 /***** Defining new specifier types *****/
|
|
|
279
|
|
456
|
280 #define specifier_data_offset offsetof (Lisp_Specifier, data)
|
|
428
|
281 extern const struct lrecord_description specifier_empty_extra_description[];
|
|
|
282
|
|
|
283 #ifdef ERROR_CHECK_TYPECHECK
|
|
|
284 #define DECLARE_SPECIFIER_TYPE(type) \
|
|
|
285 extern struct specifier_methods * type##_specifier_methods; \
|
|
442
|
286 INLINE_HEADER struct type##_specifier * \
|
|
440
|
287 error_check_##type##_specifier_data (Lisp_Specifier *sp); \
|
|
442
|
288 INLINE_HEADER struct type##_specifier * \
|
|
440
|
289 error_check_##type##_specifier_data (Lisp_Specifier *sp) \
|
|
428
|
290 { \
|
|
|
291 if (SPECIFIERP (sp->magic_parent)) \
|
|
|
292 { \
|
|
|
293 assert (SPECIFIER_TYPE_P (sp, type)); \
|
|
|
294 sp = XSPECIFIER (sp->magic_parent); \
|
|
|
295 } \
|
|
|
296 else \
|
|
|
297 assert (NILP (sp->magic_parent) || EQ (sp->magic_parent, Qt)); \
|
|
|
298 assert (SPECIFIER_TYPE_P (sp, type)); \
|
|
|
299 return (struct type##_specifier *) sp->data; \
|
|
|
300 } \
|
|
442
|
301 INLINE_HEADER Lisp_Specifier * \
|
|
438
|
302 error_check_##type##_specifier_type (Lisp_Object obj); \
|
|
442
|
303 INLINE_HEADER Lisp_Specifier * \
|
|
438
|
304 error_check_##type##_specifier_type (Lisp_Object obj) \
|
|
|
305 { \
|
|
440
|
306 Lisp_Specifier *sp = XSPECIFIER (obj); \
|
|
438
|
307 assert (SPECIFIER_TYPE_P (sp, type)); \
|
|
|
308 return sp; \
|
|
|
309 } \
|
|
428
|
310 DECLARE_NOTHING
|
|
|
311 #else
|
|
442
|
312 #define DECLARE_SPECIFIER_TYPE(type) \
|
|
428
|
313 extern struct specifier_methods * type##_specifier_methods
|
|
|
314 #endif /* ERROR_CHECK_TYPECHECK */
|
|
|
315
|
|
442
|
316 #define DEFINE_SPECIFIER_TYPE(type) \
|
|
428
|
317 struct specifier_methods * type##_specifier_methods
|
|
|
318
|
|
771
|
319 #define INITIALIZE_SPECIFIER_TYPE(type, obj_name, pred_sym) do { \
|
|
|
320 type##_specifier_methods = xnew_and_zero (struct specifier_methods); \
|
|
|
321 type##_specifier_methods->name = obj_name; \
|
|
|
322 type##_specifier_methods->extra_description = \
|
|
|
323 specifier_empty_extra_description; \
|
|
|
324 defsymbol_nodump (&type##_specifier_methods->predicate_symbol, pred_sym); \
|
|
|
325 add_entry_to_specifier_type_list (Q##type, type##_specifier_methods); \
|
|
|
326 dump_add_root_struct_ptr (&type##_specifier_methods, \
|
|
|
327 &specifier_methods_description); \
|
|
428
|
328 } while (0)
|
|
|
329
|
|
442
|
330 #define REINITIALIZE_SPECIFIER_TYPE(type) do { \
|
|
428
|
331 staticpro_nodump (&type##_specifier_methods->predicate_symbol); \
|
|
|
332 } while (0)
|
|
|
333
|
|
|
334 #define INITIALIZE_SPECIFIER_TYPE_WITH_DATA(type, obj_name, pred_sym) \
|
|
|
335 do { \
|
|
|
336 INITIALIZE_SPECIFIER_TYPE (type, obj_name, pred_sym); \
|
|
|
337 type##_specifier_methods->extra_data_size = \
|
|
|
338 sizeof (struct type##_specifier); \
|
|
|
339 type##_specifier_methods->extra_description = \
|
|
|
340 type##_specifier_description; \
|
|
|
341 } while (0)
|
|
|
342
|
|
|
343 /* Declare that specifier-type TYPE has method METH; used in
|
|
|
344 initialization routines */
|
|
|
345 #define SPECIFIER_HAS_METHOD(type, meth) \
|
|
|
346 (type##_specifier_methods->meth##_method = type##_##meth)
|
|
|
347
|
|
|
348 /***** Macros for accessing specifier types *****/
|
|
|
349
|
|
|
350 #define SPECIFIER_TYPE_P(sp, type) \
|
|
|
351 ((sp)->methods == type##_specifier_methods)
|
|
|
352
|
|
|
353 /* Any of the two of the magic spec */
|
|
|
354 #define MAGIC_SPECIFIER_P(sp) (!NILP((sp)->magic_parent))
|
|
|
355 /* Normal part of the magic specifier */
|
|
|
356 #define BODILY_SPECIFIER_P(sp) EQ ((sp)->magic_parent, Qt)
|
|
|
357 /* Ghost part of the magic specifier */
|
|
|
358 #define GHOST_SPECIFIER_P(sp) SPECIFIERP((sp)->magic_parent)
|
|
|
359
|
|
|
360 #define GHOST_SPECIFIER(sp) XSPECIFIER ((sp)->fallback)
|
|
|
361
|
|
|
362 #ifdef ERROR_CHECK_TYPECHECK
|
|
|
363 # define SPECIFIER_TYPE_DATA(sp, type) \
|
|
|
364 error_check_##type##_specifier_data (sp)
|
|
|
365 #else
|
|
|
366 # define SPECIFIER_TYPE_DATA(sp, type) \
|
|
|
367 ((struct type##_specifier *) \
|
|
|
368 (GHOST_SPECIFIER_P(sp) \
|
|
|
369 ? XSPECIFIER((sp)->magic_parent)->data \
|
|
|
370 : (sp)->data))
|
|
|
371 #endif
|
|
|
372
|
|
438
|
373 #ifdef ERROR_CHECK_TYPECHECK
|
|
|
374 # define XSPECIFIER_TYPE(x, type) \
|
|
|
375 error_check_##type##_specifier_type (x)
|
|
|
376 # define XSETSPECIFIER_TYPE(x, p, type) do \
|
|
|
377 { \
|
|
|
378 XSETSPECIFIER (x, p); \
|
|
|
379 assert (SPECIFIER_TYPEP (XSPECIFIER(x), type)); \
|
|
|
380 } while (0)
|
|
|
381 #else
|
|
|
382 # define XSPECIFIER_TYPE(x, type) XSPECIFIER (x)
|
|
|
383 # define XSETSPECIFIER_TYPE(x, p, type) XSETSPECIFIER (x, p)
|
|
|
384 #endif /* ERROR_CHECK_TYPE_CHECK */
|
|
428
|
385
|
|
442
|
386 #define SPECIFIER_TYPEP(x, type) \
|
|
428
|
387 (SPECIFIERP (x) && SPECIFIER_TYPE_P (XSPECIFIER (x), type))
|
|
|
388 #define CHECK_SPECIFIER_TYPE(x, type) do { \
|
|
|
389 CHECK_SPECIFIER (x); \
|
|
|
390 if (!SPECIFIER_TYPE_P (XSPECIFIER (x), type)) \
|
|
|
391 dead_wrong_type_argument \
|
|
|
392 (type##_specifier_methods->predicate_symbol, x); \
|
|
|
393 } while (0)
|
|
|
394 #define CONCHECK_SPECIFIER_TYPE(x, type) do { \
|
|
|
395 CONCHECK_SPECIFIER (x); \
|
|
|
396 if (!(SPECIFIER_TYPEP (x, type))) \
|
|
|
397 x = wrong_type_argument \
|
|
|
398 (type##_specifier_methods->predicate_symbol, x); \
|
|
|
399 } while (0)
|
|
|
400
|
|
|
401 /***** Miscellaneous structures *****/
|
|
|
402
|
|
|
403 enum spec_locale_type
|
|
|
404 {
|
|
|
405 LOCALE_GLOBAL,
|
|
|
406 LOCALE_DEVICE,
|
|
|
407 LOCALE_FRAME,
|
|
|
408 LOCALE_WINDOW,
|
|
|
409 LOCALE_BUFFER
|
|
|
410 };
|
|
|
411
|
|
|
412 enum spec_add_meth
|
|
|
413 {
|
|
|
414 SPEC_PREPEND,
|
|
|
415 SPEC_APPEND,
|
|
|
416 SPEC_REMOVE_TAG_SET_PREPEND,
|
|
|
417 SPEC_REMOVE_TAG_SET_APPEND,
|
|
|
418 SPEC_REMOVE_LOCALE,
|
|
|
419 SPEC_REMOVE_LOCALE_TYPE,
|
|
|
420 SPEC_REMOVE_ALL
|
|
|
421 };
|
|
|
422
|
|
|
423 struct specifier_caching
|
|
|
424 {
|
|
|
425 int offset_into_struct_window;
|
|
|
426 void (*value_changed_in_window) (Lisp_Object specifier, struct window *w,
|
|
|
427 Lisp_Object oldval);
|
|
|
428 int offset_into_struct_frame;
|
|
|
429 void (*value_changed_in_frame) (Lisp_Object specifier, struct frame *f,
|
|
|
430 Lisp_Object oldval);
|
|
444
|
431 int always_recompute;
|
|
428
|
432 };
|
|
|
433
|
|
442
|
434 /* #### get image instances out of domains! */
|
|
|
435
|
|
|
436 /* #### I think the following should abort() rather than return nil
|
|
|
437 when an invalid domain is given; much more likely we'll catch design
|
|
|
438 errors early. --ben */
|
|
|
439
|
|
|
440 /* This turns out to be used heavily so we make it a macro to make it
|
|
|
441 inline. Also, the majority of the time the object will turn out to
|
|
|
442 be a window so we move it from being checked last to being checked
|
|
|
443 first. */
|
|
|
444 #define DOMAIN_DEVICE(obj) \
|
|
|
445 (WINDOWP (obj) ? WINDOW_DEVICE (XWINDOW (obj)) \
|
|
|
446 : (FRAMEP (obj) ? FRAME_DEVICE (XFRAME (obj)) \
|
|
|
447 : (DEVICEP (obj) ? obj \
|
|
|
448 : (IMAGE_INSTANCEP (obj) ? image_instance_device (obj) \
|
|
|
449 : Qnil))))
|
|
|
450
|
|
|
451 #define DOMAIN_FRAME(obj) \
|
|
|
452 (WINDOWP (obj) ? WINDOW_FRAME (XWINDOW (obj)) \
|
|
|
453 : (FRAMEP (obj) ? obj \
|
|
|
454 : (IMAGE_INSTANCEP (obj) ? image_instance_frame (obj) \
|
|
|
455 : Qnil)))
|
|
|
456
|
|
|
457 #define DOMAIN_WINDOW(obj) \
|
|
|
458 (WINDOWP (obj) ? obj \
|
|
|
459 : (IMAGE_INSTANCEP (obj) ? image_instance_window (obj) \
|
|
|
460 : Qnil))
|
|
|
461
|
|
|
462 #define DOMAIN_LIVE_P(obj) \
|
|
|
463 (WINDOWP (obj) ? WINDOW_LIVE_P (XWINDOW (obj)) \
|
|
|
464 : (FRAMEP (obj) ? FRAME_LIVE_P (XFRAME (obj)) \
|
|
|
465 : (DEVICEP (obj) ? DEVICE_LIVE_P (XDEVICE (obj)) \
|
|
|
466 : (IMAGE_INSTANCEP (obj) ? image_instance_live_p (obj) \
|
|
|
467 : 0))))
|
|
|
468
|
|
|
469 #define DOMAIN_XDEVICE(obj) \
|
|
|
470 (XDEVICE (DOMAIN_DEVICE (obj)))
|
|
|
471 #define DOMAIN_XFRAME(obj) \
|
|
|
472 (XFRAME (DOMAIN_FRAME (obj)))
|
|
|
473 #define DOMAIN_XWINDOW(obj) \
|
|
|
474 (XWINDOW (DOMAIN_WINDOW (obj)))
|
|
|
475
|
|
428
|
476 EXFUN (Fcopy_specifier, 6);
|
|
|
477 EXFUN (Fmake_specifier, 1);
|
|
|
478 EXFUN (Fset_specifier_dirty_flag, 1);
|
|
|
479 EXFUN (Fspecifier_instance, 4);
|
|
|
480 EXFUN (Fvalid_specifier_locale_p, 1);
|
|
|
481
|
|
|
482 extern Lisp_Object Qfallback, Qnatnum;
|
|
|
483
|
|
|
484 Lisp_Object make_magic_specifier (Lisp_Object type);
|
|
|
485 Lisp_Object decode_locale_list (Lisp_Object locale);
|
|
|
486 extern enum spec_add_meth
|
|
|
487 decode_how_to_add_specification (Lisp_Object how_to_add);
|
|
|
488 Lisp_Object decode_specifier_tag_set (Lisp_Object tag_set);
|
|
442
|
489 Lisp_Object decode_domain (Lisp_Object domain);
|
|
428
|
490
|
|
|
491 void add_entry_to_specifier_type_list (Lisp_Object symbol,
|
|
|
492 struct specifier_methods *meths);
|
|
|
493 void set_specifier_caching (Lisp_Object specifier,
|
|
|
494 int struct_window_offset,
|
|
|
495 void (*value_changed_in_window)
|
|
|
496 (Lisp_Object specifier, struct window *w,
|
|
|
497 Lisp_Object oldval),
|
|
|
498 int struct_frame_offset,
|
|
|
499 void (*value_changed_in_frame)
|
|
|
500 (Lisp_Object specifier, struct frame *f,
|
|
444
|
501 Lisp_Object oldval),
|
|
|
502 int always_recompute);
|
|
428
|
503 void set_specifier_fallback (Lisp_Object specifier,
|
|
|
504 Lisp_Object fallback);
|
|
|
505 void recompute_all_cached_specifiers_in_window (struct window *w);
|
|
|
506 void recompute_all_cached_specifiers_in_frame (struct frame *f);
|
|
|
507
|
|
|
508 /* Counterparts of Fadd_spec_to_specifier and Fremove_specifier, which
|
|
|
509 operate directly on ghost objects given a magic specifier. */
|
|
|
510 void add_spec_to_ghost_specifier (Lisp_Object specifier, Lisp_Object instantiator,
|
|
|
511 Lisp_Object locale, Lisp_Object tag_set,
|
|
|
512 Lisp_Object how_to_add);
|
|
|
513 void remove_ghost_specifier (Lisp_Object specifier, Lisp_Object locale,
|
|
|
514 Lisp_Object tag_set, Lisp_Object exact_p);
|
|
|
515
|
|
|
516 int unlock_ghost_specifiers_protected (void);
|
|
|
517
|
|
|
518 void cleanup_specifiers (void);
|
|
|
519 void prune_specifiers (void);
|
|
|
520 void setup_device_initial_specifier_tags (struct device *d);
|
|
|
521 void kill_specifier_buffer_locals (Lisp_Object buffer);
|
|
|
522
|
|
|
523 DECLARE_SPECIFIER_TYPE (generic);
|
|
|
524 #define XGENERIC_SPECIFIER(x) XSPECIFIER_TYPE (x, generic)
|
|
|
525 #define XSETGENERIC_SPECIFIER(x, p) XSETSPECIFIER_TYPE (x, p, generic)
|
|
|
526 #define GENERIC_SPECIFIERP(x) SPECIFIER_TYPEP (x, generic)
|
|
|
527 #define CHECK_GENERIC_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, generic)
|
|
|
528 #define CONCHECK_GENERIC_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, generic)
|
|
|
529
|
|
|
530 DECLARE_SPECIFIER_TYPE (integer);
|
|
|
531 #define XINTEGER_SPECIFIER(x) XSPECIFIER_TYPE (x, integer)
|
|
|
532 #define XSETINTEGER_SPECIFIER(x, p) XSETSPECIFIER_TYPE (x, p, integer)
|
|
|
533 #define INTEGER_SPECIFIERP(x) SPECIFIER_TYPEP (x, integer)
|
|
|
534 #define CHECK_INTEGER_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, integer)
|
|
|
535 #define CONCHECK_INTEGER_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, integer)
|
|
|
536
|
|
|
537 DECLARE_SPECIFIER_TYPE (natnum);
|
|
|
538 #define XNATNUM_SPECIFIER(x) XSPECIFIER_TYPE (x, natnum)
|
|
|
539 #define XSETNATNUM_SPECIFIER(x, p) XSETSPECIFIER_TYPE (x, p, natnum)
|
|
|
540 #define NATNUM_SPECIFIERP(x) SPECIFIER_TYPEP (x, natnum)
|
|
|
541 #define CHECK_NATNUM_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, natnum)
|
|
|
542 #define CONCHECK_NATNUM_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, natnum)
|
|
|
543
|
|
|
544 DECLARE_SPECIFIER_TYPE (boolean);
|
|
|
545 #define XBOOLEAN_SPECIFIER(x) XSPECIFIER_TYPE (x, boolean)
|
|
|
546 #define XSETBOOLEAN_SPECIFIER(x, p) XSETSPECIFIER_TYPE (x, p, boolean)
|
|
|
547 #define BOOLEAN_SPECIFIERP(x) SPECIFIER_TYPEP (x, boolean)
|
|
|
548 #define CHECK_BOOLEAN_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, boolean)
|
|
|
549 #define CONCHECK_BOOLEAN_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, boolean)
|
|
|
550
|
|
|
551 DECLARE_SPECIFIER_TYPE (display_table);
|
|
|
552 #define XDISPLAYTABLE_SPECIFIER(x) XSPECIFIER_TYPE (x, display_table)
|
|
|
553 #define XSETDISPLAYTABLE_SPECIFIER(x, p) XSETSPECIFIER_TYPE (x, p, display_table)
|
|
|
554 #define DISPLAYTABLE_SPECIFIERP(x) SPECIFIER_TYPEP (x, display_table)
|
|
|
555 #define CHECK_DISPLAYTABLE_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, display_table)
|
|
|
556 #define CONCHECK_DISPLAYTABLE_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, display_table)
|
|
|
557
|
|
440
|
558 #endif /* INCLUDED_specifier_h_ */
|
