gdb/python/py-breakpoint.c

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