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 v
= PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
);
289 /* Implementation of the gdb "python-interactive" command. */
292 python_interactive_command (char *arg
, int from_tty
)
294 struct ui
*ui
= current_ui
;
297 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
299 arg
= skip_spaces (arg
);
301 gdbpy_enter
enter_py (get_current_arch (), current_language
);
305 int len
= strlen (arg
);
306 char *script
= (char *) xmalloc (len
+ 2);
308 strcpy (script
, arg
);
310 script
[len
+ 1] = '\0';
311 err
= eval_python_command (script
);
316 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
322 gdbpy_print_stack ();
323 error (_("Error while executing Python code."));
327 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
330 On Windows hosts few users would build Python themselves (this is no
331 trivial task on this platform), and thus use binaries built by
332 someone else instead. There may happen situation where the Python
333 library and GDB are using two different versions of the C runtime
334 library. Python, being built with VC, would use one version of the
335 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
336 A FILE * from one runtime does not necessarily operate correctly in
339 To work around this potential issue, we create on Windows hosts the
340 FILE object using Python routines, thus making sure that it is
341 compatible with the Python library. */
344 python_run_simple_file (FILE *file
, const char *filename
)
348 PyRun_SimpleFile (file
, filename
);
353 PyObject
*python_file
;
354 struct cleanup
*cleanup
;
356 /* Because we have a string for a filename, and are using Python to
357 open the file, we need to expand any tilde in the path first. */
358 full_path
= tilde_expand (filename
);
359 cleanup
= make_cleanup (xfree
, full_path
);
360 python_file
= PyFile_FromString (full_path
, "r");
363 do_cleanups (cleanup
);
364 gdbpy_print_stack ();
365 error (_("Error while opening file: %s"), full_path
);
368 make_cleanup_py_decref (python_file
);
369 PyRun_SimpleFile (PyFile_AsFile (python_file
), filename
);
370 do_cleanups (cleanup
);
375 /* Given a command_line, return a command string suitable for passing
376 to Python. Lines in the string are separated by newlines. The
377 return value is allocated using xmalloc and the caller is
378 responsible for freeing it. */
381 compute_python_string (struct command_line
*l
)
383 struct command_line
*iter
;
388 for (iter
= l
; iter
; iter
= iter
->next
)
389 size
+= strlen (iter
->line
) + 1;
391 script
= (char *) xmalloc (size
+ 1);
393 for (iter
= l
; iter
; iter
= iter
->next
)
395 int len
= strlen (iter
->line
);
397 strcpy (&script
[here
], iter
->line
);
399 script
[here
++] = '\n';
405 /* Take a command line structure representing a 'python' command, and
406 evaluate its body using the Python interpreter. */
409 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
410 struct command_line
*cmd
)
415 if (cmd
->body_count
!= 1)
416 error (_("Invalid \"python\" block structure."));
418 gdbpy_enter
enter_py (get_current_arch (), current_language
);
420 script
= compute_python_string (cmd
->body_list
[0]);
421 ret
= PyRun_SimpleString (script
);
424 error (_("Error while executing Python code."));
427 /* Implementation of the gdb "python" command. */
430 python_command (char *arg
, int from_tty
)
432 gdbpy_enter
enter_py (get_current_arch (), current_language
);
434 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
436 arg
= skip_spaces (arg
);
439 if (PyRun_SimpleString (arg
))
440 error (_("Error while executing Python code."));
444 struct command_line
*l
= get_command_line (python_control
, "");
445 struct cleanup
*cleanup
= make_cleanup_free_command_lines (&l
);
447 execute_control_command_untraced (l
);
448 do_cleanups (cleanup
);
454 /* Transform a gdb parameters's value into a Python value. May return
455 NULL (and set a Python exception) on error. Helper function for
458 gdbpy_parameter_value (enum var_types type
, void *var
)
463 case var_string_noescape
:
464 case var_optional_filename
:
468 char *str
= * (char **) var
;
472 return host_string_to_python_string (str
);
483 case var_auto_boolean
:
485 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
487 if (ab
== AUTO_BOOLEAN_TRUE
)
489 else if (ab
== AUTO_BOOLEAN_FALSE
)
496 if ((* (int *) var
) == INT_MAX
)
500 return PyLong_FromLong (* (int *) var
);
504 unsigned int val
= * (unsigned int *) var
;
508 return PyLong_FromUnsignedLong (val
);
512 return PyErr_Format (PyExc_RuntimeError
,
513 _("Programmer error: unhandled type."));
516 /* A Python function which returns a gdb parameter's value as a Python
520 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
522 struct gdb_exception except
= exception_none
;
523 struct cmd_list_element
*alias
, *prefix
, *cmd
;
528 if (! PyArg_ParseTuple (args
, "s", &arg
))
531 newarg
= concat ("show ", arg
, (char *) NULL
);
535 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
537 CATCH (ex
, RETURN_MASK_ALL
)
544 GDB_PY_HANDLE_EXCEPTION (except
);
546 return PyErr_Format (PyExc_RuntimeError
,
547 _("Could not find parameter `%s'."), arg
);
550 return PyErr_Format (PyExc_RuntimeError
,
551 _("`%s' is not a parameter."), arg
);
552 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
555 /* Wrapper for target_charset. */
558 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
560 const char *cset
= target_charset (python_gdbarch
);
562 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
565 /* Wrapper for target_wide_charset. */
568 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
570 const char *cset
= target_wide_charset (python_gdbarch
);
572 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
575 /* A Python function which evaluates a string using the gdb CLI. */
578 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
581 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
582 int from_tty
, to_string
;
583 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
585 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
586 &PyBool_Type
, &from_tty_obj
,
587 &PyBool_Type
, &to_string_obj
))
593 int cmp
= PyObject_IsTrue (from_tty_obj
);
602 int cmp
= PyObject_IsTrue (to_string_obj
);
608 std::string to_string_res
;
612 /* Copy the argument text in case the command modifies it. */
613 char *copy
= xstrdup (arg
);
614 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
615 struct interp
*interp
;
617 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
619 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
621 /* Use the console interpreter uiout to have the same print format
622 for console or MI. */
623 interp
= interp_lookup (current_ui
, "console");
624 current_uiout
= interp_ui_out (interp
);
626 prevent_dont_repeat ();
628 to_string_res
= execute_command_to_string (copy
, from_tty
);
630 execute_command (copy
, from_tty
);
631 do_cleanups (cleanup
);
633 CATCH (except
, RETURN_MASK_ALL
)
635 GDB_PY_HANDLE_EXCEPTION (except
);
639 /* Do any commands attached to breakpoint we stopped at. */
640 bpstat_do_actions ();
643 return PyString_FromString (to_string_res
.c_str ());
647 /* Implementation of gdb.solib_name (Long) -> String.
648 Returns the name of the shared library holding a given address, or None. */
651 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
657 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
660 soname
= solib_name_from_address (current_program_space
, pc
);
662 str_obj
= host_string_to_python_string (soname
);
672 /* A Python function which is a wrapper for decode_line_1. */
675 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
677 struct gdb_exception except
= exception_none
;
678 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
680 struct symtab_and_line sal
;
682 struct cleanup
*cleanups
;
683 PyObject
*result
= NULL
;
684 PyObject
*return_result
= NULL
;
685 PyObject
*unparsed
= NULL
;
686 struct event_location
*location
= NULL
;
688 if (! PyArg_ParseTuple (args
, "|s", &arg
))
691 cleanups
= make_cleanup (null_cleanup
, NULL
);
697 location
= string_to_event_location_basic (&arg
, python_language
);
698 make_cleanup_delete_event_location (location
);
703 if (location
!= NULL
)
704 sals
= decode_line_1 (location
, 0, NULL
, NULL
, 0);
707 set_default_source_symtab_and_line ();
708 sal
= get_current_source_symtab_and_line ();
713 CATCH (ex
, RETURN_MASK_ALL
)
719 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
720 make_cleanup (xfree
, sals
.sals
);
722 if (except
.reason
< 0)
724 do_cleanups (cleanups
);
725 /* We know this will always throw. */
726 gdbpy_convert_exception (except
);
734 result
= PyTuple_New (sals
.nelts
);
737 for (i
= 0; i
< sals
.nelts
; ++i
)
741 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
748 PyTuple_SetItem (result
, i
, obj
);
757 return_result
= PyTuple_New (2);
764 if (arg
!= NULL
&& strlen (arg
) > 0)
766 unparsed
= PyString_FromString (arg
);
767 if (unparsed
== NULL
)
770 Py_DECREF (return_result
);
771 return_result
= NULL
;
781 PyTuple_SetItem (return_result
, 0, unparsed
);
782 PyTuple_SetItem (return_result
, 1, result
);
785 do_cleanups (cleanups
);
787 return return_result
;
790 /* Parse a string and evaluate it as an expression. */
792 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
794 const char *expr_str
;
795 struct value
*result
= NULL
;
797 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
802 result
= parse_and_eval (expr_str
);
804 CATCH (except
, RETURN_MASK_ALL
)
806 GDB_PY_HANDLE_EXCEPTION (except
);
810 return value_to_value_object (result
);
813 /* Implementation of gdb.find_pc_line function.
814 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
817 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
819 gdb_py_ulongest pc_llu
;
820 PyObject
*result
= NULL
; /* init for gcc -Wall */
822 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
827 struct symtab_and_line sal
;
830 pc
= (CORE_ADDR
) pc_llu
;
831 sal
= find_pc_line (pc
, 0);
832 result
= symtab_and_line_to_sal_object (sal
);
834 CATCH (except
, RETURN_MASK_ALL
)
836 GDB_PY_HANDLE_EXCEPTION (except
);
843 /* Implementation of gdb.invalidate_cached_frames. */
846 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
848 reinit_frame_cache ();
852 /* Read a file as Python code.
853 This is the extension_language_script_ops.script_sourcer "method".
854 FILE is the file to load. FILENAME is name of the file FILE.
855 This does not throw any errors. If an exception occurs python will print
856 the traceback and clear the error indicator. */
859 gdbpy_source_script (const struct extension_language_defn
*extlang
,
860 FILE *file
, const char *filename
)
862 gdbpy_enter
enter_py (get_current_arch (), current_language
);
863 python_run_simple_file (file
, filename
);
868 /* Posting and handling events. */
870 /* A single event. */
873 /* The Python event. This is just a callable object. */
875 /* The next event. */
876 struct gdbpy_event
*next
;
879 /* All pending events. */
880 static struct gdbpy_event
*gdbpy_event_list
;
881 /* The final link of the event list. */
882 static struct gdbpy_event
**gdbpy_event_list_end
;
884 /* So that we can wake up the main thread even when it is blocked in
886 static struct serial_event
*gdbpy_serial_event
;
888 /* The file handler callback. This reads from the internal pipe, and
889 then processes the Python event queue. This will always be run in
890 the main gdb thread. */
893 gdbpy_run_events (int error
, gdb_client_data client_data
)
895 gdbpy_enter
enter_py (get_current_arch (), current_language
);
897 /* Clear the event fd. Do this before flushing the events list, so
898 that any new event post afterwards is sure to re-awake the event
900 serial_event_clear (gdbpy_serial_event
);
902 while (gdbpy_event_list
)
904 PyObject
*call_result
;
906 /* Dispatching the event might push a new element onto the event
907 loop, so we update here "atomically enough". */
908 struct gdbpy_event
*item
= gdbpy_event_list
;
909 gdbpy_event_list
= gdbpy_event_list
->next
;
910 if (gdbpy_event_list
== NULL
)
911 gdbpy_event_list_end
= &gdbpy_event_list
;
914 call_result
= PyObject_CallObject (item
->event
, NULL
);
915 if (call_result
== NULL
)
918 Py_XDECREF (call_result
);
919 Py_DECREF (item
->event
);
924 /* Submit an event to the gdb thread. */
926 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
928 struct gdbpy_event
*event
;
932 if (!PyArg_ParseTuple (args
, "O", &func
))
935 if (!PyCallable_Check (func
))
937 PyErr_SetString (PyExc_RuntimeError
,
938 _("Posted event is not callable"));
944 /* From here until the end of the function, we have the GIL, so we
945 can operate on our global data structures without worrying. */
946 wakeup
= gdbpy_event_list
== NULL
;
948 event
= XNEW (struct gdbpy_event
);
951 *gdbpy_event_list_end
= event
;
952 gdbpy_event_list_end
= &event
->next
;
954 /* Wake up gdb when needed. */
956 serial_event_set (gdbpy_serial_event
);
961 /* Initialize the Python event handler. */
963 gdbpy_initialize_events (void)
965 gdbpy_event_list_end
= &gdbpy_event_list
;
967 gdbpy_serial_event
= make_serial_event ();
968 add_file_handler (serial_event_fd (gdbpy_serial_event
),
969 gdbpy_run_events
, NULL
);
976 /* This is the extension_language_ops.before_prompt "method". */
978 static enum ext_lang_rc
979 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
980 const char *current_gdb_prompt
)
982 if (!gdb_python_initialized
)
983 return EXT_LANG_RC_NOP
;
985 gdbpy_enter
enter_py (get_current_arch (), current_language
);
987 if (gdb_python_module
988 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
990 gdbpy_ref
hook (PyObject_GetAttrString (gdb_python_module
,
994 gdbpy_print_stack ();
995 return EXT_LANG_RC_ERROR
;
998 if (PyCallable_Check (hook
.get ()))
1000 gdbpy_ref
current_prompt (PyString_FromString (current_gdb_prompt
));
1001 if (current_prompt
== NULL
)
1003 gdbpy_print_stack ();
1004 return EXT_LANG_RC_ERROR
;
1007 gdbpy_ref
result (PyObject_CallFunctionObjArgs (hook
.get (),
1008 current_prompt
.get (),
1012 gdbpy_print_stack ();
1013 return EXT_LANG_RC_ERROR
;
1016 /* Return type should be None, or a String. If it is None,
1017 fall through, we will not set a prompt. If it is a
1018 string, set PROMPT. Anything else, set an exception. */
1019 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1021 PyErr_Format (PyExc_RuntimeError
,
1022 _("Return from prompt_hook must " \
1023 "be either a Python string, or None"));
1024 gdbpy_print_stack ();
1025 return EXT_LANG_RC_ERROR
;
1028 if (result
!= Py_None
)
1030 gdb::unique_xmalloc_ptr
<char>
1031 prompt (python_string_to_host_string (result
.get ()));
1035 gdbpy_print_stack ();
1036 return EXT_LANG_RC_ERROR
;
1039 set_prompt (prompt
.get ());
1040 return EXT_LANG_RC_OK
;
1045 return EXT_LANG_RC_NOP
;
1052 /* A python function to write a single string using gdb's filtered
1053 output stream . The optional keyword STREAM can be used to write
1054 to a particular stream. The default stream is to gdb_stdout. */
1057 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1060 static char *keywords
[] = {"text", "stream", NULL
};
1061 int stream_type
= 0;
1063 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1069 switch (stream_type
)
1073 fprintf_filtered (gdb_stderr
, "%s", arg
);
1078 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1082 fprintf_filtered (gdb_stdout
, "%s", arg
);
1085 CATCH (except
, RETURN_MASK_ALL
)
1087 GDB_PY_HANDLE_EXCEPTION (except
);
1094 /* A python function to flush a gdb stream. The optional keyword
1095 STREAM can be used to flush a particular stream. The default stream
1099 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1101 static char *keywords
[] = {"stream", NULL
};
1102 int stream_type
= 0;
1104 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1108 switch (stream_type
)
1112 gdb_flush (gdb_stderr
);
1117 gdb_flush (gdb_stdlog
);
1121 gdb_flush (gdb_stdout
);
1127 /* Return non-zero if print-stack is not "none". */
1130 gdbpy_print_python_errors_p (void)
1132 return gdbpy_should_print_stack
!= python_excp_none
;
1135 /* Print a python exception trace, print just a message, or print
1136 nothing and clear the python exception, depending on
1137 gdbpy_should_print_stack. Only call this if a python exception is
1140 gdbpy_print_stack (void)
1143 /* Print "none", just clear exception. */
1144 if (gdbpy_should_print_stack
== python_excp_none
)
1148 /* Print "full" message and backtrace. */
1149 else if (gdbpy_should_print_stack
== python_excp_full
)
1152 /* PyErr_Print doesn't necessarily end output with a newline.
1153 This works because Python's stdout/stderr is fed through
1159 CATCH (except
, RETURN_MASK_ALL
)
1164 /* Print "message", just error print message. */
1167 PyObject
*ptype
, *pvalue
, *ptraceback
;
1169 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1171 /* Fetch the error message contained within ptype, pvalue. */
1172 gdb::unique_xmalloc_ptr
<char>
1173 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1174 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1180 /* An error occurred computing the string representation of the
1182 fprintf_filtered (gdb_stderr
,
1183 _("Error occurred computing Python error" \
1187 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1188 type
.get (), msg
.get ());
1190 CATCH (except
, RETURN_MASK_ALL
)
1196 Py_XDECREF (pvalue
);
1197 Py_XDECREF (ptraceback
);
1203 /* Return the current Progspace.
1204 There always is one. */
1207 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1211 result
= pspace_to_pspace_object (current_program_space
);
1217 /* Return a sequence holding all the Progspaces. */
1220 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1222 struct program_space
*ps
;
1224 gdbpy_ref
list (PyList_New (0));
1230 PyObject
*item
= pspace_to_pspace_object (ps
);
1232 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1236 return list
.release ();
1241 /* The "current" objfile. This is set when gdb detects that a new
1242 objfile has been loaded. It is only set for the duration of a call to
1243 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1245 static struct objfile
*gdbpy_current_objfile
;
1247 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1248 as Python code. This does not throw any errors. If an exception
1249 occurs python will print the traceback and clear the error indicator.
1250 This is the extension_language_script_ops.objfile_script_sourcer
1254 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1255 struct objfile
*objfile
, FILE *file
,
1256 const char *filename
)
1258 if (!gdb_python_initialized
)
1261 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1262 gdbpy_current_objfile
= objfile
;
1264 python_run_simple_file (file
, filename
);
1266 gdbpy_current_objfile
= NULL
;
1269 /* Set the current objfile to OBJFILE and then execute SCRIPT
1270 as Python code. This does not throw any errors. If an exception
1271 occurs python will print the traceback and clear the error indicator.
1272 This is the extension_language_script_ops.objfile_script_executor
1276 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1277 struct objfile
*objfile
, const char *name
,
1280 if (!gdb_python_initialized
)
1283 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1284 gdbpy_current_objfile
= objfile
;
1286 PyRun_SimpleString (script
);
1288 gdbpy_current_objfile
= NULL
;
1291 /* Return the current Objfile, or None if there isn't one. */
1294 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1298 if (! gdbpy_current_objfile
)
1301 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1307 /* Return a sequence holding all the Objfiles. */
1310 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1312 struct objfile
*objf
;
1314 gdbpy_ref
list (PyList_New (0));
1320 PyObject
*item
= objfile_to_objfile_object (objf
);
1322 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1326 return list
.release ();
1329 /* Compute the list of active python type printers and store them in
1330 EXT_PRINTERS->py_type_printers. The product of this function is used by
1331 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1332 This is the extension_language_ops.start_type_printers "method". */
1335 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1336 struct ext_lang_type_printers
*ext_printers
)
1338 PyObject
*type_module
, *func
= NULL
, *printers_obj
= NULL
;
1340 if (!gdb_python_initialized
)
1343 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1345 type_module
= PyImport_ImportModule ("gdb.types");
1346 if (type_module
== NULL
)
1348 gdbpy_print_stack ();
1352 func
= PyObject_GetAttrString (type_module
, "get_type_recognizers");
1355 gdbpy_print_stack ();
1359 printers_obj
= PyObject_CallFunctionObjArgs (func
, (char *) NULL
);
1360 if (printers_obj
== NULL
)
1361 gdbpy_print_stack ();
1363 ext_printers
->py_type_printers
= printers_obj
;
1366 Py_XDECREF (type_module
);
1370 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1371 a newly allocated string holding the type's replacement name, and return
1372 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1373 If there's a Python error return EXT_LANG_RC_ERROR.
1374 Otherwise, return EXT_LANG_RC_NOP.
1375 This is the extension_language_ops.apply_type_printers "method". */
1377 static enum ext_lang_rc
1378 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1379 const struct ext_lang_type_printers
*ext_printers
,
1380 struct type
*type
, char **prettied_type
)
1382 PyObject
*type_obj
, *type_module
= NULL
, *func
= NULL
;
1383 PyObject
*result_obj
= NULL
;
1384 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1385 gdb::unique_xmalloc_ptr
<char> result
;
1387 if (printers_obj
== NULL
)
1388 return EXT_LANG_RC_NOP
;
1390 if (!gdb_python_initialized
)
1391 return EXT_LANG_RC_NOP
;
1393 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1395 type_obj
= type_to_type_object (type
);
1396 if (type_obj
== NULL
)
1398 gdbpy_print_stack ();
1402 type_module
= PyImport_ImportModule ("gdb.types");
1403 if (type_module
== NULL
)
1405 gdbpy_print_stack ();
1409 func
= PyObject_GetAttrString (type_module
, "apply_type_recognizers");
1412 gdbpy_print_stack ();
1416 result_obj
= PyObject_CallFunctionObjArgs (func
, printers_obj
,
1417 type_obj
, (char *) NULL
);
1418 if (result_obj
== NULL
)
1420 gdbpy_print_stack ();
1424 if (result_obj
!= Py_None
)
1426 result
= python_string_to_host_string (result_obj
);
1428 gdbpy_print_stack ();
1432 Py_XDECREF (type_obj
);
1433 Py_XDECREF (type_module
);
1435 Py_XDECREF (result_obj
);
1438 *prettied_type
= result
.release ();
1439 return EXT_LANG_RC_OK
;
1441 return EXT_LANG_RC_ERROR
;
1444 /* Free the result of start_type_printers.
1445 This is the extension_language_ops.free_type_printers "method". */
1448 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1449 struct ext_lang_type_printers
*ext_printers
)
1451 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1453 if (printers
== NULL
)
1456 if (!gdb_python_initialized
)
1459 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1460 Py_DECREF (printers
);
1463 #else /* HAVE_PYTHON */
1465 /* Dummy implementation of the gdb "python-interactive" and "python"
1469 python_interactive_command (char *arg
, int from_tty
)
1471 arg
= skip_spaces (arg
);
1473 error (_("Python scripting is not supported in this copy of GDB."));
1476 struct command_line
*l
= get_command_line (python_control
, "");
1477 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1479 execute_control_command_untraced (l
);
1480 do_cleanups (cleanups
);
1485 python_command (char *arg
, int from_tty
)
1487 python_interactive_command (arg
, from_tty
);
1490 #endif /* HAVE_PYTHON */
1494 /* Lists for 'set python' commands. */
1496 static struct cmd_list_element
*user_set_python_list
;
1497 static struct cmd_list_element
*user_show_python_list
;
1499 /* Function for use by 'set python' prefix command. */
1502 user_set_python (char *args
, int from_tty
)
1504 help_list (user_set_python_list
, "set python ", all_commands
,
1508 /* Function for use by 'show python' prefix command. */
1511 user_show_python (char *args
, int from_tty
)
1513 cmd_show_list (user_show_python_list
, from_tty
, "");
1516 /* Initialize the Python code. */
1520 /* This is installed as a final cleanup and cleans up the
1521 interpreter. This lets Python's 'atexit' work. */
1524 finalize_python (void *ignore
)
1526 struct active_ext_lang_state
*previous_active
;
1528 /* We don't use ensure_python_env here because if we ever ran the
1529 cleanup, gdb would crash -- because the cleanup calls into the
1530 Python interpreter, which we are about to destroy. It seems
1531 clearer to make the needed calls explicitly here than to create a
1532 cleanup and then mysteriously discard it. */
1534 /* This is only called as a final cleanup so we can assume the active
1535 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1536 previous_active
= set_active_ext_lang (&extension_language_python
);
1538 (void) PyGILState_Ensure ();
1539 python_gdbarch
= target_gdbarch ();
1540 python_language
= current_language
;
1544 restore_active_ext_lang (previous_active
);
1548 /* Provide a prototype to silence -Wmissing-prototypes. */
1549 extern initialize_file_ftype _initialize_python
;
1552 _initialize_python (void)
1557 size_t progsize
, count
;
1559 wchar_t *progname_copy
;
1562 add_com ("python-interactive", class_obscure
,
1563 python_interactive_command
,
1566 Start an interactive Python prompt.\n\
1568 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1571 Alternatively, a single-line Python command can be given as an\n\
1572 argument, and if the command is an expression, the result will be\n\
1573 printed. For example:\n\
1575 (gdb) python-interactive 2 + 3\n\
1578 #else /* HAVE_PYTHON */
1580 Start a Python interactive prompt.\n\
1582 Python scripting is not supported in this copy of GDB.\n\
1583 This command is only a placeholder.")
1584 #endif /* HAVE_PYTHON */
1586 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1588 add_com ("python", class_obscure
, python_command
,
1591 Evaluate a Python command.\n\
1593 The command can be given as an argument, for instance:\n\
1597 If no argument is given, the following lines are read and used\n\
1598 as the Python commands. Type a line containing \"end\" to indicate\n\
1599 the end of the command.")
1600 #else /* HAVE_PYTHON */
1602 Evaluate a Python command.\n\
1604 Python scripting is not supported in this copy of GDB.\n\
1605 This command is only a placeholder.")
1606 #endif /* HAVE_PYTHON */
1608 add_com_alias ("py", "python", class_obscure
, 1);
1610 /* Add set/show python print-stack. */
1611 add_prefix_cmd ("python", no_class
, user_show_python
,
1612 _("Prefix command for python preference settings."),
1613 &user_show_python_list
, "show python ", 0,
1616 add_prefix_cmd ("python", no_class
, user_set_python
,
1617 _("Prefix command for python preference settings."),
1618 &user_set_python_list
, "set python ", 0,
1621 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1622 &gdbpy_should_print_stack
, _("\
1623 Set mode for Python stack dump on error."), _("\
1624 Show the mode of Python stack printing on error."), _("\
1625 none == no stack or message will be printed.\n\
1626 full == a message and a stack will be printed.\n\
1627 message == an error message without a stack will be printed."),
1629 &user_set_python_list
,
1630 &user_show_python_list
);
1633 #ifdef WITH_PYTHON_PATH
1634 /* Work around problem where python gets confused about where it is,
1635 and then can't find its libraries, etc.
1636 NOTE: Python assumes the following layout:
1638 /foo/lib/pythonX.Y/...
1639 This must be done before calling Py_Initialize. */
1640 progname
= concat (ldirname (python_libdir
), SLASH_STRING
, "bin",
1641 SLASH_STRING
, "python", (char *) NULL
);
1643 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1644 setlocale (LC_ALL
, "");
1645 progsize
= strlen (progname
);
1646 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1650 fprintf (stderr
, "out of memory\n");
1653 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1654 if (count
== (size_t) -1)
1657 fprintf (stderr
, "Could not convert python path to string\n");
1660 setlocale (LC_ALL
, oldloc
);
1663 /* Note that Py_SetProgramName expects the string it is passed to
1664 remain alive for the duration of the program's execution, so
1665 it is not freed after this call. */
1666 Py_SetProgramName (progname_copy
);
1668 Py_SetProgramName (progname
);
1673 PyEval_InitThreads ();
1676 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1677 /* Add _gdb module to the list of known built-in modules. */
1678 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1680 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1682 if (gdb_module
== NULL
)
1685 /* The casts to (char*) are for python 2.4. */
1686 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1687 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1688 (char*) host_name
) < 0
1689 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1690 (char*) target_name
) < 0)
1693 /* Add stream constants. */
1694 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1695 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1696 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1699 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1700 if (gdbpy_gdb_error
== NULL
1701 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1704 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1705 gdbpy_gdb_error
, NULL
);
1706 if (gdbpy_gdb_memory_error
== NULL
1707 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1708 gdbpy_gdb_memory_error
) < 0)
1711 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1712 if (gdbpy_gdberror_exc
== NULL
1713 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1714 gdbpy_gdberror_exc
) < 0)
1717 gdbpy_initialize_gdb_readline ();
1719 if (gdbpy_initialize_auto_load () < 0
1720 || gdbpy_initialize_values () < 0
1721 || gdbpy_initialize_frames () < 0
1722 || gdbpy_initialize_commands () < 0
1723 || gdbpy_initialize_symbols () < 0
1724 || gdbpy_initialize_symtabs () < 0
1725 || gdbpy_initialize_blocks () < 0
1726 || gdbpy_initialize_functions () < 0
1727 || gdbpy_initialize_parameters () < 0
1728 || gdbpy_initialize_types () < 0
1729 || gdbpy_initialize_pspace () < 0
1730 || gdbpy_initialize_objfile () < 0
1731 || gdbpy_initialize_breakpoints () < 0
1732 || gdbpy_initialize_finishbreakpoints () < 0
1733 || gdbpy_initialize_lazy_string () < 0
1734 || gdbpy_initialize_linetable () < 0
1735 || gdbpy_initialize_thread () < 0
1736 || gdbpy_initialize_inferior () < 0
1737 || gdbpy_initialize_events () < 0
1738 || gdbpy_initialize_eventregistry () < 0
1739 || gdbpy_initialize_py_events () < 0
1740 || gdbpy_initialize_event () < 0
1741 || gdbpy_initialize_stop_event () < 0
1742 || gdbpy_initialize_signal_event () < 0
1743 || gdbpy_initialize_breakpoint_event () < 0
1744 || gdbpy_initialize_continue_event () < 0
1745 || gdbpy_initialize_inferior_call_pre_event () < 0
1746 || gdbpy_initialize_inferior_call_post_event () < 0
1747 || gdbpy_initialize_register_changed_event () < 0
1748 || gdbpy_initialize_memory_changed_event () < 0
1749 || gdbpy_initialize_exited_event () < 0
1750 || gdbpy_initialize_thread_event () < 0
1751 || gdbpy_initialize_new_objfile_event () < 0
1752 || gdbpy_initialize_clear_objfiles_event () < 0
1753 || gdbpy_initialize_arch () < 0
1754 || gdbpy_initialize_xmethods () < 0
1755 || gdbpy_initialize_unwind () < 0)
1758 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1759 if (gdbpy_to_string_cst
== NULL
)
1761 gdbpy_children_cst
= PyString_FromString ("children");
1762 if (gdbpy_children_cst
== NULL
)
1764 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1765 if (gdbpy_display_hint_cst
== NULL
)
1767 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1768 if (gdbpy_doc_cst
== NULL
)
1770 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1771 if (gdbpy_enabled_cst
== NULL
)
1773 gdbpy_value_cst
= PyString_FromString ("value");
1774 if (gdbpy_value_cst
== NULL
)
1777 /* Release the GIL while gdb runs. */
1778 PyThreadState_Swap (NULL
);
1779 PyEval_ReleaseLock ();
1781 make_final_cleanup (finalize_python
, NULL
);
1783 gdb_python_initialized
= 1;
1787 gdbpy_print_stack ();
1788 /* Do not set 'gdb_python_initialized'. */
1791 #endif /* HAVE_PYTHON */
1796 /* Helper function for gdbpy_finish_initialization. This does the
1797 work and then returns false if an error has occurred and must be
1798 displayed, or true on success. */
1801 do_finish_initialization (const struct extension_language_defn
*extlang
)
1806 /* Add the initial data-directory to sys.path. */
1808 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1811 sys_path
= PySys_GetObject ("path");
1813 /* If sys.path is not defined yet, define it first. */
1814 if (!(sys_path
&& PyList_Check (sys_path
)))
1817 PySys_SetPath (L
"");
1821 sys_path
= PySys_GetObject ("path");
1823 if (sys_path
&& PyList_Check (sys_path
))
1825 gdbpy_ref
pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1826 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1832 /* Import the gdb module to finish the initialization, and
1833 add it to __main__ for convenience. */
1834 m
= PyImport_AddModule ("__main__");
1838 /* Keep the reference to gdb_python_module since it is in a global
1840 gdb_python_module
= PyImport_ImportModule ("gdb");
1841 if (gdb_python_module
== NULL
)
1843 gdbpy_print_stack ();
1844 /* This is passed in one call to warning so that blank lines aren't
1845 inserted between each line of text. */
1847 "Could not load the Python gdb module from `%s'.\n"
1848 "Limited Python support is available from the _gdb module.\n"
1849 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1850 gdb_pythondir
.c_str ());
1851 /* We return "success" here as we've already emitted the
1856 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1859 /* Perform the remaining python initializations.
1860 These must be done after GDB is at least mostly initialized.
1861 E.g., The "info pretty-printer" command needs the "info" prefix
1863 This is the extension_language_ops.finish_initialization "method". */
1866 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1868 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1870 if (!do_finish_initialization (extlang
))
1872 gdbpy_print_stack ();
1873 warning (_("internal error: Unhandled Python exception"));
1877 /* Return non-zero if Python has successfully initialized.
1878 This is the extension_languages_ops.initialized "method". */
1881 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1883 return gdb_python_initialized
;
1886 #endif /* HAVE_PYTHON */
1892 PyMethodDef python_GdbMethods
[] =
1894 { "history", gdbpy_history
, METH_VARARGS
,
1895 "Get a value from history" },
1896 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1897 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1898 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1899 a Python String containing the output of the command if to_string is\n\
1901 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1902 "Return a gdb parameter's value" },
1904 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1905 "Return a tuple of all breakpoint objects" },
1907 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1908 "Find the default visualizer for a Value." },
1910 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1911 "Return the current Progspace." },
1912 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1913 "Return a sequence of all progspaces." },
1915 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1916 "Return the current Objfile being loaded, or None." },
1917 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1918 "Return a sequence of all loaded objfiles." },
1920 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1921 "newest_frame () -> gdb.Frame.\n\
1922 Return the newest frame object." },
1923 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1924 "selected_frame () -> gdb.Frame.\n\
1925 Return the selected frame object." },
1926 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1927 "stop_reason_string (Integer) -> String.\n\
1928 Return a string explaining unwind stop reason." },
1930 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1931 METH_VARARGS
| METH_KEYWORDS
,
1932 "lookup_type (name [, block]) -> type\n\
1933 Return a Type corresponding to the given name." },
1934 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1935 METH_VARARGS
| METH_KEYWORDS
,
1936 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1937 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1938 a boolean indicating if name is a field of the current implied argument\n\
1939 `this' (when the current language is object-oriented)." },
1940 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1941 METH_VARARGS
| METH_KEYWORDS
,
1942 "lookup_global_symbol (name [, domain]) -> symbol\n\
1943 Return the symbol corresponding to the given name (or None)." },
1945 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1946 METH_VARARGS
| METH_KEYWORDS
,
1947 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1948 Look up the specified objfile.\n\
1949 If by_build_id is True, the objfile is looked up by using name\n\
1950 as its build id." },
1952 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
1953 "Return the block containing the given pc value, or None." },
1954 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
1955 "solib_name (Long) -> String.\n\
1956 Return the name of the shared library holding a given address, or None." },
1957 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1958 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1959 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1960 The first element contains any unparsed portion of the String parameter\n\
1961 (or None if the string was fully parsed). The second element contains\n\
1962 a tuple that contains all the locations that match, represented as\n\
1963 gdb.Symtab_and_line objects (or None)."},
1964 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
1965 "parse_and_eval (String) -> Value.\n\
1966 Parse String as an expression, evaluate it, and return the result as a Value."
1968 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
1969 "find_pc_line (pc) -> Symtab_and_line.\n\
1970 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1972 { "post_event", gdbpy_post_event
, METH_VARARGS
,
1973 "Post an event into gdb's event loop." },
1975 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
1976 "target_charset () -> string.\n\
1977 Return the name of the current target charset." },
1978 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
1979 "target_wide_charset () -> string.\n\
1980 Return the name of the current target wide charset." },
1982 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
1983 "string_to_argv (String) -> Array.\n\
1984 Parse String and return an argv-like array.\n\
1985 Arguments are separate by spaces and may be quoted."
1987 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
1988 "Write a string using gdb's filtered stream." },
1989 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
1990 "Flush gdb's filtered stdout stream." },
1991 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
1992 "selected_thread () -> gdb.InferiorThread.\n\
1993 Return the selected thread object." },
1994 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
1995 "selected_inferior () -> gdb.Inferior.\n\
1996 Return the selected inferior object." },
1997 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
1998 "inferiors () -> (gdb.Inferior, ...).\n\
1999 Return a tuple containing all inferiors." },
2001 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2002 "invalidate_cached_frames () -> None.\n\
2003 Invalidate any cached frame objects in gdb.\n\
2004 Intended for internal use only." },
2006 {NULL
, NULL
, 0, NULL
}
2010 struct PyModuleDef python_GdbModuleDef
=
2012 PyModuleDef_HEAD_INIT
,
2023 #endif /* HAVE_PYTHON */