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
;
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
;
992 gdbpy_ref
result (PyObject_CallFunctionObjArgs (hook
.get (),
993 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 (), printers_obj
,
1400 if (result_obj
== NULL
)
1402 gdbpy_print_stack ();
1403 return EXT_LANG_RC_ERROR
;
1406 if (result_obj
== Py_None
)
1407 return EXT_LANG_RC_NOP
;
1409 result
= python_string_to_host_string (result_obj
.get ());
1412 gdbpy_print_stack ();
1413 return EXT_LANG_RC_ERROR
;
1416 *prettied_type
= result
.release ();
1417 return EXT_LANG_RC_OK
;
1420 /* Free the result of start_type_printers.
1421 This is the extension_language_ops.free_type_printers "method". */
1424 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1425 struct ext_lang_type_printers
*ext_printers
)
1427 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1429 if (printers
== NULL
)
1432 if (!gdb_python_initialized
)
1435 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1436 Py_DECREF (printers
);
1439 #else /* HAVE_PYTHON */
1441 /* Dummy implementation of the gdb "python-interactive" and "python"
1445 python_interactive_command (char *arg
, int from_tty
)
1447 arg
= skip_spaces (arg
);
1449 error (_("Python scripting is not supported in this copy of GDB."));
1452 struct command_line
*l
= get_command_line (python_control
, "");
1453 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1455 execute_control_command_untraced (l
);
1456 do_cleanups (cleanups
);
1461 python_command (char *arg
, int from_tty
)
1463 python_interactive_command (arg
, from_tty
);
1466 #endif /* HAVE_PYTHON */
1470 /* Lists for 'set python' commands. */
1472 static struct cmd_list_element
*user_set_python_list
;
1473 static struct cmd_list_element
*user_show_python_list
;
1475 /* Function for use by 'set python' prefix command. */
1478 user_set_python (char *args
, int from_tty
)
1480 help_list (user_set_python_list
, "set python ", all_commands
,
1484 /* Function for use by 'show python' prefix command. */
1487 user_show_python (char *args
, int from_tty
)
1489 cmd_show_list (user_show_python_list
, from_tty
, "");
1492 /* Initialize the Python code. */
1496 /* This is installed as a final cleanup and cleans up the
1497 interpreter. This lets Python's 'atexit' work. */
1500 finalize_python (void *ignore
)
1502 struct active_ext_lang_state
*previous_active
;
1504 /* We don't use ensure_python_env here because if we ever ran the
1505 cleanup, gdb would crash -- because the cleanup calls into the
1506 Python interpreter, which we are about to destroy. It seems
1507 clearer to make the needed calls explicitly here than to create a
1508 cleanup and then mysteriously discard it. */
1510 /* This is only called as a final cleanup so we can assume the active
1511 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1512 previous_active
= set_active_ext_lang (&extension_language_python
);
1514 (void) PyGILState_Ensure ();
1515 python_gdbarch
= target_gdbarch ();
1516 python_language
= current_language
;
1520 restore_active_ext_lang (previous_active
);
1524 /* Provide a prototype to silence -Wmissing-prototypes. */
1525 extern initialize_file_ftype _initialize_python
;
1528 _initialize_python (void)
1533 size_t progsize
, count
;
1535 wchar_t *progname_copy
;
1538 add_com ("python-interactive", class_obscure
,
1539 python_interactive_command
,
1542 Start an interactive Python prompt.\n\
1544 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1547 Alternatively, a single-line Python command can be given as an\n\
1548 argument, and if the command is an expression, the result will be\n\
1549 printed. For example:\n\
1551 (gdb) python-interactive 2 + 3\n\
1554 #else /* HAVE_PYTHON */
1556 Start a Python interactive prompt.\n\
1558 Python scripting is not supported in this copy of GDB.\n\
1559 This command is only a placeholder.")
1560 #endif /* HAVE_PYTHON */
1562 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1564 add_com ("python", class_obscure
, python_command
,
1567 Evaluate a Python command.\n\
1569 The command can be given as an argument, for instance:\n\
1573 If no argument is given, the following lines are read and used\n\
1574 as the Python commands. Type a line containing \"end\" to indicate\n\
1575 the end of the command.")
1576 #else /* HAVE_PYTHON */
1578 Evaluate a Python command.\n\
1580 Python scripting is not supported in this copy of GDB.\n\
1581 This command is only a placeholder.")
1582 #endif /* HAVE_PYTHON */
1584 add_com_alias ("py", "python", class_obscure
, 1);
1586 /* Add set/show python print-stack. */
1587 add_prefix_cmd ("python", no_class
, user_show_python
,
1588 _("Prefix command for python preference settings."),
1589 &user_show_python_list
, "show python ", 0,
1592 add_prefix_cmd ("python", no_class
, user_set_python
,
1593 _("Prefix command for python preference settings."),
1594 &user_set_python_list
, "set python ", 0,
1597 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1598 &gdbpy_should_print_stack
, _("\
1599 Set mode for Python stack dump on error."), _("\
1600 Show the mode of Python stack printing on error."), _("\
1601 none == no stack or message will be printed.\n\
1602 full == a message and a stack will be printed.\n\
1603 message == an error message without a stack will be printed."),
1605 &user_set_python_list
,
1606 &user_show_python_list
);
1609 #ifdef WITH_PYTHON_PATH
1610 /* Work around problem where python gets confused about where it is,
1611 and then can't find its libraries, etc.
1612 NOTE: Python assumes the following layout:
1614 /foo/lib/pythonX.Y/...
1615 This must be done before calling Py_Initialize. */
1616 progname
= concat (ldirname (python_libdir
), SLASH_STRING
, "bin",
1617 SLASH_STRING
, "python", (char *) NULL
);
1619 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1620 setlocale (LC_ALL
, "");
1621 progsize
= strlen (progname
);
1622 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1626 fprintf (stderr
, "out of memory\n");
1629 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1630 if (count
== (size_t) -1)
1633 fprintf (stderr
, "Could not convert python path to string\n");
1636 setlocale (LC_ALL
, oldloc
);
1639 /* Note that Py_SetProgramName expects the string it is passed to
1640 remain alive for the duration of the program's execution, so
1641 it is not freed after this call. */
1642 Py_SetProgramName (progname_copy
);
1644 Py_SetProgramName (progname
);
1649 PyEval_InitThreads ();
1652 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1653 /* Add _gdb module to the list of known built-in modules. */
1654 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1656 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1658 if (gdb_module
== NULL
)
1661 /* The casts to (char*) are for python 2.4. */
1662 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1663 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1664 (char*) host_name
) < 0
1665 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1666 (char*) target_name
) < 0)
1669 /* Add stream constants. */
1670 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1671 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1672 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1675 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1676 if (gdbpy_gdb_error
== NULL
1677 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1680 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1681 gdbpy_gdb_error
, NULL
);
1682 if (gdbpy_gdb_memory_error
== NULL
1683 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1684 gdbpy_gdb_memory_error
) < 0)
1687 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1688 if (gdbpy_gdberror_exc
== NULL
1689 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1690 gdbpy_gdberror_exc
) < 0)
1693 gdbpy_initialize_gdb_readline ();
1695 if (gdbpy_initialize_auto_load () < 0
1696 || gdbpy_initialize_values () < 0
1697 || gdbpy_initialize_frames () < 0
1698 || gdbpy_initialize_commands () < 0
1699 || gdbpy_initialize_symbols () < 0
1700 || gdbpy_initialize_symtabs () < 0
1701 || gdbpy_initialize_blocks () < 0
1702 || gdbpy_initialize_functions () < 0
1703 || gdbpy_initialize_parameters () < 0
1704 || gdbpy_initialize_types () < 0
1705 || gdbpy_initialize_pspace () < 0
1706 || gdbpy_initialize_objfile () < 0
1707 || gdbpy_initialize_breakpoints () < 0
1708 || gdbpy_initialize_finishbreakpoints () < 0
1709 || gdbpy_initialize_lazy_string () < 0
1710 || gdbpy_initialize_linetable () < 0
1711 || gdbpy_initialize_thread () < 0
1712 || gdbpy_initialize_inferior () < 0
1713 || gdbpy_initialize_events () < 0
1714 || gdbpy_initialize_eventregistry () < 0
1715 || gdbpy_initialize_py_events () < 0
1716 || gdbpy_initialize_event () < 0
1717 || gdbpy_initialize_stop_event () < 0
1718 || gdbpy_initialize_signal_event () < 0
1719 || gdbpy_initialize_breakpoint_event () < 0
1720 || gdbpy_initialize_continue_event () < 0
1721 || gdbpy_initialize_inferior_call_pre_event () < 0
1722 || gdbpy_initialize_inferior_call_post_event () < 0
1723 || gdbpy_initialize_register_changed_event () < 0
1724 || gdbpy_initialize_memory_changed_event () < 0
1725 || gdbpy_initialize_exited_event () < 0
1726 || gdbpy_initialize_thread_event () < 0
1727 || gdbpy_initialize_new_objfile_event () < 0
1728 || gdbpy_initialize_clear_objfiles_event () < 0
1729 || gdbpy_initialize_arch () < 0
1730 || gdbpy_initialize_xmethods () < 0
1731 || gdbpy_initialize_unwind () < 0)
1734 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1735 if (gdbpy_to_string_cst
== NULL
)
1737 gdbpy_children_cst
= PyString_FromString ("children");
1738 if (gdbpy_children_cst
== NULL
)
1740 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1741 if (gdbpy_display_hint_cst
== NULL
)
1743 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1744 if (gdbpy_doc_cst
== NULL
)
1746 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1747 if (gdbpy_enabled_cst
== NULL
)
1749 gdbpy_value_cst
= PyString_FromString ("value");
1750 if (gdbpy_value_cst
== NULL
)
1753 /* Release the GIL while gdb runs. */
1754 PyThreadState_Swap (NULL
);
1755 PyEval_ReleaseLock ();
1757 make_final_cleanup (finalize_python
, NULL
);
1759 gdb_python_initialized
= 1;
1763 gdbpy_print_stack ();
1764 /* Do not set 'gdb_python_initialized'. */
1767 #endif /* HAVE_PYTHON */
1772 /* Helper function for gdbpy_finish_initialization. This does the
1773 work and then returns false if an error has occurred and must be
1774 displayed, or true on success. */
1777 do_finish_initialization (const struct extension_language_defn
*extlang
)
1782 /* Add the initial data-directory to sys.path. */
1784 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1787 sys_path
= PySys_GetObject ("path");
1789 /* If sys.path is not defined yet, define it first. */
1790 if (!(sys_path
&& PyList_Check (sys_path
)))
1793 PySys_SetPath (L
"");
1797 sys_path
= PySys_GetObject ("path");
1799 if (sys_path
&& PyList_Check (sys_path
))
1801 gdbpy_ref
pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1802 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1808 /* Import the gdb module to finish the initialization, and
1809 add it to __main__ for convenience. */
1810 m
= PyImport_AddModule ("__main__");
1814 /* Keep the reference to gdb_python_module since it is in a global
1816 gdb_python_module
= PyImport_ImportModule ("gdb");
1817 if (gdb_python_module
== NULL
)
1819 gdbpy_print_stack ();
1820 /* This is passed in one call to warning so that blank lines aren't
1821 inserted between each line of text. */
1823 "Could not load the Python gdb module from `%s'.\n"
1824 "Limited Python support is available from the _gdb module.\n"
1825 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1826 gdb_pythondir
.c_str ());
1827 /* We return "success" here as we've already emitted the
1832 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1835 /* Perform the remaining python initializations.
1836 These must be done after GDB is at least mostly initialized.
1837 E.g., The "info pretty-printer" command needs the "info" prefix
1839 This is the extension_language_ops.finish_initialization "method". */
1842 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1844 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1846 if (!do_finish_initialization (extlang
))
1848 gdbpy_print_stack ();
1849 warning (_("internal error: Unhandled Python exception"));
1853 /* Return non-zero if Python has successfully initialized.
1854 This is the extension_languages_ops.initialized "method". */
1857 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1859 return gdb_python_initialized
;
1862 #endif /* HAVE_PYTHON */
1868 PyMethodDef python_GdbMethods
[] =
1870 { "history", gdbpy_history
, METH_VARARGS
,
1871 "Get a value from history" },
1872 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1873 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1874 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1875 a Python String containing the output of the command if to_string is\n\
1877 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1878 "Return a gdb parameter's value" },
1880 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1881 "Return a tuple of all breakpoint objects" },
1883 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1884 "Find the default visualizer for a Value." },
1886 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1887 "Return the current Progspace." },
1888 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1889 "Return a sequence of all progspaces." },
1891 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1892 "Return the current Objfile being loaded, or None." },
1893 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1894 "Return a sequence of all loaded objfiles." },
1896 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1897 "newest_frame () -> gdb.Frame.\n\
1898 Return the newest frame object." },
1899 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1900 "selected_frame () -> gdb.Frame.\n\
1901 Return the selected frame object." },
1902 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1903 "stop_reason_string (Integer) -> String.\n\
1904 Return a string explaining unwind stop reason." },
1906 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1907 METH_VARARGS
| METH_KEYWORDS
,
1908 "lookup_type (name [, block]) -> type\n\
1909 Return a Type corresponding to the given name." },
1910 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1911 METH_VARARGS
| METH_KEYWORDS
,
1912 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1913 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1914 a boolean indicating if name is a field of the current implied argument\n\
1915 `this' (when the current language is object-oriented)." },
1916 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1917 METH_VARARGS
| METH_KEYWORDS
,
1918 "lookup_global_symbol (name [, domain]) -> symbol\n\
1919 Return the symbol corresponding to the given name (or None)." },
1921 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1922 METH_VARARGS
| METH_KEYWORDS
,
1923 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1924 Look up the specified objfile.\n\
1925 If by_build_id is True, the objfile is looked up by using name\n\
1926 as its build id." },
1928 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
1929 "Return the block containing the given pc value, or None." },
1930 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
1931 "solib_name (Long) -> String.\n\
1932 Return the name of the shared library holding a given address, or None." },
1933 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1934 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1935 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1936 The first element contains any unparsed portion of the String parameter\n\
1937 (or None if the string was fully parsed). The second element contains\n\
1938 a tuple that contains all the locations that match, represented as\n\
1939 gdb.Symtab_and_line objects (or None)."},
1940 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
1941 "parse_and_eval (String) -> Value.\n\
1942 Parse String as an expression, evaluate it, and return the result as a Value."
1944 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
1945 "find_pc_line (pc) -> Symtab_and_line.\n\
1946 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1948 { "post_event", gdbpy_post_event
, METH_VARARGS
,
1949 "Post an event into gdb's event loop." },
1951 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
1952 "target_charset () -> string.\n\
1953 Return the name of the current target charset." },
1954 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
1955 "target_wide_charset () -> string.\n\
1956 Return the name of the current target wide charset." },
1958 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
1959 "string_to_argv (String) -> Array.\n\
1960 Parse String and return an argv-like array.\n\
1961 Arguments are separate by spaces and may be quoted."
1963 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
1964 "Write a string using gdb's filtered stream." },
1965 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
1966 "Flush gdb's filtered stdout stream." },
1967 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
1968 "selected_thread () -> gdb.InferiorThread.\n\
1969 Return the selected thread object." },
1970 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
1971 "selected_inferior () -> gdb.Inferior.\n\
1972 Return the selected inferior object." },
1973 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
1974 "inferiors () -> (gdb.Inferior, ...).\n\
1975 Return a tuple containing all inferiors." },
1977 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
1978 "invalidate_cached_frames () -> None.\n\
1979 Invalidate any cached frame objects in gdb.\n\
1980 Intended for internal use only." },
1982 {NULL
, NULL
, 0, NULL
}
1986 struct PyModuleDef python_GdbModuleDef
=
1988 PyModuleDef_HEAD_INIT
,
1999 #endif /* HAVE_PYTHON */