gdb/guile/scm-breakpoint.c

   1 /* Scheme interface to breakpoints.
   2
   3    Copyright (C) 2008-2019 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 #include "defs.h"
  24 #include "value.h"
  25 #include "breakpoint.h"
  26 #include "gdbcmd.h"
  27 #include "gdbthread.h"
  28 #include "observable.h"
  29 #include "cli/cli-script.h"
  30 #include "ada-lang.h"
  31 #include "arch-utils.h"
  32 #include "language.h"
  33 #include "guile-internal.h"
  34 #include "location.h"
  35
  36 /* The <gdb:breakpoint> smob.
  37    N.B.: The name of this struct is known to breakpoint.h.
  38
  39    Note: Breakpoints are added to gdb using a two step process:
  40    1) Call make-breakpoint to create a <gdb:breakpoint> object.
  41    2) Call register-breakpoint! to add the breakpoint to gdb.
  42    It is done this way so that the constructor, make-breakpoint, doesn't have
  43    any side-effects.  This means that the smob needs to store everything
  44    that was passed to make-breakpoint.  */
  45
  46 typedef struct gdbscm_breakpoint_object
  47 {
  48   /* This always appears first.  */
  49   gdb_smob base;
  50
  51   /* Non-zero if this breakpoint was created with make-breakpoint.  */
  52   int is_scheme_bkpt;
  53
  54   /* For breakpoints created with make-breakpoint, these are the parameters
  55      that were passed to make-breakpoint.  These values are not used except
  56      to register the breakpoint with GDB.  */
  57   struct
  58   {
  59     /* The string representation of the breakpoint.
  60        Space for this lives in GC space.  */
  61     char *location;
  62
  63     /* The kind of breakpoint.
  64        At the moment this can only be one of bp_breakpoint, bp_watchpoint.  */
  65     enum bptype type;
  66
  67     /* If a watchpoint, the kind of watchpoint.  */
  68     enum target_hw_bp_type access_type;
  69
  70     /* Non-zero if the breakpoint is an "internal" breakpoint.  */
  71     int is_internal;
  72   } spec;
  73
  74   /* The breakpoint number according to gdb.
  75      For breakpoints created from Scheme, this has the value -1 until the
  76      breakpoint is registered with gdb.
  77      This is recorded here because BP will be NULL when deleted.  */
  78   int number;
  79
  80   /* The gdb breakpoint object, or NULL if the breakpoint has not been
  81      registered yet, or has been deleted.  */
  82   struct breakpoint *bp;
  83
  84   /* Backlink to our containing <gdb:breakpoint> smob.
  85      This is needed when we are deleted, we need to unprotect the object
  86      from GC.  */
  87   SCM containing_scm;
  88
  89   /* A stop condition or #f.  */
  90   SCM stop;
  91 } breakpoint_smob;
  92
  93 static const char breakpoint_smob_name[] = "gdb:breakpoint";
  94
  95 /* The tag Guile knows the breakpoint smob by.  */
  96 static scm_t_bits breakpoint_smob_tag;
  97
  98 /* Variables used to pass information between the breakpoint_smob
  99    constructor and the breakpoint-created hook function.  */
 100 static SCM pending_breakpoint_scm = SCM_BOOL_F;
 101
 102 /* Keywords used by create-breakpoint!.  */
 103 static SCM type_keyword;
 104 static SCM wp_class_keyword;
 105 static SCM internal_keyword;
 106 \f
 107 /* Administrivia for breakpoint smobs.  */
 108
 109 /* The smob "free" function for <gdb:breakpoint>.  */
 110
 111 static size_t
 112 bpscm_free_breakpoint_smob (SCM self)
 113 {
 114   breakpoint_smob *bp_smob = (breakpoint_smob *) SCM_SMOB_DATA (self);
 115
 116   if (bp_smob->bp)
 117     bp_smob->bp->scm_bp_object = NULL;
 118
 119   /* Not necessary, done to catch bugs.  */
 120   bp_smob->bp = NULL;
 121   bp_smob->containing_scm = SCM_UNDEFINED;
 122   bp_smob->stop = SCM_UNDEFINED;
 123
 124   return 0;
 125 }
 126
 127 /* Return the name of TYPE.
 128    This doesn't handle all types, just the ones we export.  */
 129
 130 static const char *
 131 bpscm_type_to_string (enum bptype type)
 132 {
 133   switch (type)
 134     {
 135     case bp_none: return "BP_NONE";
 136     case bp_breakpoint: return "BP_BREAKPOINT";
 137     case bp_watchpoint: return "BP_WATCHPOINT";
 138     case bp_hardware_watchpoint: return "BP_HARDWARE_WATCHPOINT";
 139     case bp_read_watchpoint: return "BP_READ_WATCHPOINT";
 140     case bp_access_watchpoint: return "BP_ACCESS_WATCHPOINT";
 141     default: return "internal/other";
 142     }
 143 }
 144
 145 /* Return the name of ENABLE_STATE.  */
 146
 147 static const char *
 148 bpscm_enable_state_to_string (enum enable_state enable_state)
 149 {
 150   switch (enable_state)
 151     {
 152     case bp_disabled: return "disabled";
 153     case bp_enabled: return "enabled";
 154     case bp_call_disabled: return "call_disabled";
 155     default: return "unknown";
 156     }
 157 }
 158
 159 /* The smob "print" function for <gdb:breakpoint>.  */
 160
 161 static int
 162 bpscm_print_breakpoint_smob (SCM self, SCM port, scm_print_state *pstate)
 163 {
 164   breakpoint_smob *bp_smob = (breakpoint_smob *) SCM_SMOB_DATA (self);
 165   struct breakpoint *b = bp_smob->bp;
 166
 167   gdbscm_printf (port, "#<%s", breakpoint_smob_name);
 168
 169   /* Only print what we export to the user.
 170      The rest are possibly internal implementation details.  */
 171
 172   gdbscm_printf (port, " #%d", bp_smob->number);
 173
 174   /* Careful, the breakpoint may be invalid.  */
 175   if (b != NULL)
 176     {
 177       const char *str;
 178
 179       gdbscm_printf (port, " %s %s %s",
 180                      bpscm_type_to_string (b->type),
 181                      bpscm_enable_state_to_string (b->enable_state),
 182                      b->silent ? "silent" : "noisy");
 183
 184       gdbscm_printf (port, " hit:%d", b->hit_count);
 185       gdbscm_printf (port, " ignore:%d", b->ignore_count);
 186
 187       str = event_location_to_string (b->location.get ());
 188       if (str != NULL)
 189         gdbscm_printf (port, " @%s", str);
 190     }
 191
 192   scm_puts (">", port);
 193
 194   scm_remember_upto_here_1 (self);
 195
 196   /* Non-zero means success.  */
 197   return 1;
 198 }
 199
 200 /* Low level routine to create a <gdb:breakpoint> object.  */
 201
 202 static SCM
 203 bpscm_make_breakpoint_smob (void)
 204 {
 205   breakpoint_smob *bp_smob = (breakpoint_smob *)
 206     scm_gc_malloc (sizeof (breakpoint_smob), breakpoint_smob_name);
 207   SCM bp_scm;
 208
 209   memset (bp_smob, 0, sizeof (*bp_smob));
 210   bp_smob->number = -1;
 211   bp_smob->stop = SCM_BOOL_F;
 212   bp_scm = scm_new_smob (breakpoint_smob_tag, (scm_t_bits) bp_smob);
 213   bp_smob->containing_scm = bp_scm;
 214   gdbscm_init_gsmob (&bp_smob->base);
 215
 216   return bp_scm;
 217 }
 218
 219 /* Return non-zero if we want a Scheme wrapper for breakpoint B.
 220    If FROM_SCHEME is non-zero,this is called for a breakpoint created
 221    by the user from Scheme.  Otherwise it is zero.  */
 222
 223 static int
 224 bpscm_want_scm_wrapper_p (struct breakpoint *bp, int from_scheme)
 225 {
 226   /* Don't create <gdb:breakpoint> objects for internal GDB breakpoints.  */
 227   if (bp->number < 0 && !from_scheme)
 228     return 0;
 229
 230   /* The others are not supported.  */
 231   if (bp->type != bp_breakpoint
 232       && bp->type != bp_watchpoint
 233       && bp->type != bp_hardware_watchpoint
 234       && bp->type != bp_read_watchpoint
 235       && bp->type != bp_access_watchpoint)
 236     return 0;
 237
 238   return 1;
 239 }
 240
 241 /* Install the Scheme side of a breakpoint, CONTAINING_SCM, in
 242    the gdb side BP.  */
 243
 244 static void
 245 bpscm_attach_scm_to_breakpoint (struct breakpoint *bp, SCM containing_scm)
 246 {
 247   breakpoint_smob *bp_smob;
 248
 249   bp_smob = (breakpoint_smob *) SCM_SMOB_DATA (containing_scm);
 250   bp_smob->number = bp->number;
 251   bp_smob->bp = bp;
 252   bp_smob->containing_scm = containing_scm;
 253   bp_smob->bp->scm_bp_object = bp_smob;
 254
 255   /* The owner of this breakpoint is not in GC-controlled memory, so we need
 256      to protect it from GC until the breakpoint is deleted.  */
 257   scm_gc_protect_object (containing_scm);
 258 }
 259
 260 /* Return non-zero if SCM is a breakpoint smob.  */
 261
 262 static int
 263 bpscm_is_breakpoint (SCM scm)
 264 {
 265   return SCM_SMOB_PREDICATE (breakpoint_smob_tag, scm);
 266 }
 267
 268 /* (breakpoint? scm) -> boolean */
 269
 270 static SCM
 271 gdbscm_breakpoint_p (SCM scm)
 272 {
 273   return scm_from_bool (bpscm_is_breakpoint (scm));
 274 }
 275
 276 /* Returns the <gdb:breakpoint> object in SELF.
 277    Throws an exception if SELF is not a <gdb:breakpoint> object.  */
 278
 279 static SCM
 280 bpscm_get_breakpoint_arg_unsafe (SCM self, int arg_pos, const char *func_name)
 281 {
 282   SCM_ASSERT_TYPE (bpscm_is_breakpoint (self), self, arg_pos, func_name,
 283                    breakpoint_smob_name);
 284
 285   return self;
 286 }
 287
 288 /* Returns a pointer to the breakpoint smob of SELF.
 289    Throws an exception if SELF is not a <gdb:breakpoint> object.  */
 290
 291 static breakpoint_smob *
 292 bpscm_get_breakpoint_smob_arg_unsafe (SCM self, int arg_pos,
 293                                       const char *func_name)
 294 {
 295   SCM bp_scm = bpscm_get_breakpoint_arg_unsafe (self, arg_pos, func_name);
 296   breakpoint_smob *bp_smob = (breakpoint_smob *) SCM_SMOB_DATA (bp_scm);
 297
 298   return bp_smob;
 299 }
 300
 301 /* Return non-zero if breakpoint BP_SMOB is valid.  */
 302
 303 static int
 304 bpscm_is_valid (breakpoint_smob *bp_smob)
 305 {
 306   return bp_smob->bp != NULL;
 307 }
 308
 309 /* Returns the breakpoint smob in SELF, verifying it's valid.
 310    Throws an exception if SELF is not a <gdb:breakpoint> object,
 311    or is invalid.  */
 312
 313 static breakpoint_smob *
 314 bpscm_get_valid_breakpoint_smob_arg_unsafe (SCM self, int arg_pos,
 315                                             const char *func_name)
 316 {
 317   breakpoint_smob *bp_smob
 318     = bpscm_get_breakpoint_smob_arg_unsafe (self, arg_pos, func_name);
 319
 320   if (!bpscm_is_valid (bp_smob))
 321     {
 322       gdbscm_invalid_object_error (func_name, arg_pos, self,
 323                                    _("<gdb:breakpoint>"));
 324     }
 325
 326   return bp_smob;
 327 }
 328 \f
 329 /* Breakpoint methods.  */
 330
 331 /* (make-breakpoint string [#:type integer] [#:wp-class integer]
 332     [#:internal boolean) -> <gdb:breakpoint>
 333
 334    The result is the <gdb:breakpoint> Scheme object.
 335    The breakpoint is not available to be used yet, however.
 336    It must still be added to gdb with register-breakpoint!.  */
 337
 338 static SCM
 339 gdbscm_make_breakpoint (SCM location_scm, SCM rest)
 340 {
 341   const SCM keywords[] = {
 342     type_keyword, wp_class_keyword, internal_keyword, SCM_BOOL_F
 343   };
 344   char *s;
 345   char *location;
 346   int type_arg_pos = -1, access_type_arg_pos = -1, internal_arg_pos = -1;
 347   enum bptype type = bp_breakpoint;
 348   enum target_hw_bp_type access_type = hw_write;
 349   int internal = 0;
 350   SCM result;
 351   breakpoint_smob *bp_smob;
 352
 353   gdbscm_parse_function_args (FUNC_NAME, SCM_ARG1, keywords, "s#iit",
 354                               location_scm, &location, rest,
 355                               &type_arg_pos, &type,
 356                               &access_type_arg_pos, &access_type,
 357                               &internal_arg_pos, &internal);
 358
 359   result = bpscm_make_breakpoint_smob ();
 360   bp_smob = (breakpoint_smob *) SCM_SMOB_DATA (result);
 361
 362   s = location;
 363   location = gdbscm_gc_xstrdup (s);
 364   xfree (s);
 365
 366   switch (type)
 367     {
 368     case bp_breakpoint:
 369       if (access_type_arg_pos > 0)
 370         {
 371           gdbscm_misc_error (FUNC_NAME, access_type_arg_pos,
 372                              scm_from_int (access_type),
 373                              _("access type with breakpoint is not allowed"));
 374         }
 375       break;
 376     case bp_watchpoint:
 377       switch (access_type)
 378         {
 379         case hw_write:
 380         case hw_access:
 381         case hw_read:
 382           break;
 383         default:
 384           gdbscm_out_of_range_error (FUNC_NAME, access_type_arg_pos,
 385                                      scm_from_int (access_type),
 386                                      _("invalid watchpoint class"));
 387         }
 388       break;
 389     default:
 390       gdbscm_out_of_range_error (FUNC_NAME, access_type_arg_pos,
 391                                  scm_from_int (type),
 392                                  _("invalid breakpoint type"));
 393     }
 394
 395   bp_smob->is_scheme_bkpt = 1;
 396   bp_smob->spec.location = location;
 397   bp_smob->spec.type = type;
 398   bp_smob->spec.access_type = access_type;
 399   bp_smob->spec.is_internal = internal;
 400
 401   return result;
 402 }
 403
 404 /* (register-breakpoint! <gdb:breakpoint>) -> unspecified
 405
 406    It is an error to register a breakpoint created outside of Guile,
 407    or an already-registered breakpoint.  */
 408
 409 static SCM
 410 gdbscm_register_breakpoint_x (SCM self)
 411 {
 412   breakpoint_smob *bp_smob
 413     = bpscm_get_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 414   struct gdb_exception except = exception_none;
 415   const char *location, *copy;
 416
 417   /* We only support registering breakpoints created with make-breakpoint.  */
 418   if (!bp_smob->is_scheme_bkpt)
 419     scm_misc_error (FUNC_NAME, _("not a Scheme breakpoint"), SCM_EOL);
 420
 421   if (bpscm_is_valid (bp_smob))
 422     scm_misc_error (FUNC_NAME, _("breakpoint is already registered"), SCM_EOL);
 423
 424   pending_breakpoint_scm = self;
 425   location = bp_smob->spec.location;
 426   copy = skip_spaces (location);
 427   event_location_up eloc
 428     = string_to_event_location_basic (&copy,
 429                                       current_language,
 430                                       symbol_name_match_type::WILD);
 431
 432   try
 433     {
 434       int internal = bp_smob->spec.is_internal;
 435
 436       switch (bp_smob->spec.type)
 437         {
 438         case bp_breakpoint:
 439           {
 440             create_breakpoint (get_current_arch (),
 441                                eloc.get (), NULL, -1, NULL,
 442                                0,
 443                                0, bp_breakpoint,
 444                                0,
 445                                AUTO_BOOLEAN_TRUE,
 446                                &bkpt_breakpoint_ops,
 447                                0, 1, internal, 0);
 448             break;
 449           }
 450         case bp_watchpoint:
 451           {
 452             enum target_hw_bp_type access_type = bp_smob->spec.access_type;
 453
 454             if (access_type == hw_write)
 455               watch_command_wrapper (location, 0, internal);
 456             else if (access_type == hw_access)
 457               awatch_command_wrapper (location, 0, internal);
 458             else if (access_type == hw_read)
 459               rwatch_command_wrapper (location, 0, internal);
 460             else
 461               gdb_assert_not_reached ("invalid access type");
 462             break;
 463           }
 464         default:
 465           gdb_assert_not_reached ("invalid breakpoint type");
 466         }
 467     }
 468   catch (const gdb_exception &ex)
 469     {
 470       except = ex;
 471     }
 472
 473   /* Ensure this gets reset, even if there's an error.  */
 474   pending_breakpoint_scm = SCM_BOOL_F;
 475   GDBSCM_HANDLE_GDB_EXCEPTION (except);
 476
 477   return SCM_UNSPECIFIED;
 478 }
 479
 480 /* (delete-breakpoint! <gdb:breakpoint>) -> unspecified
 481    Scheme function which deletes (removes) the underlying GDB breakpoint
 482    from GDB's list of breakpoints.  This triggers the breakpoint_deleted
 483    observer which will call gdbscm_breakpoint_deleted; that function cleans
 484    up the Scheme bits.  */
 485
 486 static SCM
 487 gdbscm_delete_breakpoint_x (SCM self)
 488 {
 489   breakpoint_smob *bp_smob
 490     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 491
 492   try
 493     {
 494       delete_breakpoint (bp_smob->bp);
 495     }
 496   catch (const gdb_exception &except)
 497     {
 498       GDBSCM_HANDLE_GDB_EXCEPTION (except);
 499     }
 500
 501   return SCM_UNSPECIFIED;
 502 }
 503
 504 /* iterate_over_breakpoints function for gdbscm_breakpoints.  */
 505
 506 static int
 507 bpscm_build_bp_list (struct breakpoint *bp, void *arg)
 508 {
 509   SCM *list = (SCM *) arg;
 510   breakpoint_smob *bp_smob = bp->scm_bp_object;
 511
 512   /* Lazily create wrappers for breakpoints created outside Scheme.  */
 513
 514   if (bp_smob == NULL)
 515     {
 516       if (bpscm_want_scm_wrapper_p (bp, 0))
 517         {
 518           SCM bp_scm;
 519
 520           bp_scm = bpscm_make_breakpoint_smob ();
 521           bpscm_attach_scm_to_breakpoint (bp, bp_scm);
 522           /* Refetch it.  */
 523           bp_smob = bp->scm_bp_object;
 524         }
 525     }
 526
 527   /* Not all breakpoints will have a companion Scheme object.
 528      Only breakpoints that trigger the created_breakpoint observer call,
 529      and satisfy certain conditions (see bpscm_want_scm_wrapper_p),
 530      get a companion object (this includes Scheme-created breakpoints).  */
 531
 532   if (bp_smob != NULL)
 533     *list = scm_cons (bp_smob->containing_scm, *list);
 534
 535   return 0;
 536 }
 537
 538 /* (breakpoints) -> list
 539    Return a list of all breakpoints.  */
 540
 541 static SCM
 542 gdbscm_breakpoints (void)
 543 {
 544   SCM list = SCM_EOL;
 545
 546   /* If iterate_over_breakpoints returns non-NULL it means the iteration
 547      terminated early.
 548      In that case abandon building the list and return #f.  */
 549   if (iterate_over_breakpoints (bpscm_build_bp_list, &list) != NULL)
 550     return SCM_BOOL_F;
 551
 552   return scm_reverse_x (list, SCM_EOL);
 553 }
 554
 555 /* (breakpoint-valid? <gdb:breakpoint>) -> boolean
 556    Returns #t if SELF is still valid.  */
 557
 558 static SCM
 559 gdbscm_breakpoint_valid_p (SCM self)
 560 {
 561   breakpoint_smob *bp_smob
 562     = bpscm_get_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 563
 564   return scm_from_bool (bpscm_is_valid (bp_smob));
 565 }
 566
 567 /* (breakpoint-enabled? <gdb:breakpoint>) -> boolean */
 568
 569 static SCM
 570 gdbscm_breakpoint_enabled_p (SCM self)
 571 {
 572   breakpoint_smob *bp_smob
 573     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 574
 575   return scm_from_bool (bp_smob->bp->enable_state == bp_enabled);
 576 }
 577
 578 /* (set-breakpoint-enabled? <gdb:breakpoint> boolean) -> unspecified */
 579
 580 static SCM
 581 gdbscm_set_breakpoint_enabled_x (SCM self, SCM newvalue)
 582 {
 583   breakpoint_smob *bp_smob
 584     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 585
 586   SCM_ASSERT_TYPE (gdbscm_is_bool (newvalue), newvalue, SCM_ARG2, FUNC_NAME,
 587                    _("boolean"));
 588
 589   try
 590     {
 591       if (gdbscm_is_true (newvalue))
 592         enable_breakpoint (bp_smob->bp);
 593       else
 594         disable_breakpoint (bp_smob->bp);
 595     }
 596   catch (const gdb_exception &except)
 597     {
 598       GDBSCM_HANDLE_GDB_EXCEPTION (except);
 599     }
 600
 601   return SCM_UNSPECIFIED;
 602 }
 603
 604 /* (breakpoint-silent? <gdb:breakpoint>) -> boolean */
 605
 606 static SCM
 607 gdbscm_breakpoint_silent_p (SCM self)
 608 {
 609   breakpoint_smob *bp_smob
 610     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 611
 612   return scm_from_bool (bp_smob->bp->silent);
 613 }
 614
 615 /* (set-breakpoint-silent?! <gdb:breakpoint> boolean) -> unspecified */
 616
 617 static SCM
 618 gdbscm_set_breakpoint_silent_x (SCM self, SCM newvalue)
 619 {
 620   breakpoint_smob *bp_smob
 621     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 622
 623   SCM_ASSERT_TYPE (gdbscm_is_bool (newvalue), newvalue, SCM_ARG2, FUNC_NAME,
 624                    _("boolean"));
 625
 626   try
 627     {
 628       breakpoint_set_silent (bp_smob->bp, gdbscm_is_true (newvalue));
 629     }
 630   catch (const gdb_exception &except)
 631     {
 632       GDBSCM_HANDLE_GDB_EXCEPTION (except);
 633     }
 634
 635   return SCM_UNSPECIFIED;
 636 }
 637
 638 /* (breakpoint-ignore-count <gdb:breakpoint>) -> integer */
 639
 640 static SCM
 641 gdbscm_breakpoint_ignore_count (SCM self)
 642 {
 643   breakpoint_smob *bp_smob
 644     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 645
 646   return scm_from_long (bp_smob->bp->ignore_count);
 647 }
 648
 649 /* (set-breakpoint-ignore-count! <gdb:breakpoint> integer)
 650      -> unspecified */
 651
 652 static SCM
 653 gdbscm_set_breakpoint_ignore_count_x (SCM self, SCM newvalue)
 654 {
 655   breakpoint_smob *bp_smob
 656     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 657   long value;
 658
 659   SCM_ASSERT_TYPE (scm_is_signed_integer (newvalue, LONG_MIN, LONG_MAX),
 660                    newvalue, SCM_ARG2, FUNC_NAME, _("integer"));
 661
 662   value = scm_to_long (newvalue);
 663   if (value < 0)
 664     value = 0;
 665
 666   try
 667     {
 668       set_ignore_count (bp_smob->number, (int) value, 0);
 669     }
 670   catch (const gdb_exception &except)
 671     {
 672       GDBSCM_HANDLE_GDB_EXCEPTION (except);
 673     }
 674
 675   return SCM_UNSPECIFIED;
 676 }
 677
 678 /* (breakpoint-hit-count <gdb:breakpoint>) -> integer */
 679
 680 static SCM
 681 gdbscm_breakpoint_hit_count (SCM self)
 682 {
 683   breakpoint_smob *bp_smob
 684     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 685
 686   return scm_from_long (bp_smob->bp->hit_count);
 687 }
 688
 689 /* (set-breakpoint-hit-count! <gdb:breakpoint> integer) -> unspecified */
 690
 691 static SCM
 692 gdbscm_set_breakpoint_hit_count_x (SCM self, SCM newvalue)
 693 {
 694   breakpoint_smob *bp_smob
 695     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 696   long value;
 697
 698   SCM_ASSERT_TYPE (scm_is_signed_integer (newvalue, LONG_MIN, LONG_MAX),
 699                    newvalue, SCM_ARG2, FUNC_NAME, _("integer"));
 700
 701   value = scm_to_long (newvalue);
 702   if (value < 0)
 703     value = 0;
 704
 705   if (value != 0)
 706     {
 707       gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG2, newvalue,
 708                                  _("hit-count must be zero"));
 709     }
 710
 711   bp_smob->bp->hit_count = 0;
 712
 713   return SCM_UNSPECIFIED;
 714 }
 715
 716 /* (breakpoint-thread <gdb:breakpoint>) -> integer */
 717
 718 static SCM
 719 gdbscm_breakpoint_thread (SCM self)
 720 {
 721   breakpoint_smob *bp_smob
 722     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 723
 724   if (bp_smob->bp->thread == -1)
 725     return SCM_BOOL_F;
 726
 727   return scm_from_long (bp_smob->bp->thread);
 728 }
 729
 730 /* (set-breakpoint-thread! <gdb:breakpoint> integer) -> unspecified */
 731
 732 static SCM
 733 gdbscm_set_breakpoint_thread_x (SCM self, SCM newvalue)
 734 {
 735   breakpoint_smob *bp_smob
 736     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 737   long id;
 738
 739   if (scm_is_signed_integer (newvalue, LONG_MIN, LONG_MAX))
 740     {
 741       id = scm_to_long (newvalue);
 742       if (!valid_global_thread_id (id))
 743         {
 744           gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG2, newvalue,
 745                                      _("invalid thread id"));
 746         }
 747     }
 748   else if (gdbscm_is_false (newvalue))
 749     id = -1;
 750   else
 751     SCM_ASSERT_TYPE (0, newvalue, SCM_ARG2, FUNC_NAME, _("integer or #f"));
 752
 753   breakpoint_set_thread (bp_smob->bp, id);
 754
 755   return SCM_UNSPECIFIED;
 756 }
 757
 758 /* (breakpoint-task <gdb:breakpoint>) -> integer */
 759
 760 static SCM
 761 gdbscm_breakpoint_task (SCM self)
 762 {
 763   breakpoint_smob *bp_smob
 764     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 765
 766   if (bp_smob->bp->task == 0)
 767     return SCM_BOOL_F;
 768
 769   return scm_from_long (bp_smob->bp->task);
 770 }
 771
 772 /* (set-breakpoint-task! <gdb:breakpoint> integer) -> unspecified */
 773
 774 static SCM
 775 gdbscm_set_breakpoint_task_x (SCM self, SCM newvalue)
 776 {
 777   breakpoint_smob *bp_smob
 778     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 779   long id;
 780   int valid_id = 0;
 781
 782   if (scm_is_signed_integer (newvalue, LONG_MIN, LONG_MAX))
 783     {
 784       id = scm_to_long (newvalue);
 785
 786       try
 787         {
 788           valid_id = valid_task_id (id);
 789         }
 790       catch (const gdb_exception &except)
 791         {
 792           GDBSCM_HANDLE_GDB_EXCEPTION (except);
 793         }
 794
 795       if (! valid_id)
 796         {
 797           gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG2, newvalue,
 798                                      _("invalid task id"));
 799         }
 800     }
 801   else if (gdbscm_is_false (newvalue))
 802     id = 0;
 803   else
 804     SCM_ASSERT_TYPE (0, newvalue, SCM_ARG2, FUNC_NAME, _("integer or #f"));
 805
 806   try
 807     {
 808       breakpoint_set_task (bp_smob->bp, id);
 809     }
 810   catch (const gdb_exception &except)
 811     {
 812       GDBSCM_HANDLE_GDB_EXCEPTION (except);
 813     }
 814
 815   return SCM_UNSPECIFIED;
 816 }
 817
 818 /* (breakpoint-location <gdb:breakpoint>) -> string */
 819
 820 static SCM
 821 gdbscm_breakpoint_location (SCM self)
 822 {
 823   breakpoint_smob *bp_smob
 824     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 825   const char *str;
 826
 827   if (bp_smob->bp->type != bp_breakpoint)
 828     return SCM_BOOL_F;
 829
 830   str = event_location_to_string (bp_smob->bp->location.get ());
 831   if (! str)
 832     str = "";
 833
 834   return gdbscm_scm_from_c_string (str);
 835 }
 836
 837 /* (breakpoint-expression <gdb:breakpoint>) -> string
 838    This is only valid for watchpoints.
 839    Returns #f for non-watchpoints.  */
 840
 841 static SCM
 842 gdbscm_breakpoint_expression (SCM self)
 843 {
 844   breakpoint_smob *bp_smob
 845     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 846   struct watchpoint *wp;
 847
 848   if (!is_watchpoint (bp_smob->bp))
 849     return SCM_BOOL_F;
 850
 851   wp = (struct watchpoint *) bp_smob->bp;
 852
 853   const char *str = wp->exp_string;
 854   if (! str)
 855     str = "";
 856
 857   return gdbscm_scm_from_c_string (str);
 858 }
 859
 860 /* (breakpoint-condition <gdb:breakpoint>) -> string */
 861
 862 static SCM
 863 gdbscm_breakpoint_condition (SCM self)
 864 {
 865   breakpoint_smob *bp_smob
 866     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 867   char *str;
 868
 869   str = bp_smob->bp->cond_string;
 870   if (! str)
 871     return SCM_BOOL_F;
 872
 873   return gdbscm_scm_from_c_string (str);
 874 }
 875
 876 /* (set-breakpoint-condition! <gdb:breakpoint> string|#f)
 877    -> unspecified */
 878
 879 static SCM
 880 gdbscm_set_breakpoint_condition_x (SCM self, SCM newvalue)
 881 {
 882   breakpoint_smob *bp_smob
 883     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 884
 885   SCM_ASSERT_TYPE (scm_is_string (newvalue) || gdbscm_is_false (newvalue),
 886                    newvalue, SCM_ARG2, FUNC_NAME,
 887                    _("string or #f"));
 888
 889   return gdbscm_wrap ([=]
 890     {
 891       gdb::unique_xmalloc_ptr<char> exp
 892         = (gdbscm_is_false (newvalue)
 893            ? nullptr
 894            : gdbscm_scm_to_c_string (newvalue));
 895
 896       set_breakpoint_condition (bp_smob->bp, exp ? exp.get () : "", 0);
 897
 898       return SCM_UNSPECIFIED;
 899     });
 900 }
 901
 902 /* (breakpoint-stop <gdb:breakpoint>) -> procedure or #f */
 903
 904 static SCM
 905 gdbscm_breakpoint_stop (SCM self)
 906 {
 907   breakpoint_smob *bp_smob
 908     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 909
 910   return bp_smob->stop;
 911 }
 912
 913 /* (set-breakpoint-stop! <gdb:breakpoint> procedure|#f)
 914    -> unspecified */
 915
 916 static SCM
 917 gdbscm_set_breakpoint_stop_x (SCM self, SCM newvalue)
 918 {
 919   breakpoint_smob *bp_smob
 920     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 921   const struct extension_language_defn *extlang = NULL;
 922
 923   SCM_ASSERT_TYPE (gdbscm_is_procedure (newvalue)
 924                    || gdbscm_is_false (newvalue),
 925                    newvalue, SCM_ARG2, FUNC_NAME,
 926                    _("procedure or #f"));
 927
 928   if (bp_smob->bp->cond_string != NULL)
 929     extlang = get_ext_lang_defn (EXT_LANG_GDB);
 930   if (extlang == NULL)
 931     extlang = get_breakpoint_cond_ext_lang (bp_smob->bp, EXT_LANG_GUILE);
 932   if (extlang != NULL)
 933     {
 934       char *error_text
 935         = xstrprintf (_("Only one stop condition allowed.  There is"
 936                         " currently a %s stop condition defined for"
 937                         " this breakpoint."),
 938                       ext_lang_capitalized_name (extlang));
 939
 940       scm_dynwind_begin ((scm_t_dynwind_flags) 0);
 941       gdbscm_dynwind_xfree (error_text);
 942       gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG1, self, error_text);
 943       /* The following line, while unnecessary, is present for completeness
 944          sake.  */
 945       scm_dynwind_end ();
 946     }
 947
 948   bp_smob->stop = newvalue;
 949
 950   return SCM_UNSPECIFIED;
 951 }
 952
 953 /* (breakpoint-commands <gdb:breakpoint>) -> string */
 954
 955 static SCM
 956 gdbscm_breakpoint_commands (SCM self)
 957 {
 958   breakpoint_smob *bp_smob
 959     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 960   struct breakpoint *bp;
 961   SCM result;
 962
 963   bp = bp_smob->bp;
 964
 965   if (bp->commands == NULL)
 966     return SCM_BOOL_F;
 967
 968   string_file buf;
 969
 970   current_uiout->redirect (&buf);
 971   try
 972     {
 973       print_command_lines (current_uiout, breakpoint_commands (bp), 0);
 974     }
 975   catch (const gdb_exception &except)
 976     {
 977       current_uiout->redirect (NULL);
 978       gdbscm_throw_gdb_exception (except);
 979     }
 980
 981   current_uiout->redirect (NULL);
 982   result = gdbscm_scm_from_c_string (buf.c_str ());
 983
 984   return result;
 985 }
 986
 987 /* (breakpoint-type <gdb:breakpoint>) -> integer */
 988
 989 static SCM
 990 gdbscm_breakpoint_type (SCM self)
 991 {
 992   breakpoint_smob *bp_smob
 993     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
 994
 995   return scm_from_long (bp_smob->bp->type);
 996 }
 997
 998 /* (breakpoint-visible? <gdb:breakpoint>) -> boolean */
 999
1000 static SCM
1001 gdbscm_breakpoint_visible (SCM self)
1002 {
1003   breakpoint_smob *bp_smob
1004     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
1005
1006   return scm_from_bool (bp_smob->bp->number >= 0);
1007 }
1008
1009 /* (breakpoint-number <gdb:breakpoint>) -> integer */
1010
1011 static SCM
1012 gdbscm_breakpoint_number (SCM self)
1013 {
1014   breakpoint_smob *bp_smob
1015     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
1016
1017   return scm_from_long (bp_smob->number);
1018 }
1019 \f
1020 /* Return TRUE if "stop" has been set for this breakpoint.
1021
1022    This is the extension_language_ops.breakpoint_has_cond "method".  */
1023
1024 int
1025 gdbscm_breakpoint_has_cond (const struct extension_language_defn *extlang,
1026                             struct breakpoint *b)
1027 {
1028   breakpoint_smob *bp_smob = b->scm_bp_object;
1029
1030   if (bp_smob == NULL)
1031     return 0;
1032
1033   return gdbscm_is_procedure (bp_smob->stop);
1034 }
1035
1036 /* Call the "stop" method in the breakpoint class.
1037    This must only be called if gdbscm_breakpoint_has_cond returns true.
1038    If the stop method returns #t, the inferior will be stopped at the
1039    breakpoint.  Otherwise the inferior will be allowed to continue
1040    (assuming other conditions don't indicate "stop").
1041
1042    This is the extension_language_ops.breakpoint_cond_says_stop "method".  */
1043
1044 enum ext_lang_bp_stop
1045 gdbscm_breakpoint_cond_says_stop
1046   (const struct extension_language_defn *extlang, struct breakpoint *b)
1047 {
1048   breakpoint_smob *bp_smob = b->scm_bp_object;
1049   SCM predicate_result;
1050   int stop;
1051
1052   if (bp_smob == NULL)
1053     return EXT_LANG_BP_STOP_UNSET;
1054   if (!gdbscm_is_procedure (bp_smob->stop))
1055     return EXT_LANG_BP_STOP_UNSET;
1056
1057   stop = 1;
1058
1059   predicate_result
1060     = gdbscm_safe_call_1 (bp_smob->stop, bp_smob->containing_scm, NULL);
1061
1062   if (gdbscm_is_exception (predicate_result))
1063     ; /* Exception already printed.  */
1064   /* If the "stop" function returns #f that means
1065      the Scheme breakpoint wants GDB to continue.  */
1066   else if (gdbscm_is_false (predicate_result))
1067     stop = 0;
1068
1069   return stop ? EXT_LANG_BP_STOP_YES : EXT_LANG_BP_STOP_NO;
1070 }
1071 \f
1072 /* Event callback functions.  */
1073
1074 /* Callback that is used when a breakpoint is created.
1075    For breakpoints created by Scheme, i.e., gdbscm_create_breakpoint_x, finish
1076    object creation by connecting the Scheme wrapper to the gdb object.
1077    We ignore breakpoints created from gdb or python here, we create the
1078    Scheme wrapper for those when there's a need to, e.g.,
1079    gdbscm_breakpoints.  */
1080
1081 static void
1082 bpscm_breakpoint_created (struct breakpoint *bp)
1083 {
1084   SCM bp_scm;
1085
1086   if (gdbscm_is_false (pending_breakpoint_scm))
1087     return;
1088
1089   /* Verify our caller error checked the user's request.  */
1090   gdb_assert (bpscm_want_scm_wrapper_p (bp, 1));
1091
1092   bp_scm = pending_breakpoint_scm;
1093   pending_breakpoint_scm = SCM_BOOL_F;
1094
1095   bpscm_attach_scm_to_breakpoint (bp, bp_scm);
1096 }
1097
1098 /* Callback that is used when a breakpoint is deleted.  This will
1099    invalidate the corresponding Scheme object.  */
1100
1101 static void
1102 bpscm_breakpoint_deleted (struct breakpoint *b)
1103 {
1104   int num = b->number;
1105   struct breakpoint *bp;
1106
1107   /* TODO: Why the lookup?  We have B.  */
1108
1109   bp = get_breakpoint (num);
1110   if (bp)
1111     {
1112       breakpoint_smob *bp_smob = bp->scm_bp_object;
1113
1114       if (bp_smob)
1115         {
1116           bp_smob->bp = NULL;
1117           bp_smob->number = -1;
1118           bp_smob->stop = SCM_BOOL_F;
1119           scm_gc_unprotect_object (bp_smob->containing_scm);
1120         }
1121     }
1122 }
1123 \f
1124 /* Initialize the Scheme breakpoint code.  */
1125
1126 static const scheme_integer_constant breakpoint_integer_constants[] =
1127 {
1128   { "BP_NONE", bp_none },
1129   { "BP_BREAKPOINT", bp_breakpoint },
1130   { "BP_WATCHPOINT", bp_watchpoint },
1131   { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint },
1132   { "BP_READ_WATCHPOINT", bp_read_watchpoint },
1133   { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint },
1134
1135   { "WP_READ", hw_read },
1136   { "WP_WRITE", hw_write },
1137   { "WP_ACCESS", hw_access },
1138
1139   END_INTEGER_CONSTANTS
1140 };
1141
1142 static const scheme_function breakpoint_functions[] =
1143 {
1144   { "make-breakpoint", 1, 0, 1, as_a_scm_t_subr (gdbscm_make_breakpoint),
1145     "\
1146 Create a GDB breakpoint object.\n\
1147 \n\
1148   Arguments:\n\
1149     location [#:type <type>] [#:wp-class <wp-class>] [#:internal <bool>]\n\
1150   Returns:\n\
1151     <gdb:breakpoint object" },
1152
1153   { "register-breakpoint!", 1, 0, 0,
1154     as_a_scm_t_subr (gdbscm_register_breakpoint_x),
1155     "\
1156 Register a <gdb:breakpoint> object with GDB." },
1157
1158   { "delete-breakpoint!", 1, 0, 0, as_a_scm_t_subr (gdbscm_delete_breakpoint_x),
1159     "\
1160 Delete the breakpoint from GDB." },
1161
1162   { "breakpoints", 0, 0, 0, as_a_scm_t_subr (gdbscm_breakpoints),
1163     "\
1164 Return a list of all GDB breakpoints.\n\
1165 \n\
1166   Arguments: none" },
1167
1168   { "breakpoint?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_p),
1169     "\
1170 Return #t if the object is a <gdb:breakpoint> object." },
1171
1172   { "breakpoint-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_valid_p),
1173     "\
1174 Return #t if the breakpoint has not been deleted from GDB." },
1175
1176   { "breakpoint-number", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_number),
1177     "\
1178 Return the breakpoint's number." },
1179
1180   { "breakpoint-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_type),
1181     "\
1182 Return the type of the breakpoint." },
1183
1184   { "breakpoint-visible?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_visible),
1185     "\
1186 Return #t if the breakpoint is visible to the user." },
1187
1188   { "breakpoint-location", 1, 0, 0,
1189     as_a_scm_t_subr (gdbscm_breakpoint_location),
1190     "\
1191 Return the location of the breakpoint as specified by the user." },
1192
1193   { "breakpoint-expression", 1, 0, 0,
1194     as_a_scm_t_subr (gdbscm_breakpoint_expression),
1195     "\
1196 Return the expression of the breakpoint as specified by the user.\n\
1197 Valid for watchpoints only, returns #f for non-watchpoints." },
1198
1199   { "breakpoint-enabled?", 1, 0, 0,
1200     as_a_scm_t_subr (gdbscm_breakpoint_enabled_p),
1201     "\
1202 Return #t if the breakpoint is enabled." },
1203
1204   { "set-breakpoint-enabled!", 2, 0, 0,
1205     as_a_scm_t_subr (gdbscm_set_breakpoint_enabled_x),
1206     "\
1207 Set the breakpoint's enabled state.\n\
1208 \n\
1209   Arguments: <gdb:breakpoint> boolean" },
1210
1211   { "breakpoint-silent?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_silent_p),
1212     "\
1213 Return #t if the breakpoint is silent." },
1214
1215   { "set-breakpoint-silent!", 2, 0, 0,
1216     as_a_scm_t_subr (gdbscm_set_breakpoint_silent_x),
1217     "\
1218 Set the breakpoint's silent state.\n\
1219 \n\
1220   Arguments: <gdb:breakpoint> boolean" },
1221
1222   { "breakpoint-ignore-count", 1, 0, 0,
1223     as_a_scm_t_subr (gdbscm_breakpoint_ignore_count),
1224     "\
1225 Return the breakpoint's \"ignore\" count." },
1226
1227   { "set-breakpoint-ignore-count!", 2, 0, 0,
1228     as_a_scm_t_subr (gdbscm_set_breakpoint_ignore_count_x),
1229     "\
1230 Set the breakpoint's \"ignore\" count.\n\
1231 \n\
1232   Arguments: <gdb:breakpoint> count" },
1233
1234   { "breakpoint-hit-count", 1, 0, 0,
1235     as_a_scm_t_subr (gdbscm_breakpoint_hit_count),
1236     "\
1237 Return the breakpoint's \"hit\" count." },
1238
1239   { "set-breakpoint-hit-count!", 2, 0, 0,
1240     as_a_scm_t_subr (gdbscm_set_breakpoint_hit_count_x),
1241     "\
1242 Set the breakpoint's \"hit\" count.  The value must be zero.\n\
1243 \n\
1244   Arguments: <gdb:breakpoint> 0" },
1245
1246   { "breakpoint-thread", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_thread),
1247     "\
1248 Return the breakpoint's global thread id or #f if there isn't one." },
1249
1250   { "set-breakpoint-thread!", 2, 0, 0,
1251     as_a_scm_t_subr (gdbscm_set_breakpoint_thread_x),
1252     "\
1253 Set the global thread id for this breakpoint.\n\
1254 \n\
1255   Arguments: <gdb:breakpoint> global-thread-id" },
1256
1257   { "breakpoint-task", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_task),
1258     "\
1259 Return the breakpoint's Ada task-id or #f if there isn't one." },
1260
1261   { "set-breakpoint-task!", 2, 0, 0,
1262     as_a_scm_t_subr (gdbscm_set_breakpoint_task_x),
1263     "\
1264 Set the breakpoint's Ada task-id.\n\
1265 \n\
1266   Arguments: <gdb:breakpoint> task-id" },
1267
1268   { "breakpoint-condition", 1, 0, 0,
1269     as_a_scm_t_subr (gdbscm_breakpoint_condition),
1270     "\
1271 Return the breakpoint's condition as specified by the user.\n\
1272 Return #f if there isn't one." },
1273
1274   { "set-breakpoint-condition!", 2, 0, 0,
1275     as_a_scm_t_subr (gdbscm_set_breakpoint_condition_x),
1276     "\
1277 Set the breakpoint's condition.\n\
1278 \n\
1279   Arguments: <gdb:breakpoint> condition\n\
1280     condition: a string" },
1281
1282   { "breakpoint-stop", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_stop),
1283     "\
1284 Return the breakpoint's stop predicate.\n\
1285 Return #f if there isn't one." },
1286
1287   { "set-breakpoint-stop!", 2, 0, 0,
1288     as_a_scm_t_subr (gdbscm_set_breakpoint_stop_x),
1289     "\
1290 Set the breakpoint's stop predicate.\n\
1291 \n\
1292   Arguments: <gdb:breakpoint> procedure\n\
1293     procedure: A procedure of one argument, the breakpoint.\n\
1294       Its result is true if program execution should stop." },
1295
1296   { "breakpoint-commands", 1, 0, 0,
1297     as_a_scm_t_subr (gdbscm_breakpoint_commands),
1298     "\
1299 Return the breakpoint's commands." },
1300
1301   END_FUNCTIONS
1302 };
1303
1304 void
1305 gdbscm_initialize_breakpoints (void)
1306 {
1307   breakpoint_smob_tag
1308     = gdbscm_make_smob_type (breakpoint_smob_name, sizeof (breakpoint_smob));
1309   scm_set_smob_free (breakpoint_smob_tag, bpscm_free_breakpoint_smob);
1310   scm_set_smob_print (breakpoint_smob_tag, bpscm_print_breakpoint_smob);
1311
1312   gdb::observers::breakpoint_created.attach (bpscm_breakpoint_created);
1313   gdb::observers::breakpoint_deleted.attach (bpscm_breakpoint_deleted);
1314
1315   gdbscm_define_integer_constants (breakpoint_integer_constants, 1);
1316   gdbscm_define_functions (breakpoint_functions, 1);
1317
1318   type_keyword = scm_from_latin1_keyword ("type");
1319   wp_class_keyword = scm_from_latin1_keyword ("wp-class");
1320   internal_keyword = scm_from_latin1_keyword ("internal");
1321 }