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. */
371 compute_python_string (struct command_line
*l
)
373 struct command_line
*iter
;
376 for (iter
= l
; iter
; iter
= iter
->next
)
378 script
+= iter
->line
;
384 /* Take a command line structure representing a 'python' command, and
385 evaluate its body using the Python interpreter. */
388 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
389 struct command_line
*cmd
)
393 if (cmd
->body_count
!= 1)
394 error (_("Invalid \"python\" block structure."));
396 gdbpy_enter
enter_py (get_current_arch (), current_language
);
398 std::string script
= compute_python_string (cmd
->body_list
[0]);
399 ret
= PyRun_SimpleString (script
.c_str ());
401 error (_("Error while executing Python code."));
404 /* Implementation of the gdb "python" command. */
407 python_command (char *arg
, int from_tty
)
409 gdbpy_enter
enter_py (get_current_arch (), current_language
);
411 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
413 arg
= skip_spaces (arg
);
416 if (PyRun_SimpleString (arg
))
417 error (_("Error while executing Python code."));
421 command_line_up l
= get_command_line (python_control
, "");
423 execute_control_command_untraced (l
.get ());
429 /* Transform a gdb parameters's value into a Python value. May return
430 NULL (and set a Python exception) on error. Helper function for
433 gdbpy_parameter_value (enum var_types type
, void *var
)
438 case var_string_noescape
:
439 case var_optional_filename
:
443 const char *str
= *(char **) var
;
447 return host_string_to_python_string (str
);
458 case var_auto_boolean
:
460 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
462 if (ab
== AUTO_BOOLEAN_TRUE
)
464 else if (ab
== AUTO_BOOLEAN_FALSE
)
471 if ((* (int *) var
) == INT_MAX
)
475 return PyLong_FromLong (* (int *) var
);
479 unsigned int val
= * (unsigned int *) var
;
483 return PyLong_FromUnsignedLong (val
);
487 return PyErr_Format (PyExc_RuntimeError
,
488 _("Programmer error: unhandled type."));
491 /* A Python function which returns a gdb parameter's value as a Python
495 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
497 struct gdb_exception except
= exception_none
;
498 struct cmd_list_element
*alias
, *prefix
, *cmd
;
503 if (! PyArg_ParseTuple (args
, "s", &arg
))
506 newarg
= concat ("show ", arg
, (char *) NULL
);
510 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
512 CATCH (ex
, RETURN_MASK_ALL
)
519 GDB_PY_HANDLE_EXCEPTION (except
);
521 return PyErr_Format (PyExc_RuntimeError
,
522 _("Could not find parameter `%s'."), arg
);
525 return PyErr_Format (PyExc_RuntimeError
,
526 _("`%s' is not a parameter."), arg
);
527 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
530 /* Wrapper for target_charset. */
533 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
535 const char *cset
= target_charset (python_gdbarch
);
537 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
540 /* Wrapper for target_wide_charset. */
543 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
545 const char *cset
= target_wide_charset (python_gdbarch
);
547 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
550 /* A Python function which evaluates a string using the gdb CLI. */
553 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
556 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
557 int from_tty
, to_string
;
558 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
560 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
561 &PyBool_Type
, &from_tty_obj
,
562 &PyBool_Type
, &to_string_obj
))
568 int cmp
= PyObject_IsTrue (from_tty_obj
);
577 int cmp
= PyObject_IsTrue (to_string_obj
);
583 std::string to_string_res
;
587 /* Copy the argument text in case the command modifies it. */
588 std::string
copy (arg
);
589 struct interp
*interp
;
591 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
593 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
595 /* Use the console interpreter uiout to have the same print format
596 for console or MI. */
597 interp
= interp_lookup (current_ui
, "console");
598 current_uiout
= interp_ui_out (interp
);
600 scoped_restore preventer
= prevent_dont_repeat ();
602 to_string_res
= execute_command_to_string (©
[0], from_tty
);
604 execute_command (©
[0], from_tty
);
606 CATCH (except
, RETURN_MASK_ALL
)
608 GDB_PY_HANDLE_EXCEPTION (except
);
612 /* Do any commands attached to breakpoint we stopped at. */
613 bpstat_do_actions ();
616 return PyString_FromString (to_string_res
.c_str ());
620 /* Implementation of gdb.solib_name (Long) -> String.
621 Returns the name of the shared library holding a given address, or None. */
624 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
630 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
633 soname
= solib_name_from_address (current_program_space
, pc
);
635 str_obj
= host_string_to_python_string (soname
);
645 /* A Python function which is a wrapper for decode_line_1. */
648 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
650 const char *arg
= NULL
;
652 gdbpy_ref
<> unparsed
;
653 event_location_up location
;
655 if (! PyArg_ParseTuple (args
, "|s", &arg
))
659 location
= string_to_event_location_basic (&arg
, python_language
);
661 std::vector
<symtab_and_line
> decoded_sals
;
662 symtab_and_line def_sal
;
663 gdb::array_view
<symtab_and_line
> sals
;
666 if (location
!= NULL
)
668 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
673 set_default_source_symtab_and_line ();
674 def_sal
= get_current_source_symtab_and_line ();
678 CATCH (ex
, RETURN_MASK_ALL
)
680 /* We know this will always throw. */
681 gdbpy_convert_exception (ex
);
688 result
.reset (PyTuple_New (sals
.size ()));
691 for (size_t i
= 0; i
< sals
.size (); ++i
)
693 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
697 PyTuple_SetItem (result
.get (), i
, obj
);
702 result
.reset (Py_None
);
706 gdbpy_ref
<> return_result (PyTuple_New (2));
707 if (return_result
== NULL
)
710 if (arg
!= NULL
&& strlen (arg
) > 0)
712 unparsed
.reset (PyString_FromString (arg
));
713 if (unparsed
== NULL
)
718 unparsed
.reset (Py_None
);
722 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
723 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
725 return return_result
.release ();
728 /* Parse a string and evaluate it as an expression. */
730 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
732 const char *expr_str
;
733 struct value
*result
= NULL
;
735 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
740 result
= parse_and_eval (expr_str
);
742 CATCH (except
, RETURN_MASK_ALL
)
744 GDB_PY_HANDLE_EXCEPTION (except
);
748 return value_to_value_object (result
);
751 /* Implementation of gdb.find_pc_line function.
752 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
755 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
757 gdb_py_ulongest pc_llu
;
758 PyObject
*result
= NULL
; /* init for gcc -Wall */
760 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
765 struct symtab_and_line sal
;
768 pc
= (CORE_ADDR
) pc_llu
;
769 sal
= find_pc_line (pc
, 0);
770 result
= symtab_and_line_to_sal_object (sal
);
772 CATCH (except
, RETURN_MASK_ALL
)
774 GDB_PY_HANDLE_EXCEPTION (except
);
781 /* Implementation of gdb.invalidate_cached_frames. */
784 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
786 reinit_frame_cache ();
790 /* Read a file as Python code.
791 This is the extension_language_script_ops.script_sourcer "method".
792 FILE is the file to load. FILENAME is name of the file FILE.
793 This does not throw any errors. If an exception occurs python will print
794 the traceback and clear the error indicator. */
797 gdbpy_source_script (const struct extension_language_defn
*extlang
,
798 FILE *file
, const char *filename
)
800 gdbpy_enter
enter_py (get_current_arch (), current_language
);
801 python_run_simple_file (file
, filename
);
806 /* Posting and handling events. */
808 /* A single event. */
811 /* The Python event. This is just a callable object. */
813 /* The next event. */
814 struct gdbpy_event
*next
;
817 /* All pending events. */
818 static struct gdbpy_event
*gdbpy_event_list
;
819 /* The final link of the event list. */
820 static struct gdbpy_event
**gdbpy_event_list_end
;
822 /* So that we can wake up the main thread even when it is blocked in
824 static struct serial_event
*gdbpy_serial_event
;
826 /* The file handler callback. This reads from the internal pipe, and
827 then processes the Python event queue. This will always be run in
828 the main gdb thread. */
831 gdbpy_run_events (int error
, gdb_client_data client_data
)
833 gdbpy_enter
enter_py (get_current_arch (), current_language
);
835 /* Clear the event fd. Do this before flushing the events list, so
836 that any new event post afterwards is sure to re-awake the event
838 serial_event_clear (gdbpy_serial_event
);
840 while (gdbpy_event_list
)
842 /* Dispatching the event might push a new element onto the event
843 loop, so we update here "atomically enough". */
844 struct gdbpy_event
*item
= gdbpy_event_list
;
845 gdbpy_event_list
= gdbpy_event_list
->next
;
846 if (gdbpy_event_list
== NULL
)
847 gdbpy_event_list_end
= &gdbpy_event_list
;
850 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
851 if (call_result
== NULL
)
854 Py_DECREF (item
->event
);
859 /* Submit an event to the gdb thread. */
861 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
863 struct gdbpy_event
*event
;
867 if (!PyArg_ParseTuple (args
, "O", &func
))
870 if (!PyCallable_Check (func
))
872 PyErr_SetString (PyExc_RuntimeError
,
873 _("Posted event is not callable"));
879 /* From here until the end of the function, we have the GIL, so we
880 can operate on our global data structures without worrying. */
881 wakeup
= gdbpy_event_list
== NULL
;
883 event
= XNEW (struct gdbpy_event
);
886 *gdbpy_event_list_end
= event
;
887 gdbpy_event_list_end
= &event
->next
;
889 /* Wake up gdb when needed. */
891 serial_event_set (gdbpy_serial_event
);
896 /* Initialize the Python event handler. */
898 gdbpy_initialize_events (void)
900 gdbpy_event_list_end
= &gdbpy_event_list
;
902 gdbpy_serial_event
= make_serial_event ();
903 add_file_handler (serial_event_fd (gdbpy_serial_event
),
904 gdbpy_run_events
, NULL
);
911 /* This is the extension_language_ops.before_prompt "method". */
913 static enum ext_lang_rc
914 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
915 const char *current_gdb_prompt
)
917 if (!gdb_python_initialized
)
918 return EXT_LANG_RC_NOP
;
920 gdbpy_enter
enter_py (get_current_arch (), current_language
);
922 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
923 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
924 return EXT_LANG_RC_ERROR
;
926 if (gdb_python_module
927 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
929 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
933 gdbpy_print_stack ();
934 return EXT_LANG_RC_ERROR
;
937 if (PyCallable_Check (hook
.get ()))
939 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
940 if (current_prompt
== NULL
)
942 gdbpy_print_stack ();
943 return EXT_LANG_RC_ERROR
;
947 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
951 gdbpy_print_stack ();
952 return EXT_LANG_RC_ERROR
;
955 /* Return type should be None, or a String. If it is None,
956 fall through, we will not set a prompt. If it is a
957 string, set PROMPT. Anything else, set an exception. */
958 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
960 PyErr_Format (PyExc_RuntimeError
,
961 _("Return from prompt_hook must " \
962 "be either a Python string, or None"));
963 gdbpy_print_stack ();
964 return EXT_LANG_RC_ERROR
;
967 if (result
!= Py_None
)
969 gdb::unique_xmalloc_ptr
<char>
970 prompt (python_string_to_host_string (result
.get ()));
974 gdbpy_print_stack ();
975 return EXT_LANG_RC_ERROR
;
978 set_prompt (prompt
.get ());
979 return EXT_LANG_RC_OK
;
984 return EXT_LANG_RC_NOP
;
991 /* A python function to write a single string using gdb's filtered
992 output stream . The optional keyword STREAM can be used to write
993 to a particular stream. The default stream is to gdb_stdout. */
996 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
999 static const char *keywords
[] = { "text", "stream", NULL
};
1000 int stream_type
= 0;
1002 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1008 switch (stream_type
)
1012 fprintf_filtered (gdb_stderr
, "%s", arg
);
1017 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1021 fprintf_filtered (gdb_stdout
, "%s", arg
);
1024 CATCH (except
, RETURN_MASK_ALL
)
1026 GDB_PY_HANDLE_EXCEPTION (except
);
1033 /* A python function to flush a gdb stream. The optional keyword
1034 STREAM can be used to flush a particular stream. The default stream
1038 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1040 static const char *keywords
[] = { "stream", NULL
};
1041 int stream_type
= 0;
1043 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1047 switch (stream_type
)
1051 gdb_flush (gdb_stderr
);
1056 gdb_flush (gdb_stdlog
);
1060 gdb_flush (gdb_stdout
);
1066 /* Return non-zero if print-stack is not "none". */
1069 gdbpy_print_python_errors_p (void)
1071 return gdbpy_should_print_stack
!= python_excp_none
;
1074 /* Print a python exception trace, print just a message, or print
1075 nothing and clear the python exception, depending on
1076 gdbpy_should_print_stack. Only call this if a python exception is
1079 gdbpy_print_stack (void)
1082 /* Print "none", just clear exception. */
1083 if (gdbpy_should_print_stack
== python_excp_none
)
1087 /* Print "full" message and backtrace. */
1088 else if (gdbpy_should_print_stack
== python_excp_full
)
1091 /* PyErr_Print doesn't necessarily end output with a newline.
1092 This works because Python's stdout/stderr is fed through
1098 CATCH (except
, RETURN_MASK_ALL
)
1103 /* Print "message", just error print message. */
1106 PyObject
*ptype
, *pvalue
, *ptraceback
;
1108 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1110 /* Fetch the error message contained within ptype, pvalue. */
1111 gdb::unique_xmalloc_ptr
<char>
1112 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1113 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1119 /* An error occurred computing the string representation of the
1121 fprintf_filtered (gdb_stderr
,
1122 _("Error occurred computing Python error" \
1126 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1127 type
.get (), msg
.get ());
1129 CATCH (except
, RETURN_MASK_ALL
)
1135 Py_XDECREF (pvalue
);
1136 Py_XDECREF (ptraceback
);
1142 /* Return the current Progspace.
1143 There always is one. */
1146 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1150 result
= pspace_to_pspace_object (current_program_space
);
1156 /* Return a sequence holding all the Progspaces. */
1159 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1161 struct program_space
*ps
;
1163 gdbpy_ref
<> list (PyList_New (0));
1169 PyObject
*item
= pspace_to_pspace_object (ps
);
1171 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1175 return list
.release ();
1180 /* The "current" objfile. This is set when gdb detects that a new
1181 objfile has been loaded. It is only set for the duration of a call to
1182 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1184 static struct objfile
*gdbpy_current_objfile
;
1186 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1187 as Python code. This does not throw any errors. If an exception
1188 occurs python will print the traceback and clear the error indicator.
1189 This is the extension_language_script_ops.objfile_script_sourcer
1193 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1194 struct objfile
*objfile
, FILE *file
,
1195 const char *filename
)
1197 if (!gdb_python_initialized
)
1200 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1201 gdbpy_current_objfile
= objfile
;
1203 python_run_simple_file (file
, filename
);
1205 gdbpy_current_objfile
= NULL
;
1208 /* Set the current objfile to OBJFILE and then execute SCRIPT
1209 as Python code. This does not throw any errors. If an exception
1210 occurs python will print the traceback and clear the error indicator.
1211 This is the extension_language_script_ops.objfile_script_executor
1215 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1216 struct objfile
*objfile
, const char *name
,
1219 if (!gdb_python_initialized
)
1222 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1223 gdbpy_current_objfile
= objfile
;
1225 PyRun_SimpleString (script
);
1227 gdbpy_current_objfile
= NULL
;
1230 /* Return the current Objfile, or None if there isn't one. */
1233 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1237 if (! gdbpy_current_objfile
)
1240 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1246 /* Return a sequence holding all the Objfiles. */
1249 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1251 struct objfile
*objf
;
1253 gdbpy_ref
<> list (PyList_New (0));
1259 PyObject
*item
= objfile_to_objfile_object (objf
);
1261 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1265 return list
.release ();
1268 /* Compute the list of active python type printers and store them in
1269 EXT_PRINTERS->py_type_printers. The product of this function is used by
1270 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1271 This is the extension_language_ops.start_type_printers "method". */
1274 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1275 struct ext_lang_type_printers
*ext_printers
)
1277 PyObject
*printers_obj
= NULL
;
1279 if (!gdb_python_initialized
)
1282 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1284 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1285 if (type_module
== NULL
)
1287 gdbpy_print_stack ();
1291 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1292 "get_type_recognizers"));
1295 gdbpy_print_stack ();
1299 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1300 if (printers_obj
== NULL
)
1301 gdbpy_print_stack ();
1303 ext_printers
->py_type_printers
= printers_obj
;
1306 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1307 a newly allocated string holding the type's replacement name, and return
1308 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1309 If there's a Python error return EXT_LANG_RC_ERROR.
1310 Otherwise, return EXT_LANG_RC_NOP.
1311 This is the extension_language_ops.apply_type_printers "method". */
1313 static enum ext_lang_rc
1314 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1315 const struct ext_lang_type_printers
*ext_printers
,
1316 struct type
*type
, char **prettied_type
)
1318 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1319 gdb::unique_xmalloc_ptr
<char> result
;
1321 if (printers_obj
== NULL
)
1322 return EXT_LANG_RC_NOP
;
1324 if (!gdb_python_initialized
)
1325 return EXT_LANG_RC_NOP
;
1327 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1329 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1330 if (type_obj
== NULL
)
1332 gdbpy_print_stack ();
1333 return EXT_LANG_RC_ERROR
;
1336 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1337 if (type_module
== NULL
)
1339 gdbpy_print_stack ();
1340 return EXT_LANG_RC_ERROR
;
1343 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1344 "apply_type_recognizers"));
1347 gdbpy_print_stack ();
1348 return EXT_LANG_RC_ERROR
;
1351 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1355 if (result_obj
== NULL
)
1357 gdbpy_print_stack ();
1358 return EXT_LANG_RC_ERROR
;
1361 if (result_obj
== Py_None
)
1362 return EXT_LANG_RC_NOP
;
1364 result
= python_string_to_host_string (result_obj
.get ());
1367 gdbpy_print_stack ();
1368 return EXT_LANG_RC_ERROR
;
1371 *prettied_type
= result
.release ();
1372 return EXT_LANG_RC_OK
;
1375 /* Free the result of start_type_printers.
1376 This is the extension_language_ops.free_type_printers "method". */
1379 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1380 struct ext_lang_type_printers
*ext_printers
)
1382 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1384 if (printers
== NULL
)
1387 if (!gdb_python_initialized
)
1390 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1391 Py_DECREF (printers
);
1394 #else /* HAVE_PYTHON */
1396 /* Dummy implementation of the gdb "python-interactive" and "python"
1400 python_interactive_command (char *arg
, int from_tty
)
1402 arg
= skip_spaces (arg
);
1404 error (_("Python scripting is not supported in this copy of GDB."));
1407 command_line_up l
= get_command_line (python_control
, "");
1409 execute_control_command_untraced (l
.get ());
1414 python_command (char *arg
, int from_tty
)
1416 python_interactive_command (arg
, from_tty
);
1419 #endif /* HAVE_PYTHON */
1423 /* Lists for 'set python' commands. */
1425 static struct cmd_list_element
*user_set_python_list
;
1426 static struct cmd_list_element
*user_show_python_list
;
1428 /* Function for use by 'set python' prefix command. */
1431 user_set_python (const char *args
, int from_tty
)
1433 help_list (user_set_python_list
, "set python ", all_commands
,
1437 /* Function for use by 'show python' prefix command. */
1440 user_show_python (const char *args
, int from_tty
)
1442 cmd_show_list (user_show_python_list
, from_tty
, "");
1445 /* Initialize the Python code. */
1449 /* This is installed as a final cleanup and cleans up the
1450 interpreter. This lets Python's 'atexit' work. */
1453 finalize_python (void *ignore
)
1455 struct active_ext_lang_state
*previous_active
;
1457 /* We don't use ensure_python_env here because if we ever ran the
1458 cleanup, gdb would crash -- because the cleanup calls into the
1459 Python interpreter, which we are about to destroy. It seems
1460 clearer to make the needed calls explicitly here than to create a
1461 cleanup and then mysteriously discard it. */
1463 /* This is only called as a final cleanup so we can assume the active
1464 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1465 previous_active
= set_active_ext_lang (&extension_language_python
);
1467 (void) PyGILState_Ensure ();
1468 python_gdbarch
= target_gdbarch ();
1469 python_language
= current_language
;
1473 restore_active_ext_lang (previous_active
);
1477 do_start_initialization ()
1482 size_t progsize
, count
;
1483 wchar_t *progname_copy
;
1486 #ifdef WITH_PYTHON_PATH
1487 /* Work around problem where python gets confused about where it is,
1488 and then can't find its libraries, etc.
1489 NOTE: Python assumes the following layout:
1491 /foo/lib/pythonX.Y/...
1492 This must be done before calling Py_Initialize. */
1493 progname
= concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1494 SLASH_STRING
, "python", (char *) NULL
);
1496 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1497 setlocale (LC_ALL
, "");
1498 progsize
= strlen (progname
);
1499 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1502 fprintf (stderr
, "out of memory\n");
1505 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1506 if (count
== (size_t) -1)
1508 fprintf (stderr
, "Could not convert python path to string\n");
1511 setlocale (LC_ALL
, oldloc
.c_str ());
1513 /* Note that Py_SetProgramName expects the string it is passed to
1514 remain alive for the duration of the program's execution, so
1515 it is not freed after this call. */
1516 Py_SetProgramName (progname_copy
);
1518 Py_SetProgramName (progname
);
1523 PyEval_InitThreads ();
1526 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1527 /* Add _gdb module to the list of known built-in modules. */
1528 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1530 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1532 if (gdb_module
== NULL
)
1535 /* The casts to (char*) are for python 2.4. */
1536 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1537 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1538 (char*) host_name
) < 0
1539 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1540 (char*) target_name
) < 0)
1543 /* Add stream constants. */
1544 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1545 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1546 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1549 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1550 if (gdbpy_gdb_error
== NULL
1551 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1554 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1555 gdbpy_gdb_error
, NULL
);
1556 if (gdbpy_gdb_memory_error
== NULL
1557 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1558 gdbpy_gdb_memory_error
) < 0)
1561 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1562 if (gdbpy_gdberror_exc
== NULL
1563 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1564 gdbpy_gdberror_exc
) < 0)
1567 gdbpy_initialize_gdb_readline ();
1569 if (gdbpy_initialize_auto_load () < 0
1570 || gdbpy_initialize_values () < 0
1571 || gdbpy_initialize_frames () < 0
1572 || gdbpy_initialize_commands () < 0
1573 || gdbpy_initialize_instruction () < 0
1574 || gdbpy_initialize_record () < 0
1575 || gdbpy_initialize_btrace () < 0
1576 || gdbpy_initialize_symbols () < 0
1577 || gdbpy_initialize_symtabs () < 0
1578 || gdbpy_initialize_blocks () < 0
1579 || gdbpy_initialize_functions () < 0
1580 || gdbpy_initialize_parameters () < 0
1581 || gdbpy_initialize_types () < 0
1582 || gdbpy_initialize_pspace () < 0
1583 || gdbpy_initialize_objfile () < 0
1584 || gdbpy_initialize_breakpoints () < 0
1585 || gdbpy_initialize_finishbreakpoints () < 0
1586 || gdbpy_initialize_lazy_string () < 0
1587 || gdbpy_initialize_linetable () < 0
1588 || gdbpy_initialize_thread () < 0
1589 || gdbpy_initialize_inferior () < 0
1590 || gdbpy_initialize_events () < 0
1591 || gdbpy_initialize_eventregistry () < 0
1592 || gdbpy_initialize_py_events () < 0
1593 || gdbpy_initialize_event () < 0
1594 || gdbpy_initialize_arch () < 0
1595 || gdbpy_initialize_xmethods () < 0
1596 || gdbpy_initialize_unwind () < 0)
1599 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1600 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1602 #include "py-event-types.def"
1603 #undef GDB_PY_DEFINE_EVENT_TYPE
1605 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1606 if (gdbpy_to_string_cst
== NULL
)
1608 gdbpy_children_cst
= PyString_FromString ("children");
1609 if (gdbpy_children_cst
== NULL
)
1611 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1612 if (gdbpy_display_hint_cst
== NULL
)
1614 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1615 if (gdbpy_doc_cst
== NULL
)
1617 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1618 if (gdbpy_enabled_cst
== NULL
)
1620 gdbpy_value_cst
= PyString_FromString ("value");
1621 if (gdbpy_value_cst
== NULL
)
1624 /* Release the GIL while gdb runs. */
1625 PyThreadState_Swap (NULL
);
1626 PyEval_ReleaseLock ();
1628 make_final_cleanup (finalize_python
, NULL
);
1630 /* Only set this when initialization has succeeded. */
1631 gdb_python_initialized
= 1;
1635 #endif /* HAVE_PYTHON */
1638 _initialize_python (void)
1640 add_com ("python-interactive", class_obscure
,
1641 python_interactive_command
,
1644 Start an interactive Python prompt.\n\
1646 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1649 Alternatively, a single-line Python command can be given as an\n\
1650 argument, and if the command is an expression, the result will be\n\
1651 printed. For example:\n\
1653 (gdb) python-interactive 2 + 3\n\
1656 #else /* HAVE_PYTHON */
1658 Start a Python interactive prompt.\n\
1660 Python scripting is not supported in this copy of GDB.\n\
1661 This command is only a placeholder.")
1662 #endif /* HAVE_PYTHON */
1664 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1666 add_com ("python", class_obscure
, python_command
,
1669 Evaluate a Python command.\n\
1671 The command can be given as an argument, for instance:\n\
1675 If no argument is given, the following lines are read and used\n\
1676 as the Python commands. Type a line containing \"end\" to indicate\n\
1677 the end of the command.")
1678 #else /* HAVE_PYTHON */
1680 Evaluate a Python command.\n\
1682 Python scripting is not supported in this copy of GDB.\n\
1683 This command is only a placeholder.")
1684 #endif /* HAVE_PYTHON */
1686 add_com_alias ("py", "python", class_obscure
, 1);
1688 /* Add set/show python print-stack. */
1689 add_prefix_cmd ("python", no_class
, user_show_python
,
1690 _("Prefix command for python preference settings."),
1691 &user_show_python_list
, "show python ", 0,
1694 add_prefix_cmd ("python", no_class
, user_set_python
,
1695 _("Prefix command for python preference settings."),
1696 &user_set_python_list
, "set python ", 0,
1699 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1700 &gdbpy_should_print_stack
, _("\
1701 Set mode for Python stack dump on error."), _("\
1702 Show the mode of Python stack printing on error."), _("\
1703 none == no stack or message will be printed.\n\
1704 full == a message and a stack will be printed.\n\
1705 message == an error message without a stack will be printed."),
1707 &user_set_python_list
,
1708 &user_show_python_list
);
1711 if (!do_start_initialization () && PyErr_Occurred ())
1712 gdbpy_print_stack ();
1713 #endif /* HAVE_PYTHON */
1718 /* Helper function for gdbpy_finish_initialization. This does the
1719 work and then returns false if an error has occurred and must be
1720 displayed, or true on success. */
1723 do_finish_initialization (const struct extension_language_defn
*extlang
)
1728 /* Add the initial data-directory to sys.path. */
1730 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1733 sys_path
= PySys_GetObject ("path");
1735 /* If sys.path is not defined yet, define it first. */
1736 if (!(sys_path
&& PyList_Check (sys_path
)))
1739 PySys_SetPath (L
"");
1743 sys_path
= PySys_GetObject ("path");
1745 if (sys_path
&& PyList_Check (sys_path
))
1747 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1748 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1754 /* Import the gdb module to finish the initialization, and
1755 add it to __main__ for convenience. */
1756 m
= PyImport_AddModule ("__main__");
1760 /* Keep the reference to gdb_python_module since it is in a global
1762 gdb_python_module
= PyImport_ImportModule ("gdb");
1763 if (gdb_python_module
== NULL
)
1765 gdbpy_print_stack ();
1766 /* This is passed in one call to warning so that blank lines aren't
1767 inserted between each line of text. */
1769 "Could not load the Python gdb module from `%s'.\n"
1770 "Limited Python support is available from the _gdb module.\n"
1771 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1772 gdb_pythondir
.c_str ());
1773 /* We return "success" here as we've already emitted the
1778 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1781 /* Perform the remaining python initializations.
1782 These must be done after GDB is at least mostly initialized.
1783 E.g., The "info pretty-printer" command needs the "info" prefix
1785 This is the extension_language_ops.finish_initialization "method". */
1788 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1790 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1792 if (!do_finish_initialization (extlang
))
1794 gdbpy_print_stack ();
1795 warning (_("internal error: Unhandled Python exception"));
1799 /* Return non-zero if Python has successfully initialized.
1800 This is the extension_languages_ops.initialized "method". */
1803 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1805 return gdb_python_initialized
;
1808 #endif /* HAVE_PYTHON */
1814 PyMethodDef python_GdbMethods
[] =
1816 { "history", gdbpy_history
, METH_VARARGS
,
1817 "Get a value from history" },
1818 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1819 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1820 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1821 a Python String containing the output of the command if to_string is\n\
1823 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1824 "Return a gdb parameter's value" },
1826 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1827 "Return a tuple of all breakpoint objects" },
1829 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1830 "Find the default visualizer for a Value." },
1832 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1833 "Return the current Progspace." },
1834 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1835 "Return a sequence of all progspaces." },
1837 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1838 "Return the current Objfile being loaded, or None." },
1839 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1840 "Return a sequence of all loaded objfiles." },
1842 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1843 "newest_frame () -> gdb.Frame.\n\
1844 Return the newest frame object." },
1845 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1846 "selected_frame () -> gdb.Frame.\n\
1847 Return the selected frame object." },
1848 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1849 "stop_reason_string (Integer) -> String.\n\
1850 Return a string explaining unwind stop reason." },
1852 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
1853 "start_recording ([method] [, format]) -> gdb.Record.\n\
1854 Start recording with the given method. If no method is given, will fall back\n\
1855 to the system default method. If no format is given, will fall back to the\n\
1856 default format for the given method."},
1857 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
1858 "current_recording () -> gdb.Record.\n\
1859 Return current recording object." },
1860 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
1861 "stop_recording () -> None.\n\
1862 Stop current recording." },
1864 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1865 METH_VARARGS
| METH_KEYWORDS
,
1866 "lookup_type (name [, block]) -> type\n\
1867 Return a Type corresponding to the given name." },
1868 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1869 METH_VARARGS
| METH_KEYWORDS
,
1870 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1871 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1872 a boolean indicating if name is a field of the current implied argument\n\
1873 `this' (when the current language is object-oriented)." },
1874 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1875 METH_VARARGS
| METH_KEYWORDS
,
1876 "lookup_global_symbol (name [, domain]) -> symbol\n\
1877 Return the symbol corresponding to the given name (or None)." },
1879 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1880 METH_VARARGS
| METH_KEYWORDS
,
1881 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1882 Look up the specified objfile.\n\
1883 If by_build_id is True, the objfile is looked up by using name\n\
1884 as its build id." },
1886 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
1887 "Return the block containing the given pc value, or None." },
1888 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
1889 "solib_name (Long) -> String.\n\
1890 Return the name of the shared library holding a given address, or None." },
1891 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1892 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1893 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1894 The first element contains any unparsed portion of the String parameter\n\
1895 (or None if the string was fully parsed). The second element contains\n\
1896 a tuple that contains all the locations that match, represented as\n\
1897 gdb.Symtab_and_line objects (or None)."},
1898 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
1899 "parse_and_eval (String) -> Value.\n\
1900 Parse String as an expression, evaluate it, and return the result as a Value."
1902 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
1903 "find_pc_line (pc) -> Symtab_and_line.\n\
1904 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1906 { "post_event", gdbpy_post_event
, METH_VARARGS
,
1907 "Post an event into gdb's event loop." },
1909 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
1910 "target_charset () -> string.\n\
1911 Return the name of the current target charset." },
1912 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
1913 "target_wide_charset () -> string.\n\
1914 Return the name of the current target wide charset." },
1916 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
1917 "string_to_argv (String) -> Array.\n\
1918 Parse String and return an argv-like array.\n\
1919 Arguments are separate by spaces and may be quoted."
1921 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
1922 "Write a string using gdb's filtered stream." },
1923 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
1924 "Flush gdb's filtered stdout stream." },
1925 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
1926 "selected_thread () -> gdb.InferiorThread.\n\
1927 Return the selected thread object." },
1928 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
1929 "selected_inferior () -> gdb.Inferior.\n\
1930 Return the selected inferior object." },
1931 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
1932 "inferiors () -> (gdb.Inferior, ...).\n\
1933 Return a tuple containing all inferiors." },
1935 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
1936 "invalidate_cached_frames () -> None.\n\
1937 Invalidate any cached frame objects in gdb.\n\
1938 Intended for internal use only." },
1940 {NULL
, NULL
, 0, NULL
}
1944 struct PyModuleDef python_GdbModuleDef
=
1946 PyModuleDef_HEAD_INIT
,
1958 /* Define all the event objects. */
1959 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1960 PyTypeObject name##_event_object_type \
1961 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
1963 PyVarObject_HEAD_INIT (NULL, 0) \
1964 "gdb." py_name, /* tp_name */ \
1965 sizeof (event_object), /* tp_basicsize */ \
1966 0, /* tp_itemsize */ \
1967 evpy_dealloc, /* tp_dealloc */ \
1969 0, /* tp_getattr */ \
1970 0, /* tp_setattr */ \
1971 0, /* tp_compare */ \
1973 0, /* tp_as_number */ \
1974 0, /* tp_as_sequence */ \
1975 0, /* tp_as_mapping */ \
1979 0, /* tp_getattro */ \
1980 0, /* tp_setattro */ \
1981 0, /* tp_as_buffer */ \
1982 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
1984 0, /* tp_traverse */ \
1986 0, /* tp_richcompare */ \
1987 0, /* tp_weaklistoffset */ \
1989 0, /* tp_iternext */ \
1990 0, /* tp_methods */ \
1991 0, /* tp_members */ \
1992 0, /* tp_getset */ \
1993 &base, /* tp_base */ \
1995 0, /* tp_descr_get */ \
1996 0, /* tp_descr_set */ \
1997 0, /* tp_dictoffset */ \
2001 #include "py-event-types.def"
2002 #undef GDB_PY_DEFINE_EVENT_TYPE
2004 #endif /* HAVE_PYTHON */