gdb/python/py-breakpoint.c

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