gdb/guile/guile-internal.h

   1 /* Internal header for GDB/Scheme code.
   2
   3    Copyright (C) 2014-2018 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 /* Although scm_t_subr is meant to hold a function pointer, at least
  54    in some versions of guile, it is actually a typedef to "void *".
  55    That means that in C++, an explicit cast is necessary to convert
  56    function pointer to scm_t_subr.  But a cast also makes it possible
  57    to pass function pointers with the wrong type by mistake.  So
  58    instead of adding such casts throughout, we use 'as_a_scm_t_subr'
  59    to do the conversion, which (only) has overloads for function
  60    pointer types that are valid.
  61
  62    See https://lists.gnu.org/archive/html/guile-devel/2013-03/msg00001.html.
  63 */
  64
  65 static inline scm_t_subr
  66 as_a_scm_t_subr (SCM (*func) (void))
  67 {
  68   return (scm_t_subr) func;
  69 }
  70
  71 static inline scm_t_subr
  72 as_a_scm_t_subr (SCM (*func) (SCM))
  73 {
  74   return (scm_t_subr) func;
  75 }
  76
  77 static inline scm_t_subr
  78 as_a_scm_t_subr (SCM (*func) (SCM, SCM))
  79 {
  80   return (scm_t_subr) func;
  81 }
  82
  83 static inline scm_t_subr
  84 as_a_scm_t_subr (SCM (*func) (SCM, SCM, SCM))
  85 {
  86   return (scm_t_subr) func;
  87 }
  88
  89 /* Scheme functions to define during initialization.  */
  90
  91 typedef struct
  92 {
  93   const char *name;
  94   int required;
  95   int optional;
  96   int rest;
  97   scm_t_subr func;
  98   const char *doc_string;
  99 } scheme_function;
 100
 101 /* End of scheme_function table mark.  */
 102
 103 #define END_FUNCTIONS { NULL, 0, 0, 0, NULL, NULL }
 104
 105 /* Useful for defining a set of constants.  */
 106
 107 typedef struct
 108 {
 109   const char *name;
 110   int value;
 111 } scheme_integer_constant;
 112
 113 #define END_INTEGER_CONSTANTS { NULL, 0 }
 114
 115 /* Pass this instead of 0 to routines like SCM_ASSERT to indicate the value
 116    is not a function argument.  */
 117 #define GDBSCM_ARG_NONE 0
 118
 119 /* Ensure new code doesn't accidentally try to use this.  */
 120 #undef scm_make_smob_type
 121 #define scm_make_smob_type USE_gdbscm_make_smob_type_INSTEAD
 122
 123 /* They brought over () == #f from lisp.
 124    Let's avoid that for now.  */
 125 #undef scm_is_bool
 126 #undef scm_is_false
 127 #undef scm_is_true
 128 #define scm_is_bool USE_gdbscm_is_bool_INSTEAD
 129 #define scm_is_false USE_gdbscm_is_false_INSTEAD
 130 #define scm_is_true USE_gdbscm_is_true_INSTEAD
 131 #define gdbscm_is_bool(scm) \
 132   (scm_is_eq ((scm), SCM_BOOL_F) || scm_is_eq ((scm), SCM_BOOL_T))
 133 #define gdbscm_is_false(scm) scm_is_eq ((scm), SCM_BOOL_F)
 134 #define gdbscm_is_true(scm) (!gdbscm_is_false (scm))
 135
 136 #ifndef HAVE_SCM_NEW_SMOB
 137
 138 /* Guile <= 2.0.5 did not provide this function, so provide it here.  */
 139
 140 static inline SCM
 141 scm_new_smob (scm_t_bits tc, scm_t_bits data)
 142 {
 143   SCM_RETURN_NEWSMOB (tc, data);
 144 }
 145
 146 #endif
 147
 148 /* Function name that is passed around in case an error needs to be reported.
 149    __func is in C99, but we provide a wrapper "just in case",
 150    and because FUNC_NAME is the canonical value used in guile sources.
 151    IWBN to use the Scheme version of the name (e.g. foo-bar vs foo_bar),
 152    but let's KISS for now.  */
 153 #define FUNC_NAME __func__
 154
 155 extern const char gdbscm_module_name[];
 156 extern const char gdbscm_init_module_name[];
 157
 158 extern int gdb_scheme_initialized;
 159
 160 extern int gdbscm_guile_major_version;
 161 extern int gdbscm_guile_minor_version;
 162 extern int gdbscm_guile_micro_version;
 163
 164 extern const char gdbscm_print_excp_none[];
 165 extern const char gdbscm_print_excp_full[];
 166 extern const char gdbscm_print_excp_message[];
 167 extern const char *gdbscm_print_excp;
 168
 169 extern SCM gdbscm_documentation_symbol;
 170 extern SCM gdbscm_invalid_object_error_symbol;
 171
 172 extern SCM gdbscm_map_string;
 173 extern SCM gdbscm_array_string;
 174 extern SCM gdbscm_string_string;
 175 \f
 176 /* scm-utils.c */
 177
 178 extern void gdbscm_define_variables (const scheme_variable *, int is_public);
 179
 180 extern void gdbscm_define_functions (const scheme_function *, int is_public);
 181
 182 extern void gdbscm_define_integer_constants (const scheme_integer_constant *,
 183                                              int is_public);
 184
 185 extern void gdbscm_printf (SCM port, const char *format, ...)
 186   ATTRIBUTE_PRINTF (2, 3);
 187
 188 extern void gdbscm_debug_display (SCM obj);
 189
 190 extern void gdbscm_debug_write (SCM obj);
 191
 192 extern void gdbscm_parse_function_args (const char *function_name,
 193                                         int beginning_arg_pos,
 194                                         const SCM *keywords,
 195                                         const char *format, ...);
 196
 197 extern SCM gdbscm_scm_from_longest (LONGEST l);
 198
 199 extern LONGEST gdbscm_scm_to_longest (SCM l);
 200
 201 extern SCM gdbscm_scm_from_ulongest (ULONGEST l);
 202
 203 extern ULONGEST gdbscm_scm_to_ulongest (SCM u);
 204
 205 extern void gdbscm_dynwind_xfree (void *ptr);
 206
 207 extern int gdbscm_is_procedure (SCM proc);
 208
 209 extern char *gdbscm_gc_xstrdup (const char *);
 210
 211 extern const char * const *gdbscm_gc_dup_argv (char **argv);
 212
 213 extern int gdbscm_guile_version_is_at_least (int major, int minor, int micro);
 214 \f
 215 /* GDB smobs, from scm-gsmob.c */
 216
 217 /* All gdb smobs must contain one of the following as the first member:
 218    gdb_smob, chained_gdb_smob, or eqable_gdb_smob.
 219
 220    Chained GDB smobs should have chained_gdb_smob as their first member.  The
 221    next,prev members of chained_gdb_smob allow for chaining gsmobs together so
 222    that, for example, when an objfile is deleted we can clean up all smobs that
 223    reference it.
 224
 225    Eq-able GDB smobs should have eqable_gdb_smob as their first member.  The
 226    containing_scm member of eqable_gdb_smob allows for returning the same gsmob
 227    instead of creating a new one, allowing them to be eq?-able.
 228
 229    All other smobs should have gdb_smob as their first member.
 230    FIXME: dje/2014-05-26: gdb_smob was useful during early development as a
 231    "baseclass" for all gdb smobs.  If it's still unused by gdb 8.0 delete it.
 232
 233    IMPORTANT: chained_gdb_smob and eqable_gdb-smob are "subclasses" of
 234    gdb_smob.  The layout of chained_gdb_smob,eqable_gdb_smob must match
 235    gdb_smob as if it is a subclass.  To that end we use macro GDB_SMOB_HEAD
 236    to ensure this.  */
 237
 238 #define GDB_SMOB_HEAD \
 239   int empty_base_class;
 240
 241 typedef struct
 242 {
 243   GDB_SMOB_HEAD
 244 } gdb_smob;
 245
 246 typedef struct _chained_gdb_smob
 247 {
 248   GDB_SMOB_HEAD
 249
 250   struct _chained_gdb_smob *prev;
 251   struct _chained_gdb_smob *next;
 252 } chained_gdb_smob;
 253
 254 typedef struct _eqable_gdb_smob
 255 {
 256   GDB_SMOB_HEAD
 257
 258   /* The object we are contained in.
 259      This can be used for several purposes.
 260      This is used by the eq? machinery:  We need to be able to see if we have
 261      already created an object for a symbol, and if so use that SCM.
 262      This may also be used to protect the smob from GC if there is
 263      a reference to this smob from outside of GC space (i.e., from gdb).
 264      This can also be used in place of chained_gdb_smob where we need to
 265      keep track of objfile referencing objects.  When the objfile is deleted
 266      we need to invalidate the objects: we can do that using the same hashtab
 267      used to record the smob for eq-ability.  */
 268   SCM containing_scm;
 269 } eqable_gdb_smob;
 270
 271 #undef GDB_SMOB_HEAD
 272
 273 struct objfile;
 274 struct objfile_data;
 275
 276 /* A predicate that returns non-zero if an object is a particular kind
 277    of gsmob.  */
 278 typedef int (gsmob_pred_func) (SCM);
 279
 280 extern scm_t_bits gdbscm_make_smob_type (const char *name, size_t size);
 281
 282 extern void gdbscm_init_gsmob (gdb_smob *base);
 283
 284 extern void gdbscm_init_chained_gsmob (chained_gdb_smob *base);
 285
 286 extern void gdbscm_init_eqable_gsmob (eqable_gdb_smob *base,
 287                                       SCM containing_scm);
 288
 289 extern void gdbscm_add_objfile_ref (struct objfile *objfile,
 290                                     const struct objfile_data *data_key,
 291                                     chained_gdb_smob *g_smob);
 292
 293 extern void gdbscm_remove_objfile_ref (struct objfile *objfile,
 294                                        const struct objfile_data *data_key,
 295                                        chained_gdb_smob *g_smob);
 296
 297 extern htab_t gdbscm_create_eqable_gsmob_ptr_map (htab_hash hash_fn,
 298                                                   htab_eq eq_fn);
 299
 300 extern eqable_gdb_smob **gdbscm_find_eqable_gsmob_ptr_slot
 301   (htab_t htab, eqable_gdb_smob *base);
 302
 303 extern void gdbscm_fill_eqable_gsmob_ptr_slot (eqable_gdb_smob **slot,
 304                                                eqable_gdb_smob *base);
 305
 306 extern void gdbscm_clear_eqable_gsmob_ptr_slot (htab_t htab,
 307                                                 eqable_gdb_smob *base);
 308 \f
 309 /* Exceptions and calling out to Guile.  */
 310
 311 /* scm-exception.c */
 312
 313 extern SCM gdbscm_make_exception (SCM tag, SCM args);
 314
 315 extern int gdbscm_is_exception (SCM scm);
 316
 317 extern SCM gdbscm_exception_key (SCM excp);
 318
 319 extern SCM gdbscm_exception_args (SCM excp);
 320
 321 extern SCM gdbscm_make_exception_with_stack (SCM key, SCM args, SCM stack);
 322
 323 extern SCM gdbscm_make_error_scm (SCM key, SCM subr, SCM message,
 324                                   SCM args, SCM data);
 325
 326 extern SCM gdbscm_make_error (SCM key, const char *subr, const char *message,
 327                               SCM args, SCM data);
 328
 329 extern SCM gdbscm_make_type_error (const char *subr, int arg_pos,
 330                                    SCM bad_value, const char *expected_type);
 331
 332 extern SCM gdbscm_make_invalid_object_error (const char *subr, int arg_pos,
 333                                              SCM bad_value, const char *error);
 334
 335 extern void gdbscm_invalid_object_error (const char *subr, int arg_pos,
 336                                          SCM bad_value, const char *error)
 337    ATTRIBUTE_NORETURN;
 338
 339 extern SCM gdbscm_make_out_of_range_error (const char *subr, int arg_pos,
 340                                            SCM bad_value, const char *error);
 341
 342 extern void gdbscm_out_of_range_error (const char *subr, int arg_pos,
 343                                        SCM bad_value, const char *error)
 344    ATTRIBUTE_NORETURN;
 345
 346 extern SCM gdbscm_make_misc_error (const char *subr, int arg_pos,
 347                                    SCM bad_value, const char *error);
 348
 349 extern void gdbscm_misc_error (const char *subr, int arg_pos,
 350                                SCM bad_value, const char *error)
 351    ATTRIBUTE_NORETURN;
 352
 353 extern void gdbscm_throw (SCM exception) ATTRIBUTE_NORETURN;
 354
 355 extern SCM gdbscm_scm_from_gdb_exception (struct gdb_exception exception);
 356
 357 extern void gdbscm_throw_gdb_exception (struct gdb_exception exception)
 358   ATTRIBUTE_NORETURN;
 359
 360 extern void gdbscm_print_exception_with_stack (SCM port, SCM stack,
 361                                                SCM key, SCM args);
 362
 363 extern void gdbscm_print_gdb_exception (SCM port, SCM exception);
 364
 365 extern char *gdbscm_exception_message_to_string (SCM exception);
 366
 367 extern excp_matcher_func gdbscm_memory_error_p;
 368
 369 extern excp_matcher_func gdbscm_user_error_p;
 370
 371 extern SCM gdbscm_make_memory_error (const char *subr, const char *msg,
 372                                      SCM args);
 373
 374 extern void gdbscm_memory_error (const char *subr, const char *msg, SCM args)
 375   ATTRIBUTE_NORETURN;
 376
 377 /* scm-safe-call.c */
 378
 379 extern const char *gdbscm_with_guile (const char *(*func) (void *), void *data);
 380
 381 extern SCM gdbscm_call_guile (SCM (*func) (void *), void *data,
 382                               excp_matcher_func *ok_excps);
 383
 384 extern SCM gdbscm_safe_call_0 (SCM proc, excp_matcher_func *ok_excps);
 385
 386 extern SCM gdbscm_safe_call_1 (SCM proc, SCM arg0,
 387                                excp_matcher_func *ok_excps);
 388
 389 extern SCM gdbscm_safe_call_2 (SCM proc, SCM arg0, SCM arg1,
 390                                excp_matcher_func *ok_excps);
 391
 392 extern SCM gdbscm_safe_call_3 (SCM proc, SCM arg0, SCM arg1, SCM arg2,
 393                                excp_matcher_func *ok_excps);
 394
 395 extern SCM gdbscm_safe_call_4 (SCM proc, SCM arg0, SCM arg1, SCM arg2,
 396                                SCM arg3,
 397                                excp_matcher_func *ok_excps);
 398
 399 extern SCM gdbscm_safe_apply_1 (SCM proc, SCM arg0, SCM args,
 400                                 excp_matcher_func *ok_excps);
 401
 402 extern SCM gdbscm_unsafe_call_1 (SCM proc, SCM arg0);
 403
 404 extern char *gdbscm_safe_eval_string (const char *string, int display_result);
 405
 406 extern char *gdbscm_safe_source_script (const char *filename);
 407
 408 extern void gdbscm_enter_repl (void);
 409 \f
 410 /* Interface to various GDB objects, in alphabetical order.  */
 411
 412 /* scm-arch.c */
 413
 414 typedef struct _arch_smob arch_smob;
 415
 416 extern struct gdbarch *arscm_get_gdbarch (arch_smob *a_smob);
 417
 418 extern arch_smob *arscm_get_arch_smob_arg_unsafe (SCM arch_scm, int arg_pos,
 419                                                   const char *func_name);
 420
 421 extern SCM arscm_scm_from_arch (struct gdbarch *gdbarch);
 422
 423 /* scm-block.c */
 424
 425 extern SCM bkscm_scm_from_block (const struct block *block,
 426                                  struct objfile *objfile);
 427
 428 extern const struct block *bkscm_scm_to_block
 429   (SCM block_scm, int arg_pos, const char *func_name, SCM *excp);
 430
 431 /* scm-cmd.c */
 432
 433 extern char *gdbscm_parse_command_name (const char *name,
 434                                         const char *func_name, int arg_pos,
 435                                         struct cmd_list_element ***base_list,
 436                                         struct cmd_list_element **start_list);
 437
 438 extern int gdbscm_valid_command_class_p (int command_class);
 439
 440 extern char *gdbscm_canonicalize_command_name (const char *name,
 441                                                int want_trailing_space);
 442
 443 /* scm-frame.c */
 444
 445 typedef struct _frame_smob frame_smob;
 446
 447 extern int frscm_is_frame (SCM scm);
 448
 449 extern frame_smob *frscm_get_frame_smob_arg_unsafe (SCM frame_scm, int arg_pos,
 450                                                     const char *func_name);
 451
 452 extern struct frame_info *frscm_frame_smob_to_frame (frame_smob *);
 453
 454 /* scm-iterator.c */
 455
 456 typedef struct _iterator_smob iterator_smob;
 457
 458 extern SCM itscm_iterator_smob_object (iterator_smob *i_smob);
 459
 460 extern SCM itscm_iterator_smob_progress (iterator_smob *i_smob);
 461
 462 extern void itscm_set_iterator_smob_progress_x (iterator_smob *i_smob,
 463                                                 SCM progress);
 464
 465 extern const char *itscm_iterator_smob_name (void);
 466
 467 extern SCM gdbscm_make_iterator (SCM object, SCM progress, SCM next);
 468
 469 extern int itscm_is_iterator (SCM scm);
 470
 471 extern SCM gdbscm_end_of_iteration (void);
 472
 473 extern int itscm_is_end_of_iteration (SCM obj);
 474
 475 extern SCM itscm_safe_call_next_x (SCM iter, excp_matcher_func *ok_excps);
 476
 477 extern SCM itscm_get_iterator_arg_unsafe (SCM self, int arg_pos,
 478                                           const char *func_name);
 479
 480 /* scm-lazy-string.c */
 481
 482 extern int lsscm_is_lazy_string (SCM scm);
 483
 484 extern SCM lsscm_make_lazy_string (CORE_ADDR address, int length,
 485                                    const char *encoding, struct type *type);
 486
 487 extern struct value *lsscm_safe_lazy_string_to_value (SCM string,
 488                                                       int arg_pos,
 489                                                       const char *func_name,
 490                                                       SCM *except_scmp);
 491
 492 extern void lsscm_val_print_lazy_string
 493   (SCM string, struct ui_file *stream,
 494    const struct value_print_options *options);
 495
 496 /* scm-objfile.c */
 497
 498 typedef struct _objfile_smob objfile_smob;
 499
 500 extern SCM ofscm_objfile_smob_pretty_printers (objfile_smob *o_smob);
 501
 502 extern objfile_smob *ofscm_objfile_smob_from_objfile (struct objfile *objfile);
 503
 504 extern SCM ofscm_scm_from_objfile (struct objfile *objfile);
 505
 506 /* scm-progspace.c */
 507
 508 typedef struct _pspace_smob pspace_smob;
 509
 510 extern SCM psscm_pspace_smob_pretty_printers (const pspace_smob *);
 511
 512 extern pspace_smob *psscm_pspace_smob_from_pspace (struct program_space *);
 513
 514 extern SCM psscm_scm_from_pspace (struct program_space *);
 515
 516 /* scm-string.c */
 517
 518 extern int gdbscm_scm_string_to_int (SCM string);
 519
 520 extern char *gdbscm_scm_to_c_string (SCM string);
 521
 522 extern SCM gdbscm_scm_from_c_string (const char *string);
 523
 524 extern SCM gdbscm_scm_from_printf (const char *format, ...)
 525     ATTRIBUTE_PRINTF (1, 2);
 526
 527 extern char *gdbscm_scm_to_string (SCM string, size_t *lenp,
 528                                    const char *charset,
 529                                    int strict, SCM *except_scmp);
 530
 531 extern SCM gdbscm_scm_from_string (const char *string, size_t len,
 532                                    const char *charset, int strict);
 533
 534 extern char *gdbscm_scm_to_host_string (SCM string, size_t *lenp, SCM *except);
 535
 536 extern SCM gdbscm_scm_from_host_string (const char *string, size_t len);
 537
 538 /* scm-symbol.c */
 539
 540 extern int syscm_is_symbol (SCM scm);
 541
 542 extern SCM syscm_scm_from_symbol (struct symbol *symbol);
 543
 544 extern struct symbol *syscm_get_valid_symbol_arg_unsafe
 545   (SCM self, int arg_pos, const char *func_name);
 546
 547 /* scm-symtab.c */
 548
 549 extern SCM stscm_scm_from_symtab (struct symtab *symtab);
 550
 551 extern SCM stscm_scm_from_sal (struct symtab_and_line sal);
 552
 553 /* scm-type.c */
 554
 555 typedef struct _type_smob type_smob;
 556
 557 extern int tyscm_is_type (SCM scm);
 558
 559 extern SCM tyscm_scm_from_type (struct type *type);
 560
 561 extern type_smob *tyscm_get_type_smob_arg_unsafe (SCM type_scm, int arg_pos,
 562                                                   const char *func_name);
 563
 564 extern struct type *tyscm_scm_to_type (SCM t_scm);
 565
 566 extern struct type *tyscm_type_smob_type (type_smob *t_smob);
 567
 568 extern SCM tyscm_scm_from_field (SCM type_scm, int field_num);
 569
 570 /* scm-value.c */
 571
 572 extern struct value *vlscm_scm_to_value (SCM scm);
 573
 574 extern int vlscm_is_value (SCM scm);
 575
 576 extern SCM vlscm_scm_from_value (struct value *value);
 577
 578 extern SCM vlscm_scm_from_value_unsafe (struct value *value);
 579
 580 extern struct value *vlscm_convert_typed_value_from_scheme
 581   (const char *func_name, int obj_arg_pos, SCM obj,
 582    int type_arg_pos, SCM type_scm, struct type *type, SCM *except_scmp,
 583    struct gdbarch *gdbarch, const struct language_defn *language);
 584
 585 extern struct value *vlscm_convert_value_from_scheme
 586   (const char *func_name, int obj_arg_pos, SCM obj, SCM *except_scmp,
 587    struct gdbarch *gdbarch, const struct language_defn *language);
 588 \f
 589 /* stript_lang methods */
 590
 591 extern objfile_script_sourcer_func gdbscm_source_objfile_script;
 592 extern objfile_script_executor_func gdbscm_execute_objfile_script;
 593
 594 extern int gdbscm_auto_load_enabled (const struct extension_language_defn *);
 595
 596 extern void gdbscm_preserve_values
 597   (const struct extension_language_defn *,
 598    struct objfile *, htab_t copied_types);
 599
 600 extern enum ext_lang_rc gdbscm_apply_val_pretty_printer
 601   (const struct extension_language_defn *,
 602    struct type *type,
 603    LONGEST embedded_offset, CORE_ADDR address,
 604    struct ui_file *stream, int recurse,
 605    struct value *val,
 606    const struct value_print_options *options,
 607    const struct language_defn *language);
 608
 609 extern int gdbscm_breakpoint_has_cond (const struct extension_language_defn *,
 610                                        struct breakpoint *b);
 611
 612 extern enum ext_lang_bp_stop gdbscm_breakpoint_cond_says_stop
 613   (const struct extension_language_defn *, struct breakpoint *b);
 614 \f
 615 /* Initializers for each piece of Scheme support, in alphabetical order.  */
 616
 617 extern void gdbscm_initialize_arches (void);
 618 extern void gdbscm_initialize_auto_load (void);
 619 extern void gdbscm_initialize_blocks (void);
 620 extern void gdbscm_initialize_breakpoints (void);
 621 extern void gdbscm_initialize_commands (void);
 622 extern void gdbscm_initialize_disasm (void);
 623 extern void gdbscm_initialize_exceptions (void);
 624 extern void gdbscm_initialize_frames (void);
 625 extern void gdbscm_initialize_iterators (void);
 626 extern void gdbscm_initialize_lazy_strings (void);
 627 extern void gdbscm_initialize_math (void);
 628 extern void gdbscm_initialize_objfiles (void);
 629 extern void gdbscm_initialize_pretty_printers (void);
 630 extern void gdbscm_initialize_parameters (void);
 631 extern void gdbscm_initialize_ports (void);
 632 extern void gdbscm_initialize_pspaces (void);
 633 extern void gdbscm_initialize_smobs (void);
 634 extern void gdbscm_initialize_strings (void);
 635 extern void gdbscm_initialize_symbols (void);
 636 extern void gdbscm_initialize_symtabs (void);
 637 extern void gdbscm_initialize_types (void);
 638 extern void gdbscm_initialize_values (void);
 639 \f
 640 /* Use these after a TRY_CATCH to throw the appropriate Scheme exception
 641    if a GDB error occurred.  */
 642
 643 #define GDBSCM_HANDLE_GDB_EXCEPTION(exception)          \
 644   do {                                                  \
 645     if (exception.reason < 0)                           \
 646       {                                                 \
 647         gdbscm_throw_gdb_exception (exception);         \
 648         /*NOTREACHED */                                 \
 649       }                                                 \
 650   } while (0)
 651
 652 /* If cleanups are establish outside the TRY_CATCH block, use this version.  */
 653
 654 #define GDBSCM_HANDLE_GDB_EXCEPTION_WITH_CLEANUPS(exception, cleanups)  \
 655   do {                                                                  \
 656     if (exception.reason < 0)                                           \
 657       {                                                                 \
 658         do_cleanups (cleanups);                                         \
 659         gdbscm_throw_gdb_exception (exception);                         \
 660         /*NOTREACHED */                                                 \
 661       }                                                                 \
 662   } while (0)
 663
 664 #endif /* GDB_GUILE_INTERNAL_H */