gdb/python/py-breakpoint.c

   1 /* Python interface to breakpoints
   2
   3    Copyright (C) 2008-2016 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   char *exp;
 444   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 445   struct gdb_exception except = exception_none;
 446
 447   BPPY_SET_REQUIRE_VALID (self_bp);
 448
 449   if (newvalue == NULL)
 450     {
 451       PyErr_SetString (PyExc_TypeError,
 452                        _("Cannot delete `condition' attribute."));
 453       return -1;
 454     }
 455   else if (newvalue == Py_None)
 456     exp = "";
 457   else
 458     {
 459       exp = python_string_to_host_string (newvalue);
 460       if (exp == NULL)
 461         return -1;
 462     }
 463
 464   TRY
 465     {
 466       set_breakpoint_condition (self_bp->bp, exp, 0);
 467     }
 468   CATCH (ex, RETURN_MASK_ALL)
 469     {
 470       except = ex;
 471     }
 472   END_CATCH
 473
 474   if (newvalue != Py_None)
 475     xfree (exp);
 476
 477   GDB_PY_SET_HANDLE_EXCEPTION (except);
 478
 479   return 0;
 480 }
 481
 482 /* Python function to get the commands attached to a breakpoint.  */
 483 static PyObject *
 484 bppy_get_commands (PyObject *self, void *closure)
 485 {
 486   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 487   struct breakpoint *bp = self_bp->bp;
 488   long length;
 489   struct ui_file *string_file;
 490   PyObject *result;
 491   struct cleanup *chain;
 492
 493   BPPY_REQUIRE_VALID (self_bp);
 494
 495   if (! self_bp->bp->commands)
 496     Py_RETURN_NONE;
 497
 498   string_file = mem_fileopen ();
 499   chain = make_cleanup_ui_file_delete (string_file);
 500
 501   ui_out_redirect (current_uiout, string_file);
 502   TRY
 503     {
 504       print_command_lines (current_uiout, breakpoint_commands (bp), 0);
 505     }
 506   CATCH (except, RETURN_MASK_ALL)
 507     {
 508       ui_out_redirect (current_uiout, NULL);
 509       do_cleanups (chain);
 510       gdbpy_convert_exception (except);
 511       return NULL;
 512     }
 513   END_CATCH
 514
 515   ui_out_redirect (current_uiout, NULL);
 516   std::string cmdstr = ui_file_as_string (string_file);
 517   result = host_string_to_python_string (cmdstr.c_str ());
 518   do_cleanups (chain);
 519   return result;
 520 }
 521
 522 /* Python function to get the breakpoint type.  */
 523 static PyObject *
 524 bppy_get_type (PyObject *self, void *closure)
 525 {
 526   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 527
 528   BPPY_REQUIRE_VALID (self_bp);
 529
 530   return PyInt_FromLong (self_bp->bp->type);
 531 }
 532
 533 /* Python function to get the visibility of the breakpoint.  */
 534
 535 static PyObject *
 536 bppy_get_visibility (PyObject *self, void *closure)
 537 {
 538   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 539
 540   BPPY_REQUIRE_VALID (self_bp);
 541
 542   if (user_breakpoint_p (self_bp->bp))
 543     Py_RETURN_TRUE;
 544
 545   Py_RETURN_FALSE;
 546 }
 547
 548 /* Python function to determine if the breakpoint is a temporary
 549    breakpoint.  */
 550
 551 static PyObject *
 552 bppy_get_temporary (PyObject *self, void *closure)
 553 {
 554   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 555
 556   BPPY_REQUIRE_VALID (self_bp);
 557
 558   if (self_bp->bp->disposition == disp_del
 559       || self_bp->bp->disposition == disp_del_at_next_stop)
 560     Py_RETURN_TRUE;
 561
 562   Py_RETURN_FALSE;
 563 }
 564
 565 /* Python function to determine if the breakpoint is a pending
 566    breakpoint.  */
 567
 568 static PyObject *
 569 bppy_get_pending (PyObject *self, void *closure)
 570 {
 571   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 572
 573   BPPY_REQUIRE_VALID (self_bp);
 574
 575   if (is_watchpoint (self_bp->bp))
 576     Py_RETURN_FALSE;
 577   if (pending_breakpoint_p (self_bp->bp))
 578     Py_RETURN_TRUE;
 579
 580   Py_RETURN_FALSE;
 581 }
 582
 583 /* Python function to get the breakpoint's number.  */
 584 static PyObject *
 585 bppy_get_number (PyObject *self, void *closure)
 586 {
 587   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 588
 589   BPPY_REQUIRE_VALID (self_bp);
 590
 591   return PyInt_FromLong (self_bp->number);
 592 }
 593
 594 /* Python function to get the breakpoint's thread ID.  */
 595 static PyObject *
 596 bppy_get_thread (PyObject *self, void *closure)
 597 {
 598   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 599
 600   BPPY_REQUIRE_VALID (self_bp);
 601
 602   if (self_bp->bp->thread == -1)
 603     Py_RETURN_NONE;
 604
 605   return PyInt_FromLong (self_bp->bp->thread);
 606 }
 607
 608 /* Python function to get the breakpoint's task ID (in Ada).  */
 609 static PyObject *
 610 bppy_get_task (PyObject *self, void *closure)
 611 {
 612   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 613
 614   BPPY_REQUIRE_VALID (self_bp);
 615
 616   if (self_bp->bp->task == 0)
 617     Py_RETURN_NONE;
 618
 619   return PyInt_FromLong (self_bp->bp->task);
 620 }
 621
 622 /* Python function to get the breakpoint's hit count.  */
 623 static PyObject *
 624 bppy_get_hit_count (PyObject *self, void *closure)
 625 {
 626   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 627
 628   BPPY_REQUIRE_VALID (self_bp);
 629
 630   return PyInt_FromLong (self_bp->bp->hit_count);
 631 }
 632
 633 /* Python function to get the breakpoint's ignore count.  */
 634 static PyObject *
 635 bppy_get_ignore_count (PyObject *self, void *closure)
 636 {
 637   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
 638
 639   BPPY_REQUIRE_VALID (self_bp);
 640
 641   return PyInt_FromLong (self_bp->bp->ignore_count);
 642 }
 643
 644 /* Python function to create a new breakpoint.  */
 645 static int
 646 bppy_init (PyObject *self, PyObject *args, PyObject *kwargs)
 647 {
 648   static char *keywords[] = { "spec", "type", "wp_class", "internal",
 649                               "temporary", NULL };
 650   const char *spec;
 651   int type = bp_breakpoint;
 652   int access_type = hw_write;
 653   PyObject *internal = NULL;
 654   PyObject *temporary = NULL;
 655   int internal_bp = 0;
 656   int temporary_bp = 0;
 657
 658   if (! PyArg_ParseTupleAndKeywords (args, kwargs, "s|iiOO", keywords,
 659                                      &spec, &type, &access_type,
 660                                      &internal, &temporary))
 661     return -1;
 662
 663   if (internal)
 664     {
 665       internal_bp = PyObject_IsTrue (internal);
 666       if (internal_bp == -1)
 667         return -1;
 668     }
 669
 670   if (temporary != NULL)
 671     {
 672       temporary_bp = PyObject_IsTrue (temporary);
 673       if (temporary_bp == -1)
 674         return -1;
 675     }
 676
 677   bppy_pending_object = (gdbpy_breakpoint_object *) self;
 678   bppy_pending_object->number = -1;
 679   bppy_pending_object->bp = NULL;
 680
 681   TRY
 682     {
 683       char *copy = xstrdup (skip_spaces_const (spec));
 684       struct cleanup *cleanup = make_cleanup (xfree, copy);
 685
 686       switch (type)
 687         {
 688         case bp_breakpoint:
 689           {
 690             struct event_location *location;
 691
 692             location
 693               = string_to_event_location_basic (&copy, current_language);
 694             make_cleanup_delete_event_location (location);
 695             create_breakpoint (python_gdbarch,
 696                                location, NULL, -1, NULL,
 697                                0,
 698                                temporary_bp, bp_breakpoint,
 699                                0,
 700                                AUTO_BOOLEAN_TRUE,
 701                                &bkpt_breakpoint_ops,
 702                                0, 1, internal_bp, 0);
 703             break;
 704           }
 705         case bp_watchpoint:
 706           {
 707             if (access_type == hw_write)
 708               watch_command_wrapper (copy, 0, internal_bp);
 709             else if (access_type == hw_access)
 710               awatch_command_wrapper (copy, 0, internal_bp);
 711             else if (access_type == hw_read)
 712               rwatch_command_wrapper (copy, 0, internal_bp);
 713             else
 714               error(_("Cannot understand watchpoint access type."));
 715             break;
 716           }
 717         default:
 718           error(_("Do not understand breakpoint type to set."));
 719         }
 720
 721       do_cleanups (cleanup);
 722     }
 723   CATCH (except, RETURN_MASK_ALL)
 724     {
 725       bppy_pending_object = NULL;
 726       PyErr_Format (except.reason == RETURN_QUIT
 727                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 728                     "%s", except.message);
 729       return -1;
 730     }
 731   END_CATCH
 732
 733   BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object *) self);
 734   return 0;
 735 }
 736
 737 \f
 738
 739 static int
 740 build_bp_list (struct breakpoint *b, void *arg)
 741 {
 742   PyObject *list = (PyObject *) arg;
 743   PyObject *bp = (PyObject *) b->py_bp_object;
 744   int iserr = 0;
 745
 746   /* Not all breakpoints will have a companion Python object.
 747      Only breakpoints that were created via bppy_new, or
 748      breakpoints that were created externally and are tracked by
 749      the Python Scripting API.  */
 750   if (bp)
 751     iserr = PyList_Append (list, bp);
 752
 753   if (iserr == -1)
 754     return 1;
 755
 756   return 0;
 757 }
 758
 759 /* Static function to return a tuple holding all breakpoints.  */
 760
 761 PyObject *
 762 gdbpy_breakpoints (PyObject *self, PyObject *args)
 763 {
 764   PyObject *list, *tuple;
 765
 766   if (bppy_live == 0)
 767     return PyTuple_New (0);
 768
 769   list = PyList_New (0);
 770   if (!list)
 771     return NULL;
 772
 773   /* If iterate_over_breakpoints returns non NULL it signals an error
 774      condition.  In that case abandon building the list and return
 775      NULL.  */
 776   if (iterate_over_breakpoints (build_bp_list, list) != NULL)
 777     {
 778       Py_DECREF (list);
 779       return NULL;
 780     }
 781
 782   tuple = PyList_AsTuple (list);
 783   Py_DECREF (list);
 784
 785   return tuple;
 786 }
 787
 788 /* Call the "stop" method (if implemented) in the breakpoint
 789    class.  If the method returns True, the inferior  will be
 790    stopped at the breakpoint.  Otherwise the inferior will be
 791    allowed to continue.  */
 792
 793 enum ext_lang_bp_stop
 794 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn *extlang,
 795                                  struct breakpoint *b)
 796 {
 797   int stop;
 798   struct gdbpy_breakpoint_object *bp_obj = b->py_bp_object;
 799   PyObject *py_bp = (PyObject *) bp_obj;
 800   struct gdbarch *garch;
 801   struct cleanup *cleanup;
 802
 803   if (bp_obj == NULL)
 804     return EXT_LANG_BP_STOP_UNSET;
 805
 806   stop = -1;
 807   garch = b->gdbarch ? b->gdbarch : get_current_arch ();
 808   cleanup = ensure_python_env (garch, current_language);
 809
 810   if (bp_obj->is_finish_bp)
 811     bpfinishpy_pre_stop_hook (bp_obj);
 812
 813   if (PyObject_HasAttrString (py_bp, stop_func))
 814     {
 815       PyObject *result = PyObject_CallMethod (py_bp, stop_func, NULL);
 816
 817       stop = 1;
 818       if (result)
 819         {
 820           int evaluate = PyObject_IsTrue (result);
 821
 822           if (evaluate == -1)
 823             gdbpy_print_stack ();
 824
 825           /* If the "stop" function returns False that means
 826              the Python breakpoint wants GDB to continue.  */
 827           if (! evaluate)
 828             stop = 0;
 829
 830           Py_DECREF (result);
 831         }
 832       else
 833         gdbpy_print_stack ();
 834     }
 835
 836   if (bp_obj->is_finish_bp)
 837     bpfinishpy_post_stop_hook (bp_obj);
 838
 839   do_cleanups (cleanup);
 840
 841   if (stop < 0)
 842     return EXT_LANG_BP_STOP_UNSET;
 843   return stop ? EXT_LANG_BP_STOP_YES : EXT_LANG_BP_STOP_NO;
 844 }
 845
 846 /* Checks if the  "stop" method exists in this breakpoint.
 847    Used by condition_command to ensure mutual exclusion of breakpoint
 848    conditions.  */
 849
 850 int
 851 gdbpy_breakpoint_has_cond (const struct extension_language_defn *extlang,
 852                            struct breakpoint *b)
 853 {
 854   int has_func;
 855   PyObject *py_bp;
 856   struct gdbarch *garch;
 857   struct cleanup *cleanup;
 858
 859   if (b->py_bp_object == NULL)
 860     return 0;
 861
 862   py_bp = (PyObject *) b->py_bp_object;
 863   garch = b->gdbarch ? b->gdbarch : get_current_arch ();
 864   cleanup = ensure_python_env (garch, current_language);
 865   has_func = PyObject_HasAttrString (py_bp, stop_func);
 866   do_cleanups (cleanup);
 867
 868   return has_func;
 869 }
 870
 871 \f
 872
 873 /* Event callback functions.  */
 874
 875 /* Callback that is used when a breakpoint is created.  This function
 876    will create a new Python breakpoint object.  */
 877 static void
 878 gdbpy_breakpoint_created (struct breakpoint *bp)
 879 {
 880   gdbpy_breakpoint_object *newbp;
 881   PyGILState_STATE state;
 882
 883   if (!user_breakpoint_p (bp) && bppy_pending_object == NULL)
 884     return;
 885
 886   if (bp->type != bp_breakpoint
 887       && bp->type != bp_watchpoint
 888       && bp->type != bp_hardware_watchpoint
 889       && bp->type != bp_read_watchpoint
 890       && bp->type != bp_access_watchpoint)
 891     return;
 892
 893   state = PyGILState_Ensure ();
 894
 895   if (bppy_pending_object)
 896     {
 897       newbp = bppy_pending_object;
 898       bppy_pending_object = NULL;
 899     }
 900   else
 901     newbp = PyObject_New (gdbpy_breakpoint_object, &breakpoint_object_type);
 902   if (newbp)
 903     {
 904       newbp->number = bp->number;
 905       newbp->bp = bp;
 906       newbp->bp->py_bp_object = newbp;
 907       newbp->is_finish_bp = 0;
 908       Py_INCREF (newbp);
 909       ++bppy_live;
 910     }
 911   else
 912     {
 913       PyErr_SetString (PyExc_RuntimeError,
 914                        _("Error while creating breakpoint from GDB."));
 915       gdbpy_print_stack ();
 916     }
 917
 918   if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_created))
 919     {
 920       Py_INCREF (newbp);
 921       if (evpy_emit_event ((PyObject *) newbp,
 922                            gdb_py_events.breakpoint_created) < 0)
 923         gdbpy_print_stack ();
 924     }
 925
 926   PyGILState_Release (state);
 927 }
 928
 929 /* Callback that is used when a breakpoint is deleted.  This will
 930    invalidate the corresponding Python object.  */
 931 static void
 932 gdbpy_breakpoint_deleted (struct breakpoint *b)
 933 {
 934   int num = b->number;
 935   PyGILState_STATE state;
 936   struct breakpoint *bp = NULL;
 937   gdbpy_breakpoint_object *bp_obj;
 938
 939   state = PyGILState_Ensure ();
 940   bp = get_breakpoint (num);
 941   if (bp)
 942     {
 943       bp_obj = bp->py_bp_object;
 944       if (bp_obj)
 945         {
 946           if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_deleted))
 947             {
 948               PyObject *bp_obj_alias = (PyObject *) bp_obj;
 949
 950               Py_INCREF (bp_obj_alias);
 951               if (evpy_emit_event (bp_obj_alias,
 952                                    gdb_py_events.breakpoint_deleted) < 0)
 953                 gdbpy_print_stack ();
 954             }
 955
 956           bp_obj->bp = NULL;
 957           --bppy_live;
 958           Py_DECREF (bp_obj);
 959         }
 960     }
 961   PyGILState_Release (state);
 962 }
 963
 964 /* Callback that is used when a breakpoint is modified.  */
 965
 966 static void
 967 gdbpy_breakpoint_modified (struct breakpoint *b)
 968 {
 969   int num = b->number;
 970   PyGILState_STATE state;
 971   struct breakpoint *bp = NULL;
 972   gdbpy_breakpoint_object *bp_obj;
 973
 974   state = PyGILState_Ensure ();
 975   bp = get_breakpoint (num);
 976   if (bp)
 977     {
 978       PyObject *bp_obj = (PyObject *) bp->py_bp_object;
 979       if (bp_obj)
 980         {
 981           if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_modified))
 982             {
 983               Py_INCREF (bp_obj);
 984               if (evpy_emit_event (bp_obj,
 985                                    gdb_py_events.breakpoint_modified) < 0)
 986                 gdbpy_print_stack ();
 987             }
 988         }
 989     }
 990   PyGILState_Release (state);
 991 }
 992
 993 \f
 994
 995 /* Initialize the Python breakpoint code.  */
 996 int
 997 gdbpy_initialize_breakpoints (void)
 998 {
 999   int i;
1000
1001   breakpoint_object_type.tp_new = PyType_GenericNew;
1002   if (PyType_Ready (&breakpoint_object_type) < 0)
1003     return -1;
1004
1005   if (gdb_pymodule_addobject (gdb_module, "Breakpoint",
1006                               (PyObject *) &breakpoint_object_type) < 0)
1007     return -1;
1008
1009   observer_attach_breakpoint_created (gdbpy_breakpoint_created);
1010   observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted);
1011   observer_attach_breakpoint_modified (gdbpy_breakpoint_modified);
1012
1013   /* Add breakpoint types constants.  */
1014   for (i = 0; pybp_codes[i].name; ++i)
1015     {
1016       if (PyModule_AddIntConstant (gdb_module,
1017                                    /* Cast needed for Python 2.4.  */
1018                                    (char *) pybp_codes[i].name,
1019                                    pybp_codes[i].code) < 0)
1020         return -1;
1021     }
1022
1023   /* Add watchpoint types constants.  */
1024   for (i = 0; pybp_watch_types[i].name; ++i)
1025     {
1026       if (PyModule_AddIntConstant (gdb_module,
1027                                    /* Cast needed for Python 2.4.  */
1028                                    (char *) pybp_watch_types[i].name,
1029                                    pybp_watch_types[i].code) < 0)
1030         return -1;
1031     }
1032
1033   return 0;
1034 }
1035
1036 \f
1037
1038 /* Helper function that overrides this Python object's
1039    PyObject_GenericSetAttr to allow extra validation of the attribute
1040    being set.  */
1041
1042 static int
1043 local_setattro (PyObject *self, PyObject *name, PyObject *v)
1044 {
1045   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
1046   char *attr = python_string_to_host_string (name);
1047
1048   if (attr == NULL)
1049     return -1;
1050
1051   /* If the attribute trying to be set is the "stop" method,
1052      but we already have a condition set in the CLI or other extension
1053      language, disallow this operation.  */
1054   if (strcmp (attr, stop_func) == 0)
1055     {
1056       const struct extension_language_defn *extlang = NULL;
1057
1058       if (obj->bp->cond_string != NULL)
1059         extlang = get_ext_lang_defn (EXT_LANG_GDB);
1060       if (extlang == NULL)
1061         extlang = get_breakpoint_cond_ext_lang (obj->bp, EXT_LANG_PYTHON);
1062       if (extlang != NULL)
1063         {
1064           char *error_text;
1065
1066           xfree (attr);
1067           error_text
1068             = xstrprintf (_("Only one stop condition allowed.  There is"
1069                             " currently a %s stop condition defined for"
1070                             " this breakpoint."),
1071                           ext_lang_capitalized_name (extlang));
1072           PyErr_SetString (PyExc_RuntimeError, error_text);
1073           xfree (error_text);
1074           return -1;
1075         }
1076     }
1077
1078   xfree (attr);
1079
1080   return PyObject_GenericSetAttr ((PyObject *)self, name, v);
1081 }
1082
1083 static PyGetSetDef breakpoint_object_getset[] = {
1084   { "enabled", bppy_get_enabled, bppy_set_enabled,
1085     "Boolean telling whether the breakpoint is enabled.", NULL },
1086   { "silent", bppy_get_silent, bppy_set_silent,
1087     "Boolean telling whether the breakpoint is silent.", NULL },
1088   { "thread", bppy_get_thread, bppy_set_thread,
1089     "Thread ID for the breakpoint.\n\
1090 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1091 If the value is None, then this breakpoint is not thread-specific.\n\
1092 No other type of value can be used.", NULL },
1093   { "task", bppy_get_task, bppy_set_task,
1094     "Thread ID for the breakpoint.\n\
1095 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1096 If the value is None, then this breakpoint is not task-specific.\n\
1097 No other type of value can be used.", NULL },
1098   { "ignore_count", bppy_get_ignore_count, bppy_set_ignore_count,
1099     "Number of times this breakpoint should be automatically continued.",
1100     NULL },
1101   { "number", bppy_get_number, NULL,
1102     "Breakpoint's number assigned by GDB.", NULL },
1103   { "hit_count", bppy_get_hit_count, bppy_set_hit_count,
1104     "Number of times the breakpoint has been hit.\n\
1105 Can be set to zero to clear the count. No other value is valid\n\
1106 when setting this property.", NULL },
1107   { "location", bppy_get_location, NULL,
1108     "Location of the breakpoint, as specified by the user.", NULL},
1109   { "expression", bppy_get_expression, NULL,
1110     "Expression of the breakpoint, as specified by the user.", NULL},
1111   { "condition", bppy_get_condition, bppy_set_condition,
1112     "Condition of the breakpoint, as specified by the user,\
1113 or None if no condition set."},
1114   { "commands", bppy_get_commands, NULL,
1115     "Commands of the breakpoint, as specified by the user."},
1116   { "type", bppy_get_type, NULL,
1117     "Type of breakpoint."},
1118   { "visible", bppy_get_visibility, NULL,
1119     "Whether the breakpoint is visible to the user."},
1120   { "temporary", bppy_get_temporary, NULL,
1121     "Whether this breakpoint is a temporary breakpoint."},
1122   { "pending", bppy_get_pending, NULL,
1123     "Whether this breakpoint is a pending breakpoint."},
1124   { NULL }  /* Sentinel.  */
1125 };
1126
1127 static PyMethodDef breakpoint_object_methods[] =
1128 {
1129   { "is_valid", bppy_is_valid, METH_NOARGS,
1130     "Return true if this breakpoint is valid, false if not." },
1131   { "delete", bppy_delete_breakpoint, METH_NOARGS,
1132     "Delete the underlying GDB breakpoint." },
1133   { NULL } /* Sentinel.  */
1134 };
1135
1136 PyTypeObject breakpoint_object_type =
1137 {
1138   PyVarObject_HEAD_INIT (NULL, 0)
1139   "gdb.Breakpoint",               /*tp_name*/
1140   sizeof (gdbpy_breakpoint_object), /*tp_basicsize*/
1141   0,                              /*tp_itemsize*/
1142   0,                              /*tp_dealloc*/
1143   0,                              /*tp_print*/
1144   0,                              /*tp_getattr*/
1145   0,                              /*tp_setattr*/
1146   0,                              /*tp_compare*/
1147   0,                              /*tp_repr*/
1148   0,                              /*tp_as_number*/
1149   0,                              /*tp_as_sequence*/
1150   0,                              /*tp_as_mapping*/
1151   0,                              /*tp_hash */
1152   0,                              /*tp_call*/
1153   0,                              /*tp_str*/
1154   0,                              /*tp_getattro*/
1155   (setattrofunc)local_setattro,   /*tp_setattro */
1156   0,                              /*tp_as_buffer*/
1157   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
1158   "GDB breakpoint object",        /* tp_doc */
1159   0,                              /* tp_traverse */
1160   0,                              /* tp_clear */
1161   0,                              /* tp_richcompare */
1162   0,                              /* tp_weaklistoffset */
1163   0,                              /* tp_iter */
1164   0,                              /* tp_iternext */
1165   breakpoint_object_methods,      /* tp_methods */
1166   0,                              /* tp_members */
1167   breakpoint_object_getset,       /* tp_getset */
1168   0,                              /* tp_base */
1169   0,                              /* tp_dict */
1170   0,                              /* tp_descr_get */
1171   0,                              /* tp_descr_set */
1172   0,                              /* tp_dictoffset */
1173   bppy_init,                      /* tp_init */
1174   0,                              /* tp_alloc */
1175 };