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