gdb/python/py-breakpoint.c

   1 /* Python interface to breakpoints
   2
   3    Copyright (C) 2008-2016 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_global_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 host_string_to_python_string (str);
 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 host_string_to_python_string (str);
 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 host_string_to_python_string (str);
 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 = host_string_to_python_string (cmdstr);
 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 (skip_spaces_const (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
 676               = string_to_event_location_basic (&copy, current_language);
 677             make_cleanup_delete_event_location (location);
 678             create_breakpoint (python_gdbarch,
 679                                location, NULL, -1, NULL,
 680                                0,
 681                                temporary_bp, bp_breakpoint,
 682                                0,
 683                                AUTO_BOOLEAN_TRUE,
 684                                &bkpt_breakpoint_ops,
 685                                0, 1, internal_bp, 0);
 686             break;
 687           }
 688         case bp_watchpoint:
 689           {
 690             if (access_type == hw_write)
 691               watch_command_wrapper (copy, 0, internal_bp);
 692             else if (access_type == hw_access)
 693               awatch_command_wrapper (copy, 0, internal_bp);
 694             else if (access_type == hw_read)
 695               rwatch_command_wrapper (copy, 0, internal_bp);
 696             else
 697               error(_("Cannot understand watchpoint access type."));
 698             break;
 699           }
 700         default:
 701           error(_("Do not understand breakpoint type to set."));
 702         }
 703
 704       do_cleanups (cleanup);
 705     }
 706   CATCH (except, RETURN_MASK_ALL)
 707     {
 708       bppy_pending_object = NULL;
 709       PyErr_Format (except.reason == RETURN_QUIT
 710                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 711                     "%s", except.message);
 712       return -1;
 713     }
 714   END_CATCH
 715
 716   BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object *) self);
 717   return 0;
 718 }
 719
 720 \f
 721
 722 static int
 723 build_bp_list (struct breakpoint *b, void *arg)
 724 {
 725   PyObject *list = (PyObject *) arg;
 726   PyObject *bp = (PyObject *) b->py_bp_object;
 727   int iserr = 0;
 728
 729   /* Not all breakpoints will have a companion Python object.
 730      Only breakpoints that were created via bppy_new, or
 731      breakpoints that were created externally and are tracked by
 732      the Python Scripting API.  */
 733   if (bp)
 734     iserr = PyList_Append (list, bp);
 735
 736   if (iserr == -1)
 737     return 1;
 738
 739   return 0;
 740 }
 741
 742 /* Static function to return a tuple holding all breakpoints.  */
 743
 744 PyObject *
 745 gdbpy_breakpoints (PyObject *self, PyObject *args)
 746 {
 747   PyObject *list, *tuple;
 748
 749   if (bppy_live == 0)
 750     return PyTuple_New (0);
 751
 752   list = PyList_New (0);
 753   if (!list)
 754     return NULL;
 755
 756   /* If iterate_over_breakpoints returns non NULL it signals an error
 757      condition.  In that case abandon building the list and return
 758      NULL.  */
 759   if (iterate_over_breakpoints (build_bp_list, list) != NULL)
 760     {
 761       Py_DECREF (list);
 762       return NULL;
 763     }
 764
 765   tuple = PyList_AsTuple (list);
 766   Py_DECREF (list);
 767
 768   return tuple;
 769 }
 770
 771 /* Call the "stop" method (if implemented) in the breakpoint
 772    class.  If the method returns True, the inferior  will be
 773    stopped at the breakpoint.  Otherwise the inferior will be
 774    allowed to continue.  */
 775
 776 enum ext_lang_bp_stop
 777 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn *extlang,
 778                                  struct breakpoint *b)
 779 {
 780   int stop;
 781   struct gdbpy_breakpoint_object *bp_obj = b->py_bp_object;
 782   PyObject *py_bp = (PyObject *) bp_obj;
 783   struct gdbarch *garch;
 784   struct cleanup *cleanup;
 785
 786   if (bp_obj == NULL)
 787     return EXT_LANG_BP_STOP_UNSET;
 788
 789   stop = -1;
 790   garch = b->gdbarch ? b->gdbarch : get_current_arch ();
 791   cleanup = ensure_python_env (garch, current_language);
 792
 793   if (bp_obj->is_finish_bp)
 794     bpfinishpy_pre_stop_hook (bp_obj);
 795
 796   if (PyObject_HasAttrString (py_bp, stop_func))
 797     {
 798       PyObject *result = PyObject_CallMethod (py_bp, stop_func, NULL);
 799
 800       stop = 1;
 801       if (result)
 802         {
 803           int evaluate = PyObject_IsTrue (result);
 804
 805           if (evaluate == -1)
 806             gdbpy_print_stack ();
 807
 808           /* If the "stop" function returns False that means
 809              the Python breakpoint wants GDB to continue.  */
 810           if (! evaluate)
 811             stop = 0;
 812
 813           Py_DECREF (result);
 814         }
 815       else
 816         gdbpy_print_stack ();
 817     }
 818
 819   if (bp_obj->is_finish_bp)
 820     bpfinishpy_post_stop_hook (bp_obj);
 821
 822   do_cleanups (cleanup);
 823
 824   if (stop < 0)
 825     return EXT_LANG_BP_STOP_UNSET;
 826   return stop ? EXT_LANG_BP_STOP_YES : EXT_LANG_BP_STOP_NO;
 827 }
 828
 829 /* Checks if the  "stop" method exists in this breakpoint.
 830    Used by condition_command to ensure mutual exclusion of breakpoint
 831    conditions.  */
 832
 833 int
 834 gdbpy_breakpoint_has_cond (const struct extension_language_defn *extlang,
 835                            struct breakpoint *b)
 836 {
 837   int has_func;
 838   PyObject *py_bp;
 839   struct gdbarch *garch;
 840   struct cleanup *cleanup;
 841
 842   if (b->py_bp_object == NULL)
 843     return 0;
 844
 845   py_bp = (PyObject *) b->py_bp_object;
 846   garch = b->gdbarch ? b->gdbarch : get_current_arch ();
 847   cleanup = ensure_python_env (garch, current_language);
 848   has_func = PyObject_HasAttrString (py_bp, stop_func);
 849   do_cleanups (cleanup);
 850
 851   return has_func;
 852 }
 853
 854 \f
 855
 856 /* Event callback functions.  */
 857
 858 /* Callback that is used when a breakpoint is created.  This function
 859    will create a new Python breakpoint object.  */
 860 static void
 861 gdbpy_breakpoint_created (struct breakpoint *bp)
 862 {
 863   gdbpy_breakpoint_object *newbp;
 864   PyGILState_STATE state;
 865
 866   if (bp->number < 0 && bppy_pending_object == NULL)
 867     return;
 868
 869   if (bp->type != bp_breakpoint
 870       && bp->type != bp_watchpoint
 871       && bp->type != bp_hardware_watchpoint
 872       && bp->type != bp_read_watchpoint
 873       && bp->type != bp_access_watchpoint)
 874     return;
 875
 876   state = PyGILState_Ensure ();
 877
 878   if (bppy_pending_object)
 879     {
 880       newbp = bppy_pending_object;
 881       bppy_pending_object = NULL;
 882     }
 883   else
 884     newbp = PyObject_New (gdbpy_breakpoint_object, &breakpoint_object_type);
 885   if (newbp)
 886     {
 887       newbp->number = bp->number;
 888       newbp->bp = bp;
 889       newbp->bp->py_bp_object = newbp;
 890       newbp->is_finish_bp = 0;
 891       Py_INCREF (newbp);
 892       ++bppy_live;
 893     }
 894   else
 895     {
 896       PyErr_SetString (PyExc_RuntimeError,
 897                        _("Error while creating breakpoint from GDB."));
 898       gdbpy_print_stack ();
 899     }
 900
 901   PyGILState_Release (state);
 902 }
 903
 904 /* Callback that is used when a breakpoint is deleted.  This will
 905    invalidate the corresponding Python object.  */
 906 static void
 907 gdbpy_breakpoint_deleted (struct breakpoint *b)
 908 {
 909   int num = b->number;
 910   PyGILState_STATE state;
 911   struct breakpoint *bp = NULL;
 912   gdbpy_breakpoint_object *bp_obj;
 913
 914   state = PyGILState_Ensure ();
 915   bp = get_breakpoint (num);
 916   if (bp)
 917     {
 918       bp_obj = bp->py_bp_object;
 919       if (bp_obj)
 920         {
 921           bp_obj->bp = NULL;
 922           --bppy_live;
 923           Py_DECREF (bp_obj);
 924         }
 925     }
 926   PyGILState_Release (state);
 927 }
 928
 929 \f
 930
 931 /* Initialize the Python breakpoint code.  */
 932 int
 933 gdbpy_initialize_breakpoints (void)
 934 {
 935   int i;
 936
 937   breakpoint_object_type.tp_new = PyType_GenericNew;
 938   if (PyType_Ready (&breakpoint_object_type) < 0)
 939     return -1;
 940
 941   if (gdb_pymodule_addobject (gdb_module, "Breakpoint",
 942                               (PyObject *) &breakpoint_object_type) < 0)
 943     return -1;
 944
 945   observer_attach_breakpoint_created (gdbpy_breakpoint_created);
 946   observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted);
 947
 948   /* Add breakpoint types constants.  */
 949   for (i = 0; pybp_codes[i].name; ++i)
 950     {
 951       if (PyModule_AddIntConstant (gdb_module,
 952                                    /* Cast needed for Python 2.4.  */
 953                                    (char *) pybp_codes[i].name,
 954                                    pybp_codes[i].code) < 0)
 955         return -1;
 956     }
 957
 958   /* Add watchpoint types constants.  */
 959   for (i = 0; pybp_watch_types[i].name; ++i)
 960     {
 961       if (PyModule_AddIntConstant (gdb_module,
 962                                    /* Cast needed for Python 2.4.  */
 963                                    (char *) pybp_watch_types[i].name,
 964                                    pybp_watch_types[i].code) < 0)
 965         return -1;
 966     }
 967
 968   return 0;
 969 }
 970
 971 \f
 972
 973 /* Helper function that overrides this Python object's
 974    PyObject_GenericSetAttr to allow extra validation of the attribute
 975    being set.  */
 976
 977 static int
 978 local_setattro (PyObject *self, PyObject *name, PyObject *v)
 979 {
 980   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
 981   char *attr = python_string_to_host_string (name);
 982
 983   if (attr == NULL)
 984     return -1;
 985
 986   /* If the attribute trying to be set is the "stop" method,
 987      but we already have a condition set in the CLI or other extension
 988      language, disallow this operation.  */
 989   if (strcmp (attr, stop_func) == 0)
 990     {
 991       const struct extension_language_defn *extlang = NULL;
 992
 993       if (obj->bp->cond_string != NULL)
 994         extlang = get_ext_lang_defn (EXT_LANG_GDB);
 995       if (extlang == NULL)
 996         extlang = get_breakpoint_cond_ext_lang (obj->bp, EXT_LANG_PYTHON);
 997       if (extlang != NULL)
 998         {
 999           char *error_text;
1000
1001           xfree (attr);
1002           error_text
1003             = xstrprintf (_("Only one stop condition allowed.  There is"
1004                             " currently a %s stop condition defined for"
1005                             " this breakpoint."),
1006                           ext_lang_capitalized_name (extlang));
1007           PyErr_SetString (PyExc_RuntimeError, error_text);
1008           xfree (error_text);
1009           return -1;
1010         }
1011     }
1012
1013   xfree (attr);
1014
1015   return PyObject_GenericSetAttr ((PyObject *)self, name, v);
1016 }
1017
1018 static PyGetSetDef breakpoint_object_getset[] = {
1019   { "enabled", bppy_get_enabled, bppy_set_enabled,
1020     "Boolean telling whether the breakpoint is enabled.", NULL },
1021   { "silent", bppy_get_silent, bppy_set_silent,
1022     "Boolean telling whether the breakpoint is silent.", NULL },
1023   { "thread", bppy_get_thread, bppy_set_thread,
1024     "Thread ID for the breakpoint.\n\
1025 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1026 If the value is None, then this breakpoint is not thread-specific.\n\
1027 No other type of value can be used.", NULL },
1028   { "task", bppy_get_task, bppy_set_task,
1029     "Thread ID for the breakpoint.\n\
1030 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1031 If the value is None, then this breakpoint is not task-specific.\n\
1032 No other type of value can be used.", NULL },
1033   { "ignore_count", bppy_get_ignore_count, bppy_set_ignore_count,
1034     "Number of times this breakpoint should be automatically continued.",
1035     NULL },
1036   { "number", bppy_get_number, NULL,
1037     "Breakpoint's number assigned by GDB.", NULL },
1038   { "hit_count", bppy_get_hit_count, bppy_set_hit_count,
1039     "Number of times the breakpoint has been hit.\n\
1040 Can be set to zero to clear the count. No other value is valid\n\
1041 when setting this property.", NULL },
1042   { "location", bppy_get_location, NULL,
1043     "Location of the breakpoint, as specified by the user.", NULL},
1044   { "expression", bppy_get_expression, NULL,
1045     "Expression of the breakpoint, as specified by the user.", NULL},
1046   { "condition", bppy_get_condition, bppy_set_condition,
1047     "Condition of the breakpoint, as specified by the user,\
1048 or None if no condition set."},
1049   { "commands", bppy_get_commands, NULL,
1050     "Commands of the breakpoint, as specified by the user."},
1051   { "type", bppy_get_type, NULL,
1052     "Type of breakpoint."},
1053   { "visible", bppy_get_visibility, NULL,
1054     "Whether the breakpoint is visible to the user."},
1055   { "temporary", bppy_get_temporary, NULL,
1056     "Whether this breakpoint is a temporary breakpoint."},
1057   { NULL }  /* Sentinel.  */
1058 };
1059
1060 static PyMethodDef breakpoint_object_methods[] =
1061 {
1062   { "is_valid", bppy_is_valid, METH_NOARGS,
1063     "Return true if this breakpoint is valid, false if not." },
1064   { "delete", bppy_delete_breakpoint, METH_NOARGS,
1065     "Delete the underlying GDB breakpoint." },
1066   { NULL } /* Sentinel.  */
1067 };
1068
1069 PyTypeObject breakpoint_object_type =
1070 {
1071   PyVarObject_HEAD_INIT (NULL, 0)
1072   "gdb.Breakpoint",               /*tp_name*/
1073   sizeof (gdbpy_breakpoint_object), /*tp_basicsize*/
1074   0,                              /*tp_itemsize*/
1075   0,                              /*tp_dealloc*/
1076   0,                              /*tp_print*/
1077   0,                              /*tp_getattr*/
1078   0,                              /*tp_setattr*/
1079   0,                              /*tp_compare*/
1080   0,                              /*tp_repr*/
1081   0,                              /*tp_as_number*/
1082   0,                              /*tp_as_sequence*/
1083   0,                              /*tp_as_mapping*/
1084   0,                              /*tp_hash */
1085   0,                              /*tp_call*/
1086   0,                              /*tp_str*/
1087   0,                              /*tp_getattro*/
1088   (setattrofunc)local_setattro,   /*tp_setattro */
1089   0,                              /*tp_as_buffer*/
1090   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
1091   "GDB breakpoint object",        /* tp_doc */
1092   0,                              /* tp_traverse */
1093   0,                              /* tp_clear */
1094   0,                              /* tp_richcompare */
1095   0,                              /* tp_weaklistoffset */
1096   0,                              /* tp_iter */
1097   0,                              /* tp_iternext */
1098   breakpoint_object_methods,      /* tp_methods */
1099   0,                              /* tp_members */
1100   breakpoint_object_getset,       /* tp_getset */
1101   0,                              /* tp_base */
1102   0,                              /* tp_dict */
1103   0,                              /* tp_descr_get */
1104   0,                              /* tp_descr_set */
1105   0,                              /* tp_dictoffset */
1106   bppy_init,                      /* tp_init */
1107   0,                              /* tp_alloc */
1108 };