]> Git Repo - binutils.git/blob - gdb/python/python.c
d252646c02cfd4bde41582a7695402a8c7b49f5b
[binutils.git] / gdb / python / python.c
1 /* General python/gdb code
2
3    Copyright (C) 2008-2020 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include "command.h"
23 #include "ui-out.h"
24 #include "cli/cli-script.h"
25 #include "gdbcmd.h"
26 #include "progspace.h"
27 #include "objfiles.h"
28 #include "value.h"
29 #include "language.h"
30 #include "gdbsupport/event-loop.h"
31 #include "readline/tilde.h"
32 #include "python.h"
33 #include "extension-priv.h"
34 #include "cli/cli-utils.h"
35 #include <ctype.h>
36 #include "location.h"
37 #include "run-on-main-thread.h"
38
39 /* Declared constants and enum for python stack printing.  */
40 static const char python_excp_none[] = "none";
41 static const char python_excp_full[] = "full";
42 static const char python_excp_message[] = "message";
43
44 /* "set python print-stack" choices.  */
45 static const char *const python_excp_enums[] =
46   {
47     python_excp_none,
48     python_excp_full,
49     python_excp_message,
50     NULL
51   };
52
53 /* The exception printing variable.  'full' if we want to print the
54    error message and stack, 'none' if we want to print nothing, and
55    'message' if we only want to print the error message.  'message' is
56    the default.  */
57 static const char *gdbpy_should_print_stack = python_excp_message;
58
59 #ifdef HAVE_PYTHON
60 /* Forward decls, these are defined later.  */
61 extern const struct extension_language_script_ops python_extension_script_ops;
62 extern const struct extension_language_ops python_extension_ops;
63 #endif
64
65 /* The main struct describing GDB's interface to the Python
66    extension language.  */
67 const struct extension_language_defn extension_language_python =
68 {
69   EXT_LANG_PYTHON,
70   "python",
71   "Python",
72
73   ".py",
74   "-gdb.py",
75
76   python_control,
77
78 #ifdef HAVE_PYTHON
79   &python_extension_script_ops,
80   &python_extension_ops
81 #else
82   NULL,
83   NULL
84 #endif
85 };
86 \f
87 #ifdef HAVE_PYTHON
88
89 #include "cli/cli-decode.h"
90 #include "charset.h"
91 #include "top.h"
92 #include "python-internal.h"
93 #include "linespec.h"
94 #include "source.h"
95 #include "gdbsupport/version.h"
96 #include "target.h"
97 #include "gdbthread.h"
98 #include "interps.h"
99 #include "event-top.h"
100 #include "py-event.h"
101
102 /* True if Python has been successfully initialized, false
103    otherwise.  */
104
105 int gdb_python_initialized;
106
107 extern PyMethodDef python_GdbMethods[];
108
109 #ifdef IS_PY3K
110 extern struct PyModuleDef python_GdbModuleDef;
111 #endif
112
113 PyObject *gdb_module;
114 PyObject *gdb_python_module;
115
116 /* Some string constants we may wish to use.  */
117 PyObject *gdbpy_to_string_cst;
118 PyObject *gdbpy_children_cst;
119 PyObject *gdbpy_display_hint_cst;
120 PyObject *gdbpy_doc_cst;
121 PyObject *gdbpy_enabled_cst;
122 PyObject *gdbpy_value_cst;
123
124 /* The GdbError exception.  */
125 PyObject *gdbpy_gdberror_exc;
126
127 /* The `gdb.error' base class.  */
128 PyObject *gdbpy_gdb_error;
129
130 /* The `gdb.MemoryError' exception.  */
131 PyObject *gdbpy_gdb_memory_error;
132
133 static script_sourcer_func gdbpy_source_script;
134 static objfile_script_sourcer_func gdbpy_source_objfile_script;
135 static objfile_script_executor_func gdbpy_execute_objfile_script;
136 static void gdbpy_finish_initialization
137   (const struct extension_language_defn *);
138 static int gdbpy_initialized (const struct extension_language_defn *);
139 static void gdbpy_eval_from_control_command
140   (const struct extension_language_defn *, struct command_line *cmd);
141 static void gdbpy_start_type_printers (const struct extension_language_defn *,
142                                        struct ext_lang_type_printers *);
143 static enum ext_lang_rc gdbpy_apply_type_printers
144   (const struct extension_language_defn *,
145    const struct ext_lang_type_printers *, struct type *, char **);
146 static void gdbpy_free_type_printers (const struct extension_language_defn *,
147                                       struct ext_lang_type_printers *);
148 static void gdbpy_set_quit_flag (const struct extension_language_defn *);
149 static int gdbpy_check_quit_flag (const struct extension_language_defn *);
150 static enum ext_lang_rc gdbpy_before_prompt_hook
151   (const struct extension_language_defn *, const char *current_gdb_prompt);
152 static gdb::optional<std::string> gdbpy_colorize
153   (const std::string &filename, const std::string &contents);
154
155 /* The interface between gdb proper and loading of python scripts.  */
156
157 const struct extension_language_script_ops python_extension_script_ops =
158 {
159   gdbpy_source_script,
160   gdbpy_source_objfile_script,
161   gdbpy_execute_objfile_script,
162   gdbpy_auto_load_enabled
163 };
164
165 /* The interface between gdb proper and python extensions.  */
166
167 const struct extension_language_ops python_extension_ops =
168 {
169   gdbpy_finish_initialization,
170   gdbpy_initialized,
171
172   gdbpy_eval_from_control_command,
173
174   gdbpy_start_type_printers,
175   gdbpy_apply_type_printers,
176   gdbpy_free_type_printers,
177
178   gdbpy_apply_val_pretty_printer,
179
180   gdbpy_apply_frame_filter,
181
182   gdbpy_preserve_values,
183
184   gdbpy_breakpoint_has_cond,
185   gdbpy_breakpoint_cond_says_stop,
186
187   gdbpy_set_quit_flag,
188   gdbpy_check_quit_flag,
189
190   gdbpy_before_prompt_hook,
191
192   gdbpy_get_matching_xmethod_workers,
193
194   gdbpy_colorize,
195 };
196
197 /* Architecture and language to be used in callbacks from
198    the Python interpreter.  */
199 struct gdbarch *python_gdbarch;
200 const struct language_defn *python_language;
201
202 gdbpy_enter::gdbpy_enter  (struct gdbarch *gdbarch,
203                            const struct language_defn *language)
204 : m_gdbarch (python_gdbarch),
205   m_language (python_language)
206 {
207   /* We should not ever enter Python unless initialized.  */
208   if (!gdb_python_initialized)
209     error (_("Python not initialized"));
210
211   m_previous_active = set_active_ext_lang (&extension_language_python);
212
213   m_state = PyGILState_Ensure ();
214
215   python_gdbarch = gdbarch;
216   python_language = language;
217
218   /* Save it and ensure ! PyErr_Occurred () afterwards.  */
219   m_error.emplace ();
220 }
221
222 gdbpy_enter::~gdbpy_enter ()
223 {
224   /* Leftover Python error is forbidden by Python Exception Handling.  */
225   if (PyErr_Occurred ())
226     {
227       /* This order is similar to the one calling error afterwards. */
228       gdbpy_print_stack ();
229       warning (_("internal error: Unhandled Python exception"));
230     }
231
232   m_error->restore ();
233
234   python_gdbarch = m_gdbarch;
235   python_language = m_language;
236
237   restore_active_ext_lang (m_previous_active);
238   PyGILState_Release (m_state);
239 }
240
241 /* Set the quit flag.  */
242
243 static void
244 gdbpy_set_quit_flag (const struct extension_language_defn *extlang)
245 {
246   PyErr_SetInterrupt ();
247 }
248
249 /* Return true if the quit flag has been set, false otherwise.  */
250
251 static int
252 gdbpy_check_quit_flag (const struct extension_language_defn *extlang)
253 {
254   return PyOS_InterruptOccurred ();
255 }
256
257 /* Evaluate a Python command like PyRun_SimpleString, but uses
258    Py_single_input which prints the result of expressions, and does
259    not automatically print the stack on errors.  */
260
261 static int
262 eval_python_command (const char *command)
263 {
264   PyObject *m, *d;
265
266   m = PyImport_AddModule ("__main__");
267   if (m == NULL)
268     return -1;
269
270   d = PyModule_GetDict (m);
271   if (d == NULL)
272     return -1;
273   gdbpy_ref<> v (PyRun_StringFlags (command, Py_single_input, d, d, NULL));
274   if (v == NULL)
275     return -1;
276
277 #ifndef IS_PY3K
278   if (Py_FlushLine ())
279     PyErr_Clear ();
280 #endif
281
282   return 0;
283 }
284
285 /* Implementation of the gdb "python-interactive" command.  */
286
287 static void
288 python_interactive_command (const char *arg, int from_tty)
289 {
290   struct ui *ui = current_ui;
291   int err;
292
293   scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
294
295   arg = skip_spaces (arg);
296
297   gdbpy_enter enter_py (get_current_arch (), current_language);
298
299   if (arg && *arg)
300     {
301       std::string script = std::string (arg) + "\n";
302       err = eval_python_command (script.c_str ());
303     }
304   else
305     {
306       err = PyRun_InteractiveLoop (ui->instream, "<stdin>");
307       dont_repeat ();
308     }
309
310   if (err)
311     {
312       gdbpy_print_stack ();
313       error (_("Error while executing Python code."));
314     }
315 }
316
317 /* A wrapper around PyRun_SimpleFile.  FILE is the Python script to run
318    named FILENAME.
319
320    On Windows hosts few users would build Python themselves (this is no
321    trivial task on this platform), and thus use binaries built by
322    someone else instead.  There may happen situation where the Python
323    library and GDB are using two different versions of the C runtime
324    library.  Python, being built with VC, would use one version of the
325    msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
326    A FILE * from one runtime does not necessarily operate correctly in
327    the other runtime.
328
329    To work around this potential issue, we run code in Python to load
330    the script.  */
331
332 static void
333 python_run_simple_file (FILE *file, const char *filename)
334 {
335 #ifndef _WIN32
336
337   PyRun_SimpleFile (file, filename);
338
339 #else /* _WIN32 */
340
341   /* Because we have a string for a filename, and are using Python to
342      open the file, we need to expand any tilde in the path first.  */
343   gdb::unique_xmalloc_ptr<char> full_path (tilde_expand (filename));
344
345   if (gdb_python_module == nullptr
346       || ! PyObject_HasAttrString (gdb_python_module, "_execute_file"))
347     error (_("Installation error: gdb._execute_file function is missing"));
348
349   gdbpy_ref<> return_value
350     (PyObject_CallMethod (gdb_python_module, "_execute_file", "s",
351                           full_path.get ()));
352   if (return_value == nullptr)
353     {
354       /* Use PyErr_PrintEx instead of gdbpy_print_stack to better match the
355          behavior of the non-Windows codepath.  */
356       PyErr_PrintEx(0);
357     }
358
359 #endif /* _WIN32 */
360 }
361
362 /* Given a command_line, return a command string suitable for passing
363    to Python.  Lines in the string are separated by newlines.  */
364
365 static std::string
366 compute_python_string (struct command_line *l)
367 {
368   struct command_line *iter;
369   std::string script;
370
371   for (iter = l; iter; iter = iter->next)
372     {
373       script += iter->line;
374       script += '\n';
375     }
376   return script;
377 }
378
379 /* Take a command line structure representing a 'python' command, and
380    evaluate its body using the Python interpreter.  */
381
382 static void
383 gdbpy_eval_from_control_command (const struct extension_language_defn *extlang,
384                                  struct command_line *cmd)
385 {
386   int ret;
387
388   if (cmd->body_list_1 != nullptr)
389     error (_("Invalid \"python\" block structure."));
390
391   gdbpy_enter enter_py (get_current_arch (), current_language);
392
393   std::string script = compute_python_string (cmd->body_list_0.get ());
394   ret = PyRun_SimpleString (script.c_str ());
395   if (ret)
396     error (_("Error while executing Python code."));
397 }
398
399 /* Implementation of the gdb "python" command.  */
400
401 static void
402 python_command (const char *arg, int from_tty)
403 {
404   gdbpy_enter enter_py (get_current_arch (), current_language);
405
406   scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
407
408   arg = skip_spaces (arg);
409   if (arg && *arg)
410     {
411       if (PyRun_SimpleString (arg))
412         error (_("Error while executing Python code."));
413     }
414   else
415     {
416       counted_command_line l = get_command_line (python_control, "");
417
418       execute_control_command_untraced (l.get ());
419     }
420 }
421
422 \f
423
424 /* Transform a gdb parameters's value into a Python value.  May return
425    NULL (and set a Python exception) on error.  Helper function for
426    get_parameter.  */
427 PyObject *
428 gdbpy_parameter_value (enum var_types type, void *var)
429 {
430   switch (type)
431     {
432     case var_string:
433     case var_string_noescape:
434     case var_optional_filename:
435     case var_filename:
436     case var_enum:
437       {
438         const char *str = *(char **) var;
439
440         if (! str)
441           str = "";
442         return host_string_to_python_string (str).release ();
443       }
444
445     case var_boolean:
446       {
447         if (* (bool *) var)
448           Py_RETURN_TRUE;
449         else
450           Py_RETURN_FALSE;
451       }
452
453     case var_auto_boolean:
454       {
455         enum auto_boolean ab = * (enum auto_boolean *) var;
456
457         if (ab == AUTO_BOOLEAN_TRUE)
458           Py_RETURN_TRUE;
459         else if (ab == AUTO_BOOLEAN_FALSE)
460           Py_RETURN_FALSE;
461         else
462           Py_RETURN_NONE;
463       }
464
465     case var_integer:
466       if ((* (int *) var) == INT_MAX)
467         Py_RETURN_NONE;
468       /* Fall through.  */
469     case var_zinteger:
470     case var_zuinteger_unlimited:
471       return PyLong_FromLong (* (int *) var);
472
473     case var_uinteger:
474       {
475         unsigned int val = * (unsigned int *) var;
476
477         if (val == UINT_MAX)
478           Py_RETURN_NONE;
479         return PyLong_FromUnsignedLong (val);
480       }
481
482     case var_zuinteger:
483       {
484         unsigned int val = * (unsigned int *) var;
485         return PyLong_FromUnsignedLong (val);
486       }
487     }
488
489   return PyErr_Format (PyExc_RuntimeError,
490                        _("Programmer error: unhandled type."));
491 }
492
493 /* A Python function which returns a gdb parameter's value as a Python
494    value.  */
495
496 static PyObject *
497 gdbpy_parameter (PyObject *self, PyObject *args)
498 {
499   struct cmd_list_element *alias, *prefix, *cmd;
500   const char *arg;
501   int found = -1;
502
503   if (! PyArg_ParseTuple (args, "s", &arg))
504     return NULL;
505
506   std::string newarg = std::string ("show ") + arg;
507
508   try
509     {
510       found = lookup_cmd_composition (newarg.c_str (), &alias, &prefix, &cmd);
511     }
512   catch (const gdb_exception &ex)
513     {
514       GDB_PY_HANDLE_EXCEPTION (ex);
515     }
516
517   if (!found)
518     return PyErr_Format (PyExc_RuntimeError,
519                          _("Could not find parameter `%s'."), arg);
520
521   if (! cmd->var)
522     return PyErr_Format (PyExc_RuntimeError,
523                          _("`%s' is not a parameter."), arg);
524   return gdbpy_parameter_value (cmd->var_type, cmd->var);
525 }
526
527 /* Wrapper for target_charset.  */
528
529 static PyObject *
530 gdbpy_target_charset (PyObject *self, PyObject *args)
531 {
532   const char *cset = target_charset (python_gdbarch);
533
534   return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
535 }
536
537 /* Wrapper for target_wide_charset.  */
538
539 static PyObject *
540 gdbpy_target_wide_charset (PyObject *self, PyObject *args)
541 {
542   const char *cset = target_wide_charset (python_gdbarch);
543
544   return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
545 }
546
547 /* A Python function which evaluates a string using the gdb CLI.  */
548
549 static PyObject *
550 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
551 {
552   const char *arg;
553   PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
554   int from_tty, to_string;
555   static const char *keywords[] = { "command", "from_tty", "to_string", NULL };
556
557   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
558                                         &PyBool_Type, &from_tty_obj,
559                                         &PyBool_Type, &to_string_obj))
560     return NULL;
561
562   from_tty = 0;
563   if (from_tty_obj)
564     {
565       int cmp = PyObject_IsTrue (from_tty_obj);
566       if (cmp < 0)
567         return NULL;
568       from_tty = cmp;
569     }
570
571   to_string = 0;
572   if (to_string_obj)
573     {
574       int cmp = PyObject_IsTrue (to_string_obj);
575       if (cmp < 0)
576         return NULL;
577       to_string = cmp;
578     }
579
580   std::string to_string_res;
581
582   scoped_restore preventer = prevent_dont_repeat ();
583
584   try
585     {
586       gdbpy_allow_threads allow_threads;
587
588       struct interp *interp;
589
590       std::string arg_copy = arg;
591       bool first = true;
592       char *save_ptr = nullptr;
593       auto reader
594         = [&] ()
595           {
596             const char *result = strtok_r (first ? &arg_copy[0] : nullptr,
597                                            "\n", &save_ptr);
598             first = false;
599             return result;
600           };
601
602       counted_command_line lines = read_command_lines_1 (reader, 1, nullptr);
603
604       {
605         scoped_restore save_async = make_scoped_restore (&current_ui->async,
606                                                          0);
607
608         scoped_restore save_uiout = make_scoped_restore (&current_uiout);
609
610         /* Use the console interpreter uiout to have the same print format
611            for console or MI.  */
612         interp = interp_lookup (current_ui, "console");
613         current_uiout = interp->interp_ui_out ();
614
615         if (to_string)
616           to_string_res = execute_control_commands_to_string (lines.get (),
617                                                               from_tty);
618         else
619           execute_control_commands (lines.get (), from_tty);
620       }
621
622       /* Do any commands attached to breakpoint we stopped at.  */
623       bpstat_do_actions ();
624     }
625   catch (const gdb_exception &except)
626     {
627       /* If an exception occurred then we won't hit normal_stop (), or have
628          an exception reach the top level of the event loop, which are the
629          two usual places in which stdin would be re-enabled. So, before we
630          convert the exception and continue back in Python, we should
631          re-enable stdin here.  */
632       async_enable_stdin ();
633       GDB_PY_HANDLE_EXCEPTION (except);
634     }
635
636   if (to_string)
637     return PyString_FromString (to_string_res.c_str ());
638   Py_RETURN_NONE;
639 }
640
641 /* Implementation of Python rbreak command.  Take a REGEX and
642    optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
643    Python list that contains newly set breakpoints that match that
644    criteria.  REGEX refers to a GDB format standard regex pattern of
645    symbols names to search; MINSYMS is an optional boolean (default
646    False) that indicates if the function should search GDB's minimal
647    symbols; THROTTLE is an optional integer (default unlimited) that
648    indicates the maximum amount of breakpoints allowable before the
649    function exits (note, if the throttle bound is passed, no
650    breakpoints will be set and a runtime error returned); SYMTABS is
651    an optional Python iterable that contains a set of gdb.Symtabs to
652    constrain the search within.  */
653
654 static PyObject *
655 gdbpy_rbreak (PyObject *self, PyObject *args, PyObject *kw)
656 {
657   char *regex = NULL;
658   std::vector<symbol_search> symbols;
659   unsigned long count = 0;
660   PyObject *symtab_list = NULL;
661   PyObject *minsyms_p_obj = NULL;
662   int minsyms_p = 0;
663   unsigned int throttle = 0;
664   static const char *keywords[] = {"regex","minsyms", "throttle",
665                                    "symtabs", NULL};
666
667   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O!IO", keywords,
668                                         &regex, &PyBool_Type,
669                                         &minsyms_p_obj, &throttle,
670                                         &symtab_list))
671     return NULL;
672
673   /* Parse minsyms keyword.  */
674   if (minsyms_p_obj != NULL)
675     {
676       int cmp = PyObject_IsTrue (minsyms_p_obj);
677       if (cmp < 0)
678         return NULL;
679       minsyms_p = cmp;
680     }
681
682   global_symbol_searcher spec (FUNCTIONS_DOMAIN, regex);
683   SCOPE_EXIT {
684     for (const char *elem : spec.filenames)
685       xfree ((void *) elem);
686   };
687
688   /* The "symtabs" keyword is any Python iterable object that returns
689      a gdb.Symtab on each iteration.  If specified, iterate through
690      the provided gdb.Symtabs and extract their full path.  As
691      python_string_to_target_string returns a
692      gdb::unique_xmalloc_ptr<char> and a vector containing these types
693      cannot be coerced to a const char **p[] via the vector.data call,
694      release the value from the unique_xmalloc_ptr and place it in a
695      simple type symtab_list_type (which holds the vector and a
696      destructor that frees the contents of the allocated strings.  */
697   if (symtab_list != NULL)
698     {
699       gdbpy_ref<> iter (PyObject_GetIter (symtab_list));
700
701       if (iter == NULL)
702         return NULL;
703
704       while (true)
705         {
706           gdbpy_ref<> next (PyIter_Next (iter.get ()));
707
708           if (next == NULL)
709             {
710               if (PyErr_Occurred ())
711                 return NULL;
712               break;
713             }
714
715           gdbpy_ref<> obj_name (PyObject_GetAttrString (next.get (),
716                                                         "filename"));
717
718           if (obj_name == NULL)
719             return NULL;
720
721           /* Is the object file still valid?  */
722           if (obj_name == Py_None)
723             continue;
724
725           gdb::unique_xmalloc_ptr<char> filename =
726             python_string_to_target_string (obj_name.get ());
727
728           if (filename == NULL)
729             return NULL;
730
731           /* Make sure there is a definite place to store the value of
732              filename before it is released.  */
733           spec.filenames.push_back (nullptr);
734           spec.filenames.back () = filename.release ();
735         }
736     }
737
738   /* The search spec.  */
739   symbols = spec.search ();
740
741   /* Count the number of symbols (both symbols and optionally minimal
742      symbols) so we can correctly check the throttle limit.  */
743   for (const symbol_search &p : symbols)
744     {
745       /* Minimal symbols included?  */
746       if (minsyms_p)
747         {
748           if (p.msymbol.minsym != NULL)
749             count++;
750         }
751
752       if (p.symbol != NULL)
753         count++;
754     }
755
756   /* Check throttle bounds and exit if in excess.  */
757   if (throttle != 0 && count > throttle)
758     {
759       PyErr_SetString (PyExc_RuntimeError,
760                        _("Number of breakpoints exceeds throttled maximum."));
761       return NULL;
762     }
763
764   gdbpy_ref<> return_list (PyList_New (0));
765
766   if (return_list == NULL)
767     return NULL;
768
769   /* Construct full path names for symbols and call the Python
770      breakpoint constructor on the resulting names.  Be tolerant of
771      individual breakpoint failures.  */
772   for (const symbol_search &p : symbols)
773     {
774       std::string symbol_name;
775
776       /* Skipping minimal symbols?  */
777       if (minsyms_p == 0)
778         if (p.msymbol.minsym != NULL)
779           continue;
780
781       if (p.msymbol.minsym == NULL)
782         {
783           struct symtab *symtab = symbol_symtab (p.symbol);
784           const char *fullname = symtab_to_fullname (symtab);
785
786           symbol_name = fullname;
787           symbol_name  += ":";
788           symbol_name  += p.symbol->linkage_name ();
789         }
790       else
791         symbol_name = p.msymbol.minsym->linkage_name ();
792
793       gdbpy_ref<> argList (Py_BuildValue("(s)", symbol_name.c_str ()));
794       gdbpy_ref<> obj (PyObject_CallObject ((PyObject *)
795                                             &breakpoint_object_type,
796                                             argList.get ()));
797
798       /* Tolerate individual breakpoint failures.  */
799       if (obj == NULL)
800         gdbpy_print_stack ();
801       else
802         {
803           if (PyList_Append (return_list.get (), obj.get ()) == -1)
804             return NULL;
805         }
806     }
807   return return_list.release ();
808 }
809
810 /* A Python function which is a wrapper for decode_line_1.  */
811
812 static PyObject *
813 gdbpy_decode_line (PyObject *self, PyObject *args)
814 {
815   const char *arg = NULL;
816   gdbpy_ref<> result;
817   gdbpy_ref<> unparsed;
818   event_location_up location;
819
820   if (! PyArg_ParseTuple (args, "|s", &arg))
821     return NULL;
822
823   /* Treat a string consisting of just whitespace the same as
824      NULL.  */
825   if (arg != NULL)
826     {
827       arg = skip_spaces (arg);
828       if (*arg == '\0')
829         arg = NULL;
830     }
831
832   if (arg != NULL)
833     location = string_to_event_location_basic (&arg, python_language,
834                                                symbol_name_match_type::WILD);
835
836   std::vector<symtab_and_line> decoded_sals;
837   symtab_and_line def_sal;
838   gdb::array_view<symtab_and_line> sals;
839   try
840     {
841       if (location != NULL)
842         {
843           decoded_sals = decode_line_1 (location.get (), 0, NULL, NULL, 0);
844           sals = decoded_sals;
845         }
846       else
847         {
848           set_default_source_symtab_and_line ();
849           def_sal = get_current_source_symtab_and_line ();
850           sals = def_sal;
851         }
852     }
853   catch (const gdb_exception &ex)
854     {
855       /* We know this will always throw.  */
856       gdbpy_convert_exception (ex);
857       return NULL;
858     }
859
860   if (!sals.empty ())
861     {
862       result.reset (PyTuple_New (sals.size ()));
863       if (result == NULL)
864         return NULL;
865       for (size_t i = 0; i < sals.size (); ++i)
866         {
867           PyObject *obj = symtab_and_line_to_sal_object (sals[i]);
868           if (obj == NULL)
869             return NULL;
870
871           PyTuple_SetItem (result.get (), i, obj);
872         }
873     }
874   else
875     result = gdbpy_ref<>::new_reference (Py_None);
876
877   gdbpy_ref<> return_result (PyTuple_New (2));
878   if (return_result == NULL)
879     return NULL;
880
881   if (arg != NULL && strlen (arg) > 0)
882     {
883       unparsed.reset (PyString_FromString (arg));
884       if (unparsed == NULL)
885         return NULL;
886     }
887   else
888     unparsed = gdbpy_ref<>::new_reference (Py_None);
889
890   PyTuple_SetItem (return_result.get (), 0, unparsed.release ());
891   PyTuple_SetItem (return_result.get (), 1, result.release ());
892
893   return return_result.release ();
894 }
895
896 /* Parse a string and evaluate it as an expression.  */
897 static PyObject *
898 gdbpy_parse_and_eval (PyObject *self, PyObject *args)
899 {
900   const char *expr_str;
901   struct value *result = NULL;
902
903   if (!PyArg_ParseTuple (args, "s", &expr_str))
904     return NULL;
905
906   try
907     {
908       gdbpy_allow_threads allow_threads;
909       result = parse_and_eval (expr_str);
910     }
911   catch (const gdb_exception &except)
912     {
913       GDB_PY_HANDLE_EXCEPTION (except);
914     }
915
916   return value_to_value_object (result);
917 }
918
919 /* Implementation of gdb.invalidate_cached_frames.  */
920
921 static PyObject *
922 gdbpy_invalidate_cached_frames (PyObject *self, PyObject *args)
923 {
924   reinit_frame_cache ();
925   Py_RETURN_NONE;
926 }
927
928 /* Read a file as Python code.
929    This is the extension_language_script_ops.script_sourcer "method".
930    FILE is the file to load.  FILENAME is name of the file FILE.
931    This does not throw any errors.  If an exception occurs python will print
932    the traceback and clear the error indicator.  */
933
934 static void
935 gdbpy_source_script (const struct extension_language_defn *extlang,
936                      FILE *file, const char *filename)
937 {
938   gdbpy_enter enter_py (get_current_arch (), current_language);
939   python_run_simple_file (file, filename);
940 }
941
942 \f
943
944 /* Posting and handling events.  */
945
946 /* A helper class to save and restore the GIL, but without touching
947    the other globals that are handled by gdbpy_enter.  */
948
949 class gdbpy_gil
950 {
951 public:
952
953   gdbpy_gil ()
954     : m_state (PyGILState_Ensure ())
955   {
956   }
957
958   ~gdbpy_gil ()
959   {
960     PyGILState_Release (m_state);
961   }
962
963   DISABLE_COPY_AND_ASSIGN (gdbpy_gil);
964
965 private:
966
967   PyGILState_STATE m_state;
968 };
969
970 /* A single event.  */
971 struct gdbpy_event
972 {
973   gdbpy_event (gdbpy_ref<> &&func)
974     : m_func (func.release ())
975   {
976   }
977
978   gdbpy_event (gdbpy_event &&other)
979     : m_func (other.m_func)
980   {
981     other.m_func = nullptr;
982   }
983
984   gdbpy_event (const gdbpy_event &other)
985     : m_func (other.m_func)
986   {
987     gdbpy_gil gil;
988     Py_XINCREF (m_func);
989   }
990
991   ~gdbpy_event ()
992   {
993     gdbpy_gil gil;
994     Py_XDECREF (m_func);
995   }
996
997   gdbpy_event &operator= (const gdbpy_event &other) = delete;
998
999   void operator() ()
1000   {
1001     gdbpy_enter enter_py (get_current_arch (), current_language);
1002
1003     gdbpy_ref<> call_result (PyObject_CallObject (m_func, NULL));
1004     if (call_result == NULL)
1005       gdbpy_print_stack ();
1006   }
1007
1008 private:
1009
1010   /* The Python event.  This is just a callable object.  Note that
1011      this is not a gdbpy_ref<>, because we have to take particular
1012      care to only destroy the reference when holding the GIL. */
1013   PyObject *m_func;
1014 };
1015
1016 /* Submit an event to the gdb thread.  */
1017 static PyObject *
1018 gdbpy_post_event (PyObject *self, PyObject *args)
1019 {
1020   PyObject *func;
1021
1022   if (!PyArg_ParseTuple (args, "O", &func))
1023     return NULL;
1024
1025   if (!PyCallable_Check (func))
1026     {
1027       PyErr_SetString (PyExc_RuntimeError,
1028                        _("Posted event is not callable"));
1029       return NULL;
1030     }
1031
1032   gdbpy_ref<> func_ref = gdbpy_ref<>::new_reference (func);
1033   gdbpy_event event (std::move (func_ref));
1034   run_on_main_thread (event);
1035
1036   Py_RETURN_NONE;
1037 }
1038
1039 \f
1040
1041 /* This is the extension_language_ops.before_prompt "method".  */
1042
1043 static enum ext_lang_rc
1044 gdbpy_before_prompt_hook (const struct extension_language_defn *extlang,
1045                           const char *current_gdb_prompt)
1046 {
1047   if (!gdb_python_initialized)
1048     return EXT_LANG_RC_NOP;
1049
1050   gdbpy_enter enter_py (get_current_arch (), current_language);
1051
1052   if (!evregpy_no_listeners_p (gdb_py_events.before_prompt)
1053       && evpy_emit_event (NULL, gdb_py_events.before_prompt) < 0)
1054     return EXT_LANG_RC_ERROR;
1055
1056   if (gdb_python_module
1057       && PyObject_HasAttrString (gdb_python_module, "prompt_hook"))
1058     {
1059       gdbpy_ref<> hook (PyObject_GetAttrString (gdb_python_module,
1060                                                 "prompt_hook"));
1061       if (hook == NULL)
1062         {
1063           gdbpy_print_stack ();
1064           return EXT_LANG_RC_ERROR;
1065         }
1066
1067       if (PyCallable_Check (hook.get ()))
1068         {
1069           gdbpy_ref<> current_prompt (PyString_FromString (current_gdb_prompt));
1070           if (current_prompt == NULL)
1071             {
1072               gdbpy_print_stack ();
1073               return EXT_LANG_RC_ERROR;
1074             }
1075
1076           gdbpy_ref<> result
1077             (PyObject_CallFunctionObjArgs (hook.get (), current_prompt.get (),
1078                                            NULL));
1079           if (result == NULL)
1080             {
1081               gdbpy_print_stack ();
1082               return EXT_LANG_RC_ERROR;
1083             }
1084
1085           /* Return type should be None, or a String.  If it is None,
1086              fall through, we will not set a prompt.  If it is a
1087              string, set  PROMPT.  Anything else, set an exception.  */
1088           if (result != Py_None && ! PyString_Check (result.get ()))
1089             {
1090               PyErr_Format (PyExc_RuntimeError,
1091                             _("Return from prompt_hook must " \
1092                               "be either a Python string, or None"));
1093               gdbpy_print_stack ();
1094               return EXT_LANG_RC_ERROR;
1095             }
1096
1097           if (result != Py_None)
1098             {
1099               gdb::unique_xmalloc_ptr<char>
1100                 prompt (python_string_to_host_string (result.get ()));
1101
1102               if (prompt == NULL)
1103                 {
1104                   gdbpy_print_stack ();
1105                   return EXT_LANG_RC_ERROR;
1106                 }
1107
1108               set_prompt (prompt.get ());
1109               return EXT_LANG_RC_OK;
1110             }
1111         }
1112     }
1113
1114   return EXT_LANG_RC_NOP;
1115 }
1116
1117 /* This is the extension_language_ops.colorize "method".  */
1118
1119 static gdb::optional<std::string>
1120 gdbpy_colorize (const std::string &filename, const std::string &contents)
1121 {
1122   if (!gdb_python_initialized)
1123     return {};
1124
1125   gdbpy_enter enter_py (get_current_arch (), current_language);
1126
1127   if (gdb_python_module == nullptr
1128       || !PyObject_HasAttrString (gdb_python_module, "colorize"))
1129     return {};
1130
1131   gdbpy_ref<> hook (PyObject_GetAttrString (gdb_python_module, "colorize"));
1132   if (hook == nullptr)
1133     {
1134       gdbpy_print_stack ();
1135       return {};
1136     }
1137
1138   if (!PyCallable_Check (hook.get ()))
1139     return {};
1140
1141   gdbpy_ref<> fname_arg (PyString_FromString (filename.c_str ()));
1142   if (fname_arg == nullptr)
1143     {
1144       gdbpy_print_stack ();
1145       return {};
1146     }
1147   gdbpy_ref<> contents_arg (PyString_FromString (contents.c_str ()));
1148   if (contents_arg == nullptr)
1149     {
1150       gdbpy_print_stack ();
1151       return {};
1152     }
1153
1154   gdbpy_ref<> result (PyObject_CallFunctionObjArgs (hook.get (),
1155                                                     fname_arg.get (),
1156                                                     contents_arg.get (),
1157                                                     nullptr));
1158   if (result == nullptr)
1159     {
1160       gdbpy_print_stack ();
1161       return {};
1162     }
1163
1164   if (!gdbpy_is_string (result.get ()))
1165     return {};
1166
1167   gdbpy_ref<> unic = python_string_to_unicode (result.get ());
1168   if (unic == nullptr)
1169     {
1170       gdbpy_print_stack ();
1171       return {};
1172     }
1173   gdbpy_ref<> host_str (PyUnicode_AsEncodedString (unic.get (),
1174                                                    host_charset (),
1175                                                    nullptr));
1176   if (host_str == nullptr)
1177     {
1178       gdbpy_print_stack ();
1179       return {};
1180     }
1181
1182   return std::string (PyBytes_AsString (host_str.get ()));
1183 }
1184
1185 \f
1186
1187 /* Printing.  */
1188
1189 /* A python function to write a single string using gdb's filtered
1190    output stream .  The optional keyword STREAM can be used to write
1191    to a particular stream.  The default stream is to gdb_stdout.  */
1192
1193 static PyObject *
1194 gdbpy_write (PyObject *self, PyObject *args, PyObject *kw)
1195 {
1196   const char *arg;
1197   static const char *keywords[] = { "text", "stream", NULL };
1198   int stream_type = 0;
1199
1200   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
1201                                         &stream_type))
1202     return NULL;
1203
1204   try
1205     {
1206       switch (stream_type)
1207         {
1208         case 1:
1209           {
1210             fprintf_filtered (gdb_stderr, "%s", arg);
1211             break;
1212           }
1213         case 2:
1214           {
1215             fprintf_filtered (gdb_stdlog, "%s", arg);
1216             break;
1217           }
1218         default:
1219           fprintf_filtered (gdb_stdout, "%s", arg);
1220         }
1221     }
1222   catch (const gdb_exception &except)
1223     {
1224       GDB_PY_HANDLE_EXCEPTION (except);
1225     }
1226
1227   Py_RETURN_NONE;
1228 }
1229
1230 /* A python function to flush a gdb stream.  The optional keyword
1231    STREAM can be used to flush a particular stream.  The default stream
1232    is gdb_stdout.  */
1233
1234 static PyObject *
1235 gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw)
1236 {
1237   static const char *keywords[] = { "stream", NULL };
1238   int stream_type = 0;
1239
1240   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
1241                                         &stream_type))
1242     return NULL;
1243
1244   switch (stream_type)
1245     {
1246     case 1:
1247       {
1248         gdb_flush (gdb_stderr);
1249         break;
1250       }
1251     case 2:
1252       {
1253         gdb_flush (gdb_stdlog);
1254         break;
1255       }
1256     default:
1257       gdb_flush (gdb_stdout);
1258     }
1259
1260   Py_RETURN_NONE;
1261 }
1262
1263 /* Return non-zero if print-stack is not "none".  */
1264
1265 int
1266 gdbpy_print_python_errors_p (void)
1267 {
1268   return gdbpy_should_print_stack != python_excp_none;
1269 }
1270
1271 /* Print a python exception trace, print just a message, or print
1272    nothing and clear the python exception, depending on
1273    gdbpy_should_print_stack.  Only call this if a python exception is
1274    set.  */
1275 void
1276 gdbpy_print_stack (void)
1277 {
1278
1279   /* Print "none", just clear exception.  */
1280   if (gdbpy_should_print_stack == python_excp_none)
1281     {
1282       PyErr_Clear ();
1283     }
1284   /* Print "full" message and backtrace.  */
1285   else if (gdbpy_should_print_stack == python_excp_full)
1286     {
1287       PyErr_Print ();
1288       /* PyErr_Print doesn't necessarily end output with a newline.
1289          This works because Python's stdout/stderr is fed through
1290          printf_filtered.  */
1291       try
1292         {
1293           begin_line ();
1294         }
1295       catch (const gdb_exception &except)
1296         {
1297         }
1298     }
1299   /* Print "message", just error print message.  */
1300   else
1301     {
1302       gdbpy_err_fetch fetched_error;
1303
1304       gdb::unique_xmalloc_ptr<char> msg = fetched_error.to_string ();
1305       gdb::unique_xmalloc_ptr<char> type;
1306       /* Don't compute TYPE if MSG already indicates that there is an
1307          error.  */
1308       if (msg != NULL)
1309         type = fetched_error.type_to_string ();
1310
1311       try
1312         {
1313           if (msg == NULL || type == NULL)
1314             {
1315               /* An error occurred computing the string representation of the
1316                  error message.  */
1317               fprintf_filtered (gdb_stderr,
1318                                 _("Error occurred computing Python error" \
1319                                   "message.\n"));
1320               PyErr_Clear ();
1321             }
1322           else
1323             fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
1324                               type.get (), msg.get ());
1325         }
1326       catch (const gdb_exception &except)
1327         {
1328         }
1329     }
1330 }
1331
1332 /* Like gdbpy_print_stack, but if the exception is a
1333    KeyboardException, throw a gdb "quit" instead.  */
1334
1335 void
1336 gdbpy_print_stack_or_quit ()
1337 {
1338   if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt))
1339     {
1340       PyErr_Clear ();
1341       throw_quit ("Quit");
1342     }
1343   gdbpy_print_stack ();
1344 }
1345
1346 \f
1347
1348 /* Return a sequence holding all the Progspaces.  */
1349
1350 static PyObject *
1351 gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
1352 {
1353   struct program_space *ps;
1354
1355   gdbpy_ref<> list (PyList_New (0));
1356   if (list == NULL)
1357     return NULL;
1358
1359   ALL_PSPACES (ps)
1360   {
1361     gdbpy_ref<> item = pspace_to_pspace_object (ps);
1362
1363     if (item == NULL || PyList_Append (list.get (), item.get ()) == -1)
1364       return NULL;
1365   }
1366
1367   return list.release ();
1368 }
1369
1370 \f
1371
1372 /* The "current" objfile.  This is set when gdb detects that a new
1373    objfile has been loaded.  It is only set for the duration of a call to
1374    gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1375    at other times.  */
1376 static struct objfile *gdbpy_current_objfile;
1377
1378 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1379    as Python code.  This does not throw any errors.  If an exception
1380    occurs python will print the traceback and clear the error indicator.
1381    This is the extension_language_script_ops.objfile_script_sourcer
1382    "method".  */
1383
1384 static void
1385 gdbpy_source_objfile_script (const struct extension_language_defn *extlang,
1386                              struct objfile *objfile, FILE *file,
1387                              const char *filename)
1388 {
1389   if (!gdb_python_initialized)
1390     return;
1391
1392   gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
1393   gdbpy_current_objfile = objfile;
1394
1395   python_run_simple_file (file, filename);
1396
1397   gdbpy_current_objfile = NULL;
1398 }
1399
1400 /* Set the current objfile to OBJFILE and then execute SCRIPT
1401    as Python code.  This does not throw any errors.  If an exception
1402    occurs python will print the traceback and clear the error indicator.
1403    This is the extension_language_script_ops.objfile_script_executor
1404    "method".  */
1405
1406 static void
1407 gdbpy_execute_objfile_script (const struct extension_language_defn *extlang,
1408                               struct objfile *objfile, const char *name,
1409                               const char *script)
1410 {
1411   if (!gdb_python_initialized)
1412     return;
1413
1414   gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
1415   gdbpy_current_objfile = objfile;
1416
1417   PyRun_SimpleString (script);
1418
1419   gdbpy_current_objfile = NULL;
1420 }
1421
1422 /* Return the current Objfile, or None if there isn't one.  */
1423
1424 static PyObject *
1425 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
1426 {
1427   if (! gdbpy_current_objfile)
1428     Py_RETURN_NONE;
1429
1430   return objfile_to_objfile_object (gdbpy_current_objfile).release ();
1431 }
1432
1433 /* Compute the list of active python type printers and store them in
1434    EXT_PRINTERS->py_type_printers.  The product of this function is used by
1435    gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1436    This is the extension_language_ops.start_type_printers "method".  */
1437
1438 static void
1439 gdbpy_start_type_printers (const struct extension_language_defn *extlang,
1440                            struct ext_lang_type_printers *ext_printers)
1441 {
1442   PyObject *printers_obj = NULL;
1443
1444   if (!gdb_python_initialized)
1445     return;
1446
1447   gdbpy_enter enter_py (get_current_arch (), current_language);
1448
1449   gdbpy_ref<> type_module (PyImport_ImportModule ("gdb.types"));
1450   if (type_module == NULL)
1451     {
1452       gdbpy_print_stack ();
1453       return;
1454     }
1455
1456   gdbpy_ref<> func (PyObject_GetAttrString (type_module.get (),
1457                                             "get_type_recognizers"));
1458   if (func == NULL)
1459     {
1460       gdbpy_print_stack ();
1461       return;
1462     }
1463
1464   printers_obj = PyObject_CallFunctionObjArgs (func.get (), (char *) NULL);
1465   if (printers_obj == NULL)
1466     gdbpy_print_stack ();
1467   else
1468     ext_printers->py_type_printers = printers_obj;
1469 }
1470
1471 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1472    a newly allocated string holding the type's replacement name, and return
1473    EXT_LANG_RC_OK.  The caller is responsible for freeing the string.
1474    If there's a Python error return EXT_LANG_RC_ERROR.
1475    Otherwise, return EXT_LANG_RC_NOP.
1476    This is the extension_language_ops.apply_type_printers "method".  */
1477
1478 static enum ext_lang_rc
1479 gdbpy_apply_type_printers (const struct extension_language_defn *extlang,
1480                            const struct ext_lang_type_printers *ext_printers,
1481                            struct type *type, char **prettied_type)
1482 {
1483   PyObject *printers_obj = (PyObject *) ext_printers->py_type_printers;
1484   gdb::unique_xmalloc_ptr<char> result;
1485
1486   if (printers_obj == NULL)
1487     return EXT_LANG_RC_NOP;
1488
1489   if (!gdb_python_initialized)
1490     return EXT_LANG_RC_NOP;
1491
1492   gdbpy_enter enter_py (get_current_arch (), current_language);
1493
1494   gdbpy_ref<> type_obj (type_to_type_object (type));
1495   if (type_obj == NULL)
1496     {
1497       gdbpy_print_stack ();
1498       return EXT_LANG_RC_ERROR;
1499     }
1500
1501   gdbpy_ref<> type_module (PyImport_ImportModule ("gdb.types"));
1502   if (type_module == NULL)
1503     {
1504       gdbpy_print_stack ();
1505       return EXT_LANG_RC_ERROR;
1506     }
1507
1508   gdbpy_ref<> func (PyObject_GetAttrString (type_module.get (),
1509                                             "apply_type_recognizers"));
1510   if (func == NULL)
1511     {
1512       gdbpy_print_stack ();
1513       return EXT_LANG_RC_ERROR;
1514     }
1515
1516   gdbpy_ref<> result_obj (PyObject_CallFunctionObjArgs (func.get (),
1517                                                         printers_obj,
1518                                                         type_obj.get (),
1519                                                         (char *) NULL));
1520   if (result_obj == NULL)
1521     {
1522       gdbpy_print_stack ();
1523       return EXT_LANG_RC_ERROR;
1524     }
1525
1526   if (result_obj == Py_None)
1527     return EXT_LANG_RC_NOP;
1528
1529   result = python_string_to_host_string (result_obj.get ());
1530   if (result == NULL)
1531     {
1532       gdbpy_print_stack ();
1533       return EXT_LANG_RC_ERROR;
1534     }
1535
1536   *prettied_type = result.release ();
1537   return EXT_LANG_RC_OK;
1538 }
1539
1540 /* Free the result of start_type_printers.
1541    This is the extension_language_ops.free_type_printers "method".  */
1542
1543 static void
1544 gdbpy_free_type_printers (const struct extension_language_defn *extlang,
1545                           struct ext_lang_type_printers *ext_printers)
1546 {
1547   PyObject *printers = (PyObject *) ext_printers->py_type_printers;
1548
1549   if (printers == NULL)
1550     return;
1551
1552   if (!gdb_python_initialized)
1553     return;
1554
1555   gdbpy_enter enter_py (get_current_arch (), current_language);
1556   Py_DECREF (printers);
1557 }
1558
1559 #else /* HAVE_PYTHON */
1560
1561 /* Dummy implementation of the gdb "python-interactive" and "python"
1562    command. */
1563
1564 static void
1565 python_interactive_command (const char *arg, int from_tty)
1566 {
1567   arg = skip_spaces (arg);
1568   if (arg && *arg)
1569     error (_("Python scripting is not supported in this copy of GDB."));
1570   else
1571     {
1572       counted_command_line l = get_command_line (python_control, "");
1573
1574       execute_control_command_untraced (l.get ());
1575     }
1576 }
1577
1578 static void
1579 python_command (const char *arg, int from_tty)
1580 {
1581   python_interactive_command (arg, from_tty);
1582 }
1583
1584 #endif /* HAVE_PYTHON */
1585
1586 \f
1587
1588 /* Lists for 'set python' commands.  */
1589
1590 static struct cmd_list_element *user_set_python_list;
1591 static struct cmd_list_element *user_show_python_list;
1592
1593 /* Initialize the Python code.  */
1594
1595 #ifdef HAVE_PYTHON
1596
1597 /* This is installed as a final cleanup and cleans up the
1598    interpreter.  This lets Python's 'atexit' work.  */
1599
1600 static void
1601 finalize_python (void *ignore)
1602 {
1603   struct active_ext_lang_state *previous_active;
1604
1605   /* We don't use ensure_python_env here because if we ever ran the
1606      cleanup, gdb would crash -- because the cleanup calls into the
1607      Python interpreter, which we are about to destroy.  It seems
1608      clearer to make the needed calls explicitly here than to create a
1609      cleanup and then mysteriously discard it.  */
1610
1611   /* This is only called as a final cleanup so we can assume the active
1612      SIGINT handler is gdb's.  We still need to tell it to notify Python.  */
1613   previous_active = set_active_ext_lang (&extension_language_python);
1614
1615   (void) PyGILState_Ensure ();
1616   python_gdbarch = target_gdbarch ();
1617   python_language = current_language;
1618
1619   Py_Finalize ();
1620
1621   restore_active_ext_lang (previous_active);
1622 }
1623
1624 #ifdef IS_PY3K
1625 /* This is called via the PyImport_AppendInittab mechanism called
1626    during initialization, to make the built-in _gdb module known to
1627    Python.  */
1628 PyMODINIT_FUNC init__gdb_module (void);
1629 PyMODINIT_FUNC
1630 init__gdb_module (void)
1631 {
1632   return PyModule_Create (&python_GdbModuleDef);
1633 }
1634 #endif
1635
1636 static bool
1637 do_start_initialization ()
1638 {
1639 #ifdef IS_PY3K
1640   size_t progsize, count;
1641   /* Python documentation indicates that the memory given
1642      to Py_SetProgramName cannot be freed.  However, it seems that
1643      at least Python 3.7.4 Py_SetProgramName takes a copy of the
1644      given program_name.  Making progname_copy static and not release
1645      the memory avoids a leak report for Python versions that duplicate
1646      program_name, and respect the requirement of Py_SetProgramName
1647      for Python versions that do not duplicate program_name.  */
1648   static wchar_t *progname_copy;
1649 #endif
1650
1651 #ifdef WITH_PYTHON_PATH
1652   /* Work around problem where python gets confused about where it is,
1653      and then can't find its libraries, etc.
1654      NOTE: Python assumes the following layout:
1655      /foo/bin/python
1656      /foo/lib/pythonX.Y/...
1657      This must be done before calling Py_Initialize.  */
1658   gdb::unique_xmalloc_ptr<char> progname
1659     (concat (ldirname (python_libdir.c_str ()).c_str (), SLASH_STRING, "bin",
1660               SLASH_STRING, "python", (char *) NULL));
1661 #ifdef IS_PY3K
1662   std::string oldloc = setlocale (LC_ALL, NULL);
1663   setlocale (LC_ALL, "");
1664   progsize = strlen (progname.get ());
1665   progname_copy = XNEWVEC (wchar_t, progsize + 1);
1666   count = mbstowcs (progname_copy, progname.get (), progsize + 1);
1667   if (count == (size_t) -1)
1668     {
1669       fprintf (stderr, "Could not convert python path to string\n");
1670       return false;
1671     }
1672   setlocale (LC_ALL, oldloc.c_str ());
1673
1674   /* Note that Py_SetProgramName expects the string it is passed to
1675      remain alive for the duration of the program's execution, so
1676      it is not freed after this call.  */
1677   Py_SetProgramName (progname_copy);
1678
1679   /* Define _gdb as a built-in module.  */
1680   PyImport_AppendInittab ("_gdb", init__gdb_module);
1681 #else
1682   Py_SetProgramName (progname.release ());
1683 #endif
1684 #endif
1685
1686   Py_Initialize ();
1687 #if PY_VERSION_HEX < 0x03090000
1688   /* PyEval_InitThreads became deprecated in Python 3.9 and will
1689      be removed in Python 3.11.  Prior to Python 3.7, this call was
1690      required to initialize the GIL.  */
1691   PyEval_InitThreads ();
1692 #endif
1693
1694 #ifdef IS_PY3K
1695   gdb_module = PyImport_ImportModule ("_gdb");
1696 #else
1697   gdb_module = Py_InitModule ("_gdb", python_GdbMethods);
1698 #endif
1699   if (gdb_module == NULL)
1700     return false;
1701
1702   if (PyModule_AddStringConstant (gdb_module, "VERSION", version) < 0
1703       || PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", host_name) < 0
1704       || PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
1705                                      target_name) < 0)
1706     return false;
1707
1708   /* Add stream constants.  */
1709   if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0
1710       || PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0
1711       || PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0)
1712     return false;
1713
1714   gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
1715   if (gdbpy_gdb_error == NULL
1716       || gdb_pymodule_addobject (gdb_module, "error", gdbpy_gdb_error) < 0)
1717     return false;
1718
1719   gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
1720                                                gdbpy_gdb_error, NULL);
1721   if (gdbpy_gdb_memory_error == NULL
1722       || gdb_pymodule_addobject (gdb_module, "MemoryError",
1723                                  gdbpy_gdb_memory_error) < 0)
1724     return false;
1725
1726   gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
1727   if (gdbpy_gdberror_exc == NULL
1728       || gdb_pymodule_addobject (gdb_module, "GdbError",
1729                                  gdbpy_gdberror_exc) < 0)
1730     return false;
1731
1732   gdbpy_initialize_gdb_readline ();
1733
1734   if (gdbpy_initialize_auto_load () < 0
1735       || gdbpy_initialize_values () < 0
1736       || gdbpy_initialize_frames () < 0
1737       || gdbpy_initialize_commands () < 0
1738       || gdbpy_initialize_instruction () < 0
1739       || gdbpy_initialize_record () < 0
1740       || gdbpy_initialize_btrace () < 0
1741       || gdbpy_initialize_symbols () < 0
1742       || gdbpy_initialize_symtabs () < 0
1743       || gdbpy_initialize_blocks () < 0
1744       || gdbpy_initialize_functions () < 0
1745       || gdbpy_initialize_parameters () < 0
1746       || gdbpy_initialize_types () < 0
1747       || gdbpy_initialize_pspace () < 0
1748       || gdbpy_initialize_objfile () < 0
1749       || gdbpy_initialize_breakpoints () < 0
1750       || gdbpy_initialize_finishbreakpoints () < 0
1751       || gdbpy_initialize_lazy_string () < 0
1752       || gdbpy_initialize_linetable () < 0
1753       || gdbpy_initialize_thread () < 0
1754       || gdbpy_initialize_inferior () < 0
1755       || gdbpy_initialize_eventregistry () < 0
1756       || gdbpy_initialize_py_events () < 0
1757       || gdbpy_initialize_event () < 0
1758       || gdbpy_initialize_arch () < 0
1759       || gdbpy_initialize_xmethods () < 0
1760       || gdbpy_initialize_unwind () < 0
1761       || gdbpy_initialize_tui () < 0)
1762     return false;
1763
1764 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base)      \
1765   if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1766     return false;
1767 #include "py-event-types.def"
1768 #undef GDB_PY_DEFINE_EVENT_TYPE
1769
1770   gdbpy_to_string_cst = PyString_FromString ("to_string");
1771   if (gdbpy_to_string_cst == NULL)
1772     return false;
1773   gdbpy_children_cst = PyString_FromString ("children");
1774   if (gdbpy_children_cst == NULL)
1775     return false;
1776   gdbpy_display_hint_cst = PyString_FromString ("display_hint");
1777   if (gdbpy_display_hint_cst == NULL)
1778     return false;
1779   gdbpy_doc_cst = PyString_FromString ("__doc__");
1780   if (gdbpy_doc_cst == NULL)
1781     return false;
1782   gdbpy_enabled_cst = PyString_FromString ("enabled");
1783   if (gdbpy_enabled_cst == NULL)
1784     return false;
1785   gdbpy_value_cst = PyString_FromString ("value");
1786   if (gdbpy_value_cst == NULL)
1787     return false;
1788
1789   /* Release the GIL while gdb runs.  */
1790   PyThreadState_Swap (NULL);
1791   PyEval_ReleaseLock ();
1792
1793   make_final_cleanup (finalize_python, NULL);
1794
1795   /* Only set this when initialization has succeeded.  */
1796   gdb_python_initialized = 1;
1797   return true;
1798 }
1799
1800 #endif /* HAVE_PYTHON */
1801
1802 /* See python.h.  */
1803 cmd_list_element *python_cmd_element = nullptr;
1804
1805 void _initialize_python ();
1806 void
1807 _initialize_python ()
1808 {
1809   add_com ("python-interactive", class_obscure,
1810            python_interactive_command,
1811 #ifdef HAVE_PYTHON
1812            _("\
1813 Start an interactive Python prompt.\n\
1814 \n\
1815 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1816 prompt).\n\
1817 \n\
1818 Alternatively, a single-line Python command can be given as an\n\
1819 argument, and if the command is an expression, the result will be\n\
1820 printed.  For example:\n\
1821 \n\
1822     (gdb) python-interactive 2 + 3\n\
1823     5")
1824 #else /* HAVE_PYTHON */
1825            _("\
1826 Start a Python interactive prompt.\n\
1827 \n\
1828 Python scripting is not supported in this copy of GDB.\n\
1829 This command is only a placeholder.")
1830 #endif /* HAVE_PYTHON */
1831            );
1832   add_com_alias ("pi", "python-interactive", class_obscure, 1);
1833
1834   python_cmd_element = add_com ("python", class_obscure, python_command,
1835 #ifdef HAVE_PYTHON
1836            _("\
1837 Evaluate a Python command.\n\
1838 \n\
1839 The command can be given as an argument, for instance:\n\
1840 \n\
1841     python print (23)\n\
1842 \n\
1843 If no argument is given, the following lines are read and used\n\
1844 as the Python commands.  Type a line containing \"end\" to indicate\n\
1845 the end of the command.")
1846 #else /* HAVE_PYTHON */
1847            _("\
1848 Evaluate a Python command.\n\
1849 \n\
1850 Python scripting is not supported in this copy of GDB.\n\
1851 This command is only a placeholder.")
1852 #endif /* HAVE_PYTHON */
1853            );
1854   add_com_alias ("py", "python", class_obscure, 1);
1855
1856   /* Add set/show python print-stack.  */
1857   add_basic_prefix_cmd ("python", no_class,
1858                         _("Prefix command for python preference settings."),
1859                         &user_show_python_list, "show python ", 0,
1860                         &showlist);
1861
1862   add_show_prefix_cmd ("python", no_class,
1863                        _("Prefix command for python preference settings."),
1864                        &user_set_python_list, "set python ", 0,
1865                        &setlist);
1866
1867   add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums,
1868                         &gdbpy_should_print_stack, _("\
1869 Set mode for Python stack dump on error."), _("\
1870 Show the mode of Python stack printing on error."), _("\
1871 none  == no stack or message will be printed.\n\
1872 full == a message and a stack will be printed.\n\
1873 message == an error message without a stack will be printed."),
1874                         NULL, NULL,
1875                         &user_set_python_list,
1876                         &user_show_python_list);
1877
1878 #ifdef HAVE_PYTHON
1879   if (!do_start_initialization () && PyErr_Occurred ())
1880     gdbpy_print_stack ();
1881 #endif /* HAVE_PYTHON */
1882 }
1883
1884 #ifdef HAVE_PYTHON
1885
1886 /* Helper function for gdbpy_finish_initialization.  This does the
1887    work and then returns false if an error has occurred and must be
1888    displayed, or true on success.  */
1889
1890 static bool
1891 do_finish_initialization (const struct extension_language_defn *extlang)
1892 {
1893   PyObject *m;
1894   PyObject *sys_path;
1895
1896   /* Add the initial data-directory to sys.path.  */
1897
1898   std::string gdb_pythondir = (std::string (gdb_datadir) + SLASH_STRING
1899                                + "python");
1900
1901   sys_path = PySys_GetObject ("path");
1902
1903   /* If sys.path is not defined yet, define it first.  */
1904   if (!(sys_path && PyList_Check (sys_path)))
1905     {
1906 #ifdef IS_PY3K
1907       PySys_SetPath (L"");
1908 #else
1909       PySys_SetPath ("");
1910 #endif
1911       sys_path = PySys_GetObject ("path");
1912     }
1913   if (sys_path && PyList_Check (sys_path))
1914     {
1915       gdbpy_ref<> pythondir (PyString_FromString (gdb_pythondir.c_str ()));
1916       if (pythondir == NULL || PyList_Insert (sys_path, 0, pythondir.get ()))
1917         return false;
1918     }
1919   else
1920     return false;
1921
1922   /* Import the gdb module to finish the initialization, and
1923      add it to __main__ for convenience.  */
1924   m = PyImport_AddModule ("__main__");
1925   if (m == NULL)
1926     return false;
1927
1928   /* Keep the reference to gdb_python_module since it is in a global
1929      variable.  */
1930   gdb_python_module = PyImport_ImportModule ("gdb");
1931   if (gdb_python_module == NULL)
1932     {
1933       gdbpy_print_stack ();
1934       /* This is passed in one call to warning so that blank lines aren't
1935          inserted between each line of text.  */
1936       warning (_("\n"
1937                  "Could not load the Python gdb module from `%s'.\n"
1938                  "Limited Python support is available from the _gdb module.\n"
1939                  "Suggest passing --data-directory=/path/to/gdb/data-directory."),
1940                gdb_pythondir.c_str ());
1941       /* We return "success" here as we've already emitted the
1942          warning.  */
1943       return true;
1944     }
1945
1946   return gdb_pymodule_addobject (m, "gdb", gdb_python_module) >= 0;
1947 }
1948
1949 /* Perform the remaining python initializations.
1950    These must be done after GDB is at least mostly initialized.
1951    E.g., The "info pretty-printer" command needs the "info" prefix
1952    command installed.
1953    This is the extension_language_ops.finish_initialization "method".  */
1954
1955 static void
1956 gdbpy_finish_initialization (const struct extension_language_defn *extlang)
1957 {
1958   gdbpy_enter enter_py (get_current_arch (), current_language);
1959
1960   if (!do_finish_initialization (extlang))
1961     {
1962       gdbpy_print_stack ();
1963       warning (_("internal error: Unhandled Python exception"));
1964     }
1965 }
1966
1967 /* Return non-zero if Python has successfully initialized.
1968    This is the extension_languages_ops.initialized "method".  */
1969
1970 static int
1971 gdbpy_initialized (const struct extension_language_defn *extlang)
1972 {
1973   return gdb_python_initialized;
1974 }
1975
1976 #endif /* HAVE_PYTHON */
1977
1978 \f
1979
1980 #ifdef HAVE_PYTHON
1981
1982 PyMethodDef python_GdbMethods[] =
1983 {
1984   { "history", gdbpy_history, METH_VARARGS,
1985     "Get a value from history" },
1986   { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
1987     "execute (command [, from_tty] [, to_string]) -> [String]\n\
1988 Evaluate command, a string, as a gdb CLI command.  Optionally returns\n\
1989 a Python String containing the output of the command if to_string is\n\
1990 set to True." },
1991   { "parameter", gdbpy_parameter, METH_VARARGS,
1992     "Return a gdb parameter's value" },
1993
1994   { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
1995     "Return a tuple of all breakpoint objects" },
1996
1997   { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
1998     "Find the default visualizer for a Value." },
1999
2000   { "progspaces", gdbpy_progspaces, METH_NOARGS,
2001     "Return a sequence of all progspaces." },
2002
2003   { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
2004     "Return the current Objfile being loaded, or None." },
2005
2006   { "newest_frame", gdbpy_newest_frame, METH_NOARGS,
2007     "newest_frame () -> gdb.Frame.\n\
2008 Return the newest frame object." },
2009   { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
2010     "selected_frame () -> gdb.Frame.\n\
2011 Return the selected frame object." },
2012   { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
2013     "stop_reason_string (Integer) -> String.\n\
2014 Return a string explaining unwind stop reason." },
2015
2016   { "start_recording", gdbpy_start_recording, METH_VARARGS,
2017     "start_recording ([method] [, format]) -> gdb.Record.\n\
2018 Start recording with the given method.  If no method is given, will fall back\n\
2019 to the system default method.  If no format is given, will fall back to the\n\
2020 default format for the given method."},
2021   { "current_recording", gdbpy_current_recording, METH_NOARGS,
2022     "current_recording () -> gdb.Record.\n\
2023 Return current recording object." },
2024   { "stop_recording", gdbpy_stop_recording, METH_NOARGS,
2025     "stop_recording () -> None.\n\
2026 Stop current recording." },
2027
2028   { "lookup_type", (PyCFunction) gdbpy_lookup_type,
2029     METH_VARARGS | METH_KEYWORDS,
2030     "lookup_type (name [, block]) -> type\n\
2031 Return a Type corresponding to the given name." },
2032   { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
2033     METH_VARARGS | METH_KEYWORDS,
2034     "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2035 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2036 a boolean indicating if name is a field of the current implied argument\n\
2037 `this' (when the current language is object-oriented)." },
2038   { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol,
2039     METH_VARARGS | METH_KEYWORDS,
2040     "lookup_global_symbol (name [, domain]) -> symbol\n\
2041 Return the symbol corresponding to the given name (or None)." },
2042   { "lookup_static_symbol", (PyCFunction) gdbpy_lookup_static_symbol,
2043     METH_VARARGS | METH_KEYWORDS,
2044     "lookup_static_symbol (name [, domain]) -> symbol\n\
2045 Return the static-linkage symbol corresponding to the given name (or None)." },
2046   { "lookup_static_symbols", (PyCFunction) gdbpy_lookup_static_symbols,
2047     METH_VARARGS | METH_KEYWORDS,
2048     "lookup_static_symbols (name [, domain]) -> symbol\n\
2049 Return a list of all static-linkage symbols corresponding to the given name." },
2050
2051   { "lookup_objfile", (PyCFunction) gdbpy_lookup_objfile,
2052     METH_VARARGS | METH_KEYWORDS,
2053     "lookup_objfile (name, [by_build_id]) -> objfile\n\
2054 Look up the specified objfile.\n\
2055 If by_build_id is True, the objfile is looked up by using name\n\
2056 as its build id." },
2057
2058   { "decode_line", gdbpy_decode_line, METH_VARARGS,
2059     "decode_line (String) -> Tuple.  Decode a string argument the way\n\
2060 that 'break' or 'edit' does.  Return a tuple containing two elements.\n\
2061 The first element contains any unparsed portion of the String parameter\n\
2062 (or None if the string was fully parsed).  The second element contains\n\
2063 a tuple that contains all the locations that match, represented as\n\
2064 gdb.Symtab_and_line objects (or None)."},
2065   { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
2066     "parse_and_eval (String) -> Value.\n\
2067 Parse String as an expression, evaluate it, and return the result as a Value."
2068   },
2069
2070   { "post_event", gdbpy_post_event, METH_VARARGS,
2071     "Post an event into gdb's event loop." },
2072
2073   { "target_charset", gdbpy_target_charset, METH_NOARGS,
2074     "target_charset () -> string.\n\
2075 Return the name of the current target charset." },
2076   { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
2077     "target_wide_charset () -> string.\n\
2078 Return the name of the current target wide charset." },
2079   { "rbreak", (PyCFunction) gdbpy_rbreak, METH_VARARGS | METH_KEYWORDS,
2080     "rbreak (Regex) -> List.\n\
2081 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2082   { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS,
2083     "string_to_argv (String) -> Array.\n\
2084 Parse String and return an argv-like array.\n\
2085 Arguments are separate by spaces and may be quoted."
2086   },
2087   { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS,
2088     "Write a string using gdb's filtered stream." },
2089   { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS,
2090     "Flush gdb's filtered stdout stream." },
2091   { "selected_thread", gdbpy_selected_thread, METH_NOARGS,
2092     "selected_thread () -> gdb.InferiorThread.\n\
2093 Return the selected thread object." },
2094   { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS,
2095     "selected_inferior () -> gdb.Inferior.\n\
2096 Return the selected inferior object." },
2097   { "inferiors", gdbpy_inferiors, METH_NOARGS,
2098     "inferiors () -> (gdb.Inferior, ...).\n\
2099 Return a tuple containing all inferiors." },
2100
2101   { "invalidate_cached_frames", gdbpy_invalidate_cached_frames, METH_NOARGS,
2102     "invalidate_cached_frames () -> None.\n\
2103 Invalidate any cached frame objects in gdb.\n\
2104 Intended for internal use only." },
2105
2106   { "convenience_variable", gdbpy_convenience_variable, METH_VARARGS,
2107     "convenience_variable (NAME) -> value.\n\
2108 Return the value of the convenience variable $NAME,\n\
2109 or None if not set." },
2110   { "set_convenience_variable", gdbpy_set_convenience_variable, METH_VARARGS,
2111     "convenience_variable (NAME, VALUE) -> None.\n\
2112 Set the value of the convenience variable $NAME." },
2113
2114 #ifdef TUI
2115   { "register_window_type", (PyCFunction) gdbpy_register_tui_window,
2116     METH_VARARGS | METH_KEYWORDS,
2117     "register_window_type (NAME, CONSTRUCSTOR) -> None\n\
2118 Register a TUI window constructor." },
2119 #endif  /* TUI */
2120
2121   {NULL, NULL, 0, NULL}
2122 };
2123
2124 #ifdef IS_PY3K
2125 struct PyModuleDef python_GdbModuleDef =
2126 {
2127   PyModuleDef_HEAD_INIT,
2128   "_gdb",
2129   NULL,
2130   -1,
2131   python_GdbMethods,
2132   NULL,
2133   NULL,
2134   NULL,
2135   NULL
2136 };
2137 #endif
2138
2139 /* Define all the event objects.  */
2140 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2141   PyTypeObject name##_event_object_type             \
2142         CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2143     = { \
2144       PyVarObject_HEAD_INIT (NULL, 0)                           \
2145       "gdb." py_name,                             /* tp_name */ \
2146       sizeof (event_object),                      /* tp_basicsize */ \
2147       0,                                          /* tp_itemsize */ \
2148       evpy_dealloc,                               /* tp_dealloc */ \
2149       0,                                          /* tp_print */ \
2150       0,                                          /* tp_getattr */ \
2151       0,                                          /* tp_setattr */ \
2152       0,                                          /* tp_compare */ \
2153       0,                                          /* tp_repr */ \
2154       0,                                          /* tp_as_number */ \
2155       0,                                          /* tp_as_sequence */ \
2156       0,                                          /* tp_as_mapping */ \
2157       0,                                          /* tp_hash  */ \
2158       0,                                          /* tp_call */ \
2159       0,                                          /* tp_str */ \
2160       0,                                          /* tp_getattro */ \
2161       0,                                          /* tp_setattro */ \
2162       0,                                          /* tp_as_buffer */ \
2163       Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,   /* tp_flags */ \
2164       doc,                                        /* tp_doc */ \
2165       0,                                          /* tp_traverse */ \
2166       0,                                          /* tp_clear */ \
2167       0,                                          /* tp_richcompare */ \
2168       0,                                          /* tp_weaklistoffset */ \
2169       0,                                          /* tp_iter */ \
2170       0,                                          /* tp_iternext */ \
2171       0,                                          /* tp_methods */ \
2172       0,                                          /* tp_members */ \
2173       0,                                          /* tp_getset */ \
2174       &base,                                      /* tp_base */ \
2175       0,                                          /* tp_dict */ \
2176       0,                                          /* tp_descr_get */ \
2177       0,                                          /* tp_descr_set */ \
2178       0,                                          /* tp_dictoffset */ \
2179       0,                                          /* tp_init */ \
2180       0                                           /* tp_alloc */ \
2181     };
2182 #include "py-event-types.def"
2183 #undef GDB_PY_DEFINE_EVENT_TYPE
2184
2185 #endif /* HAVE_PYTHON */
This page took 0.138705 seconds and 2 git commands to generate.