Commit | Line | Data |
---|---|---|
ed3ef339 DE |
1 | /* Internal header for GDB/Scheme code. |
2 | ||
3 | Copyright (C) 2014 Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of GDB. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 3 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
19 | ||
20 | /* See README file in this directory for implementation notes, coding | |
21 | conventions, et.al. */ | |
22 | ||
23 | #ifndef GDB_GUILE_INTERNAL_H | |
24 | #define GDB_GUILE_INTERNAL_H | |
25 | ||
26 | #include "hashtab.h" | |
27 | #include "extension-priv.h" | |
28 | #include "symtab.h" | |
29 | #include "libguile.h" | |
30 | ||
31 | struct block; | |
32 | struct frame_info; | |
33 | struct objfile; | |
34 | struct symbol; | |
35 | ||
36 | /* A function to pass to the safe-call routines to ignore things like | |
37 | memory errors. */ | |
38 | typedef int excp_matcher_func (SCM key); | |
39 | ||
40 | /* Scheme variables to define during initialization. */ | |
41 | ||
42 | typedef struct | |
43 | { | |
44 | const char *name; | |
45 | SCM value; | |
46 | const char *doc_string; | |
47 | } scheme_variable; | |
48 | ||
49 | /* End of scheme_variable table mark. */ | |
50 | ||
51 | #define END_VARIABLES { NULL, SCM_BOOL_F, NULL } | |
52 | ||
53 | /* Scheme functions to define during initialization. */ | |
54 | ||
55 | typedef struct | |
56 | { | |
57 | const char *name; | |
58 | int required; | |
59 | int optional; | |
60 | int rest; | |
61 | scm_t_subr func; | |
62 | const char *doc_string; | |
63 | } scheme_function; | |
64 | ||
65 | /* End of scheme_function table mark. */ | |
66 | ||
67 | #define END_FUNCTIONS { NULL, 0, 0, 0, NULL, NULL } | |
68 | ||
69 | /* Useful for defining a set of constants. */ | |
70 | ||
71 | typedef struct | |
72 | { | |
73 | const char *name; | |
74 | int value; | |
75 | } scheme_integer_constant; | |
76 | ||
77 | #define END_INTEGER_CONSTANTS { NULL, 0 } | |
78 | ||
79 | /* Pass this instead of 0 to routines like SCM_ASSERT to indicate the value | |
80 | is not a function argument. */ | |
81 | #define GDBSCM_ARG_NONE 0 | |
82 | ||
83 | /* Ensure new code doesn't accidentally try to use this. */ | |
84 | #undef scm_make_smob_type | |
85 | #define scm_make_smob_type USE_gdbscm_make_smob_type_INSTEAD | |
86 | ||
87 | /* They brought over () == #f from lisp. | |
88 | Let's avoid that for now. */ | |
89 | #undef scm_is_bool | |
90 | #undef scm_is_false | |
91 | #undef scm_is_true | |
92 | #define scm_is_bool USE_gdbscm_is_bool_INSTEAD | |
93 | #define scm_is_false USE_gdbscm_is_false_INSTEAD | |
94 | #define scm_is_true USE_gdbscm_is_true_INSTEAD | |
95 | #define gdbscm_is_bool(scm) \ | |
96 | (scm_is_eq ((scm), SCM_BOOL_F) || scm_is_eq ((scm), SCM_BOOL_T)) | |
97 | #define gdbscm_is_false(scm) scm_is_eq ((scm), SCM_BOOL_F) | |
98 | #define gdbscm_is_true(scm) (!gdbscm_is_false (scm)) | |
99 | ||
100 | /* Function name that is passed around in case an error needs to be reported. | |
101 | __func is in C99, but we provide a wrapper "just in case", | |
102 | and because FUNC_NAME is the canonical value used in guile sources. | |
103 | IWBN to use the Scheme version of the name (e.g. foo-bar vs foo_bar), | |
104 | but let's KISS for now. */ | |
105 | #define FUNC_NAME __func__ | |
106 | ||
107 | extern const char gdbscm_module_name[]; | |
108 | extern const char gdbscm_init_module_name[]; | |
109 | ||
110 | extern int gdb_scheme_initialized; | |
111 | ||
112 | extern const char gdbscm_print_excp_none[]; | |
113 | extern const char gdbscm_print_excp_full[]; | |
114 | extern const char gdbscm_print_excp_message[]; | |
115 | extern const char *gdbscm_print_excp; | |
116 | ||
117 | extern SCM gdbscm_documentation_symbol; | |
118 | extern SCM gdbscm_invalid_object_error_symbol; | |
119 | ||
120 | extern SCM gdbscm_map_string; | |
121 | extern SCM gdbscm_array_string; | |
122 | extern SCM gdbscm_string_string; | |
123 | \f | |
124 | /* scm-utils.c */ | |
125 | ||
126 | extern void gdbscm_define_variables (const scheme_variable *, int public); | |
127 | ||
128 | extern void gdbscm_define_functions (const scheme_function *, int public); | |
129 | ||
130 | extern void gdbscm_define_integer_constants (const scheme_integer_constant *, | |
131 | int public); | |
132 | ||
133 | extern void gdbscm_printf (SCM port, const char *format, ...); | |
134 | ||
135 | extern void gdbscm_debug_display (SCM obj); | |
136 | ||
137 | extern void gdbscm_debug_write (SCM obj); | |
138 | ||
139 | extern void gdbscm_parse_function_args (const char *function_name, | |
140 | int beginning_arg_pos, | |
141 | const SCM *keywords, | |
142 | const char *format, ...); | |
143 | ||
144 | extern SCM gdbscm_scm_from_longest (LONGEST l); | |
145 | ||
146 | extern LONGEST gdbscm_scm_to_longest (SCM l); | |
147 | ||
148 | extern SCM gdbscm_scm_from_ulongest (ULONGEST l); | |
149 | ||
150 | extern ULONGEST gdbscm_scm_to_ulongest (SCM u); | |
151 | ||
152 | extern void gdbscm_dynwind_xfree (void *ptr); | |
153 | ||
154 | extern int gdbscm_is_procedure (SCM proc); | |
155 | \f | |
156 | /* GDB smobs, from scm-smob.c */ | |
157 | ||
158 | /* All gdb smobs must contain one of the following as the first member: | |
159 | gdb_smob, chained_gdb_smob, or eqable_gdb_smob. | |
160 | ||
161 | The next,prev members of chained_gdb_smob allow for chaining gsmobs | |
162 | together so that, for example, when an objfile is deleted we can clean up | |
163 | all smobs that reference it. | |
164 | ||
165 | The containing_scm member of eqable_gdb_smob allows for returning the | |
166 | same gsmob instead of creating a new one, allowing them to be eq?-able. | |
167 | ||
168 | IMPORTANT: chained_gdb_smob and eqable_gdb-smob are a "subclasses" of | |
169 | gdb_smob. The layout of chained_gdb_smob,eqable_gdb_smob must match | |
170 | gdb_smob as if it is a subclass. To that end we use macro GDB_SMOB_HEAD | |
171 | to ensure this. */ | |
172 | ||
173 | #define GDB_SMOB_HEAD \ | |
174 | /* Property list for externally added fields. */ \ | |
175 | SCM properties; | |
176 | ||
177 | typedef struct | |
178 | { | |
179 | GDB_SMOB_HEAD | |
180 | } gdb_smob; | |
181 | ||
182 | typedef struct _chained_gdb_smob | |
183 | { | |
184 | GDB_SMOB_HEAD | |
185 | ||
186 | struct _chained_gdb_smob *prev; | |
187 | struct _chained_gdb_smob *next; | |
188 | } chained_gdb_smob; | |
189 | ||
190 | typedef struct _eqable_gdb_smob | |
191 | { | |
192 | GDB_SMOB_HEAD | |
193 | ||
194 | /* The object we are contained in. | |
195 | This can be used for several purposes. | |
196 | This is used by the eq? machinery: We need to be able to see if we have | |
197 | already created an object for a symbol, and if so use that SCM. | |
198 | This may also be used to protect the smob from GC if there is | |
199 | a reference to this smob from outside of GC space (i.e., from gdb). | |
200 | This can also be used in place of chained_gdb_smob where we need to | |
201 | keep track of objfile referencing objects. When the objfile is deleted | |
202 | we need to invalidate the objects: we can do that using the same hashtab | |
203 | used to record the smob for eq-ability. */ | |
204 | SCM containing_scm; | |
205 | } eqable_gdb_smob; | |
206 | ||
207 | #undef GDB_SMOB_HEAD | |
208 | ||
209 | struct objfile; | |
210 | struct objfile_data; | |
211 | ||
212 | /* A predicate that returns non-zero if an object is a particular kind | |
213 | of gsmob. */ | |
214 | typedef int (gsmob_pred_func) (SCM); | |
215 | ||
216 | extern scm_t_bits gdbscm_make_smob_type (const char *name, size_t size); | |
217 | ||
218 | extern void gdbscm_init_gsmob (gdb_smob *base); | |
219 | ||
220 | extern void gdbscm_init_chained_gsmob (chained_gdb_smob *base); | |
221 | ||
222 | extern void gdbscm_init_eqable_gsmob (eqable_gdb_smob *base); | |
223 | ||
224 | extern SCM gdbscm_mark_gsmob (gdb_smob *base); | |
225 | ||
226 | extern SCM gdbscm_mark_chained_gsmob (chained_gdb_smob *base); | |
227 | ||
228 | extern SCM gdbscm_mark_eqable_gsmob (eqable_gdb_smob *base); | |
229 | ||
230 | extern void gdbscm_add_objfile_ref (struct objfile *objfile, | |
231 | const struct objfile_data *data_key, | |
232 | chained_gdb_smob *g_smob); | |
233 | ||
234 | extern void gdbscm_remove_objfile_ref (struct objfile *objfile, | |
235 | const struct objfile_data *data_key, | |
236 | chained_gdb_smob *g_smob); | |
237 | ||
238 | extern htab_t gdbscm_create_eqable_gsmob_ptr_map (htab_hash hash_fn, | |
239 | htab_eq eq_fn); | |
240 | ||
241 | extern eqable_gdb_smob **gdbscm_find_eqable_gsmob_ptr_slot | |
242 | (htab_t htab, eqable_gdb_smob *base); | |
243 | ||
244 | extern void gdbscm_fill_eqable_gsmob_ptr_slot (eqable_gdb_smob **slot, | |
245 | eqable_gdb_smob *base, | |
246 | SCM containing_scm); | |
247 | ||
248 | extern void gdbscm_clear_eqable_gsmob_ptr_slot (htab_t htab, | |
249 | eqable_gdb_smob *base); | |
250 | \f | |
251 | /* Exceptions and calling out to Guile. */ | |
252 | ||
253 | /* scm-exception.c */ | |
254 | ||
255 | extern SCM gdbscm_make_exception (SCM tag, SCM args); | |
256 | ||
257 | extern int gdbscm_is_exception (SCM scm); | |
258 | ||
259 | extern SCM gdbscm_exception_key (SCM excp); | |
260 | ||
261 | extern SCM gdbscm_exception_args (SCM excp); | |
262 | ||
263 | extern SCM gdbscm_make_exception_with_stack (SCM key, SCM args, SCM stack); | |
264 | ||
265 | extern SCM gdbscm_make_error_scm (SCM key, SCM subr, SCM message, | |
266 | SCM args, SCM data); | |
267 | ||
268 | extern SCM gdbscm_make_error (SCM key, const char *subr, const char *message, | |
269 | SCM args, SCM data); | |
270 | ||
271 | extern SCM gdbscm_make_type_error (const char *subr, int arg_pos, | |
272 | SCM bad_value, const char *expected_type); | |
273 | ||
274 | extern SCM gdbscm_make_invalid_object_error (const char *subr, int arg_pos, | |
275 | SCM bad_value, const char *error); | |
276 | ||
277 | extern SCM gdbscm_invalid_object_error (const char *subr, int arg_pos, | |
278 | SCM bad_value, const char *error) | |
279 | ATTRIBUTE_NORETURN; | |
280 | ||
281 | extern SCM gdbscm_make_out_of_range_error (const char *subr, int arg_pos, | |
282 | SCM bad_value, const char *error); | |
283 | ||
284 | extern SCM gdbscm_out_of_range_error (const char *subr, int arg_pos, | |
285 | SCM bad_value, const char *error) | |
286 | ATTRIBUTE_NORETURN; | |
287 | ||
288 | extern SCM gdbscm_make_misc_error (const char *subr, int arg_pos, | |
289 | SCM bad_value, const char *error); | |
290 | ||
291 | extern void gdbscm_throw (SCM exception) ATTRIBUTE_NORETURN; | |
292 | ||
293 | extern SCM gdbscm_scm_from_gdb_exception (struct gdb_exception exception); | |
294 | ||
295 | extern void gdbscm_throw_gdb_exception (struct gdb_exception exception) | |
296 | ATTRIBUTE_NORETURN; | |
297 | ||
298 | extern void gdbscm_print_exception_with_stack (SCM port, SCM stack, | |
299 | SCM key, SCM args); | |
300 | ||
301 | extern void gdbscm_print_gdb_exception (SCM port, SCM exception); | |
302 | ||
303 | extern char *gdbscm_exception_message_to_string (SCM exception); | |
304 | ||
305 | extern excp_matcher_func gdbscm_memory_error_p; | |
306 | ||
307 | extern SCM gdbscm_make_memory_error (const char *subr, const char *msg, | |
308 | SCM args); | |
309 | ||
310 | extern SCM gdbscm_memory_error (const char *subr, const char *msg, SCM args); | |
311 | ||
312 | /* scm-safe-call.c */ | |
313 | ||
314 | extern void *gdbscm_with_guile (void *(*func) (void *), void *data); | |
315 | ||
316 | extern SCM gdbscm_call_guile (SCM (*func) (void *), void *data, | |
317 | excp_matcher_func *ok_excps); | |
318 | ||
319 | extern SCM gdbscm_safe_call_0 (SCM proc, excp_matcher_func *ok_excps); | |
320 | ||
321 | extern SCM gdbscm_safe_call_1 (SCM proc, SCM arg0, | |
322 | excp_matcher_func *ok_excps); | |
323 | ||
324 | extern SCM gdbscm_safe_call_2 (SCM proc, SCM arg0, SCM arg1, | |
325 | excp_matcher_func *ok_excps); | |
326 | ||
327 | extern SCM gdbscm_safe_call_3 (SCM proc, SCM arg0, SCM arg1, SCM arg2, | |
328 | excp_matcher_func *ok_excps); | |
329 | ||
330 | extern SCM gdbscm_safe_call_4 (SCM proc, SCM arg0, SCM arg1, SCM arg2, | |
331 | SCM arg3, | |
332 | excp_matcher_func *ok_excps); | |
333 | ||
334 | extern SCM gdbscm_safe_apply_1 (SCM proc, SCM arg0, SCM args, | |
335 | excp_matcher_func *ok_excps); | |
336 | ||
337 | extern SCM gdbscm_unsafe_call_1 (SCM proc, SCM arg0); | |
338 | ||
339 | extern char *gdbscm_safe_eval_string (const char *string, int display_result); | |
340 | ||
341 | extern char *gdbscm_safe_source_script (const char *filename); | |
342 | ||
343 | extern void gdbscm_enter_repl (void); | |
344 | \f | |
345 | /* Interface to various GDB objects, in alphabetical order. */ | |
346 | ||
347 | /* scm-arch.c */ | |
348 | ||
349 | typedef struct _arch_smob arch_smob; | |
350 | ||
351 | extern struct gdbarch *arscm_get_gdbarch (arch_smob *a_smob); | |
352 | ||
353 | extern arch_smob *arscm_get_arch_smob_arg_unsafe (SCM arch_scm, int arg_pos, | |
354 | const char *func_name); | |
355 | ||
356 | extern SCM arscm_scm_from_arch (struct gdbarch *gdbarch); | |
357 | ||
358 | /* scm-block.c */ | |
359 | ||
360 | extern SCM bkscm_scm_from_block (const struct block *block, | |
361 | struct objfile *objfile); | |
362 | ||
363 | extern const struct block *bkscm_scm_to_block | |
364 | (SCM block_scm, int arg_pos, const char *func_name, SCM *excp); | |
365 | ||
366 | /* scm-frame.c */ | |
367 | ||
368 | typedef struct _frame_smob frame_smob; | |
369 | ||
370 | extern int frscm_is_frame (SCM scm); | |
371 | ||
372 | extern frame_smob *frscm_get_frame_smob_arg_unsafe (SCM frame_scm, int arg_pos, | |
373 | const char *func_name); | |
374 | ||
375 | extern struct frame_info *frscm_frame_smob_to_frame (frame_smob *); | |
376 | ||
377 | /* scm-iterator.c */ | |
378 | ||
379 | typedef struct _iterator_smob iterator_smob; | |
380 | ||
381 | extern SCM itscm_iterator_smob_object (iterator_smob *i_smob); | |
382 | ||
383 | extern SCM itscm_iterator_smob_progress (iterator_smob *i_smob); | |
384 | ||
385 | extern void itscm_set_iterator_smob_progress_x (iterator_smob *i_smob, | |
386 | SCM progress); | |
387 | ||
388 | extern const char *itscm_iterator_smob_name (void); | |
389 | ||
390 | extern SCM gdbscm_make_iterator (SCM object, SCM progress, SCM next); | |
391 | ||
392 | extern int itscm_is_iterator (SCM scm); | |
393 | ||
394 | extern SCM gdbscm_end_of_iteration (void); | |
395 | ||
396 | extern int itscm_is_end_of_iteration (SCM obj); | |
397 | ||
398 | extern SCM itscm_safe_call_next_x (SCM iter, excp_matcher_func *ok_excps); | |
399 | ||
400 | extern SCM itscm_get_iterator_arg_unsafe (SCM self, int arg_pos, | |
401 | const char *func_name); | |
402 | ||
403 | /* scm-lazy-string.c */ | |
404 | ||
405 | extern int lsscm_is_lazy_string (SCM scm); | |
406 | ||
407 | extern SCM lsscm_make_lazy_string (CORE_ADDR address, int length, | |
408 | const char *encoding, struct type *type); | |
409 | ||
410 | extern struct value *lsscm_safe_lazy_string_to_value (SCM string, | |
411 | int arg_pos, | |
412 | const char *func_name, | |
413 | SCM *except_scmp); | |
414 | ||
415 | extern void lsscm_val_print_lazy_string | |
416 | (SCM string, struct ui_file *stream, | |
417 | const struct value_print_options *options); | |
418 | ||
419 | /* scm-objfile.c */ | |
420 | ||
421 | typedef struct _objfile_smob objfile_smob; | |
422 | ||
423 | extern SCM ofscm_objfile_smob_pretty_printers (objfile_smob *o_smob); | |
424 | ||
425 | extern objfile_smob *ofscm_objfile_smob_from_objfile (struct objfile *objfile); | |
426 | ||
427 | extern SCM ofscm_scm_from_objfile (struct objfile *objfile); | |
428 | ||
429 | /* scm-string.c */ | |
430 | ||
431 | extern char *gdbscm_scm_to_c_string (SCM string); | |
432 | ||
433 | extern SCM gdbscm_scm_from_c_string (const char *string); | |
434 | ||
435 | extern SCM gdbscm_scm_from_printf (const char *format, ...); | |
436 | ||
437 | extern char *gdbscm_scm_to_string (SCM string, size_t *lenp, | |
438 | const char *charset, | |
439 | int strict, SCM *except_scmp); | |
440 | ||
441 | extern SCM gdbscm_scm_from_string (const char *string, size_t len, | |
442 | const char *charset, int strict); | |
443 | ||
444 | extern char *gdbscm_scm_to_target_string_unsafe (SCM string, size_t *lenp, | |
445 | struct gdbarch *gdbarch); | |
446 | ||
447 | /* scm-symbol.c */ | |
448 | ||
449 | extern int syscm_is_symbol (SCM scm); | |
450 | ||
451 | extern SCM syscm_scm_from_symbol (struct symbol *symbol); | |
452 | ||
453 | extern struct symbol *syscm_get_valid_symbol_arg_unsafe | |
454 | (SCM self, int arg_pos, const char *func_name); | |
455 | ||
456 | /* scm-symtab.c */ | |
457 | ||
458 | extern SCM stscm_scm_from_symtab (struct symtab *symtab); | |
459 | ||
460 | extern SCM stscm_scm_from_sal (struct symtab_and_line sal); | |
461 | ||
462 | /* scm-type.c */ | |
463 | ||
464 | typedef struct _type_smob type_smob; | |
465 | ||
466 | extern int tyscm_is_type (SCM scm); | |
467 | ||
468 | extern SCM tyscm_scm_from_type (struct type *type); | |
469 | ||
470 | extern type_smob *tyscm_get_type_smob_arg_unsafe (SCM type_scm, int arg_pos, | |
471 | const char *func_name); | |
472 | ||
473 | extern struct type *tyscm_type_smob_type (type_smob *t_smob); | |
474 | ||
475 | extern SCM tyscm_scm_from_field (SCM type_scm, int field_num); | |
476 | ||
477 | /* scm-value.c */ | |
478 | ||
479 | extern struct value *vlscm_scm_to_value (SCM scm); | |
480 | ||
481 | extern int vlscm_is_value (SCM scm); | |
482 | ||
483 | extern SCM vlscm_scm_from_value (struct value *value); | |
484 | ||
485 | extern SCM vlscm_scm_from_value_unsafe (struct value *value); | |
486 | ||
487 | extern struct value *vlscm_convert_typed_value_from_scheme | |
488 | (const char *func_name, int obj_arg_pos, SCM obj, | |
489 | int type_arg_pos, SCM type_scm, struct type *type, SCM *except_scmp, | |
490 | struct gdbarch *gdbarch, const struct language_defn *language); | |
491 | ||
492 | extern struct value *vlscm_convert_value_from_scheme | |
493 | (const char *func_name, int obj_arg_pos, SCM obj, SCM *except_scmp, | |
494 | struct gdbarch *gdbarch, const struct language_defn *language); | |
495 | \f | |
496 | /* stript_lang methods */ | |
497 | ||
498 | extern objfile_script_sourcer_func gdbscm_source_objfile_script; | |
499 | ||
500 | extern int gdbscm_auto_load_enabled (const struct extension_language_defn *); | |
501 | ||
502 | extern void gdbscm_preserve_values | |
503 | (const struct extension_language_defn *, | |
504 | struct objfile *, htab_t copied_types); | |
505 | ||
506 | extern enum ext_lang_rc gdbscm_apply_val_pretty_printer | |
507 | (const struct extension_language_defn *, | |
508 | struct type *type, const gdb_byte *valaddr, | |
509 | int embedded_offset, CORE_ADDR address, | |
510 | struct ui_file *stream, int recurse, | |
511 | const struct value *val, | |
512 | const struct value_print_options *options, | |
513 | const struct language_defn *language); | |
514 | ||
515 | extern int gdbscm_breakpoint_has_cond (const struct extension_language_defn *, | |
516 | struct breakpoint *b); | |
517 | ||
518 | extern enum ext_lang_bp_stop gdbscm_breakpoint_cond_says_stop | |
519 | (const struct extension_language_defn *, struct breakpoint *b); | |
520 | \f | |
521 | /* Initializers for each piece of Scheme support, in alphabetical order. */ | |
522 | ||
523 | extern void gdbscm_initialize_arches (void); | |
524 | extern void gdbscm_initialize_auto_load (void); | |
525 | extern void gdbscm_initialize_blocks (void); | |
526 | extern void gdbscm_initialize_breakpoints (void); | |
527 | extern void gdbscm_initialize_disasm (void); | |
528 | extern void gdbscm_initialize_exceptions (void); | |
529 | extern void gdbscm_initialize_frames (void); | |
530 | extern void gdbscm_initialize_iterators (void); | |
531 | extern void gdbscm_initialize_lazy_strings (void); | |
532 | extern void gdbscm_initialize_math (void); | |
533 | extern void gdbscm_initialize_objfiles (void); | |
534 | extern void gdbscm_initialize_pretty_printers (void); | |
535 | extern void gdbscm_initialize_ports (void); | |
536 | extern void gdbscm_initialize_smobs (void); | |
537 | extern void gdbscm_initialize_strings (void); | |
538 | extern void gdbscm_initialize_symbols (void); | |
539 | extern void gdbscm_initialize_symtabs (void); | |
540 | extern void gdbscm_initialize_types (void); | |
541 | extern void gdbscm_initialize_values (void); | |
542 | \f | |
543 | /* Use these after a TRY_CATCH to throw the appropriate Scheme exception | |
544 | if a GDB error occurred. */ | |
545 | ||
546 | #define GDBSCM_HANDLE_GDB_EXCEPTION(exception) \ | |
547 | do { \ | |
548 | if (exception.reason < 0) \ | |
549 | { \ | |
550 | gdbscm_throw_gdb_exception (exception); \ | |
551 | /*NOTREACHED */ \ | |
552 | } \ | |
553 | } while (0) | |
554 | ||
555 | /* If cleanups are establish outside the TRY_CATCH block, use this version. */ | |
556 | ||
557 | #define GDBSCM_HANDLE_GDB_EXCEPTION_WITH_CLEANUPS(exception, cleanups) \ | |
558 | do { \ | |
559 | if (exception.reason < 0) \ | |
560 | { \ | |
561 | do_cleanups (cleanups); \ | |
562 | gdbscm_throw_gdb_exception (exception); \ | |
563 | /*NOTREACHED */ \ | |
564 | } \ | |
565 | } while (0) | |
566 | ||
567 | #endif /* GDB_GUILE_INTERNAL_H */ |