gdb/python/py-breakpoint.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Python interface to breakpoints

  3.    Copyright (C) 2008-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  34. /* Number of live breakpoints.  */
  35. ‌static int bppy_live;

  37. /* Variables used to pass information between the Breakpoint
  38.    constructor and the breakpoint-created hook function.  */
  39. ‌gdbpy_breakpoint_object *bppy_pending_object;

  41. /* Function that is called when a Python condition is evaluated.  */
  42. ‌static char * const stop_func = "stop";

  44. /* This is used to initialize various gdb.bp_* constants.  */
  45. ‌struct pybp_code
  46. {
  47.   /* The name.  */
  48.   const char *name;
  49.   /* The code.  */
  50.   int code;
  51. };

  53. /* Entries related to the type of user set breakpoints.  */
  54. ‌static struct pybp_code pybp_codes[] =
  55. {
  56.   { "BP_NONE", bp_none},
  57.   { "BP_BREAKPOINT", bp_breakpoint},
  58.   { "BP_WATCHPOINT", bp_watchpoint},
  59.   { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint},
  60.   { "BP_READ_WATCHPOINT", bp_read_watchpoint},
  61.   { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint},
  62.   {NULL} /* Sentinel.  */
  63. };

  65. /* Entries related to the type of watchpoint.  */
  66. ‌static struct pybp_code pybp_watch_types[] =
  67. {
  68.   { "WP_READ", hw_read},
  69.   { "WP_WRITE", hw_write},
  70.   { "WP_ACCESS", hw_access},
  71.   {NULL} /* Sentinel.  */
  72. };

  74. /* Python function which checks the validity of a breakpoint object.  */
  75. static PyObject *
  76. ‌bppy_is_valid (PyObject *self, PyObject *args)
  77. {
  78.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  80.   if (self_bp->bp)
  81.     Py_RETURN_TRUE;
  82.   Py_RETURN_FALSE;
  83. }

  85. /* Python function to test whether or not the breakpoint is enabled.  */
  86. static PyObject *
  87. ‌bppy_get_enabled (PyObject *self, void *closure)
  88. {
  89.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  91.   BPPY_REQUIRE_VALID (self_bp);
  92.   if (! self_bp->bp)
  93.     Py_RETURN_FALSE;
  94.   if (self_bp->bp->enable_state == bp_enabled)
  95.     Py_RETURN_TRUE;
  96.   Py_RETURN_FALSE;
  97. }

  99. /* Python function to test whether or not the breakpoint is silent.  */
  100. static PyObject *
  101. ‌bppy_get_silent (PyObject *self, void *closure)
  102. {
  103.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  105.   BPPY_REQUIRE_VALID (self_bp);
  106.   if (self_bp->bp->silent)
  107.     Py_RETURN_TRUE;
  108.   Py_RETURN_FALSE;
  109. }

  111. /* Python function to set the enabled state of a breakpoint.  */
  112. static int
  113. ‌bppy_set_enabled (PyObject *self, PyObject *newvalue, void *closure)
  114. {
  115.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
  116.   int cmp;
  117.   volatile struct gdb_exception except;

  119.   BPPY_SET_REQUIRE_VALID (self_bp);

  121.   if (newvalue == NULL)
  122.     {
  123.       PyErr_SetString (PyExc_TypeError,
  124.                        _("Cannot delete `enabled' attribute."));

  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.     }

  135.   cmp = PyObject_IsTrue (newvalue);
  136.   if (cmp < 0)
  137.     return -1;

  139.   TRY_CATCH (except, RETURN_MASK_ALL)
  140.     {
  141.       if (cmp == 1)
  142.         enable_breakpoint (self_bp->bp);
  143.       else
  144.         disable_breakpoint (self_bp->bp);
  145.     }
  146.   GDB_PY_SET_HANDLE_EXCEPTION (except);

  148.   return 0;
  149. }

  151. /* Python function to set the 'silent' state of a breakpoint.  */
  152. static int
  153. ‌bppy_set_silent (PyObject *self, PyObject *newvalue, void *closure)
  154. {
  155.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
  156.   int cmp;

  158.   BPPY_SET_REQUIRE_VALID (self_bp);

  160.   if (newvalue == NULL)
  161.     {
  162.       PyErr_SetString (PyExc_TypeError,
  163.                        _("Cannot delete `silent' attribute."));
  164.       return -1;
  165.     }
  166.   else if (! PyBool_Check (newvalue))
  167.     {
  168.       PyErr_SetString (PyExc_TypeError,
  169.                        _("The value of `silent' must be a boolean."));
  170.       return -1;
  171.     }

  173.   cmp = PyObject_IsTrue (newvalue);
  174.   if (cmp < 0)
  175.     return -1;
  176.   else
  177.     breakpoint_set_silent (self_bp->bp, cmp);

  179.   return 0;
  180. }

  182. /* Python function to set the thread of a breakpoint.  */
  183. static int
  184. ‌bppy_set_thread (PyObject *self, PyObject *newvalue, void *closure)
  185. {
  186.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
  187.   long id;

  189.   BPPY_SET_REQUIRE_VALID (self_bp);

  191.   if (newvalue == NULL)
  192.     {
  193.       PyErr_SetString (PyExc_TypeError,
  194.                        _("Cannot delete `thread' attribute."));
  195.       return -1;
  196.     }
  197.   else if (PyInt_Check (newvalue))
  198.     {
  199.       if (! gdb_py_int_as_long (newvalue, &id))
  200.         return -1;

  202.       if (! valid_thread_id (id))
  203.         {
  204.           PyErr_SetString (PyExc_RuntimeError,
  205.                            _("Invalid thread ID."));
  206.           return -1;
  207.         }
  208.     }
  209.   else if (newvalue == Py_None)
  210.     id = -1;
  211.   else
  212.     {
  213.       PyErr_SetString (PyExc_TypeError,
  214.                        _("The value of `thread' must be an integer or None."));
  215.       return -1;
  216.     }

  218.   breakpoint_set_thread (self_bp->bp, id);

  220.   return 0;
  221. }

  223. /* Python function to set the (Ada) task of a breakpoint.  */
  224. static int
  225. ‌bppy_set_task (PyObject *self, PyObject *newvalue, void *closure)
  226. {
  227.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
  228.   long id;
  229.   int valid_id = 0;
  230.   volatile struct gdb_exception except;

  232.   BPPY_SET_REQUIRE_VALID (self_bp);

  234.   if (newvalue == NULL)
  235.     {
  236.       PyErr_SetString (PyExc_TypeError,
  237.                        _("Cannot delete `task' attribute."));
  238.       return -1;
  239.     }
  240.   else if (PyInt_Check (newvalue))
  241.     {
  242.       if (! gdb_py_int_as_long (newvalue, &id))
  243.         return -1;

  245.       TRY_CATCH (except, RETURN_MASK_ALL)
  246.         {
  247.           valid_id = valid_task_id (id);
  248.         }
  249.       GDB_PY_SET_HANDLE_EXCEPTION (except);

  251.       if (! valid_id)
  252.         {
  253.           PyErr_SetString (PyExc_RuntimeError,
  254.                            _("Invalid task ID."));
  255.           return -1;
  256.         }
  257.     }
  258.   else if (newvalue == Py_None)
  259.     id = 0;
  260.   else
  261.     {
  262.       PyErr_SetString (PyExc_TypeError,
  263.                        _("The value of `task' must be an integer or None."));
  264.       return -1;
  265.     }

  267.   breakpoint_set_task (self_bp->bp, id);

  269.   return 0;
  270. }

  272. /* Python function which deletes the underlying GDB breakpoint.  This
  273.    triggers the breakpoint_deleted observer which will call
  274.    gdbpy_breakpoint_deleted; that function cleans up the Python
  275.    sections.  */

  277. static PyObject *
  278. ‌bppy_delete_breakpoint (PyObject *self, PyObject *args)
  279. {
  280.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
  281.   volatile struct gdb_exception except;

  283.   BPPY_REQUIRE_VALID (self_bp);

  285.   TRY_CATCH (except, RETURN_MASK_ALL)
  286.     {
  287.       delete_breakpoint (self_bp->bp);
  288.     }
  289.   GDB_PY_HANDLE_EXCEPTION (except);

  291.   Py_RETURN_NONE;
  292. }


  295. /* Python function to set the ignore count of a breakpoint.  */
  296. static int
  297. ‌bppy_set_ignore_count (PyObject *self, PyObject *newvalue, void *closure)
  298. {
  299.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
  300.   long value;
  301.   volatile struct gdb_exception except;

  303.   BPPY_SET_REQUIRE_VALID (self_bp);

  305.   if (newvalue == NULL)
  306.     {
  307.       PyErr_SetString (PyExc_TypeError,
  308.                        _("Cannot delete `ignore_count' attribute."));
  309.       return -1;
  310.     }
  311.   else if (! PyInt_Check (newvalue))
  312.     {
  313.       PyErr_SetString (PyExc_TypeError,
  314.                        _("The value of `ignore_count' must be an integer."));
  315.       return -1;
  316.     }

  318.   if (! gdb_py_int_as_long (newvalue, &value))
  319.     return -1;

  321.   if (value < 0)
  322.     value = 0;

  324.   TRY_CATCH (except, RETURN_MASK_ALL)
  325.     {
  326.       set_ignore_count (self_bp->number, (int) value, 0);
  327.     }
  328.   GDB_PY_SET_HANDLE_EXCEPTION (except);

  330.   return 0;
  331. }

  333. /* Python function to set the hit count of a breakpoint.  */
  334. static int
  335. ‌bppy_set_hit_count (PyObject *self, PyObject *newvalue, void *closure)
  336. {
  337.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  339.   BPPY_SET_REQUIRE_VALID (self_bp);

  341.   if (newvalue == NULL)
  342.     {
  343.       PyErr_SetString (PyExc_TypeError,
  344.                        _("Cannot delete `hit_count' attribute."));
  345.       return -1;
  346.     }
  347.   else
  348.     {
  349.       long value;

  351.       if (! gdb_py_int_as_long (newvalue, &value))
  352.         return -1;

  354.       if (value != 0)
  355.         {
  356.           PyErr_SetString (PyExc_AttributeError,
  357.                            _("The value of `hit_count' must be zero."));
  358.           return -1;
  359.         }
  360.     }

  362.   self_bp->bp->hit_count = 0;

  364.   return 0;
  365. }

  367. /* Python function to get the location of a breakpoint.  */
  368. static PyObject *
  369. ‌bppy_get_location (PyObject *self, void *closure)
  370. {
  371.   char *str;
  372.   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;

  374.   BPPY_REQUIRE_VALID (obj);

  376.   if (obj->bp->type != bp_breakpoint)
  377.     Py_RETURN_NONE;

  379.   str = obj->bp->addr_string;

  381.   if (! str)
  382.     str = "";
  383.   return PyString_Decode (str, strlen (str), host_charset (), NULL);
  384. }

  386. /* Python function to get the breakpoint expression.  */
  387. static PyObject *
  388. ‌bppy_get_expression (PyObject *self, void *closure)
  389. {
  390.   char *str;
  391.   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
  392.   struct watchpoint *wp;

  394.   BPPY_REQUIRE_VALID (obj);

  396.   if (!is_watchpoint (obj->bp))
  397.     Py_RETURN_NONE;

  399.   wp = (struct watchpoint *) obj->bp;

  401.   str = wp->exp_string;
  402.   if (! str)
  403.     str = "";

  405.   return PyString_Decode (str, strlen (str), host_charset (), NULL);
  406. }

  408. /* Python function to get the condition expression of a breakpoint.  */
  409. static PyObject *
  410. ‌bppy_get_condition (PyObject *self, void *closure)
  411. {
  412.   char *str;
  413.   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;

  415.   BPPY_REQUIRE_VALID (obj);

  417.   str = obj->bp->cond_string;
  418.   if (! str)
  419.     Py_RETURN_NONE;

  421.   return PyString_Decode (str, strlen (str), host_charset (), NULL);
  422. }

  424. /* Returns 0 on success.  Returns -1 on error, with a python exception set.
  425.    */

  427. static int
  428. ‌bppy_set_condition (PyObject *self, PyObject *newvalue, void *closure)
  429. {
  430.   char *exp;
  431.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
  432.   volatile struct gdb_exception except;

  434.   BPPY_SET_REQUIRE_VALID (self_bp);

  436.   if (newvalue == NULL)
  437.     {
  438.       PyErr_SetString (PyExc_TypeError,
  439.                        _("Cannot delete `condition' attribute."));
  440.       return -1;
  441.     }
  442.   else if (newvalue == Py_None)
  443.     exp = "";
  444.   else
  445.     {
  446.       exp = python_string_to_host_string (newvalue);
  447.       if (exp == NULL)
  448.         return -1;
  449.     }

  451.   TRY_CATCH (except, RETURN_MASK_ALL)
  452.     {
  453.       set_breakpoint_condition (self_bp->bp, exp, 0);
  454.     }

  456.   if (newvalue != Py_None)
  457.     xfree (exp);

  459.   GDB_PY_SET_HANDLE_EXCEPTION (except);

  461.   return 0;
  462. }

  464. /* Python function to get the commands attached to a breakpoint.  */
  465. static PyObject *
  466. ‌bppy_get_commands (PyObject *self, void *closure)
  467. {
  468.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
  469.   struct breakpoint *bp = self_bp->bp;
  470.   long length;
  471.   volatile struct gdb_exception except;
  472.   struct ui_file *string_file;
  473.   struct cleanup *chain;
  474.   PyObject *result;
  475.   char *cmdstr;

  477.   BPPY_REQUIRE_VALID (self_bp);

  479.   if (! self_bp->bp->commands)
  480.     Py_RETURN_NONE;

  482.   string_file = mem_fileopen ();
  483.   chain = make_cleanup_ui_file_delete (string_file);

  485.   ui_out_redirect (current_uiout, string_file);
  486.   TRY_CATCH (except, RETURN_MASK_ALL)
  487.     {
  488.       print_command_lines (current_uiout, breakpoint_commands (bp), 0);
  489.     }
  490.   ui_out_redirect (current_uiout, NULL);
  491.   if (except.reason < 0)
  492.     {
  493.       do_cleanups (chain);
  494.       gdbpy_convert_exception (except);
  495.       return NULL;
  496.     }

  498.   cmdstr = ui_file_xstrdup (string_file, &length);
  499.   make_cleanup (xfree, cmdstr);
  500.   result = PyString_Decode (cmdstr, strlen (cmdstr), host_charset (), NULL);
  501.   do_cleanups (chain);
  502.   return result;
  503. }

  505. /* Python function to get the breakpoint type.  */
  506. static PyObject *
  507. ‌bppy_get_type (PyObject *self, void *closure)
  508. {
  509.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  511.   BPPY_REQUIRE_VALID (self_bp);

  513.   return PyInt_FromLong (self_bp->bp->type);
  514. }

  516. /* Python function to get the visibility of the breakpoint.  */

  518. static PyObject *
  519. ‌bppy_get_visibility (PyObject *self, void *closure)
  520. {
  521.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  523.   BPPY_REQUIRE_VALID (self_bp);

  525.   if (self_bp->bp->number < 0)
  526.     Py_RETURN_FALSE;

  528.   Py_RETURN_TRUE;
  529. }

  531. /* Python function to determine if the breakpoint is a temporary
  532.    breakpoint.  */

  534. static PyObject *
  535. ‌bppy_get_temporary (PyObject *self, void *closure)
  536. {
  537.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  539.   BPPY_REQUIRE_VALID (self_bp);

  541.   if (self_bp->bp->disposition == disp_del
  542.       || self_bp->bp->disposition == disp_del_at_next_stop)
  543.     Py_RETURN_TRUE;

  545.   Py_RETURN_FALSE;
  546. }

  548. /* Python function to get the breakpoint's number.  */
  549. static PyObject *
  550. ‌bppy_get_number (PyObject *self, void *closure)
  551. {
  552.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  554.   BPPY_REQUIRE_VALID (self_bp);

  556.   return PyInt_FromLong (self_bp->number);
  557. }

  559. /* Python function to get the breakpoint's thread ID.  */
  560. static PyObject *
  561. ‌bppy_get_thread (PyObject *self, void *closure)
  562. {
  563.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  565.   BPPY_REQUIRE_VALID (self_bp);

  567.   if (self_bp->bp->thread == -1)
  568.     Py_RETURN_NONE;

  570.   return PyInt_FromLong (self_bp->bp->thread);
  571. }

  573. /* Python function to get the breakpoint's task ID (in Ada).  */
  574. static PyObject *
  575. ‌bppy_get_task (PyObject *self, void *closure)
  576. {
  577.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  579.   BPPY_REQUIRE_VALID (self_bp);

  581.   if (self_bp->bp->task == 0)
  582.     Py_RETURN_NONE;

  584.   return PyInt_FromLong (self_bp->bp->task);
  585. }

  587. /* Python function to get the breakpoint's hit count.  */
  588. static PyObject *
  589. ‌bppy_get_hit_count (PyObject *self, void *closure)
  590. {
  591.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  593.   BPPY_REQUIRE_VALID (self_bp);

  595.   return PyInt_FromLong (self_bp->bp->hit_count);
  596. }

  598. /* Python function to get the breakpoint's ignore count.  */
  599. static PyObject *
  600. ‌bppy_get_ignore_count (PyObject *self, void *closure)
  601. {
  602.   gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;

  604.   BPPY_REQUIRE_VALID (self_bp);

  606.   return PyInt_FromLong (self_bp->bp->ignore_count);
  607. }

  609. /* Python function to create a new breakpoint.  */
  610. static int
  611. ‌bppy_init (PyObject *self, PyObject *args, PyObject *kwargs)
  612. {
  613.   static char *keywords[] = { "spec", "type", "wp_class", "internal",
  614.                               "temporary", NULL };
  615.   const char *spec;
  616.   int type = bp_breakpoint;
  617.   int access_type = hw_write;
  618.   PyObject *internal = NULL;
  619.   PyObject *temporary = NULL;
  620.   int internal_bp = 0;
  621.   int temporary_bp = 0;
  622.   volatile struct gdb_exception except;

  624.   if (! PyArg_ParseTupleAndKeywords (args, kwargs, "s|iiOO", keywords,
  625.                                      &spec, &type, &access_type,
  626.                                      &internal, &temporary))
  627.     return -1;

  629.   if (internal)
  630.     {
  631.       internal_bp = PyObject_IsTrue (internal);
  632.       if (internal_bp == -1)
  633.         return -1;
  634.     }

  636.   if (temporary != NULL)
  637.     {
  638.       temporary_bp = PyObject_IsTrue (temporary);
  639.       if (temporary_bp == -1)
  640.         return -1;
  641.     }

  643.   bppy_pending_object = (gdbpy_breakpoint_object *) self;
  644.   bppy_pending_object->number = -1;
  645.   bppy_pending_object->bp = NULL;

  647.   TRY_CATCH (except, RETURN_MASK_ALL)
  648.     {
  649.       char *copy = xstrdup (spec);
  650.       struct cleanup *cleanup = make_cleanup (xfree, copy);

  652.       switch (type)
  653.         {
  654.         case bp_breakpoint:
  655.           {
  656.             create_breakpoint (python_gdbarch,
  657.                                copy, NULL, -1, NULL,
  658.                                0,
  659.                                temporary_bp, bp_breakpoint,
  660.                                0,
  661.                                AUTO_BOOLEAN_TRUE,
  662.                                &bkpt_breakpoint_ops,
  663.                                0, 1, internal_bp, 0);
  664.             break;
  665.           }
  666.         case bp_watchpoint:
  667.           {
  668.             if (access_type == hw_write)
  669.               watch_command_wrapper (copy, 0, internal_bp);
  670.             else if (access_type == hw_access)
  671.               awatch_command_wrapper (copy, 0, internal_bp);
  672.             else if (access_type == hw_read)
  673.               rwatch_command_wrapper (copy, 0, internal_bp);
  674.             else
  675.               error(_("Cannot understand watchpoint access type."));
  676.             break;
  677.           }
  678.         default:
  679.           error(_("Do not understand breakpoint type to set."));
  680.         }

  682.       do_cleanups (cleanup);
  683.     }
  684.   if (except.reason < 0)
  685.     {
  686.       PyErr_Format (except.reason == RETURN_QUIT
  687.                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
  688.                     "%s", except.message);
  689.       return -1;
  690.     }

  692.   BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object *) self);
  693.   return 0;
  694. }



  698. static int
  699. ‌build_bp_list (struct breakpoint *b, void *arg)
  700. {
  701.   PyObject *list = arg;
  702.   PyObject *bp = (PyObject *) b->py_bp_object;
  703.   int iserr = 0;

  705.   /* Not all breakpoints will have a companion Python object.
  706.      Only breakpoints that were created via bppy_new, or
  707.      breakpoints that were created externally and are tracked by
  708.      the Python Scripting API.  */
  709.   if (bp)
  710.     iserr = PyList_Append (list, bp);

  712.   if (iserr == -1)
  713.     return 1;

  715.   return 0;
  716. }

  718. /* Static function to return a tuple holding all breakpoints.  */

  720. PyObject *
  721. ‌gdbpy_breakpoints (PyObject *self, PyObject *args)
  722. {
  723.   PyObject *list, *tuple;

  725.   if (bppy_live == 0)
  726.     Py_RETURN_NONE;

  728.   list = PyList_New (0);
  729.   if (!list)
  730.     return NULL;

  732.   /* If iteratre_over_breakpoints returns non NULL it signals an error
  733.      condition.  In that case abandon building the list and return
  734.      NULL.  */
  735.   if (iterate_over_breakpoints (build_bp_list, list) != NULL)
  736.     {
  737.       Py_DECREF (list);
  738.       return NULL;
  739.     }

  741.   tuple = PyList_AsTuple (list);
  742.   Py_DECREF (list);

  744.   return tuple;
  745. }

  747. /* Call the "stop" method (if implemented) in the breakpoint
  748.    class.  If the method returns True, the inferior  will be
  749.    stopped at the breakpoint.  Otherwise the inferior will be
  750.    allowed to continue.  */

  752. enum ext_lang_bp_stop
  753. ‌gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn *extlang,
  754.                                  struct breakpoint *b)
  755. {
  756.   int stop;
  757.   struct gdbpy_breakpoint_object *bp_obj = b->py_bp_object;
  758.   PyObject *py_bp = (PyObject *) bp_obj;
  759.   struct gdbarch *garch;
  760.   struct cleanup *cleanup;

  762.   if (bp_obj == NULL)
  763.     return EXT_LANG_BP_STOP_UNSET;

  765.   stop = -1;
  766.   garch = b->gdbarch ? b->gdbarch : get_current_arch ();
  767.   cleanup = ensure_python_env (garch, current_language);

  769.   if (bp_obj->is_finish_bp)
  770.     bpfinishpy_pre_stop_hook (bp_obj);

  772.   if (PyObject_HasAttrString (py_bp, stop_func))
  773.     {
  774.       PyObject *result = PyObject_CallMethod (py_bp, stop_func, NULL);

  776.       stop = 1;
  777.       if (result)
  778.         {
  779.           int evaluate = PyObject_IsTrue (result);

  781.           if (evaluate == -1)
  782.             gdbpy_print_stack ();

  784.           /* If the "stop" function returns False that means
  785.              the Python breakpoint wants GDB to continue.  */
  786.           if (! evaluate)
  787.             stop = 0;

  789.           Py_DECREF (result);
  790.         }
  791.       else
  792.         gdbpy_print_stack ();
  793.     }

  795.   if (bp_obj->is_finish_bp)
  796.     bpfinishpy_post_stop_hook (bp_obj);

  798.   do_cleanups (cleanup);

  800.   if (stop < 0)
  801.     return EXT_LANG_BP_STOP_UNSET;
  802.   return stop ? EXT_LANG_BP_STOP_YES : EXT_LANG_BP_STOP_NO;
  803. }

  805. /* Checks if the  "stop" method exists in this breakpoint.
  806.    Used by condition_command to ensure mutual exclusion of breakpoint
  807.    conditions.  */

  809. int
  810. ‌gdbpy_breakpoint_has_cond (const struct extension_language_defn *extlang,
  811.                            struct breakpoint *b)
  812. {
  813.   int has_func;
  814.   PyObject *py_bp;
  815.   struct gdbarch *garch;
  816.   struct cleanup *cleanup;

  818.   if (b->py_bp_object == NULL)
  819.     return 0;

  821.   py_bp = (PyObject *) b->py_bp_object;
  822.   garch = b->gdbarch ? b->gdbarch : get_current_arch ();
  823.   cleanup = ensure_python_env (garch, current_language);
  824.   has_func = PyObject_HasAttrString (py_bp, stop_func);
  825.   do_cleanups (cleanup);

  827.   return has_func;
  828. }



  832. /* Event callback functions.  */

  834. /* Callback that is used when a breakpoint is created.  This function
  835.    will create a new Python breakpoint object.  */
  836. static void
  837. ‌gdbpy_breakpoint_created (struct breakpoint *bp)
  838. {
  839.   gdbpy_breakpoint_object *newbp;
  840.   PyGILState_STATE state;

  842.   if (bp->number < 0 && bppy_pending_object == NULL)
  843.     return;

  845.   if (bp->type != bp_breakpoint
  846.       && bp->type != bp_watchpoint
  847.       && bp->type != bp_hardware_watchpoint
  848.       && bp->type != bp_read_watchpoint
  849.       && bp->type != bp_access_watchpoint)
  850.     return;

  852.   state = PyGILState_Ensure ();

  854.   if (bppy_pending_object)
  855.     {
  856.       newbp = bppy_pending_object;
  857.       bppy_pending_object = NULL;
  858.     }
  859.   else
  860.     newbp = PyObject_New (gdbpy_breakpoint_object, &breakpoint_object_type);
  861.   if (newbp)
  862.     {
  863.       newbp->number = bp->number;
  864.       newbp->bp = bp;
  865.       newbp->bp->py_bp_object = newbp;
  866.       newbp->is_finish_bp = 0;
  867.       Py_INCREF (newbp);
  868.       ++bppy_live;
  869.     }
  870.   else
  871.     {
  872.       PyErr_SetString (PyExc_RuntimeError,
  873.                        _("Error while creating breakpoint from GDB."));
  874.       gdbpy_print_stack ();
  875.     }

  877.   PyGILState_Release (state);
  878. }

  880. /* Callback that is used when a breakpoint is deleted.  This will
  881.    invalidate the corresponding Python object.  */
  882. static void
  883. ‌gdbpy_breakpoint_deleted (struct breakpoint *b)
  884. {
  885.   int num = b->number;
  886.   PyGILState_STATE state;
  887.   struct breakpoint *bp = NULL;
  888.   gdbpy_breakpoint_object *bp_obj;

  890.   state = PyGILState_Ensure ();
  891.   bp = get_breakpoint (num);
  892.   if (bp)
  893.     {
  894.       bp_obj = bp->py_bp_object;
  895.       if (bp_obj)
  896.         {
  897.           bp_obj->bp = NULL;
  898.           --bppy_live;
  899.           Py_DECREF (bp_obj);
  900.         }
  901.     }
  902.   PyGILState_Release (state);
  903. }



  907. /* Initialize the Python breakpoint code.  */
  908. int
  909. ‌gdbpy_initialize_breakpoints (void)
  910. {
  911.   int i;

  913.   breakpoint_object_type.tp_new = PyType_GenericNew;
  914.   if (PyType_Ready (&breakpoint_object_type) < 0)
  915.     return -1;

  917.   if (gdb_pymodule_addobject (gdb_module, "Breakpoint",
  918.                               (PyObject *) &breakpoint_object_type) < 0)
  919.     return -1;

  921.   observer_attach_breakpoint_created (gdbpy_breakpoint_created);
  922.   observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted);

  924.   /* Add breakpoint types constants.  */
  925.   for (i = 0; pybp_codes[i].name; ++i)
  926.     {
  927.       if (PyModule_AddIntConstant (gdb_module,
  928.                                    /* Cast needed for Python 2.4.  */
  929.                                    (char *) pybp_codes[i].name,
  930.                                    pybp_codes[i].code) < 0)
  931.         return -1;
  932.     }

  934.   /* Add watchpoint types constants.  */
  935.   for (i = 0; pybp_watch_types[i].name; ++i)
  936.     {
  937.       if (PyModule_AddIntConstant (gdb_module,
  938.                                    /* Cast needed for Python 2.4.  */
  939.                                    (char *) pybp_watch_types[i].name,
  940.                                    pybp_watch_types[i].code) < 0)
  941.         return -1;
  942.     }

  944.   return 0;
  945. }



  949. /* Helper function that overrides this Python object's
  950.    PyObject_GenericSetAttr to allow extra validation of the attribute
  951.    being set.  */

  953. static int
  954. ‌local_setattro (PyObject *self, PyObject *name, PyObject *v)
  955. {
  956.   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
  957.   char *attr = python_string_to_host_string (name);

  959.   if (attr == NULL)
  960.     return -1;

  962.   /* If the attribute trying to be set is the "stop" method,
  963.      but we already have a condition set in the CLI or other extension
  964.      language, disallow this operation.  */
  965.   if (strcmp (attr, stop_func) == 0)
  966.     {
  967.       const struct extension_language_defn *extlang = NULL;

  969.       if (obj->bp->cond_string != NULL)
  970.         extlang = get_ext_lang_defn (EXT_LANG_GDB);
  971.       if (extlang == NULL)
  972.         extlang = get_breakpoint_cond_ext_lang (obj->bp, EXT_LANG_PYTHON);
  973.       if (extlang != NULL)
  974.         {
  975.           char *error_text;

  977.           xfree (attr);
  978.           error_text
  979.             = xstrprintf (_("Only one stop condition allowed.  There is"
  980.                             " currently a %s stop condition defined for"
  981.                             " this breakpoint."),
  982.                           ext_lang_capitalized_name (extlang));
  983.           PyErr_SetString (PyExc_RuntimeError, error_text);
  984.           xfree (error_text);
  985.           return -1;
  986.         }
  987.     }

  989.   xfree (attr);

  991.   return PyObject_GenericSetAttr ((PyObject *)self, name, v);
  992. }

  994. ‌static PyGetSetDef breakpoint_object_getset[] = {
  995.   { "enabled", bppy_get_enabled, bppy_set_enabled,
  996.     "Boolean telling whether the breakpoint is enabled.", NULL },
  997.   { "silent", bppy_get_silent, bppy_set_silent,
  998.     "Boolean telling whether the breakpoint is silent.", NULL },
  999.   { "thread", bppy_get_thread, bppy_set_thread,
  1000.     "Thread ID for the breakpoint.\n\
  1001. If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
  1002. If the value is None, then this breakpoint is not thread-specific.\n\
  1003. No other type of value can be used.", NULL },
  1004.   { "task", bppy_get_task, bppy_set_task,
  1005.     "Thread ID for the breakpoint.\n\
  1006. If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
  1007. If the value is None, then this breakpoint is not task-specific.\n\
  1008. No other type of value can be used.", NULL },
  1009.   { "ignore_count", bppy_get_ignore_count, bppy_set_ignore_count,
  1010.     "Number of times this breakpoint should be automatically continued.",
  1011.     NULL },
  1012.   { "number", bppy_get_number, NULL,
  1013.     "Breakpoint's number assigned by GDB.", NULL },
  1014.   { "hit_count", bppy_get_hit_count, bppy_set_hit_count,
  1015.     "Number of times the breakpoint has been hit.\n\
  1016. Can be set to zero to clear the count. No other value is valid\n\
  1017. when setting this property.", NULL },
  1018.   { "location", bppy_get_location, NULL,
  1019.     "Location of the breakpoint, as specified by the user.", NULL},
  1020.   { "expression", bppy_get_expression, NULL,
  1021.     "Expression of the breakpoint, as specified by the user.", NULL},
  1022.   { "condition", bppy_get_condition, bppy_set_condition,
  1023.     "Condition of the breakpoint, as specified by the user,\
  1024. or None if no condition set."},
  1025.   { "commands", bppy_get_commands, NULL,
  1026.     "Commands of the breakpoint, as specified by the user."},
  1027.   { "type", bppy_get_type, NULL,
  1028.     "Type of breakpoint."},
  1029.   { "visible", bppy_get_visibility, NULL,
  1030.     "Whether the breakpoint is visible to the user."},
  1031.   { "temporary", bppy_get_temporary, NULL,
  1032.     "Whether this breakpoint is a temporary breakpoint."},
  1033.   { NULL }  /* Sentinel.  */
  1034. };

  1036. ‌static PyMethodDef breakpoint_object_methods[] =
  1037. {
  1038.   { "is_valid", bppy_is_valid, METH_NOARGS,
  1039.     "Return true if this breakpoint is valid, false if not." },
  1040.   { "delete", bppy_delete_breakpoint, METH_NOARGS,
  1041.     "Delete the underlying GDB breakpoint." },
  1042.   { NULL } /* Sentinel.  */
  1043. };

  1045. ‌PyTypeObject breakpoint_object_type =
  1046. {
  1047.   PyVarObject_HEAD_INIT (NULL, 0)
  1048.   "gdb.Breakpoint",                  /*tp_name*/
  1049.   sizeof (gdbpy_breakpoint_object), /*tp_basicsize*/
  1050.   0,                                  /*tp_itemsize*/
  1051.   0,                                  /*tp_dealloc*/
  1052.   0,                                  /*tp_print*/
  1053.   0,                                  /*tp_getattr*/
  1054.   0,                                  /*tp_setattr*/
  1055.   0,                                  /*tp_compare*/
  1056.   0,                                  /*tp_repr*/
  1057.   0,                                  /*tp_as_number*/
  1058.   0,                                  /*tp_as_sequence*/
  1059.   0,                                  /*tp_as_mapping*/
  1060.   0,                                  /*tp_hash */
  1061.   0,                                  /*tp_call*/
  1062.   0,                                  /*tp_str*/
  1063.   0,                                  /*tp_getattro*/
  1064.   (setattrofunc)local_setattro,   /*tp_setattro */
  1065.   0,                                  /*tp_as_buffer*/
  1066.   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
  1067.   "GDB breakpoint object",          /* tp_doc */
  1068.   0,                                  /* tp_traverse */
  1069.   0,                                  /* tp_clear */
  1070.   0,                                  /* tp_richcompare */
  1071.   0,                                  /* tp_weaklistoffset */
  1072.   0,                                  /* tp_iter */
  1073.   0,                                  /* tp_iternext */
  1074.   breakpoint_object_methods,          /* tp_methods */
  1075.   0,                                  /* tp_members */
  1076.   breakpoint_object_getset,          /* tp_getset */
  1077.   0,                                  /* tp_base */
  1078.   0,                                  /* tp_dict */
  1079.   0,                                  /* tp_descr_get */
  1080.   0,                                  /* tp_descr_set */
  1081.   0,                                  /* tp_dictoffset */
  1082.   bppy_init,                          /* tp_init */
  1083.   0,                                  /* tp_alloc */
  1084. };