|
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 */
|
|
2720
|
280 #ifdef MC_ALLOC
|
|
|
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
|
|
|
312 #else /* not MC_ALLOC */
|
|
|
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)
|
|
2720
|
326 #endif /* not MC_ALLOC */
|
|
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
|
|
2720
|
399 #ifdef MC_ALLOC
|
|
|
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)
|
|
|
416 #else /* not MC_ALLOC */
|
|
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)
|
|
2720
|
442 #endif /* not MC_ALLOC */
|
|
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_ */
|
