428
+ − 1 /* Definitions of symbol-value forwarding for XEmacs Lisp interpreter.
+ − 2 Copyright (C) 1985, 1986, 1987, 1992, 1993 Free Software Foundation, Inc.
793
+ − 3 Copyright (C) 2000, 2001, 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
+ − 24 /* Fsymbol_value checks whether XSYMBOL (sym)->value is one of these,
+ − 25 * and does weird magic stuff if so */
+ − 26
440
+ − 27 #ifndef INCLUDED_symeval_h_
+ − 28 #define INCLUDED_symeval_h_
428
+ − 29
1743
+ − 30 BEGIN_C_DECLS
1650
+ − 31
428
+ − 32 enum symbol_value_type
+ − 33 {
+ − 34 /* The following tags use the 'symbol_value_forward' structure
+ − 35 and are strictly for variables DEFVARed on the C level. */
458
+ − 36 SYMVAL_FIXNUM_FORWARD, /* Forward C "Fixnum", really "EMACS_INT" */
428
+ − 37 SYMVAL_CONST_FIXNUM_FORWARD, /* Same, but can't be set */
+ − 38 SYMVAL_BOOLEAN_FORWARD, /* Forward C boolean ("int") */
+ − 39 SYMVAL_CONST_BOOLEAN_FORWARD, /* Same, but can't be set */
+ − 40 SYMVAL_OBJECT_FORWARD, /* Forward C Lisp_Object */
+ − 41 SYMVAL_CONST_OBJECT_FORWARD, /* Same, but can't be set */
+ − 42 SYMVAL_CONST_SPECIFIER_FORWARD, /* Same, can't be set, but gives a
+ − 43 different message when attempting to
+ − 44 set that says "use set-specifier" */
+ − 45 SYMVAL_DEFAULT_BUFFER_FORWARD, /* Forward Lisp_Object into Vbuffer_defaults */
+ − 46 SYMVAL_CURRENT_BUFFER_FORWARD, /* Forward Lisp_Object into current_buffer */
+ − 47 SYMVAL_CONST_CURRENT_BUFFER_FORWARD, /* Forward Lisp_Object into
+ − 48 current_buffer, can't be set */
+ − 49 SYMVAL_DEFAULT_CONSOLE_FORWARD, /* Forward Lisp_Object into
+ − 50 Vconsole_defaults */
+ − 51 SYMVAL_SELECTED_CONSOLE_FORWARD, /* Forward Lisp_Object into
+ − 52 Vselected_console */
+ − 53 SYMVAL_CONST_SELECTED_CONSOLE_FORWARD, /* Forward Lisp_Object into
+ − 54 Vselected_console,
+ − 55 can't be set */
+ − 56 SYMVAL_UNBOUND_MARKER, /* Only Qunbound actually has this tag */
+ − 57
+ − 58 /* The following tags use the 'symbol_value_buffer_local' structure */
+ − 59 SYMVAL_BUFFER_LOCAL, /* make-variable-buffer-local */
+ − 60 SYMVAL_SOME_BUFFER_LOCAL, /* make-local-variable */
+ − 61
+ − 62 /* The following tag uses the 'symbol_value_lisp_magic' structure */
+ − 63 SYMVAL_LISP_MAGIC, /* Forward to lisp callbacks */
+ − 64
+ − 65 /* The following tag uses the 'symbol_value_varalias' structure */
+ − 66 SYMVAL_VARALIAS /* defvaralias */
+ − 67
+ − 68 #if 0
+ − 69 /* NYI */
+ − 70 SYMVAL_CONSTANT_SYMBOL, /* Self-evaluating symbol */
+ − 71 /* NYI */
+ − 72 #endif
+ − 73 };
+ − 74
458
+ − 75 /* Underlying C type used to implement DEFVAR_INT */
+ − 76 typedef EMACS_INT Fixnum;
+ − 77
428
+ − 78 struct symbol_value_magic
+ − 79 {
3017
+ − 80 struct LCRECORD_HEADER header;
442
+ − 81 void *value;
428
+ − 82 enum symbol_value_type type;
+ − 83 };
442
+ − 84 #define SYMBOL_VALUE_MAGIC_P(x) \
+ − 85 (LRECORDP (x) && \
+ − 86 XRECORD_LHEADER (x)->type <= lrecord_type_max_symbol_value_magic)
428
+ − 87 #define XSYMBOL_VALUE_MAGIC_TYPE(v) \
+ − 88 (((struct symbol_value_magic *) XPNTR (v))->type)
793
+ − 89 #define wrap_symbol_value_magic(p) wrap_pointer_1 (p)
428
+ − 90 void print_symbol_value_magic (Lisp_Object, Lisp_Object, int);
+ − 91
+ − 92 /********** The various different symbol-value-magic types ***********/
+ − 93
+ − 94 /* 1. symbol-value-forward */
+ − 95
+ − 96 /* This type of symbol-value-magic is used for variables declared
+ − 97 DEFVAR_LISP, DEFVAR_INT, DEFVAR_BOOL, DEFVAR_BUFFER_LOCAL,
+ − 98 DEFVAR_BUFFER_DEFAULTS, DEFVAR_SPECIFIER, and for Qunbound.
+ − 99
+ − 100 Note that some of these types of variables can be made buffer-local.
+ − 101 Then, the symbol's value field contains a symbol-value-buffer-local,
+ − 102 whose CURRENT-VALUE field then contains a symbol-value-forward.
+ − 103 */
+ − 104
+ − 105 struct symbol_value_forward
+ − 106 {
+ − 107 struct symbol_value_magic magic;
+ − 108
+ − 109 /* `magicfun' is a function controlling the magic behavior of this
+ − 110 forward variable.
+ − 111
+ − 112 SYM is the symbol being operated on (read, set, etc.);
+ − 113
+ − 114 VAL is either the value to set or the value to be returned.
+ − 115
+ − 116 IN_OBJECT is the buffer or console that the value is read in
+ − 117 or set in. A value of Qnil means that the current buffer
+ − 118 and possibly other buffers are being set. (This value will
+ − 119 never be passed for built-in buffer-local or console-local
+ − 120 variables such as `truncate-lines'.) (Currently, a value of
+ − 121 Qnil is always passed for DEFVAR_INT, DEFVAR_LISP, and
+ − 122 DEFVAR_BOOL variables; the code isn't smart enough to figure
+ − 123 out what buffers besides the current buffer are being
+ − 124 affected. Because the magic function is called
+ − 125 before the value is changed, it's not that easy
+ − 126 to determine which buffers are getting changed.
+ − 127 #### If this information is important, let me know
+ − 128 and I will look into providing it.) (Remember also
+ − 129 that the only console-local variables currently existing
+ − 130 are built-in ones, because others can't be created.)
+ − 131
+ − 132 FLAGS gives more information about the operation being performed.
+ − 133
+ − 134 The return value indicates what the magic function actually did.
+ − 135
+ − 136 Currently FLAGS and the return value are not used. This
+ − 137 function is only called when the value of a forward variable
+ − 138 is about to be changed. Note that this can occur explicitly
+ − 139 through a call to `set', `setq', `set-default', or `setq-default',
+ − 140 or implicitly by the current buffer being changed. */
+ − 141 int (*magicfun) (Lisp_Object sym, Lisp_Object *val, Lisp_Object in_object,
+ − 142 int flags);
+ − 143 };
+ − 144 DECLARE_LRECORD (symbol_value_forward, struct symbol_value_forward);
+ − 145 #define XSYMBOL_VALUE_FORWARD(x) \
+ − 146 XRECORD (x, symbol_value_forward, struct symbol_value_forward)
442
+ − 147 #define symbol_value_forward_forward(m) ((void *)((m)->magic.value))
428
+ − 148 #define symbol_value_forward_magicfun(m) ((m)->magicfun)
+ − 149
+ − 150 /* 2. symbol-value-buffer-local */
+ − 151
+ − 152 struct symbol_value_buffer_local
+ − 153 {
+ − 154 struct symbol_value_magic magic;
+ − 155 /* Used in a symbol value cell when the symbol's value is per-buffer.
+ − 156
+ − 157 The type of the symbol-value-magic will be either
+ − 158 SYMVAL_BUFFER_LOCAL (i.e. `make-variable-buffer-local' was called)
+ − 159 or SYMVAL_SOME_BUFFER_LOCAL (i.e. `make-local-variable' was called).
+ − 160 The only difference between the two is that when setting the
+ − 161 former kind of variable, an implicit `make-local-variable' is
+ − 162 called.
+ − 163
+ − 164 A buffer-local variable logically has
+ − 165
+ − 166 -- a default value
+ − 167 -- local values in some buffers
+ − 168
+ − 169 The primary place where the local values are stored is in each
+ − 170 buffer's local_var_alist slot.
+ − 171
+ − 172 In the simplest implementation, all that this structure needs to
+ − 173 keep track of is the default value; to retrieve the value in
+ − 174 a buffer, look in that buffer's local_var_alist, and use the
+ − 175 default value if there is no local value. To implement
+ − 176 `make-local-variable' in a buffer, look in the buffer's
+ − 177 local_var_alist, and if no element exists for this symbol,
+ − 178 add one, copying the value from the default value. When setting
+ − 179 the value in a buffer, look in the buffer's local_var_alist, and set
+ − 180 the value in that list if an element exists for this symbol;
+ − 181 otherwise, set the default. (Remember that SYMVAL_BUFFER_LOCAL
+ − 182 variables implicitly call `make-local-variable' first, so when
+ − 183 setting a value, there will always be an entry in the buffer's
+ − 184 local_var_alist to set.)
+ − 185
+ − 186 However, this operation is potentially slow. To speed it up,
+ − 187 we cache the value in one buffer in this structure.
+ − 188
+ − 189 NOTE: This is *not* a write-through cache. I.e. when setting
+ − 190 the value in the buffer that is cached, we *only* change the
+ − 191 cache and don't write the value through to either the buffer's
+ − 192 local_var_alist or the default value. Therefore, when retrieving
+ − 193 a value in a buffer, you must *always* look in the cache to see if
+ − 194 it refers to that buffer.
+ − 195
+ − 196 The cache consists of
+ − 197
+ − 198 -- a buffer, or nil if the cache has not been set up
+ − 199 -- the value in that buffer
+ − 200 -- the element (a cons) from the buffer's local_var_alist, or
+ − 201 nil if there is no local value in the buffer
+ − 202
+ − 203 These slots are called CURRENT-BUFFER, CURRENT-VALUE, and
+ − 204 CURRENT-ALIST-ELEMENT, respectively.
+ − 205
+ − 206 If we want to examine or set the value in BUFFER and CURRENT-BUFFER
+ − 207 equals BUFFER, we just examine or set CURRENT-VALUE. Otherwise,
+ − 208 we store CURRENT-VALUE value into CURRENT-ALIST-ELEMENT (or maybe
+ − 209 into DEFAULT-VALUE), then find the appropriate alist element for
+ − 210 BUFFER and set up CURRENT-ALIST-ELEMENT. Then we set CURRENT-VALUE
+ − 211 out of that element (or maybe out of DEFAULT-VALUE), and store
+ − 212 BUFFER into CURRENT-BUFFER.
+ − 213
+ − 214 If we are setting the variable and the current buffer does not have
+ − 215 an alist entry for this variable, an alist entry is created.
+ − 216
+ − 217 Note that CURRENT-BUFFER's local_var_alist value for this variable
+ − 218 might be out-of-date (the correct value is stored in CURRENT-VALUE).
+ − 219 Similarly, if CURRENT-BUFFER sees the default value, then
+ − 220 DEFAULT-VALUE might be out-of-date.
+ − 221
+ − 222 Note that CURRENT-VALUE (but not DEFAULT-VALUE) can be a
+ − 223 forwarding pointer. Each time it is examined or set,
+ − 224 forwarding must be done.
+ − 225 */
+ − 226 Lisp_Object default_value;
+ − 227 Lisp_Object current_value;
+ − 228 Lisp_Object current_buffer;
+ − 229 Lisp_Object current_alist_element;
+ − 230 };
+ − 231 DECLARE_LRECORD (symbol_value_buffer_local, struct symbol_value_buffer_local);
+ − 232 #define XSYMBOL_VALUE_BUFFER_LOCAL(x) \
+ − 233 XRECORD (x, symbol_value_buffer_local, struct symbol_value_buffer_local)
+ − 234 #define SYMBOL_VALUE_BUFFER_LOCAL_P(x) RECORDP (x, symbol_value_buffer_local)
+ − 235
+ − 236 /* 3. symbol-value-lisp-magic */
+ − 237
+ − 238 enum lisp_magic_handler
+ − 239 {
+ − 240 MAGIC_HANDLER_GET_VALUE,
+ − 241 MAGIC_HANDLER_SET_VALUE,
+ − 242 MAGIC_HANDLER_BOUND_PREDICATE,
+ − 243 MAGIC_HANDLER_MAKE_UNBOUND,
+ − 244 MAGIC_HANDLER_LOCAL_PREDICATE,
+ − 245 MAGIC_HANDLER_MAKE_LOCAL,
+ − 246 MAGIC_HANDLER_MAX
+ − 247 };
+ − 248
+ − 249 struct symbol_value_lisp_magic
+ − 250 {
+ − 251 struct symbol_value_magic magic;
+ − 252 Lisp_Object handler[MAGIC_HANDLER_MAX];
+ − 253 Lisp_Object harg[MAGIC_HANDLER_MAX];
+ − 254 Lisp_Object shadowed;
+ − 255 };
+ − 256 DECLARE_LRECORD (symbol_value_lisp_magic, struct symbol_value_lisp_magic);
+ − 257 #define XSYMBOL_VALUE_LISP_MAGIC(x) \
+ − 258 XRECORD (x, symbol_value_lisp_magic, struct symbol_value_lisp_magic)
+ − 259 #define SYMBOL_VALUE_LISP_MAGIC_P(x) RECORDP (x, symbol_value_lisp_magic)
+ − 260
+ − 261 /* 4. symbol-value-varalias */
+ − 262
+ − 263 struct symbol_value_varalias
+ − 264 {
+ − 265 struct symbol_value_magic magic;
+ − 266 Lisp_Object aliasee;
+ − 267 Lisp_Object shadowed;
+ − 268 };
+ − 269 DECLARE_LRECORD (symbol_value_varalias, struct symbol_value_varalias);
+ − 270 #define XSYMBOL_VALUE_VARALIAS(x) \
+ − 271 XRECORD (x, symbol_value_varalias, struct symbol_value_varalias)
+ − 272 #define SYMBOL_VALUE_VARALIAS_P(x) RECORDP (x, symbol_value_varalias)
+ − 273 #define symbol_value_varalias_aliasee(m) ((m)->aliasee)
+ − 274 #define symbol_value_varalias_shadowed(m) ((m)->shadowed)
+ − 275
+ − 276 /* To define a Lisp primitive function using a C function `Fname', do this:
+ − 277 DEFUN ("name, Fname, ...); // at top level in foo.c
+ − 278 DEFSUBR (Fname); // in syms_of_foo();
+ − 279 */
3263
+ − 280 #ifdef NEW_GC
2720
+ − 281 MODULE_API void defsubr (Lisp_Subr *);
+ − 282 #define DEFSUBR_MC_ALLOC(Fname) \
2814
+ − 283 S##Fname= (struct Lisp_Subr *) mc_alloc (sizeof (struct Lisp_Subr)); \
2720
+ − 284 set_lheader_implementation (&S##Fname->lheader, &lrecord_subr); \
+ − 285 \
+ − 286 S##Fname->min_args = MC_ALLOC_S##Fname.min_args; \
+ − 287 S##Fname->max_args = MC_ALLOC_S##Fname.max_args; \
+ − 288 S##Fname->prompt = MC_ALLOC_S##Fname.prompt; \
+ − 289 S##Fname->doc = MC_ALLOC_S##Fname.doc; \
+ − 290 S##Fname->name = MC_ALLOC_S##Fname.name; \
+ − 291 S##Fname->subr_fn = MC_ALLOC_S##Fname.subr_fn; \
+ − 292 MARK_LRECORD_AS_LISP_READONLY (S##Fname);
+ − 293
+ − 294
+ − 295 #define DEFSUBR(Fname) \
+ − 296 do { \
+ − 297 DEFSUBR_MC_ALLOC (Fname); \
+ − 298 defsubr (S##Fname); \
+ − 299 } while (0)
+ − 300
+ − 301 /* To define a Lisp primitive macro using a C function `Fname', do this:
+ − 302 DEFUN ("name, Fname, ...); // at top level in foo.c
+ − 303 DEFSUBR_MACRO (Fname); // in syms_of_foo();
+ − 304 */
+ − 305 MODULE_API void defsubr_macro (Lisp_Subr *);
+ − 306 #define DEFSUBR_MACRO(Fname) \
+ − 307 do { \
+ − 308 DEFSUBR_MC_ALLOC (Fname); \
+ − 309 defsubr_macro (S##Fname); \
+ − 310 } while (0)
+ − 311
3263
+ − 312 #else /* not NEW_GC */
2720
+ − 313 /* To define a Lisp primitive function using a C function `Fname', do this:
+ − 314 DEFUN ("name, Fname, ...); // at top level in foo.c
+ − 315 DEFSUBR (Fname); // in syms_of_foo();
+ − 316 */
1632
+ − 317 MODULE_API void defsubr (Lisp_Subr *);
428
+ − 318 #define DEFSUBR(Fname) defsubr (&S##Fname)
+ − 319
+ − 320 /* To define a Lisp primitive macro using a C function `Fname', do this:
+ − 321 DEFUN ("name, Fname, ...); // at top level in foo.c
+ − 322 DEFSUBR_MACRO (Fname); // in syms_of_foo();
+ − 323 */
1632
+ − 324 MODULE_API void defsubr_macro (Lisp_Subr *);
428
+ − 325 #define DEFSUBR_MACRO(Fname) defsubr_macro (&S##Fname)
3263
+ − 326 #endif /* not NEW_GC */
428
+ − 327
1632
+ − 328 MODULE_API void defsymbol_massage_name (Lisp_Object *location,
+ − 329 const char *name);
+ − 330 MODULE_API void defsymbol_massage_name_nodump (Lisp_Object *location,
+ − 331 const char *name);
+ − 332 MODULE_API void defsymbol_massage_multiword_predicate (Lisp_Object *location,
+ − 333 const char *name);
+ − 334 MODULE_API void
+ − 335 defsymbol_massage_multiword_predicate_nodump (Lisp_Object *location,
+ − 336 const char *name);
+ − 337 MODULE_API void defsymbol (Lisp_Object *location, const char *name);
+ − 338 MODULE_API void defsymbol_nodump (Lisp_Object *location, const char *name);
442
+ − 339
563
+ − 340 /* Defining symbols:
+ − 341
+ − 342 (1) A standard symbol is defined with DEFSYMBOL. That means that
+ − 343 the symbol's print name can be derived from the symbol's variable
+ − 344 name by removing the initial Q and replacing underscores with hyphens.
+ − 345 (2) A keyword symbol is defined with DEFKEYWORD. That means that
+ − 346 the symbol's print name can be derived from the symbol's variable
+ − 347 name by removing the initial Q and replacing underscores with hyphens,
+ − 348 except that the initial underscore, which comes directly after the Q,
+ − 349 is replaced by a colon.
+ − 350 (3) DEFSYMBOL_MULTIWORD_PREDICATE is used for the predicates that are
+ − 351 associated with a particular type of Lisp Object. Because of the
+ − 352 limitations of C macros, they're always given a predicate symbol
+ − 353 whose C name simply appends `p' to the type name, modulo hyphen/
+ − 354 underscore conversion. Properly, however, the Lisp name should have
+ − 355 `-p' if there is more than one word in the type name.
+ − 356 DEFSYMBOL_MULTIWORD_PREDICATE is for these weird symbols -- the
+ − 357 C name as supplied to the macro should end with a `p' with no
+ − 358 underscore before it, and the macro will insert a hyphen there in
+ − 359 the Lisp name.
+ − 360 (4) In case you have some weird symbol where the equivalence between
+ − 361 the C and Lisp names is more complicated (e.g. the Lisp symbol has
+ − 362 non-alphabetic, non-numeric characters in it), you can just call
+ − 363 defsymbol() (the lowercase version) directly.
+ − 364 */
+ − 365
442
+ − 366 #define DEFSYMBOL(name) defsymbol_massage_name (&name, #name)
+ − 367 #define DEFSYMBOL_NO_DUMP(name) defsymbol_massage_name_nodump (&name, #name)
+ − 368 #define DEFSYMBOL_MULTIWORD_PREDICATE(name) \
+ − 369 defsymbol_massage_multiword_predicate (&name, #name)
+ − 370 #define DEFSYMBOL_MULTIWORD_PREDICATE_NO_DUMP(name) \
+ − 371 defsymbol_massage_multiword_predicate_nodump (&name, #name)
428
+ − 372
1632
+ − 373 MODULE_API void defkeyword (Lisp_Object *location, const char *name);
+ − 374 MODULE_API void defkeyword_massage_name (Lisp_Object *location,
+ − 375 const char *name);
442
+ − 376 #define DEFKEYWORD(name) defkeyword_massage_name (&name, #name)
428
+ − 377
1632
+ − 378 MODULE_API void deferror (Lisp_Object *symbol, const char *name,
+ − 379 const char *message, Lisp_Object inherits_from);
+ − 380 MODULE_API void deferror_massage_name (Lisp_Object *symbol, const char *name,
+ − 381 const char *message,
+ − 382 Lisp_Object inherits_from);
+ − 383 MODULE_API void deferror_massage_name_and_message (Lisp_Object *symbol,
+ − 384 const char *name,
+ − 385 Lisp_Object inherits_from);
442
+ − 386 #define DEFERROR(name, message, inherits_from) \
+ − 387 deferror_massage_name (&name, #name, message, inherits_from)
+ − 388 /* In this case, the error message is the same as the name, modulo some
+ − 389 prettifying */
+ − 390 #define DEFERROR_STANDARD(name, inherits_from) \
+ − 391 deferror_massage_name_and_message (&name, #name, inherits_from)
428
+ − 392
+ − 393 /* Macros we use to define forwarded Lisp variables.
+ − 394 These are used in the syms_of_FILENAME functions. */
+ − 395
1632
+ − 396 MODULE_API void defvar_magic (const char *symbol_name,
+ − 397 const struct symbol_value_forward *magic);
428
+ − 398
3263
+ − 399 #ifdef NEW_GC
2720
+ − 400 #define DEFVAR_SYMVAL_FWD(lname, c_location, forward_type, magic_fun) \
+ − 401 do \
+ − 402 { \
+ − 403 struct symbol_value_forward *I_hate_C = \
+ − 404 alloc_lrecord_type (struct symbol_value_forward, \
+ − 405 &lrecord_symbol_value_forward); \
+ − 406 /* mcpro ((Lisp_Object) I_hate_C);*/ \
+ − 407 \
+ − 408 MARK_LRECORD_AS_LISP_READONLY (I_hate_C); \
+ − 409 \
+ − 410 I_hate_C->magic.value = c_location; \
+ − 411 I_hate_C->magic.type = forward_type; \
+ − 412 I_hate_C->magicfun = magic_fun; \
+ − 413 \
+ − 414 defvar_magic ((lname), I_hate_C); \
+ − 415 } while (0)
3263
+ − 416 #else /* not NEW_GC */
771
+ − 417 #define DEFVAR_SYMVAL_FWD(lname, c_location, forward_type, magicfun) \
+ − 418 do \
+ − 419 { \
+ − 420 static const struct symbol_value_forward I_hate_C = \
+ − 421 { /* struct symbol_value_forward */ \
+ − 422 { /* struct symbol_value_magic */ \
3024
+ − 423 { /* struct old_lcrecord_header */ \
771
+ − 424 { /* struct lrecord_header */ \
+ − 425 lrecord_type_symbol_value_forward, /* lrecord_type_index */ \
+ − 426 1, /* mark bit */ \
+ − 427 1, /* c_readonly bit */ \
1111
+ − 428 1, /* lisp_readonly bit */ \
+ − 429 0 /* unused */ \
771
+ − 430 }, \
+ − 431 0, /* next */ \
+ − 432 0, /* uid */ \
+ − 433 0 /* free */ \
+ − 434 }, \
+ − 435 c_location, \
+ − 436 forward_type \
+ − 437 }, \
+ − 438 magicfun \
+ − 439 }; \
+ − 440 defvar_magic ((lname), &I_hate_C); \
428
+ − 441 } while (0)
3263
+ − 442 #endif /* not NEW_GC */
771
+ − 443 #define DEFVAR_SYMVAL_FWD_INT(lname, c_location, forward_type, magicfun) \
+ − 444 do \
+ − 445 { \
+ − 446 DEFVAR_SYMVAL_FWD (lname, c_location, forward_type, magicfun); \
+ − 447 dump_add_opaque_int (c_location); \
458
+ − 448 } while (0)
+ − 449
771
+ − 450 #define DEFVAR_SYMVAL_FWD_FIXNUM(lname, c_location, forward_type, magicfun) \
+ − 451 do \
+ − 452 { \
+ − 453 DEFVAR_SYMVAL_FWD (lname, c_location, forward_type, magicfun); \
+ − 454 dump_add_opaque_fixnum (c_location); \
442
+ − 455 } while (0)
+ − 456
771
+ − 457 #define DEFVAR_SYMVAL_FWD_OBJECT(lname, c_location, forward_type, magicfun) \
+ − 458 do \
+ − 459 { \
+ − 460 DEFVAR_SYMVAL_FWD (lname, c_location, forward_type, magicfun); \
+ − 461 { \
+ − 462 Lisp_Object *DSF_location = c_location; /* Type check */ \
+ − 463 staticpro (DSF_location); \
+ − 464 if (EQ (*DSF_location, Qnull_pointer)) *DSF_location = Qnil; \
+ − 465 } \
428
+ − 466 } while (0)
+ − 467
+ − 468 #define DEFVAR_LISP(lname, c_location) \
+ − 469 DEFVAR_SYMVAL_FWD_OBJECT (lname, c_location, SYMVAL_OBJECT_FORWARD, 0)
+ − 470 #define DEFVAR_CONST_LISP(lname, c_location) \
+ − 471 DEFVAR_SYMVAL_FWD_OBJECT (lname, c_location, SYMVAL_CONST_OBJECT_FORWARD, 0)
+ − 472 #define DEFVAR_SPECIFIER(lname, c_location) \
+ − 473 DEFVAR_SYMVAL_FWD_OBJECT (lname, c_location, SYMVAL_CONST_SPECIFIER_FORWARD, 0)
+ − 474 #define DEFVAR_INT(lname, c_location) \
458
+ − 475 DEFVAR_SYMVAL_FWD_FIXNUM (lname, c_location, SYMVAL_FIXNUM_FORWARD, 0)
428
+ − 476 #define DEFVAR_CONST_INT(lname, c_location) \
458
+ − 477 DEFVAR_SYMVAL_FWD_FIXNUM (lname, c_location, SYMVAL_CONST_FIXNUM_FORWARD, 0)
428
+ − 478 #define DEFVAR_BOOL(lname, c_location) \
442
+ − 479 DEFVAR_SYMVAL_FWD_INT (lname, c_location, SYMVAL_BOOLEAN_FORWARD, 0)
428
+ − 480 #define DEFVAR_CONST_BOOL(lname, c_location) \
442
+ − 481 DEFVAR_SYMVAL_FWD_INT (lname, c_location, SYMVAL_CONST_BOOLEAN_FORWARD, 0)
428
+ − 482 #define DEFVAR_LISP_MAGIC(lname, c_location, magicfun) \
440
+ − 483 DEFVAR_SYMVAL_FWD_OBJECT (lname, c_location, SYMVAL_OBJECT_FORWARD, magicfun)
428
+ − 484 #define DEFVAR_INT_MAGIC(lname, c_location, magicfun) \
458
+ − 485 DEFVAR_SYMVAL_FWD_FIXNUM (lname, c_location, SYMVAL_FIXNUM_FORWARD, magicfun)
428
+ − 486 #define DEFVAR_BOOL_MAGIC(lname, c_location, magicfun) \
442
+ − 487 DEFVAR_SYMVAL_FWD_INT (lname, c_location, SYMVAL_BOOLEAN_FORWARD, magicfun)
428
+ − 488
446
+ − 489 void flush_all_buffer_local_cache (void);
+ − 490
1743
+ − 491 END_C_DECLS
1650
+ − 492
440
+ − 493 #endif /* INCLUDED_symeval_h_ */