gdb/python/python-internal.h

   1 /* Gdb/Python header for private use by Python module.
   2
   3    Copyright (C) 2008-2017 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 #ifndef GDB_PYTHON_INTERNAL_H
  21 #define GDB_PYTHON_INTERNAL_H
  22
  23 #include "extension.h"
  24 #include "extension-priv.h"
  25
  26 /* These WITH_* macros are defined by the CPython API checker that
  27    comes with the Python plugin for GCC.  See:
  28    https://gcc-python-plugin.readthedocs.org/en/latest/cpychecker.html
  29    The checker defines a WITH_ macro for each attribute it
  30    exposes.  */
  31
  32 #ifdef WITH_CPYCHECKER_RETURNS_BORROWED_REF_ATTRIBUTE
  33 #define CPYCHECKER_RETURNS_BORROWED_REF                 \
  34   __attribute__ ((cpychecker_returns_borrowed_ref))
  35 #else
  36 #define CPYCHECKER_RETURNS_BORROWED_REF
  37 #endif
  38
  39 #ifdef WITH_CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF_ATTRIBUTE
  40 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)         \
  41   __attribute__ ((cpychecker_type_object_for_typedef (ARG)))
  42 #else
  43 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)
  44 #endif
  45
  46 #ifdef WITH_CPYCHECKER_STEALS_REFERENCE_TO_ARG_ATTRIBUTE
  47 #define CPYCHECKER_STEALS_REFERENCE_TO_ARG(n) \
  48    __attribute__ ((cpychecker_steals_reference_to_arg (n)))
  49 #else
  50 #define CPYCHECKER_STEALS_REFERENCE_TO_ARG(n)
  51 #endif
  52
  53 #ifdef WITH_CPYCHECKER_SETS_EXCEPTION_ATTRIBUTE
  54 #define CPYCHECKER_SETS_EXCEPTION __attribute__ ((cpychecker_sets_exception))
  55 #else
  56 #define CPYCHECKER_SETS_EXCEPTION
  57 #endif
  58
  59 #ifdef WITH_CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION_ATTRIBUTE
  60 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION               \
  61   __attribute__ ((cpychecker_negative_result_sets_exception))
  62 #else
  63 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
  64 #endif
  65
  66 /* Python 2.4 doesn't include stdint.h soon enough to get {u,}intptr_t
  67    needed by pyport.h.  */
  68 /* /usr/include/features.h on linux systems will define _POSIX_C_SOURCE
  69    if it sees _GNU_SOURCE (which config.h will define).
  70    pyconfig.h defines _POSIX_C_SOURCE to a different value than
  71    /usr/include/features.h does causing compilation to fail.
  72    To work around this, undef _POSIX_C_SOURCE before we include Python.h.
  73
  74    Same problem with _XOPEN_SOURCE.  */
  75 #undef _POSIX_C_SOURCE
  76 #undef _XOPEN_SOURCE
  77
  78 /* On sparc-solaris, /usr/include/sys/feature_tests.h defines
  79    _FILE_OFFSET_BITS, which pyconfig.h also defines.  Same work
  80    around technique as above.  */
  81 #undef _FILE_OFFSET_BITS
  82
  83 /* A kludge to avoid redefinition of snprintf on Windows by pyerrors.h.  */
  84 #if defined(_WIN32) && defined(HAVE_DECL_SNPRINTF)
  85 #define HAVE_SNPRINTF 1
  86 #endif
  87
  88 /* Request clean size types from Python.  */
  89 #define PY_SSIZE_T_CLEAN
  90
  91 /* Include the Python header files using angle brackets rather than
  92    double quotes.  On case-insensitive filesystems, this prevents us
  93    from including our python/python.h header file.  */
  94 #include <Python.h>
  95 #include <frameobject.h>
  96
  97 #if PY_MAJOR_VERSION >= 3
  98 #define IS_PY3K 1
  99 #endif
 100
 101 #ifdef IS_PY3K
 102 #define Py_TPFLAGS_HAVE_ITER 0
 103 #define Py_TPFLAGS_CHECKTYPES 0
 104
 105 #define PyInt_Check PyLong_Check
 106 #define PyInt_FromLong PyLong_FromLong
 107 #define PyInt_AsLong PyLong_AsLong
 108
 109 #define PyString_FromString PyUnicode_FromString
 110 #define PyString_Decode PyUnicode_Decode
 111 #define PyString_FromFormat PyUnicode_FromFormat
 112 #define PyString_Check PyUnicode_Check
 113 #endif
 114
 115 #if HAVE_LIBPYTHON2_4
 116 /* Py_ssize_t is not defined until 2.5.
 117    Logical type for Py_ssize_t is Py_intptr_t, but that fails in 64-bit
 118    compilation due to several apparent mistakes in python2.4 API, so we
 119    use 'int' instead.  */
 120 typedef int Py_ssize_t;
 121 #endif
 122
 123 #ifndef PyVarObject_HEAD_INIT
 124 /* Python 2.4 does not define PyVarObject_HEAD_INIT.  */
 125 #define PyVarObject_HEAD_INIT(type, size)       \
 126     PyObject_HEAD_INIT(type) size,
 127
 128 #endif
 129
 130 #ifndef Py_TYPE
 131 /* Python 2.4 does not define Py_TYPE.  */
 132 #define Py_TYPE(ob)             (((PyObject*)(ob))->ob_type)
 133 #endif
 134
 135 /* If Python.h does not define WITH_THREAD, then the various
 136    GIL-related functions will not be defined.  However,
 137    PyGILState_STATE will be.  */
 138 #ifndef WITH_THREAD
 139 #define PyGILState_Ensure() ((PyGILState_STATE) 0)
 140 #define PyGILState_Release(ARG) ((void)(ARG))
 141 #define PyEval_InitThreads()
 142 #define PyThreadState_Swap(ARG) ((void)(ARG))
 143 #define PyEval_ReleaseLock()
 144 #endif
 145
 146 /* Python supplies HAVE_LONG_LONG and some `long long' support when it
 147    is available.  These defines let us handle the differences more
 148    cleanly.  */
 149 #ifdef HAVE_LONG_LONG
 150
 151 #define GDB_PY_LL_ARG "L"
 152 #define GDB_PY_LLU_ARG "K"
 153 typedef PY_LONG_LONG gdb_py_longest;
 154 typedef unsigned PY_LONG_LONG gdb_py_ulongest;
 155 #define gdb_py_long_from_longest PyLong_FromLongLong
 156 #define gdb_py_long_from_ulongest PyLong_FromUnsignedLongLong
 157 #define gdb_py_long_as_ulongest PyLong_AsUnsignedLongLong
 158
 159 #else /* HAVE_LONG_LONG */
 160
 161 #define GDB_PY_LL_ARG "L"
 162 #define GDB_PY_LLU_ARG "K"
 163 typedef long gdb_py_longest;
 164 typedef unsigned long gdb_py_ulongest;
 165 #define gdb_py_long_from_longest PyLong_FromLong
 166 #define gdb_py_long_from_ulongest PyLong_FromUnsignedLong
 167 #define gdb_py_long_as_ulongest PyLong_AsUnsignedLong
 168
 169 #endif /* HAVE_LONG_LONG */
 170
 171 #if PY_VERSION_HEX < 0x03020000
 172 typedef long Py_hash_t;
 173 #endif
 174
 175 /* Python 2.6 did not wrap Py_DECREF in 'do {...} while (0)', leading
 176    to 'suggest explicit braces to avoid ambiguous ‘else’' gcc errors.
 177    Wrap it ourselves, so that callers don't need to care.  */
 178
 179 static inline void
 180 gdb_Py_DECREF (void *op) /* ARI: editCase function */
 181 {
 182   /* ... and Python 2.4 didn't cast OP to PyObject pointer on the
 183      '(op)->ob_refcnt' references within the macro.  Cast it ourselves
 184      too.  */
 185   Py_DECREF ((PyObject *) op);
 186 }
 187
 188 #undef Py_DECREF
 189 #define Py_DECREF(op) gdb_Py_DECREF (op)
 190
 191 /* The second argument to PyObject_GetAttrString was missing the 'const'
 192    qualifier in Python-2.4.  Hence, we wrap it in a function to avoid errors
 193    when compiled with -Werror.  */
 194
 195 static inline PyObject *
 196 gdb_PyObject_GetAttrString (PyObject *obj,
 197                             const char *attr) /* ARI: editCase function */
 198 {
 199   return PyObject_GetAttrString (obj, (char *) attr);
 200 }
 201
 202 #define PyObject_GetAttrString(obj, attr) gdb_PyObject_GetAttrString (obj, attr)
 203
 204 /* The second argument to PyObject_HasAttrString was also missing the 'const'
 205    qualifier in Python-2.4.  Hence, we wrap it also in a function to avoid
 206    errors when compiled with -Werror.  */
 207
 208 static inline int
 209 gdb_PyObject_HasAttrString (PyObject *obj,
 210                             const char *attr)  /* ARI: editCase function */
 211 {
 212   return PyObject_HasAttrString (obj, (char *) attr);
 213 }
 214
 215 #define PyObject_HasAttrString(obj, attr) gdb_PyObject_HasAttrString (obj, attr)
 216
 217 /* In order to be able to parse symtab_and_line_to_sal_object function
 218    a real symtab_and_line structure is needed.  */
 219 #include "symtab.h"
 220
 221 /* Also needed to parse enum var_types. */
 222 #include "command.h"
 223 #include "breakpoint.h"
 224
 225 enum gdbpy_iter_kind { iter_keys, iter_values, iter_items };
 226
 227 struct block;
 228 struct value;
 229 struct language_defn;
 230 struct program_space;
 231 struct bpstats;
 232 struct inferior;
 233
 234 extern int gdb_python_initialized;
 235
 236 extern PyObject *gdb_module;
 237 extern PyObject *gdb_python_module;
 238 extern PyTypeObject value_object_type
 239     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("value_object");
 240 extern PyTypeObject block_object_type
 241     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("block_object");
 242 extern PyTypeObject symbol_object_type
 243     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symbol_object");
 244 extern PyTypeObject event_object_type
 245     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object");
 246 extern PyTypeObject stop_event_object_type
 247     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object");
 248 extern PyTypeObject breakpoint_object_type
 249     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("breakpoint_object");
 250 extern PyTypeObject frame_object_type
 251     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("frame_object");
 252
 253 typedef struct gdbpy_breakpoint_object
 254 {
 255   PyObject_HEAD
 256
 257   /* The breakpoint number according to gdb.  */
 258   int number;
 259
 260   /* The gdb breakpoint object, or NULL if the breakpoint has been
 261      deleted.  */
 262   struct breakpoint *bp;
 263
 264   /* 1 is this is a FinishBreakpoint object, 0 otherwise.  */
 265   int is_finish_bp;
 266 } gdbpy_breakpoint_object;
 267
 268 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
 269    exception if it is invalid.  */
 270 #define BPPY_REQUIRE_VALID(Breakpoint)                                  \
 271     do {                                                                \
 272       if ((Breakpoint)->bp == NULL)                                     \
 273         return PyErr_Format (PyExc_RuntimeError,                        \
 274                              _("Breakpoint %d is invalid."),            \
 275                              (Breakpoint)->number);                     \
 276     } while (0)
 277
 278 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
 279    exception if it is invalid.  This macro is for use in setter functions.  */
 280 #define BPPY_SET_REQUIRE_VALID(Breakpoint)                              \
 281     do {                                                                \
 282       if ((Breakpoint)->bp == NULL)                                     \
 283         {                                                               \
 284           PyErr_Format (PyExc_RuntimeError, _("Breakpoint %d is invalid."), \
 285                         (Breakpoint)->number);                          \
 286           return -1;                                                    \
 287         }                                                               \
 288     } while (0)
 289
 290
 291 /* Variables used to pass information between the Breakpoint
 292    constructor and the breakpoint-created hook function.  */
 293 extern gdbpy_breakpoint_object *bppy_pending_object;
 294
 295
 296 typedef struct
 297 {
 298   PyObject_HEAD
 299
 300   /* The thread we represent.  */
 301   struct thread_info *thread;
 302
 303   /* The Inferior object to which this thread belongs.  */
 304   PyObject *inf_obj;
 305 } thread_object;
 306
 307 extern struct cmd_list_element *set_python_list;
 308 extern struct cmd_list_element *show_python_list;
 309 \f
 310 /* extension_language_script_ops "methods".  */
 311
 312 extern int gdbpy_auto_load_enabled (const struct extension_language_defn *);
 313
 314 /* extension_language_ops "methods".  */
 315
 316 extern enum ext_lang_rc gdbpy_apply_val_pretty_printer
 317   (const struct extension_language_defn *,
 318    struct type *type,
 319    LONGEST embedded_offset, CORE_ADDR address,
 320    struct ui_file *stream, int recurse,
 321    struct value *val,
 322    const struct value_print_options *options,
 323    const struct language_defn *language);
 324 extern enum ext_lang_bt_status gdbpy_apply_frame_filter
 325   (const struct extension_language_defn *,
 326    struct frame_info *frame, int flags, enum ext_lang_frame_args args_type,
 327    struct ui_out *out, int frame_low, int frame_high);
 328 extern void gdbpy_preserve_values (const struct extension_language_defn *,
 329                                    struct objfile *objfile,
 330                                    htab_t copied_types);
 331 extern enum ext_lang_bp_stop gdbpy_breakpoint_cond_says_stop
 332   (const struct extension_language_defn *, struct breakpoint *);
 333 extern int gdbpy_breakpoint_has_cond (const struct extension_language_defn *,
 334                                       struct breakpoint *b);
 335
 336 extern void *gdbpy_clone_xmethod_worker_data
 337   (const struct extension_language_defn *extlang, void *data);
 338 extern void gdbpy_free_xmethod_worker_data
 339   (const struct extension_language_defn *extlang, void *data);
 340 extern enum ext_lang_rc gdbpy_get_matching_xmethod_workers
 341   (const struct extension_language_defn *extlang,
 342    struct type *obj_type, const char *method_name,
 343    xmethod_worker_vec **dm_vec);
 344 extern enum ext_lang_rc gdbpy_get_xmethod_arg_types
 345   (const struct extension_language_defn *extlang,
 346    struct xmethod_worker *worker,
 347    int *nargs,
 348    struct type ***arg_types);
 349 extern enum ext_lang_rc gdbpy_get_xmethod_result_type
 350   (const struct extension_language_defn *extlang,
 351    struct xmethod_worker *worker,
 352    struct value *object, struct value **args, int nargs,
 353    struct type **result_type);
 354 extern struct value *gdbpy_invoke_xmethod
 355   (const struct extension_language_defn *extlang,
 356    struct xmethod_worker *worker,
 357    struct value *obj, struct value **args, int nargs);
 358 \f
 359 PyObject *gdbpy_history (PyObject *self, PyObject *args);
 360 PyObject *gdbpy_breakpoints (PyObject *, PyObject *);
 361 PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *);
 362 PyObject *gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw);
 363 PyObject *gdbpy_lookup_global_symbol (PyObject *self, PyObject *args,
 364                                       PyObject *kw);
 365 PyObject *gdbpy_newest_frame (PyObject *self, PyObject *args);
 366 PyObject *gdbpy_selected_frame (PyObject *self, PyObject *args);
 367 PyObject *gdbpy_block_for_pc (PyObject *self, PyObject *args);
 368 PyObject *gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw);
 369 int gdbpy_is_field (PyObject *obj);
 370 PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
 371                                            const char *encoding,
 372                                            struct type *type);
 373 PyObject *gdbpy_inferiors (PyObject *unused, PyObject *unused2);
 374 PyObject *gdbpy_create_ptid_object (ptid_t ptid);
 375 PyObject *gdbpy_selected_thread (PyObject *self, PyObject *args);
 376 PyObject *gdbpy_selected_inferior (PyObject *self, PyObject *args);
 377 PyObject *gdbpy_string_to_argv (PyObject *self, PyObject *args);
 378 PyObject *gdbpy_parameter_value (enum var_types type, void *var);
 379 char *gdbpy_parse_command_name (const char *name,
 380                                 struct cmd_list_element ***base_list,
 381                                 struct cmd_list_element **start_list);
 382
 383 PyObject *symtab_and_line_to_sal_object (struct symtab_and_line sal);
 384 PyObject *symtab_to_symtab_object (struct symtab *symtab);
 385 PyObject *symbol_to_symbol_object (struct symbol *sym);
 386 PyObject *block_to_block_object (const struct block *block,
 387                                  struct objfile *objfile);
 388 PyObject *value_to_value_object (struct value *v);
 389 PyObject *type_to_type_object (struct type *);
 390 PyObject *frame_info_to_frame_object (struct frame_info *frame);
 391 PyObject *symtab_to_linetable_object (PyObject *symtab);
 392 PyObject *pspace_to_pspace_object (struct program_space *)
 393     CPYCHECKER_RETURNS_BORROWED_REF;
 394 PyObject *pspy_get_printers (PyObject *, void *);
 395 PyObject *pspy_get_frame_filters (PyObject *, void *);
 396 PyObject *pspy_get_frame_unwinders (PyObject *, void *);
 397 PyObject *pspy_get_xmethods (PyObject *, void *);
 398
 399 PyObject *objfile_to_objfile_object (struct objfile *)
 400     CPYCHECKER_RETURNS_BORROWED_REF;
 401 PyObject *objfpy_get_printers (PyObject *, void *);
 402 PyObject *objfpy_get_frame_filters (PyObject *, void *);
 403 PyObject *objfpy_get_frame_unwinders (PyObject *, void *);
 404 PyObject *objfpy_get_xmethods (PyObject *, void *);
 405 PyObject *gdbpy_lookup_objfile (PyObject *self, PyObject *args, PyObject *kw);
 406
 407 PyObject *gdbarch_to_arch_object (struct gdbarch *gdbarch);
 408
 409 thread_object *create_thread_object (struct thread_info *tp);
 410 thread_object *find_thread_object (ptid_t ptid)
 411     CPYCHECKER_RETURNS_BORROWED_REF;
 412 PyObject *find_inferior_object (int pid);
 413 PyObject *inferior_to_inferior_object (struct inferior *inferior);
 414
 415 const struct block *block_object_to_block (PyObject *obj);
 416 struct symbol *symbol_object_to_symbol (PyObject *obj);
 417 struct value *value_object_to_value (PyObject *self);
 418 struct value *convert_value_from_python (PyObject *obj);
 419 struct type *type_object_to_type (PyObject *obj);
 420 struct symtab *symtab_object_to_symtab (PyObject *obj);
 421 struct symtab_and_line *sal_object_to_symtab_and_line (PyObject *obj);
 422 struct frame_info *frame_object_to_frame_info (PyObject *frame_obj);
 423 struct gdbarch *arch_object_to_gdbarch (PyObject *obj);
 424
 425 void gdbpy_initialize_gdb_readline (void);
 426 int gdbpy_initialize_auto_load (void)
 427   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 428 int gdbpy_initialize_values (void)
 429   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 430 int gdbpy_initialize_frames (void)
 431   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 432 int gdbpy_initialize_symtabs (void)
 433   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 434 int gdbpy_initialize_commands (void)
 435   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 436 int gdbpy_initialize_symbols (void)
 437   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 438 int gdbpy_initialize_symtabs (void)
 439   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 440 int gdbpy_initialize_blocks (void)
 441   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 442 int gdbpy_initialize_types (void)
 443   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 444 int gdbpy_initialize_functions (void)
 445   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 446 int gdbpy_initialize_pspace (void)
 447   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 448 int gdbpy_initialize_objfile (void)
 449   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 450 int gdbpy_initialize_breakpoints (void)
 451   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 452 int gdbpy_initialize_finishbreakpoints (void)
 453   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 454 int gdbpy_initialize_lazy_string (void)
 455   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 456 int gdbpy_initialize_linetable (void)
 457   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 458 int gdbpy_initialize_parameters (void)
 459   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 460 int gdbpy_initialize_thread (void)
 461   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 462 int gdbpy_initialize_inferior (void)
 463   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 464 int gdbpy_initialize_eventregistry (void)
 465   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 466 int gdbpy_initialize_event (void)
 467   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 468 int gdbpy_initialize_py_events (void)
 469   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 470 int gdbpy_initialize_stop_event (void)
 471   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 472 int gdbpy_initialize_signal_event (void)
 473   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 474 int gdbpy_initialize_breakpoint_event (void)
 475   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 476 int gdbpy_initialize_continue_event (void)
 477   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 478 int gdbpy_initialize_inferior_call_pre_event (void)
 479   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 480 int gdbpy_initialize_inferior_call_post_event (void)
 481   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 482 int gdbpy_initialize_register_changed_event (void)
 483   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 484 int gdbpy_initialize_memory_changed_event (void)
 485   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 486 int gdbpy_initialize_exited_event (void)
 487   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 488 int gdbpy_initialize_thread_event (void)
 489   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 490 int gdbpy_initialize_new_objfile_event (void)
 491   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 492 int gdbpy_initialize_clear_objfiles_event (void)
 493   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 494 int gdbpy_initialize_arch (void)
 495   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 496 int gdbpy_initialize_xmethods (void)
 497   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 498 int gdbpy_initialize_unwind (void)
 499   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 500
 501 struct cleanup *make_cleanup_py_decref (PyObject *py);
 502 struct cleanup *make_cleanup_py_xdecref (PyObject *py);
 503
 504 /* Called before entering the Python interpreter to install the
 505    current language and architecture to be used for Python values.
 506    Also set the active extension language for GDB so that SIGINT's
 507    are directed our way, and if necessary install the right SIGINT
 508    handler.  */
 509 class gdbpy_enter
 510 {
 511  public:
 512
 513   gdbpy_enter (struct gdbarch *gdbarch, const struct language_defn *language);
 514
 515   ~gdbpy_enter ();
 516
 517   gdbpy_enter (const gdbpy_enter &) = delete;
 518   gdbpy_enter &operator= (const gdbpy_enter &) = delete;
 519
 520  private:
 521
 522   struct active_ext_lang_state *m_previous_active;
 523   PyGILState_STATE m_state;
 524   struct gdbarch *m_gdbarch;
 525   const struct language_defn *m_language;
 526   PyObject *m_error_type, *m_error_value, *m_error_traceback;
 527 };
 528
 529 /* Like gdbpy_enter, but takes a varobj.  This is a subclass just to
 530    make constructor delegation a little nicer.  */
 531 class gdbpy_enter_varobj : public gdbpy_enter
 532 {
 533  public:
 534
 535   /* This is defined in varobj.c, where it can access varobj
 536      internals.  */
 537   gdbpy_enter_varobj (const struct varobj *var);
 538
 539 };
 540
 541 struct cleanup *ensure_python_env (struct gdbarch *gdbarch,
 542                                    const struct language_defn *language);
 543
 544 extern struct gdbarch *python_gdbarch;
 545 extern const struct language_defn *python_language;
 546
 547 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 548    exception.  */
 549 #define GDB_PY_HANDLE_EXCEPTION(Exception)      \
 550   do {                                          \
 551     if (Exception.reason < 0)                   \
 552       {                                         \
 553         gdbpy_convert_exception (Exception);    \
 554         return NULL;                            \
 555       }                                         \
 556   } while (0)
 557
 558 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 559    exception.  This macro is for use inside setter functions.  */
 560 #define GDB_PY_SET_HANDLE_EXCEPTION(Exception)                          \
 561     do {                                                                \
 562       if (Exception.reason < 0)                                         \
 563         {                                                               \
 564           gdbpy_convert_exception (Exception);                          \
 565           return -1;                                                    \
 566         }                                                               \
 567     } while (0)
 568
 569 int gdbpy_print_python_errors_p (void);
 570 void gdbpy_print_stack (void);
 571
 572 PyObject *python_string_to_unicode (PyObject *obj);
 573 gdb::unique_xmalloc_ptr<char> unicode_to_target_string (PyObject *unicode_str);
 574 gdb::unique_xmalloc_ptr<char> python_string_to_target_string (PyObject *obj);
 575 PyObject *python_string_to_target_python_string (PyObject *obj);
 576 gdb::unique_xmalloc_ptr<char> python_string_to_host_string (PyObject *obj);
 577 PyObject *host_string_to_python_string (const char *str);
 578 int gdbpy_is_string (PyObject *obj);
 579 gdb::unique_xmalloc_ptr<char> gdbpy_obj_to_string (PyObject *obj);
 580 gdb::unique_xmalloc_ptr<char> gdbpy_exception_to_string (PyObject *ptype,
 581                                                          PyObject *pvalue);
 582
 583 int gdbpy_is_lazy_string (PyObject *result);
 584 void gdbpy_extract_lazy_string (PyObject *string, CORE_ADDR *addr,
 585                                 struct type **str_type,
 586                                 long *length, char **encoding);
 587
 588 int gdbpy_is_value_object (PyObject *obj);
 589
 590 /* Note that these are declared here, and not in python.h with the
 591    other pretty-printer functions, because they refer to PyObject.  */
 592 PyObject *apply_varobj_pretty_printer (PyObject *print_obj,
 593                                        struct value **replacement,
 594                                        struct ui_file *stream);
 595 PyObject *gdbpy_get_varobj_pretty_printer (struct value *value);
 596 gdb::unique_xmalloc_ptr<char> gdbpy_get_display_hint (PyObject *printer);
 597 PyObject *gdbpy_default_visualizer (PyObject *self, PyObject *args);
 598
 599 void bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 600 void bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 601
 602 extern PyObject *gdbpy_doc_cst;
 603 extern PyObject *gdbpy_children_cst;
 604 extern PyObject *gdbpy_to_string_cst;
 605 extern PyObject *gdbpy_display_hint_cst;
 606 extern PyObject *gdbpy_enabled_cst;
 607 extern PyObject *gdbpy_value_cst;
 608
 609 /* Exception types.  */
 610 extern PyObject *gdbpy_gdb_error;
 611 extern PyObject *gdbpy_gdb_memory_error;
 612 extern PyObject *gdbpy_gdberror_exc;
 613
 614 extern void gdbpy_convert_exception (struct gdb_exception)
 615     CPYCHECKER_SETS_EXCEPTION;
 616
 617 int get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
 618     CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 619
 620 PyObject *gdb_py_object_from_longest (LONGEST l);
 621 PyObject *gdb_py_object_from_ulongest (ULONGEST l);
 622 int gdb_py_int_as_long (PyObject *, long *);
 623
 624 PyObject *gdb_py_generic_dict (PyObject *self, void *closure);
 625
 626 int gdb_pymodule_addobject (PyObject *module, const char *name,
 627                             PyObject *object)
 628   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 629
 630 struct varobj_iter;
 631 struct varobj;
 632 struct varobj_iter *py_varobj_get_iterator (struct varobj *var,
 633                                             PyObject *printer);
 634
 635 #endif /* GDB_PYTHON_INTERNAL_H */