gdb/python/python-internal.h

   1 /* Gdb/Python header for private use by Python module.
   2
   3    Copyright (C) 2008-2018 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.  Note that we intentionally do not use
  31    'cpychecker_returns_borrowed_ref' -- that idiom is forbidden in
  32    gdb.  */
  33
  34 #ifdef WITH_CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF_ATTRIBUTE
  35 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)         \
  36   __attribute__ ((cpychecker_type_object_for_typedef (ARG)))
  37 #else
  38 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)
  39 #endif
  40
  41 #ifdef WITH_CPYCHECKER_SETS_EXCEPTION_ATTRIBUTE
  42 #define CPYCHECKER_SETS_EXCEPTION __attribute__ ((cpychecker_sets_exception))
  43 #else
  44 #define CPYCHECKER_SETS_EXCEPTION
  45 #endif
  46
  47 #ifdef WITH_CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION_ATTRIBUTE
  48 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION               \
  49   __attribute__ ((cpychecker_negative_result_sets_exception))
  50 #else
  51 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
  52 #endif
  53
  54 /* Python 2.4 doesn't include stdint.h soon enough to get {u,}intptr_t
  55    needed by pyport.h.  */
  56 /* /usr/include/features.h on linux systems will define _POSIX_C_SOURCE
  57    if it sees _GNU_SOURCE (which config.h will define).
  58    pyconfig.h defines _POSIX_C_SOURCE to a different value than
  59    /usr/include/features.h does causing compilation to fail.
  60    To work around this, undef _POSIX_C_SOURCE before we include Python.h.
  61
  62    Same problem with _XOPEN_SOURCE.  */
  63 #undef _POSIX_C_SOURCE
  64 #undef _XOPEN_SOURCE
  65
  66 /* On sparc-solaris, /usr/include/sys/feature_tests.h defines
  67    _FILE_OFFSET_BITS, which pyconfig.h also defines.  Same work
  68    around technique as above.  */
  69 #undef _FILE_OFFSET_BITS
  70
  71 /* A kludge to avoid redefinition of snprintf on Windows by pyerrors.h.  */
  72 #if defined(_WIN32) && defined(HAVE_DECL_SNPRINTF)
  73 #define HAVE_SNPRINTF 1
  74 #endif
  75
  76 /* Another kludge to avoid compilation errors because MinGW defines
  77    'hypot' to '_hypot', but the C++ headers says "using ::hypot".  */
  78 #ifdef __MINGW32__
  79 # define _hypot hypot
  80 #endif
  81
  82 /* Request clean size types from Python.  */
  83 #define PY_SSIZE_T_CLEAN
  84
  85 /* Include the Python header files using angle brackets rather than
  86    double quotes.  On case-insensitive filesystems, this prevents us
  87    from including our python/python.h header file.  */
  88 #include <Python.h>
  89 #include <frameobject.h>
  90 #include "py-ref.h"
  91
  92 #if PY_MAJOR_VERSION >= 3
  93 #define IS_PY3K 1
  94 #endif
  95
  96 #ifdef IS_PY3K
  97 #define Py_TPFLAGS_HAVE_ITER 0
  98 #define Py_TPFLAGS_CHECKTYPES 0
  99
 100 #define PyInt_Check PyLong_Check
 101 #define PyInt_FromLong PyLong_FromLong
 102 #define PyInt_FromSsize_t PyLong_FromSsize_t
 103 #define PyInt_AsLong PyLong_AsLong
 104 #define PyInt_AsSsize_t PyLong_AsSsize_t
 105
 106 #define PyString_FromString PyUnicode_FromString
 107 #define PyString_Decode PyUnicode_Decode
 108 #define PyString_FromFormat PyUnicode_FromFormat
 109 #define PyString_Check PyUnicode_Check
 110 #endif
 111
 112 #if HAVE_LIBPYTHON2_4
 113 /* Py_ssize_t is not defined until 2.5.
 114    Logical type for Py_ssize_t is Py_intptr_t, but that fails in 64-bit
 115    compilation due to several apparent mistakes in python2.4 API, so we
 116    use 'int' instead.  */
 117 typedef int Py_ssize_t;
 118 #endif
 119
 120 #ifndef PyVarObject_HEAD_INIT
 121 /* Python 2.4 does not define PyVarObject_HEAD_INIT.  */
 122 #define PyVarObject_HEAD_INIT(type, size)       \
 123     PyObject_HEAD_INIT(type) size,
 124
 125 #endif
 126
 127 #ifndef Py_TYPE
 128 /* Python 2.4 does not define Py_TYPE.  */
 129 #define Py_TYPE(ob)             (((PyObject*)(ob))->ob_type)
 130 #endif
 131
 132 /* If Python.h does not define WITH_THREAD, then the various
 133    GIL-related functions will not be defined.  However,
 134    PyGILState_STATE will be.  */
 135 #ifndef WITH_THREAD
 136 #define PyGILState_Ensure() ((PyGILState_STATE) 0)
 137 #define PyGILState_Release(ARG) ((void)(ARG))
 138 #define PyEval_InitThreads()
 139 #define PyThreadState_Swap(ARG) ((void)(ARG))
 140 #define PyEval_ReleaseLock()
 141 #endif
 142
 143 /* Python supplies HAVE_LONG_LONG and some `long long' support when it
 144    is available.  These defines let us handle the differences more
 145    cleanly.  */
 146 #ifdef HAVE_LONG_LONG
 147
 148 #define GDB_PY_LL_ARG "L"
 149 #define GDB_PY_LLU_ARG "K"
 150 typedef PY_LONG_LONG gdb_py_longest;
 151 typedef unsigned PY_LONG_LONG gdb_py_ulongest;
 152 #define gdb_py_long_from_longest PyLong_FromLongLong
 153 #define gdb_py_long_from_ulongest PyLong_FromUnsignedLongLong
 154 #define gdb_py_long_as_ulongest PyLong_AsUnsignedLongLong
 155
 156 #else /* HAVE_LONG_LONG */
 157
 158 #define GDB_PY_LL_ARG "L"
 159 #define GDB_PY_LLU_ARG "K"
 160 typedef long gdb_py_longest;
 161 typedef unsigned long gdb_py_ulongest;
 162 #define gdb_py_long_from_longest PyLong_FromLong
 163 #define gdb_py_long_from_ulongest PyLong_FromUnsignedLong
 164 #define gdb_py_long_as_ulongest PyLong_AsUnsignedLong
 165
 166 #endif /* HAVE_LONG_LONG */
 167
 168 #if PY_VERSION_HEX < 0x03020000
 169 typedef long Py_hash_t;
 170 #endif
 171
 172 /* PyMem_RawMalloc appeared in Python 3.4.  For earlier versions, we can just
 173    fall back to PyMem_Malloc.  */
 174
 175 #if PY_VERSION_HEX < 0x03040000
 176 #define PyMem_RawMalloc PyMem_Malloc
 177 #endif
 178
 179 /* Python 2.6 did not wrap Py_DECREF in 'do {...} while (0)', leading
 180    to 'suggest explicit braces to avoid ambiguous ‘else’' gcc errors.
 181    Wrap it ourselves, so that callers don't need to care.  */
 182
 183 static inline void
 184 gdb_Py_DECREF (void *op) /* ARI: editCase function */
 185 {
 186   /* ... and Python 2.4 didn't cast OP to PyObject pointer on the
 187      '(op)->ob_refcnt' references within the macro.  Cast it ourselves
 188      too.  */
 189   Py_DECREF ((PyObject *) op);
 190 }
 191
 192 #undef Py_DECREF
 193 #define Py_DECREF(op) gdb_Py_DECREF (op)
 194
 195 /* The second argument to PyObject_GetAttrString was missing the 'const'
 196    qualifier in Python-2.4.  Hence, we wrap it in a function to avoid errors
 197    when compiled with -Werror.  */
 198
 199 static inline PyObject *
 200 gdb_PyObject_GetAttrString (PyObject *obj,
 201                             const char *attr) /* ARI: editCase function */
 202 {
 203   return PyObject_GetAttrString (obj, (char *) attr);
 204 }
 205
 206 #define PyObject_GetAttrString(obj, attr) gdb_PyObject_GetAttrString (obj, attr)
 207
 208 /* The second argument to PyObject_HasAttrString was also missing the 'const'
 209    qualifier in Python-2.4.  Hence, we wrap it also in a function to avoid
 210    errors when compiled with -Werror.  */
 211
 212 static inline int
 213 gdb_PyObject_HasAttrString (PyObject *obj,
 214                             const char *attr)  /* ARI: editCase function */
 215 {
 216   return PyObject_HasAttrString (obj, (char *) attr);
 217 }
 218
 219 #define PyObject_HasAttrString(obj, attr) gdb_PyObject_HasAttrString (obj, attr)
 220
 221 /* PyObject_CallMethod's 'method' and 'format' parameters were missing
 222    the 'const' qualifier before Python 3.4.  Hence, we wrap the
 223    function in our own version to avoid errors with string literals.
 224    Note, this is a variadic template because PyObject_CallMethod is a
 225    varargs function and Python doesn't have a "PyObject_VaCallMethod"
 226    variant taking a va_list that we could defer to instead.  */
 227
 228 template<typename... Args>
 229 static inline PyObject *
 230 gdb_PyObject_CallMethod (PyObject *o, const char *method, const char *format,
 231                          Args... args) /* ARI: editCase function */
 232 {
 233   return PyObject_CallMethod (o,
 234                               const_cast<char *> (method),
 235                               const_cast<char *> (format),
 236                               args...);
 237 }
 238
 239 #undef PyObject_CallMethod
 240 #define PyObject_CallMethod gdb_PyObject_CallMethod
 241
 242 /* The 'name' parameter of PyErr_NewException was missing the 'const'
 243    qualifier in Python <= 3.4.  Hence, we wrap it in a function to
 244    avoid errors when compiled with -Werror.  */
 245
 246 static inline PyObject*
 247 gdb_PyErr_NewException (const char *name, PyObject *base, PyObject *dict)
 248 {
 249   return PyErr_NewException (const_cast<char *> (name), base, dict);
 250 }
 251
 252 #define PyErr_NewException gdb_PyErr_NewException
 253
 254 /* PySys_GetObject's 'name' parameter was missing the 'const'
 255    qualifier before Python 3.4.  Hence, we wrap it in a function to
 256    avoid errors when compiled with -Werror.  */
 257
 258 static inline PyObject *
 259 gdb_PySys_GetObject (const char *name)
 260 {
 261   return PySys_GetObject (const_cast<char *> (name));
 262 }
 263
 264 #define PySys_GetObject gdb_PySys_GetObject
 265
 266 /* PySys_SetPath's 'path' parameter was missing the 'const' qualifier
 267    before Python 3.6.  Hence, we wrap it in a function to avoid errors
 268    when compiled with -Werror.  */
 269
 270 #ifdef IS_PY3K
 271 # define GDB_PYSYS_SETPATH_CHAR wchar_t
 272 #else
 273 # define GDB_PYSYS_SETPATH_CHAR char
 274 #endif
 275
 276 static inline void
 277 gdb_PySys_SetPath (const GDB_PYSYS_SETPATH_CHAR *path)
 278 {
 279   PySys_SetPath (const_cast<GDB_PYSYS_SETPATH_CHAR *> (path));
 280 }
 281
 282 #define PySys_SetPath gdb_PySys_SetPath
 283
 284 /* Wrap PyGetSetDef to allow convenient construction with string
 285    literals.  Unfortunately, PyGetSetDef's 'name' and 'doc' members
 286    are 'char *' instead of 'const char *', meaning that in order to
 287    list-initialize PyGetSetDef arrays with string literals (and
 288    without the wrapping below) would require writing explicit 'char *'
 289    casts.  Instead, we extend PyGetSetDef and add constexpr
 290    constructors that accept const 'name' and 'doc', hiding the ugly
 291    casts here in a single place.  */
 292
 293 struct gdb_PyGetSetDef : PyGetSetDef
 294 {
 295   constexpr gdb_PyGetSetDef (const char *name_, getter get_, setter set_,
 296                              const char *doc_, void *closure_)
 297     : PyGetSetDef {const_cast<char *> (name_), get_, set_,
 298                    const_cast<char *> (doc_), closure_}
 299   {}
 300
 301   /* Alternative constructor that allows omitting the closure in list
 302      initialization.  */
 303   constexpr gdb_PyGetSetDef (const char *name_, getter get_, setter set_,
 304                              const char *doc_)
 305     : gdb_PyGetSetDef {name_, get_, set_, doc_, NULL}
 306   {}
 307
 308   /* Constructor for the sentinel entries.  */
 309   constexpr gdb_PyGetSetDef (std::nullptr_t)
 310     : gdb_PyGetSetDef {NULL, NULL, NULL, NULL, NULL}
 311   {}
 312 };
 313
 314 /* The 'keywords' parameter of PyArg_ParseTupleAndKeywords has type
 315    'char **'.  However, string literals are const in C++, and so to
 316    avoid casting at every keyword array definition, we'll need to make
 317    the keywords array an array of 'const char *'.  To avoid having all
 318    callers add a 'const_cast<char **>' themselves when passing such an
 319    array through 'char **', we define our own version of
 320    PyArg_ParseTupleAndKeywords here with a corresponding 'keywords'
 321    parameter type that does the cast in a single place.  (This is not
 322    an overload of PyArg_ParseTupleAndKeywords in order to make it
 323    clearer that we're calling our own function instead of a function
 324    that exists in some newer Python version.)  */
 325
 326 static inline int
 327 gdb_PyArg_ParseTupleAndKeywords (PyObject *args, PyObject *kw,
 328                                  const char *format, const char **keywords, ...)
 329 {
 330   va_list ap;
 331   int res;
 332
 333   va_start (ap, keywords);
 334   res = PyArg_VaParseTupleAndKeywords (args, kw, format,
 335                                        const_cast<char **> (keywords),
 336                                        ap);
 337   va_end (ap);
 338
 339   return res;
 340 }
 341
 342 /* In order to be able to parse symtab_and_line_to_sal_object function
 343    a real symtab_and_line structure is needed.  */
 344 #include "symtab.h"
 345
 346 /* Also needed to parse enum var_types. */
 347 #include "command.h"
 348 #include "breakpoint.h"
 349
 350 enum gdbpy_iter_kind { iter_keys, iter_values, iter_items };
 351
 352 struct block;
 353 struct value;
 354 struct language_defn;
 355 struct program_space;
 356 struct bpstats;
 357 struct inferior;
 358
 359 extern int gdb_python_initialized;
 360
 361 extern PyObject *gdb_module;
 362 extern PyObject *gdb_python_module;
 363 extern PyTypeObject value_object_type
 364     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("value_object");
 365 extern PyTypeObject block_object_type
 366     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("block_object");
 367 extern PyTypeObject symbol_object_type
 368     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symbol_object");
 369 extern PyTypeObject event_object_type
 370     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object");
 371 extern PyTypeObject breakpoint_object_type
 372     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("breakpoint_object");
 373 extern PyTypeObject frame_object_type
 374     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("frame_object");
 375 extern PyTypeObject thread_object_type
 376     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("thread_object");
 377
 378 typedef struct gdbpy_breakpoint_object
 379 {
 380   PyObject_HEAD
 381
 382   /* The breakpoint number according to gdb.  */
 383   int number;
 384
 385   /* The gdb breakpoint object, or NULL if the breakpoint has been
 386      deleted.  */
 387   struct breakpoint *bp;
 388
 389   /* 1 is this is a FinishBreakpoint object, 0 otherwise.  */
 390   int is_finish_bp;
 391 } gdbpy_breakpoint_object;
 392
 393 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
 394    exception if it is invalid.  */
 395 #define BPPY_REQUIRE_VALID(Breakpoint)                                  \
 396     do {                                                                \
 397       if ((Breakpoint)->bp == NULL)                                     \
 398         return PyErr_Format (PyExc_RuntimeError,                        \
 399                              _("Breakpoint %d is invalid."),            \
 400                              (Breakpoint)->number);                     \
 401     } while (0)
 402
 403 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
 404    exception if it is invalid.  This macro is for use in setter functions.  */
 405 #define BPPY_SET_REQUIRE_VALID(Breakpoint)                              \
 406     do {                                                                \
 407       if ((Breakpoint)->bp == NULL)                                     \
 408         {                                                               \
 409           PyErr_Format (PyExc_RuntimeError, _("Breakpoint %d is invalid."), \
 410                         (Breakpoint)->number);                          \
 411           return -1;                                                    \
 412         }                                                               \
 413     } while (0)
 414
 415
 416 /* Variables used to pass information between the Breakpoint
 417    constructor and the breakpoint-created hook function.  */
 418 extern gdbpy_breakpoint_object *bppy_pending_object;
 419
 420
 421 typedef struct
 422 {
 423   PyObject_HEAD
 424
 425   /* The thread we represent.  */
 426   struct thread_info *thread;
 427
 428   /* The Inferior object to which this thread belongs.  */
 429   PyObject *inf_obj;
 430 } thread_object;
 431
 432 struct inferior_object;
 433
 434 extern struct cmd_list_element *set_python_list;
 435 extern struct cmd_list_element *show_python_list;
 436 \f
 437 /* extension_language_script_ops "methods".  */
 438
 439 extern int gdbpy_auto_load_enabled (const struct extension_language_defn *);
 440
 441 /* extension_language_ops "methods".  */
 442
 443 extern enum ext_lang_rc gdbpy_apply_val_pretty_printer
 444   (const struct extension_language_defn *,
 445    struct type *type,
 446    LONGEST embedded_offset, CORE_ADDR address,
 447    struct ui_file *stream, int recurse,
 448    struct value *val,
 449    const struct value_print_options *options,
 450    const struct language_defn *language);
 451 extern enum ext_lang_bt_status gdbpy_apply_frame_filter
 452   (const struct extension_language_defn *,
 453    struct frame_info *frame, frame_filter_flags flags,
 454    enum ext_lang_frame_args args_type,
 455    struct ui_out *out, int frame_low, int frame_high);
 456 extern void gdbpy_preserve_values (const struct extension_language_defn *,
 457                                    struct objfile *objfile,
 458                                    htab_t copied_types);
 459 extern enum ext_lang_bp_stop gdbpy_breakpoint_cond_says_stop
 460   (const struct extension_language_defn *, struct breakpoint *);
 461 extern int gdbpy_breakpoint_has_cond (const struct extension_language_defn *,
 462                                       struct breakpoint *b);
 463
 464 extern enum ext_lang_rc gdbpy_get_matching_xmethod_workers
 465   (const struct extension_language_defn *extlang,
 466    struct type *obj_type, const char *method_name,
 467    std::vector<xmethod_worker_up> *dm_vec);
 468
 469 \f
 470 PyObject *gdbpy_history (PyObject *self, PyObject *args);
 471 PyObject *gdbpy_convenience_variable (PyObject *self, PyObject *args);
 472 PyObject *gdbpy_set_convenience_variable (PyObject *self, PyObject *args);
 473 PyObject *gdbpy_breakpoints (PyObject *, PyObject *);
 474 PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *);
 475 PyObject *gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw);
 476 PyObject *gdbpy_lookup_global_symbol (PyObject *self, PyObject *args,
 477                                       PyObject *kw);
 478 PyObject *gdbpy_start_recording (PyObject *self, PyObject *args);
 479 PyObject *gdbpy_current_recording (PyObject *self, PyObject *args);
 480 PyObject *gdbpy_stop_recording (PyObject *self, PyObject *args);
 481 PyObject *gdbpy_newest_frame (PyObject *self, PyObject *args);
 482 PyObject *gdbpy_selected_frame (PyObject *self, PyObject *args);
 483 PyObject *gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw);
 484 int gdbpy_is_field (PyObject *obj);
 485 PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
 486                                            const char *encoding,
 487                                            struct type *type);
 488 PyObject *gdbpy_inferiors (PyObject *unused, PyObject *unused2);
 489 PyObject *gdbpy_create_ptid_object (ptid_t ptid);
 490 PyObject *gdbpy_selected_thread (PyObject *self, PyObject *args);
 491 PyObject *gdbpy_selected_inferior (PyObject *self, PyObject *args);
 492 PyObject *gdbpy_string_to_argv (PyObject *self, PyObject *args);
 493 PyObject *gdbpy_parameter_value (enum var_types type, void *var);
 494 char *gdbpy_parse_command_name (const char *name,
 495                                 struct cmd_list_element ***base_list,
 496                                 struct cmd_list_element **start_list);
 497
 498 PyObject *symtab_and_line_to_sal_object (struct symtab_and_line sal);
 499 PyObject *symtab_to_symtab_object (struct symtab *symtab);
 500 PyObject *symbol_to_symbol_object (struct symbol *sym);
 501 PyObject *block_to_block_object (const struct block *block,
 502                                  struct objfile *objfile);
 503 PyObject *value_to_value_object (struct value *v);
 504 PyObject *type_to_type_object (struct type *);
 505 PyObject *frame_info_to_frame_object (struct frame_info *frame);
 506 PyObject *symtab_to_linetable_object (PyObject *symtab);
 507 gdbpy_ref<> pspace_to_pspace_object (struct program_space *);
 508 PyObject *pspy_get_printers (PyObject *, void *);
 509 PyObject *pspy_get_frame_filters (PyObject *, void *);
 510 PyObject *pspy_get_frame_unwinders (PyObject *, void *);
 511 PyObject *pspy_get_xmethods (PyObject *, void *);
 512
 513 gdbpy_ref<> objfile_to_objfile_object (struct objfile *);
 514 PyObject *objfpy_get_printers (PyObject *, void *);
 515 PyObject *objfpy_get_frame_filters (PyObject *, void *);
 516 PyObject *objfpy_get_frame_unwinders (PyObject *, void *);
 517 PyObject *objfpy_get_xmethods (PyObject *, void *);
 518 PyObject *gdbpy_lookup_objfile (PyObject *self, PyObject *args, PyObject *kw);
 519
 520 PyObject *gdbarch_to_arch_object (struct gdbarch *gdbarch);
 521
 522 thread_object *create_thread_object (struct thread_info *tp);
 523 gdbpy_ref<> thread_to_thread_object (thread_info *thr);;
 524 inferior_object *inferior_to_inferior_object (inferior *inf);
 525
 526 const struct block *block_object_to_block (PyObject *obj);
 527 struct symbol *symbol_object_to_symbol (PyObject *obj);
 528 struct value *value_object_to_value (PyObject *self);
 529 struct value *convert_value_from_python (PyObject *obj);
 530 struct type *type_object_to_type (PyObject *obj);
 531 struct symtab *symtab_object_to_symtab (PyObject *obj);
 532 struct symtab_and_line *sal_object_to_symtab_and_line (PyObject *obj);
 533 struct frame_info *frame_object_to_frame_info (PyObject *frame_obj);
 534 struct gdbarch *arch_object_to_gdbarch (PyObject *obj);
 535
 536 void gdbpy_initialize_gdb_readline (void);
 537 int gdbpy_initialize_auto_load (void)
 538   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 539 int gdbpy_initialize_values (void)
 540   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 541 int gdbpy_initialize_frames (void)
 542   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 543 int gdbpy_initialize_instruction (void)
 544   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 545 int gdbpy_initialize_btrace (void)
 546   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 547 int gdbpy_initialize_record (void)
 548   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 549 int gdbpy_initialize_symtabs (void)
 550   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 551 int gdbpy_initialize_commands (void)
 552   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 553 int gdbpy_initialize_symbols (void)
 554   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 555 int gdbpy_initialize_symtabs (void)
 556   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 557 int gdbpy_initialize_blocks (void)
 558   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 559 int gdbpy_initialize_types (void)
 560   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 561 int gdbpy_initialize_functions (void)
 562   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 563 int gdbpy_initialize_pspace (void)
 564   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 565 int gdbpy_initialize_objfile (void)
 566   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 567 int gdbpy_initialize_breakpoints (void)
 568   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 569 int gdbpy_initialize_finishbreakpoints (void)
 570   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 571 int gdbpy_initialize_lazy_string (void)
 572   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 573 int gdbpy_initialize_linetable (void)
 574   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 575 int gdbpy_initialize_parameters (void)
 576   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 577 int gdbpy_initialize_thread (void)
 578   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 579 int gdbpy_initialize_inferior (void)
 580   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 581 int gdbpy_initialize_eventregistry (void)
 582   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 583 int gdbpy_initialize_event (void)
 584   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 585 int gdbpy_initialize_py_events (void)
 586   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 587 int gdbpy_initialize_arch (void)
 588   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 589 int gdbpy_initialize_xmethods (void)
 590   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 591 int gdbpy_initialize_unwind (void)
 592   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 593
 594 /* Called before entering the Python interpreter to install the
 595    current language and architecture to be used for Python values.
 596    Also set the active extension language for GDB so that SIGINT's
 597    are directed our way, and if necessary install the right SIGINT
 598    handler.  */
 599 class gdbpy_enter
 600 {
 601  public:
 602
 603   gdbpy_enter (struct gdbarch *gdbarch, const struct language_defn *language);
 604
 605   ~gdbpy_enter ();
 606
 607   DISABLE_COPY_AND_ASSIGN (gdbpy_enter);
 608
 609  private:
 610
 611   struct active_ext_lang_state *m_previous_active;
 612   PyGILState_STATE m_state;
 613   struct gdbarch *m_gdbarch;
 614   const struct language_defn *m_language;
 615   PyObject *m_error_type, *m_error_value, *m_error_traceback;
 616 };
 617
 618 /* Like gdbpy_enter, but takes a varobj.  This is a subclass just to
 619    make constructor delegation a little nicer.  */
 620 class gdbpy_enter_varobj : public gdbpy_enter
 621 {
 622  public:
 623
 624   /* This is defined in varobj.c, where it can access varobj
 625      internals.  */
 626   gdbpy_enter_varobj (const struct varobj *var);
 627
 628 };
 629
 630 extern struct gdbarch *python_gdbarch;
 631 extern const struct language_defn *python_language;
 632
 633 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 634    exception.  */
 635 #define GDB_PY_HANDLE_EXCEPTION(Exception)      \
 636   do {                                          \
 637     if (Exception.reason < 0)                   \
 638       {                                         \
 639         gdbpy_convert_exception (Exception);    \
 640         return NULL;                            \
 641       }                                         \
 642   } while (0)
 643
 644 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 645    exception.  This macro is for use inside setter functions.  */
 646 #define GDB_PY_SET_HANDLE_EXCEPTION(Exception)                          \
 647     do {                                                                \
 648       if (Exception.reason < 0)                                         \
 649         {                                                               \
 650           gdbpy_convert_exception (Exception);                          \
 651           return -1;                                                    \
 652         }                                                               \
 653     } while (0)
 654
 655 int gdbpy_print_python_errors_p (void);
 656 void gdbpy_print_stack (void);
 657 void gdbpy_print_stack_or_quit ();
 658 void gdbpy_handle_exception () ATTRIBUTE_NORETURN;
 659
 660 gdbpy_ref<> python_string_to_unicode (PyObject *obj);
 661 gdb::unique_xmalloc_ptr<char> unicode_to_target_string (PyObject *unicode_str);
 662 gdb::unique_xmalloc_ptr<char> python_string_to_target_string (PyObject *obj);
 663 gdbpy_ref<> python_string_to_target_python_string (PyObject *obj);
 664 gdb::unique_xmalloc_ptr<char> python_string_to_host_string (PyObject *obj);
 665 gdbpy_ref<> host_string_to_python_string (const char *str);
 666 int gdbpy_is_string (PyObject *obj);
 667 gdb::unique_xmalloc_ptr<char> gdbpy_obj_to_string (PyObject *obj);
 668 gdb::unique_xmalloc_ptr<char> gdbpy_exception_to_string (PyObject *ptype,
 669                                                          PyObject *pvalue);
 670
 671 int gdbpy_is_lazy_string (PyObject *result);
 672 void gdbpy_extract_lazy_string (PyObject *string, CORE_ADDR *addr,
 673                                 struct type **str_type,
 674                                 long *length,
 675                                 gdb::unique_xmalloc_ptr<char> *encoding);
 676
 677 int gdbpy_is_value_object (PyObject *obj);
 678
 679 /* Note that these are declared here, and not in python.h with the
 680    other pretty-printer functions, because they refer to PyObject.  */
 681 gdbpy_ref<> apply_varobj_pretty_printer (PyObject *print_obj,
 682                                          struct value **replacement,
 683                                          struct ui_file *stream);
 684 gdbpy_ref<> gdbpy_get_varobj_pretty_printer (struct value *value);
 685 gdb::unique_xmalloc_ptr<char> gdbpy_get_display_hint (PyObject *printer);
 686 PyObject *gdbpy_default_visualizer (PyObject *self, PyObject *args);
 687
 688 void bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 689 void bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 690
 691 extern PyObject *gdbpy_doc_cst;
 692 extern PyObject *gdbpy_children_cst;
 693 extern PyObject *gdbpy_to_string_cst;
 694 extern PyObject *gdbpy_display_hint_cst;
 695 extern PyObject *gdbpy_enabled_cst;
 696 extern PyObject *gdbpy_value_cst;
 697
 698 /* Exception types.  */
 699 extern PyObject *gdbpy_gdb_error;
 700 extern PyObject *gdbpy_gdb_memory_error;
 701 extern PyObject *gdbpy_gdberror_exc;
 702
 703 extern void gdbpy_convert_exception (struct gdb_exception)
 704     CPYCHECKER_SETS_EXCEPTION;
 705
 706 int get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
 707     CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 708
 709 gdbpy_ref<> gdb_py_object_from_longest (LONGEST l);
 710 gdbpy_ref<> gdb_py_object_from_ulongest (ULONGEST l);
 711 int gdb_py_int_as_long (PyObject *, long *);
 712
 713 PyObject *gdb_py_generic_dict (PyObject *self, void *closure);
 714
 715 int gdb_pymodule_addobject (PyObject *module, const char *name,
 716                             PyObject *object)
 717   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 718
 719 struct varobj_iter;
 720 struct varobj;
 721 struct varobj_iter *py_varobj_get_iterator (struct varobj *var,
 722                                             PyObject *printer);
 723
 724 #endif /* GDB_PYTHON_INTERNAL_H */