|
0
|
1 /* Definitions of symbol-value forwarding for XEmacs Lisp interpreter.
|
|
|
2 Copyright (C) 1985, 1986, 1987, 1992, 1993 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 This file is part of XEmacs.
|
|
|
5
|
|
|
6 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
7 under the terms of the GNU General Public License as published by the
|
|
|
8 Free Software Foundation; either version 2, or (at your option) any
|
|
|
9 later version.
|
|
|
10
|
|
|
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
|
15
|
|
|
16 You should have received a copy of the GNU General Public License
|
|
|
17 along with XEmacs; see the file COPYING. If not, write to
|
|
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
19 Boston, MA 02111-1307, USA. */
|
|
|
20
|
|
|
21 /* Synched up with: Not in FSF. */
|
|
|
22
|
|
|
23 /* Fsymbol_value checks whether XSYMBOL (sym)->value is one of these,
|
|
|
24 * and does weird magic stuff if so */
|
|
|
25
|
|
|
26 #ifndef _XEMACS_SYMEVAL_H_
|
|
|
27 #define _XEMACS_SYMEVAL_H_
|
|
|
28
|
|
185
|
29 enum symbol_value_type
|
|
|
30 {
|
|
|
31 /* The following tags use the 'symbol_value_forward' structure
|
|
|
32 and are strictly for variables DEFVARed on the C level. */
|
|
|
33 SYMVAL_FIXNUM_FORWARD, /* Forward C "int" */
|
|
|
34 SYMVAL_CONST_FIXNUM_FORWARD, /* Same, but can't be set */
|
|
|
35 SYMVAL_BOOLEAN_FORWARD, /* Forward C boolean ("int") */
|
|
|
36 SYMVAL_CONST_BOOLEAN_FORWARD, /* Same, but can't be set */
|
|
|
37 SYMVAL_OBJECT_FORWARD, /* Forward C Lisp_Object */
|
|
|
38 SYMVAL_CONST_OBJECT_FORWARD, /* Same, but can't be set */
|
|
|
39 SYMVAL_CONST_SPECIFIER_FORWARD, /* Same, can't be set, but gives a
|
|
|
40 different message when attempting to
|
|
|
41 set that says "use set-specifier" */
|
|
|
42 SYMVAL_DEFAULT_BUFFER_FORWARD, /* Forward Lisp_Object into Vbuffer_defaults */
|
|
|
43 SYMVAL_CURRENT_BUFFER_FORWARD, /* Forward Lisp_Object into current_buffer */
|
|
|
44 SYMVAL_CONST_CURRENT_BUFFER_FORWARD, /* Forward Lisp_Object into
|
|
|
45 current_buffer, can't be set */
|
|
|
46 SYMVAL_DEFAULT_CONSOLE_FORWARD, /* Forward Lisp_Object into
|
|
|
47 Vconsole_defaults */
|
|
|
48 SYMVAL_SELECTED_CONSOLE_FORWARD, /* Forward Lisp_Object into
|
|
|
49 Vselected_console */
|
|
|
50 SYMVAL_CONST_SELECTED_CONSOLE_FORWARD, /* Forward Lisp_Object into
|
|
|
51 Vselected_console,
|
|
|
52 can't be set */
|
|
|
53 SYMVAL_UNBOUND_MARKER, /* Only Qunbound actually has this tag */
|
|
|
54
|
|
|
55 /* The following tags use the 'symbol_value_buffer_local' structure */
|
|
|
56 SYMVAL_BUFFER_LOCAL, /* make-variable-buffer-local */
|
|
|
57 SYMVAL_SOME_BUFFER_LOCAL, /* make-local-variable */
|
|
|
58
|
|
|
59 /* The following tag uses the 'symbol_value_lisp_magic' structure */
|
|
|
60 SYMVAL_LISP_MAGIC, /* Forward to lisp callbacks */
|
|
|
61
|
|
|
62 /* The following tag uses the 'symbol_value_varalias' structure */
|
|
|
63 SYMVAL_VARALIAS /* defvaralias */
|
|
|
64
|
|
|
65 #if 0
|
|
|
66 /* NYI */
|
|
|
67 SYMVAL_CONSTANT_SYMBOL, /* Self-evaluating symbol */
|
|
|
68 /* NYI */
|
|
|
69 #endif
|
|
|
70 };
|
|
|
71
|
|
0
|
72 struct symbol_value_magic
|
|
|
73 {
|
|
|
74 struct lcrecord_header lcheader;
|
|
185
|
75 enum symbol_value_type type;
|
|
0
|
76 };
|
|
|
77 #define SYMBOL_VALUE_MAGIC_P(x) \
|
|
|
78 (LRECORDP (x) \
|
|
|
79 && (XRECORD_LHEADER (x)->implementation->printer \
|
|
|
80 == print_symbol_value_magic))
|
|
|
81 #define XSYMBOL_VALUE_MAGIC_TYPE(v) \
|
|
|
82 (((struct symbol_value_magic *) XPNTR (v))->type)
|
|
185
|
83 #define XSETSYMBOL_VALUE_MAGIC(s, p) XSETOBJ (s, Lisp_Type_Record, p)
|
|
0
|
84 extern void print_symbol_value_magic (Lisp_Object, Lisp_Object, int);
|
|
|
85
|
|
|
86 /********** The various different symbol-value-magic types ***********/
|
|
|
87
|
|
|
88 /* 1. symbol-value-forward */
|
|
|
89
|
|
|
90 /* This type of symbol-value-magic is used for variables declared
|
|
|
91 DEFVAR_LISP, DEFVAR_INT, DEFVAR_BOOL, DEFVAR_BUFFER_LOCAL,
|
|
|
92 DEFVAR_BUFFER_DEFAULTS, DEFVAR_SPECIFIER, and for Qunbound.
|
|
|
93
|
|
|
94 Note that some of these types of variables can be made buffer-local.
|
|
|
95 Then, the symbol's value field contains a symbol-value-buffer-local,
|
|
|
96 whose CURRENT-VALUE field then contains a symbol-value-forward.
|
|
|
97 */
|
|
185
|
98
|
|
0
|
99 extern CONST_IF_NOT_DEBUG struct lrecord_implementation
|
|
|
100 lrecord_symbol_value_forward[];
|
|
|
101 struct symbol_value_forward
|
|
|
102 {
|
|
|
103 struct symbol_value_magic magic;
|
|
|
104 /* void *forward; -- use magic.lcheader.next instead */
|
|
|
105 /* Function controlling magic behavior of this forward variable.
|
|
|
106
|
|
|
107 SYM is the symbol being operated on (read, set, etc.);
|
|
|
108
|
|
|
109 VAL is either the value to set or the value to be returned.
|
|
|
110
|
|
|
111 IN_OBJECT is the buffer or console that the value is read in
|
|
|
112 or set in. A value of Qnil means that the current buffer
|
|
|
113 and possibly other buffers are being set. (This value will
|
|
|
114 never be passed for built-in buffer-local or console-local
|
|
|
115 variables such as `truncate-lines'.) (Currently, a value of
|
|
|
116 Qnil is always passed for DEFVAR_INT, DEFVAR_LISP, and
|
|
|
117 DEFVAR_BOOL variables; the code isn't smart enough to figure
|
|
|
118 out what buffers besides the current buffer are being
|
|
|
119 affected. Because the magic function is called
|
|
|
120 before the value is changed, it's not that easy
|
|
|
121 to determine which buffers are getting changed.
|
|
|
122 #### If this information is important, let me know
|
|
|
123 and I will look into providing it.) (Remember also
|
|
|
124 that the only console-local variables currently existing
|
|
|
125 are built-in ones, because others can't be created.)
|
|
|
126
|
|
|
127 FLAGS gives more information about the operation being
|
|
|
128 performed.
|
|
|
129
|
|
|
130 The return value indicates what the magic function actually
|
|
|
131 did.
|
|
|
132
|
|
|
133 Currently FLAGS and the return value are not used. This
|
|
|
134 function is only called when the value of a forward variable
|
|
|
135 is about to be changed. Note that this can occur explicitly
|
|
|
136 through a call to `set', `setq', `set-default', or `setq-default',
|
|
|
137 or implicitly by the current buffer being changed.
|
|
|
138
|
|
|
139 */
|
|
185
|
140
|
|
0
|
141 int (*magicfun) (Lisp_Object sym, Lisp_Object *val, Lisp_Object in_object,
|
|
|
142 int flags);
|
|
|
143 };
|
|
|
144 #define XSYMBOL_VALUE_FORWARD(v) \
|
|
|
145 ((CONST struct symbol_value_forward *) XPNTR(v))
|
|
|
146 #define symbol_value_forward_forward(m) ((void *)((m)->magic.lcheader.next))
|
|
|
147 #define symbol_value_forward_magicfun(m) ((m)->magicfun)
|
|
|
148
|
|
|
149 /* 2. symbol-value-buffer-local */
|
|
|
150
|
|
|
151 extern CONST_IF_NOT_DEBUG struct lrecord_implementation
|
|
|
152 lrecord_symbol_value_buffer_local[];
|
|
|
153 struct symbol_value_buffer_local
|
|
|
154 {
|
|
|
155 struct symbol_value_magic magic;
|
|
|
156 /* Used in a symbol value cell when the symbol's value is per-buffer.
|
|
|
157
|
|
|
158 The type of the symbol-value-magic will be either
|
|
|
159 SYMVAL_BUFFER_LOCAL (i.e. `make-variable-buffer-local' was called)
|
|
|
160 or SYMVAL_SOME_BUFFER_LOCAL (i.e. `make-local-variable' was called).
|
|
|
161 The only difference between the two is that when setting the
|
|
|
162 former kind of variable, an implicit `make-local-variable' is
|
|
|
163 called.
|
|
|
164
|
|
|
165 A buffer-local variable logically has
|
|
|
166
|
|
|
167 -- a default value
|
|
|
168 -- local values in some buffers
|
|
|
169
|
|
|
170 The primary place where the local values are stored is in each
|
|
|
171 buffer's local_var_alist slot.
|
|
|
172
|
|
|
173 In the simplest implementation, all that this structure needs to
|
|
|
174 keep track of is the default value; to retrieve the value in
|
|
|
175 a buffer, look in that buffer's local_var_alist, and use the
|
|
|
176 default value if there is no local value. To implement
|
|
|
177 `make-local-variable' in a buffer, look in the buffer's
|
|
|
178 local_var_alist, and if no element exists for this symbol,
|
|
|
179 add one, copying the value from the default value. When setting
|
|
|
180 the value in a buffer, look in the buffer's local_var_alist, and set
|
|
|
181 the value in that list if an element exists for this symbol;
|
|
|
182 otherwise, set the default. (Remember that SYMVAL_BUFFER_LOCAL
|
|
|
183 variables implicitly call `make-local-variable' first, so when
|
|
|
184 setting a value, there will always be an entry in the buffer's
|
|
|
185 local_var_alist to set.)
|
|
|
186
|
|
|
187 However, these operation is potentially slow. To speed it up,
|
|
|
188 we cache the value in one buffer in this structure.
|
|
|
189
|
|
|
190 NOTE: This is *not* a write-through cache. I.e. when setting
|
|
|
191 the value in the buffer that is cached, we *only* change the
|
|
|
192 cache and don't write the value through to either the buffer's
|
|
|
193 local_var_alist or the default value. Therefore, when retrieving
|
|
|
194 a value in a buffer, you must *always* look in the cache to see if
|
|
|
195 it refers to that buffer.
|
|
|
196
|
|
|
197 The cache consists of
|
|
|
198
|
|
|
199 -- a buffer, or nil if the cache has not been set up
|
|
|
200 -- the value in that buffer
|
|
|
201 -- the element (a cons) from the buffer's local_var_alist, or
|
|
|
202 nil if there is no local value in the buffer
|
|
|
203
|
|
|
204 These slots are called CURRENT-BUFFER, CURRENT-VALUE, and
|
|
|
205 CURRENT-ALIST-ELEMENT, respectively.
|
|
185
|
206
|
|
0
|
207 If we want to examine or set the value in BUFFER and CURRENT-BUFFER
|
|
|
208 equals BUFFER, we just examine or set CURRENT-VALUE. Otherwise,
|
|
|
209 we store CURRENT-VALUE value into CURRENT-ALIST-ELEMENT (or maybe
|
|
|
210 into DEFAULT-VALUE), then find the appropriate alist element for
|
|
|
211 BUFFER and set up CURRENT-ALIST-ELEMENT. Then we set CURRENT-VALUE
|
|
|
212 out of that element (or maybe out of DEFAULT-VALUE), and store
|
|
|
213 BUFFER into CURRENT-BUFFER.
|
|
185
|
214
|
|
0
|
215 If we are setting the variable and the current buffer does not have
|
|
|
216 an alist entry for this variable, an alist entry is created.
|
|
185
|
217
|
|
0
|
218 Note that CURRENT-BUFFER's local_var_alist value for this variable
|
|
|
219 might be out-of-date (the correct value is stored in CURRENT-VALUE).
|
|
|
220 Similarly, if CURRENT-BUFFER sees the default value, then
|
|
|
221 DEFAULT-VALUE might be out-of-date.
|
|
185
|
222
|
|
0
|
223 Note that CURRENT-VALUE (but not DEFAULT-VALUE) can be a
|
|
185
|
224 forwarding pointer. Each time it is examined or set,
|
|
0
|
225 forwarding must be done.
|
|
|
226 */
|
|
|
227 Lisp_Object default_value;
|
|
|
228 Lisp_Object current_value;
|
|
|
229 Lisp_Object current_buffer;
|
|
|
230 Lisp_Object current_alist_element;
|
|
|
231 };
|
|
|
232 #define XSYMBOL_VALUE_BUFFER_LOCAL(v) \
|
|
|
233 ((struct symbol_value_buffer_local *) XPNTR(v))
|
|
|
234 #define SYMBOL_VALUE_BUFFER_LOCAL_P(v) \
|
|
|
235 (SYMBOL_VALUE_MAGIC_P (v) && \
|
|
|
236 (XSYMBOL_VALUE_MAGIC_TYPE (v) == SYMVAL_BUFFER_LOCAL \
|
|
|
237 || XSYMBOL_VALUE_MAGIC_TYPE (v) == SYMVAL_SOME_BUFFER_LOCAL))
|
|
|
238
|
|
|
239 /* 3. symbol-value-lisp-magic */
|
|
|
240
|
|
|
241 extern CONST_IF_NOT_DEBUG struct lrecord_implementation
|
|
|
242 lrecord_symbol_value_lisp_magic[];
|
|
|
243 enum lisp_magic_handler
|
|
|
244 {
|
|
|
245 MAGIC_HANDLER_GET_VALUE,
|
|
|
246 MAGIC_HANDLER_SET_VALUE,
|
|
|
247 MAGIC_HANDLER_BOUND_PREDICATE,
|
|
|
248 MAGIC_HANDLER_MAKE_UNBOUND,
|
|
|
249 MAGIC_HANDLER_LOCAL_PREDICATE,
|
|
|
250 MAGIC_HANDLER_MAKE_LOCAL,
|
|
|
251 MAGIC_HANDLER_MAX
|
|
|
252 };
|
|
|
253
|
|
|
254 struct symbol_value_lisp_magic
|
|
|
255 {
|
|
|
256 struct symbol_value_magic magic;
|
|
|
257 Lisp_Object handler[MAGIC_HANDLER_MAX];
|
|
|
258 Lisp_Object harg[MAGIC_HANDLER_MAX];
|
|
|
259 Lisp_Object shadowed;
|
|
|
260 };
|
|
|
261 #define XSYMBOL_VALUE_LISP_MAGIC(v) \
|
|
|
262 ((struct symbol_value_lisp_magic *) XPNTR (v))
|
|
|
263 #define SYMBOL_VALUE_LISP_MAGIC_P(v) \
|
|
|
264 (SYMBOL_VALUE_MAGIC_P (v) && \
|
|
|
265 XSYMBOL_VALUE_MAGIC_TYPE (v) == SYMVAL_LISP_MAGIC)
|
|
|
266
|
|
|
267 /* 4. symbol-value-varalias */
|
|
|
268
|
|
|
269 extern CONST_IF_NOT_DEBUG struct lrecord_implementation
|
|
|
270 lrecord_symbol_value_varalias[];
|
|
|
271 struct symbol_value_varalias
|
|
|
272 {
|
|
|
273 struct symbol_value_magic magic;
|
|
|
274 Lisp_Object aliasee;
|
|
|
275 Lisp_Object shadowed;
|
|
|
276 };
|
|
|
277 #define XSYMBOL_VALUE_VARALIAS(v) \
|
|
|
278 ((struct symbol_value_varalias *) XPNTR (v))
|
|
|
279 #define SYMBOL_VALUE_VARALIAS_P(v) \
|
|
|
280 (SYMBOL_VALUE_MAGIC_P (v) && \
|
|
|
281 XSYMBOL_VALUE_MAGIC_TYPE (v) == SYMVAL_VARALIAS)
|
|
|
282 #define symbol_value_varalias_aliasee(m) ((m)->aliasee)
|
|
|
283 #define symbol_value_varalias_shadowed(m) ((m)->shadowed)
|
|
|
284
|
|
16
|
285 /* DEFSUBR (Fname);
|
|
|
286 is how we define the symbol for function `Fname' at start-up time. */
|
|
|
287 #define DEFSUBR(Fname) defsubr (&S##Fname)
|
|
0
|
288 extern void defsubr (struct Lisp_Subr *);
|
|
|
289
|
|
|
290 extern void defsymbol (Lisp_Object *location, CONST char *name);
|
|
|
291
|
|
|
292 extern void defkeyword (Lisp_Object *location, CONST char *name);
|
|
|
293
|
|
|
294 extern void deferror (Lisp_Object *symbol, CONST char *name,
|
|
|
295 CONST char *message, Lisp_Object inherits_from);
|
|
|
296
|
|
|
297 /* Macros we use to define forwarded Lisp variables.
|
|
|
298 These are used in the syms_of_FILENAME functions. */
|
|
|
299
|
|
|
300 extern void defvar_mumble (CONST char *names,
|
|
|
301 CONST void *magic, int sizeof_magic);
|
|
|
302
|
|
185
|
303 #define DEFVAR_HEADER(lname, c_location, forward_type) do { \
|
|
|
304 static CONST struct symbol_value_forward I_hate_C \
|
|
|
305 = { { { { lrecord_symbol_value_forward }, \
|
|
|
306 (struct lcrecord_header *) (c_location), 69 }, \
|
|
|
307 forward_type }, 0 }; \
|
|
|
308 defvar_mumble ((lname), &I_hate_C, sizeof (I_hate_C)); \
|
|
|
309 } while (0)
|
|
0
|
310
|
|
185
|
311 #define DEFVAR_MAGIC_HEADER(lname, c_location, forward_type, magicfun) do { \
|
|
|
312 static CONST struct symbol_value_forward I_hate_C \
|
|
|
313 = { { { { lrecord_symbol_value_forward }, \
|
|
|
314 (struct lcrecord_header *) (c_location), 69 }, \
|
|
|
315 forward_type }, magicfun }; \
|
|
|
316 defvar_mumble ((lname), &I_hate_C, sizeof (I_hate_C)); \
|
|
|
317 } while (0)
|
|
0
|
318
|
|
|
319 /* These discard their DOC arg because it is snarfed by make-docfile
|
|
|
320 * and stored in an external file. */
|
|
|
321
|
|
185
|
322 #define DEFVAR_HEADER_GCPRO(lname, c_location, symbol_value_type) do { \
|
|
|
323 DEFVAR_HEADER (lname, c_location, symbol_value_type); \
|
|
|
324 staticpro (c_location); \
|
|
|
325 } while (0)
|
|
0
|
326
|
|
185
|
327 #define DEFVAR_LISP(lname, c_location) \
|
|
|
328 DEFVAR_HEADER_GCPRO (lname, c_location, SYMVAL_OBJECT_FORWARD)
|
|
|
329 #define DEFVAR_CONST_LISP(lname, c_location) \
|
|
|
330 DEFVAR_HEADER_GCPRO (lname, c_location, SYMVAL_CONST_OBJECT_FORWARD)
|
|
|
331 #define DEFVAR_SPECIFIER(lname, c_location) \
|
|
|
332 DEFVAR_HEADER_GCPRO (lname, c_location, SYMVAL_CONST_SPECIFIER_FORWARD)
|
|
|
333 #define DEFVAR_INT(lname, c_location) \
|
|
|
334 DEFVAR_HEADER (lname, c_location, SYMVAL_FIXNUM_FORWARD)
|
|
|
335 #define DEFVAR_CONST_INT(lname, c_location) \
|
|
|
336 DEFVAR_HEADER (lname, c_location, SYMVAL_CONST_FIXNUM_FORWARD)
|
|
|
337 #define DEFVAR_BOOL(lname, c_location) \
|
|
|
338 DEFVAR_HEADER (lname, c_location, SYMVAL_BOOLEAN_FORWARD)
|
|
|
339 #define DEFVAR_CONST_BOOL(lname, c_location) \
|
|
|
340 DEFVAR_HEADER (lname, c_location, SYMVAL_CONST_BOOLEAN_FORWARD)
|
|
|
341
|
|
|
342 #define DEFVAR_LISP_MAGIC(lname, c_location, magicfun) do { \
|
|
|
343 DEFVAR_MAGIC_HEADER (lname, c_location, SYMVAL_OBJECT_FORWARD, magicfun); \
|
|
|
344 staticpro (c_location); \
|
|
|
345 } while (0)
|
|
|
346 #define DEFVAR_INT_MAGIC(lname, c_location, magicfun) \
|
|
|
347 DEFVAR_MAGIC_HEADER (lname, c_location, SYMVAL_FIXNUM_FORWARD, magicfun);
|
|
|
348 #define DEFVAR_BOOL_MAGIC(lname, c_location, magicfun) \
|
|
|
349 DEFVAR_MAGIC_HEADER (lname, c_location, SYMVAL_BOOLEAN_FORWARD, magicfun);
|
|
0
|
350
|
|
|
351 #endif /* _XEMACS_SYMEVAL_H_ */
|
