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"
104 /* True if Python has been successfully initialized, false
107 int gdb_python_initialized
;
109 extern PyMethodDef python_GdbMethods
[];
112 extern struct PyModuleDef python_GdbModuleDef
;
115 PyObject
*gdb_module
;
116 PyObject
*gdb_python_module
;
118 /* Some string constants we may wish to use. */
119 PyObject
*gdbpy_to_string_cst
;
120 PyObject
*gdbpy_children_cst
;
121 PyObject
*gdbpy_display_hint_cst
;
122 PyObject
*gdbpy_doc_cst
;
123 PyObject
*gdbpy_enabled_cst
;
124 PyObject
*gdbpy_value_cst
;
126 /* The GdbError exception. */
127 PyObject
*gdbpy_gdberror_exc
;
129 /* The `gdb.error' base class. */
130 PyObject
*gdbpy_gdb_error
;
132 /* The `gdb.MemoryError' exception. */
133 PyObject
*gdbpy_gdb_memory_error
;
135 static script_sourcer_func gdbpy_source_script
;
136 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
137 static objfile_script_executor_func gdbpy_execute_objfile_script
;
138 static void gdbpy_finish_initialization
139 (const struct extension_language_defn
*);
140 static int gdbpy_initialized (const struct extension_language_defn
*);
141 static void gdbpy_eval_from_control_command
142 (const struct extension_language_defn
*, struct command_line
*cmd
);
143 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
144 struct ext_lang_type_printers
*);
145 static enum ext_lang_rc gdbpy_apply_type_printers
146 (const struct extension_language_defn
*,
147 const struct ext_lang_type_printers
*, struct type
*, char **);
148 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
149 struct ext_lang_type_printers
*);
150 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
151 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
152 static enum ext_lang_rc gdbpy_before_prompt_hook
153 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
155 /* The interface between gdb proper and loading of python scripts. */
157 const struct extension_language_script_ops python_extension_script_ops
=
160 gdbpy_source_objfile_script
,
161 gdbpy_execute_objfile_script
,
162 gdbpy_auto_load_enabled
165 /* The interface between gdb proper and python extensions. */
167 const struct extension_language_ops python_extension_ops
=
169 gdbpy_finish_initialization
,
172 gdbpy_eval_from_control_command
,
174 gdbpy_start_type_printers
,
175 gdbpy_apply_type_printers
,
176 gdbpy_free_type_printers
,
178 gdbpy_apply_val_pretty_printer
,
180 gdbpy_apply_frame_filter
,
182 gdbpy_preserve_values
,
184 gdbpy_breakpoint_has_cond
,
185 gdbpy_breakpoint_cond_says_stop
,
188 gdbpy_check_quit_flag
,
190 gdbpy_before_prompt_hook
,
192 gdbpy_clone_xmethod_worker_data
,
193 gdbpy_free_xmethod_worker_data
,
194 gdbpy_get_matching_xmethod_workers
,
195 gdbpy_get_xmethod_arg_types
,
196 gdbpy_get_xmethod_result_type
,
200 /* Architecture and language to be used in callbacks from
201 the Python interpreter. */
202 struct gdbarch
*python_gdbarch
;
203 const struct language_defn
*python_language
;
205 gdbpy_enter::gdbpy_enter (struct gdbarch
*gdbarch
,
206 const struct language_defn
*language
)
207 : m_gdbarch (python_gdbarch
),
208 m_language (python_language
)
210 /* We should not ever enter Python unless initialized. */
211 if (!gdb_python_initialized
)
212 error (_("Python not initialized"));
214 m_previous_active
= set_active_ext_lang (&extension_language_python
);
216 m_state
= PyGILState_Ensure ();
218 python_gdbarch
= gdbarch
;
219 python_language
= language
;
221 /* Save it and ensure ! PyErr_Occurred () afterwards. */
222 PyErr_Fetch (&m_error_type
, &m_error_value
, &m_error_traceback
);
225 gdbpy_enter::~gdbpy_enter ()
227 /* Leftover Python error is forbidden by Python Exception Handling. */
228 if (PyErr_Occurred ())
230 /* This order is similar to the one calling error afterwards. */
231 gdbpy_print_stack ();
232 warning (_("internal error: Unhandled Python exception"));
235 PyErr_Restore (m_error_type
, m_error_value
, m_error_traceback
);
237 PyGILState_Release (m_state
);
238 python_gdbarch
= m_gdbarch
;
239 python_language
= m_language
;
241 restore_active_ext_lang (m_previous_active
);
244 /* Set the quit flag. */
247 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
249 PyErr_SetInterrupt ();
252 /* Return true if the quit flag has been set, false otherwise. */
255 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
257 return PyOS_InterruptOccurred ();
260 /* Evaluate a Python command like PyRun_SimpleString, but uses
261 Py_single_input which prints the result of expressions, and does
262 not automatically print the stack on errors. */
265 eval_python_command (const char *command
)
269 m
= PyImport_AddModule ("__main__");
273 d
= PyModule_GetDict (m
);
276 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
288 /* Implementation of the gdb "python-interactive" command. */
291 python_interactive_command (char *arg
, int from_tty
)
293 struct ui
*ui
= current_ui
;
296 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
298 arg
= skip_spaces (arg
);
300 gdbpy_enter
enter_py (get_current_arch (), current_language
);
304 int len
= strlen (arg
);
305 char *script
= (char *) xmalloc (len
+ 2);
307 strcpy (script
, arg
);
309 script
[len
+ 1] = '\0';
310 err
= eval_python_command (script
);
315 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
321 gdbpy_print_stack ();
322 error (_("Error while executing Python code."));
326 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
329 On Windows hosts few users would build Python themselves (this is no
330 trivial task on this platform), and thus use binaries built by
331 someone else instead. There may happen situation where the Python
332 library and GDB are using two different versions of the C runtime
333 library. Python, being built with VC, would use one version of the
334 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
335 A FILE * from one runtime does not necessarily operate correctly in
338 To work around this potential issue, we create on Windows hosts the
339 FILE object using Python routines, thus making sure that it is
340 compatible with the Python library. */
343 python_run_simple_file (FILE *file
, const char *filename
)
347 PyRun_SimpleFile (file
, filename
);
351 /* Because we have a string for a filename, and are using Python to
352 open the file, we need to expand any tilde in the path first. */
353 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
354 gdbpy_ref
<> python_file (PyFile_FromString (full_path
.get (), "r"));
355 if (python_file
== NULL
)
357 gdbpy_print_stack ();
358 error (_("Error while opening file: %s"), full_path
.get ());
361 PyRun_SimpleFile (PyFile_AsFile (python_file
.get ()), filename
);
366 /* Given a command_line, return a command string suitable for passing
367 to Python. Lines in the string are separated by newlines. The
368 return value is allocated using xmalloc and the caller is
369 responsible for freeing it. */
372 compute_python_string (struct command_line
*l
)
374 struct command_line
*iter
;
379 for (iter
= l
; iter
; iter
= iter
->next
)
380 size
+= strlen (iter
->line
) + 1;
382 script
= (char *) xmalloc (size
+ 1);
384 for (iter
= l
; iter
; iter
= iter
->next
)
386 int len
= strlen (iter
->line
);
388 strcpy (&script
[here
], iter
->line
);
390 script
[here
++] = '\n';
396 /* Take a command line structure representing a 'python' command, and
397 evaluate its body using the Python interpreter. */
400 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
401 struct command_line
*cmd
)
406 if (cmd
->body_count
!= 1)
407 error (_("Invalid \"python\" block structure."));
409 gdbpy_enter
enter_py (get_current_arch (), current_language
);
411 script
= compute_python_string (cmd
->body_list
[0]);
412 ret
= PyRun_SimpleString (script
);
415 error (_("Error while executing Python code."));
418 /* Implementation of the gdb "python" command. */
421 python_command (char *arg
, int from_tty
)
423 gdbpy_enter
enter_py (get_current_arch (), current_language
);
425 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
427 arg
= skip_spaces (arg
);
430 if (PyRun_SimpleString (arg
))
431 error (_("Error while executing Python code."));
435 struct command_line
*l
= get_command_line (python_control
, "");
436 struct cleanup
*cleanup
= make_cleanup_free_command_lines (&l
);
438 execute_control_command_untraced (l
);
439 do_cleanups (cleanup
);
445 /* Transform a gdb parameters's value into a Python value. May return
446 NULL (and set a Python exception) on error. Helper function for
449 gdbpy_parameter_value (enum var_types type
, void *var
)
454 case var_string_noescape
:
455 case var_optional_filename
:
459 char *str
= * (char **) var
;
463 return host_string_to_python_string (str
);
474 case var_auto_boolean
:
476 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
478 if (ab
== AUTO_BOOLEAN_TRUE
)
480 else if (ab
== AUTO_BOOLEAN_FALSE
)
487 if ((* (int *) var
) == INT_MAX
)
491 return PyLong_FromLong (* (int *) var
);
495 unsigned int val
= * (unsigned int *) var
;
499 return PyLong_FromUnsignedLong (val
);
503 return PyErr_Format (PyExc_RuntimeError
,
504 _("Programmer error: unhandled type."));
507 /* A Python function which returns a gdb parameter's value as a Python
511 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
513 struct gdb_exception except
= exception_none
;
514 struct cmd_list_element
*alias
, *prefix
, *cmd
;
519 if (! PyArg_ParseTuple (args
, "s", &arg
))
522 newarg
= concat ("show ", arg
, (char *) NULL
);
526 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
528 CATCH (ex
, RETURN_MASK_ALL
)
535 GDB_PY_HANDLE_EXCEPTION (except
);
537 return PyErr_Format (PyExc_RuntimeError
,
538 _("Could not find parameter `%s'."), arg
);
541 return PyErr_Format (PyExc_RuntimeError
,
542 _("`%s' is not a parameter."), arg
);
543 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
546 /* Wrapper for target_charset. */
549 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
551 const char *cset
= target_charset (python_gdbarch
);
553 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
556 /* Wrapper for target_wide_charset. */
559 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
561 const char *cset
= target_wide_charset (python_gdbarch
);
563 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
566 /* A Python function which evaluates a string using the gdb CLI. */
569 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
572 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
573 int from_tty
, to_string
;
574 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
576 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
577 &PyBool_Type
, &from_tty_obj
,
578 &PyBool_Type
, &to_string_obj
))
584 int cmp
= PyObject_IsTrue (from_tty_obj
);
593 int cmp
= PyObject_IsTrue (to_string_obj
);
599 std::string to_string_res
;
603 /* Copy the argument text in case the command modifies it. */
604 std::string
copy (arg
);
605 struct interp
*interp
;
607 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
609 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
611 /* Use the console interpreter uiout to have the same print format
612 for console or MI. */
613 interp
= interp_lookup (current_ui
, "console");
614 current_uiout
= interp_ui_out (interp
);
616 scoped_restore preventer
= prevent_dont_repeat ();
618 to_string_res
= execute_command_to_string (©
[0], from_tty
);
620 execute_command (©
[0], from_tty
);
622 CATCH (except
, RETURN_MASK_ALL
)
624 GDB_PY_HANDLE_EXCEPTION (except
);
628 /* Do any commands attached to breakpoint we stopped at. */
629 bpstat_do_actions ();
632 return PyString_FromString (to_string_res
.c_str ());
636 /* Implementation of gdb.solib_name (Long) -> String.
637 Returns the name of the shared library holding a given address, or None. */
640 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
646 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
649 soname
= solib_name_from_address (current_program_space
, pc
);
651 str_obj
= host_string_to_python_string (soname
);
661 /* A Python function which is a wrapper for decode_line_1. */
664 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
666 struct gdb_exception except
= exception_none
;
667 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
669 struct symtab_and_line sal
;
671 struct cleanup
*cleanups
;
673 gdbpy_ref
<> unparsed
;
674 struct event_location
*location
= NULL
;
676 if (! PyArg_ParseTuple (args
, "|s", &arg
))
679 cleanups
= make_cleanup (null_cleanup
, NULL
);
685 location
= string_to_event_location_basic (&arg
, python_language
);
686 make_cleanup_delete_event_location (location
);
691 if (location
!= NULL
)
692 sals
= decode_line_1 (location
, 0, NULL
, NULL
, 0);
695 set_default_source_symtab_and_line ();
696 sal
= get_current_source_symtab_and_line ();
701 CATCH (ex
, RETURN_MASK_ALL
)
707 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
708 make_cleanup (xfree
, sals
.sals
);
710 if (except
.reason
< 0)
712 do_cleanups (cleanups
);
713 /* We know this will always throw. */
714 gdbpy_convert_exception (except
);
722 result
.reset (PyTuple_New (sals
.nelts
));
725 do_cleanups (cleanups
);
728 for (i
= 0; i
< sals
.nelts
; ++i
)
732 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
735 do_cleanups (cleanups
);
739 PyTuple_SetItem (result
.get (), i
, obj
);
744 result
.reset (Py_None
);
748 gdbpy_ref
<> return_result (PyTuple_New (2));
749 if (return_result
== NULL
)
751 do_cleanups (cleanups
);
755 if (arg
!= NULL
&& strlen (arg
) > 0)
757 unparsed
.reset (PyString_FromString (arg
));
758 if (unparsed
== NULL
)
760 do_cleanups (cleanups
);
766 unparsed
.reset (Py_None
);
770 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
771 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
773 do_cleanups (cleanups
);
775 return return_result
.release ();
778 /* Parse a string and evaluate it as an expression. */
780 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
782 const char *expr_str
;
783 struct value
*result
= NULL
;
785 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
790 result
= parse_and_eval (expr_str
);
792 CATCH (except
, RETURN_MASK_ALL
)
794 GDB_PY_HANDLE_EXCEPTION (except
);
798 return value_to_value_object (result
);
801 /* Implementation of gdb.find_pc_line function.
802 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
805 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
807 gdb_py_ulongest pc_llu
;
808 PyObject
*result
= NULL
; /* init for gcc -Wall */
810 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
815 struct symtab_and_line sal
;
818 pc
= (CORE_ADDR
) pc_llu
;
819 sal
= find_pc_line (pc
, 0);
820 result
= symtab_and_line_to_sal_object (sal
);
822 CATCH (except
, RETURN_MASK_ALL
)
824 GDB_PY_HANDLE_EXCEPTION (except
);
831 /* Implementation of gdb.invalidate_cached_frames. */
834 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
836 reinit_frame_cache ();
840 /* Read a file as Python code.
841 This is the extension_language_script_ops.script_sourcer "method".
842 FILE is the file to load. FILENAME is name of the file FILE.
843 This does not throw any errors. If an exception occurs python will print
844 the traceback and clear the error indicator. */
847 gdbpy_source_script (const struct extension_language_defn
*extlang
,
848 FILE *file
, const char *filename
)
850 gdbpy_enter
enter_py (get_current_arch (), current_language
);
851 python_run_simple_file (file
, filename
);
856 /* Posting and handling events. */
858 /* A single event. */
861 /* The Python event. This is just a callable object. */
863 /* The next event. */
864 struct gdbpy_event
*next
;
867 /* All pending events. */
868 static struct gdbpy_event
*gdbpy_event_list
;
869 /* The final link of the event list. */
870 static struct gdbpy_event
**gdbpy_event_list_end
;
872 /* So that we can wake up the main thread even when it is blocked in
874 static struct serial_event
*gdbpy_serial_event
;
876 /* The file handler callback. This reads from the internal pipe, and
877 then processes the Python event queue. This will always be run in
878 the main gdb thread. */
881 gdbpy_run_events (int error
, gdb_client_data client_data
)
883 gdbpy_enter
enter_py (get_current_arch (), current_language
);
885 /* Clear the event fd. Do this before flushing the events list, so
886 that any new event post afterwards is sure to re-awake the event
888 serial_event_clear (gdbpy_serial_event
);
890 while (gdbpy_event_list
)
892 /* Dispatching the event might push a new element onto the event
893 loop, so we update here "atomically enough". */
894 struct gdbpy_event
*item
= gdbpy_event_list
;
895 gdbpy_event_list
= gdbpy_event_list
->next
;
896 if (gdbpy_event_list
== NULL
)
897 gdbpy_event_list_end
= &gdbpy_event_list
;
900 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
901 if (call_result
== NULL
)
904 Py_DECREF (item
->event
);
909 /* Submit an event to the gdb thread. */
911 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
913 struct gdbpy_event
*event
;
917 if (!PyArg_ParseTuple (args
, "O", &func
))
920 if (!PyCallable_Check (func
))
922 PyErr_SetString (PyExc_RuntimeError
,
923 _("Posted event is not callable"));
929 /* From here until the end of the function, we have the GIL, so we
930 can operate on our global data structures without worrying. */
931 wakeup
= gdbpy_event_list
== NULL
;
933 event
= XNEW (struct gdbpy_event
);
936 *gdbpy_event_list_end
= event
;
937 gdbpy_event_list_end
= &event
->next
;
939 /* Wake up gdb when needed. */
941 serial_event_set (gdbpy_serial_event
);
946 /* Initialize the Python event handler. */
948 gdbpy_initialize_events (void)
950 gdbpy_event_list_end
= &gdbpy_event_list
;
952 gdbpy_serial_event
= make_serial_event ();
953 add_file_handler (serial_event_fd (gdbpy_serial_event
),
954 gdbpy_run_events
, NULL
);
961 /* This is the extension_language_ops.before_prompt "method". */
963 static enum ext_lang_rc
964 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
965 const char *current_gdb_prompt
)
967 if (!gdb_python_initialized
)
968 return EXT_LANG_RC_NOP
;
970 gdbpy_enter
enter_py (get_current_arch (), current_language
);
972 if (gdb_python_module
973 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
975 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
979 gdbpy_print_stack ();
980 return EXT_LANG_RC_ERROR
;
983 if (PyCallable_Check (hook
.get ()))
985 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
986 if (current_prompt
== NULL
)
988 gdbpy_print_stack ();
989 return EXT_LANG_RC_ERROR
;
993 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
997 gdbpy_print_stack ();
998 return EXT_LANG_RC_ERROR
;
1001 /* Return type should be None, or a String. If it is None,
1002 fall through, we will not set a prompt. If it is a
1003 string, set PROMPT. Anything else, set an exception. */
1004 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1006 PyErr_Format (PyExc_RuntimeError
,
1007 _("Return from prompt_hook must " \
1008 "be either a Python string, or None"));
1009 gdbpy_print_stack ();
1010 return EXT_LANG_RC_ERROR
;
1013 if (result
!= Py_None
)
1015 gdb::unique_xmalloc_ptr
<char>
1016 prompt (python_string_to_host_string (result
.get ()));
1020 gdbpy_print_stack ();
1021 return EXT_LANG_RC_ERROR
;
1024 set_prompt (prompt
.get ());
1025 return EXT_LANG_RC_OK
;
1030 return EXT_LANG_RC_NOP
;
1037 /* A python function to write a single string using gdb's filtered
1038 output stream . The optional keyword STREAM can be used to write
1039 to a particular stream. The default stream is to gdb_stdout. */
1042 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1045 static char *keywords
[] = {"text", "stream", NULL
};
1046 int stream_type
= 0;
1048 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1054 switch (stream_type
)
1058 fprintf_filtered (gdb_stderr
, "%s", arg
);
1063 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1067 fprintf_filtered (gdb_stdout
, "%s", arg
);
1070 CATCH (except
, RETURN_MASK_ALL
)
1072 GDB_PY_HANDLE_EXCEPTION (except
);
1079 /* A python function to flush a gdb stream. The optional keyword
1080 STREAM can be used to flush a particular stream. The default stream
1084 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1086 static char *keywords
[] = {"stream", NULL
};
1087 int stream_type
= 0;
1089 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1093 switch (stream_type
)
1097 gdb_flush (gdb_stderr
);
1102 gdb_flush (gdb_stdlog
);
1106 gdb_flush (gdb_stdout
);
1112 /* Return non-zero if print-stack is not "none". */
1115 gdbpy_print_python_errors_p (void)
1117 return gdbpy_should_print_stack
!= python_excp_none
;
1120 /* Print a python exception trace, print just a message, or print
1121 nothing and clear the python exception, depending on
1122 gdbpy_should_print_stack. Only call this if a python exception is
1125 gdbpy_print_stack (void)
1128 /* Print "none", just clear exception. */
1129 if (gdbpy_should_print_stack
== python_excp_none
)
1133 /* Print "full" message and backtrace. */
1134 else if (gdbpy_should_print_stack
== python_excp_full
)
1137 /* PyErr_Print doesn't necessarily end output with a newline.
1138 This works because Python's stdout/stderr is fed through
1144 CATCH (except
, RETURN_MASK_ALL
)
1149 /* Print "message", just error print message. */
1152 PyObject
*ptype
, *pvalue
, *ptraceback
;
1154 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1156 /* Fetch the error message contained within ptype, pvalue. */
1157 gdb::unique_xmalloc_ptr
<char>
1158 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1159 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1165 /* An error occurred computing the string representation of the
1167 fprintf_filtered (gdb_stderr
,
1168 _("Error occurred computing Python error" \
1172 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1173 type
.get (), msg
.get ());
1175 CATCH (except
, RETURN_MASK_ALL
)
1181 Py_XDECREF (pvalue
);
1182 Py_XDECREF (ptraceback
);
1188 /* Return the current Progspace.
1189 There always is one. */
1192 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1196 result
= pspace_to_pspace_object (current_program_space
);
1202 /* Return a sequence holding all the Progspaces. */
1205 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1207 struct program_space
*ps
;
1209 gdbpy_ref
<> list (PyList_New (0));
1215 PyObject
*item
= pspace_to_pspace_object (ps
);
1217 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1221 return list
.release ();
1226 /* The "current" objfile. This is set when gdb detects that a new
1227 objfile has been loaded. It is only set for the duration of a call to
1228 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1230 static struct objfile
*gdbpy_current_objfile
;
1232 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1233 as Python code. This does not throw any errors. If an exception
1234 occurs python will print the traceback and clear the error indicator.
1235 This is the extension_language_script_ops.objfile_script_sourcer
1239 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1240 struct objfile
*objfile
, FILE *file
,
1241 const char *filename
)
1243 if (!gdb_python_initialized
)
1246 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1247 gdbpy_current_objfile
= objfile
;
1249 python_run_simple_file (file
, filename
);
1251 gdbpy_current_objfile
= NULL
;
1254 /* Set the current objfile to OBJFILE and then execute SCRIPT
1255 as Python code. This does not throw any errors. If an exception
1256 occurs python will print the traceback and clear the error indicator.
1257 This is the extension_language_script_ops.objfile_script_executor
1261 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1262 struct objfile
*objfile
, const char *name
,
1265 if (!gdb_python_initialized
)
1268 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1269 gdbpy_current_objfile
= objfile
;
1271 PyRun_SimpleString (script
);
1273 gdbpy_current_objfile
= NULL
;
1276 /* Return the current Objfile, or None if there isn't one. */
1279 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1283 if (! gdbpy_current_objfile
)
1286 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1292 /* Return a sequence holding all the Objfiles. */
1295 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1297 struct objfile
*objf
;
1299 gdbpy_ref
<> list (PyList_New (0));
1305 PyObject
*item
= objfile_to_objfile_object (objf
);
1307 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1311 return list
.release ();
1314 /* Compute the list of active python type printers and store them in
1315 EXT_PRINTERS->py_type_printers. The product of this function is used by
1316 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1317 This is the extension_language_ops.start_type_printers "method". */
1320 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1321 struct ext_lang_type_printers
*ext_printers
)
1323 PyObject
*printers_obj
= NULL
;
1325 if (!gdb_python_initialized
)
1328 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1330 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1331 if (type_module
== NULL
)
1333 gdbpy_print_stack ();
1337 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1338 "get_type_recognizers"));
1341 gdbpy_print_stack ();
1345 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1346 if (printers_obj
== NULL
)
1347 gdbpy_print_stack ();
1349 ext_printers
->py_type_printers
= printers_obj
;
1352 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1353 a newly allocated string holding the type's replacement name, and return
1354 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1355 If there's a Python error return EXT_LANG_RC_ERROR.
1356 Otherwise, return EXT_LANG_RC_NOP.
1357 This is the extension_language_ops.apply_type_printers "method". */
1359 static enum ext_lang_rc
1360 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1361 const struct ext_lang_type_printers
*ext_printers
,
1362 struct type
*type
, char **prettied_type
)
1364 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1365 gdb::unique_xmalloc_ptr
<char> result
;
1367 if (printers_obj
== NULL
)
1368 return EXT_LANG_RC_NOP
;
1370 if (!gdb_python_initialized
)
1371 return EXT_LANG_RC_NOP
;
1373 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1375 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1376 if (type_obj
== NULL
)
1378 gdbpy_print_stack ();
1379 return EXT_LANG_RC_ERROR
;
1382 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1383 if (type_module
== NULL
)
1385 gdbpy_print_stack ();
1386 return EXT_LANG_RC_ERROR
;
1389 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1390 "apply_type_recognizers"));
1393 gdbpy_print_stack ();
1394 return EXT_LANG_RC_ERROR
;
1397 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1401 if (result_obj
== NULL
)
1403 gdbpy_print_stack ();
1404 return EXT_LANG_RC_ERROR
;
1407 if (result_obj
== Py_None
)
1408 return EXT_LANG_RC_NOP
;
1410 result
= python_string_to_host_string (result_obj
.get ());
1413 gdbpy_print_stack ();
1414 return EXT_LANG_RC_ERROR
;
1417 *prettied_type
= result
.release ();
1418 return EXT_LANG_RC_OK
;
1421 /* Free the result of start_type_printers.
1422 This is the extension_language_ops.free_type_printers "method". */
1425 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1426 struct ext_lang_type_printers
*ext_printers
)
1428 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1430 if (printers
== NULL
)
1433 if (!gdb_python_initialized
)
1436 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1437 Py_DECREF (printers
);
1440 #else /* HAVE_PYTHON */
1442 /* Dummy implementation of the gdb "python-interactive" and "python"
1446 python_interactive_command (char *arg
, int from_tty
)
1448 arg
= skip_spaces (arg
);
1450 error (_("Python scripting is not supported in this copy of GDB."));
1453 struct command_line
*l
= get_command_line (python_control
, "");
1454 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1456 execute_control_command_untraced (l
);
1457 do_cleanups (cleanups
);
1462 python_command (char *arg
, int from_tty
)
1464 python_interactive_command (arg
, from_tty
);
1467 #endif /* HAVE_PYTHON */
1471 /* Lists for 'set python' commands. */
1473 static struct cmd_list_element
*user_set_python_list
;
1474 static struct cmd_list_element
*user_show_python_list
;
1476 /* Function for use by 'set python' prefix command. */
1479 user_set_python (char *args
, int from_tty
)
1481 help_list (user_set_python_list
, "set python ", all_commands
,
1485 /* Function for use by 'show python' prefix command. */
1488 user_show_python (char *args
, int from_tty
)
1490 cmd_show_list (user_show_python_list
, from_tty
, "");
1493 /* Initialize the Python code. */
1497 /* This is installed as a final cleanup and cleans up the
1498 interpreter. This lets Python's 'atexit' work. */
1501 finalize_python (void *ignore
)
1503 struct active_ext_lang_state
*previous_active
;
1505 /* We don't use ensure_python_env here because if we ever ran the
1506 cleanup, gdb would crash -- because the cleanup calls into the
1507 Python interpreter, which we are about to destroy. It seems
1508 clearer to make the needed calls explicitly here than to create a
1509 cleanup and then mysteriously discard it. */
1511 /* This is only called as a final cleanup so we can assume the active
1512 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1513 previous_active
= set_active_ext_lang (&extension_language_python
);
1515 (void) PyGILState_Ensure ();
1516 python_gdbarch
= target_gdbarch ();
1517 python_language
= current_language
;
1521 restore_active_ext_lang (previous_active
);
1525 /* Provide a prototype to silence -Wmissing-prototypes. */
1526 extern initialize_file_ftype _initialize_python
;
1531 do_start_initialization ()
1536 size_t progsize
, count
;
1538 wchar_t *progname_copy
;
1541 #ifdef WITH_PYTHON_PATH
1542 /* Work around problem where python gets confused about where it is,
1543 and then can't find its libraries, etc.
1544 NOTE: Python assumes the following layout:
1546 /foo/lib/pythonX.Y/...
1547 This must be done before calling Py_Initialize. */
1548 progname
= concat (ldirname (python_libdir
), SLASH_STRING
, "bin",
1549 SLASH_STRING
, "python", (char *) NULL
);
1551 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1552 setlocale (LC_ALL
, "");
1553 progsize
= strlen (progname
);
1554 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1558 fprintf (stderr
, "out of memory\n");
1561 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1562 if (count
== (size_t) -1)
1565 fprintf (stderr
, "Could not convert python path to string\n");
1568 setlocale (LC_ALL
, oldloc
);
1571 /* Note that Py_SetProgramName expects the string it is passed to
1572 remain alive for the duration of the program's execution, so
1573 it is not freed after this call. */
1574 Py_SetProgramName (progname_copy
);
1576 Py_SetProgramName (progname
);
1581 PyEval_InitThreads ();
1584 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1585 /* Add _gdb module to the list of known built-in modules. */
1586 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1588 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1590 if (gdb_module
== NULL
)
1593 /* The casts to (char*) are for python 2.4. */
1594 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1595 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1596 (char*) host_name
) < 0
1597 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1598 (char*) target_name
) < 0)
1601 /* Add stream constants. */
1602 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1603 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1604 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1607 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1608 if (gdbpy_gdb_error
== NULL
1609 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1612 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1613 gdbpy_gdb_error
, NULL
);
1614 if (gdbpy_gdb_memory_error
== NULL
1615 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1616 gdbpy_gdb_memory_error
) < 0)
1619 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1620 if (gdbpy_gdberror_exc
== NULL
1621 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1622 gdbpy_gdberror_exc
) < 0)
1625 gdbpy_initialize_gdb_readline ();
1627 if (gdbpy_initialize_auto_load () < 0
1628 || gdbpy_initialize_values () < 0
1629 || gdbpy_initialize_frames () < 0
1630 || gdbpy_initialize_commands () < 0
1631 || gdbpy_initialize_symbols () < 0
1632 || gdbpy_initialize_symtabs () < 0
1633 || gdbpy_initialize_blocks () < 0
1634 || gdbpy_initialize_functions () < 0
1635 || gdbpy_initialize_parameters () < 0
1636 || gdbpy_initialize_types () < 0
1637 || gdbpy_initialize_pspace () < 0
1638 || gdbpy_initialize_objfile () < 0
1639 || gdbpy_initialize_breakpoints () < 0
1640 || gdbpy_initialize_finishbreakpoints () < 0
1641 || gdbpy_initialize_lazy_string () < 0
1642 || gdbpy_initialize_linetable () < 0
1643 || gdbpy_initialize_thread () < 0
1644 || gdbpy_initialize_inferior () < 0
1645 || gdbpy_initialize_events () < 0
1646 || gdbpy_initialize_eventregistry () < 0
1647 || gdbpy_initialize_py_events () < 0
1648 || gdbpy_initialize_event () < 0
1649 || gdbpy_initialize_stop_event () < 0
1650 || gdbpy_initialize_signal_event () < 0
1651 || gdbpy_initialize_breakpoint_event () < 0
1652 || gdbpy_initialize_continue_event () < 0
1653 || gdbpy_initialize_inferior_call_pre_event () < 0
1654 || gdbpy_initialize_inferior_call_post_event () < 0
1655 || gdbpy_initialize_register_changed_event () < 0
1656 || gdbpy_initialize_memory_changed_event () < 0
1657 || gdbpy_initialize_exited_event () < 0
1658 || gdbpy_initialize_thread_event () < 0
1659 || gdbpy_initialize_new_objfile_event () < 0
1660 || gdbpy_initialize_clear_objfiles_event () < 0
1661 || gdbpy_initialize_arch () < 0
1662 || gdbpy_initialize_xmethods () < 0
1663 || gdbpy_initialize_unwind () < 0)
1666 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1667 if (gdbpy_to_string_cst
== NULL
)
1669 gdbpy_children_cst
= PyString_FromString ("children");
1670 if (gdbpy_children_cst
== NULL
)
1672 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1673 if (gdbpy_display_hint_cst
== NULL
)
1675 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1676 if (gdbpy_doc_cst
== NULL
)
1678 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1679 if (gdbpy_enabled_cst
== NULL
)
1681 gdbpy_value_cst
= PyString_FromString ("value");
1682 if (gdbpy_value_cst
== NULL
)
1685 /* Release the GIL while gdb runs. */
1686 PyThreadState_Swap (NULL
);
1687 PyEval_ReleaseLock ();
1689 make_final_cleanup (finalize_python
, NULL
);
1691 /* Only set this when initialization has succeeded. */
1692 gdb_python_initialized
= 1;
1696 #endif /* HAVE_PYTHON */
1699 _initialize_python (void)
1701 add_com ("python-interactive", class_obscure
,
1702 python_interactive_command
,
1705 Start an interactive Python prompt.\n\
1707 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1710 Alternatively, a single-line Python command can be given as an\n\
1711 argument, and if the command is an expression, the result will be\n\
1712 printed. For example:\n\
1714 (gdb) python-interactive 2 + 3\n\
1717 #else /* HAVE_PYTHON */
1719 Start a Python interactive prompt.\n\
1721 Python scripting is not supported in this copy of GDB.\n\
1722 This command is only a placeholder.")
1723 #endif /* HAVE_PYTHON */
1725 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1727 add_com ("python", class_obscure
, python_command
,
1730 Evaluate a Python command.\n\
1732 The command can be given as an argument, for instance:\n\
1736 If no argument is given, the following lines are read and used\n\
1737 as the Python commands. Type a line containing \"end\" to indicate\n\
1738 the end of the command.")
1739 #else /* HAVE_PYTHON */
1741 Evaluate a Python command.\n\
1743 Python scripting is not supported in this copy of GDB.\n\
1744 This command is only a placeholder.")
1745 #endif /* HAVE_PYTHON */
1747 add_com_alias ("py", "python", class_obscure
, 1);
1749 /* Add set/show python print-stack. */
1750 add_prefix_cmd ("python", no_class
, user_show_python
,
1751 _("Prefix command for python preference settings."),
1752 &user_show_python_list
, "show python ", 0,
1755 add_prefix_cmd ("python", no_class
, user_set_python
,
1756 _("Prefix command for python preference settings."),
1757 &user_set_python_list
, "set python ", 0,
1760 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1761 &gdbpy_should_print_stack
, _("\
1762 Set mode for Python stack dump on error."), _("\
1763 Show the mode of Python stack printing on error."), _("\
1764 none == no stack or message will be printed.\n\
1765 full == a message and a stack will be printed.\n\
1766 message == an error message without a stack will be printed."),
1768 &user_set_python_list
,
1769 &user_show_python_list
);
1772 if (!do_start_initialization () && PyErr_Occurred ())
1773 gdbpy_print_stack ();
1774 #endif /* HAVE_PYTHON */
1779 /* Helper function for gdbpy_finish_initialization. This does the
1780 work and then returns false if an error has occurred and must be
1781 displayed, or true on success. */
1784 do_finish_initialization (const struct extension_language_defn
*extlang
)
1789 /* Add the initial data-directory to sys.path. */
1791 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1794 sys_path
= PySys_GetObject ("path");
1796 /* If sys.path is not defined yet, define it first. */
1797 if (!(sys_path
&& PyList_Check (sys_path
)))
1800 PySys_SetPath (L
"");
1804 sys_path
= PySys_GetObject ("path");
1806 if (sys_path
&& PyList_Check (sys_path
))
1808 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1809 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1815 /* Import the gdb module to finish the initialization, and
1816 add it to __main__ for convenience. */
1817 m
= PyImport_AddModule ("__main__");
1821 /* Keep the reference to gdb_python_module since it is in a global
1823 gdb_python_module
= PyImport_ImportModule ("gdb");
1824 if (gdb_python_module
== NULL
)
1826 gdbpy_print_stack ();
1827 /* This is passed in one call to warning so that blank lines aren't
1828 inserted between each line of text. */
1830 "Could not load the Python gdb module from `%s'.\n"
1831 "Limited Python support is available from the _gdb module.\n"
1832 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1833 gdb_pythondir
.c_str ());
1834 /* We return "success" here as we've already emitted the
1839 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1842 /* Perform the remaining python initializations.
1843 These must be done after GDB is at least mostly initialized.
1844 E.g., The "info pretty-printer" command needs the "info" prefix
1846 This is the extension_language_ops.finish_initialization "method". */
1849 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1851 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1853 if (!do_finish_initialization (extlang
))
1855 gdbpy_print_stack ();
1856 warning (_("internal error: Unhandled Python exception"));
1860 /* Return non-zero if Python has successfully initialized.
1861 This is the extension_languages_ops.initialized "method". */
1864 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1866 return gdb_python_initialized
;
1869 #endif /* HAVE_PYTHON */
1875 PyMethodDef python_GdbMethods
[] =
1877 { "history", gdbpy_history
, METH_VARARGS
,
1878 "Get a value from history" },
1879 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1880 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1881 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1882 a Python String containing the output of the command if to_string is\n\
1884 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1885 "Return a gdb parameter's value" },
1887 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1888 "Return a tuple of all breakpoint objects" },
1890 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1891 "Find the default visualizer for a Value." },
1893 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1894 "Return the current Progspace." },
1895 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1896 "Return a sequence of all progspaces." },
1898 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1899 "Return the current Objfile being loaded, or None." },
1900 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1901 "Return a sequence of all loaded objfiles." },
1903 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1904 "newest_frame () -> gdb.Frame.\n\
1905 Return the newest frame object." },
1906 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1907 "selected_frame () -> gdb.Frame.\n\
1908 Return the selected frame object." },
1909 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1910 "stop_reason_string (Integer) -> String.\n\
1911 Return a string explaining unwind stop reason." },
1913 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1914 METH_VARARGS
| METH_KEYWORDS
,
1915 "lookup_type (name [, block]) -> type\n\
1916 Return a Type corresponding to the given name." },
1917 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1918 METH_VARARGS
| METH_KEYWORDS
,
1919 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1920 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1921 a boolean indicating if name is a field of the current implied argument\n\
1922 `this' (when the current language is object-oriented)." },
1923 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1924 METH_VARARGS
| METH_KEYWORDS
,
1925 "lookup_global_symbol (name [, domain]) -> symbol\n\
1926 Return the symbol corresponding to the given name (or None)." },
1928 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1929 METH_VARARGS
| METH_KEYWORDS
,
1930 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1931 Look up the specified objfile.\n\
1932 If by_build_id is True, the objfile is looked up by using name\n\
1933 as its build id." },
1935 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
1936 "Return the block containing the given pc value, or None." },
1937 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
1938 "solib_name (Long) -> String.\n\
1939 Return the name of the shared library holding a given address, or None." },
1940 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1941 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1942 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1943 The first element contains any unparsed portion of the String parameter\n\
1944 (or None if the string was fully parsed). The second element contains\n\
1945 a tuple that contains all the locations that match, represented as\n\
1946 gdb.Symtab_and_line objects (or None)."},
1947 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
1948 "parse_and_eval (String) -> Value.\n\
1949 Parse String as an expression, evaluate it, and return the result as a Value."
1951 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
1952 "find_pc_line (pc) -> Symtab_and_line.\n\
1953 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1955 { "post_event", gdbpy_post_event
, METH_VARARGS
,
1956 "Post an event into gdb's event loop." },
1958 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
1959 "target_charset () -> string.\n\
1960 Return the name of the current target charset." },
1961 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
1962 "target_wide_charset () -> string.\n\
1963 Return the name of the current target wide charset." },
1965 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
1966 "string_to_argv (String) -> Array.\n\
1967 Parse String and return an argv-like array.\n\
1968 Arguments are separate by spaces and may be quoted."
1970 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
1971 "Write a string using gdb's filtered stream." },
1972 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
1973 "Flush gdb's filtered stdout stream." },
1974 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
1975 "selected_thread () -> gdb.InferiorThread.\n\
1976 Return the selected thread object." },
1977 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
1978 "selected_inferior () -> gdb.Inferior.\n\
1979 Return the selected inferior object." },
1980 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
1981 "inferiors () -> (gdb.Inferior, ...).\n\
1982 Return a tuple containing all inferiors." },
1984 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
1985 "invalidate_cached_frames () -> None.\n\
1986 Invalidate any cached frame objects in gdb.\n\
1987 Intended for internal use only." },
1989 {NULL
, NULL
, 0, NULL
}
1993 struct PyModuleDef python_GdbModuleDef
=
1995 PyModuleDef_HEAD_INIT
,
2006 #endif /* HAVE_PYTHON */