Mercurial > hg > xemacs-beta

comparison src/backtrace.h @ 440:8de8e3f6228a r21-2-28

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-2-28
author cvs
date Mon, 13 Aug 2007 11:33:38 +0200
parents 3ecd8885ac67
children af57a77cbc92
comparison
equal deleted inserted replaced
439:357dd071b03c 440:8de8e3f6228a
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_ */