Mercurial > hg > xemacs-beta
comparison src/backtrace.h @ 398:74fd4e045ea6 r21-2-29
Import from CVS: tag r21-2-29
author | cvs |
---|---|
date | Mon, 13 Aug 2007 11:13:30 +0200 |
parents | aabb7f5b1c81 |
children | 697ef44129c6 |
comparison
equal
deleted
inserted
replaced
397:f4aeb21a5bad | 398:74fd4e045ea6 |
---|---|
28 file couldn't be used in FSF Emacs, but XEmacs doesn't have | 28 file couldn't be used in FSF Emacs, but XEmacs doesn't have |
29 that problem.) | 29 that problem.) |
30 Mly (probably) or JWZ: Some changes. | 30 Mly (probably) or JWZ: Some changes. |
31 */ | 31 */ |
32 | 32 |
33 #ifndef _XEMACS_BACKTRACE_H_ | 33 #ifndef INCLUDED_backtrace_h_ |
34 #define _XEMACS_BACKTRACE_H_ | 34 #define INCLUDED_backtrace_h_ |
35 | 35 |
36 #include <setjmp.h> | 36 #include <setjmp.h> |
37 | 37 |
38 /* These definitions are used in eval.c and alloc.c */ | 38 /* These definitions are used in eval.c and alloc.c */ |
39 | 39 |
156 to save the overhead of even a single function call. */ | 156 to save the overhead of even a single function call. */ |
157 #define SPECBIND(symbol_object, value_object) do { \ | 157 #define SPECBIND(symbol_object, value_object) do { \ |
158 Lisp_Object SB_symbol = (symbol_object); \ | 158 Lisp_Object SB_symbol = (symbol_object); \ |
159 Lisp_Object SB_newval = (value_object); \ | 159 Lisp_Object SB_newval = (value_object); \ |
160 Lisp_Object SB_oldval; \ | 160 Lisp_Object SB_oldval; \ |
161 struct Lisp_Symbol *SB_sym; \ | 161 Lisp_Symbol *SB_sym; \ |
162 \ | 162 \ |
163 SPECPDL_RESERVE (1); \ | 163 SPECPDL_RESERVE (1); \ |
164 \ | 164 \ |
165 CHECK_SYMBOL (SB_symbol); \ | 165 CHECK_SYMBOL (SB_symbol); \ |
166 SB_sym = XSYMBOL (SB_symbol); \ | 166 SB_sym = XSYMBOL (SB_symbol); \ |
167 SB_oldval = SB_sym->value; \ | 167 SB_oldval = SB_sym->value; \ |
168 \ | 168 \ |
169 if (!SYMBOL_VALUE_MAGIC_P (SB_oldval) || UNBOUNDP (SB_oldval)) \ | 169 if (!SYMBOL_VALUE_MAGIC_P (SB_oldval) || UNBOUNDP (SB_oldval)) \ |
170 { \ | 170 { \ |
171 /* ### the following test will go away when we have a constant \ | 171 /* #### the following test will go away when we have a constant \ |
172 symbol magic object */ \ | 172 symbol magic object */ \ |
173 if (EQ (SB_symbol, Qnil) || \ | 173 if (EQ (SB_symbol, Qnil) || \ |
174 EQ (SB_symbol, Qt) || \ | 174 EQ (SB_symbol, Qt) || \ |
175 SYMBOL_IS_KEYWORD (SB_symbol)) \ | 175 SYMBOL_IS_KEYWORD (SB_symbol)) \ |
176 reject_constant_symbols (SB_symbol, SB_newval, 0, \ | 176 reject_constant_symbols (SB_symbol, SB_newval, 0, \ |
195 - specpdl_depth_counter >= specpdl_size. | 195 - specpdl_depth_counter >= specpdl_size. |
196 Else we crash. */ | 196 Else we crash. */ |
197 #define SPECBIND_FAST_UNSAFE(symbol_object, value_object) do { \ | 197 #define SPECBIND_FAST_UNSAFE(symbol_object, value_object) do { \ |
198 Lisp_Object SFU_symbol = (symbol_object); \ | 198 Lisp_Object SFU_symbol = (symbol_object); \ |
199 Lisp_Object SFU_newval = (value_object); \ | 199 Lisp_Object SFU_newval = (value_object); \ |
200 struct Lisp_Symbol *SFU_sym = XSYMBOL (SFU_symbol); \ | 200 Lisp_Symbol *SFU_sym = XSYMBOL (SFU_symbol); \ |
201 Lisp_Object SFU_oldval = SFU_sym->value; \ | 201 Lisp_Object SFU_oldval = SFU_sym->value; \ |
202 if (!SYMBOL_VALUE_MAGIC_P (SFU_oldval) || UNBOUNDP (SFU_oldval)) \ | 202 if (!SYMBOL_VALUE_MAGIC_P (SFU_oldval) || UNBOUNDP (SFU_oldval)) \ |
203 { \ | 203 { \ |
204 specpdl_ptr->symbol = SFU_symbol; \ | 204 specpdl_ptr->symbol = SFU_symbol; \ |
205 specpdl_ptr->old_value = SFU_oldval; \ | 205 specpdl_ptr->old_value = SFU_oldval; \ |
228 variables, so optimize for that. */ | 228 variables, so optimize for that. */ |
229 #define UNBIND_TO_GCPRO(count, value) do { \ | 229 #define UNBIND_TO_GCPRO(count, value) do { \ |
230 int UNBIND_TO_count = (count); \ | 230 int UNBIND_TO_count = (count); \ |
231 while (specpdl_depth_counter != UNBIND_TO_count) \ | 231 while (specpdl_depth_counter != UNBIND_TO_count) \ |
232 { \ | 232 { \ |
233 struct Lisp_Symbol *sym; \ | 233 Lisp_Symbol *sym; \ |
234 --specpdl_ptr; \ | 234 --specpdl_ptr; \ |
235 --specpdl_depth_counter; \ | 235 --specpdl_depth_counter; \ |
236 \ | 236 \ |
237 if (specpdl_ptr->func != 0 || \ | 237 if (specpdl_ptr->func != 0 || \ |
238 ((sym = XSYMBOL (specpdl_ptr->symbol)), \ | 238 ((sym = XSYMBOL (specpdl_ptr->symbol)), \ |
253 that doesn't offer GCPROing services. */ | 253 that doesn't offer GCPROing services. */ |
254 #define UNBIND_TO(count) do { \ | 254 #define UNBIND_TO(count) do { \ |
255 int UNBIND_TO_count = (count); \ | 255 int UNBIND_TO_count = (count); \ |
256 while (specpdl_depth_counter != UNBIND_TO_count) \ | 256 while (specpdl_depth_counter != UNBIND_TO_count) \ |
257 { \ | 257 { \ |
258 struct Lisp_Symbol *sym; \ | 258 Lisp_Symbol *sym; \ |
259 --specpdl_ptr; \ | 259 --specpdl_ptr; \ |
260 --specpdl_depth_counter; \ | 260 --specpdl_depth_counter; \ |
261 \ | 261 \ |
262 if (specpdl_ptr->func != 0 || \ | 262 if (specpdl_ptr->func != 0 || \ |
263 ((sym = XSYMBOL (specpdl_ptr->symbol)), \ | 263 ((sym = XSYMBOL (specpdl_ptr->symbol)), \ |
286 Else we crash. */ | 286 Else we crash. */ |
287 #define UNBIND_TO_GCPRO_VARIABLES_ONLY(count, value) do { \ | 287 #define UNBIND_TO_GCPRO_VARIABLES_ONLY(count, value) do { \ |
288 int UNBIND_TO_count = (count); \ | 288 int UNBIND_TO_count = (count); \ |
289 while (specpdl_depth_counter != UNBIND_TO_count) \ | 289 while (specpdl_depth_counter != UNBIND_TO_count) \ |
290 { \ | 290 { \ |
291 struct Lisp_Symbol *sym; \ | 291 Lisp_Symbol *sym; \ |
292 --specpdl_ptr; \ | 292 --specpdl_ptr; \ |
293 --specpdl_depth_counter; \ | 293 --specpdl_depth_counter; \ |
294 \ | 294 \ |
295 CHECK_SPECBIND_VARIABLE; \ | 295 CHECK_SPECBIND_VARIABLE; \ |
296 sym = XSYMBOL (specpdl_ptr->symbol); \ | 296 sym = XSYMBOL (specpdl_ptr->symbol); \ |
313 - SYMBOL is a non-constant symbol (i.e. not Qnil, Qt, or keyword). | 313 - SYMBOL is a non-constant symbol (i.e. not Qnil, Qt, or keyword). |
314 Else we crash. */ | 314 Else we crash. */ |
315 #define FSET_FAST_UNSAFE(sym, newval) do { \ | 315 #define FSET_FAST_UNSAFE(sym, newval) do { \ |
316 Lisp_Object FFU_sym = (sym); \ | 316 Lisp_Object FFU_sym = (sym); \ |
317 Lisp_Object FFU_newval = (newval); \ | 317 Lisp_Object FFU_newval = (newval); \ |
318 struct Lisp_Symbol *FFU_symbol = XSYMBOL (FFU_sym); \ | 318 Lisp_Symbol *FFU_symbol = XSYMBOL (FFU_sym); \ |
319 Lisp_Object FFU_oldval = FFU_symbol->value; \ | 319 Lisp_Object FFU_oldval = FFU_symbol->value; \ |
320 if (!SYMBOL_VALUE_MAGIC_P (FFU_oldval) || UNBOUNDP (FFU_oldval)) \ | 320 if (!SYMBOL_VALUE_MAGIC_P (FFU_oldval) || UNBOUNDP (FFU_oldval)) \ |
321 FFU_symbol->value = FFU_newval; \ | 321 FFU_symbol->value = FFU_newval; \ |
322 else \ | 322 else \ |
323 Fset (FFU_sym, FFU_newval); \ | 323 Fset (FFU_sym, FFU_newval); \ |
324 } while (0) | 324 } while (0) |
325 | 325 |
326 #endif /* _XEMACS_BACKTRACE_H_ */ | 326 #endif /* INCLUDED_backtrace_h_ */ |