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