1 /* General python/gdb code
3 Copyright (C) 2008-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
24 #include "cli/cli-script.h"
26 #include "progspace.h"
30 #include "event-loop.h"
32 #include "readline/tilde.h"
34 #include "extension-priv.h"
35 #include "cli/cli-utils.h"
38 #include "ser-event.h"
40 /* Declared constants and enum for python stack printing. */
41 static const char python_excp_none
[] = "none";
42 static const char python_excp_full
[] = "full";
43 static const char python_excp_message
[] = "message";
45 /* "set python print-stack" choices. */
46 static const char *const python_excp_enums
[] =
54 /* The exception printing variable. 'full' if we want to print the
55 error message and stack, 'none' if we want to print nothing, and
56 'message' if we only want to print the error message. 'message' is
58 static const char *gdbpy_should_print_stack
= python_excp_message
;
61 /* Forward decls, these are defined later. */
62 extern const struct extension_language_script_ops python_extension_script_ops
;
63 extern const struct extension_language_ops python_extension_ops
;
66 /* The main struct describing GDB's interface to the Python
67 extension language. */
68 const struct extension_language_defn extension_language_python
=
80 &python_extension_script_ops
,
90 #include "cli/cli-decode.h"
94 #include "python-internal.h"
99 #include "gdbthread.h"
101 #include "event-top.h"
103 #include "py-event.h"
105 /* True if Python has been successfully initialized, false
108 int gdb_python_initialized
;
110 extern PyMethodDef python_GdbMethods
[];
113 extern struct PyModuleDef python_GdbModuleDef
;
116 PyObject
*gdb_module
;
117 PyObject
*gdb_python_module
;
119 /* Some string constants we may wish to use. */
120 PyObject
*gdbpy_to_string_cst
;
121 PyObject
*gdbpy_children_cst
;
122 PyObject
*gdbpy_display_hint_cst
;
123 PyObject
*gdbpy_doc_cst
;
124 PyObject
*gdbpy_enabled_cst
;
125 PyObject
*gdbpy_value_cst
;
127 /* The GdbError exception. */
128 PyObject
*gdbpy_gdberror_exc
;
130 /* The `gdb.error' base class. */
131 PyObject
*gdbpy_gdb_error
;
133 /* The `gdb.MemoryError' exception. */
134 PyObject
*gdbpy_gdb_memory_error
;
136 static script_sourcer_func gdbpy_source_script
;
137 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
138 static objfile_script_executor_func gdbpy_execute_objfile_script
;
139 static void gdbpy_finish_initialization
140 (const struct extension_language_defn
*);
141 static int gdbpy_initialized (const struct extension_language_defn
*);
142 static void gdbpy_eval_from_control_command
143 (const struct extension_language_defn
*, struct command_line
*cmd
);
144 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
145 struct ext_lang_type_printers
*);
146 static enum ext_lang_rc gdbpy_apply_type_printers
147 (const struct extension_language_defn
*,
148 const struct ext_lang_type_printers
*, struct type
*, char **);
149 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
150 struct ext_lang_type_printers
*);
151 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
152 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
153 static enum ext_lang_rc gdbpy_before_prompt_hook
154 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
156 /* The interface between gdb proper and loading of python scripts. */
158 const struct extension_language_script_ops python_extension_script_ops
=
161 gdbpy_source_objfile_script
,
162 gdbpy_execute_objfile_script
,
163 gdbpy_auto_load_enabled
166 /* The interface between gdb proper and python extensions. */
168 const struct extension_language_ops python_extension_ops
=
170 gdbpy_finish_initialization
,
173 gdbpy_eval_from_control_command
,
175 gdbpy_start_type_printers
,
176 gdbpy_apply_type_printers
,
177 gdbpy_free_type_printers
,
179 gdbpy_apply_val_pretty_printer
,
181 gdbpy_apply_frame_filter
,
183 gdbpy_preserve_values
,
185 gdbpy_breakpoint_has_cond
,
186 gdbpy_breakpoint_cond_says_stop
,
189 gdbpy_check_quit_flag
,
191 gdbpy_before_prompt_hook
,
193 gdbpy_clone_xmethod_worker_data
,
194 gdbpy_free_xmethod_worker_data
,
195 gdbpy_get_matching_xmethod_workers
,
196 gdbpy_get_xmethod_arg_types
,
197 gdbpy_get_xmethod_result_type
,
201 /* Architecture and language to be used in callbacks from
202 the Python interpreter. */
203 struct gdbarch
*python_gdbarch
;
204 const struct language_defn
*python_language
;
206 gdbpy_enter::gdbpy_enter (struct gdbarch
*gdbarch
,
207 const struct language_defn
*language
)
208 : m_gdbarch (python_gdbarch
),
209 m_language (python_language
)
211 /* We should not ever enter Python unless initialized. */
212 if (!gdb_python_initialized
)
213 error (_("Python not initialized"));
215 m_previous_active
= set_active_ext_lang (&extension_language_python
);
217 m_state
= PyGILState_Ensure ();
219 python_gdbarch
= gdbarch
;
220 python_language
= language
;
222 /* Save it and ensure ! PyErr_Occurred () afterwards. */
223 PyErr_Fetch (&m_error_type
, &m_error_value
, &m_error_traceback
);
226 gdbpy_enter::~gdbpy_enter ()
228 /* Leftover Python error is forbidden by Python Exception Handling. */
229 if (PyErr_Occurred ())
231 /* This order is similar to the one calling error afterwards. */
232 gdbpy_print_stack ();
233 warning (_("internal error: Unhandled Python exception"));
236 PyErr_Restore (m_error_type
, m_error_value
, m_error_traceback
);
238 PyGILState_Release (m_state
);
239 python_gdbarch
= m_gdbarch
;
240 python_language
= m_language
;
242 restore_active_ext_lang (m_previous_active
);
245 /* Set the quit flag. */
248 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
250 PyErr_SetInterrupt ();
253 /* Return true if the quit flag has been set, false otherwise. */
256 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
258 return PyOS_InterruptOccurred ();
261 /* Evaluate a Python command like PyRun_SimpleString, but uses
262 Py_single_input which prints the result of expressions, and does
263 not automatically print the stack on errors. */
266 eval_python_command (const char *command
)
270 m
= PyImport_AddModule ("__main__");
274 d
= PyModule_GetDict (m
);
277 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
289 /* Implementation of the gdb "python-interactive" command. */
292 python_interactive_command (char *arg
, int from_tty
)
294 struct ui
*ui
= current_ui
;
297 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
299 arg
= skip_spaces (arg
);
301 gdbpy_enter
enter_py (get_current_arch (), current_language
);
305 int len
= strlen (arg
);
306 char *script
= (char *) xmalloc (len
+ 2);
308 strcpy (script
, arg
);
310 script
[len
+ 1] = '\0';
311 err
= eval_python_command (script
);
316 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
322 gdbpy_print_stack ();
323 error (_("Error while executing Python code."));
327 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
330 On Windows hosts few users would build Python themselves (this is no
331 trivial task on this platform), and thus use binaries built by
332 someone else instead. There may happen situation where the Python
333 library and GDB are using two different versions of the C runtime
334 library. Python, being built with VC, would use one version of the
335 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
336 A FILE * from one runtime does not necessarily operate correctly in
339 To work around this potential issue, we create on Windows hosts the
340 FILE object using Python routines, thus making sure that it is
341 compatible with the Python library. */
344 python_run_simple_file (FILE *file
, const char *filename
)
348 PyRun_SimpleFile (file
, filename
);
352 /* Because we have a string for a filename, and are using Python to
353 open the file, we need to expand any tilde in the path first. */
354 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
355 gdbpy_ref
<> python_file (PyFile_FromString (full_path
.get (), (char *) "r"));
356 if (python_file
== NULL
)
358 gdbpy_print_stack ();
359 error (_("Error while opening file: %s"), full_path
.get ());
362 PyRun_SimpleFile (PyFile_AsFile (python_file
.get ()), filename
);
367 /* Given a command_line, return a command string suitable for passing
368 to Python. Lines in the string are separated by newlines. The
369 return value is allocated using xmalloc and the caller is
370 responsible for freeing it. */
373 compute_python_string (struct command_line
*l
)
375 struct command_line
*iter
;
380 for (iter
= l
; iter
; iter
= iter
->next
)
381 size
+= strlen (iter
->line
) + 1;
383 script
= (char *) xmalloc (size
+ 1);
385 for (iter
= l
; iter
; iter
= iter
->next
)
387 int len
= strlen (iter
->line
);
389 strcpy (&script
[here
], iter
->line
);
391 script
[here
++] = '\n';
397 /* Take a command line structure representing a 'python' command, and
398 evaluate its body using the Python interpreter. */
401 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
402 struct command_line
*cmd
)
407 if (cmd
->body_count
!= 1)
408 error (_("Invalid \"python\" block structure."));
410 gdbpy_enter
enter_py (get_current_arch (), current_language
);
412 script
= compute_python_string (cmd
->body_list
[0]);
413 ret
= PyRun_SimpleString (script
);
416 error (_("Error while executing Python code."));
419 /* Implementation of the gdb "python" command. */
422 python_command (char *arg
, int from_tty
)
424 gdbpy_enter
enter_py (get_current_arch (), current_language
);
426 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
428 arg
= skip_spaces (arg
);
431 if (PyRun_SimpleString (arg
))
432 error (_("Error while executing Python code."));
436 command_line_up l
= get_command_line (python_control
, "");
438 execute_control_command_untraced (l
.get ());
444 /* Transform a gdb parameters's value into a Python value. May return
445 NULL (and set a Python exception) on error. Helper function for
448 gdbpy_parameter_value (enum var_types type
, void *var
)
453 case var_string_noescape
:
454 case var_optional_filename
:
458 const char *str
= *(char **) var
;
462 return host_string_to_python_string (str
);
473 case var_auto_boolean
:
475 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
477 if (ab
== AUTO_BOOLEAN_TRUE
)
479 else if (ab
== AUTO_BOOLEAN_FALSE
)
486 if ((* (int *) var
) == INT_MAX
)
490 return PyLong_FromLong (* (int *) var
);
494 unsigned int val
= * (unsigned int *) var
;
498 return PyLong_FromUnsignedLong (val
);
502 return PyErr_Format (PyExc_RuntimeError
,
503 _("Programmer error: unhandled type."));
506 /* A Python function which returns a gdb parameter's value as a Python
510 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
512 struct gdb_exception except
= exception_none
;
513 struct cmd_list_element
*alias
, *prefix
, *cmd
;
518 if (! PyArg_ParseTuple (args
, "s", &arg
))
521 newarg
= concat ("show ", arg
, (char *) NULL
);
525 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
527 CATCH (ex
, RETURN_MASK_ALL
)
534 GDB_PY_HANDLE_EXCEPTION (except
);
536 return PyErr_Format (PyExc_RuntimeError
,
537 _("Could not find parameter `%s'."), arg
);
540 return PyErr_Format (PyExc_RuntimeError
,
541 _("`%s' is not a parameter."), arg
);
542 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
545 /* Wrapper for target_charset. */
548 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
550 const char *cset
= target_charset (python_gdbarch
);
552 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
555 /* Wrapper for target_wide_charset. */
558 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
560 const char *cset
= target_wide_charset (python_gdbarch
);
562 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
565 /* A Python function which evaluates a string using the gdb CLI. */
568 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
571 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
572 int from_tty
, to_string
;
573 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
575 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
576 &PyBool_Type
, &from_tty_obj
,
577 &PyBool_Type
, &to_string_obj
))
583 int cmp
= PyObject_IsTrue (from_tty_obj
);
592 int cmp
= PyObject_IsTrue (to_string_obj
);
598 std::string to_string_res
;
602 /* Copy the argument text in case the command modifies it. */
603 std::string
copy (arg
);
604 struct interp
*interp
;
606 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
608 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
610 /* Use the console interpreter uiout to have the same print format
611 for console or MI. */
612 interp
= interp_lookup (current_ui
, "console");
613 current_uiout
= interp_ui_out (interp
);
615 scoped_restore preventer
= prevent_dont_repeat ();
617 to_string_res
= execute_command_to_string (©
[0], from_tty
);
619 execute_command (©
[0], from_tty
);
621 CATCH (except
, RETURN_MASK_ALL
)
623 GDB_PY_HANDLE_EXCEPTION (except
);
627 /* Do any commands attached to breakpoint we stopped at. */
628 bpstat_do_actions ();
631 return PyString_FromString (to_string_res
.c_str ());
635 /* Implementation of gdb.solib_name (Long) -> String.
636 Returns the name of the shared library holding a given address, or None. */
639 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
645 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
648 soname
= solib_name_from_address (current_program_space
, pc
);
650 str_obj
= host_string_to_python_string (soname
);
660 /* A Python function which is a wrapper for decode_line_1. */
663 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
665 struct gdb_exception except
= exception_none
;
666 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
668 struct symtab_and_line sal
;
670 struct cleanup
*cleanups
;
672 gdbpy_ref
<> unparsed
;
673 event_location_up location
;
675 if (! PyArg_ParseTuple (args
, "|s", &arg
))
678 cleanups
= make_cleanup (null_cleanup
, NULL
);
683 location
= string_to_event_location_basic (&arg
, python_language
);
687 if (location
!= NULL
)
688 sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
691 set_default_source_symtab_and_line ();
692 sal
= get_current_source_symtab_and_line ();
697 CATCH (ex
, RETURN_MASK_ALL
)
703 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
704 make_cleanup (xfree
, sals
.sals
);
706 if (except
.reason
< 0)
708 do_cleanups (cleanups
);
709 /* We know this will always throw. */
710 gdbpy_convert_exception (except
);
718 result
.reset (PyTuple_New (sals
.nelts
));
721 do_cleanups (cleanups
);
724 for (i
= 0; i
< sals
.nelts
; ++i
)
728 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
731 do_cleanups (cleanups
);
735 PyTuple_SetItem (result
.get (), i
, obj
);
740 result
.reset (Py_None
);
744 gdbpy_ref
<> return_result (PyTuple_New (2));
745 if (return_result
== NULL
)
747 do_cleanups (cleanups
);
751 if (arg
!= NULL
&& strlen (arg
) > 0)
753 unparsed
.reset (PyString_FromString (arg
));
754 if (unparsed
== NULL
)
756 do_cleanups (cleanups
);
762 unparsed
.reset (Py_None
);
766 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
767 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
769 do_cleanups (cleanups
);
771 return return_result
.release ();
774 /* Parse a string and evaluate it as an expression. */
776 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
778 const char *expr_str
;
779 struct value
*result
= NULL
;
781 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
786 result
= parse_and_eval (expr_str
);
788 CATCH (except
, RETURN_MASK_ALL
)
790 GDB_PY_HANDLE_EXCEPTION (except
);
794 return value_to_value_object (result
);
797 /* Implementation of gdb.find_pc_line function.
798 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
801 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
803 gdb_py_ulongest pc_llu
;
804 PyObject
*result
= NULL
; /* init for gcc -Wall */
806 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
811 struct symtab_and_line sal
;
814 pc
= (CORE_ADDR
) pc_llu
;
815 sal
= find_pc_line (pc
, 0);
816 result
= symtab_and_line_to_sal_object (sal
);
818 CATCH (except
, RETURN_MASK_ALL
)
820 GDB_PY_HANDLE_EXCEPTION (except
);
827 /* Implementation of gdb.invalidate_cached_frames. */
830 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
832 reinit_frame_cache ();
836 /* Read a file as Python code.
837 This is the extension_language_script_ops.script_sourcer "method".
838 FILE is the file to load. FILENAME is name of the file FILE.
839 This does not throw any errors. If an exception occurs python will print
840 the traceback and clear the error indicator. */
843 gdbpy_source_script (const struct extension_language_defn
*extlang
,
844 FILE *file
, const char *filename
)
846 gdbpy_enter
enter_py (get_current_arch (), current_language
);
847 python_run_simple_file (file
, filename
);
852 /* Posting and handling events. */
854 /* A single event. */
857 /* The Python event. This is just a callable object. */
859 /* The next event. */
860 struct gdbpy_event
*next
;
863 /* All pending events. */
864 static struct gdbpy_event
*gdbpy_event_list
;
865 /* The final link of the event list. */
866 static struct gdbpy_event
**gdbpy_event_list_end
;
868 /* So that we can wake up the main thread even when it is blocked in
870 static struct serial_event
*gdbpy_serial_event
;
872 /* The file handler callback. This reads from the internal pipe, and
873 then processes the Python event queue. This will always be run in
874 the main gdb thread. */
877 gdbpy_run_events (int error
, gdb_client_data client_data
)
879 gdbpy_enter
enter_py (get_current_arch (), current_language
);
881 /* Clear the event fd. Do this before flushing the events list, so
882 that any new event post afterwards is sure to re-awake the event
884 serial_event_clear (gdbpy_serial_event
);
886 while (gdbpy_event_list
)
888 /* Dispatching the event might push a new element onto the event
889 loop, so we update here "atomically enough". */
890 struct gdbpy_event
*item
= gdbpy_event_list
;
891 gdbpy_event_list
= gdbpy_event_list
->next
;
892 if (gdbpy_event_list
== NULL
)
893 gdbpy_event_list_end
= &gdbpy_event_list
;
896 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
897 if (call_result
== NULL
)
900 Py_DECREF (item
->event
);
905 /* Submit an event to the gdb thread. */
907 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
909 struct gdbpy_event
*event
;
913 if (!PyArg_ParseTuple (args
, "O", &func
))
916 if (!PyCallable_Check (func
))
918 PyErr_SetString (PyExc_RuntimeError
,
919 _("Posted event is not callable"));
925 /* From here until the end of the function, we have the GIL, so we
926 can operate on our global data structures without worrying. */
927 wakeup
= gdbpy_event_list
== NULL
;
929 event
= XNEW (struct gdbpy_event
);
932 *gdbpy_event_list_end
= event
;
933 gdbpy_event_list_end
= &event
->next
;
935 /* Wake up gdb when needed. */
937 serial_event_set (gdbpy_serial_event
);
942 /* Initialize the Python event handler. */
944 gdbpy_initialize_events (void)
946 gdbpy_event_list_end
= &gdbpy_event_list
;
948 gdbpy_serial_event
= make_serial_event ();
949 add_file_handler (serial_event_fd (gdbpy_serial_event
),
950 gdbpy_run_events
, NULL
);
957 /* This is the extension_language_ops.before_prompt "method". */
959 static enum ext_lang_rc
960 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
961 const char *current_gdb_prompt
)
963 if (!gdb_python_initialized
)
964 return EXT_LANG_RC_NOP
;
966 gdbpy_enter
enter_py (get_current_arch (), current_language
);
968 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
969 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
970 return EXT_LANG_RC_ERROR
;
972 if (gdb_python_module
973 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
975 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
979 gdbpy_print_stack ();
980 return EXT_LANG_RC_ERROR
;
983 if (PyCallable_Check (hook
.get ()))
985 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
986 if (current_prompt
== NULL
)
988 gdbpy_print_stack ();
989 return EXT_LANG_RC_ERROR
;
993 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
997 gdbpy_print_stack ();
998 return EXT_LANG_RC_ERROR
;
1001 /* Return type should be None, or a String. If it is None,
1002 fall through, we will not set a prompt. If it is a
1003 string, set PROMPT. Anything else, set an exception. */
1004 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1006 PyErr_Format (PyExc_RuntimeError
,
1007 _("Return from prompt_hook must " \
1008 "be either a Python string, or None"));
1009 gdbpy_print_stack ();
1010 return EXT_LANG_RC_ERROR
;
1013 if (result
!= Py_None
)
1015 gdb::unique_xmalloc_ptr
<char>
1016 prompt (python_string_to_host_string (result
.get ()));
1020 gdbpy_print_stack ();
1021 return EXT_LANG_RC_ERROR
;
1024 set_prompt (prompt
.get ());
1025 return EXT_LANG_RC_OK
;
1030 return EXT_LANG_RC_NOP
;
1037 /* A python function to write a single string using gdb's filtered
1038 output stream . The optional keyword STREAM can be used to write
1039 to a particular stream. The default stream is to gdb_stdout. */
1042 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1045 static const char *keywords
[] = { "text", "stream", NULL
};
1046 int stream_type
= 0;
1048 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1054 switch (stream_type
)
1058 fprintf_filtered (gdb_stderr
, "%s", arg
);
1063 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1067 fprintf_filtered (gdb_stdout
, "%s", arg
);
1070 CATCH (except
, RETURN_MASK_ALL
)
1072 GDB_PY_HANDLE_EXCEPTION (except
);
1079 /* A python function to flush a gdb stream. The optional keyword
1080 STREAM can be used to flush a particular stream. The default stream
1084 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1086 static const char *keywords
[] = { "stream", NULL
};
1087 int stream_type
= 0;
1089 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1093 switch (stream_type
)
1097 gdb_flush (gdb_stderr
);
1102 gdb_flush (gdb_stdlog
);
1106 gdb_flush (gdb_stdout
);
1112 /* Return non-zero if print-stack is not "none". */
1115 gdbpy_print_python_errors_p (void)
1117 return gdbpy_should_print_stack
!= python_excp_none
;
1120 /* Print a python exception trace, print just a message, or print
1121 nothing and clear the python exception, depending on
1122 gdbpy_should_print_stack. Only call this if a python exception is
1125 gdbpy_print_stack (void)
1128 /* Print "none", just clear exception. */
1129 if (gdbpy_should_print_stack
== python_excp_none
)
1133 /* Print "full" message and backtrace. */
1134 else if (gdbpy_should_print_stack
== python_excp_full
)
1137 /* PyErr_Print doesn't necessarily end output with a newline.
1138 This works because Python's stdout/stderr is fed through
1144 CATCH (except
, RETURN_MASK_ALL
)
1149 /* Print "message", just error print message. */
1152 PyObject
*ptype
, *pvalue
, *ptraceback
;
1154 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1156 /* Fetch the error message contained within ptype, pvalue. */
1157 gdb::unique_xmalloc_ptr
<char>
1158 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1159 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1165 /* An error occurred computing the string representation of the
1167 fprintf_filtered (gdb_stderr
,
1168 _("Error occurred computing Python error" \
1172 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1173 type
.get (), msg
.get ());
1175 CATCH (except
, RETURN_MASK_ALL
)
1181 Py_XDECREF (pvalue
);
1182 Py_XDECREF (ptraceback
);
1188 /* Return the current Progspace.
1189 There always is one. */
1192 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1196 result
= pspace_to_pspace_object (current_program_space
);
1202 /* Return a sequence holding all the Progspaces. */
1205 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1207 struct program_space
*ps
;
1209 gdbpy_ref
<> list (PyList_New (0));
1215 PyObject
*item
= pspace_to_pspace_object (ps
);
1217 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1221 return list
.release ();
1226 /* The "current" objfile. This is set when gdb detects that a new
1227 objfile has been loaded. It is only set for the duration of a call to
1228 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1230 static struct objfile
*gdbpy_current_objfile
;
1232 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1233 as Python code. This does not throw any errors. If an exception
1234 occurs python will print the traceback and clear the error indicator.
1235 This is the extension_language_script_ops.objfile_script_sourcer
1239 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1240 struct objfile
*objfile
, FILE *file
,
1241 const char *filename
)
1243 if (!gdb_python_initialized
)
1246 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1247 gdbpy_current_objfile
= objfile
;
1249 python_run_simple_file (file
, filename
);
1251 gdbpy_current_objfile
= NULL
;
1254 /* Set the current objfile to OBJFILE and then execute SCRIPT
1255 as Python code. This does not throw any errors. If an exception
1256 occurs python will print the traceback and clear the error indicator.
1257 This is the extension_language_script_ops.objfile_script_executor
1261 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1262 struct objfile
*objfile
, const char *name
,
1265 if (!gdb_python_initialized
)
1268 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1269 gdbpy_current_objfile
= objfile
;
1271 PyRun_SimpleString (script
);
1273 gdbpy_current_objfile
= NULL
;
1276 /* Return the current Objfile, or None if there isn't one. */
1279 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1283 if (! gdbpy_current_objfile
)
1286 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1292 /* Return a sequence holding all the Objfiles. */
1295 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1297 struct objfile
*objf
;
1299 gdbpy_ref
<> list (PyList_New (0));
1305 PyObject
*item
= objfile_to_objfile_object (objf
);
1307 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1311 return list
.release ();
1314 /* Compute the list of active python type printers and store them in
1315 EXT_PRINTERS->py_type_printers. The product of this function is used by
1316 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1317 This is the extension_language_ops.start_type_printers "method". */
1320 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1321 struct ext_lang_type_printers
*ext_printers
)
1323 PyObject
*printers_obj
= NULL
;
1325 if (!gdb_python_initialized
)
1328 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1330 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1331 if (type_module
== NULL
)
1333 gdbpy_print_stack ();
1337 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1338 "get_type_recognizers"));
1341 gdbpy_print_stack ();
1345 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1346 if (printers_obj
== NULL
)
1347 gdbpy_print_stack ();
1349 ext_printers
->py_type_printers
= printers_obj
;
1352 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1353 a newly allocated string holding the type's replacement name, and return
1354 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1355 If there's a Python error return EXT_LANG_RC_ERROR.
1356 Otherwise, return EXT_LANG_RC_NOP.
1357 This is the extension_language_ops.apply_type_printers "method". */
1359 static enum ext_lang_rc
1360 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1361 const struct ext_lang_type_printers
*ext_printers
,
1362 struct type
*type
, char **prettied_type
)
1364 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1365 gdb::unique_xmalloc_ptr
<char> result
;
1367 if (printers_obj
== NULL
)
1368 return EXT_LANG_RC_NOP
;
1370 if (!gdb_python_initialized
)
1371 return EXT_LANG_RC_NOP
;
1373 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1375 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1376 if (type_obj
== NULL
)
1378 gdbpy_print_stack ();
1379 return EXT_LANG_RC_ERROR
;
1382 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1383 if (type_module
== NULL
)
1385 gdbpy_print_stack ();
1386 return EXT_LANG_RC_ERROR
;
1389 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1390 "apply_type_recognizers"));
1393 gdbpy_print_stack ();
1394 return EXT_LANG_RC_ERROR
;
1397 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1401 if (result_obj
== NULL
)
1403 gdbpy_print_stack ();
1404 return EXT_LANG_RC_ERROR
;
1407 if (result_obj
== Py_None
)
1408 return EXT_LANG_RC_NOP
;
1410 result
= python_string_to_host_string (result_obj
.get ());
1413 gdbpy_print_stack ();
1414 return EXT_LANG_RC_ERROR
;
1417 *prettied_type
= result
.release ();
1418 return EXT_LANG_RC_OK
;
1421 /* Free the result of start_type_printers.
1422 This is the extension_language_ops.free_type_printers "method". */
1425 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1426 struct ext_lang_type_printers
*ext_printers
)
1428 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1430 if (printers
== NULL
)
1433 if (!gdb_python_initialized
)
1436 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1437 Py_DECREF (printers
);
1440 #else /* HAVE_PYTHON */
1442 /* Dummy implementation of the gdb "python-interactive" and "python"
1446 python_interactive_command (char *arg
, int from_tty
)
1448 arg
= skip_spaces (arg
);
1450 error (_("Python scripting is not supported in this copy of GDB."));
1453 command_line_up l
= get_command_line (python_control
, "");
1455 execute_control_command_untraced (l
.get ());
1460 python_command (char *arg
, int from_tty
)
1462 python_interactive_command (arg
, from_tty
);
1465 #endif /* HAVE_PYTHON */
1469 /* Lists for 'set python' commands. */
1471 static struct cmd_list_element
*user_set_python_list
;
1472 static struct cmd_list_element
*user_show_python_list
;
1474 /* Function for use by 'set python' prefix command. */
1477 user_set_python (char *args
, int from_tty
)
1479 help_list (user_set_python_list
, "set python ", all_commands
,
1483 /* Function for use by 'show python' prefix command. */
1486 user_show_python (char *args
, int from_tty
)
1488 cmd_show_list (user_show_python_list
, from_tty
, "");
1491 /* Initialize the Python code. */
1495 /* This is installed as a final cleanup and cleans up the
1496 interpreter. This lets Python's 'atexit' work. */
1499 finalize_python (void *ignore
)
1501 struct active_ext_lang_state
*previous_active
;
1503 /* We don't use ensure_python_env here because if we ever ran the
1504 cleanup, gdb would crash -- because the cleanup calls into the
1505 Python interpreter, which we are about to destroy. It seems
1506 clearer to make the needed calls explicitly here than to create a
1507 cleanup and then mysteriously discard it. */
1509 /* This is only called as a final cleanup so we can assume the active
1510 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1511 previous_active
= set_active_ext_lang (&extension_language_python
);
1513 (void) PyGILState_Ensure ();
1514 python_gdbarch
= target_gdbarch ();
1515 python_language
= current_language
;
1519 restore_active_ext_lang (previous_active
);
1523 /* Provide a prototype to silence -Wmissing-prototypes. */
1524 extern initialize_file_ftype _initialize_python
;
1529 do_start_initialization ()
1534 size_t progsize
, count
;
1536 wchar_t *progname_copy
;
1539 #ifdef WITH_PYTHON_PATH
1540 /* Work around problem where python gets confused about where it is,
1541 and then can't find its libraries, etc.
1542 NOTE: Python assumes the following layout:
1544 /foo/lib/pythonX.Y/...
1545 This must be done before calling Py_Initialize. */
1546 progname
= concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1547 SLASH_STRING
, "python", (char *) NULL
);
1549 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1550 setlocale (LC_ALL
, "");
1551 progsize
= strlen (progname
);
1552 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1556 fprintf (stderr
, "out of memory\n");
1559 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1560 if (count
== (size_t) -1)
1563 fprintf (stderr
, "Could not convert python path to string\n");
1566 setlocale (LC_ALL
, oldloc
);
1569 /* Note that Py_SetProgramName expects the string it is passed to
1570 remain alive for the duration of the program's execution, so
1571 it is not freed after this call. */
1572 Py_SetProgramName (progname_copy
);
1574 Py_SetProgramName (progname
);
1579 PyEval_InitThreads ();
1582 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1583 /* Add _gdb module to the list of known built-in modules. */
1584 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1586 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1588 if (gdb_module
== NULL
)
1591 /* The casts to (char*) are for python 2.4. */
1592 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1593 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1594 (char*) host_name
) < 0
1595 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1596 (char*) target_name
) < 0)
1599 /* Add stream constants. */
1600 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1601 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1602 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1605 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1606 if (gdbpy_gdb_error
== NULL
1607 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1610 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1611 gdbpy_gdb_error
, NULL
);
1612 if (gdbpy_gdb_memory_error
== NULL
1613 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1614 gdbpy_gdb_memory_error
) < 0)
1617 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1618 if (gdbpy_gdberror_exc
== NULL
1619 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1620 gdbpy_gdberror_exc
) < 0)
1623 gdbpy_initialize_gdb_readline ();
1625 if (gdbpy_initialize_auto_load () < 0
1626 || gdbpy_initialize_values () < 0
1627 || gdbpy_initialize_frames () < 0
1628 || gdbpy_initialize_commands () < 0
1629 || gdbpy_initialize_record () < 0
1630 || gdbpy_initialize_btrace () < 0
1631 || gdbpy_initialize_symbols () < 0
1632 || gdbpy_initialize_symtabs () < 0
1633 || gdbpy_initialize_blocks () < 0
1634 || gdbpy_initialize_functions () < 0
1635 || gdbpy_initialize_parameters () < 0
1636 || gdbpy_initialize_types () < 0
1637 || gdbpy_initialize_pspace () < 0
1638 || gdbpy_initialize_objfile () < 0
1639 || gdbpy_initialize_breakpoints () < 0
1640 || gdbpy_initialize_finishbreakpoints () < 0
1641 || gdbpy_initialize_lazy_string () < 0
1642 || gdbpy_initialize_linetable () < 0
1643 || gdbpy_initialize_thread () < 0
1644 || gdbpy_initialize_inferior () < 0
1645 || gdbpy_initialize_events () < 0
1646 || gdbpy_initialize_eventregistry () < 0
1647 || gdbpy_initialize_py_events () < 0
1648 || gdbpy_initialize_event () < 0
1649 || gdbpy_initialize_stop_event () < 0
1650 || gdbpy_initialize_signal_event () < 0
1651 || gdbpy_initialize_breakpoint_event () < 0
1652 || gdbpy_initialize_continue_event () < 0
1653 || gdbpy_initialize_inferior_call_pre_event () < 0
1654 || gdbpy_initialize_inferior_call_post_event () < 0
1655 || gdbpy_initialize_register_changed_event () < 0
1656 || gdbpy_initialize_memory_changed_event () < 0
1657 || gdbpy_initialize_exited_event () < 0
1658 || gdbpy_initialize_thread_event () < 0
1659 || gdbpy_initialize_new_objfile_event () < 0
1660 || gdbpy_initialize_clear_objfiles_event () < 0
1661 || gdbpy_initialize_arch () < 0
1662 || gdbpy_initialize_xmethods () < 0
1663 || gdbpy_initialize_unwind () < 0)
1666 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1667 if (gdbpy_to_string_cst
== NULL
)
1669 gdbpy_children_cst
= PyString_FromString ("children");
1670 if (gdbpy_children_cst
== NULL
)
1672 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1673 if (gdbpy_display_hint_cst
== NULL
)
1675 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1676 if (gdbpy_doc_cst
== NULL
)
1678 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1679 if (gdbpy_enabled_cst
== NULL
)
1681 gdbpy_value_cst
= PyString_FromString ("value");
1682 if (gdbpy_value_cst
== NULL
)
1685 /* Release the GIL while gdb runs. */
1686 PyThreadState_Swap (NULL
);
1687 PyEval_ReleaseLock ();
1689 make_final_cleanup (finalize_python
, NULL
);
1691 /* Only set this when initialization has succeeded. */
1692 gdb_python_initialized
= 1;
1696 #endif /* HAVE_PYTHON */
1699 _initialize_python (void)
1701 add_com ("python-interactive", class_obscure
,
1702 python_interactive_command
,
1705 Start an interactive Python prompt.\n\
1707 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1710 Alternatively, a single-line Python command can be given as an\n\
1711 argument, and if the command is an expression, the result will be\n\
1712 printed. For example:\n\
1714 (gdb) python-interactive 2 + 3\n\
1717 #else /* HAVE_PYTHON */
1719 Start a Python interactive prompt.\n\
1721 Python scripting is not supported in this copy of GDB.\n\
1722 This command is only a placeholder.")
1723 #endif /* HAVE_PYTHON */
1725 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1727 add_com ("python", class_obscure
, python_command
,
1730 Evaluate a Python command.\n\
1732 The command can be given as an argument, for instance:\n\
1736 If no argument is given, the following lines are read and used\n\
1737 as the Python commands. Type a line containing \"end\" to indicate\n\
1738 the end of the command.")
1739 #else /* HAVE_PYTHON */
1741 Evaluate a Python command.\n\
1743 Python scripting is not supported in this copy of GDB.\n\
1744 This command is only a placeholder.")
1745 #endif /* HAVE_PYTHON */
1747 add_com_alias ("py", "python", class_obscure
, 1);
1749 /* Add set/show python print-stack. */
1750 add_prefix_cmd ("python", no_class
, user_show_python
,
1751 _("Prefix command for python preference settings."),
1752 &user_show_python_list
, "show python ", 0,
1755 add_prefix_cmd ("python", no_class
, user_set_python
,
1756 _("Prefix command for python preference settings."),
1757 &user_set_python_list
, "set python ", 0,
1760 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1761 &gdbpy_should_print_stack
, _("\
1762 Set mode for Python stack dump on error."), _("\
1763 Show the mode of Python stack printing on error."), _("\
1764 none == no stack or message will be printed.\n\
1765 full == a message and a stack will be printed.\n\
1766 message == an error message without a stack will be printed."),
1768 &user_set_python_list
,
1769 &user_show_python_list
);
1772 if (!do_start_initialization () && PyErr_Occurred ())
1773 gdbpy_print_stack ();
1774 #endif /* HAVE_PYTHON */
1779 /* Helper function for gdbpy_finish_initialization. This does the
1780 work and then returns false if an error has occurred and must be
1781 displayed, or true on success. */
1784 do_finish_initialization (const struct extension_language_defn
*extlang
)
1789 /* Add the initial data-directory to sys.path. */
1791 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1794 sys_path
= PySys_GetObject ("path");
1796 /* If sys.path is not defined yet, define it first. */
1797 if (!(sys_path
&& PyList_Check (sys_path
)))
1800 PySys_SetPath (L
"");
1804 sys_path
= PySys_GetObject ("path");
1806 if (sys_path
&& PyList_Check (sys_path
))
1808 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1809 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1815 /* Import the gdb module to finish the initialization, and
1816 add it to __main__ for convenience. */
1817 m
= PyImport_AddModule ("__main__");
1821 /* Keep the reference to gdb_python_module since it is in a global
1823 gdb_python_module
= PyImport_ImportModule ("gdb");
1824 if (gdb_python_module
== NULL
)
1826 gdbpy_print_stack ();
1827 /* This is passed in one call to warning so that blank lines aren't
1828 inserted between each line of text. */
1830 "Could not load the Python gdb module from `%s'.\n"
1831 "Limited Python support is available from the _gdb module.\n"
1832 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1833 gdb_pythondir
.c_str ());
1834 /* We return "success" here as we've already emitted the
1839 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1842 /* Perform the remaining python initializations.
1843 These must be done after GDB is at least mostly initialized.
1844 E.g., The "info pretty-printer" command needs the "info" prefix
1846 This is the extension_language_ops.finish_initialization "method". */
1849 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1851 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1853 if (!do_finish_initialization (extlang
))
1855 gdbpy_print_stack ();
1856 warning (_("internal error: Unhandled Python exception"));
1860 /* Return non-zero if Python has successfully initialized.
1861 This is the extension_languages_ops.initialized "method". */
1864 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1866 return gdb_python_initialized
;
1869 #endif /* HAVE_PYTHON */
1875 PyMethodDef python_GdbMethods
[] =
1877 { "history", gdbpy_history
, METH_VARARGS
,
1878 "Get a value from history" },
1879 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1880 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1881 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1882 a Python String containing the output of the command if to_string is\n\
1884 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1885 "Return a gdb parameter's value" },
1887 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1888 "Return a tuple of all breakpoint objects" },
1890 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1891 "Find the default visualizer for a Value." },
1893 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1894 "Return the current Progspace." },
1895 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1896 "Return a sequence of all progspaces." },
1898 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1899 "Return the current Objfile being loaded, or None." },
1900 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1901 "Return a sequence of all loaded objfiles." },
1903 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1904 "newest_frame () -> gdb.Frame.\n\
1905 Return the newest frame object." },
1906 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1907 "selected_frame () -> gdb.Frame.\n\
1908 Return the selected frame object." },
1909 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1910 "stop_reason_string (Integer) -> String.\n\
1911 Return a string explaining unwind stop reason." },
1913 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
1914 "start_recording ([method] [, format]) -> gdb.Record.\n\
1915 Start recording with the given method. If no method is given, will fall back\n\
1916 to the system default method. If no format is given, will fall back to the\n\
1917 default format for the given method."},
1918 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
1919 "current_recording () -> gdb.Record.\n\
1920 Return current recording object." },
1921 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
1922 "stop_recording () -> None.\n\
1923 Stop current recording." },
1925 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1926 METH_VARARGS
| METH_KEYWORDS
,
1927 "lookup_type (name [, block]) -> type\n\
1928 Return a Type corresponding to the given name." },
1929 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1930 METH_VARARGS
| METH_KEYWORDS
,
1931 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1932 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1933 a boolean indicating if name is a field of the current implied argument\n\
1934 `this' (when the current language is object-oriented)." },
1935 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1936 METH_VARARGS
| METH_KEYWORDS
,
1937 "lookup_global_symbol (name [, domain]) -> symbol\n\
1938 Return the symbol corresponding to the given name (or None)." },
1940 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1941 METH_VARARGS
| METH_KEYWORDS
,
1942 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1943 Look up the specified objfile.\n\
1944 If by_build_id is True, the objfile is looked up by using name\n\
1945 as its build id." },
1947 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
1948 "Return the block containing the given pc value, or None." },
1949 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
1950 "solib_name (Long) -> String.\n\
1951 Return the name of the shared library holding a given address, or None." },
1952 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1953 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1954 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1955 The first element contains any unparsed portion of the String parameter\n\
1956 (or None if the string was fully parsed). The second element contains\n\
1957 a tuple that contains all the locations that match, represented as\n\
1958 gdb.Symtab_and_line objects (or None)."},
1959 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
1960 "parse_and_eval (String) -> Value.\n\
1961 Parse String as an expression, evaluate it, and return the result as a Value."
1963 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
1964 "find_pc_line (pc) -> Symtab_and_line.\n\
1965 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1967 { "post_event", gdbpy_post_event
, METH_VARARGS
,
1968 "Post an event into gdb's event loop." },
1970 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
1971 "target_charset () -> string.\n\
1972 Return the name of the current target charset." },
1973 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
1974 "target_wide_charset () -> string.\n\
1975 Return the name of the current target wide charset." },
1977 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
1978 "string_to_argv (String) -> Array.\n\
1979 Parse String and return an argv-like array.\n\
1980 Arguments are separate by spaces and may be quoted."
1982 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
1983 "Write a string using gdb's filtered stream." },
1984 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
1985 "Flush gdb's filtered stdout stream." },
1986 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
1987 "selected_thread () -> gdb.InferiorThread.\n\
1988 Return the selected thread object." },
1989 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
1990 "selected_inferior () -> gdb.Inferior.\n\
1991 Return the selected inferior object." },
1992 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
1993 "inferiors () -> (gdb.Inferior, ...).\n\
1994 Return a tuple containing all inferiors." },
1996 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
1997 "invalidate_cached_frames () -> None.\n\
1998 Invalidate any cached frame objects in gdb.\n\
1999 Intended for internal use only." },
2001 {NULL
, NULL
, 0, NULL
}
2005 struct PyModuleDef python_GdbModuleDef
=
2007 PyModuleDef_HEAD_INIT
,
2018 #endif /* HAVE_PYTHON */