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
 403   BPPY_REQUIRE_VALID (obj);
 404
 405   if (obj->bp->type != bp_watchpoint
 406       && obj->bp->type != bp_hardware_watchpoint
 407       && obj->bp->type != bp_read_watchpoint
 408       && obj->bp->type != bp_access_watchpoint)
 409     Py_RETURN_NONE;
 410
 411   str = obj->bp->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 (uiout, string_file);
 496   TRY_CATCH (except, RETURN_MASK_ALL)
 497     {
 498       print_command_lines (uiout, breakpoint_commands (bp), 0);
 499     }
 500   ui_out_redirect (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                                NULL, 0, 1, internal_bp);
 640             break;
 641           }
 642         case bp_watchpoint:
 643           {
 644             if (access_type == hw_write)
 645               watch_command_wrapper (copy, 0, internal_bp);
 646             else if (access_type == hw_access)
 647               awatch_command_wrapper (copy, 0, internal_bp);
 648             else if (access_type == hw_read)
 649               rwatch_command_wrapper (copy, 0, internal_bp);
 650             else
 651               error(_("Cannot understand watchpoint access type."));
 652             break;
 653           }
 654         default:
 655           error(_("Do not understand breakpoint type to set."));
 656         }
 657
 658       do_cleanups (cleanup);
 659     }
 660   if (except.reason < 0)
 661     {
 662       PyErr_Format (except.reason == RETURN_QUIT
 663                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 664                     "%s", except.message);
 665       return -1;
 666     }
 667
 668   BPPY_SET_REQUIRE_VALID ((breakpoint_object *) self);
 669   return 0;
 670 }
 671
 672 \f
 673
 674 static int
 675 build_bp_list (struct breakpoint *b, void *arg)
 676 {
 677   PyObject *list = arg;
 678   PyObject *bp = (PyObject *) b->py_bp_object;
 679   int iserr = 0;
 680
 681   /* Not all breakpoints will have a companion Python object.
 682      Only breakpoints that were created via bppy_new, or
 683      breakpoints that were created externally and are tracked by
 684      the Python Scripting API.  */
 685   if (bp)
 686     iserr = PyList_Append (list, bp);
 687
 688   if (iserr == -1)
 689     return 1;
 690
 691   return 0;
 692 }
 693
 694 /* Static function to return a tuple holding all breakpoints.  */
 695
 696 PyObject *
 697 gdbpy_breakpoints (PyObject *self, PyObject *args)
 698 {
 699   PyObject *list;
 700
 701   if (bppy_live == 0)
 702     Py_RETURN_NONE;
 703
 704   list = PyList_New (0);
 705   if (!list)
 706     return NULL;
 707
 708   /* If iteratre_over_breakpoints returns non NULL it signals an error
 709      condition.  In that case abandon building the list and return
 710      NULL.  */
 711   if (iterate_over_breakpoints (build_bp_list, list) != NULL)
 712     {
 713       Py_DECREF (list);
 714       return NULL;
 715     }
 716
 717   return PyList_AsTuple (list);
 718 }
 719
 720 /* Call the "stop" method (if implemented) in the breakpoint
 721    class.  If the method returns True, the inferior  will be
 722    stopped at the breakpoint.  Otherwise the inferior will be
 723    allowed to continue.  */
 724
 725 int
 726 gdbpy_should_stop (struct breakpoint_object *bp_obj)
 727 {
 728   int stop = 1;
 729
 730   PyObject *py_bp = (PyObject *) bp_obj;
 731   struct breakpoint *b = bp_obj->bp;
 732   struct gdbarch *garch = b->gdbarch ? b->gdbarch : get_current_arch ();
 733   struct cleanup *cleanup = ensure_python_env (garch, current_language);
 734
 735   if (PyObject_HasAttrString (py_bp, stop_func))
 736     {
 737       PyObject *result = PyObject_CallMethod (py_bp, stop_func, NULL);
 738
 739       if (result)
 740         {
 741           int evaluate = PyObject_IsTrue (result);
 742
 743           if (evaluate == -1)
 744             gdbpy_print_stack ();
 745
 746           /* If the "stop" function returns False that means
 747              the Python breakpoint wants GDB to continue.  */
 748           if (! evaluate)
 749             stop = 0;
 750
 751           Py_DECREF (result);
 752         }
 753       else
 754         gdbpy_print_stack ();
 755     }
 756   do_cleanups (cleanup);
 757
 758   return stop;
 759 }
 760
 761 /* Checks if the  "stop" method exists in this breakpoint.
 762    Used by condition_command to ensure mutual exclusion of breakpoint
 763    conditions.  */
 764
 765 int
 766 gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj)
 767 {
 768   int has_func = 0;
 769   PyObject *py_bp = (PyObject *) bp_obj;
 770   struct gdbarch *garch = bp_obj->bp->gdbarch ? bp_obj->bp->gdbarch :
 771     get_current_arch ();
 772   struct cleanup *cleanup = ensure_python_env (garch, current_language);
 773
 774   if (py_bp != NULL)
 775     has_func = PyObject_HasAttrString (py_bp, stop_func);
 776
 777   do_cleanups (cleanup);
 778
 779   return has_func;
 780 }
 781
 782 \f
 783
 784 /* Event callback functions.  */
 785
 786 /* Callback that is used when a breakpoint is created.  This function
 787    will create a new Python breakpoint object.  */
 788 static void
 789 gdbpy_breakpoint_created (struct breakpoint *bp)
 790 {
 791   breakpoint_object *newbp;
 792   PyGILState_STATE state;
 793
 794   if (bp->number < 0 && bppy_pending_object == NULL)
 795     return;
 796
 797   if (bp->type != bp_breakpoint
 798       && bp->type != bp_watchpoint
 799       && bp->type != bp_hardware_watchpoint
 800       && bp->type != bp_read_watchpoint
 801       && bp->type != bp_access_watchpoint)
 802     return;
 803
 804   state = PyGILState_Ensure ();
 805
 806   if (bppy_pending_object)
 807     {
 808       newbp = bppy_pending_object;
 809       bppy_pending_object = NULL;
 810     }
 811   else
 812     newbp = PyObject_New (breakpoint_object, &breakpoint_object_type);
 813   if (newbp)
 814     {
 815       newbp->number = bp->number;
 816       newbp->bp = bp;
 817       newbp->bp->py_bp_object = newbp;
 818       Py_INCREF (newbp);
 819       ++bppy_live;
 820     }
 821   else
 822     {
 823       PyErr_SetString (PyExc_RuntimeError,
 824                        _("Error while creating breakpoint from GDB."));
 825       gdbpy_print_stack ();
 826     }
 827
 828   PyGILState_Release (state);
 829 }
 830
 831 /* Callback that is used when a breakpoint is deleted.  This will
 832    invalidate the corresponding Python object.  */
 833 static void
 834 gdbpy_breakpoint_deleted (struct breakpoint *b)
 835 {
 836   int num = b->number;
 837   PyGILState_STATE state;
 838   struct breakpoint *bp = NULL;
 839   breakpoint_object *bp_obj;
 840
 841   state = PyGILState_Ensure ();
 842   bp = get_breakpoint (num);
 843   if (! bp)
 844     return;
 845
 846   bp_obj = bp->py_bp_object;
 847   if (bp_obj)
 848     {
 849       bp_obj->bp = NULL;
 850       --bppy_live;
 851       Py_DECREF (bp_obj);
 852     }
 853   PyGILState_Release (state);
 854 }
 855
 856 \f
 857
 858 /* Initialize the Python breakpoint code.  */
 859 void
 860 gdbpy_initialize_breakpoints (void)
 861 {
 862   int i;
 863
 864   if (PyType_Ready (&breakpoint_object_type) < 0)
 865     return;
 866
 867   Py_INCREF (&breakpoint_object_type);
 868   PyModule_AddObject (gdb_module, "Breakpoint",
 869                       (PyObject *) &breakpoint_object_type);
 870
 871   observer_attach_breakpoint_created (gdbpy_breakpoint_created);
 872   observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted);
 873
 874   /* Add breakpoint types constants.  */
 875   for (i = 0; pybp_codes[i].name; ++i)
 876     {
 877       if (PyModule_AddIntConstant (gdb_module,
 878                                    /* Cast needed for Python 2.4.  */
 879                                    (char *) pybp_codes[i].name,
 880                                    pybp_codes[i].code) < 0)
 881         return;
 882     }
 883
 884   /* Add watchpoint types constants.  */
 885   for (i = 0; pybp_watch_types[i].name; ++i)
 886     {
 887       if (PyModule_AddIntConstant (gdb_module,
 888                                    /* Cast needed for Python 2.4.  */
 889                                    (char *) pybp_watch_types[i].name,
 890                                    pybp_watch_types[i].code) < 0)
 891         return;
 892     }
 893
 894 }
 895
 896 \f
 897
 898 /* Helper function that overrides this Python object's
 899    PyObject_GenericSetAttr to allow extra validation of the attribute
 900    being set.  */
 901
 902 static int
 903 local_setattro (PyObject *self, PyObject *name, PyObject *v)
 904 {
 905   breakpoint_object *obj = (breakpoint_object *) self;
 906   char *attr = python_string_to_host_string (name);
 907
 908   if (attr == NULL)
 909     return -1;
 910
 911   /* If the attribute trying to be set is the "stop" method,
 912      but we already have a condition set in the CLI, disallow this
 913      operation.  */
 914   if (strcmp (attr, stop_func) == 0 && obj->bp->cond_string)
 915     {
 916       xfree (attr);
 917       PyErr_SetString (PyExc_RuntimeError,
 918                        _("Cannot set 'stop' method.  There is an " \
 919                          "existing GDB condition attached to the " \
 920                          "breakpoint."));
 921       return -1;
 922     }
 923
 924   xfree (attr);
 925
 926   return PyObject_GenericSetAttr ((PyObject *)self, name, v);
 927 }
 928
 929 static PyGetSetDef breakpoint_object_getset[] = {
 930   { "enabled", bppy_get_enabled, bppy_set_enabled,
 931     "Boolean telling whether the breakpoint is enabled.", NULL },
 932   { "silent", bppy_get_silent, bppy_set_silent,
 933     "Boolean telling whether the breakpoint is silent.", NULL },
 934   { "thread", bppy_get_thread, bppy_set_thread,
 935     "Thread ID for the breakpoint.\n\
 936 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
 937 If the value is None, then this breakpoint is not thread-specific.\n\
 938 No other type of value can be used.", NULL },
 939   { "task", bppy_get_task, bppy_set_task,
 940     "Thread ID for the breakpoint.\n\
 941 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
 942 If the value is None, then this breakpoint is not task-specific.\n\
 943 No other type of value can be used.", NULL },
 944   { "ignore_count", bppy_get_ignore_count, bppy_set_ignore_count,
 945     "Number of times this breakpoint should be automatically continued.",
 946     NULL },
 947   { "number", bppy_get_number, NULL,
 948     "Breakpoint's number assigned by GDB.", NULL },
 949   { "hit_count", bppy_get_hit_count, bppy_set_hit_count,
 950     "Number of times the breakpoint has been hit.\n\
 951 Can be set to zero to clear the count. No other value is valid\n\
 952 when setting this property.", NULL },
 953   { "location", bppy_get_location, NULL,
 954     "Location of the breakpoint, as specified by the user.", NULL},
 955   { "expression", bppy_get_expression, NULL,
 956     "Expression of the breakpoint, as specified by the user.", NULL},
 957   { "condition", bppy_get_condition, bppy_set_condition,
 958     "Condition of the breakpoint, as specified by the user,\
 959 or None if no condition set."},
 960   { "commands", bppy_get_commands, NULL,
 961     "Commands of the breakpoint, as specified by the user."},
 962   { "type", bppy_get_type, NULL,
 963     "Type of breakpoint."},
 964   { "visible", bppy_get_visibility, NULL,
 965     "Whether the breakpoint is visible to the user."},
 966   { NULL }  /* Sentinel.  */
 967 };
 968
 969 static PyMethodDef breakpoint_object_methods[] =
 970 {
 971   { "is_valid", bppy_is_valid, METH_NOARGS,
 972     "Return true if this breakpoint is valid, false if not." },
 973   { "delete", bppy_delete_breakpoint, METH_NOARGS,
 974     "Delete the underlying GDB breakpoint." },
 975   { NULL } /* Sentinel.  */
 976 };
 977
 978 static PyTypeObject breakpoint_object_type =
 979 {
 980   PyObject_HEAD_INIT (NULL)
 981   0,                              /*ob_size*/
 982   "gdb.Breakpoint",               /*tp_name*/
 983   sizeof (breakpoint_object),     /*tp_basicsize*/
 984   0,                              /*tp_itemsize*/
 985   0,                              /*tp_dealloc*/
 986   0,                              /*tp_print*/
 987   0,                              /*tp_getattr*/
 988   0,                              /*tp_setattr*/
 989   0,                              /*tp_compare*/
 990   0,                              /*tp_repr*/
 991   0,                              /*tp_as_number*/
 992   0,                              /*tp_as_sequence*/
 993   0,                              /*tp_as_mapping*/
 994   0,                              /*tp_hash */
 995   0,                              /*tp_call*/
 996   0,                              /*tp_str*/
 997   0,                              /*tp_getattro*/
 998   (setattrofunc)local_setattro,   /*tp_setattro */
 999   0,                              /*tp_as_buffer*/
1000   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
1001   "GDB breakpoint object",        /* tp_doc */
1002   0,                              /* tp_traverse */
1003   0,                              /* tp_clear */
1004   0,                              /* tp_richcompare */
1005   0,                              /* tp_weaklistoffset */
1006   0,                              /* tp_iter */
1007   0,                              /* tp_iternext */
1008   breakpoint_object_methods,      /* tp_methods */
1009   0,                              /* tp_members */
1010   breakpoint_object_getset,       /* tp_getset */
1011   0,                              /* tp_base */
1012   0,                              /* tp_dict */
1013   0,                              /* tp_descr_get */
1014   0,                              /* tp_descr_set */
1015   0,                              /* tp_dictoffset */
1016   bppy_init,                      /* tp_init */
1017   0,                              /* tp_alloc */
1018   PyType_GenericNew               /* tp_new */
1019 };