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
);
245 restore_python_env (void *p
)
247 gdbpy_enter
*env
= (gdbpy_enter
*) p
;
252 /* Called before entering the Python interpreter to install the
253 current language and architecture to be used for Python values.
254 Also set the active extension language for GDB so that SIGINT's
255 are directed our way, and if necessary install the right SIGINT
259 ensure_python_env (struct gdbarch
*gdbarch
,
260 const struct language_defn
*language
)
262 gdbpy_enter
*env
= new gdbpy_enter (gdbarch
, language
);
264 return make_cleanup (restore_python_env
, env
);
267 /* Set the quit flag. */
270 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
272 PyErr_SetInterrupt ();
275 /* Return true if the quit flag has been set, false otherwise. */
278 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
280 return PyOS_InterruptOccurred ();
283 /* Evaluate a Python command like PyRun_SimpleString, but uses
284 Py_single_input which prints the result of expressions, and does
285 not automatically print the stack on errors. */
288 eval_python_command (const char *command
)
292 m
= PyImport_AddModule ("__main__");
296 d
= PyModule_GetDict (m
);
299 v
= PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
);
312 /* Implementation of the gdb "python-interactive" command. */
315 python_interactive_command (char *arg
, int from_tty
)
317 struct ui
*ui
= current_ui
;
320 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
322 arg
= skip_spaces (arg
);
324 gdbpy_enter
enter_py (get_current_arch (), current_language
);
328 int len
= strlen (arg
);
329 char *script
= (char *) xmalloc (len
+ 2);
331 strcpy (script
, arg
);
333 script
[len
+ 1] = '\0';
334 err
= eval_python_command (script
);
339 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
345 gdbpy_print_stack ();
346 error (_("Error while executing Python code."));
350 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
353 On Windows hosts few users would build Python themselves (this is no
354 trivial task on this platform), and thus use binaries built by
355 someone else instead. There may happen situation where the Python
356 library and GDB are using two different versions of the C runtime
357 library. Python, being built with VC, would use one version of the
358 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
359 A FILE * from one runtime does not necessarily operate correctly in
362 To work around this potential issue, we create on Windows hosts the
363 FILE object using Python routines, thus making sure that it is
364 compatible with the Python library. */
367 python_run_simple_file (FILE *file
, const char *filename
)
371 PyRun_SimpleFile (file
, filename
);
376 PyObject
*python_file
;
377 struct cleanup
*cleanup
;
379 /* Because we have a string for a filename, and are using Python to
380 open the file, we need to expand any tilde in the path first. */
381 full_path
= tilde_expand (filename
);
382 cleanup
= make_cleanup (xfree
, full_path
);
383 python_file
= PyFile_FromString (full_path
, "r");
386 do_cleanups (cleanup
);
387 gdbpy_print_stack ();
388 error (_("Error while opening file: %s"), full_path
);
391 make_cleanup_py_decref (python_file
);
392 PyRun_SimpleFile (PyFile_AsFile (python_file
), filename
);
393 do_cleanups (cleanup
);
398 /* Given a command_line, return a command string suitable for passing
399 to Python. Lines in the string are separated by newlines. The
400 return value is allocated using xmalloc and the caller is
401 responsible for freeing it. */
404 compute_python_string (struct command_line
*l
)
406 struct command_line
*iter
;
411 for (iter
= l
; iter
; iter
= iter
->next
)
412 size
+= strlen (iter
->line
) + 1;
414 script
= (char *) xmalloc (size
+ 1);
416 for (iter
= l
; iter
; iter
= iter
->next
)
418 int len
= strlen (iter
->line
);
420 strcpy (&script
[here
], iter
->line
);
422 script
[here
++] = '\n';
428 /* Take a command line structure representing a 'python' command, and
429 evaluate its body using the Python interpreter. */
432 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
433 struct command_line
*cmd
)
438 if (cmd
->body_count
!= 1)
439 error (_("Invalid \"python\" block structure."));
441 gdbpy_enter
enter_py (get_current_arch (), current_language
);
443 script
= compute_python_string (cmd
->body_list
[0]);
444 ret
= PyRun_SimpleString (script
);
447 error (_("Error while executing Python code."));
450 /* Implementation of the gdb "python" command. */
453 python_command (char *arg
, int from_tty
)
455 struct cleanup
*cleanup
;
457 cleanup
= ensure_python_env (get_current_arch (), current_language
);
459 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
461 arg
= skip_spaces (arg
);
464 if (PyRun_SimpleString (arg
))
465 error (_("Error while executing Python code."));
469 struct command_line
*l
= get_command_line (python_control
, "");
471 make_cleanup_free_command_lines (&l
);
472 execute_control_command_untraced (l
);
475 do_cleanups (cleanup
);
480 /* Transform a gdb parameters's value into a Python value. May return
481 NULL (and set a Python exception) on error. Helper function for
484 gdbpy_parameter_value (enum var_types type
, void *var
)
489 case var_string_noescape
:
490 case var_optional_filename
:
494 char *str
= * (char **) var
;
498 return host_string_to_python_string (str
);
509 case var_auto_boolean
:
511 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
513 if (ab
== AUTO_BOOLEAN_TRUE
)
515 else if (ab
== AUTO_BOOLEAN_FALSE
)
522 if ((* (int *) var
) == INT_MAX
)
526 return PyLong_FromLong (* (int *) var
);
530 unsigned int val
= * (unsigned int *) var
;
534 return PyLong_FromUnsignedLong (val
);
538 return PyErr_Format (PyExc_RuntimeError
,
539 _("Programmer error: unhandled type."));
542 /* A Python function which returns a gdb parameter's value as a Python
546 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
548 struct gdb_exception except
= exception_none
;
549 struct cmd_list_element
*alias
, *prefix
, *cmd
;
554 if (! PyArg_ParseTuple (args
, "s", &arg
))
557 newarg
= concat ("show ", arg
, (char *) NULL
);
561 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
563 CATCH (ex
, RETURN_MASK_ALL
)
570 GDB_PY_HANDLE_EXCEPTION (except
);
572 return PyErr_Format (PyExc_RuntimeError
,
573 _("Could not find parameter `%s'."), arg
);
576 return PyErr_Format (PyExc_RuntimeError
,
577 _("`%s' is not a parameter."), arg
);
578 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
581 /* Wrapper for target_charset. */
584 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
586 const char *cset
= target_charset (python_gdbarch
);
588 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
591 /* Wrapper for target_wide_charset. */
594 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
596 const char *cset
= target_wide_charset (python_gdbarch
);
598 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
601 /* A Python function which evaluates a string using the gdb CLI. */
604 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
607 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
608 int from_tty
, to_string
;
609 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
611 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
612 &PyBool_Type
, &from_tty_obj
,
613 &PyBool_Type
, &to_string_obj
))
619 int cmp
= PyObject_IsTrue (from_tty_obj
);
628 int cmp
= PyObject_IsTrue (to_string_obj
);
634 std::string to_string_res
;
638 /* Copy the argument text in case the command modifies it. */
639 char *copy
= xstrdup (arg
);
640 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
641 struct interp
*interp
;
643 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
645 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
647 /* Use the console interpreter uiout to have the same print format
648 for console or MI. */
649 interp
= interp_lookup (current_ui
, "console");
650 current_uiout
= interp_ui_out (interp
);
652 prevent_dont_repeat ();
654 to_string_res
= execute_command_to_string (copy
, from_tty
);
656 execute_command (copy
, from_tty
);
657 do_cleanups (cleanup
);
659 CATCH (except
, RETURN_MASK_ALL
)
661 GDB_PY_HANDLE_EXCEPTION (except
);
665 /* Do any commands attached to breakpoint we stopped at. */
666 bpstat_do_actions ();
669 return PyString_FromString (to_string_res
.c_str ());
673 /* Implementation of gdb.solib_name (Long) -> String.
674 Returns the name of the shared library holding a given address, or None. */
677 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
683 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
686 soname
= solib_name_from_address (current_program_space
, pc
);
688 str_obj
= host_string_to_python_string (soname
);
698 /* A Python function which is a wrapper for decode_line_1. */
701 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
703 struct gdb_exception except
= exception_none
;
704 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
706 struct symtab_and_line sal
;
708 struct cleanup
*cleanups
;
709 PyObject
*result
= NULL
;
710 PyObject
*return_result
= NULL
;
711 PyObject
*unparsed
= NULL
;
712 struct event_location
*location
= NULL
;
714 if (! PyArg_ParseTuple (args
, "|s", &arg
))
717 cleanups
= make_cleanup (null_cleanup
, NULL
);
723 location
= string_to_event_location_basic (&arg
, python_language
);
724 make_cleanup_delete_event_location (location
);
729 if (location
!= NULL
)
730 sals
= decode_line_1 (location
, 0, NULL
, NULL
, 0);
733 set_default_source_symtab_and_line ();
734 sal
= get_current_source_symtab_and_line ();
739 CATCH (ex
, RETURN_MASK_ALL
)
745 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
746 make_cleanup (xfree
, sals
.sals
);
748 if (except
.reason
< 0)
750 do_cleanups (cleanups
);
751 /* We know this will always throw. */
752 gdbpy_convert_exception (except
);
760 result
= PyTuple_New (sals
.nelts
);
763 for (i
= 0; i
< sals
.nelts
; ++i
)
767 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
774 PyTuple_SetItem (result
, i
, obj
);
783 return_result
= PyTuple_New (2);
790 if (arg
!= NULL
&& strlen (arg
) > 0)
792 unparsed
= PyString_FromString (arg
);
793 if (unparsed
== NULL
)
796 Py_DECREF (return_result
);
797 return_result
= NULL
;
807 PyTuple_SetItem (return_result
, 0, unparsed
);
808 PyTuple_SetItem (return_result
, 1, result
);
811 do_cleanups (cleanups
);
813 return return_result
;
816 /* Parse a string and evaluate it as an expression. */
818 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
820 const char *expr_str
;
821 struct value
*result
= NULL
;
823 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
828 result
= parse_and_eval (expr_str
);
830 CATCH (except
, RETURN_MASK_ALL
)
832 GDB_PY_HANDLE_EXCEPTION (except
);
836 return value_to_value_object (result
);
839 /* Implementation of gdb.find_pc_line function.
840 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
843 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
845 gdb_py_ulongest pc_llu
;
846 PyObject
*result
= NULL
; /* init for gcc -Wall */
848 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
853 struct symtab_and_line sal
;
856 pc
= (CORE_ADDR
) pc_llu
;
857 sal
= find_pc_line (pc
, 0);
858 result
= symtab_and_line_to_sal_object (sal
);
860 CATCH (except
, RETURN_MASK_ALL
)
862 GDB_PY_HANDLE_EXCEPTION (except
);
869 /* Implementation of gdb.invalidate_cached_frames. */
872 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
874 reinit_frame_cache ();
878 /* Read a file as Python code.
879 This is the extension_language_script_ops.script_sourcer "method".
880 FILE is the file to load. FILENAME is name of the file FILE.
881 This does not throw any errors. If an exception occurs python will print
882 the traceback and clear the error indicator. */
885 gdbpy_source_script (const struct extension_language_defn
*extlang
,
886 FILE *file
, const char *filename
)
888 gdbpy_enter
enter_py (get_current_arch (), current_language
);
889 python_run_simple_file (file
, filename
);
894 /* Posting and handling events. */
896 /* A single event. */
899 /* The Python event. This is just a callable object. */
901 /* The next event. */
902 struct gdbpy_event
*next
;
905 /* All pending events. */
906 static struct gdbpy_event
*gdbpy_event_list
;
907 /* The final link of the event list. */
908 static struct gdbpy_event
**gdbpy_event_list_end
;
910 /* So that we can wake up the main thread even when it is blocked in
912 static struct serial_event
*gdbpy_serial_event
;
914 /* The file handler callback. This reads from the internal pipe, and
915 then processes the Python event queue. This will always be run in
916 the main gdb thread. */
919 gdbpy_run_events (int error
, gdb_client_data client_data
)
921 gdbpy_enter
enter_py (get_current_arch (), current_language
);
923 /* Clear the event fd. Do this before flushing the events list, so
924 that any new event post afterwards is sure to re-awake the event
926 serial_event_clear (gdbpy_serial_event
);
928 while (gdbpy_event_list
)
930 PyObject
*call_result
;
932 /* Dispatching the event might push a new element onto the event
933 loop, so we update here "atomically enough". */
934 struct gdbpy_event
*item
= gdbpy_event_list
;
935 gdbpy_event_list
= gdbpy_event_list
->next
;
936 if (gdbpy_event_list
== NULL
)
937 gdbpy_event_list_end
= &gdbpy_event_list
;
940 call_result
= PyObject_CallObject (item
->event
, NULL
);
941 if (call_result
== NULL
)
944 Py_XDECREF (call_result
);
945 Py_DECREF (item
->event
);
950 /* Submit an event to the gdb thread. */
952 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
954 struct gdbpy_event
*event
;
958 if (!PyArg_ParseTuple (args
, "O", &func
))
961 if (!PyCallable_Check (func
))
963 PyErr_SetString (PyExc_RuntimeError
,
964 _("Posted event is not callable"));
970 /* From here until the end of the function, we have the GIL, so we
971 can operate on our global data structures without worrying. */
972 wakeup
= gdbpy_event_list
== NULL
;
974 event
= XNEW (struct gdbpy_event
);
977 *gdbpy_event_list_end
= event
;
978 gdbpy_event_list_end
= &event
->next
;
980 /* Wake up gdb when needed. */
982 serial_event_set (gdbpy_serial_event
);
987 /* Initialize the Python event handler. */
989 gdbpy_initialize_events (void)
991 gdbpy_event_list_end
= &gdbpy_event_list
;
993 gdbpy_serial_event
= make_serial_event ();
994 add_file_handler (serial_event_fd (gdbpy_serial_event
),
995 gdbpy_run_events
, NULL
);
1002 /* This is the extension_language_ops.before_prompt "method". */
1004 static enum ext_lang_rc
1005 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1006 const char *current_gdb_prompt
)
1008 if (!gdb_python_initialized
)
1009 return EXT_LANG_RC_NOP
;
1011 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1013 if (gdb_python_module
1014 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1016 gdbpy_ref
hook (PyObject_GetAttrString (gdb_python_module
,
1020 gdbpy_print_stack ();
1021 return EXT_LANG_RC_ERROR
;
1024 if (PyCallable_Check (hook
.get ()))
1026 gdbpy_ref
current_prompt (PyString_FromString (current_gdb_prompt
));
1027 if (current_prompt
== NULL
)
1029 gdbpy_print_stack ();
1030 return EXT_LANG_RC_ERROR
;
1033 gdbpy_ref
result (PyObject_CallFunctionObjArgs (hook
.get (),
1034 current_prompt
.get (),
1038 gdbpy_print_stack ();
1039 return EXT_LANG_RC_ERROR
;
1042 /* Return type should be None, or a String. If it is None,
1043 fall through, we will not set a prompt. If it is a
1044 string, set PROMPT. Anything else, set an exception. */
1045 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1047 PyErr_Format (PyExc_RuntimeError
,
1048 _("Return from prompt_hook must " \
1049 "be either a Python string, or None"));
1050 gdbpy_print_stack ();
1051 return EXT_LANG_RC_ERROR
;
1054 if (result
!= Py_None
)
1056 gdb::unique_xmalloc_ptr
<char>
1057 prompt (python_string_to_host_string (result
.get ()));
1061 gdbpy_print_stack ();
1062 return EXT_LANG_RC_ERROR
;
1065 set_prompt (prompt
.get ());
1066 return EXT_LANG_RC_OK
;
1071 return EXT_LANG_RC_NOP
;
1078 /* A python function to write a single string using gdb's filtered
1079 output stream . The optional keyword STREAM can be used to write
1080 to a particular stream. The default stream is to gdb_stdout. */
1083 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1086 static char *keywords
[] = {"text", "stream", NULL
};
1087 int stream_type
= 0;
1089 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1095 switch (stream_type
)
1099 fprintf_filtered (gdb_stderr
, "%s", arg
);
1104 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1108 fprintf_filtered (gdb_stdout
, "%s", arg
);
1111 CATCH (except
, RETURN_MASK_ALL
)
1113 GDB_PY_HANDLE_EXCEPTION (except
);
1120 /* A python function to flush a gdb stream. The optional keyword
1121 STREAM can be used to flush a particular stream. The default stream
1125 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1127 static char *keywords
[] = {"stream", NULL
};
1128 int stream_type
= 0;
1130 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1134 switch (stream_type
)
1138 gdb_flush (gdb_stderr
);
1143 gdb_flush (gdb_stdlog
);
1147 gdb_flush (gdb_stdout
);
1153 /* Return non-zero if print-stack is not "none". */
1156 gdbpy_print_python_errors_p (void)
1158 return gdbpy_should_print_stack
!= python_excp_none
;
1161 /* Print a python exception trace, print just a message, or print
1162 nothing and clear the python exception, depending on
1163 gdbpy_should_print_stack. Only call this if a python exception is
1166 gdbpy_print_stack (void)
1169 /* Print "none", just clear exception. */
1170 if (gdbpy_should_print_stack
== python_excp_none
)
1174 /* Print "full" message and backtrace. */
1175 else if (gdbpy_should_print_stack
== python_excp_full
)
1178 /* PyErr_Print doesn't necessarily end output with a newline.
1179 This works because Python's stdout/stderr is fed through
1185 CATCH (except
, RETURN_MASK_ALL
)
1190 /* Print "message", just error print message. */
1193 PyObject
*ptype
, *pvalue
, *ptraceback
;
1195 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1197 /* Fetch the error message contained within ptype, pvalue. */
1198 gdb::unique_xmalloc_ptr
<char>
1199 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1200 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1206 /* An error occurred computing the string representation of the
1208 fprintf_filtered (gdb_stderr
,
1209 _("Error occurred computing Python error" \
1213 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1214 type
.get (), msg
.get ());
1216 CATCH (except
, RETURN_MASK_ALL
)
1222 Py_XDECREF (pvalue
);
1223 Py_XDECREF (ptraceback
);
1229 /* Return the current Progspace.
1230 There always is one. */
1233 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1237 result
= pspace_to_pspace_object (current_program_space
);
1243 /* Return a sequence holding all the Progspaces. */
1246 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1248 struct program_space
*ps
;
1250 gdbpy_ref
list (PyList_New (0));
1256 PyObject
*item
= pspace_to_pspace_object (ps
);
1258 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1262 return list
.release ();
1267 /* The "current" objfile. This is set when gdb detects that a new
1268 objfile has been loaded. It is only set for the duration of a call to
1269 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1271 static struct objfile
*gdbpy_current_objfile
;
1273 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1274 as Python code. This does not throw any errors. If an exception
1275 occurs python will print the traceback and clear the error indicator.
1276 This is the extension_language_script_ops.objfile_script_sourcer
1280 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1281 struct objfile
*objfile
, FILE *file
,
1282 const char *filename
)
1284 if (!gdb_python_initialized
)
1287 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1288 gdbpy_current_objfile
= objfile
;
1290 python_run_simple_file (file
, filename
);
1292 gdbpy_current_objfile
= NULL
;
1295 /* Set the current objfile to OBJFILE and then execute SCRIPT
1296 as Python code. This does not throw any errors. If an exception
1297 occurs python will print the traceback and clear the error indicator.
1298 This is the extension_language_script_ops.objfile_script_executor
1302 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1303 struct objfile
*objfile
, const char *name
,
1306 if (!gdb_python_initialized
)
1309 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1310 gdbpy_current_objfile
= objfile
;
1312 PyRun_SimpleString (script
);
1314 gdbpy_current_objfile
= NULL
;
1317 /* Return the current Objfile, or None if there isn't one. */
1320 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1324 if (! gdbpy_current_objfile
)
1327 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1333 /* Return a sequence holding all the Objfiles. */
1336 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1338 struct objfile
*objf
;
1340 gdbpy_ref
list (PyList_New (0));
1346 PyObject
*item
= objfile_to_objfile_object (objf
);
1348 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1352 return list
.release ();
1355 /* Compute the list of active python type printers and store them in
1356 EXT_PRINTERS->py_type_printers. The product of this function is used by
1357 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1358 This is the extension_language_ops.start_type_printers "method". */
1361 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1362 struct ext_lang_type_printers
*ext_printers
)
1364 PyObject
*type_module
, *func
= NULL
, *printers_obj
= NULL
;
1366 if (!gdb_python_initialized
)
1369 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1371 type_module
= PyImport_ImportModule ("gdb.types");
1372 if (type_module
== NULL
)
1374 gdbpy_print_stack ();
1378 func
= PyObject_GetAttrString (type_module
, "get_type_recognizers");
1381 gdbpy_print_stack ();
1385 printers_obj
= PyObject_CallFunctionObjArgs (func
, (char *) NULL
);
1386 if (printers_obj
== NULL
)
1387 gdbpy_print_stack ();
1389 ext_printers
->py_type_printers
= printers_obj
;
1392 Py_XDECREF (type_module
);
1396 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1397 a newly allocated string holding the type's replacement name, and return
1398 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1399 If there's a Python error return EXT_LANG_RC_ERROR.
1400 Otherwise, return EXT_LANG_RC_NOP.
1401 This is the extension_language_ops.apply_type_printers "method". */
1403 static enum ext_lang_rc
1404 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1405 const struct ext_lang_type_printers
*ext_printers
,
1406 struct type
*type
, char **prettied_type
)
1408 PyObject
*type_obj
, *type_module
= NULL
, *func
= NULL
;
1409 PyObject
*result_obj
= NULL
;
1410 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1411 gdb::unique_xmalloc_ptr
<char> result
;
1413 if (printers_obj
== NULL
)
1414 return EXT_LANG_RC_NOP
;
1416 if (!gdb_python_initialized
)
1417 return EXT_LANG_RC_NOP
;
1419 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1421 type_obj
= type_to_type_object (type
);
1422 if (type_obj
== NULL
)
1424 gdbpy_print_stack ();
1428 type_module
= PyImport_ImportModule ("gdb.types");
1429 if (type_module
== NULL
)
1431 gdbpy_print_stack ();
1435 func
= PyObject_GetAttrString (type_module
, "apply_type_recognizers");
1438 gdbpy_print_stack ();
1442 result_obj
= PyObject_CallFunctionObjArgs (func
, printers_obj
,
1443 type_obj
, (char *) NULL
);
1444 if (result_obj
== NULL
)
1446 gdbpy_print_stack ();
1450 if (result_obj
!= Py_None
)
1452 result
= python_string_to_host_string (result_obj
);
1454 gdbpy_print_stack ();
1458 Py_XDECREF (type_obj
);
1459 Py_XDECREF (type_module
);
1461 Py_XDECREF (result_obj
);
1464 *prettied_type
= result
.release ();
1465 return EXT_LANG_RC_OK
;
1467 return EXT_LANG_RC_ERROR
;
1470 /* Free the result of start_type_printers.
1471 This is the extension_language_ops.free_type_printers "method". */
1474 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1475 struct ext_lang_type_printers
*ext_printers
)
1477 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1479 if (printers
== NULL
)
1482 if (!gdb_python_initialized
)
1485 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1486 Py_DECREF (printers
);
1489 #else /* HAVE_PYTHON */
1491 /* Dummy implementation of the gdb "python-interactive" and "python"
1495 python_interactive_command (char *arg
, int from_tty
)
1497 arg
= skip_spaces (arg
);
1499 error (_("Python scripting is not supported in this copy of GDB."));
1502 struct command_line
*l
= get_command_line (python_control
, "");
1503 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1505 execute_control_command_untraced (l
);
1506 do_cleanups (cleanups
);
1511 python_command (char *arg
, int from_tty
)
1513 python_interactive_command (arg
, from_tty
);
1516 #endif /* HAVE_PYTHON */
1520 /* Lists for 'set python' commands. */
1522 static struct cmd_list_element
*user_set_python_list
;
1523 static struct cmd_list_element
*user_show_python_list
;
1525 /* Function for use by 'set python' prefix command. */
1528 user_set_python (char *args
, int from_tty
)
1530 help_list (user_set_python_list
, "set python ", all_commands
,
1534 /* Function for use by 'show python' prefix command. */
1537 user_show_python (char *args
, int from_tty
)
1539 cmd_show_list (user_show_python_list
, from_tty
, "");
1542 /* Initialize the Python code. */
1546 /* This is installed as a final cleanup and cleans up the
1547 interpreter. This lets Python's 'atexit' work. */
1550 finalize_python (void *ignore
)
1552 struct active_ext_lang_state
*previous_active
;
1554 /* We don't use ensure_python_env here because if we ever ran the
1555 cleanup, gdb would crash -- because the cleanup calls into the
1556 Python interpreter, which we are about to destroy. It seems
1557 clearer to make the needed calls explicitly here than to create a
1558 cleanup and then mysteriously discard it. */
1560 /* This is only called as a final cleanup so we can assume the active
1561 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1562 previous_active
= set_active_ext_lang (&extension_language_python
);
1564 (void) PyGILState_Ensure ();
1565 python_gdbarch
= target_gdbarch ();
1566 python_language
= current_language
;
1570 restore_active_ext_lang (previous_active
);
1574 /* Provide a prototype to silence -Wmissing-prototypes. */
1575 extern initialize_file_ftype _initialize_python
;
1578 _initialize_python (void)
1583 size_t progsize
, count
;
1585 wchar_t *progname_copy
;
1588 add_com ("python-interactive", class_obscure
,
1589 python_interactive_command
,
1592 Start an interactive Python prompt.\n\
1594 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1597 Alternatively, a single-line Python command can be given as an\n\
1598 argument, and if the command is an expression, the result will be\n\
1599 printed. For example:\n\
1601 (gdb) python-interactive 2 + 3\n\
1604 #else /* HAVE_PYTHON */
1606 Start a Python interactive prompt.\n\
1608 Python scripting is not supported in this copy of GDB.\n\
1609 This command is only a placeholder.")
1610 #endif /* HAVE_PYTHON */
1612 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1614 add_com ("python", class_obscure
, python_command
,
1617 Evaluate a Python command.\n\
1619 The command can be given as an argument, for instance:\n\
1623 If no argument is given, the following lines are read and used\n\
1624 as the Python commands. Type a line containing \"end\" to indicate\n\
1625 the end of the command.")
1626 #else /* HAVE_PYTHON */
1628 Evaluate a Python command.\n\
1630 Python scripting is not supported in this copy of GDB.\n\
1631 This command is only a placeholder.")
1632 #endif /* HAVE_PYTHON */
1634 add_com_alias ("py", "python", class_obscure
, 1);
1636 /* Add set/show python print-stack. */
1637 add_prefix_cmd ("python", no_class
, user_show_python
,
1638 _("Prefix command for python preference settings."),
1639 &user_show_python_list
, "show python ", 0,
1642 add_prefix_cmd ("python", no_class
, user_set_python
,
1643 _("Prefix command for python preference settings."),
1644 &user_set_python_list
, "set python ", 0,
1647 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1648 &gdbpy_should_print_stack
, _("\
1649 Set mode for Python stack dump on error."), _("\
1650 Show the mode of Python stack printing on error."), _("\
1651 none == no stack or message will be printed.\n\
1652 full == a message and a stack will be printed.\n\
1653 message == an error message without a stack will be printed."),
1655 &user_set_python_list
,
1656 &user_show_python_list
);
1659 #ifdef WITH_PYTHON_PATH
1660 /* Work around problem where python gets confused about where it is,
1661 and then can't find its libraries, etc.
1662 NOTE: Python assumes the following layout:
1664 /foo/lib/pythonX.Y/...
1665 This must be done before calling Py_Initialize. */
1666 progname
= concat (ldirname (python_libdir
), SLASH_STRING
, "bin",
1667 SLASH_STRING
, "python", (char *) NULL
);
1669 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1670 setlocale (LC_ALL
, "");
1671 progsize
= strlen (progname
);
1672 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1676 fprintf (stderr
, "out of memory\n");
1679 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1680 if (count
== (size_t) -1)
1683 fprintf (stderr
, "Could not convert python path to string\n");
1686 setlocale (LC_ALL
, oldloc
);
1689 /* Note that Py_SetProgramName expects the string it is passed to
1690 remain alive for the duration of the program's execution, so
1691 it is not freed after this call. */
1692 Py_SetProgramName (progname_copy
);
1694 Py_SetProgramName (progname
);
1699 PyEval_InitThreads ();
1702 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1703 /* Add _gdb module to the list of known built-in modules. */
1704 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1706 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1708 if (gdb_module
== NULL
)
1711 /* The casts to (char*) are for python 2.4. */
1712 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1713 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1714 (char*) host_name
) < 0
1715 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1716 (char*) target_name
) < 0)
1719 /* Add stream constants. */
1720 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1721 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1722 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1725 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1726 if (gdbpy_gdb_error
== NULL
1727 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1730 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1731 gdbpy_gdb_error
, NULL
);
1732 if (gdbpy_gdb_memory_error
== NULL
1733 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1734 gdbpy_gdb_memory_error
) < 0)
1737 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1738 if (gdbpy_gdberror_exc
== NULL
1739 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1740 gdbpy_gdberror_exc
) < 0)
1743 gdbpy_initialize_gdb_readline ();
1745 if (gdbpy_initialize_auto_load () < 0
1746 || gdbpy_initialize_values () < 0
1747 || gdbpy_initialize_frames () < 0
1748 || gdbpy_initialize_commands () < 0
1749 || gdbpy_initialize_symbols () < 0
1750 || gdbpy_initialize_symtabs () < 0
1751 || gdbpy_initialize_blocks () < 0
1752 || gdbpy_initialize_functions () < 0
1753 || gdbpy_initialize_parameters () < 0
1754 || gdbpy_initialize_types () < 0
1755 || gdbpy_initialize_pspace () < 0
1756 || gdbpy_initialize_objfile () < 0
1757 || gdbpy_initialize_breakpoints () < 0
1758 || gdbpy_initialize_finishbreakpoints () < 0
1759 || gdbpy_initialize_lazy_string () < 0
1760 || gdbpy_initialize_linetable () < 0
1761 || gdbpy_initialize_thread () < 0
1762 || gdbpy_initialize_inferior () < 0
1763 || gdbpy_initialize_events () < 0
1764 || gdbpy_initialize_eventregistry () < 0
1765 || gdbpy_initialize_py_events () < 0
1766 || gdbpy_initialize_event () < 0
1767 || gdbpy_initialize_stop_event () < 0
1768 || gdbpy_initialize_signal_event () < 0
1769 || gdbpy_initialize_breakpoint_event () < 0
1770 || gdbpy_initialize_continue_event () < 0
1771 || gdbpy_initialize_inferior_call_pre_event () < 0
1772 || gdbpy_initialize_inferior_call_post_event () < 0
1773 || gdbpy_initialize_register_changed_event () < 0
1774 || gdbpy_initialize_memory_changed_event () < 0
1775 || gdbpy_initialize_exited_event () < 0
1776 || gdbpy_initialize_thread_event () < 0
1777 || gdbpy_initialize_new_objfile_event () < 0
1778 || gdbpy_initialize_clear_objfiles_event () < 0
1779 || gdbpy_initialize_arch () < 0
1780 || gdbpy_initialize_xmethods () < 0
1781 || gdbpy_initialize_unwind () < 0)
1784 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1785 if (gdbpy_to_string_cst
== NULL
)
1787 gdbpy_children_cst
= PyString_FromString ("children");
1788 if (gdbpy_children_cst
== NULL
)
1790 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1791 if (gdbpy_display_hint_cst
== NULL
)
1793 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1794 if (gdbpy_doc_cst
== NULL
)
1796 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1797 if (gdbpy_enabled_cst
== NULL
)
1799 gdbpy_value_cst
= PyString_FromString ("value");
1800 if (gdbpy_value_cst
== NULL
)
1803 /* Release the GIL while gdb runs. */
1804 PyThreadState_Swap (NULL
);
1805 PyEval_ReleaseLock ();
1807 make_final_cleanup (finalize_python
, NULL
);
1809 gdb_python_initialized
= 1;
1813 gdbpy_print_stack ();
1814 /* Do not set 'gdb_python_initialized'. */
1817 #endif /* HAVE_PYTHON */
1822 /* Perform the remaining python initializations.
1823 These must be done after GDB is at least mostly initialized.
1824 E.g., The "info pretty-printer" command needs the "info" prefix
1826 This is the extension_language_ops.finish_initialization "method". */
1829 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1832 char *gdb_pythondir
;
1834 struct cleanup
*cleanup
;
1836 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1838 /* Add the initial data-directory to sys.path. */
1840 gdb_pythondir
= concat (gdb_datadir
, SLASH_STRING
, "python", (char *) NULL
);
1841 make_cleanup (xfree
, gdb_pythondir
);
1843 sys_path
= PySys_GetObject ("path");
1845 /* If sys.path is not defined yet, define it first. */
1846 if (!(sys_path
&& PyList_Check (sys_path
)))
1849 PySys_SetPath (L
"");
1853 sys_path
= PySys_GetObject ("path");
1855 if (sys_path
&& PyList_Check (sys_path
))
1857 PyObject
*pythondir
;
1860 pythondir
= PyString_FromString (gdb_pythondir
);
1861 if (pythondir
== NULL
)
1864 err
= PyList_Insert (sys_path
, 0, pythondir
);
1865 Py_DECREF (pythondir
);
1872 /* Import the gdb module to finish the initialization, and
1873 add it to __main__ for convenience. */
1874 m
= PyImport_AddModule ("__main__");
1878 gdb_python_module
= PyImport_ImportModule ("gdb");
1879 if (gdb_python_module
== NULL
)
1881 gdbpy_print_stack ();
1882 /* This is passed in one call to warning so that blank lines aren't
1883 inserted between each line of text. */
1885 "Could not load the Python gdb module from `%s'.\n"
1886 "Limited Python support is available from the _gdb module.\n"
1887 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1889 do_cleanups (cleanup
);
1893 if (gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) < 0)
1896 /* Keep the reference to gdb_python_module since it is in a global
1899 do_cleanups (cleanup
);
1903 gdbpy_print_stack ();
1904 warning (_("internal error: Unhandled Python exception"));
1905 do_cleanups (cleanup
);
1908 /* Return non-zero if Python has successfully initialized.
1909 This is the extension_languages_ops.initialized "method". */
1912 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1914 return gdb_python_initialized
;
1917 #endif /* HAVE_PYTHON */
1923 PyMethodDef python_GdbMethods
[] =
1925 { "history", gdbpy_history
, METH_VARARGS
,
1926 "Get a value from history" },
1927 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1928 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1929 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1930 a Python String containing the output of the command if to_string is\n\
1932 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1933 "Return a gdb parameter's value" },
1935 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1936 "Return a tuple of all breakpoint objects" },
1938 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1939 "Find the default visualizer for a Value." },
1941 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1942 "Return the current Progspace." },
1943 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1944 "Return a sequence of all progspaces." },
1946 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1947 "Return the current Objfile being loaded, or None." },
1948 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1949 "Return a sequence of all loaded objfiles." },
1951 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1952 "newest_frame () -> gdb.Frame.\n\
1953 Return the newest frame object." },
1954 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1955 "selected_frame () -> gdb.Frame.\n\
1956 Return the selected frame object." },
1957 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1958 "stop_reason_string (Integer) -> String.\n\
1959 Return a string explaining unwind stop reason." },
1961 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1962 METH_VARARGS
| METH_KEYWORDS
,
1963 "lookup_type (name [, block]) -> type\n\
1964 Return a Type corresponding to the given name." },
1965 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1966 METH_VARARGS
| METH_KEYWORDS
,
1967 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1968 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1969 a boolean indicating if name is a field of the current implied argument\n\
1970 `this' (when the current language is object-oriented)." },
1971 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1972 METH_VARARGS
| METH_KEYWORDS
,
1973 "lookup_global_symbol (name [, domain]) -> symbol\n\
1974 Return the symbol corresponding to the given name (or None)." },
1976 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1977 METH_VARARGS
| METH_KEYWORDS
,
1978 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1979 Look up the specified objfile.\n\
1980 If by_build_id is True, the objfile is looked up by using name\n\
1981 as its build id." },
1983 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
1984 "Return the block containing the given pc value, or None." },
1985 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
1986 "solib_name (Long) -> String.\n\
1987 Return the name of the shared library holding a given address, or None." },
1988 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1989 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1990 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1991 The first element contains any unparsed portion of the String parameter\n\
1992 (or None if the string was fully parsed). The second element contains\n\
1993 a tuple that contains all the locations that match, represented as\n\
1994 gdb.Symtab_and_line objects (or None)."},
1995 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
1996 "parse_and_eval (String) -> Value.\n\
1997 Parse String as an expression, evaluate it, and return the result as a Value."
1999 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2000 "find_pc_line (pc) -> Symtab_and_line.\n\
2001 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2003 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2004 "Post an event into gdb's event loop." },
2006 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2007 "target_charset () -> string.\n\
2008 Return the name of the current target charset." },
2009 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2010 "target_wide_charset () -> string.\n\
2011 Return the name of the current target wide charset." },
2013 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2014 "string_to_argv (String) -> Array.\n\
2015 Parse String and return an argv-like array.\n\
2016 Arguments are separate by spaces and may be quoted."
2018 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2019 "Write a string using gdb's filtered stream." },
2020 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2021 "Flush gdb's filtered stdout stream." },
2022 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2023 "selected_thread () -> gdb.InferiorThread.\n\
2024 Return the selected thread object." },
2025 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2026 "selected_inferior () -> gdb.Inferior.\n\
2027 Return the selected inferior object." },
2028 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2029 "inferiors () -> (gdb.Inferior, ...).\n\
2030 Return a tuple containing all inferiors." },
2032 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2033 "invalidate_cached_frames () -> None.\n\
2034 Invalidate any cached frame objects in gdb.\n\
2035 Intended for internal use only." },
2037 {NULL
, NULL
, 0, NULL
}
2041 struct PyModuleDef python_GdbModuleDef
=
2043 PyModuleDef_HEAD_INIT
,
2054 #endif /* HAVE_PYTHON */