1 /* General python/gdb code
3 Copyright (C) 2008-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
24 #include "cli/cli-script.h"
26 #include "progspace.h"
30 #include "event-loop.h"
32 #include "readline/tilde.h"
34 #include "extension-priv.h"
35 #include "cli/cli-utils.h"
38 #include "ser-event.h"
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";
45 /* "set python print-stack" choices. */
46 static const char *const python_excp_enums
[] =
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
58 static const char *gdbpy_should_print_stack
= python_excp_message
;
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
;
66 /* The main struct describing GDB's interface to the Python
67 extension language. */
68 const struct extension_language_defn extension_language_python
=
80 &python_extension_script_ops
,
90 #include "cli/cli-decode.h"
94 #include "python-internal.h"
99 #include "gdbthread.h"
101 #include "event-top.h"
103 #include "py-event.h"
105 /* True if Python has been successfully initialized, false
108 int gdb_python_initialized
;
110 extern PyMethodDef python_GdbMethods
[];
113 extern struct PyModuleDef python_GdbModuleDef
;
116 PyObject
*gdb_module
;
117 PyObject
*gdb_python_module
;
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
;
127 /* The GdbError exception. */
128 PyObject
*gdbpy_gdberror_exc
;
130 /* The `gdb.error' base class. */
131 PyObject
*gdbpy_gdb_error
;
133 /* The `gdb.MemoryError' exception. */
134 PyObject
*gdbpy_gdb_memory_error
;
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
);
156 /* The interface between gdb proper and loading of python scripts. */
158 const struct extension_language_script_ops python_extension_script_ops
=
161 gdbpy_source_objfile_script
,
162 gdbpy_execute_objfile_script
,
163 gdbpy_auto_load_enabled
166 /* The interface between gdb proper and python extensions. */
168 const struct extension_language_ops python_extension_ops
=
170 gdbpy_finish_initialization
,
173 gdbpy_eval_from_control_command
,
175 gdbpy_start_type_printers
,
176 gdbpy_apply_type_printers
,
177 gdbpy_free_type_printers
,
179 gdbpy_apply_val_pretty_printer
,
181 gdbpy_apply_frame_filter
,
183 gdbpy_preserve_values
,
185 gdbpy_breakpoint_has_cond
,
186 gdbpy_breakpoint_cond_says_stop
,
189 gdbpy_check_quit_flag
,
191 gdbpy_before_prompt_hook
,
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
,
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
;
206 gdbpy_enter::gdbpy_enter (struct gdbarch
*gdbarch
,
207 const struct language_defn
*language
)
208 : m_gdbarch (python_gdbarch
),
209 m_language (python_language
)
211 /* We should not ever enter Python unless initialized. */
212 if (!gdb_python_initialized
)
213 error (_("Python not initialized"));
215 m_previous_active
= set_active_ext_lang (&extension_language_python
);
217 m_state
= PyGILState_Ensure ();
219 python_gdbarch
= gdbarch
;
220 python_language
= language
;
222 /* Save it and ensure ! PyErr_Occurred () afterwards. */
223 PyErr_Fetch (&m_error_type
, &m_error_value
, &m_error_traceback
);
226 gdbpy_enter::~gdbpy_enter ()
228 /* Leftover Python error is forbidden by Python Exception Handling. */
229 if (PyErr_Occurred ())
231 /* This order is similar to the one calling error afterwards. */
232 gdbpy_print_stack ();
233 warning (_("internal error: Unhandled Python exception"));
236 PyErr_Restore (m_error_type
, m_error_value
, m_error_traceback
);
238 PyGILState_Release (m_state
);
239 python_gdbarch
= m_gdbarch
;
240 python_language
= m_language
;
242 restore_active_ext_lang (m_previous_active
);
245 /* Set the quit flag. */
248 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
250 PyErr_SetInterrupt ();
253 /* Return true if the quit flag has been set, false otherwise. */
256 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
258 return PyOS_InterruptOccurred ();
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. */
266 eval_python_command (const char *command
)
270 m
= PyImport_AddModule ("__main__");
274 d
= PyModule_GetDict (m
);
277 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
289 /* Implementation of the gdb "python-interactive" command. */
292 python_interactive_command (char *arg
, int from_tty
)
294 struct ui
*ui
= current_ui
;
297 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
299 arg
= skip_spaces (arg
);
301 gdbpy_enter
enter_py (get_current_arch (), current_language
);
305 int len
= strlen (arg
);
306 char *script
= (char *) xmalloc (len
+ 2);
308 strcpy (script
, arg
);
310 script
[len
+ 1] = '\0';
311 err
= eval_python_command (script
);
316 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
322 gdbpy_print_stack ();
323 error (_("Error while executing Python code."));
327 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
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
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. */
344 python_run_simple_file (FILE *file
, const char *filename
)
348 PyRun_SimpleFile (file
, filename
);
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
)
358 gdbpy_print_stack ();
359 error (_("Error while opening file: %s"), full_path
.get ());
362 PyRun_SimpleFile (PyFile_AsFile (python_file
.get ()), filename
);
367 /* Given a command_line, return a command string suitable for passing
368 to Python. Lines in the string are separated by newlines. The
369 return value is allocated using xmalloc and the caller is
370 responsible for freeing it. */
373 compute_python_string (struct command_line
*l
)
375 struct command_line
*iter
;
380 for (iter
= l
; iter
; iter
= iter
->next
)
381 size
+= strlen (iter
->line
) + 1;
383 script
= (char *) xmalloc (size
+ 1);
385 for (iter
= l
; iter
; iter
= iter
->next
)
387 int len
= strlen (iter
->line
);
389 strcpy (&script
[here
], iter
->line
);
391 script
[here
++] = '\n';
397 /* Take a command line structure representing a 'python' command, and
398 evaluate its body using the Python interpreter. */
401 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
402 struct command_line
*cmd
)
407 if (cmd
->body_count
!= 1)
408 error (_("Invalid \"python\" block structure."));
410 gdbpy_enter
enter_py (get_current_arch (), current_language
);
412 script
= compute_python_string (cmd
->body_list
[0]);
413 ret
= PyRun_SimpleString (script
);
416 error (_("Error while executing Python code."));
419 /* Implementation of the gdb "python" command. */
422 python_command (char *arg
, int from_tty
)
424 gdbpy_enter
enter_py (get_current_arch (), current_language
);
426 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
428 arg
= skip_spaces (arg
);
431 if (PyRun_SimpleString (arg
))
432 error (_("Error while executing Python code."));
436 struct command_line
*l
= get_command_line (python_control
, "");
437 struct cleanup
*cleanup
= make_cleanup_free_command_lines (&l
);
439 execute_control_command_untraced (l
);
440 do_cleanups (cleanup
);
446 /* Transform a gdb parameters's value into a Python value. May return
447 NULL (and set a Python exception) on error. Helper function for
450 gdbpy_parameter_value (enum var_types type
, void *var
)
455 case var_string_noescape
:
456 case var_optional_filename
:
460 const char *str
= *(char **) var
;
464 return host_string_to_python_string (str
);
475 case var_auto_boolean
:
477 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
479 if (ab
== AUTO_BOOLEAN_TRUE
)
481 else if (ab
== AUTO_BOOLEAN_FALSE
)
488 if ((* (int *) var
) == INT_MAX
)
492 return PyLong_FromLong (* (int *) var
);
496 unsigned int val
= * (unsigned int *) var
;
500 return PyLong_FromUnsignedLong (val
);
504 return PyErr_Format (PyExc_RuntimeError
,
505 _("Programmer error: unhandled type."));
508 /* A Python function which returns a gdb parameter's value as a Python
512 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
514 struct gdb_exception except
= exception_none
;
515 struct cmd_list_element
*alias
, *prefix
, *cmd
;
520 if (! PyArg_ParseTuple (args
, "s", &arg
))
523 newarg
= concat ("show ", arg
, (char *) NULL
);
527 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
529 CATCH (ex
, RETURN_MASK_ALL
)
536 GDB_PY_HANDLE_EXCEPTION (except
);
538 return PyErr_Format (PyExc_RuntimeError
,
539 _("Could not find parameter `%s'."), arg
);
542 return PyErr_Format (PyExc_RuntimeError
,
543 _("`%s' is not a parameter."), arg
);
544 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
547 /* Wrapper for target_charset. */
550 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
552 const char *cset
= target_charset (python_gdbarch
);
554 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
557 /* Wrapper for target_wide_charset. */
560 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
562 const char *cset
= target_wide_charset (python_gdbarch
);
564 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
567 /* A Python function which evaluates a string using the gdb CLI. */
570 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
573 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
574 int from_tty
, to_string
;
575 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
577 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
578 &PyBool_Type
, &from_tty_obj
,
579 &PyBool_Type
, &to_string_obj
))
585 int cmp
= PyObject_IsTrue (from_tty_obj
);
594 int cmp
= PyObject_IsTrue (to_string_obj
);
600 std::string to_string_res
;
604 /* Copy the argument text in case the command modifies it. */
605 std::string
copy (arg
);
606 struct interp
*interp
;
608 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
610 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
612 /* Use the console interpreter uiout to have the same print format
613 for console or MI. */
614 interp
= interp_lookup (current_ui
, "console");
615 current_uiout
= interp_ui_out (interp
);
617 scoped_restore preventer
= prevent_dont_repeat ();
619 to_string_res
= execute_command_to_string (©
[0], from_tty
);
621 execute_command (©
[0], from_tty
);
623 CATCH (except
, RETURN_MASK_ALL
)
625 GDB_PY_HANDLE_EXCEPTION (except
);
629 /* Do any commands attached to breakpoint we stopped at. */
630 bpstat_do_actions ();
633 return PyString_FromString (to_string_res
.c_str ());
637 /* Implementation of gdb.solib_name (Long) -> String.
638 Returns the name of the shared library holding a given address, or None. */
641 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
647 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
650 soname
= solib_name_from_address (current_program_space
, pc
);
652 str_obj
= host_string_to_python_string (soname
);
662 /* A Python function which is a wrapper for decode_line_1. */
665 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
667 struct gdb_exception except
= exception_none
;
668 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
670 struct symtab_and_line sal
;
672 struct cleanup
*cleanups
;
674 gdbpy_ref
<> unparsed
;
675 event_location_up location
;
677 if (! PyArg_ParseTuple (args
, "|s", &arg
))
680 cleanups
= make_cleanup (null_cleanup
, NULL
);
685 location
= string_to_event_location_basic (&arg
, python_language
);
689 if (location
!= NULL
)
690 sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
693 set_default_source_symtab_and_line ();
694 sal
= get_current_source_symtab_and_line ();
699 CATCH (ex
, RETURN_MASK_ALL
)
705 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
706 make_cleanup (xfree
, sals
.sals
);
708 if (except
.reason
< 0)
710 do_cleanups (cleanups
);
711 /* We know this will always throw. */
712 gdbpy_convert_exception (except
);
720 result
.reset (PyTuple_New (sals
.nelts
));
723 do_cleanups (cleanups
);
726 for (i
= 0; i
< sals
.nelts
; ++i
)
730 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
733 do_cleanups (cleanups
);
737 PyTuple_SetItem (result
.get (), i
, obj
);
742 result
.reset (Py_None
);
746 gdbpy_ref
<> return_result (PyTuple_New (2));
747 if (return_result
== NULL
)
749 do_cleanups (cleanups
);
753 if (arg
!= NULL
&& strlen (arg
) > 0)
755 unparsed
.reset (PyString_FromString (arg
));
756 if (unparsed
== NULL
)
758 do_cleanups (cleanups
);
764 unparsed
.reset (Py_None
);
768 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
769 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
771 do_cleanups (cleanups
);
773 return return_result
.release ();
776 /* Parse a string and evaluate it as an expression. */
778 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
780 const char *expr_str
;
781 struct value
*result
= NULL
;
783 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
788 result
= parse_and_eval (expr_str
);
790 CATCH (except
, RETURN_MASK_ALL
)
792 GDB_PY_HANDLE_EXCEPTION (except
);
796 return value_to_value_object (result
);
799 /* Implementation of gdb.find_pc_line function.
800 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
803 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
805 gdb_py_ulongest pc_llu
;
806 PyObject
*result
= NULL
; /* init for gcc -Wall */
808 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
813 struct symtab_and_line sal
;
816 pc
= (CORE_ADDR
) pc_llu
;
817 sal
= find_pc_line (pc
, 0);
818 result
= symtab_and_line_to_sal_object (sal
);
820 CATCH (except
, RETURN_MASK_ALL
)
822 GDB_PY_HANDLE_EXCEPTION (except
);
829 /* Implementation of gdb.invalidate_cached_frames. */
832 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
834 reinit_frame_cache ();
838 /* Read a file as Python code.
839 This is the extension_language_script_ops.script_sourcer "method".
840 FILE is the file to load. FILENAME is name of the file FILE.
841 This does not throw any errors. If an exception occurs python will print
842 the traceback and clear the error indicator. */
845 gdbpy_source_script (const struct extension_language_defn
*extlang
,
846 FILE *file
, const char *filename
)
848 gdbpy_enter
enter_py (get_current_arch (), current_language
);
849 python_run_simple_file (file
, filename
);
854 /* Posting and handling events. */
856 /* A single event. */
859 /* The Python event. This is just a callable object. */
861 /* The next event. */
862 struct gdbpy_event
*next
;
865 /* All pending events. */
866 static struct gdbpy_event
*gdbpy_event_list
;
867 /* The final link of the event list. */
868 static struct gdbpy_event
**gdbpy_event_list_end
;
870 /* So that we can wake up the main thread even when it is blocked in
872 static struct serial_event
*gdbpy_serial_event
;
874 /* The file handler callback. This reads from the internal pipe, and
875 then processes the Python event queue. This will always be run in
876 the main gdb thread. */
879 gdbpy_run_events (int error
, gdb_client_data client_data
)
881 gdbpy_enter
enter_py (get_current_arch (), current_language
);
883 /* Clear the event fd. Do this before flushing the events list, so
884 that any new event post afterwards is sure to re-awake the event
886 serial_event_clear (gdbpy_serial_event
);
888 while (gdbpy_event_list
)
890 /* Dispatching the event might push a new element onto the event
891 loop, so we update here "atomically enough". */
892 struct gdbpy_event
*item
= gdbpy_event_list
;
893 gdbpy_event_list
= gdbpy_event_list
->next
;
894 if (gdbpy_event_list
== NULL
)
895 gdbpy_event_list_end
= &gdbpy_event_list
;
898 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
899 if (call_result
== NULL
)
902 Py_DECREF (item
->event
);
907 /* Submit an event to the gdb thread. */
909 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
911 struct gdbpy_event
*event
;
915 if (!PyArg_ParseTuple (args
, "O", &func
))
918 if (!PyCallable_Check (func
))
920 PyErr_SetString (PyExc_RuntimeError
,
921 _("Posted event is not callable"));
927 /* From here until the end of the function, we have the GIL, so we
928 can operate on our global data structures without worrying. */
929 wakeup
= gdbpy_event_list
== NULL
;
931 event
= XNEW (struct gdbpy_event
);
934 *gdbpy_event_list_end
= event
;
935 gdbpy_event_list_end
= &event
->next
;
937 /* Wake up gdb when needed. */
939 serial_event_set (gdbpy_serial_event
);
944 /* Initialize the Python event handler. */
946 gdbpy_initialize_events (void)
948 gdbpy_event_list_end
= &gdbpy_event_list
;
950 gdbpy_serial_event
= make_serial_event ();
951 add_file_handler (serial_event_fd (gdbpy_serial_event
),
952 gdbpy_run_events
, NULL
);
959 /* This is the extension_language_ops.before_prompt "method". */
961 static enum ext_lang_rc
962 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
963 const char *current_gdb_prompt
)
965 if (!gdb_python_initialized
)
966 return EXT_LANG_RC_NOP
;
968 gdbpy_enter
enter_py (get_current_arch (), current_language
);
970 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
971 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
972 return EXT_LANG_RC_ERROR
;
974 if (gdb_python_module
975 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
977 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
981 gdbpy_print_stack ();
982 return EXT_LANG_RC_ERROR
;
985 if (PyCallable_Check (hook
.get ()))
987 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
988 if (current_prompt
== NULL
)
990 gdbpy_print_stack ();
991 return EXT_LANG_RC_ERROR
;
995 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
999 gdbpy_print_stack ();
1000 return EXT_LANG_RC_ERROR
;
1003 /* Return type should be None, or a String. If it is None,
1004 fall through, we will not set a prompt. If it is a
1005 string, set PROMPT. Anything else, set an exception. */
1006 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1008 PyErr_Format (PyExc_RuntimeError
,
1009 _("Return from prompt_hook must " \
1010 "be either a Python string, or None"));
1011 gdbpy_print_stack ();
1012 return EXT_LANG_RC_ERROR
;
1015 if (result
!= Py_None
)
1017 gdb::unique_xmalloc_ptr
<char>
1018 prompt (python_string_to_host_string (result
.get ()));
1022 gdbpy_print_stack ();
1023 return EXT_LANG_RC_ERROR
;
1026 set_prompt (prompt
.get ());
1027 return EXT_LANG_RC_OK
;
1032 return EXT_LANG_RC_NOP
;
1039 /* A python function to write a single string using gdb's filtered
1040 output stream . The optional keyword STREAM can be used to write
1041 to a particular stream. The default stream is to gdb_stdout. */
1044 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1047 static const char *keywords
[] = { "text", "stream", NULL
};
1048 int stream_type
= 0;
1050 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1056 switch (stream_type
)
1060 fprintf_filtered (gdb_stderr
, "%s", arg
);
1065 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1069 fprintf_filtered (gdb_stdout
, "%s", arg
);
1072 CATCH (except
, RETURN_MASK_ALL
)
1074 GDB_PY_HANDLE_EXCEPTION (except
);
1081 /* A python function to flush a gdb stream. The optional keyword
1082 STREAM can be used to flush a particular stream. The default stream
1086 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1088 static const char *keywords
[] = { "stream", NULL
};
1089 int stream_type
= 0;
1091 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1095 switch (stream_type
)
1099 gdb_flush (gdb_stderr
);
1104 gdb_flush (gdb_stdlog
);
1108 gdb_flush (gdb_stdout
);
1114 /* Return non-zero if print-stack is not "none". */
1117 gdbpy_print_python_errors_p (void)
1119 return gdbpy_should_print_stack
!= python_excp_none
;
1122 /* Print a python exception trace, print just a message, or print
1123 nothing and clear the python exception, depending on
1124 gdbpy_should_print_stack. Only call this if a python exception is
1127 gdbpy_print_stack (void)
1130 /* Print "none", just clear exception. */
1131 if (gdbpy_should_print_stack
== python_excp_none
)
1135 /* Print "full" message and backtrace. */
1136 else if (gdbpy_should_print_stack
== python_excp_full
)
1139 /* PyErr_Print doesn't necessarily end output with a newline.
1140 This works because Python's stdout/stderr is fed through
1146 CATCH (except
, RETURN_MASK_ALL
)
1151 /* Print "message", just error print message. */
1154 PyObject
*ptype
, *pvalue
, *ptraceback
;
1156 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1158 /* Fetch the error message contained within ptype, pvalue. */
1159 gdb::unique_xmalloc_ptr
<char>
1160 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1161 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1167 /* An error occurred computing the string representation of the
1169 fprintf_filtered (gdb_stderr
,
1170 _("Error occurred computing Python error" \
1174 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1175 type
.get (), msg
.get ());
1177 CATCH (except
, RETURN_MASK_ALL
)
1183 Py_XDECREF (pvalue
);
1184 Py_XDECREF (ptraceback
);
1190 /* Return the current Progspace.
1191 There always is one. */
1194 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1198 result
= pspace_to_pspace_object (current_program_space
);
1204 /* Return a sequence holding all the Progspaces. */
1207 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1209 struct program_space
*ps
;
1211 gdbpy_ref
<> list (PyList_New (0));
1217 PyObject
*item
= pspace_to_pspace_object (ps
);
1219 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1223 return list
.release ();
1228 /* The "current" objfile. This is set when gdb detects that a new
1229 objfile has been loaded. It is only set for the duration of a call to
1230 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1232 static struct objfile
*gdbpy_current_objfile
;
1234 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1235 as Python code. This does not throw any errors. If an exception
1236 occurs python will print the traceback and clear the error indicator.
1237 This is the extension_language_script_ops.objfile_script_sourcer
1241 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1242 struct objfile
*objfile
, FILE *file
,
1243 const char *filename
)
1245 if (!gdb_python_initialized
)
1248 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1249 gdbpy_current_objfile
= objfile
;
1251 python_run_simple_file (file
, filename
);
1253 gdbpy_current_objfile
= NULL
;
1256 /* Set the current objfile to OBJFILE and then execute SCRIPT
1257 as Python code. This does not throw any errors. If an exception
1258 occurs python will print the traceback and clear the error indicator.
1259 This is the extension_language_script_ops.objfile_script_executor
1263 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1264 struct objfile
*objfile
, const char *name
,
1267 if (!gdb_python_initialized
)
1270 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1271 gdbpy_current_objfile
= objfile
;
1273 PyRun_SimpleString (script
);
1275 gdbpy_current_objfile
= NULL
;
1278 /* Return the current Objfile, or None if there isn't one. */
1281 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1285 if (! gdbpy_current_objfile
)
1288 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1294 /* Return a sequence holding all the Objfiles. */
1297 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1299 struct objfile
*objf
;
1301 gdbpy_ref
<> list (PyList_New (0));
1307 PyObject
*item
= objfile_to_objfile_object (objf
);
1309 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1313 return list
.release ();
1316 /* Compute the list of active python type printers and store them in
1317 EXT_PRINTERS->py_type_printers. The product of this function is used by
1318 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1319 This is the extension_language_ops.start_type_printers "method". */
1322 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1323 struct ext_lang_type_printers
*ext_printers
)
1325 PyObject
*printers_obj
= NULL
;
1327 if (!gdb_python_initialized
)
1330 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1332 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1333 if (type_module
== NULL
)
1335 gdbpy_print_stack ();
1339 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1340 "get_type_recognizers"));
1343 gdbpy_print_stack ();
1347 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1348 if (printers_obj
== NULL
)
1349 gdbpy_print_stack ();
1351 ext_printers
->py_type_printers
= printers_obj
;
1354 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1355 a newly allocated string holding the type's replacement name, and return
1356 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1357 If there's a Python error return EXT_LANG_RC_ERROR.
1358 Otherwise, return EXT_LANG_RC_NOP.
1359 This is the extension_language_ops.apply_type_printers "method". */
1361 static enum ext_lang_rc
1362 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1363 const struct ext_lang_type_printers
*ext_printers
,
1364 struct type
*type
, char **prettied_type
)
1366 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1367 gdb::unique_xmalloc_ptr
<char> result
;
1369 if (printers_obj
== NULL
)
1370 return EXT_LANG_RC_NOP
;
1372 if (!gdb_python_initialized
)
1373 return EXT_LANG_RC_NOP
;
1375 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1377 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1378 if (type_obj
== NULL
)
1380 gdbpy_print_stack ();
1381 return EXT_LANG_RC_ERROR
;
1384 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1385 if (type_module
== NULL
)
1387 gdbpy_print_stack ();
1388 return EXT_LANG_RC_ERROR
;
1391 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1392 "apply_type_recognizers"));
1395 gdbpy_print_stack ();
1396 return EXT_LANG_RC_ERROR
;
1399 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1403 if (result_obj
== NULL
)
1405 gdbpy_print_stack ();
1406 return EXT_LANG_RC_ERROR
;
1409 if (result_obj
== Py_None
)
1410 return EXT_LANG_RC_NOP
;
1412 result
= python_string_to_host_string (result_obj
.get ());
1415 gdbpy_print_stack ();
1416 return EXT_LANG_RC_ERROR
;
1419 *prettied_type
= result
.release ();
1420 return EXT_LANG_RC_OK
;
1423 /* Free the result of start_type_printers.
1424 This is the extension_language_ops.free_type_printers "method". */
1427 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1428 struct ext_lang_type_printers
*ext_printers
)
1430 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1432 if (printers
== NULL
)
1435 if (!gdb_python_initialized
)
1438 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1439 Py_DECREF (printers
);
1442 #else /* HAVE_PYTHON */
1444 /* Dummy implementation of the gdb "python-interactive" and "python"
1448 python_interactive_command (char *arg
, int from_tty
)
1450 arg
= skip_spaces (arg
);
1452 error (_("Python scripting is not supported in this copy of GDB."));
1455 struct command_line
*l
= get_command_line (python_control
, "");
1456 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1458 execute_control_command_untraced (l
);
1459 do_cleanups (cleanups
);
1464 python_command (char *arg
, int from_tty
)
1466 python_interactive_command (arg
, from_tty
);
1469 #endif /* HAVE_PYTHON */
1473 /* Lists for 'set python' commands. */
1475 static struct cmd_list_element
*user_set_python_list
;
1476 static struct cmd_list_element
*user_show_python_list
;
1478 /* Function for use by 'set python' prefix command. */
1481 user_set_python (char *args
, int from_tty
)
1483 help_list (user_set_python_list
, "set python ", all_commands
,
1487 /* Function for use by 'show python' prefix command. */
1490 user_show_python (char *args
, int from_tty
)
1492 cmd_show_list (user_show_python_list
, from_tty
, "");
1495 /* Initialize the Python code. */
1499 /* This is installed as a final cleanup and cleans up the
1500 interpreter. This lets Python's 'atexit' work. */
1503 finalize_python (void *ignore
)
1505 struct active_ext_lang_state
*previous_active
;
1507 /* We don't use ensure_python_env here because if we ever ran the
1508 cleanup, gdb would crash -- because the cleanup calls into the
1509 Python interpreter, which we are about to destroy. It seems
1510 clearer to make the needed calls explicitly here than to create a
1511 cleanup and then mysteriously discard it. */
1513 /* This is only called as a final cleanup so we can assume the active
1514 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1515 previous_active
= set_active_ext_lang (&extension_language_python
);
1517 (void) PyGILState_Ensure ();
1518 python_gdbarch
= target_gdbarch ();
1519 python_language
= current_language
;
1523 restore_active_ext_lang (previous_active
);
1527 /* Provide a prototype to silence -Wmissing-prototypes. */
1528 extern initialize_file_ftype _initialize_python
;
1533 do_start_initialization ()
1538 size_t progsize
, count
;
1540 wchar_t *progname_copy
;
1543 #ifdef WITH_PYTHON_PATH
1544 /* Work around problem where python gets confused about where it is,
1545 and then can't find its libraries, etc.
1546 NOTE: Python assumes the following layout:
1548 /foo/lib/pythonX.Y/...
1549 This must be done before calling Py_Initialize. */
1550 progname
= concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1551 SLASH_STRING
, "python", (char *) NULL
);
1553 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1554 setlocale (LC_ALL
, "");
1555 progsize
= strlen (progname
);
1556 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1560 fprintf (stderr
, "out of memory\n");
1563 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1564 if (count
== (size_t) -1)
1567 fprintf (stderr
, "Could not convert python path to string\n");
1570 setlocale (LC_ALL
, oldloc
);
1573 /* Note that Py_SetProgramName expects the string it is passed to
1574 remain alive for the duration of the program's execution, so
1575 it is not freed after this call. */
1576 Py_SetProgramName (progname_copy
);
1578 Py_SetProgramName (progname
);
1583 PyEval_InitThreads ();
1586 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1587 /* Add _gdb module to the list of known built-in modules. */
1588 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1590 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1592 if (gdb_module
== NULL
)
1595 /* The casts to (char*) are for python 2.4. */
1596 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1597 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1598 (char*) host_name
) < 0
1599 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1600 (char*) target_name
) < 0)
1603 /* Add stream constants. */
1604 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1605 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1606 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1609 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1610 if (gdbpy_gdb_error
== NULL
1611 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1614 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1615 gdbpy_gdb_error
, NULL
);
1616 if (gdbpy_gdb_memory_error
== NULL
1617 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1618 gdbpy_gdb_memory_error
) < 0)
1621 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1622 if (gdbpy_gdberror_exc
== NULL
1623 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1624 gdbpy_gdberror_exc
) < 0)
1627 gdbpy_initialize_gdb_readline ();
1629 if (gdbpy_initialize_auto_load () < 0
1630 || gdbpy_initialize_values () < 0
1631 || gdbpy_initialize_frames () < 0
1632 || gdbpy_initialize_commands () < 0
1633 || gdbpy_initialize_record () < 0
1634 || gdbpy_initialize_btrace () < 0
1635 || gdbpy_initialize_symbols () < 0
1636 || gdbpy_initialize_symtabs () < 0
1637 || gdbpy_initialize_blocks () < 0
1638 || gdbpy_initialize_functions () < 0
1639 || gdbpy_initialize_parameters () < 0
1640 || gdbpy_initialize_types () < 0
1641 || gdbpy_initialize_pspace () < 0
1642 || gdbpy_initialize_objfile () < 0
1643 || gdbpy_initialize_breakpoints () < 0
1644 || gdbpy_initialize_finishbreakpoints () < 0
1645 || gdbpy_initialize_lazy_string () < 0
1646 || gdbpy_initialize_linetable () < 0
1647 || gdbpy_initialize_thread () < 0
1648 || gdbpy_initialize_inferior () < 0
1649 || gdbpy_initialize_events () < 0
1650 || gdbpy_initialize_eventregistry () < 0
1651 || gdbpy_initialize_py_events () < 0
1652 || gdbpy_initialize_event () < 0
1653 || gdbpy_initialize_stop_event () < 0
1654 || gdbpy_initialize_signal_event () < 0
1655 || gdbpy_initialize_breakpoint_event () < 0
1656 || gdbpy_initialize_continue_event () < 0
1657 || gdbpy_initialize_inferior_call_pre_event () < 0
1658 || gdbpy_initialize_inferior_call_post_event () < 0
1659 || gdbpy_initialize_register_changed_event () < 0
1660 || gdbpy_initialize_memory_changed_event () < 0
1661 || gdbpy_initialize_exited_event () < 0
1662 || gdbpy_initialize_thread_event () < 0
1663 || gdbpy_initialize_new_objfile_event () < 0
1664 || gdbpy_initialize_clear_objfiles_event () < 0
1665 || gdbpy_initialize_arch () < 0
1666 || gdbpy_initialize_xmethods () < 0
1667 || gdbpy_initialize_unwind () < 0)
1670 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1671 if (gdbpy_to_string_cst
== NULL
)
1673 gdbpy_children_cst
= PyString_FromString ("children");
1674 if (gdbpy_children_cst
== NULL
)
1676 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1677 if (gdbpy_display_hint_cst
== NULL
)
1679 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1680 if (gdbpy_doc_cst
== NULL
)
1682 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1683 if (gdbpy_enabled_cst
== NULL
)
1685 gdbpy_value_cst
= PyString_FromString ("value");
1686 if (gdbpy_value_cst
== NULL
)
1689 /* Release the GIL while gdb runs. */
1690 PyThreadState_Swap (NULL
);
1691 PyEval_ReleaseLock ();
1693 make_final_cleanup (finalize_python
, NULL
);
1695 /* Only set this when initialization has succeeded. */
1696 gdb_python_initialized
= 1;
1700 #endif /* HAVE_PYTHON */
1703 _initialize_python (void)
1705 add_com ("python-interactive", class_obscure
,
1706 python_interactive_command
,
1709 Start an interactive Python prompt.\n\
1711 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1714 Alternatively, a single-line Python command can be given as an\n\
1715 argument, and if the command is an expression, the result will be\n\
1716 printed. For example:\n\
1718 (gdb) python-interactive 2 + 3\n\
1721 #else /* HAVE_PYTHON */
1723 Start a Python interactive prompt.\n\
1725 Python scripting is not supported in this copy of GDB.\n\
1726 This command is only a placeholder.")
1727 #endif /* HAVE_PYTHON */
1729 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1731 add_com ("python", class_obscure
, python_command
,
1734 Evaluate a Python command.\n\
1736 The command can be given as an argument, for instance:\n\
1740 If no argument is given, the following lines are read and used\n\
1741 as the Python commands. Type a line containing \"end\" to indicate\n\
1742 the end of the command.")
1743 #else /* HAVE_PYTHON */
1745 Evaluate a Python command.\n\
1747 Python scripting is not supported in this copy of GDB.\n\
1748 This command is only a placeholder.")
1749 #endif /* HAVE_PYTHON */
1751 add_com_alias ("py", "python", class_obscure
, 1);
1753 /* Add set/show python print-stack. */
1754 add_prefix_cmd ("python", no_class
, user_show_python
,
1755 _("Prefix command for python preference settings."),
1756 &user_show_python_list
, "show python ", 0,
1759 add_prefix_cmd ("python", no_class
, user_set_python
,
1760 _("Prefix command for python preference settings."),
1761 &user_set_python_list
, "set python ", 0,
1764 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1765 &gdbpy_should_print_stack
, _("\
1766 Set mode for Python stack dump on error."), _("\
1767 Show the mode of Python stack printing on error."), _("\
1768 none == no stack or message will be printed.\n\
1769 full == a message and a stack will be printed.\n\
1770 message == an error message without a stack will be printed."),
1772 &user_set_python_list
,
1773 &user_show_python_list
);
1776 if (!do_start_initialization () && PyErr_Occurred ())
1777 gdbpy_print_stack ();
1778 #endif /* HAVE_PYTHON */
1783 /* Helper function for gdbpy_finish_initialization. This does the
1784 work and then returns false if an error has occurred and must be
1785 displayed, or true on success. */
1788 do_finish_initialization (const struct extension_language_defn
*extlang
)
1793 /* Add the initial data-directory to sys.path. */
1795 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1798 sys_path
= PySys_GetObject ("path");
1800 /* If sys.path is not defined yet, define it first. */
1801 if (!(sys_path
&& PyList_Check (sys_path
)))
1804 PySys_SetPath (L
"");
1808 sys_path
= PySys_GetObject ("path");
1810 if (sys_path
&& PyList_Check (sys_path
))
1812 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1813 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1819 /* Import the gdb module to finish the initialization, and
1820 add it to __main__ for convenience. */
1821 m
= PyImport_AddModule ("__main__");
1825 /* Keep the reference to gdb_python_module since it is in a global
1827 gdb_python_module
= PyImport_ImportModule ("gdb");
1828 if (gdb_python_module
== NULL
)
1830 gdbpy_print_stack ();
1831 /* This is passed in one call to warning so that blank lines aren't
1832 inserted between each line of text. */
1834 "Could not load the Python gdb module from `%s'.\n"
1835 "Limited Python support is available from the _gdb module.\n"
1836 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1837 gdb_pythondir
.c_str ());
1838 /* We return "success" here as we've already emitted the
1843 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1846 /* Perform the remaining python initializations.
1847 These must be done after GDB is at least mostly initialized.
1848 E.g., The "info pretty-printer" command needs the "info" prefix
1850 This is the extension_language_ops.finish_initialization "method". */
1853 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1855 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1857 if (!do_finish_initialization (extlang
))
1859 gdbpy_print_stack ();
1860 warning (_("internal error: Unhandled Python exception"));
1864 /* Return non-zero if Python has successfully initialized.
1865 This is the extension_languages_ops.initialized "method". */
1868 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1870 return gdb_python_initialized
;
1873 #endif /* HAVE_PYTHON */
1879 PyMethodDef python_GdbMethods
[] =
1881 { "history", gdbpy_history
, METH_VARARGS
,
1882 "Get a value from history" },
1883 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1884 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1885 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1886 a Python String containing the output of the command if to_string is\n\
1888 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1889 "Return a gdb parameter's value" },
1891 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1892 "Return a tuple of all breakpoint objects" },
1894 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1895 "Find the default visualizer for a Value." },
1897 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1898 "Return the current Progspace." },
1899 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1900 "Return a sequence of all progspaces." },
1902 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1903 "Return the current Objfile being loaded, or None." },
1904 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1905 "Return a sequence of all loaded objfiles." },
1907 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1908 "newest_frame () -> gdb.Frame.\n\
1909 Return the newest frame object." },
1910 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1911 "selected_frame () -> gdb.Frame.\n\
1912 Return the selected frame object." },
1913 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1914 "stop_reason_string (Integer) -> String.\n\
1915 Return a string explaining unwind stop reason." },
1917 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
1918 "start_recording ([method] [, format]) -> gdb.Record.\n\
1919 Start recording with the given method. If no method is given, will fall back\n\
1920 to the system default method. If no format is given, will fall back to the\n\
1921 default format for the given method."},
1922 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
1923 "current_recording () -> gdb.Record.\n\
1924 Return current recording object." },
1925 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
1926 "stop_recording () -> None.\n\
1927 Stop current recording." },
1929 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1930 METH_VARARGS
| METH_KEYWORDS
,
1931 "lookup_type (name [, block]) -> type\n\
1932 Return a Type corresponding to the given name." },
1933 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1934 METH_VARARGS
| METH_KEYWORDS
,
1935 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1936 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1937 a boolean indicating if name is a field of the current implied argument\n\
1938 `this' (when the current language is object-oriented)." },
1939 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1940 METH_VARARGS
| METH_KEYWORDS
,
1941 "lookup_global_symbol (name [, domain]) -> symbol\n\
1942 Return the symbol corresponding to the given name (or None)." },
1944 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1945 METH_VARARGS
| METH_KEYWORDS
,
1946 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1947 Look up the specified objfile.\n\
1948 If by_build_id is True, the objfile is looked up by using name\n\
1949 as its build id." },
1951 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
1952 "Return the block containing the given pc value, or None." },
1953 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
1954 "solib_name (Long) -> String.\n\
1955 Return the name of the shared library holding a given address, or None." },
1956 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1957 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1958 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1959 The first element contains any unparsed portion of the String parameter\n\
1960 (or None if the string was fully parsed). The second element contains\n\
1961 a tuple that contains all the locations that match, represented as\n\
1962 gdb.Symtab_and_line objects (or None)."},
1963 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
1964 "parse_and_eval (String) -> Value.\n\
1965 Parse String as an expression, evaluate it, and return the result as a Value."
1967 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
1968 "find_pc_line (pc) -> Symtab_and_line.\n\
1969 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1971 { "post_event", gdbpy_post_event
, METH_VARARGS
,
1972 "Post an event into gdb's event loop." },
1974 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
1975 "target_charset () -> string.\n\
1976 Return the name of the current target charset." },
1977 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
1978 "target_wide_charset () -> string.\n\
1979 Return the name of the current target wide charset." },
1981 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
1982 "string_to_argv (String) -> Array.\n\
1983 Parse String and return an argv-like array.\n\
1984 Arguments are separate by spaces and may be quoted."
1986 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
1987 "Write a string using gdb's filtered stream." },
1988 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
1989 "Flush gdb's filtered stdout stream." },
1990 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
1991 "selected_thread () -> gdb.InferiorThread.\n\
1992 Return the selected thread object." },
1993 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
1994 "selected_inferior () -> gdb.Inferior.\n\
1995 Return the selected inferior object." },
1996 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
1997 "inferiors () -> (gdb.Inferior, ...).\n\
1998 Return a tuple containing all inferiors." },
2000 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2001 "invalidate_cached_frames () -> None.\n\
2002 Invalidate any cached frame objects in gdb.\n\
2003 Intended for internal use only." },
2005 {NULL
, NULL
, 0, NULL
}
2009 struct PyModuleDef python_GdbModuleDef
=
2011 PyModuleDef_HEAD_INIT
,
2022 #endif /* HAVE_PYTHON */