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