1 /* General python/gdb code
3 Copyright (C) 2008-2016 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 /* True if Python has been successfully initialized, false
106 int gdb_python_initialized
;
108 extern PyMethodDef python_GdbMethods
[];
111 extern struct PyModuleDef python_GdbModuleDef
;
114 PyObject
*gdb_module
;
115 PyObject
*gdb_python_module
;
117 /* Some string constants we may wish to use. */
118 PyObject
*gdbpy_to_string_cst
;
119 PyObject
*gdbpy_children_cst
;
120 PyObject
*gdbpy_display_hint_cst
;
121 PyObject
*gdbpy_doc_cst
;
122 PyObject
*gdbpy_enabled_cst
;
123 PyObject
*gdbpy_value_cst
;
125 /* The GdbError exception. */
126 PyObject
*gdbpy_gdberror_exc
;
128 /* The `gdb.error' base class. */
129 PyObject
*gdbpy_gdb_error
;
131 /* The `gdb.MemoryError' exception. */
132 PyObject
*gdbpy_gdb_memory_error
;
134 static script_sourcer_func gdbpy_source_script
;
135 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
136 static objfile_script_executor_func gdbpy_execute_objfile_script
;
137 static void gdbpy_finish_initialization
138 (const struct extension_language_defn
*);
139 static int gdbpy_initialized (const struct extension_language_defn
*);
140 static void gdbpy_eval_from_control_command
141 (const struct extension_language_defn
*, struct command_line
*cmd
);
142 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
143 struct ext_lang_type_printers
*);
144 static enum ext_lang_rc gdbpy_apply_type_printers
145 (const struct extension_language_defn
*,
146 const struct ext_lang_type_printers
*, struct type
*, char **);
147 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
148 struct ext_lang_type_printers
*);
149 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
150 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
151 static enum ext_lang_rc gdbpy_before_prompt_hook
152 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
154 /* The interface between gdb proper and loading of python scripts. */
156 const struct extension_language_script_ops python_extension_script_ops
=
159 gdbpy_source_objfile_script
,
160 gdbpy_execute_objfile_script
,
161 gdbpy_auto_load_enabled
164 /* The interface between gdb proper and python extensions. */
166 const struct extension_language_ops python_extension_ops
=
168 gdbpy_finish_initialization
,
171 gdbpy_eval_from_control_command
,
173 gdbpy_start_type_printers
,
174 gdbpy_apply_type_printers
,
175 gdbpy_free_type_printers
,
177 gdbpy_apply_val_pretty_printer
,
179 gdbpy_apply_frame_filter
,
181 gdbpy_preserve_values
,
183 gdbpy_breakpoint_has_cond
,
184 gdbpy_breakpoint_cond_says_stop
,
187 gdbpy_check_quit_flag
,
189 gdbpy_before_prompt_hook
,
191 gdbpy_clone_xmethod_worker_data
,
192 gdbpy_free_xmethod_worker_data
,
193 gdbpy_get_matching_xmethod_workers
,
194 gdbpy_get_xmethod_arg_types
,
195 gdbpy_get_xmethod_result_type
,
199 /* Architecture and language to be used in callbacks from
200 the Python interpreter. */
201 struct gdbarch
*python_gdbarch
;
202 const struct language_defn
*python_language
;
204 /* Restore global language and architecture and Python GIL state
205 when leaving the Python interpreter. */
209 struct active_ext_lang_state
*previous_active
;
210 PyGILState_STATE state
;
211 struct gdbarch
*gdbarch
;
212 const struct language_defn
*language
;
213 PyObject
*error_type
, *error_value
, *error_traceback
;
217 restore_python_env (void *p
)
219 struct python_env
*env
= (struct python_env
*)p
;
221 /* Leftover Python error is forbidden by Python Exception Handling. */
222 if (PyErr_Occurred ())
224 /* This order is similar to the one calling error afterwards. */
225 gdbpy_print_stack ();
226 warning (_("internal error: Unhandled Python exception"));
229 PyErr_Restore (env
->error_type
, env
->error_value
, env
->error_traceback
);
231 PyGILState_Release (env
->state
);
232 python_gdbarch
= env
->gdbarch
;
233 python_language
= env
->language
;
235 restore_active_ext_lang (env
->previous_active
);
240 /* Called before entering the Python interpreter to install the
241 current language and architecture to be used for Python values.
242 Also set the active extension language for GDB so that SIGINT's
243 are directed our way, and if necessary install the right SIGINT
247 ensure_python_env (struct gdbarch
*gdbarch
,
248 const struct language_defn
*language
)
250 struct python_env
*env
= XNEW (struct python_env
);
252 /* We should not ever enter Python unless initialized. */
253 if (!gdb_python_initialized
)
254 error (_("Python not initialized"));
256 env
->previous_active
= set_active_ext_lang (&extension_language_python
);
258 env
->state
= PyGILState_Ensure ();
259 env
->gdbarch
= python_gdbarch
;
260 env
->language
= python_language
;
262 python_gdbarch
= gdbarch
;
263 python_language
= language
;
265 /* Save it and ensure ! PyErr_Occurred () afterwards. */
266 PyErr_Fetch (&env
->error_type
, &env
->error_value
, &env
->error_traceback
);
268 return make_cleanup (restore_python_env
, env
);
271 /* Set the quit flag. */
274 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
276 PyErr_SetInterrupt ();
279 /* Return true if the quit flag has been set, false otherwise. */
282 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
284 return PyOS_InterruptOccurred ();
287 /* Evaluate a Python command like PyRun_SimpleString, but uses
288 Py_single_input which prints the result of expressions, and does
289 not automatically print the stack on errors. */
292 eval_python_command (const char *command
)
296 m
= PyImport_AddModule ("__main__");
300 d
= PyModule_GetDict (m
);
303 v
= PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
);
316 /* Implementation of the gdb "python-interactive" command. */
319 python_interactive_command (char *arg
, int from_tty
)
321 struct cleanup
*cleanup
;
324 cleanup
= make_cleanup_restore_integer (¤t_ui
->async
);
325 current_ui
->async
= 0;
327 arg
= skip_spaces (arg
);
329 ensure_python_env (get_current_arch (), current_language
);
333 int len
= strlen (arg
);
334 char *script
= (char *) xmalloc (len
+ 2);
336 strcpy (script
, arg
);
338 script
[len
+ 1] = '\0';
339 err
= eval_python_command (script
);
344 err
= PyRun_InteractiveLoop (instream
, "<stdin>");
350 gdbpy_print_stack ();
351 error (_("Error while executing Python code."));
354 do_cleanups (cleanup
);
357 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
360 On Windows hosts few users would build Python themselves (this is no
361 trivial task on this platform), and thus use binaries built by
362 someone else instead. There may happen situation where the Python
363 library and GDB are using two different versions of the C runtime
364 library. Python, being built with VC, would use one version of the
365 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
366 A FILE * from one runtime does not necessarily operate correctly in
369 To work around this potential issue, we create on Windows hosts the
370 FILE object using Python routines, thus making sure that it is
371 compatible with the Python library. */
374 python_run_simple_file (FILE *file
, const char *filename
)
378 PyRun_SimpleFile (file
, filename
);
383 PyObject
*python_file
;
384 struct cleanup
*cleanup
;
386 /* Because we have a string for a filename, and are using Python to
387 open the file, we need to expand any tilde in the path first. */
388 full_path
= tilde_expand (filename
);
389 cleanup
= make_cleanup (xfree
, full_path
);
390 python_file
= PyFile_FromString (full_path
, "r");
393 do_cleanups (cleanup
);
394 gdbpy_print_stack ();
395 error (_("Error while opening file: %s"), full_path
);
398 make_cleanup_py_decref (python_file
);
399 PyRun_SimpleFile (PyFile_AsFile (python_file
), filename
);
400 do_cleanups (cleanup
);
405 /* Given a command_line, return a command string suitable for passing
406 to Python. Lines in the string are separated by newlines. The
407 return value is allocated using xmalloc and the caller is
408 responsible for freeing it. */
411 compute_python_string (struct command_line
*l
)
413 struct command_line
*iter
;
418 for (iter
= l
; iter
; iter
= iter
->next
)
419 size
+= strlen (iter
->line
) + 1;
421 script
= (char *) xmalloc (size
+ 1);
423 for (iter
= l
; iter
; iter
= iter
->next
)
425 int len
= strlen (iter
->line
);
427 strcpy (&script
[here
], iter
->line
);
429 script
[here
++] = '\n';
435 /* Take a command line structure representing a 'python' command, and
436 evaluate its body using the Python interpreter. */
439 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
440 struct command_line
*cmd
)
444 struct cleanup
*cleanup
;
446 if (cmd
->body_count
!= 1)
447 error (_("Invalid \"python\" block structure."));
449 cleanup
= ensure_python_env (get_current_arch (), current_language
);
451 script
= compute_python_string (cmd
->body_list
[0]);
452 ret
= PyRun_SimpleString (script
);
455 error (_("Error while executing Python code."));
457 do_cleanups (cleanup
);
460 /* Implementation of the gdb "python" command. */
463 python_command (char *arg
, int from_tty
)
465 struct cleanup
*cleanup
;
467 cleanup
= ensure_python_env (get_current_arch (), current_language
);
469 make_cleanup_restore_integer (¤t_ui
->async
);
470 current_ui
->async
= 0;
472 arg
= skip_spaces (arg
);
475 if (PyRun_SimpleString (arg
))
476 error (_("Error while executing Python code."));
480 struct command_line
*l
= get_command_line (python_control
, "");
482 make_cleanup_free_command_lines (&l
);
483 execute_control_command_untraced (l
);
486 do_cleanups (cleanup
);
491 /* Transform a gdb parameters's value into a Python value. May return
492 NULL (and set a Python exception) on error. Helper function for
495 gdbpy_parameter_value (enum var_types type
, void *var
)
500 case var_string_noescape
:
501 case var_optional_filename
:
505 char *str
= * (char **) var
;
509 return host_string_to_python_string (str
);
520 case var_auto_boolean
:
522 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
524 if (ab
== AUTO_BOOLEAN_TRUE
)
526 else if (ab
== AUTO_BOOLEAN_FALSE
)
533 if ((* (int *) var
) == INT_MAX
)
537 return PyLong_FromLong (* (int *) var
);
541 unsigned int val
= * (unsigned int *) var
;
545 return PyLong_FromUnsignedLong (val
);
549 return PyErr_Format (PyExc_RuntimeError
,
550 _("Programmer error: unhandled type."));
553 /* A Python function which returns a gdb parameter's value as a Python
557 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
559 struct gdb_exception except
= exception_none
;
560 struct cmd_list_element
*alias
, *prefix
, *cmd
;
565 if (! PyArg_ParseTuple (args
, "s", &arg
))
568 newarg
= concat ("show ", arg
, (char *) NULL
);
572 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
574 CATCH (ex
, RETURN_MASK_ALL
)
581 GDB_PY_HANDLE_EXCEPTION (except
);
583 return PyErr_Format (PyExc_RuntimeError
,
584 _("Could not find parameter `%s'."), arg
);
587 return PyErr_Format (PyExc_RuntimeError
,
588 _("`%s' is not a parameter."), arg
);
589 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
592 /* Wrapper for target_charset. */
595 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
597 const char *cset
= target_charset (python_gdbarch
);
599 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
602 /* Wrapper for target_wide_charset. */
605 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
607 const char *cset
= target_wide_charset (python_gdbarch
);
609 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
612 /* A Python function which evaluates a string using the gdb CLI. */
615 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
618 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
619 int from_tty
, to_string
;
620 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
623 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
624 &PyBool_Type
, &from_tty_obj
,
625 &PyBool_Type
, &to_string_obj
))
631 int cmp
= PyObject_IsTrue (from_tty_obj
);
640 int cmp
= PyObject_IsTrue (to_string_obj
);
648 /* Copy the argument text in case the command modifies it. */
649 char *copy
= xstrdup (arg
);
650 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
651 struct interp
*interp
;
653 make_cleanup_restore_integer (¤t_ui
->async
);
654 current_ui
->async
= 0;
656 make_cleanup_restore_ui_out (¤t_uiout
);
657 /* Use the console interpreter uiout to have the same print format
658 for console or MI. */
659 interp
= interp_lookup ("console");
660 current_uiout
= interp_ui_out (interp
);
662 prevent_dont_repeat ();
664 result
= execute_command_to_string (copy
, from_tty
);
668 execute_command (copy
, from_tty
);
671 do_cleanups (cleanup
);
673 CATCH (except
, RETURN_MASK_ALL
)
675 GDB_PY_HANDLE_EXCEPTION (except
);
679 /* Do any commands attached to breakpoint we stopped at. */
680 bpstat_do_actions ();
684 PyObject
*r
= PyString_FromString (result
);
691 /* Implementation of gdb.solib_name (Long) -> String.
692 Returns the name of the shared library holding a given address, or None. */
695 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
701 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
704 soname
= solib_name_from_address (current_program_space
, pc
);
706 str_obj
= host_string_to_python_string (soname
);
716 /* A Python function which is a wrapper for decode_line_1. */
719 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
721 struct gdb_exception except
= exception_none
;
722 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
724 struct symtab_and_line sal
;
726 struct cleanup
*cleanups
;
727 PyObject
*result
= NULL
;
728 PyObject
*return_result
= NULL
;
729 PyObject
*unparsed
= NULL
;
730 struct event_location
*location
= NULL
;
732 if (! PyArg_ParseTuple (args
, "|s", &arg
))
735 cleanups
= make_cleanup (null_cleanup
, NULL
);
741 location
= new_linespec_location (&arg
);
742 make_cleanup_delete_event_location (location
);
747 if (location
!= NULL
)
748 sals
= decode_line_1 (location
, 0, NULL
, NULL
, 0);
751 set_default_source_symtab_and_line ();
752 sal
= get_current_source_symtab_and_line ();
757 CATCH (ex
, RETURN_MASK_ALL
)
763 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
764 make_cleanup (xfree
, sals
.sals
);
766 if (except
.reason
< 0)
768 do_cleanups (cleanups
);
769 /* We know this will always throw. */
770 gdbpy_convert_exception (except
);
778 result
= PyTuple_New (sals
.nelts
);
781 for (i
= 0; i
< sals
.nelts
; ++i
)
785 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
792 PyTuple_SetItem (result
, i
, obj
);
801 return_result
= PyTuple_New (2);
808 if (arg
!= NULL
&& strlen (arg
) > 0)
810 unparsed
= PyString_FromString (arg
);
811 if (unparsed
== NULL
)
814 Py_DECREF (return_result
);
815 return_result
= NULL
;
825 PyTuple_SetItem (return_result
, 0, unparsed
);
826 PyTuple_SetItem (return_result
, 1, result
);
829 do_cleanups (cleanups
);
831 return return_result
;
834 /* Parse a string and evaluate it as an expression. */
836 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
838 const char *expr_str
;
839 struct value
*result
= NULL
;
841 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
846 result
= parse_and_eval (expr_str
);
848 CATCH (except
, RETURN_MASK_ALL
)
850 GDB_PY_HANDLE_EXCEPTION (except
);
854 return value_to_value_object (result
);
857 /* Implementation of gdb.find_pc_line function.
858 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
861 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
863 gdb_py_ulongest pc_llu
;
864 PyObject
*result
= NULL
; /* init for gcc -Wall */
866 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
871 struct symtab_and_line sal
;
874 pc
= (CORE_ADDR
) pc_llu
;
875 sal
= find_pc_line (pc
, 0);
876 result
= symtab_and_line_to_sal_object (sal
);
878 CATCH (except
, RETURN_MASK_ALL
)
880 GDB_PY_HANDLE_EXCEPTION (except
);
887 /* Read a file as Python code.
888 This is the extension_language_script_ops.script_sourcer "method".
889 FILE is the file to load. FILENAME is name of the file FILE.
890 This does not throw any errors. If an exception occurs python will print
891 the traceback and clear the error indicator. */
894 gdbpy_source_script (const struct extension_language_defn
*extlang
,
895 FILE *file
, const char *filename
)
897 struct cleanup
*cleanup
;
899 cleanup
= ensure_python_env (get_current_arch (), current_language
);
900 python_run_simple_file (file
, filename
);
901 do_cleanups (cleanup
);
906 /* Posting and handling events. */
908 /* A single event. */
911 /* The Python event. This is just a callable object. */
913 /* The next event. */
914 struct gdbpy_event
*next
;
917 /* All pending events. */
918 static struct gdbpy_event
*gdbpy_event_list
;
919 /* The final link of the event list. */
920 static struct gdbpy_event
**gdbpy_event_list_end
;
922 /* So that we can wake up the main thread even when it is blocked in
924 static struct serial_event
*gdbpy_serial_event
;
926 /* The file handler callback. This reads from the internal pipe, and
927 then processes the Python event queue. This will always be run in
928 the main gdb thread. */
931 gdbpy_run_events (int error
, gdb_client_data client_data
)
933 struct cleanup
*cleanup
;
935 cleanup
= ensure_python_env (get_current_arch (), current_language
);
937 /* Clear the event fd. Do this before flushing the events list, so
938 that any new event post afterwards is sure to re-awake the event
940 serial_event_clear (gdbpy_serial_event
);
942 while (gdbpy_event_list
)
944 PyObject
*call_result
;
946 /* Dispatching the event might push a new element onto the event
947 loop, so we update here "atomically enough". */
948 struct gdbpy_event
*item
= gdbpy_event_list
;
949 gdbpy_event_list
= gdbpy_event_list
->next
;
950 if (gdbpy_event_list
== NULL
)
951 gdbpy_event_list_end
= &gdbpy_event_list
;
954 call_result
= PyObject_CallObject (item
->event
, NULL
);
955 if (call_result
== NULL
)
958 Py_XDECREF (call_result
);
959 Py_DECREF (item
->event
);
963 do_cleanups (cleanup
);
966 /* Submit an event to the gdb thread. */
968 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
970 struct gdbpy_event
*event
;
974 if (!PyArg_ParseTuple (args
, "O", &func
))
977 if (!PyCallable_Check (func
))
979 PyErr_SetString (PyExc_RuntimeError
,
980 _("Posted event is not callable"));
986 /* From here until the end of the function, we have the GIL, so we
987 can operate on our global data structures without worrying. */
988 wakeup
= gdbpy_event_list
== NULL
;
990 event
= XNEW (struct gdbpy_event
);
993 *gdbpy_event_list_end
= event
;
994 gdbpy_event_list_end
= &event
->next
;
996 /* Wake up gdb when needed. */
998 serial_event_set (gdbpy_serial_event
);
1003 /* Initialize the Python event handler. */
1005 gdbpy_initialize_events (void)
1007 gdbpy_event_list_end
= &gdbpy_event_list
;
1009 gdbpy_serial_event
= make_serial_event ();
1010 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1011 gdbpy_run_events
, NULL
);
1018 /* This is the extension_language_ops.before_prompt "method". */
1020 static enum ext_lang_rc
1021 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1022 const char *current_gdb_prompt
)
1024 struct cleanup
*cleanup
;
1025 char *prompt
= NULL
;
1027 if (!gdb_python_initialized
)
1028 return EXT_LANG_RC_NOP
;
1030 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1032 if (gdb_python_module
1033 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1037 hook
= PyObject_GetAttrString (gdb_python_module
, "prompt_hook");
1041 make_cleanup_py_decref (hook
);
1043 if (PyCallable_Check (hook
))
1046 PyObject
*current_prompt
;
1048 current_prompt
= PyString_FromString (current_gdb_prompt
);
1049 if (current_prompt
== NULL
)
1052 result
= PyObject_CallFunctionObjArgs (hook
, current_prompt
, NULL
);
1054 Py_DECREF (current_prompt
);
1059 make_cleanup_py_decref (result
);
1061 /* Return type should be None, or a String. If it is None,
1062 fall through, we will not set a prompt. If it is a
1063 string, set PROMPT. Anything else, set an exception. */
1064 if (result
!= Py_None
&& ! PyString_Check (result
))
1066 PyErr_Format (PyExc_RuntimeError
,
1067 _("Return from prompt_hook must " \
1068 "be either a Python string, or None"));
1072 if (result
!= Py_None
)
1074 prompt
= python_string_to_host_string (result
);
1079 make_cleanup (xfree
, prompt
);
1084 /* If a prompt has been set, PROMPT will not be NULL. If it is
1085 NULL, do not set the prompt. */
1087 set_prompt (prompt
);
1089 do_cleanups (cleanup
);
1090 return prompt
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_NOP
;
1093 gdbpy_print_stack ();
1094 do_cleanups (cleanup
);
1095 return EXT_LANG_RC_ERROR
;
1102 /* A python function to write a single string using gdb's filtered
1103 output stream . The optional keyword STREAM can be used to write
1104 to a particular stream. The default stream is to gdb_stdout. */
1107 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1110 static char *keywords
[] = {"text", "stream", NULL
};
1111 int stream_type
= 0;
1113 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1119 switch (stream_type
)
1123 fprintf_filtered (gdb_stderr
, "%s", arg
);
1128 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1132 fprintf_filtered (gdb_stdout
, "%s", arg
);
1135 CATCH (except
, RETURN_MASK_ALL
)
1137 GDB_PY_HANDLE_EXCEPTION (except
);
1144 /* A python function to flush a gdb stream. The optional keyword
1145 STREAM can be used to flush a particular stream. The default stream
1149 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1151 static char *keywords
[] = {"stream", NULL
};
1152 int stream_type
= 0;
1154 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1158 switch (stream_type
)
1162 gdb_flush (gdb_stderr
);
1167 gdb_flush (gdb_stdlog
);
1171 gdb_flush (gdb_stdout
);
1177 /* Return non-zero if print-stack is not "none". */
1180 gdbpy_print_python_errors_p (void)
1182 return gdbpy_should_print_stack
!= python_excp_none
;
1185 /* Print a python exception trace, print just a message, or print
1186 nothing and clear the python exception, depending on
1187 gdbpy_should_print_stack. Only call this if a python exception is
1190 gdbpy_print_stack (void)
1193 /* Print "none", just clear exception. */
1194 if (gdbpy_should_print_stack
== python_excp_none
)
1198 /* Print "full" message and backtrace. */
1199 else if (gdbpy_should_print_stack
== python_excp_full
)
1202 /* PyErr_Print doesn't necessarily end output with a newline.
1203 This works because Python's stdout/stderr is fed through
1209 CATCH (except
, RETURN_MASK_ALL
)
1214 /* Print "message", just error print message. */
1217 PyObject
*ptype
, *pvalue
, *ptraceback
;
1218 char *msg
= NULL
, *type
= NULL
;
1220 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1222 /* Fetch the error message contained within ptype, pvalue. */
1223 msg
= gdbpy_exception_to_string (ptype
, pvalue
);
1224 type
= gdbpy_obj_to_string (ptype
);
1230 /* An error occurred computing the string representation of the
1232 fprintf_filtered (gdb_stderr
,
1233 _("Error occurred computing Python error" \
1237 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1240 CATCH (except
, RETURN_MASK_ALL
)
1246 Py_XDECREF (pvalue
);
1247 Py_XDECREF (ptraceback
);
1254 /* Return the current Progspace.
1255 There always is one. */
1258 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1262 result
= pspace_to_pspace_object (current_program_space
);
1268 /* Return a sequence holding all the Progspaces. */
1271 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1273 struct program_space
*ps
;
1276 list
= PyList_New (0);
1282 PyObject
*item
= pspace_to_pspace_object (ps
);
1284 if (!item
|| PyList_Append (list
, item
) == -1)
1296 /* The "current" objfile. This is set when gdb detects that a new
1297 objfile has been loaded. It is only set for the duration of a call to
1298 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1300 static struct objfile
*gdbpy_current_objfile
;
1302 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1303 as Python code. This does not throw any errors. If an exception
1304 occurs python will print the traceback and clear the error indicator.
1305 This is the extension_language_script_ops.objfile_script_sourcer
1309 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1310 struct objfile
*objfile
, FILE *file
,
1311 const char *filename
)
1313 struct cleanup
*cleanups
;
1315 if (!gdb_python_initialized
)
1318 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1319 gdbpy_current_objfile
= objfile
;
1321 python_run_simple_file (file
, filename
);
1323 do_cleanups (cleanups
);
1324 gdbpy_current_objfile
= NULL
;
1327 /* Set the current objfile to OBJFILE and then execute SCRIPT
1328 as Python code. This does not throw any errors. If an exception
1329 occurs python will print the traceback and clear the error indicator.
1330 This is the extension_language_script_ops.objfile_script_executor
1334 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1335 struct objfile
*objfile
, const char *name
,
1338 struct cleanup
*cleanups
;
1340 if (!gdb_python_initialized
)
1343 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1344 gdbpy_current_objfile
= objfile
;
1346 PyRun_SimpleString (script
);
1348 do_cleanups (cleanups
);
1349 gdbpy_current_objfile
= NULL
;
1352 /* Return the current Objfile, or None if there isn't one. */
1355 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1359 if (! gdbpy_current_objfile
)
1362 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1368 /* Return a sequence holding all the Objfiles. */
1371 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1373 struct objfile
*objf
;
1376 list
= PyList_New (0);
1382 PyObject
*item
= objfile_to_objfile_object (objf
);
1384 if (!item
|| PyList_Append (list
, item
) == -1)
1394 /* Compute the list of active python type printers and store them in
1395 EXT_PRINTERS->py_type_printers. The product of this function is used by
1396 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1397 This is the extension_language_ops.start_type_printers "method". */
1400 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1401 struct ext_lang_type_printers
*ext_printers
)
1403 struct cleanup
*cleanups
;
1404 PyObject
*type_module
, *func
= NULL
, *printers_obj
= NULL
;
1406 if (!gdb_python_initialized
)
1409 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1411 type_module
= PyImport_ImportModule ("gdb.types");
1412 if (type_module
== NULL
)
1414 gdbpy_print_stack ();
1418 func
= PyObject_GetAttrString (type_module
, "get_type_recognizers");
1421 gdbpy_print_stack ();
1425 printers_obj
= PyObject_CallFunctionObjArgs (func
, (char *) NULL
);
1426 if (printers_obj
== NULL
)
1427 gdbpy_print_stack ();
1429 ext_printers
->py_type_printers
= printers_obj
;
1432 Py_XDECREF (type_module
);
1434 do_cleanups (cleanups
);
1437 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1438 a newly allocated string holding the type's replacement name, and return
1439 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1440 If there's a Python error return EXT_LANG_RC_ERROR.
1441 Otherwise, return EXT_LANG_RC_NOP.
1442 This is the extension_language_ops.apply_type_printers "method". */
1444 static enum ext_lang_rc
1445 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1446 const struct ext_lang_type_printers
*ext_printers
,
1447 struct type
*type
, char **prettied_type
)
1449 struct cleanup
*cleanups
;
1450 PyObject
*type_obj
, *type_module
= NULL
, *func
= NULL
;
1451 PyObject
*result_obj
= NULL
;
1452 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1453 char *result
= NULL
;
1455 if (printers_obj
== NULL
)
1456 return EXT_LANG_RC_NOP
;
1458 if (!gdb_python_initialized
)
1459 return EXT_LANG_RC_NOP
;
1461 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1463 type_obj
= type_to_type_object (type
);
1464 if (type_obj
== NULL
)
1466 gdbpy_print_stack ();
1470 type_module
= PyImport_ImportModule ("gdb.types");
1471 if (type_module
== NULL
)
1473 gdbpy_print_stack ();
1477 func
= PyObject_GetAttrString (type_module
, "apply_type_recognizers");
1480 gdbpy_print_stack ();
1484 result_obj
= PyObject_CallFunctionObjArgs (func
, printers_obj
,
1485 type_obj
, (char *) NULL
);
1486 if (result_obj
== NULL
)
1488 gdbpy_print_stack ();
1492 if (result_obj
!= Py_None
)
1494 result
= python_string_to_host_string (result_obj
);
1496 gdbpy_print_stack ();
1500 Py_XDECREF (type_obj
);
1501 Py_XDECREF (type_module
);
1503 Py_XDECREF (result_obj
);
1504 do_cleanups (cleanups
);
1506 *prettied_type
= result
;
1507 return result
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_ERROR
;
1510 /* Free the result of start_type_printers.
1511 This is the extension_language_ops.free_type_printers "method". */
1514 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1515 struct ext_lang_type_printers
*ext_printers
)
1517 struct cleanup
*cleanups
;
1518 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1520 if (printers
== NULL
)
1523 if (!gdb_python_initialized
)
1526 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1527 Py_DECREF (printers
);
1528 do_cleanups (cleanups
);
1531 #else /* HAVE_PYTHON */
1533 /* Dummy implementation of the gdb "python-interactive" and "python"
1537 python_interactive_command (char *arg
, int from_tty
)
1539 arg
= skip_spaces (arg
);
1541 error (_("Python scripting is not supported in this copy of GDB."));
1544 struct command_line
*l
= get_command_line (python_control
, "");
1545 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1547 execute_control_command_untraced (l
);
1548 do_cleanups (cleanups
);
1553 python_command (char *arg
, int from_tty
)
1555 python_interactive_command (arg
, from_tty
);
1558 #endif /* HAVE_PYTHON */
1562 /* Lists for 'set python' commands. */
1564 static struct cmd_list_element
*user_set_python_list
;
1565 static struct cmd_list_element
*user_show_python_list
;
1567 /* Function for use by 'set python' prefix command. */
1570 user_set_python (char *args
, int from_tty
)
1572 help_list (user_set_python_list
, "set python ", all_commands
,
1576 /* Function for use by 'show python' prefix command. */
1579 user_show_python (char *args
, int from_tty
)
1581 cmd_show_list (user_show_python_list
, from_tty
, "");
1584 /* Initialize the Python code. */
1588 /* This is installed as a final cleanup and cleans up the
1589 interpreter. This lets Python's 'atexit' work. */
1592 finalize_python (void *ignore
)
1594 struct active_ext_lang_state
*previous_active
;
1596 /* We don't use ensure_python_env here because if we ever ran the
1597 cleanup, gdb would crash -- because the cleanup calls into the
1598 Python interpreter, which we are about to destroy. It seems
1599 clearer to make the needed calls explicitly here than to create a
1600 cleanup and then mysteriously discard it. */
1602 /* This is only called as a final cleanup so we can assume the active
1603 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1604 previous_active
= set_active_ext_lang (&extension_language_python
);
1606 (void) PyGILState_Ensure ();
1607 python_gdbarch
= target_gdbarch ();
1608 python_language
= current_language
;
1612 restore_active_ext_lang (previous_active
);
1616 /* Provide a prototype to silence -Wmissing-prototypes. */
1617 extern initialize_file_ftype _initialize_python
;
1620 _initialize_python (void)
1625 size_t progsize
, count
;
1627 wchar_t *progname_copy
;
1630 add_com ("python-interactive", class_obscure
,
1631 python_interactive_command
,
1634 Start an interactive Python prompt.\n\
1636 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1639 Alternatively, a single-line Python command can be given as an\n\
1640 argument, and if the command is an expression, the result will be\n\
1641 printed. For example:\n\
1643 (gdb) python-interactive 2 + 3\n\
1646 #else /* HAVE_PYTHON */
1648 Start a Python interactive prompt.\n\
1650 Python scripting is not supported in this copy of GDB.\n\
1651 This command is only a placeholder.")
1652 #endif /* HAVE_PYTHON */
1654 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1656 add_com ("python", class_obscure
, python_command
,
1659 Evaluate a Python command.\n\
1661 The command can be given as an argument, for instance:\n\
1665 If no argument is given, the following lines are read and used\n\
1666 as the Python commands. Type a line containing \"end\" to indicate\n\
1667 the end of the command.")
1668 #else /* HAVE_PYTHON */
1670 Evaluate a Python command.\n\
1672 Python scripting is not supported in this copy of GDB.\n\
1673 This command is only a placeholder.")
1674 #endif /* HAVE_PYTHON */
1676 add_com_alias ("py", "python", class_obscure
, 1);
1678 /* Add set/show python print-stack. */
1679 add_prefix_cmd ("python", no_class
, user_show_python
,
1680 _("Prefix command for python preference settings."),
1681 &user_show_python_list
, "show python ", 0,
1684 add_prefix_cmd ("python", no_class
, user_set_python
,
1685 _("Prefix command for python preference settings."),
1686 &user_set_python_list
, "set python ", 0,
1689 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1690 &gdbpy_should_print_stack
, _("\
1691 Set mode for Python stack dump on error."), _("\
1692 Show the mode of Python stack printing on error."), _("\
1693 none == no stack or message will be printed.\n\
1694 full == a message and a stack will be printed.\n\
1695 message == an error message without a stack will be printed."),
1697 &user_set_python_list
,
1698 &user_show_python_list
);
1701 #ifdef WITH_PYTHON_PATH
1702 /* Work around problem where python gets confused about where it is,
1703 and then can't find its libraries, etc.
1704 NOTE: Python assumes the following layout:
1706 /foo/lib/pythonX.Y/...
1707 This must be done before calling Py_Initialize. */
1708 progname
= concat (ldirname (python_libdir
), SLASH_STRING
, "bin",
1709 SLASH_STRING
, "python", (char *) NULL
);
1711 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1712 setlocale (LC_ALL
, "");
1713 progsize
= strlen (progname
);
1714 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1718 fprintf (stderr
, "out of memory\n");
1721 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1722 if (count
== (size_t) -1)
1725 fprintf (stderr
, "Could not convert python path to string\n");
1728 setlocale (LC_ALL
, oldloc
);
1731 /* Note that Py_SetProgramName expects the string it is passed to
1732 remain alive for the duration of the program's execution, so
1733 it is not freed after this call. */
1734 Py_SetProgramName (progname_copy
);
1736 Py_SetProgramName (progname
);
1741 PyEval_InitThreads ();
1744 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1745 /* Add _gdb module to the list of known built-in modules. */
1746 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1748 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1750 if (gdb_module
== NULL
)
1753 /* The casts to (char*) are for python 2.4. */
1754 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1755 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1756 (char*) host_name
) < 0
1757 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1758 (char*) target_name
) < 0)
1761 /* Add stream constants. */
1762 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1763 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1764 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1767 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1768 if (gdbpy_gdb_error
== NULL
1769 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1772 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1773 gdbpy_gdb_error
, NULL
);
1774 if (gdbpy_gdb_memory_error
== NULL
1775 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1776 gdbpy_gdb_memory_error
) < 0)
1779 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1780 if (gdbpy_gdberror_exc
== NULL
1781 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1782 gdbpy_gdberror_exc
) < 0)
1785 gdbpy_initialize_gdb_readline ();
1787 if (gdbpy_initialize_auto_load () < 0
1788 || gdbpy_initialize_values () < 0
1789 || gdbpy_initialize_frames () < 0
1790 || gdbpy_initialize_commands () < 0
1791 || gdbpy_initialize_symbols () < 0
1792 || gdbpy_initialize_symtabs () < 0
1793 || gdbpy_initialize_blocks () < 0
1794 || gdbpy_initialize_functions () < 0
1795 || gdbpy_initialize_parameters () < 0
1796 || gdbpy_initialize_types () < 0
1797 || gdbpy_initialize_pspace () < 0
1798 || gdbpy_initialize_objfile () < 0
1799 || gdbpy_initialize_breakpoints () < 0
1800 || gdbpy_initialize_finishbreakpoints () < 0
1801 || gdbpy_initialize_lazy_string () < 0
1802 || gdbpy_initialize_linetable () < 0
1803 || gdbpy_initialize_thread () < 0
1804 || gdbpy_initialize_inferior () < 0
1805 || gdbpy_initialize_events () < 0
1806 || gdbpy_initialize_eventregistry () < 0
1807 || gdbpy_initialize_py_events () < 0
1808 || gdbpy_initialize_event () < 0
1809 || gdbpy_initialize_stop_event () < 0
1810 || gdbpy_initialize_signal_event () < 0
1811 || gdbpy_initialize_breakpoint_event () < 0
1812 || gdbpy_initialize_continue_event () < 0
1813 || gdbpy_initialize_inferior_call_pre_event () < 0
1814 || gdbpy_initialize_inferior_call_post_event () < 0
1815 || gdbpy_initialize_register_changed_event () < 0
1816 || gdbpy_initialize_memory_changed_event () < 0
1817 || gdbpy_initialize_exited_event () < 0
1818 || gdbpy_initialize_thread_event () < 0
1819 || gdbpy_initialize_new_objfile_event () < 0
1820 || gdbpy_initialize_clear_objfiles_event () < 0
1821 || gdbpy_initialize_arch () < 0
1822 || gdbpy_initialize_xmethods () < 0
1823 || gdbpy_initialize_unwind () < 0)
1826 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1827 if (gdbpy_to_string_cst
== NULL
)
1829 gdbpy_children_cst
= PyString_FromString ("children");
1830 if (gdbpy_children_cst
== NULL
)
1832 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1833 if (gdbpy_display_hint_cst
== NULL
)
1835 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1836 if (gdbpy_doc_cst
== NULL
)
1838 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1839 if (gdbpy_enabled_cst
== NULL
)
1841 gdbpy_value_cst
= PyString_FromString ("value");
1842 if (gdbpy_value_cst
== NULL
)
1845 /* Release the GIL while gdb runs. */
1846 PyThreadState_Swap (NULL
);
1847 PyEval_ReleaseLock ();
1849 make_final_cleanup (finalize_python
, NULL
);
1851 gdb_python_initialized
= 1;
1855 gdbpy_print_stack ();
1856 /* Do not set 'gdb_python_initialized'. */
1859 #endif /* HAVE_PYTHON */
1864 /* Perform the remaining python initializations.
1865 These must be done after GDB is at least mostly initialized.
1866 E.g., The "info pretty-printer" command needs the "info" prefix
1868 This is the extension_language_ops.finish_initialization "method". */
1871 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1874 char *gdb_pythondir
;
1876 struct cleanup
*cleanup
;
1878 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1880 /* Add the initial data-directory to sys.path. */
1882 gdb_pythondir
= concat (gdb_datadir
, SLASH_STRING
, "python", (char *) NULL
);
1883 make_cleanup (xfree
, gdb_pythondir
);
1885 sys_path
= PySys_GetObject ("path");
1887 /* If sys.path is not defined yet, define it first. */
1888 if (!(sys_path
&& PyList_Check (sys_path
)))
1891 PySys_SetPath (L
"");
1895 sys_path
= PySys_GetObject ("path");
1897 if (sys_path
&& PyList_Check (sys_path
))
1899 PyObject
*pythondir
;
1902 pythondir
= PyString_FromString (gdb_pythondir
);
1903 if (pythondir
== NULL
)
1906 err
= PyList_Insert (sys_path
, 0, pythondir
);
1907 Py_DECREF (pythondir
);
1914 /* Import the gdb module to finish the initialization, and
1915 add it to __main__ for convenience. */
1916 m
= PyImport_AddModule ("__main__");
1920 gdb_python_module
= PyImport_ImportModule ("gdb");
1921 if (gdb_python_module
== NULL
)
1923 gdbpy_print_stack ();
1924 /* This is passed in one call to warning so that blank lines aren't
1925 inserted between each line of text. */
1927 "Could not load the Python gdb module from `%s'.\n"
1928 "Limited Python support is available from the _gdb module.\n"
1929 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1931 do_cleanups (cleanup
);
1935 if (gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) < 0)
1938 /* Keep the reference to gdb_python_module since it is in a global
1941 do_cleanups (cleanup
);
1945 gdbpy_print_stack ();
1946 warning (_("internal error: Unhandled Python exception"));
1947 do_cleanups (cleanup
);
1950 /* Return non-zero if Python has successfully initialized.
1951 This is the extension_languages_ops.initialized "method". */
1954 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1956 return gdb_python_initialized
;
1959 #endif /* HAVE_PYTHON */
1965 PyMethodDef python_GdbMethods
[] =
1967 { "history", gdbpy_history
, METH_VARARGS
,
1968 "Get a value from history" },
1969 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1970 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1971 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1972 a Python String containing the output of the command if to_string is\n\
1974 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1975 "Return a gdb parameter's value" },
1977 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1978 "Return a tuple of all breakpoint objects" },
1980 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1981 "Find the default visualizer for a Value." },
1983 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1984 "Return the current Progspace." },
1985 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1986 "Return a sequence of all progspaces." },
1988 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1989 "Return the current Objfile being loaded, or None." },
1990 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1991 "Return a sequence of all loaded objfiles." },
1993 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1994 "newest_frame () -> gdb.Frame.\n\
1995 Return the newest frame object." },
1996 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1997 "selected_frame () -> gdb.Frame.\n\
1998 Return the selected frame object." },
1999 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2000 "stop_reason_string (Integer) -> String.\n\
2001 Return a string explaining unwind stop reason." },
2003 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2004 METH_VARARGS
| METH_KEYWORDS
,
2005 "lookup_type (name [, block]) -> type\n\
2006 Return a Type corresponding to the given name." },
2007 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2008 METH_VARARGS
| METH_KEYWORDS
,
2009 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2010 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2011 a boolean indicating if name is a field of the current implied argument\n\
2012 `this' (when the current language is object-oriented)." },
2013 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2014 METH_VARARGS
| METH_KEYWORDS
,
2015 "lookup_global_symbol (name [, domain]) -> symbol\n\
2016 Return the symbol corresponding to the given name (or None)." },
2018 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2019 METH_VARARGS
| METH_KEYWORDS
,
2020 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2021 Look up the specified objfile.\n\
2022 If by_build_id is True, the objfile is looked up by using name\n\
2023 as its build id." },
2025 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
2026 "Return the block containing the given pc value, or None." },
2027 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
2028 "solib_name (Long) -> String.\n\
2029 Return the name of the shared library holding a given address, or None." },
2030 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2031 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2032 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2033 The first element contains any unparsed portion of the String parameter\n\
2034 (or None if the string was fully parsed). The second element contains\n\
2035 a tuple that contains all the locations that match, represented as\n\
2036 gdb.Symtab_and_line objects (or None)."},
2037 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2038 "parse_and_eval (String) -> Value.\n\
2039 Parse String as an expression, evaluate it, and return the result as a Value."
2041 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2042 "find_pc_line (pc) -> Symtab_and_line.\n\
2043 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2045 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2046 "Post an event into gdb's event loop." },
2048 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2049 "target_charset () -> string.\n\
2050 Return the name of the current target charset." },
2051 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2052 "target_wide_charset () -> string.\n\
2053 Return the name of the current target wide charset." },
2055 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2056 "string_to_argv (String) -> Array.\n\
2057 Parse String and return an argv-like array.\n\
2058 Arguments are separate by spaces and may be quoted."
2060 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2061 "Write a string using gdb's filtered stream." },
2062 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2063 "Flush gdb's filtered stdout stream." },
2064 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2065 "selected_thread () -> gdb.InferiorThread.\n\
2066 Return the selected thread object." },
2067 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2068 "selected_inferior () -> gdb.Inferior.\n\
2069 Return the selected inferior object." },
2070 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2071 "inferiors () -> (gdb.Inferior, ...).\n\
2072 Return a tuple containing all inferiors." },
2073 {NULL
, NULL
, 0, NULL
}
2077 struct PyModuleDef python_GdbModuleDef
=
2079 PyModuleDef_HEAD_INIT
,
2090 #endif /* HAVE_PYTHON */