gdb/python/py-breakpoint.c

   1 /* Python interface to breakpoints
   2
   3    Copyright (C) 2008-2017 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 #include "defs.h"
  21 #include "value.h"
  22 #include "python-internal.h"
  23 #include "python.h"
  24 #include "charset.h"
  25 #include "breakpoint.h"
  26 #include "gdbcmd.h"
  27 #include "gdbthread.h"
  28 #include "observer.h"
  29 #include "cli/cli-script.h"
  30 #include "ada-lang.h"
  31 #include "arch-utils.h"
  32 #include "language.h"
  33 #include "location.h"
  34 #include "py-event.h"
  35
  36 /* Number of live breakpoints.  */
  37 static int bppy_live;
  38
  39 /* Variables used to pass information between the Breakpoint
  40    constructor and the breakpoint-created hook function.  */
  41 gdbpy_breakpoint_object *bppy_pending_object;
  42
  43 /* Function that is called when a Python condition is evaluated.  */
  44 static char * const stop_func = "stop";
  45
  46 /* This is used to initialize various gdb.bp_* constants.  */
  47 struct pybp_code
  48 {
  49   /* The name.  */
  50   const char *name;
  51   /* The code.  */
  52   int code;
  53 };
  54
  55 /* Entries related to the type of user set breakpoints.  */
  56 static struct pybp_code pybp_codes[] =
  57 {
  58   { "BP_NONE", bp_none},
  59   { "BP_BREAKPOINT", bp_breakpoint},
  60   { "BP_WATCHPOINT", bp_watchpoint},
  61   { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint},
  62   { "BP_READ_WATCHPOINT", bp_read_watchpoint},
  63   { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint},
  64   {NULL} /* Sentinel.  */
  65 };
  66
  67 /* Entries related to the type of watchpoint.  */
  68 static struct pybp_code pybp_watch_types[] =
  69 {
  70   { "WP_READ", hw_read},
  71   { "WP_WRITE", hw_write},
  72   { "WP_ACCESS", hw_access},
  73   {NULL} /* Sentinel.  */
  74 };
  75
  76 /* Python function which checks the validity of a breakpoint object.  */
  77 static PyObject *
  78 bppy_is_valid (PyObject *self, PyObject *args)
  79 {
  80   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
  81
  82   if (self_bp->bp)
  83     Py_RETURN_TRUE;
  84   Py_RETURN_FALSE;
  85 }
  86
  87 /* Python function to test whether or not the breakpoint is enabled.  */
  88 static PyObject *
  89 bppy_get_enabled (PyObject *self, void *closure)
  90 {
  91   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
  92
  93   BPPY_REQUIRE_VALID (self_bp);
  94   if (! self_bp->bp)
  95     Py_RETURN_FALSE;
  96   if (self_bp->bp->enable_state == bp_enabled)
  97     Py_RETURN_TRUE;
  98   Py_RETURN_FALSE;
  99 }
 100
 101 /* Python function to test whether or not the breakpoint is silent.  */
 102 static PyObject *
 103 bppy_get_silent (PyObject *self, void *closure)
 104 {
 105   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 106
 107   BPPY_REQUIRE_VALID (self_bp);
 108   if (self_bp->bp->silent)
 109     Py_RETURN_TRUE;
 110   Py_RETURN_FALSE;
 111 }
 112
 113 /* Python function to set the enabled state of a breakpoint.  */
 114 static int
 115 bppy_set_enabled (PyObject *self, PyObject *newvalue, void *closure)
 116 {
 117   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 118   int cmp;
 119
 120   BPPY_SET_REQUIRE_VALID (self_bp);
 121
 122   if (newvalue == NULL)
 123     {
 124       PyErr_SetString (PyExc_TypeError,
 125                        _("Cannot delete `enabled' attribute."));
 126
 127       return -1;
 128     }
 129   else if (! PyBool_Check (newvalue))
 130     {
 131       PyErr_SetString (PyExc_TypeError,
 132                        _("The value of `enabled' must be a boolean."));
 133       return -1;
 134     }
 135
 136   cmp = PyObject_IsTrue (newvalue);
 137   if (cmp < 0)
 138     return -1;
 139
 140   TRY
 141     {
 142       if (cmp == 1)
 143         enable_breakpoint (self_bp->bp);
 144       else
 145         disable_breakpoint (self_bp->bp);
 146     }
 147   CATCH (except, RETURN_MASK_ALL)
 148     {
 149       GDB_PY_SET_HANDLE_EXCEPTION (except);
 150     }
 151   END_CATCH
 152
 153   return 0;
 154 }
 155
 156 /* Python function to set the 'silent' state of a breakpoint.  */
 157 static int
 158 bppy_set_silent (PyObject *self, PyObject *newvalue, void *closure)
 159 {
 160   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 161   int cmp;
 162
 163   BPPY_SET_REQUIRE_VALID (self_bp);
 164
 165   if (newvalue == NULL)
 166     {
 167       PyErr_SetString (PyExc_TypeError,
 168                        _("Cannot delete `silent' attribute."));
 169       return -1;
 170     }
 171   else if (! PyBool_Check (newvalue))
 172     {
 173       PyErr_SetString (PyExc_TypeError,
 174                        _("The value of `silent' must be a boolean."));
 175       return -1;
 176     }
 177
 178   cmp = PyObject_IsTrue (newvalue);
 179   if (cmp < 0)
 180     return -1;
 181   else
 182     breakpoint_set_silent (self_bp->bp, cmp);
 183
 184   return 0;
 185 }
 186
 187 /* Python function to set the thread of a breakpoint.  */
 188 static int
 189 bppy_set_thread (PyObject *self, PyObject *newvalue, void *closure)
 190 {
 191   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 192   long id;
 193
 194   BPPY_SET_REQUIRE_VALID (self_bp);
 195
 196   if (newvalue == NULL)
 197     {
 198       PyErr_SetString (PyExc_TypeError,
 199                        _("Cannot delete `thread' attribute."));
 200       return -1;
 201     }
 202   else if (PyInt_Check (newvalue))
 203     {
 204       if (! gdb_py_int_as_long (newvalue, &id))
 205         return -1;
 206
 207       if (!valid_global_thread_id (id))
 208         {
 209           PyErr_SetString (PyExc_RuntimeError,
 210                            _("Invalid thread ID."));
 211           return -1;
 212         }
 213     }
 214   else if (newvalue == Py_None)
 215     id = -1;
 216   else
 217     {
 218       PyErr_SetString (PyExc_TypeError,
 219                        _("The value of `thread' must be an integer or None."));
 220       return -1;
 221     }
 222
 223   breakpoint_set_thread (self_bp->bp, id);
 224
 225   return 0;
 226 }
 227
 228 /* Python function to set the (Ada) task of a breakpoint.  */
 229 static int
 230 bppy_set_task (PyObject *self, PyObject *newvalue, void *closure)
 231 {
 232   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 233   long id;
 234   int valid_id = 0;
 235
 236   BPPY_SET_REQUIRE_VALID (self_bp);
 237
 238   if (newvalue == NULL)
 239     {
 240       PyErr_SetString (PyExc_TypeError,
 241                        _("Cannot delete `task' attribute."));
 242       return -1;
 243     }
 244   else if (PyInt_Check (newvalue))
 245     {
 246       if (! gdb_py_int_as_long (newvalue, &id))
 247         return -1;
 248
 249       TRY
 250         {
 251           valid_id = valid_task_id (id);
 252         }
 253       CATCH (except, RETURN_MASK_ALL)
 254         {
 255           GDB_PY_SET_HANDLE_EXCEPTION (except);
 256         }
 257       END_CATCH
 258
 259       if (! valid_id)
 260         {
 261           PyErr_SetString (PyExc_RuntimeError,
 262                            _("Invalid task ID."));
 263           return -1;
 264         }
 265     }
 266   else if (newvalue == Py_None)
 267     id = 0;
 268   else
 269     {
 270       PyErr_SetString (PyExc_TypeError,
 271                        _("The value of `task' must be an integer or None."));
 272       return -1;
 273     }
 274
 275   breakpoint_set_task (self_bp->bp, id);
 276
 277   return 0;
 278 }
 279
 280 /* Python function which deletes the underlying GDB breakpoint.  This
 281    triggers the breakpoint_deleted observer which will call
 282    gdbpy_breakpoint_deleted; that function cleans up the Python
 283    sections.  */
 284
 285 static PyObject *
 286 bppy_delete_breakpoint (PyObject *self, PyObject *args)
 287 {
 288   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 289
 290   BPPY_REQUIRE_VALID (self_bp);
 291
 292   TRY
 293     {
 294       delete_breakpoint (self_bp->bp);
 295     }
 296   CATCH (except, RETURN_MASK_ALL)
 297     {
 298       GDB_PY_HANDLE_EXCEPTION (except);
 299     }
 300   END_CATCH
 301
 302   Py_RETURN_NONE;
 303 }
 304
 305
 306 /* Python function to set the ignore count of a breakpoint.  */
 307 static int
 308 bppy_set_ignore_count (PyObject *self, PyObject *newvalue, void *closure)
 309 {
 310   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 311   long value;
 312
 313   BPPY_SET_REQUIRE_VALID (self_bp);
 314
 315   if (newvalue == NULL)
 316     {
 317       PyErr_SetString (PyExc_TypeError,
 318                        _("Cannot delete `ignore_count' attribute."));
 319       return -1;
 320     }
 321   else if (! PyInt_Check (newvalue))
 322     {
 323       PyErr_SetString (PyExc_TypeError,
 324                        _("The value of `ignore_count' must be an integer."));
 325       return -1;
 326     }
 327
 328   if (! gdb_py_int_as_long (newvalue, &value))
 329     return -1;
 330
 331   if (value < 0)
 332     value = 0;
 333
 334   TRY
 335     {
 336       set_ignore_count (self_bp->number, (int) value, 0);
 337     }
 338   CATCH (except, RETURN_MASK_ALL)
 339     {
 340       GDB_PY_SET_HANDLE_EXCEPTION (except);
 341     }
 342   END_CATCH
 343
 344   return 0;
 345 }
 346
 347 /* Python function to set the hit count of a breakpoint.  */
 348 static int
 349 bppy_set_hit_count (PyObject *self, PyObject *newvalue, void *closure)
 350 {
 351   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 352
 353   BPPY_SET_REQUIRE_VALID (self_bp);
 354
 355   if (newvalue == NULL)
 356     {
 357       PyErr_SetString (PyExc_TypeError,
 358                        _("Cannot delete `hit_count' attribute."));
 359       return -1;
 360     }
 361   else
 362     {
 363       long value;
 364
 365       if (! gdb_py_int_as_long (newvalue, &value))
 366         return -1;
 367
 368       if (value != 0)
 369         {
 370           PyErr_SetString (PyExc_AttributeError,
 371                            _("The value of `hit_count' must be zero."));
 372           return -1;
 373         }
 374     }
 375
 376   self_bp->bp->hit_count = 0;
 377
 378   return 0;
 379 }
 380
 381 /* Python function to get the location of a breakpoint.  */
 382 static PyObject *
 383 bppy_get_location (PyObject *self, void *closure)
 384 {
 385   const char *str;
 386   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
 387
 388   BPPY_REQUIRE_VALID (obj);
 389
 390   if (obj->bp->type != bp_breakpoint)
 391     Py_RETURN_NONE;
 392
 393   str = event_location_to_string (obj->bp->location);
 394   if (! str)
 395     str = "";
 396   return host_string_to_python_string (str);
 397 }
 398
 399 /* Python function to get the breakpoint expression.  */
 400 static PyObject *
 401 bppy_get_expression (PyObject *self, void *closure)
 402 {
 403   char *str;
 404   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
 405   struct watchpoint *wp;
 406
 407   BPPY_REQUIRE_VALID (obj);
 408
 409   if (!is_watchpoint (obj->bp))
 410     Py_RETURN_NONE;
 411
 412   wp = (struct watchpoint *) obj->bp;
 413
 414   str = wp->exp_string;
 415   if (! str)
 416     str = "";
 417
 418   return host_string_to_python_string (str);
 419 }
 420
 421 /* Python function to get the condition expression of a breakpoint.  */
 422 static PyObject *
 423 bppy_get_condition (PyObject *self, void *closure)
 424 {
 425   char *str;
 426   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
 427
 428   BPPY_REQUIRE_VALID (obj);
 429
 430   str = obj->bp->cond_string;
 431   if (! str)
 432     Py_RETURN_NONE;
 433
 434   return host_string_to_python_string (str);
 435 }
 436
 437 /* Returns 0 on success.  Returns -1 on error, with a python exception set.
 438    */
 439
 440 static int
 441 bppy_set_condition (PyObject *self, PyObject *newvalue, void *closure)
 442 {
 443   gdb::unique_xmalloc_ptr<char> exp_holder;
 444   const char *exp = NULL;
 445   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 446   struct gdb_exception except = exception_none;
 447
 448   BPPY_SET_REQUIRE_VALID (self_bp);
 449
 450   if (newvalue == NULL)
 451     {
 452       PyErr_SetString (PyExc_TypeError,
 453                        _("Cannot delete `condition' attribute."));
 454       return -1;
 455     }
 456   else if (newvalue == Py_None)
 457     exp = "";
 458   else
 459     {
 460       exp_holder = python_string_to_host_string (newvalue);
 461       if (exp_holder == NULL)
 462         return -1;
 463       exp = exp_holder.get ();
 464     }
 465
 466   TRY
 467     {
 468       set_breakpoint_condition (self_bp->bp, exp, 0);
 469     }
 470   CATCH (ex, RETURN_MASK_ALL)
 471     {
 472       except = ex;
 473     }
 474   END_CATCH
 475
 476   GDB_PY_SET_HANDLE_EXCEPTION (except);
 477
 478   return 0;
 479 }
 480
 481 /* Python function to get the commands attached to a breakpoint.  */
 482 static PyObject *
 483 bppy_get_commands (PyObject *self, void *closure)
 484 {
 485   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 486   struct breakpoint *bp = self_bp->bp;
 487   long length;
 488   struct ui_file *string_file;
 489   PyObject *result;
 490   struct cleanup *chain;
 491
 492   BPPY_REQUIRE_VALID (self_bp);
 493
 494   if (! self_bp->bp->commands)
 495     Py_RETURN_NONE;
 496
 497   string_file = mem_fileopen ();
 498   chain = make_cleanup_ui_file_delete (string_file);
 499
 500   current_uiout->redirect (string_file);
 501   TRY
 502     {
 503       print_command_lines (current_uiout, breakpoint_commands (bp), 0);
 504     }
 505   CATCH (except, RETURN_MASK_ALL)
 506     {
 507       current_uiout->redirect (NULL);
 508       do_cleanups (chain);
 509       gdbpy_convert_exception (except);
 510       return NULL;
 511     }
 512   END_CATCH
 513
 514   current_uiout->redirect (NULL);
 515   std::string cmdstr = ui_file_as_string (string_file);
 516   result = host_string_to_python_string (cmdstr.c_str ());
 517   do_cleanups (chain);
 518   return result;
 519 }
 520
 521 /* Python function to get the breakpoint type.  */
 522 static PyObject *
 523 bppy_get_type (PyObject *self, void *closure)
 524 {
 525   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 526
 527   BPPY_REQUIRE_VALID (self_bp);
 528
 529   return PyInt_FromLong (self_bp->bp->type);
 530 }
 531
 532 /* Python function to get the visibility of the breakpoint.  */
 533
 534 static PyObject *
 535 bppy_get_visibility (PyObject *self, void *closure)
 536 {
 537   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 538
 539   BPPY_REQUIRE_VALID (self_bp);
 540
 541   if (user_breakpoint_p (self_bp->bp))
 542     Py_RETURN_TRUE;
 543
 544   Py_RETURN_FALSE;
 545 }
 546
 547 /* Python function to determine if the breakpoint is a temporary
 548    breakpoint.  */
 549
 550 static PyObject *
 551 bppy_get_temporary (PyObject *self, void *closure)
 552 {
 553   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 554
 555   BPPY_REQUIRE_VALID (self_bp);
 556
 557   if (self_bp->bp->disposition == disp_del
 558       || self_bp->bp->disposition == disp_del_at_next_stop)
 559     Py_RETURN_TRUE;
 560
 561   Py_RETURN_FALSE;
 562 }
 563
 564 /* Python function to determine if the breakpoint is a pending
 565    breakpoint.  */
 566
 567 static PyObject *
 568 bppy_get_pending (PyObject *self, void *closure)
 569 {
 570   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 571
 572   BPPY_REQUIRE_VALID (self_bp);
 573
 574   if (is_watchpoint (self_bp->bp))
 575     Py_RETURN_FALSE;
 576   if (pending_breakpoint_p (self_bp->bp))
 577     Py_RETURN_TRUE;
 578
 579   Py_RETURN_FALSE;
 580 }
 581
 582 /* Python function to get the breakpoint's number.  */
 583 static PyObject *
 584 bppy_get_number (PyObject *self, void *closure)
 585 {
 586   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 587
 588   BPPY_REQUIRE_VALID (self_bp);
 589
 590   return PyInt_FromLong (self_bp->number);
 591 }
 592
 593 /* Python function to get the breakpoint's thread ID.  */
 594 static PyObject *
 595 bppy_get_thread (PyObject *self, void *closure)
 596 {
 597   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 598
 599   BPPY_REQUIRE_VALID (self_bp);
 600
 601   if (self_bp->bp->thread == -1)
 602     Py_RETURN_NONE;
 603
 604   return PyInt_FromLong (self_bp->bp->thread);
 605 }
 606
 607 /* Python function to get the breakpoint's task ID (in Ada).  */
 608 static PyObject *
 609 bppy_get_task (PyObject *self, void *closure)
 610 {
 611   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 612
 613   BPPY_REQUIRE_VALID (self_bp);
 614
 615   if (self_bp->bp->task == 0)
 616     Py_RETURN_NONE;
 617
 618   return PyInt_FromLong (self_bp->bp->task);
 619 }
 620
 621 /* Python function to get the breakpoint's hit count.  */
 622 static PyObject *
 623 bppy_get_hit_count (PyObject *self, void *closure)
 624 {
 625   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 626
 627   BPPY_REQUIRE_VALID (self_bp);
 628
 629   return PyInt_FromLong (self_bp->bp->hit_count);
 630 }
 631
 632 /* Python function to get the breakpoint's ignore count.  */
 633 static PyObject *
 634 bppy_get_ignore_count (PyObject *self, void *closure)
 635 {
 636   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 637
 638   BPPY_REQUIRE_VALID (self_bp);
 639
 640   return PyInt_FromLong (self_bp->bp->ignore_count);
 641 }
 642
 643 /* Python function to create a new breakpoint.  */
 644 static int
 645 bppy_init (PyObject *self, PyObject *args, PyObject *kwargs)
 646 {
 647   static char *keywords[] = { "spec", "type", "wp_class", "internal",
 648                               "temporary", NULL };
 649   const char *spec;
 650   int type = bp_breakpoint;
 651   int access_type = hw_write;
 652   PyObject *internal = NULL;
 653   PyObject *temporary = NULL;
 654   int internal_bp = 0;
 655   int temporary_bp = 0;
 656
 657   if (! PyArg_ParseTupleAndKeywords (args, kwargs, "s|iiOO", keywords,
 658                                      &spec, &type, &access_type,
 659                                      &internal, &temporary))
 660     return -1;
 661
 662   if (internal)
 663     {
 664       internal_bp = PyObject_IsTrue (internal);
 665       if (internal_bp == -1)
 666         return -1;
 667     }
 668
 669   if (temporary != NULL)
 670     {
 671       temporary_bp = PyObject_IsTrue (temporary);
 672       if (temporary_bp == -1)
 673         return -1;
 674     }
 675
 676   bppy_pending_object = (gdbpy_breakpoint_object *) self;
 677   bppy_pending_object->number = -1;
 678   bppy_pending_object->bp = NULL;
 679
 680   TRY
 681     {
 682       gdb::unique_xmalloc_ptr<char>
 683         copy_holder (xstrdup (skip_spaces_const (spec)));
 684       char *copy = copy_holder.get ();
 685
 686       switch (type)
 687         {
 688         case bp_breakpoint:
 689           {
 690             struct event_location *location;
 691             struct cleanup *cleanup;
 692
 693             location
 694               = string_to_event_location_basic (&copy, current_language);
 695             cleanup = make_cleanup_delete_event_location (location);
 696             create_breakpoint (python_gdbarch,
 697                                location, NULL, -1, NULL,
 698                                0,
 699                                temporary_bp, bp_breakpoint,
 700                                0,
 701                                AUTO_BOOLEAN_TRUE,
 702                                &bkpt_breakpoint_ops,
 703                                0, 1, internal_bp, 0);
 704
 705             do_cleanups (cleanup);
 706             break;
 707           }
 708         case bp_watchpoint:
 709           {
 710             if (access_type == hw_write)
 711               watch_command_wrapper (copy, 0, internal_bp);
 712             else if (access_type == hw_access)
 713               awatch_command_wrapper (copy, 0, internal_bp);
 714             else if (access_type == hw_read)
 715               rwatch_command_wrapper (copy, 0, internal_bp);
 716             else
 717               error(_("Cannot understand watchpoint access type."));
 718             break;
 719           }
 720         default:
 721           error(_("Do not understand breakpoint type to set."));
 722         }
 723     }
 724   CATCH (except, RETURN_MASK_ALL)
 725     {
 726       bppy_pending_object = NULL;
 727       PyErr_Format (except.reason == RETURN_QUIT
 728                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 729                     "%s", except.message);
 730       return -1;
 731     }
 732   END_CATCH
 733
 734   BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object *) self);
 735   return 0;
 736 }
 737
 738 \f
 739
 740 static int
 741 build_bp_list (struct breakpoint *b, void *arg)
 742 {
 743   PyObject *list = (PyObject *) arg;
 744   PyObject *bp = (PyObject *) b->py_bp_object;
 745   int iserr = 0;
 746
 747   /* Not all breakpoints will have a companion Python object.
 748      Only breakpoints that were created via bppy_new, or
 749      breakpoints that were created externally and are tracked by
 750      the Python Scripting API.  */
 751   if (bp)
 752     iserr = PyList_Append (list, bp);
 753
 754   if (iserr == -1)
 755     return 1;
 756
 757   return 0;
 758 }
 759
 760 /* Static function to return a tuple holding all breakpoints.  */
 761
 762 PyObject *
 763 gdbpy_breakpoints (PyObject *self, PyObject *args)
 764 {
 765   if (bppy_live == 0)
 766     return PyTuple_New (0);
 767
 768   gdbpy_ref list (PyList_New (0));
 769   if (list == NULL)
 770     return NULL;
 771
 772   /* If iterate_over_breakpoints returns non NULL it signals an error
 773      condition.  In that case abandon building the list and return
 774      NULL.  */
 775   if (iterate_over_breakpoints (build_bp_list, list.get ()) != NULL)
 776     return NULL;
 777
 778   return PyList_AsTuple (list.get ());
 779 }
 780
 781 /* Call the "stop" method (if implemented) in the breakpoint
 782    class.  If the method returns True, the inferior  will be
 783    stopped at the breakpoint.  Otherwise the inferior will be
 784    allowed to continue.  */
 785
 786 enum ext_lang_bp_stop
 787 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn *extlang,
 788                                  struct breakpoint *b)
 789 {
 790   int stop;
 791   struct gdbpy_breakpoint_object *bp_obj = b->py_bp_object;
 792   PyObject *py_bp = (PyObject *) bp_obj;
 793   struct gdbarch *garch;
 794
 795   if (bp_obj == NULL)
 796     return EXT_LANG_BP_STOP_UNSET;
 797
 798   stop = -1;
 799   garch = b->gdbarch ? b->gdbarch : get_current_arch ();
 800
 801   gdbpy_enter enter_py (garch, current_language);
 802
 803   if (bp_obj->is_finish_bp)
 804     bpfinishpy_pre_stop_hook (bp_obj);
 805
 806   if (PyObject_HasAttrString (py_bp, stop_func))
 807     {
 808       PyObject *result = PyObject_CallMethod (py_bp, stop_func, NULL);
 809
 810       stop = 1;
 811       if (result)
 812         {
 813           int evaluate = PyObject_IsTrue (result);
 814
 815           if (evaluate == -1)
 816             gdbpy_print_stack ();
 817
 818           /* If the "stop" function returns False that means
 819              the Python breakpoint wants GDB to continue.  */
 820           if (! evaluate)
 821             stop = 0;
 822
 823           Py_DECREF (result);
 824         }
 825       else
 826         gdbpy_print_stack ();
 827     }
 828
 829   if (bp_obj->is_finish_bp)
 830     bpfinishpy_post_stop_hook (bp_obj);
 831
 832   if (stop < 0)
 833     return EXT_LANG_BP_STOP_UNSET;
 834   return stop ? EXT_LANG_BP_STOP_YES : EXT_LANG_BP_STOP_NO;
 835 }
 836
 837 /* Checks if the  "stop" method exists in this breakpoint.
 838    Used by condition_command to ensure mutual exclusion of breakpoint
 839    conditions.  */
 840
 841 int
 842 gdbpy_breakpoint_has_cond (const struct extension_language_defn *extlang,
 843                            struct breakpoint *b)
 844 {
 845   PyObject *py_bp;
 846   struct gdbarch *garch;
 847
 848   if (b->py_bp_object == NULL)
 849     return 0;
 850
 851   py_bp = (PyObject *) b->py_bp_object;
 852   garch = b->gdbarch ? b->gdbarch : get_current_arch ();
 853
 854   gdbpy_enter enter_py (garch, current_language);
 855   return PyObject_HasAttrString (py_bp, stop_func);
 856 }
 857
 858 \f
 859
 860 /* Event callback functions.  */
 861
 862 /* Callback that is used when a breakpoint is created.  This function
 863    will create a new Python breakpoint object.  */
 864 static void
 865 gdbpy_breakpoint_created (struct breakpoint *bp)
 866 {
 867   gdbpy_breakpoint_object *newbp;
 868   PyGILState_STATE state;
 869
 870   if (!user_breakpoint_p (bp) && bppy_pending_object == NULL)
 871     return;
 872
 873   if (bp->type != bp_breakpoint
 874       && bp->type != bp_watchpoint
 875       && bp->type != bp_hardware_watchpoint
 876       && bp->type != bp_read_watchpoint
 877       && bp->type != bp_access_watchpoint)
 878     return;
 879
 880   state = PyGILState_Ensure ();
 881
 882   if (bppy_pending_object)
 883     {
 884       newbp = bppy_pending_object;
 885       bppy_pending_object = NULL;
 886     }
 887   else
 888     newbp = PyObject_New (gdbpy_breakpoint_object, &breakpoint_object_type);
 889   if (newbp)
 890     {
 891       newbp->number = bp->number;
 892       newbp->bp = bp;
 893       newbp->bp->py_bp_object = newbp;
 894       newbp->is_finish_bp = 0;
 895       Py_INCREF (newbp);
 896       ++bppy_live;
 897     }
 898   else
 899     {
 900       PyErr_SetString (PyExc_RuntimeError,
 901                        _("Error while creating breakpoint from GDB."));
 902       gdbpy_print_stack ();
 903     }
 904
 905   if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_created))
 906     {
 907       if (evpy_emit_event ((PyObject *) newbp,
 908                            gdb_py_events.breakpoint_created) < 0)
 909         gdbpy_print_stack ();
 910     }
 911
 912   PyGILState_Release (state);
 913 }
 914
 915 /* Callback that is used when a breakpoint is deleted.  This will
 916    invalidate the corresponding Python object.  */
 917 static void
 918 gdbpy_breakpoint_deleted (struct breakpoint *b)
 919 {
 920   int num = b->number;
 921   PyGILState_STATE state;
 922   struct breakpoint *bp = NULL;
 923   gdbpy_breakpoint_object *bp_obj;
 924
 925   state = PyGILState_Ensure ();
 926   bp = get_breakpoint (num);
 927   if (bp)
 928     {
 929       bp_obj = bp->py_bp_object;
 930       if (bp_obj)
 931         {
 932           if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_deleted))
 933             {
 934               if (evpy_emit_event ((PyObject *) bp_obj,
 935                                    gdb_py_events.breakpoint_deleted) < 0)
 936                 gdbpy_print_stack ();
 937             }
 938
 939           bp_obj->bp = NULL;
 940           --bppy_live;
 941           Py_DECREF (bp_obj);
 942         }
 943     }
 944   PyGILState_Release (state);
 945 }
 946
 947 /* Callback that is used when a breakpoint is modified.  */
 948
 949 static void
 950 gdbpy_breakpoint_modified (struct breakpoint *b)
 951 {
 952   int num = b->number;
 953   PyGILState_STATE state;
 954   struct breakpoint *bp = NULL;
 955   gdbpy_breakpoint_object *bp_obj;
 956
 957   state = PyGILState_Ensure ();
 958   bp = get_breakpoint (num);
 959   if (bp)
 960     {
 961       PyObject *bp_obj = (PyObject *) bp->py_bp_object;
 962       if (bp_obj)
 963         {
 964           if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_modified))
 965             {
 966               if (evpy_emit_event (bp_obj,
 967                                    gdb_py_events.breakpoint_modified) < 0)
 968                 gdbpy_print_stack ();
 969             }
 970         }
 971     }
 972   PyGILState_Release (state);
 973 }
 974
 975 \f
 976
 977 /* Initialize the Python breakpoint code.  */
 978 int
 979 gdbpy_initialize_breakpoints (void)
 980 {
 981   int i;
 982
 983   breakpoint_object_type.tp_new = PyType_GenericNew;
 984   if (PyType_Ready (&breakpoint_object_type) < 0)
 985     return -1;
 986
 987   if (gdb_pymodule_addobject (gdb_module, "Breakpoint",
 988                               (PyObject *) &breakpoint_object_type) < 0)
 989     return -1;
 990
 991   observer_attach_breakpoint_created (gdbpy_breakpoint_created);
 992   observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted);
 993   observer_attach_breakpoint_modified (gdbpy_breakpoint_modified);
 994
 995   /* Add breakpoint types constants.  */
 996   for (i = 0; pybp_codes[i].name; ++i)
 997     {
 998       if (PyModule_AddIntConstant (gdb_module,
 999                                    /* Cast needed for Python 2.4.  */
1000                                    (char *) pybp_codes[i].name,
1001                                    pybp_codes[i].code) < 0)
1002         return -1;
1003     }
1004
1005   /* Add watchpoint types constants.  */
1006   for (i = 0; pybp_watch_types[i].name; ++i)
1007     {
1008       if (PyModule_AddIntConstant (gdb_module,
1009                                    /* Cast needed for Python 2.4.  */
1010                                    (char *) pybp_watch_types[i].name,
1011                                    pybp_watch_types[i].code) < 0)
1012         return -1;
1013     }
1014
1015   return 0;
1016 }
1017
1018 \f
1019
1020 /* Helper function that overrides this Python object's
1021    PyObject_GenericSetAttr to allow extra validation of the attribute
1022    being set.  */
1023
1024 static int
1025 local_setattro (PyObject *self, PyObject *name, PyObject *v)
1026 {
1027   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
1028   gdb::unique_xmalloc_ptr<char> attr (python_string_to_host_string (name));
1029
1030   if (attr == NULL)
1031     return -1;
1032
1033   /* If the attribute trying to be set is the "stop" method,
1034      but we already have a condition set in the CLI or other extension
1035      language, disallow this operation.  */
1036   if (strcmp (attr.get (), stop_func) == 0)
1037     {
1038       const struct extension_language_defn *extlang = NULL;
1039
1040       if (obj->bp->cond_string != NULL)
1041         extlang = get_ext_lang_defn (EXT_LANG_GDB);
1042       if (extlang == NULL)
1043         extlang = get_breakpoint_cond_ext_lang (obj->bp, EXT_LANG_PYTHON);
1044       if (extlang != NULL)
1045         {
1046           char *error_text;
1047
1048           error_text
1049             = xstrprintf (_("Only one stop condition allowed.  There is"
1050                             " currently a %s stop condition defined for"
1051                             " this breakpoint."),
1052                           ext_lang_capitalized_name (extlang));
1053           PyErr_SetString (PyExc_RuntimeError, error_text);
1054           xfree (error_text);
1055           return -1;
1056         }
1057     }
1058
1059   return PyObject_GenericSetAttr ((PyObject *)self, name, v);
1060 }
1061
1062 static PyGetSetDef breakpoint_object_getset[] = {
1063   { "enabled", bppy_get_enabled, bppy_set_enabled,
1064     "Boolean telling whether the breakpoint is enabled.", NULL },
1065   { "silent", bppy_get_silent, bppy_set_silent,
1066     "Boolean telling whether the breakpoint is silent.", NULL },
1067   { "thread", bppy_get_thread, bppy_set_thread,
1068     "Thread ID for the breakpoint.\n\
1069 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1070 If the value is None, then this breakpoint is not thread-specific.\n\
1071 No other type of value can be used.", NULL },
1072   { "task", bppy_get_task, bppy_set_task,
1073     "Thread ID for the breakpoint.\n\
1074 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1075 If the value is None, then this breakpoint is not task-specific.\n\
1076 No other type of value can be used.", NULL },
1077   { "ignore_count", bppy_get_ignore_count, bppy_set_ignore_count,
1078     "Number of times this breakpoint should be automatically continued.",
1079     NULL },
1080   { "number", bppy_get_number, NULL,
1081     "Breakpoint's number assigned by GDB.", NULL },
1082   { "hit_count", bppy_get_hit_count, bppy_set_hit_count,
1083     "Number of times the breakpoint has been hit.\n\
1084 Can be set to zero to clear the count. No other value is valid\n\
1085 when setting this property.", NULL },
1086   { "location", bppy_get_location, NULL,
1087     "Location of the breakpoint, as specified by the user.", NULL},
1088   { "expression", bppy_get_expression, NULL,
1089     "Expression of the breakpoint, as specified by the user.", NULL},
1090   { "condition", bppy_get_condition, bppy_set_condition,
1091     "Condition of the breakpoint, as specified by the user,\
1092 or None if no condition set."},
1093   { "commands", bppy_get_commands, NULL,
1094     "Commands of the breakpoint, as specified by the user."},
1095   { "type", bppy_get_type, NULL,
1096     "Type of breakpoint."},
1097   { "visible", bppy_get_visibility, NULL,
1098     "Whether the breakpoint is visible to the user."},
1099   { "temporary", bppy_get_temporary, NULL,
1100     "Whether this breakpoint is a temporary breakpoint."},
1101   { "pending", bppy_get_pending, NULL,
1102     "Whether this breakpoint is a pending breakpoint."},
1103   { NULL }  /* Sentinel.  */
1104 };
1105
1106 static PyMethodDef breakpoint_object_methods[] =
1107 {
1108   { "is_valid", bppy_is_valid, METH_NOARGS,
1109     "Return true if this breakpoint is valid, false if not." },
1110   { "delete", bppy_delete_breakpoint, METH_NOARGS,
1111     "Delete the underlying GDB breakpoint." },
1112   { NULL } /* Sentinel.  */
1113 };
1114
1115 PyTypeObject breakpoint_object_type =
1116 {
1117   PyVarObject_HEAD_INIT (NULL, 0)
1118   "gdb.Breakpoint",               /*tp_name*/
1119   sizeof (gdbpy_breakpoint_object), /*tp_basicsize*/
1120   0,                              /*tp_itemsize*/
1121   0,                              /*tp_dealloc*/
1122   0,                              /*tp_print*/
1123   0,                              /*tp_getattr*/
1124   0,                              /*tp_setattr*/
1125   0,                              /*tp_compare*/
1126   0,                              /*tp_repr*/
1127   0,                              /*tp_as_number*/
1128   0,                              /*tp_as_sequence*/
1129   0,                              /*tp_as_mapping*/
1130   0,                              /*tp_hash */
1131   0,                              /*tp_call*/
1132   0,                              /*tp_str*/
1133   0,                              /*tp_getattro*/
1134   (setattrofunc)local_setattro,   /*tp_setattro */
1135   0,                              /*tp_as_buffer*/
1136   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
1137   "GDB breakpoint object",        /* tp_doc */
1138   0,                              /* tp_traverse */
1139   0,                              /* tp_clear */
1140   0,                              /* tp_richcompare */
1141   0,                              /* tp_weaklistoffset */
1142   0,                              /* tp_iter */
1143   0,                              /* tp_iternext */
1144   breakpoint_object_methods,      /* tp_methods */
1145   0,                              /* tp_members */
1146   breakpoint_object_getset,       /* tp_getset */
1147   0,                              /* tp_base */
1148   0,                              /* tp_dict */
1149   0,                              /* tp_descr_get */
1150   0,                              /* tp_descr_set */
1151   0,                              /* tp_dictoffset */
1152   bppy_init,                      /* tp_init */
1153   0,                              /* tp_alloc */
1154 };