gdb/python/py-breakpoint.c

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