Mercurial > hg > xemacs-beta
annotate src/symeval.h @ 5533:11da5b828d10
shell-command and shell-command-on-region API compliant with FSF 23.3.1
| author | Mats Lidell <mats.lidell@cag.se> |
|---|---|
| date | Sun, 31 Jul 2011 01:29:09 +0200 |
| parents | 308d34e9f07d |
| children |
| rev | line source |
|---|---|
| 428 | 1 /* Definitions of symbol-value forwarding for XEmacs Lisp interpreter. |
| 2 Copyright (C) 1985, 1986, 1987, 1992, 1993 Free Software Foundation, Inc. | |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5127
diff
changeset
|
3 Copyright (C) 2000, 2001, 2002, 2010 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5280
diff
changeset
|
7 XEmacs is free software: you can redistribute it and/or modify it |
| 428 | 8 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5280
diff
changeset
|
9 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5280
diff
changeset
|
10 option) any later version. |
| 428 | 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 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5280
diff
changeset
|
18 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 428 | 19 |
| 20 /* Synched up with: Not in FSF. */ | |
| 21 | |
| 22 /* Fsymbol_value checks whether XSYMBOL (sym)->value is one of these, | |
| 23 * and does weird magic stuff if so */ | |
| 24 | |
| 440 | 25 #ifndef INCLUDED_symeval_h_ |
| 26 #define INCLUDED_symeval_h_ | |
| 428 | 27 |
| 1743 | 28 BEGIN_C_DECLS |
| 1650 | 29 |
| 428 | 30 enum symbol_value_type |
| 31 { | |
| 32 /* The following tags use the 'symbol_value_forward' structure | |
| 33 and are strictly for variables DEFVARed on the C level. */ | |
| 458 | 34 SYMVAL_FIXNUM_FORWARD, /* Forward C "Fixnum", really "EMACS_INT" */ |
| 428 | 35 SYMVAL_CONST_FIXNUM_FORWARD, /* Same, but can't be set */ |
| 36 SYMVAL_BOOLEAN_FORWARD, /* Forward C boolean ("int") */ | |
| 37 SYMVAL_CONST_BOOLEAN_FORWARD, /* Same, but can't be set */ | |
| 38 SYMVAL_OBJECT_FORWARD, /* Forward C Lisp_Object */ | |
| 39 SYMVAL_CONST_OBJECT_FORWARD, /* Same, but can't be set */ | |
| 40 SYMVAL_CONST_SPECIFIER_FORWARD, /* Same, can't be set, but gives a | |
| 41 different message when attempting to | |
| 42 set that says "use set-specifier" */ | |
| 43 SYMVAL_DEFAULT_BUFFER_FORWARD, /* Forward Lisp_Object into Vbuffer_defaults */ | |
| 44 SYMVAL_CURRENT_BUFFER_FORWARD, /* Forward Lisp_Object into current_buffer */ | |
| 45 SYMVAL_CONST_CURRENT_BUFFER_FORWARD, /* Forward Lisp_Object into | |
| 46 current_buffer, can't be set */ | |
| 47 SYMVAL_DEFAULT_CONSOLE_FORWARD, /* Forward Lisp_Object into | |
| 48 Vconsole_defaults */ | |
| 49 SYMVAL_SELECTED_CONSOLE_FORWARD, /* Forward Lisp_Object into | |
| 50 Vselected_console */ | |
| 51 SYMVAL_CONST_SELECTED_CONSOLE_FORWARD, /* Forward Lisp_Object into | |
| 52 Vselected_console, | |
| 53 can't be set */ | |
| 54 SYMVAL_UNBOUND_MARKER, /* Only Qunbound actually has this tag */ | |
| 55 | |
| 56 /* The following tags use the 'symbol_value_buffer_local' structure */ | |
| 57 SYMVAL_BUFFER_LOCAL, /* make-variable-buffer-local */ | |
| 58 SYMVAL_SOME_BUFFER_LOCAL, /* make-local-variable */ | |
| 59 | |
| 60 /* The following tag uses the 'symbol_value_lisp_magic' structure */ | |
| 61 SYMVAL_LISP_MAGIC, /* Forward to lisp callbacks */ | |
| 62 | |
| 63 /* The following tag uses the 'symbol_value_varalias' structure */ | |
| 64 SYMVAL_VARALIAS /* defvaralias */ | |
| 65 | |
| 66 #if 0 | |
| 67 /* NYI */ | |
| 68 SYMVAL_CONSTANT_SYMBOL, /* Self-evaluating symbol */ | |
| 69 /* NYI */ | |
| 70 #endif | |
| 71 }; | |
| 72 | |
| 458 | 73 /* Underlying C type used to implement DEFVAR_INT */ |
| 74 typedef EMACS_INT Fixnum; | |
| 75 | |
| 428 | 76 struct symbol_value_magic |
| 77 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5125
diff
changeset
|
78 NORMAL_LISP_OBJECT_HEADER header; |
| 442 | 79 void *value; |
| 428 | 80 enum symbol_value_type type; |
| 81 }; | |
| 442 | 82 #define SYMBOL_VALUE_MAGIC_P(x) \ |
| 83 (LRECORDP (x) && \ | |
| 84 XRECORD_LHEADER (x)->type <= lrecord_type_max_symbol_value_magic) | |
| 428 | 85 #define XSYMBOL_VALUE_MAGIC_TYPE(v) \ |
| 86 (((struct symbol_value_magic *) XPNTR (v))->type) | |
| 793 | 87 #define wrap_symbol_value_magic(p) wrap_pointer_1 (p) |
| 428 | 88 void print_symbol_value_magic (Lisp_Object, Lisp_Object, int); |
| 89 | |
| 90 /********** The various different symbol-value-magic types ***********/ | |
| 91 | |
| 92 /* 1. symbol-value-forward */ | |
| 93 | |
| 94 /* This type of symbol-value-magic is used for variables declared | |
| 95 DEFVAR_LISP, DEFVAR_INT, DEFVAR_BOOL, DEFVAR_BUFFER_LOCAL, | |
| 96 DEFVAR_BUFFER_DEFAULTS, DEFVAR_SPECIFIER, and for Qunbound. | |
| 97 | |
| 98 Note that some of these types of variables can be made buffer-local. | |
| 99 Then, the symbol's value field contains a symbol-value-buffer-local, | |
| 100 whose CURRENT-VALUE field then contains a symbol-value-forward. | |
| 101 */ | |
| 102 | |
| 103 struct symbol_value_forward | |
| 104 { | |
| 105 struct symbol_value_magic magic; | |
| 106 | |
| 107 /* `magicfun' is a function controlling the magic behavior of this | |
| 108 forward variable. | |
| 109 | |
| 110 SYM is the symbol being operated on (read, set, etc.); | |
| 111 | |
| 112 VAL is either the value to set or the value to be returned. | |
| 113 | |
| 114 IN_OBJECT is the buffer or console that the value is read in | |
| 115 or set in. A value of Qnil means that the current buffer | |
| 116 and possibly other buffers are being set. (This value will | |
| 117 never be passed for built-in buffer-local or console-local | |
| 118 variables such as `truncate-lines'.) (Currently, a value of | |
| 119 Qnil is always passed for DEFVAR_INT, DEFVAR_LISP, and | |
| 120 DEFVAR_BOOL variables; the code isn't smart enough to figure | |
| 121 out what buffers besides the current buffer are being | |
| 122 affected. Because the magic function is called | |
| 123 before the value is changed, it's not that easy | |
| 124 to determine which buffers are getting changed. | |
| 125 #### If this information is important, let me know | |
| 126 and I will look into providing it.) (Remember also | |
| 127 that the only console-local variables currently existing | |
| 128 are built-in ones, because others can't be created.) | |
| 129 | |
| 130 FLAGS gives more information about the operation being performed. | |
| 131 | |
| 132 The return value indicates what the magic function actually did. | |
| 133 | |
| 134 Currently FLAGS and the return value are not used. This | |
| 135 function is only called when the value of a forward variable | |
| 136 is about to be changed. Note that this can occur explicitly | |
| 137 through a call to `set', `setq', `set-default', or `setq-default', | |
| 138 or implicitly by the current buffer being changed. */ | |
| 139 int (*magicfun) (Lisp_Object sym, Lisp_Object *val, Lisp_Object in_object, | |
| 140 int flags); | |
| 141 }; | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
142 DECLARE_LISP_OBJECT (symbol_value_forward, struct symbol_value_forward); |
| 428 | 143 #define XSYMBOL_VALUE_FORWARD(x) \ |
| 144 XRECORD (x, symbol_value_forward, struct symbol_value_forward) | |
| 442 | 145 #define symbol_value_forward_forward(m) ((void *)((m)->magic.value)) |
| 428 | 146 #define symbol_value_forward_magicfun(m) ((m)->magicfun) |
| 147 | |
| 148 /* 2. symbol-value-buffer-local */ | |
| 149 | |
| 150 struct symbol_value_buffer_local | |
| 151 { | |
| 152 struct symbol_value_magic magic; | |
| 153 /* Used in a symbol value cell when the symbol's value is per-buffer. | |
| 154 | |
| 155 The type of the symbol-value-magic will be either | |
| 156 SYMVAL_BUFFER_LOCAL (i.e. `make-variable-buffer-local' was called) | |
| 157 or SYMVAL_SOME_BUFFER_LOCAL (i.e. `make-local-variable' was called). | |
| 158 The only difference between the two is that when setting the | |
| 159 former kind of variable, an implicit `make-local-variable' is | |
| 160 called. | |
| 161 | |
| 162 A buffer-local variable logically has | |
| 163 | |
| 164 -- a default value | |
| 165 -- local values in some buffers | |
| 166 | |
| 167 The primary place where the local values are stored is in each | |
| 168 buffer's local_var_alist slot. | |
| 169 | |
| 170 In the simplest implementation, all that this structure needs to | |
| 171 keep track of is the default value; to retrieve the value in | |
| 172 a buffer, look in that buffer's local_var_alist, and use the | |
| 173 default value if there is no local value. To implement | |
| 174 `make-local-variable' in a buffer, look in the buffer's | |
| 175 local_var_alist, and if no element exists for this symbol, | |
| 176 add one, copying the value from the default value. When setting | |
| 177 the value in a buffer, look in the buffer's local_var_alist, and set | |
| 178 the value in that list if an element exists for this symbol; | |
| 179 otherwise, set the default. (Remember that SYMVAL_BUFFER_LOCAL | |
| 180 variables implicitly call `make-local-variable' first, so when | |
| 181 setting a value, there will always be an entry in the buffer's | |
| 182 local_var_alist to set.) | |
| 183 | |
| 184 However, this operation is potentially slow. To speed it up, | |
| 185 we cache the value in one buffer in this structure. | |
| 186 | |
| 187 NOTE: This is *not* a write-through cache. I.e. when setting | |
| 188 the value in the buffer that is cached, we *only* change the | |
| 189 cache and don't write the value through to either the buffer's | |
| 190 local_var_alist or the default value. Therefore, when retrieving | |
| 191 a value in a buffer, you must *always* look in the cache to see if | |
| 192 it refers to that buffer. | |
| 193 | |
| 194 The cache consists of | |
| 195 | |
| 196 -- a buffer, or nil if the cache has not been set up | |
| 197 -- the value in that buffer | |
| 198 -- the element (a cons) from the buffer's local_var_alist, or | |
| 199 nil if there is no local value in the buffer | |
| 200 | |
| 201 These slots are called CURRENT-BUFFER, CURRENT-VALUE, and | |
| 202 CURRENT-ALIST-ELEMENT, respectively. | |
| 203 | |
| 204 If we want to examine or set the value in BUFFER and CURRENT-BUFFER | |
| 205 equals BUFFER, we just examine or set CURRENT-VALUE. Otherwise, | |
| 206 we store CURRENT-VALUE value into CURRENT-ALIST-ELEMENT (or maybe | |
| 207 into DEFAULT-VALUE), then find the appropriate alist element for | |
| 208 BUFFER and set up CURRENT-ALIST-ELEMENT. Then we set CURRENT-VALUE | |
| 209 out of that element (or maybe out of DEFAULT-VALUE), and store | |
| 210 BUFFER into CURRENT-BUFFER. | |
| 211 | |
| 212 If we are setting the variable and the current buffer does not have | |
| 213 an alist entry for this variable, an alist entry is created. | |
| 214 | |
| 215 Note that CURRENT-BUFFER's local_var_alist value for this variable | |
| 216 might be out-of-date (the correct value is stored in CURRENT-VALUE). | |
| 217 Similarly, if CURRENT-BUFFER sees the default value, then | |
| 218 DEFAULT-VALUE might be out-of-date. | |
| 219 | |
| 220 Note that CURRENT-VALUE (but not DEFAULT-VALUE) can be a | |
| 221 forwarding pointer. Each time it is examined or set, | |
| 222 forwarding must be done. | |
| 223 */ | |
| 224 Lisp_Object default_value; | |
| 225 Lisp_Object current_value; | |
| 226 Lisp_Object current_buffer; | |
| 227 Lisp_Object current_alist_element; | |
| 228 }; | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
229 DECLARE_LISP_OBJECT (symbol_value_buffer_local, struct symbol_value_buffer_local); |
| 428 | 230 #define XSYMBOL_VALUE_BUFFER_LOCAL(x) \ |
| 231 XRECORD (x, symbol_value_buffer_local, struct symbol_value_buffer_local) | |
| 232 #define SYMBOL_VALUE_BUFFER_LOCAL_P(x) RECORDP (x, symbol_value_buffer_local) | |
| 233 | |
| 234 /* 3. symbol-value-lisp-magic */ | |
| 235 | |
| 236 enum lisp_magic_handler | |
| 237 { | |
| 238 MAGIC_HANDLER_GET_VALUE, | |
| 239 MAGIC_HANDLER_SET_VALUE, | |
| 240 MAGIC_HANDLER_BOUND_PREDICATE, | |
| 241 MAGIC_HANDLER_MAKE_UNBOUND, | |
| 242 MAGIC_HANDLER_LOCAL_PREDICATE, | |
| 243 MAGIC_HANDLER_MAKE_LOCAL, | |
| 244 MAGIC_HANDLER_MAX | |
| 245 }; | |
| 246 | |
| 247 struct symbol_value_lisp_magic | |
| 248 { | |
| 249 struct symbol_value_magic magic; | |
| 250 Lisp_Object handler[MAGIC_HANDLER_MAX]; | |
| 251 Lisp_Object harg[MAGIC_HANDLER_MAX]; | |
| 252 Lisp_Object shadowed; | |
| 253 }; | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
254 DECLARE_LISP_OBJECT (symbol_value_lisp_magic, struct symbol_value_lisp_magic); |
| 428 | 255 #define XSYMBOL_VALUE_LISP_MAGIC(x) \ |
| 256 XRECORD (x, symbol_value_lisp_magic, struct symbol_value_lisp_magic) | |
| 257 #define SYMBOL_VALUE_LISP_MAGIC_P(x) RECORDP (x, symbol_value_lisp_magic) | |
| 258 | |
| 259 /* 4. symbol-value-varalias */ | |
| 260 | |
| 261 struct symbol_value_varalias | |
| 262 { | |
| 263 struct symbol_value_magic magic; | |
| 264 Lisp_Object aliasee; | |
| 265 Lisp_Object shadowed; | |
| 266 }; | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
267 DECLARE_LISP_OBJECT (symbol_value_varalias, struct symbol_value_varalias); |
| 428 | 268 #define XSYMBOL_VALUE_VARALIAS(x) \ |
| 269 XRECORD (x, symbol_value_varalias, struct symbol_value_varalias) | |
| 270 #define SYMBOL_VALUE_VARALIAS_P(x) RECORDP (x, symbol_value_varalias) | |
| 271 #define symbol_value_varalias_aliasee(m) ((m)->aliasee) | |
| 272 #define symbol_value_varalias_shadowed(m) ((m)->shadowed) | |
| 273 | |
| 274 /* To define a Lisp primitive function using a C function `Fname', do this: | |
| 275 DEFUN ("name, Fname, ...); // at top level in foo.c | |
| 276 DEFSUBR (Fname); // in syms_of_foo(); | |
| 277 */ | |
| 3263 | 278 #ifdef NEW_GC |
| 2720 | 279 MODULE_API void defsubr (Lisp_Subr *); |
| 280 #define DEFSUBR_MC_ALLOC(Fname) \ | |
| 2814 | 281 S##Fname= (struct Lisp_Subr *) mc_alloc (sizeof (struct Lisp_Subr)); \ |
| 2720 | 282 set_lheader_implementation (&S##Fname->lheader, &lrecord_subr); \ |
| 283 \ | |
| 284 S##Fname->min_args = MC_ALLOC_S##Fname.min_args; \ | |
| 285 S##Fname->max_args = MC_ALLOC_S##Fname.max_args; \ | |
| 286 S##Fname->prompt = MC_ALLOC_S##Fname.prompt; \ | |
| 287 S##Fname->doc = MC_ALLOC_S##Fname.doc; \ | |
| 288 S##Fname->name = MC_ALLOC_S##Fname.name; \ | |
| 289 S##Fname->subr_fn = MC_ALLOC_S##Fname.subr_fn; \ | |
| 290 MARK_LRECORD_AS_LISP_READONLY (S##Fname); | |
| 291 | |
| 292 | |
| 293 #define DEFSUBR(Fname) \ | |
| 294 do { \ | |
|
5280
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5142
diff
changeset
|
295 /* #### As far as I can see, this has no upside compared to the non-NEW_GC \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5142
diff
changeset
|
296 code. The MC_ALLOC_S##Fname structure is also in the dumped \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5142
diff
changeset
|
297 XEmacs. Aidan Kehoe, Mon Sep 20 23:14:01 IST 2010 */ \ |
| 2720 | 298 DEFSUBR_MC_ALLOC (Fname); \ |
| 299 defsubr (S##Fname); \ | |
| 300 } while (0) | |
| 301 | |
| 302 /* To define a Lisp primitive macro using a C function `Fname', do this: | |
| 303 DEFUN ("name, Fname, ...); // at top level in foo.c | |
| 304 DEFSUBR_MACRO (Fname); // in syms_of_foo(); | |
| 305 */ | |
| 306 MODULE_API void defsubr_macro (Lisp_Subr *); | |
| 307 #define DEFSUBR_MACRO(Fname) \ | |
| 308 do { \ | |
| 309 DEFSUBR_MC_ALLOC (Fname); \ | |
| 310 defsubr_macro (S##Fname); \ | |
| 311 } while (0) | |
| 312 | |
| 3263 | 313 #else /* not NEW_GC */ |
| 2720 | 314 /* To define a Lisp primitive function using a C function `Fname', do this: |
| 315 DEFUN ("name, Fname, ...); // at top level in foo.c | |
| 316 DEFSUBR (Fname); // in syms_of_foo(); | |
| 317 */ | |
| 1632 | 318 MODULE_API void defsubr (Lisp_Subr *); |
| 428 | 319 #define DEFSUBR(Fname) defsubr (&S##Fname) |
| 320 | |
| 321 /* To define a Lisp primitive macro using a C function `Fname', do this: | |
| 322 DEFUN ("name, Fname, ...); // at top level in foo.c | |
| 323 DEFSUBR_MACRO (Fname); // in syms_of_foo(); | |
| 324 */ | |
| 1632 | 325 MODULE_API void defsubr_macro (Lisp_Subr *); |
| 428 | 326 #define DEFSUBR_MACRO(Fname) defsubr_macro (&S##Fname) |
| 3263 | 327 #endif /* not NEW_GC */ |
| 428 | 328 |
| 1632 | 329 MODULE_API void defsymbol_massage_name (Lisp_Object *location, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
330 const Ascbyte *name); |
| 1632 | 331 MODULE_API void defsymbol_massage_name_nodump (Lisp_Object *location, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
332 const Ascbyte *name); |
| 1632 | 333 MODULE_API void defsymbol_massage_multiword_predicate (Lisp_Object *location, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
334 const Ascbyte *name); |
| 1632 | 335 MODULE_API void |
| 336 defsymbol_massage_multiword_predicate_nodump (Lisp_Object *location, | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
337 const Ascbyte *name); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
338 MODULE_API void defsymbol (Lisp_Object *location, const Ascbyte *name); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
339 MODULE_API void defsymbol_nodump (Lisp_Object *location, const Ascbyte *name); |
| 442 | 340 |
| 563 | 341 /* Defining symbols: |
| 342 | |
| 343 (1) A standard symbol is defined with DEFSYMBOL. That means that | |
| 344 the symbol's print name can be derived from the symbol's variable | |
| 345 name by removing the initial Q and replacing underscores with hyphens. | |
| 346 (2) A keyword symbol is defined with DEFKEYWORD. That means that | |
| 347 the symbol's print name can be derived from the symbol's variable | |
| 348 name by removing the initial Q and replacing underscores with hyphens, | |
| 349 except that the initial underscore, which comes directly after the Q, | |
| 350 is replaced by a colon. | |
| 351 (3) DEFSYMBOL_MULTIWORD_PREDICATE is used for the predicates that are | |
| 352 associated with a particular type of Lisp Object. Because of the | |
| 353 limitations of C macros, they're always given a predicate symbol | |
| 354 whose C name simply appends `p' to the type name, modulo hyphen/ | |
| 355 underscore conversion. Properly, however, the Lisp name should have | |
| 356 `-p' if there is more than one word in the type name. | |
| 357 DEFSYMBOL_MULTIWORD_PREDICATE is for these weird symbols -- the | |
| 358 C name as supplied to the macro should end with a `p' with no | |
| 359 underscore before it, and the macro will insert a hyphen there in | |
| 360 the Lisp name. | |
| 361 (4) In case you have some weird symbol where the equivalence between | |
| 362 the C and Lisp names is more complicated (e.g. the Lisp symbol has | |
| 363 non-alphabetic, non-numeric characters in it), you can just call | |
| 364 defsymbol() (the lowercase version) directly. | |
| 365 */ | |
| 366 | |
| 442 | 367 #define DEFSYMBOL(name) defsymbol_massage_name (&name, #name) |
| 368 #define DEFSYMBOL_NO_DUMP(name) defsymbol_massage_name_nodump (&name, #name) | |
| 369 #define DEFSYMBOL_MULTIWORD_PREDICATE(name) \ | |
| 370 defsymbol_massage_multiword_predicate (&name, #name) | |
| 371 #define DEFSYMBOL_MULTIWORD_PREDICATE_NO_DUMP(name) \ | |
| 372 defsymbol_massage_multiword_predicate_nodump (&name, #name) | |
| 428 | 373 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
374 MODULE_API void defkeyword (Lisp_Object *location, const Ascbyte *name); |
| 1632 | 375 MODULE_API void defkeyword_massage_name (Lisp_Object *location, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
376 const Ascbyte *name); |
| 442 | 377 #define DEFKEYWORD(name) defkeyword_massage_name (&name, #name) |
| 428 | 378 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
379 MODULE_API void deferror (Lisp_Object *symbol, const Ascbyte *name, |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
380 const Ascbyte *message, Lisp_Object inherits_from); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
381 MODULE_API void deferror_massage_name (Lisp_Object *symbol, const Ascbyte *name, |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
382 const Ascbyte *message, |
| 1632 | 383 Lisp_Object inherits_from); |
| 384 MODULE_API void deferror_massage_name_and_message (Lisp_Object *symbol, | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
385 const Ascbyte *name, |
| 1632 | 386 Lisp_Object inherits_from); |
| 442 | 387 #define DEFERROR(name, message, inherits_from) \ |
| 388 deferror_massage_name (&name, #name, message, inherits_from) | |
| 389 /* In this case, the error message is the same as the name, modulo some | |
| 390 prettifying */ | |
| 391 #define DEFERROR_STANDARD(name, inherits_from) \ | |
| 392 deferror_massage_name_and_message (&name, #name, inherits_from) | |
| 428 | 393 |
| 394 /* Macros we use to define forwarded Lisp variables. | |
| 395 These are used in the syms_of_FILENAME functions. */ | |
| 396 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
397 MODULE_API void defvar_magic (const Ascbyte *symbol_name, |
| 1632 | 398 const struct symbol_value_forward *magic); |
| 428 | 399 |
| 3263 | 400 #ifdef NEW_GC |
| 2720 | 401 #define DEFVAR_SYMVAL_FWD(lname, c_location, forward_type, magic_fun) \ |
| 402 do \ | |
| 403 { \ | |
| 404 struct symbol_value_forward *I_hate_C = \ | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5125
diff
changeset
|
405 XSYMBOL_VALUE_FORWARD (ALLOC_NORMAL_LISP_OBJECT (symbol_value_forward)); \ |
| 2720 | 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 */ \ |
| 771 | 429 }, \ |
| 430 0, /* next */ \ | |
| 431 }, \ | |
| 432 c_location, \ | |
| 433 forward_type \ | |
| 434 }, \ | |
| 435 magicfun \ | |
| 436 }; \ | |
| 437 defvar_magic ((lname), &I_hate_C); \ | |
| 428 | 438 } while (0) |
| 3263 | 439 #endif /* not NEW_GC */ |
| 771 | 440 #define DEFVAR_SYMVAL_FWD_INT(lname, c_location, forward_type, magicfun) \ |
| 441 do \ | |
| 442 { \ | |
| 443 DEFVAR_SYMVAL_FWD (lname, c_location, forward_type, magicfun); \ | |
| 444 dump_add_opaque_int (c_location); \ | |
| 458 | 445 } while (0) |
| 446 | |
| 771 | 447 #define DEFVAR_SYMVAL_FWD_FIXNUM(lname, c_location, forward_type, magicfun) \ |
| 448 do \ | |
| 449 { \ | |
| 450 DEFVAR_SYMVAL_FWD (lname, c_location, forward_type, magicfun); \ | |
| 451 dump_add_opaque_fixnum (c_location); \ | |
| 442 | 452 } while (0) |
| 453 | |
| 771 | 454 #define DEFVAR_SYMVAL_FWD_OBJECT(lname, c_location, forward_type, magicfun) \ |
| 455 do \ | |
| 456 { \ | |
| 457 DEFVAR_SYMVAL_FWD (lname, c_location, forward_type, magicfun); \ | |
| 458 { \ | |
| 459 Lisp_Object *DSF_location = c_location; /* Type check */ \ | |
|
4971
bcdf496e49d0
put back patch to get more informative staticpro debugging
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
460 staticpro_1 (DSF_location, lname); \ |
| 771 | 461 if (EQ (*DSF_location, Qnull_pointer)) *DSF_location = Qnil; \ |
| 462 } \ | |
| 428 | 463 } while (0) |
| 464 | |
| 465 #define DEFVAR_LISP(lname, c_location) \ | |
| 466 DEFVAR_SYMVAL_FWD_OBJECT (lname, c_location, SYMVAL_OBJECT_FORWARD, 0) | |
| 467 #define DEFVAR_CONST_LISP(lname, c_location) \ | |
| 468 DEFVAR_SYMVAL_FWD_OBJECT (lname, c_location, SYMVAL_CONST_OBJECT_FORWARD, 0) | |
| 469 #define DEFVAR_SPECIFIER(lname, c_location) \ | |
| 470 DEFVAR_SYMVAL_FWD_OBJECT (lname, c_location, SYMVAL_CONST_SPECIFIER_FORWARD, 0) | |
| 471 #define DEFVAR_INT(lname, c_location) \ | |
| 458 | 472 DEFVAR_SYMVAL_FWD_FIXNUM (lname, c_location, SYMVAL_FIXNUM_FORWARD, 0) |
| 428 | 473 #define DEFVAR_CONST_INT(lname, c_location) \ |
| 458 | 474 DEFVAR_SYMVAL_FWD_FIXNUM (lname, c_location, SYMVAL_CONST_FIXNUM_FORWARD, 0) |
| 428 | 475 #define DEFVAR_BOOL(lname, c_location) \ |
| 442 | 476 DEFVAR_SYMVAL_FWD_INT (lname, c_location, SYMVAL_BOOLEAN_FORWARD, 0) |
| 428 | 477 #define DEFVAR_CONST_BOOL(lname, c_location) \ |
| 442 | 478 DEFVAR_SYMVAL_FWD_INT (lname, c_location, SYMVAL_CONST_BOOLEAN_FORWARD, 0) |
| 428 | 479 #define DEFVAR_LISP_MAGIC(lname, c_location, magicfun) \ |
| 440 | 480 DEFVAR_SYMVAL_FWD_OBJECT (lname, c_location, SYMVAL_OBJECT_FORWARD, magicfun) |
| 428 | 481 #define DEFVAR_INT_MAGIC(lname, c_location, magicfun) \ |
| 458 | 482 DEFVAR_SYMVAL_FWD_FIXNUM (lname, c_location, SYMVAL_FIXNUM_FORWARD, magicfun) |
| 428 | 483 #define DEFVAR_BOOL_MAGIC(lname, c_location, magicfun) \ |
| 442 | 484 DEFVAR_SYMVAL_FWD_INT (lname, c_location, SYMVAL_BOOLEAN_FORWARD, magicfun) |
| 428 | 485 |
| 446 | 486 void flush_all_buffer_local_cache (void); |
| 487 | |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
488 struct multiple_value { |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5125
diff
changeset
|
489 NORMAL_LISP_OBJECT_HEADER header; |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
490 Elemcount count; |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
491 Elemcount allocated_count; |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
492 Elemcount first_desired; |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
493 Lisp_Object contents[1]; |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
494 }; |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
495 typedef struct multiple_value multiple_value; |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
496 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4677
diff
changeset
|
497 DECLARE_LISP_OBJECT (multiple_value, multiple_value); |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
498 #define MULTIPLE_VALUEP(x) RECORDP (x, multiple_value) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
499 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
500 #define XMULTIPLE_VALUE(x) XRECORD (x, multiple_value, multiple_value) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
501 #define wrap_multiple_value(p) wrap_record (p, multiple_value) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
502 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
503 #define CHECK_MULTIPLE_VALUE(x) CHECK_RECORD (x, multiple_value) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
504 #define CONCHECK_MULTIPLE_VALUE(x) CONCHECK_RECORD (x, multiple_value) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
505 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
506 #define multiple_value_count(x) ((x)->count) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
507 #define multiple_value_allocated_count(x) ((x)->allocated_count) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
508 #define multiple_value_first_desired(x) ((x)->first_desired) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
509 #define multiple_value_contents(x) ((x)->contents) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
510 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
511 #define XMULTIPLE_VALUE_COUNT(x) multiple_value_count (XMULTIPLE_VALUE (x)) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
512 #define XMULTIPLE_VALUE_ALLOCATED_COUNT(x) \ |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
513 multiple_value_allocated_count (XMULTIPLE_VALUE (x)) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
514 #define XMULTIPLE_VALUE_FIRST_DESIRED(x) \ |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
515 multiple_value_first_desired (XMULTIPLE_VALUE(x)) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
516 #define XMULTIPLE_VALUE_CONTENTS(x) multiple_value_contents (XMULTIPLE_VALUE(x)) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
517 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
518 Lisp_Object multiple_value_call (int nargs, Lisp_Object *args); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
519 Lisp_Object multiple_value_list_internal (int nargs, Lisp_Object *args); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
520 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
521 /* It's slightly ugly to expose this here, but it does cut down the amount |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
522 of work the bytecode interpreter has to do substantially. */ |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
523 extern int multiple_value_current_limit; |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
524 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
525 /* Bind the multiple value limits that #'values and #'values-list pay |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
526 attention to. Used by bytecode and interpreted code. */ |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
527 int bind_multiple_value_limits (int first, int upper); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
528 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
529 Lisp_Object multiple_value_aref (Lisp_Object, Elemcount); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
530 void multiple_value_aset (Lisp_Object, Elemcount, Lisp_Object); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
531 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
532 Lisp_Object values2 (Lisp_Object first, Lisp_Object second); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
533 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
534 DECLARE_INLINE_HEADER ( |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
535 Lisp_Object |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
536 ignore_multiple_values (Lisp_Object obj) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
537 ) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
538 { |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
539 return MULTIPLE_VALUEP (obj) ? multiple_value_aref (obj, 0) : obj; |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
540 } |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
541 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
542 #ifdef ERROR_CHECK_MULTIPLE_VALUES |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
543 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
544 DECLARE_INLINE_HEADER ( |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
545 Lisp_Object |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
546 ignore_multiple_values_1 (Lisp_Object obj) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
547 ) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
548 { |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
549 if (1 == multiple_value_current_limit) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
550 { |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
551 assert (!MULTIPLE_VALUEP (obj)); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
552 return obj; |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
553 } |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
554 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
555 return ignore_multiple_values (obj); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
556 } |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
557 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
558 #define IGNORE_MULTIPLE_VALUES(X) ignore_multiple_values_1 (X) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
559 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
560 #else |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
561 #define IGNORE_MULTIPLE_VALUES(X) (multiple_value_current_limit == 1 ? (X) \ |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
562 : ignore_multiple_values (X)) |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
563 #endif |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3263
diff
changeset
|
564 |
| 1743 | 565 END_C_DECLS |
| 1650 | 566 |
| 440 | 567 #endif /* INCLUDED_symeval_h_ */ |