428
+ − 1 /* Generic specifier list implementation
+ − 2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
826
+ − 3 Copyright (C) 1995, 1996, 2002 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: 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
1204
+ − 86 extern const struct sized_memory_description specifier_methods_description;
428
+ − 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
1204
+ − 197 /* Specifier extra data: Specifier objects can have extra data, specific
+ − 198 to the type of specifier, stored at the end of the object. To have
+ − 199 this, a specifier declares a structure of type `struct TYPE_specifier'
+ − 200 containing the data and uses DEFINE_SPECIFIER_TYPE_WITH_DATA and
+ − 201 INITIALIZE_SPECIFIER_TYPE_WITH_DATA instead of the plain versions.
+ − 202 Then, a pointer to the `struct TYPE_specifier' can be obtained from a
+ − 203 specifier object using SPECIFIER_TYPE_DATA.
771
+ − 204
1204
+ − 205 A data description of the extra data must also be provided, in the
+ − 206 form of a memory_description named TYPE_specifier_description. */
+ − 207
+ − 208 /* Description of extra data structure; initialized when
771
+ − 209 INITIALIZE_SPECIFIER_TYPE_WITH_DATA is called. */
1204
+ − 210 const struct sized_memory_description *extra_description;
771
+ − 211
+ − 212 /* Size of extra data structure; initialized when
+ − 213 INITIALIZE_SPECIFIER_TYPE_WITH_DATA is called. */
428
+ − 214 int extra_data_size;
+ − 215 };
+ − 216
+ − 217 struct Lisp_Specifier
+ − 218 {
+ − 219 struct lcrecord_header header;
+ − 220 struct specifier_methods *methods;
+ − 221
+ − 222 /* we keep a chained list of all current specifiers, for GC cleanup
+ − 223 purposes. Do NOT mark through this, or specifiers will never
+ − 224 be GC'd. */
+ − 225 Lisp_Object next_specifier;
+ − 226
+ − 227 /* This is a straight list of instantiators. */
+ − 228 Lisp_Object global_specs;
+ − 229
+ − 230 /* These are all assoc lists where the key is the type of object the
+ − 231 list represents (buffer, window, etc.) and the associated list is
+ − 232 the actual list of instantiators. */
+ − 233 Lisp_Object device_specs;
+ − 234 Lisp_Object frame_specs;
+ − 235 /* window_specs is actually a key-assoc weak list. See specifier.c
+ − 236 for an explanation of why (it boils down to the fact that
+ − 237 dead windows can become live again through window configurations).
+ − 238 */
+ − 239 Lisp_Object window_specs;
+ − 240 Lisp_Object buffer_specs;
+ − 241
+ − 242 struct specifier_caching *caching;
+ − 243
+ − 244 /* This can be either nil, for a plain, non-magic specifier object,
+ − 245 t for the normal part of the magic specifier, or #<specifier> for
+ − 246 the ghost part of the magic specifier, a pointer to its parent
+ − 247 object */
+ − 248 Lisp_Object magic_parent;
+ − 249
+ − 250 /* Fallback value. For magic specifiers, it is a pointer to the ghost. */
+ − 251 Lisp_Object fallback;
+ − 252
+ − 253 /* type-specific extra data attached to a specifier */
456
+ − 254 max_align_t data[1];
428
+ − 255 };
440
+ − 256 typedef struct Lisp_Specifier Lisp_Specifier;
428
+ − 257
440
+ − 258 DECLARE_LRECORD (specifier, Lisp_Specifier);
+ − 259 #define XSPECIFIER(x) XRECORD (x, specifier, Lisp_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
1204
+ − 280 extern const struct sized_memory_description specifier_empty_extra_description;
428
+ − 281
800
+ − 282 #ifdef ERROR_CHECK_TYPES
428
+ − 283 #define DECLARE_SPECIFIER_TYPE(type) \
+ − 284 extern struct specifier_methods * type##_specifier_methods; \
826
+ − 285 DECLARE_INLINE_HEADER ( \
+ − 286 struct type##_specifier * \
440
+ − 287 error_check_##type##_specifier_data (Lisp_Specifier *sp) \
826
+ − 288 ) \
428
+ − 289 { \
+ − 290 if (SPECIFIERP (sp->magic_parent)) \
+ − 291 { \
+ − 292 assert (SPECIFIER_TYPE_P (sp, type)); \
+ − 293 sp = XSPECIFIER (sp->magic_parent); \
+ − 294 } \
+ − 295 else \
+ − 296 assert (NILP (sp->magic_parent) || EQ (sp->magic_parent, Qt)); \
+ − 297 assert (SPECIFIER_TYPE_P (sp, type)); \
+ − 298 return (struct type##_specifier *) sp->data; \
+ − 299 } \
826
+ − 300 DECLARE_INLINE_HEADER ( \
+ − 301 Lisp_Specifier * \
438
+ − 302 error_check_##type##_specifier_type (Lisp_Object obj) \
826
+ − 303 ) \
438
+ − 304 { \
440
+ − 305 Lisp_Specifier *sp = XSPECIFIER (obj); \
438
+ − 306 assert (SPECIFIER_TYPE_P (sp, type)); \
+ − 307 return sp; \
+ − 308 } \
428
+ − 309 DECLARE_NOTHING
+ − 310 #else
442
+ − 311 #define DECLARE_SPECIFIER_TYPE(type) \
428
+ − 312 extern struct specifier_methods * type##_specifier_methods
800
+ − 313 #endif /* ERROR_CHECK_TYPES */
428
+ − 314
442
+ − 315 #define DEFINE_SPECIFIER_TYPE(type) \
428
+ − 316 struct specifier_methods * type##_specifier_methods
+ − 317
1204
+ − 318 #define DEFINE_SPECIFIER_TYPE_WITH_DATA(type) \
+ − 319 struct specifier_methods * type##_specifier_methods; \
+ − 320 static const struct sized_memory_description type##_specifier_description_0 \
+ − 321 = { \
+ − 322 sizeof (struct type##_specifier), \
+ − 323 type##_specifier_description \
+ − 324 }
+ − 325
771
+ − 326 #define INITIALIZE_SPECIFIER_TYPE(type, obj_name, pred_sym) do { \
+ − 327 type##_specifier_methods = xnew_and_zero (struct specifier_methods); \
+ − 328 type##_specifier_methods->name = obj_name; \
+ − 329 type##_specifier_methods->extra_description = \
1204
+ − 330 &specifier_empty_extra_description; \
771
+ − 331 defsymbol_nodump (&type##_specifier_methods->predicate_symbol, pred_sym); \
+ − 332 add_entry_to_specifier_type_list (Q##type, type##_specifier_methods); \
2367
+ − 333 dump_add_root_block_ptr (&type##_specifier_methods, \
771
+ − 334 &specifier_methods_description); \
428
+ − 335 } while (0)
+ − 336
442
+ − 337 #define REINITIALIZE_SPECIFIER_TYPE(type) do { \
428
+ − 338 staticpro_nodump (&type##_specifier_methods->predicate_symbol); \
+ − 339 } while (0)
+ − 340
+ − 341 #define INITIALIZE_SPECIFIER_TYPE_WITH_DATA(type, obj_name, pred_sym) \
+ − 342 do { \
+ − 343 INITIALIZE_SPECIFIER_TYPE (type, obj_name, pred_sym); \
+ − 344 type##_specifier_methods->extra_data_size = \
+ − 345 sizeof (struct type##_specifier); \
+ − 346 type##_specifier_methods->extra_description = \
1204
+ − 347 &type##_specifier_description_0; \
428
+ − 348 } while (0)
+ − 349
+ − 350 /* Declare that specifier-type TYPE has method METH; used in
+ − 351 initialization routines */
+ − 352 #define SPECIFIER_HAS_METHOD(type, meth) \
+ − 353 (type##_specifier_methods->meth##_method = type##_##meth)
+ − 354
+ − 355 /***** Macros for accessing specifier types *****/
+ − 356
+ − 357 #define SPECIFIER_TYPE_P(sp, type) \
+ − 358 ((sp)->methods == type##_specifier_methods)
+ − 359
+ − 360 /* Any of the two of the magic spec */
+ − 361 #define MAGIC_SPECIFIER_P(sp) (!NILP((sp)->magic_parent))
+ − 362 /* Normal part of the magic specifier */
+ − 363 #define BODILY_SPECIFIER_P(sp) EQ ((sp)->magic_parent, Qt)
+ − 364 /* Ghost part of the magic specifier */
+ − 365 #define GHOST_SPECIFIER_P(sp) SPECIFIERP((sp)->magic_parent)
+ − 366
+ − 367 #define GHOST_SPECIFIER(sp) XSPECIFIER ((sp)->fallback)
+ − 368
800
+ − 369 #ifdef ERROR_CHECK_TYPES
428
+ − 370 # define SPECIFIER_TYPE_DATA(sp, type) \
+ − 371 error_check_##type##_specifier_data (sp)
+ − 372 #else
+ − 373 # define SPECIFIER_TYPE_DATA(sp, type) \
+ − 374 ((struct type##_specifier *) \
+ − 375 (GHOST_SPECIFIER_P(sp) \
+ − 376 ? XSPECIFIER((sp)->magic_parent)->data \
+ − 377 : (sp)->data))
+ − 378 #endif
+ − 379
800
+ − 380 #ifdef ERROR_CHECK_TYPES
438
+ − 381 # define XSPECIFIER_TYPE(x, type) \
+ − 382 error_check_##type##_specifier_type (x)
+ − 383 #else
+ − 384 # define XSPECIFIER_TYPE(x, type) XSPECIFIER (x)
800
+ − 385 #endif /* ERROR_CHECK_TYPES */
428
+ − 386
442
+ − 387 #define SPECIFIER_TYPEP(x, type) \
428
+ − 388 (SPECIFIERP (x) && SPECIFIER_TYPE_P (XSPECIFIER (x), type))
+ − 389 #define CHECK_SPECIFIER_TYPE(x, type) do { \
+ − 390 CHECK_SPECIFIER (x); \
+ − 391 if (!SPECIFIER_TYPE_P (XSPECIFIER (x), type)) \
+ − 392 dead_wrong_type_argument \
+ − 393 (type##_specifier_methods->predicate_symbol, x); \
+ − 394 } while (0)
+ − 395 #define CONCHECK_SPECIFIER_TYPE(x, type) do { \
+ − 396 CONCHECK_SPECIFIER (x); \
+ − 397 if (!(SPECIFIER_TYPEP (x, type))) \
+ − 398 x = wrong_type_argument \
+ − 399 (type##_specifier_methods->predicate_symbol, x); \
+ − 400 } while (0)
+ − 401
+ − 402 /***** Miscellaneous structures *****/
+ − 403
+ − 404 enum spec_locale_type
+ − 405 {
+ − 406 LOCALE_GLOBAL,
+ − 407 LOCALE_DEVICE,
+ − 408 LOCALE_FRAME,
+ − 409 LOCALE_WINDOW,
+ − 410 LOCALE_BUFFER
+ − 411 };
+ − 412
+ − 413 enum spec_add_meth
+ − 414 {
+ − 415 SPEC_PREPEND,
+ − 416 SPEC_APPEND,
+ − 417 SPEC_REMOVE_TAG_SET_PREPEND,
+ − 418 SPEC_REMOVE_TAG_SET_APPEND,
+ − 419 SPEC_REMOVE_LOCALE,
+ − 420 SPEC_REMOVE_LOCALE_TYPE,
+ − 421 SPEC_REMOVE_ALL
+ − 422 };
+ − 423
+ − 424 struct specifier_caching
+ − 425 {
+ − 426 int offset_into_struct_window;
+ − 427 void (*value_changed_in_window) (Lisp_Object specifier, struct window *w,
+ − 428 Lisp_Object oldval);
+ − 429 int offset_into_struct_frame;
+ − 430 void (*value_changed_in_frame) (Lisp_Object specifier, struct frame *f,
+ − 431 Lisp_Object oldval);
444
+ − 432 int always_recompute;
428
+ − 433 };
+ − 434
442
+ − 435 /* #### get image instances out of domains! */
+ − 436
+ − 437 /* #### I think the following should abort() rather than return nil
+ − 438 when an invalid domain is given; much more likely we'll catch design
+ − 439 errors early. --ben */
+ − 440
+ − 441 /* This turns out to be used heavily so we make it a macro to make it
+ − 442 inline. Also, the majority of the time the object will turn out to
+ − 443 be a window so we move it from being checked last to being checked
+ − 444 first. */
+ − 445 #define DOMAIN_DEVICE(obj) \
+ − 446 (WINDOWP (obj) ? WINDOW_DEVICE (XWINDOW (obj)) \
+ − 447 : (FRAMEP (obj) ? FRAME_DEVICE (XFRAME (obj)) \
+ − 448 : (DEVICEP (obj) ? obj \
+ − 449 : (IMAGE_INSTANCEP (obj) ? image_instance_device (obj) \
+ − 450 : Qnil))))
+ − 451
+ − 452 #define DOMAIN_FRAME(obj) \
+ − 453 (WINDOWP (obj) ? WINDOW_FRAME (XWINDOW (obj)) \
+ − 454 : (FRAMEP (obj) ? obj \
+ − 455 : (IMAGE_INSTANCEP (obj) ? image_instance_frame (obj) \
+ − 456 : Qnil)))
+ − 457
+ − 458 #define DOMAIN_WINDOW(obj) \
+ − 459 (WINDOWP (obj) ? obj \
+ − 460 : (IMAGE_INSTANCEP (obj) ? image_instance_window (obj) \
+ − 461 : Qnil))
+ − 462
+ − 463 #define DOMAIN_LIVE_P(obj) \
+ − 464 (WINDOWP (obj) ? WINDOW_LIVE_P (XWINDOW (obj)) \
+ − 465 : (FRAMEP (obj) ? FRAME_LIVE_P (XFRAME (obj)) \
+ − 466 : (DEVICEP (obj) ? DEVICE_LIVE_P (XDEVICE (obj)) \
+ − 467 : (IMAGE_INSTANCEP (obj) ? image_instance_live_p (obj) \
+ − 468 : 0))))
+ − 469
+ − 470 #define DOMAIN_XDEVICE(obj) \
+ − 471 (XDEVICE (DOMAIN_DEVICE (obj)))
+ − 472 #define DOMAIN_XFRAME(obj) \
+ − 473 (XFRAME (DOMAIN_FRAME (obj)))
+ − 474 #define DOMAIN_XWINDOW(obj) \
+ − 475 (XWINDOW (DOMAIN_WINDOW (obj)))
+ − 476
428
+ − 477 EXFUN (Fcopy_specifier, 6);
+ − 478 EXFUN (Fmake_specifier, 1);
+ − 479 EXFUN (Fset_specifier_dirty_flag, 1);
+ − 480 EXFUN (Fspecifier_instance, 4);
+ − 481 EXFUN (Fvalid_specifier_locale_p, 1);
+ − 482
+ − 483 extern Lisp_Object Qfallback, Qnatnum;
+ − 484
+ − 485 Lisp_Object make_magic_specifier (Lisp_Object type);
+ − 486 Lisp_Object decode_locale_list (Lisp_Object locale);
+ − 487 extern enum spec_add_meth
+ − 488 decode_how_to_add_specification (Lisp_Object how_to_add);
+ − 489 Lisp_Object decode_specifier_tag_set (Lisp_Object tag_set);
442
+ − 490 Lisp_Object decode_domain (Lisp_Object domain);
428
+ − 491
+ − 492 void add_entry_to_specifier_type_list (Lisp_Object symbol,
+ − 493 struct specifier_methods *meths);
+ − 494 void set_specifier_caching (Lisp_Object specifier,
+ − 495 int struct_window_offset,
+ − 496 void (*value_changed_in_window)
+ − 497 (Lisp_Object specifier, struct window *w,
+ − 498 Lisp_Object oldval),
+ − 499 int struct_frame_offset,
+ − 500 void (*value_changed_in_frame)
+ − 501 (Lisp_Object specifier, struct frame *f,
444
+ − 502 Lisp_Object oldval),
+ − 503 int always_recompute);
428
+ − 504 void set_specifier_fallback (Lisp_Object specifier,
+ − 505 Lisp_Object fallback);
+ − 506 void recompute_all_cached_specifiers_in_window (struct window *w);
+ − 507 void recompute_all_cached_specifiers_in_frame (struct frame *f);
+ − 508
+ − 509 /* Counterparts of Fadd_spec_to_specifier and Fremove_specifier, which
+ − 510 operate directly on ghost objects given a magic specifier. */
+ − 511 void add_spec_to_ghost_specifier (Lisp_Object specifier, Lisp_Object instantiator,
+ − 512 Lisp_Object locale, Lisp_Object tag_set,
+ − 513 Lisp_Object how_to_add);
+ − 514 void remove_ghost_specifier (Lisp_Object specifier, Lisp_Object locale,
+ − 515 Lisp_Object tag_set, Lisp_Object exact_p);
+ − 516
+ − 517 int unlock_ghost_specifiers_protected (void);
+ − 518
+ − 519 void cleanup_specifiers (void);
+ − 520 void prune_specifiers (void);
+ − 521 void setup_device_initial_specifier_tags (struct device *d);
+ − 522 void kill_specifier_buffer_locals (Lisp_Object buffer);
+ − 523
+ − 524 DECLARE_SPECIFIER_TYPE (generic);
+ − 525 #define XGENERIC_SPECIFIER(x) XSPECIFIER_TYPE (x, 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 INTEGER_SPECIFIERP(x) SPECIFIER_TYPEP (x, integer)
+ − 533 #define CHECK_INTEGER_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, integer)
+ − 534 #define CONCHECK_INTEGER_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, integer)
+ − 535
+ − 536 DECLARE_SPECIFIER_TYPE (natnum);
+ − 537 #define XNATNUM_SPECIFIER(x) XSPECIFIER_TYPE (x, natnum)
+ − 538 #define NATNUM_SPECIFIERP(x) SPECIFIER_TYPEP (x, natnum)
+ − 539 #define CHECK_NATNUM_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, natnum)
+ − 540 #define CONCHECK_NATNUM_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, natnum)
+ − 541
+ − 542 DECLARE_SPECIFIER_TYPE (boolean);
+ − 543 #define XBOOLEAN_SPECIFIER(x) XSPECIFIER_TYPE (x, boolean)
+ − 544 #define BOOLEAN_SPECIFIERP(x) SPECIFIER_TYPEP (x, boolean)
+ − 545 #define CHECK_BOOLEAN_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, boolean)
+ − 546 #define CONCHECK_BOOLEAN_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, boolean)
+ − 547
+ − 548 DECLARE_SPECIFIER_TYPE (display_table);
+ − 549 #define XDISPLAYTABLE_SPECIFIER(x) XSPECIFIER_TYPE (x, display_table)
+ − 550 #define DISPLAYTABLE_SPECIFIERP(x) SPECIFIER_TYPEP (x, display_table)
+ − 551 #define CHECK_DISPLAYTABLE_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, display_table)
+ − 552 #define CONCHECK_DISPLAYTABLE_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, display_table)
+ − 553
440
+ − 554 #endif /* INCLUDED_specifier_h_ */
