1 /* General python/gdb code
3 Copyright (C) 2008-2015 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 /* Declared constants and enum for python stack printing. */
39 static const char python_excp_none
[] = "none";
40 static const char python_excp_full
[] = "full";
41 static const char python_excp_message
[] = "message";
43 /* "set python print-stack" choices. */
44 static const char *const python_excp_enums
[] =
52 /* The exception printing variable. 'full' if we want to print the
53 error message and stack, 'none' if we want to print nothing, and
54 'message' if we only want to print the error message. 'message' is
56 static const char *gdbpy_should_print_stack
= python_excp_message
;
59 /* Forward decls, these are defined later. */
60 extern const struct extension_language_script_ops python_extension_script_ops
;
61 extern const struct extension_language_ops python_extension_ops
;
64 /* The main struct describing GDB's interface to the Python
65 extension language. */
66 const struct extension_language_defn extension_language_python
=
78 &python_extension_script_ops
,
88 #include "cli/cli-decode.h"
92 #include "python-internal.h"
97 #include "gdbthread.h"
99 #include "event-top.h"
101 /* True if Python has been successfully initialized, false
104 int gdb_python_initialized
;
106 extern PyMethodDef python_GdbMethods
[];
109 extern struct PyModuleDef python_GdbModuleDef
;
112 PyObject
*gdb_module
;
113 PyObject
*gdb_python_module
;
115 /* Some string constants we may wish to use. */
116 PyObject
*gdbpy_to_string_cst
;
117 PyObject
*gdbpy_children_cst
;
118 PyObject
*gdbpy_display_hint_cst
;
119 PyObject
*gdbpy_doc_cst
;
120 PyObject
*gdbpy_enabled_cst
;
121 PyObject
*gdbpy_value_cst
;
123 /* The GdbError exception. */
124 PyObject
*gdbpy_gdberror_exc
;
126 /* The `gdb.error' base class. */
127 PyObject
*gdbpy_gdb_error
;
129 /* The `gdb.MemoryError' exception. */
130 PyObject
*gdbpy_gdb_memory_error
;
132 static script_sourcer_func gdbpy_source_script
;
133 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
134 static objfile_script_executor_func gdbpy_execute_objfile_script
;
135 static void gdbpy_finish_initialization
136 (const struct extension_language_defn
*);
137 static int gdbpy_initialized (const struct extension_language_defn
*);
138 static void gdbpy_eval_from_control_command
139 (const struct extension_language_defn
*, struct command_line
*cmd
);
140 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
141 struct ext_lang_type_printers
*);
142 static enum ext_lang_rc gdbpy_apply_type_printers
143 (const struct extension_language_defn
*,
144 const struct ext_lang_type_printers
*, struct type
*, char **);
145 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
146 struct ext_lang_type_printers
*);
147 static void gdbpy_clear_quit_flag (const struct extension_language_defn
*);
148 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
149 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
150 static enum ext_lang_rc gdbpy_before_prompt_hook
151 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
153 /* The interface between gdb proper and loading of python scripts. */
155 const struct extension_language_script_ops python_extension_script_ops
=
158 gdbpy_source_objfile_script
,
159 gdbpy_execute_objfile_script
,
160 gdbpy_auto_load_enabled
163 /* The interface between gdb proper and python extensions. */
165 const struct extension_language_ops python_extension_ops
=
167 gdbpy_finish_initialization
,
170 gdbpy_eval_from_control_command
,
172 gdbpy_start_type_printers
,
173 gdbpy_apply_type_printers
,
174 gdbpy_free_type_printers
,
176 gdbpy_apply_val_pretty_printer
,
178 gdbpy_apply_frame_filter
,
180 gdbpy_preserve_values
,
182 gdbpy_breakpoint_has_cond
,
183 gdbpy_breakpoint_cond_says_stop
,
185 gdbpy_clear_quit_flag
,
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
,
198 /* Architecture and language to be used in callbacks from
199 the Python interpreter. */
200 struct gdbarch
*python_gdbarch
;
201 const struct language_defn
*python_language
;
203 /* Restore global language and architecture and Python GIL state
204 when leaving the Python interpreter. */
208 struct active_ext_lang_state
*previous_active
;
209 PyGILState_STATE state
;
210 struct gdbarch
*gdbarch
;
211 const struct language_defn
*language
;
212 PyObject
*error_type
, *error_value
, *error_traceback
;
216 restore_python_env (void *p
)
218 struct python_env
*env
= (struct python_env
*)p
;
220 /* Leftover Python error is forbidden by Python Exception Handling. */
221 if (PyErr_Occurred ())
223 /* This order is similar to the one calling error afterwards. */
224 gdbpy_print_stack ();
225 warning (_("internal error: Unhandled Python exception"));
228 PyErr_Restore (env
->error_type
, env
->error_value
, env
->error_traceback
);
230 PyGILState_Release (env
->state
);
231 python_gdbarch
= env
->gdbarch
;
232 python_language
= env
->language
;
234 restore_active_ext_lang (env
->previous_active
);
239 /* Called before entering the Python interpreter to install the
240 current language and architecture to be used for Python values.
241 Also set the active extension language for GDB so that SIGINT's
242 are directed our way, and if necessary install the right SIGINT
246 ensure_python_env (struct gdbarch
*gdbarch
,
247 const struct language_defn
*language
)
249 struct python_env
*env
= xmalloc (sizeof *env
);
251 /* We should not ever enter Python unless initialized. */
252 if (!gdb_python_initialized
)
253 error (_("Python not initialized"));
255 env
->previous_active
= set_active_ext_lang (&extension_language_python
);
257 env
->state
= PyGILState_Ensure ();
258 env
->gdbarch
= python_gdbarch
;
259 env
->language
= python_language
;
261 python_gdbarch
= gdbarch
;
262 python_language
= language
;
264 /* Save it and ensure ! PyErr_Occurred () afterwards. */
265 PyErr_Fetch (&env
->error_type
, &env
->error_value
, &env
->error_traceback
);
267 return make_cleanup (restore_python_env
, env
);
270 /* Clear the quit flag. */
273 gdbpy_clear_quit_flag (const struct extension_language_defn
*extlang
)
275 /* This clears the flag as a side effect. */
276 PyOS_InterruptOccurred ();
279 /* Set the quit flag. */
282 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
284 PyErr_SetInterrupt ();
287 /* Return true if the quit flag has been set, false otherwise. */
290 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
292 return PyOS_InterruptOccurred ();
295 /* Evaluate a Python command like PyRun_SimpleString, but uses
296 Py_single_input which prints the result of expressions, and does
297 not automatically print the stack on errors. */
300 eval_python_command (const char *command
)
304 m
= PyImport_AddModule ("__main__");
308 d
= PyModule_GetDict (m
);
311 v
= PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
);
324 /* Implementation of the gdb "python-interactive" command. */
327 python_interactive_command (char *arg
, int from_tty
)
329 struct cleanup
*cleanup
;
332 cleanup
= make_cleanup_restore_integer (&interpreter_async
);
333 interpreter_async
= 0;
335 arg
= skip_spaces (arg
);
337 ensure_python_env (get_current_arch (), current_language
);
341 int len
= strlen (arg
);
342 char *script
= xmalloc (len
+ 2);
344 strcpy (script
, arg
);
346 script
[len
+ 1] = '\0';
347 err
= eval_python_command (script
);
352 err
= PyRun_InteractiveLoop (instream
, "<stdin>");
358 gdbpy_print_stack ();
359 error (_("Error while executing Python code."));
362 do_cleanups (cleanup
);
365 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
368 On Windows hosts few users would build Python themselves (this is no
369 trivial task on this platform), and thus use binaries built by
370 someone else instead. There may happen situation where the Python
371 library and GDB are using two different versions of the C runtime
372 library. Python, being built with VC, would use one version of the
373 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
374 A FILE * from one runtime does not necessarily operate correctly in
377 To work around this potential issue, we create on Windows hosts the
378 FILE object using Python routines, thus making sure that it is
379 compatible with the Python library. */
382 python_run_simple_file (FILE *file
, const char *filename
)
386 PyRun_SimpleFile (file
, filename
);
391 PyObject
*python_file
;
392 struct cleanup
*cleanup
;
394 /* Because we have a string for a filename, and are using Python to
395 open the file, we need to expand any tilde in the path first. */
396 full_path
= tilde_expand (filename
);
397 cleanup
= make_cleanup (xfree
, full_path
);
398 python_file
= PyFile_FromString (full_path
, "r");
401 do_cleanups (cleanup
);
402 gdbpy_print_stack ();
403 error (_("Error while opening file: %s"), full_path
);
406 make_cleanup_py_decref (python_file
);
407 PyRun_SimpleFile (PyFile_AsFile (python_file
), filename
);
408 do_cleanups (cleanup
);
413 /* Given a command_line, return a command string suitable for passing
414 to Python. Lines in the string are separated by newlines. The
415 return value is allocated using xmalloc and the caller is
416 responsible for freeing it. */
419 compute_python_string (struct command_line
*l
)
421 struct command_line
*iter
;
426 for (iter
= l
; iter
; iter
= iter
->next
)
427 size
+= strlen (iter
->line
) + 1;
429 script
= xmalloc (size
+ 1);
431 for (iter
= l
; iter
; iter
= iter
->next
)
433 int len
= strlen (iter
->line
);
435 strcpy (&script
[here
], iter
->line
);
437 script
[here
++] = '\n';
443 /* Take a command line structure representing a 'python' command, and
444 evaluate its body using the Python interpreter. */
447 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
448 struct command_line
*cmd
)
452 struct cleanup
*cleanup
;
454 if (cmd
->body_count
!= 1)
455 error (_("Invalid \"python\" block structure."));
457 cleanup
= ensure_python_env (get_current_arch (), current_language
);
459 script
= compute_python_string (cmd
->body_list
[0]);
460 ret
= PyRun_SimpleString (script
);
463 error (_("Error while executing Python code."));
465 do_cleanups (cleanup
);
468 /* Implementation of the gdb "python" command. */
471 python_command (char *arg
, int from_tty
)
473 struct cleanup
*cleanup
;
475 cleanup
= ensure_python_env (get_current_arch (), current_language
);
477 make_cleanup_restore_integer (&interpreter_async
);
478 interpreter_async
= 0;
480 arg
= skip_spaces (arg
);
483 if (PyRun_SimpleString (arg
))
484 error (_("Error while executing Python code."));
488 struct command_line
*l
= get_command_line (python_control
, "");
490 make_cleanup_free_command_lines (&l
);
491 execute_control_command_untraced (l
);
494 do_cleanups (cleanup
);
499 /* Transform a gdb parameters's value into a Python value. May return
500 NULL (and set a Python exception) on error. Helper function for
503 gdbpy_parameter_value (enum var_types type
, void *var
)
508 case var_string_noescape
:
509 case var_optional_filename
:
513 char *str
= * (char **) var
;
517 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
528 case var_auto_boolean
:
530 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
532 if (ab
== AUTO_BOOLEAN_TRUE
)
534 else if (ab
== AUTO_BOOLEAN_FALSE
)
541 if ((* (int *) var
) == INT_MAX
)
545 return PyLong_FromLong (* (int *) var
);
549 unsigned int val
= * (unsigned int *) var
;
553 return PyLong_FromUnsignedLong (val
);
557 return PyErr_Format (PyExc_RuntimeError
,
558 _("Programmer error: unhandled type."));
561 /* A Python function which returns a gdb parameter's value as a Python
565 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
567 struct gdb_exception except
= exception_none
;
568 struct cmd_list_element
*alias
, *prefix
, *cmd
;
573 if (! PyArg_ParseTuple (args
, "s", &arg
))
576 newarg
= concat ("show ", arg
, (char *) NULL
);
580 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
582 CATCH (ex
, RETURN_MASK_ALL
)
589 GDB_PY_HANDLE_EXCEPTION (except
);
591 return PyErr_Format (PyExc_RuntimeError
,
592 _("Could not find parameter `%s'."), arg
);
595 return PyErr_Format (PyExc_RuntimeError
,
596 _("`%s' is not a parameter."), arg
);
597 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
600 /* Wrapper for target_charset. */
603 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
605 const char *cset
= target_charset (python_gdbarch
);
607 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
610 /* Wrapper for target_wide_charset. */
613 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
615 const char *cset
= target_wide_charset (python_gdbarch
);
617 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
620 /* A Python function which evaluates a string using the gdb CLI. */
623 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
626 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
627 int from_tty
, to_string
;
628 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
631 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
632 &PyBool_Type
, &from_tty_obj
,
633 &PyBool_Type
, &to_string_obj
))
639 int cmp
= PyObject_IsTrue (from_tty_obj
);
648 int cmp
= PyObject_IsTrue (to_string_obj
);
656 /* Copy the argument text in case the command modifies it. */
657 char *copy
= xstrdup (arg
);
658 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
660 make_cleanup_restore_integer (&interpreter_async
);
661 interpreter_async
= 0;
663 prevent_dont_repeat ();
665 result
= execute_command_to_string (copy
, from_tty
);
669 execute_command (copy
, from_tty
);
672 do_cleanups (cleanup
);
674 CATCH (except
, RETURN_MASK_ALL
)
676 GDB_PY_HANDLE_EXCEPTION (except
);
680 /* Do any commands attached to breakpoint we stopped at. */
681 bpstat_do_actions ();
685 PyObject
*r
= PyString_FromString (result
);
692 /* Implementation of gdb.solib_name (Long) -> String.
693 Returns the name of the shared library holding a given address, or None. */
696 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
702 if (!PyArg_ParseTuple (args
, GDB_PY_LL_ARG
, &pc
))
705 soname
= solib_name_from_address (current_program_space
, pc
);
707 str_obj
= PyString_Decode (soname
, strlen (soname
), host_charset (), NULL
);
717 /* A Python function which is a wrapper for decode_line_1. */
720 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
722 struct gdb_exception except
= exception_none
;
723 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
725 struct symtab_and_line sal
;
726 const char *arg
= NULL
;
727 char *copy_to_free
= NULL
, *copy
= NULL
;
728 struct cleanup
*cleanups
;
729 PyObject
*result
= NULL
;
730 PyObject
*return_result
= NULL
;
731 PyObject
*unparsed
= NULL
;
733 if (! PyArg_ParseTuple (args
, "|s", &arg
))
736 cleanups
= make_cleanup (null_cleanup
, NULL
);
744 copy
= xstrdup (arg
);
746 sals
= decode_line_1 (©
, 0, 0, 0);
750 set_default_source_symtab_and_line ();
751 sal
= get_current_source_symtab_and_line ();
756 CATCH (ex
, RETURN_MASK_ALL
)
762 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
764 make_cleanup (xfree
, copy_to_free
);
765 make_cleanup (xfree
, sals
.sals
);
768 if (except
.reason
< 0)
770 do_cleanups (cleanups
);
771 /* We know this will always throw. */
772 gdbpy_convert_exception (except
);
780 result
= PyTuple_New (sals
.nelts
);
783 for (i
= 0; i
< sals
.nelts
; ++i
)
787 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
794 PyTuple_SetItem (result
, i
, obj
);
803 return_result
= PyTuple_New (2);
810 if (copy
&& strlen (copy
) > 0)
812 unparsed
= PyString_FromString (copy
);
813 if (unparsed
== NULL
)
816 Py_DECREF (return_result
);
817 return_result
= NULL
;
827 PyTuple_SetItem (return_result
, 0, unparsed
);
828 PyTuple_SetItem (return_result
, 1, result
);
831 do_cleanups (cleanups
);
833 return return_result
;
836 /* Parse a string and evaluate it as an expression. */
838 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
840 const char *expr_str
;
841 struct value
*result
= NULL
;
843 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
848 result
= parse_and_eval (expr_str
);
850 CATCH (except
, RETURN_MASK_ALL
)
852 GDB_PY_HANDLE_EXCEPTION (except
);
856 return value_to_value_object (result
);
859 /* Implementation of gdb.find_pc_line function.
860 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
863 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
865 gdb_py_ulongest pc_llu
;
866 PyObject
*result
= NULL
; /* init for gcc -Wall */
868 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
873 struct symtab_and_line sal
;
876 pc
= (CORE_ADDR
) pc_llu
;
877 sal
= find_pc_line (pc
, 0);
878 result
= symtab_and_line_to_sal_object (sal
);
880 CATCH (except
, RETURN_MASK_ALL
)
882 GDB_PY_HANDLE_EXCEPTION (except
);
889 /* Read a file as Python code.
890 This is the extension_language_script_ops.script_sourcer "method".
891 FILE is the file to load. FILENAME is name of the file FILE.
892 This does not throw any errors. If an exception occurs python will print
893 the traceback and clear the error indicator. */
896 gdbpy_source_script (const struct extension_language_defn
*extlang
,
897 FILE *file
, const char *filename
)
899 struct cleanup
*cleanup
;
901 cleanup
= ensure_python_env (get_current_arch (), current_language
);
902 python_run_simple_file (file
, filename
);
903 do_cleanups (cleanup
);
908 /* Posting and handling events. */
910 /* A single event. */
913 /* The Python event. This is just a callable object. */
915 /* The next event. */
916 struct gdbpy_event
*next
;
919 /* All pending events. */
920 static struct gdbpy_event
*gdbpy_event_list
;
921 /* The final link of the event list. */
922 static struct gdbpy_event
**gdbpy_event_list_end
;
924 /* We use a file handler, and not an async handler, so that we can
925 wake up the main thread even when it is blocked in poll(). */
926 static struct serial
*gdbpy_event_fds
[2];
928 /* The file handler callback. This reads from the internal pipe, and
929 then processes the Python event queue. This will always be run in
930 the main gdb thread. */
933 gdbpy_run_events (struct serial
*scb
, void *context
)
935 struct cleanup
*cleanup
;
937 cleanup
= ensure_python_env (get_current_arch (), current_language
);
939 /* Flush the fd. Do this before flushing the events list, so that
940 any new event post afterwards is sure to re-awake the event
942 while (serial_readchar (gdbpy_event_fds
[0], 0) >= 0)
945 while (gdbpy_event_list
)
947 PyObject
*call_result
;
949 /* Dispatching the event might push a new element onto the event
950 loop, so we update here "atomically enough". */
951 struct gdbpy_event
*item
= gdbpy_event_list
;
952 gdbpy_event_list
= gdbpy_event_list
->next
;
953 if (gdbpy_event_list
== NULL
)
954 gdbpy_event_list_end
= &gdbpy_event_list
;
957 call_result
= PyObject_CallObject (item
->event
, NULL
);
958 if (call_result
== NULL
)
961 Py_XDECREF (call_result
);
962 Py_DECREF (item
->event
);
966 do_cleanups (cleanup
);
969 /* Submit an event to the gdb thread. */
971 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
973 struct gdbpy_event
*event
;
977 if (!PyArg_ParseTuple (args
, "O", &func
))
980 if (!PyCallable_Check (func
))
982 PyErr_SetString (PyExc_RuntimeError
,
983 _("Posted event is not callable"));
989 /* From here until the end of the function, we have the GIL, so we
990 can operate on our global data structures without worrying. */
991 wakeup
= gdbpy_event_list
== NULL
;
993 event
= XNEW (struct gdbpy_event
);
996 *gdbpy_event_list_end
= event
;
997 gdbpy_event_list_end
= &event
->next
;
999 /* Wake up gdb when needed. */
1002 char c
= 'q'; /* Anything. */
1004 if (serial_write (gdbpy_event_fds
[1], &c
, 1))
1005 return PyErr_SetFromErrno (PyExc_IOError
);
1011 /* Initialize the Python event handler. */
1013 gdbpy_initialize_events (void)
1015 if (serial_pipe (gdbpy_event_fds
) == 0)
1017 gdbpy_event_list_end
= &gdbpy_event_list
;
1018 serial_async (gdbpy_event_fds
[0], gdbpy_run_events
, NULL
);
1026 /* This is the extension_language_ops.before_prompt "method". */
1028 static enum ext_lang_rc
1029 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1030 const char *current_gdb_prompt
)
1032 struct cleanup
*cleanup
;
1033 char *prompt
= NULL
;
1035 if (!gdb_python_initialized
)
1036 return EXT_LANG_RC_NOP
;
1038 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1040 if (gdb_python_module
1041 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1045 hook
= PyObject_GetAttrString (gdb_python_module
, "prompt_hook");
1049 make_cleanup_py_decref (hook
);
1051 if (PyCallable_Check (hook
))
1054 PyObject
*current_prompt
;
1056 current_prompt
= PyString_FromString (current_gdb_prompt
);
1057 if (current_prompt
== NULL
)
1060 result
= PyObject_CallFunctionObjArgs (hook
, current_prompt
, NULL
);
1062 Py_DECREF (current_prompt
);
1067 make_cleanup_py_decref (result
);
1069 /* Return type should be None, or a String. If it is None,
1070 fall through, we will not set a prompt. If it is a
1071 string, set PROMPT. Anything else, set an exception. */
1072 if (result
!= Py_None
&& ! PyString_Check (result
))
1074 PyErr_Format (PyExc_RuntimeError
,
1075 _("Return from prompt_hook must " \
1076 "be either a Python string, or None"));
1080 if (result
!= Py_None
)
1082 prompt
= python_string_to_host_string (result
);
1087 make_cleanup (xfree
, prompt
);
1092 /* If a prompt has been set, PROMPT will not be NULL. If it is
1093 NULL, do not set the prompt. */
1095 set_prompt (prompt
);
1097 do_cleanups (cleanup
);
1098 return prompt
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_NOP
;
1101 gdbpy_print_stack ();
1102 do_cleanups (cleanup
);
1103 return EXT_LANG_RC_ERROR
;
1110 /* A python function to write a single string using gdb's filtered
1111 output stream . The optional keyword STREAM can be used to write
1112 to a particular stream. The default stream is to gdb_stdout. */
1115 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1118 static char *keywords
[] = {"text", "stream", NULL
};
1119 int stream_type
= 0;
1121 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1127 switch (stream_type
)
1131 fprintf_filtered (gdb_stderr
, "%s", arg
);
1136 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1140 fprintf_filtered (gdb_stdout
, "%s", arg
);
1143 CATCH (except
, RETURN_MASK_ALL
)
1145 GDB_PY_HANDLE_EXCEPTION (except
);
1152 /* A python function to flush a gdb stream. The optional keyword
1153 STREAM can be used to flush a particular stream. The default stream
1157 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1159 static char *keywords
[] = {"stream", NULL
};
1160 int stream_type
= 0;
1162 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1166 switch (stream_type
)
1170 gdb_flush (gdb_stderr
);
1175 gdb_flush (gdb_stdlog
);
1179 gdb_flush (gdb_stdout
);
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
= 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
= 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", NULL
);
1711 oldloc
= setlocale (LC_ALL
, NULL
);
1712 setlocale (LC_ALL
, "");
1713 progsize
= strlen (progname
);
1714 if (progsize
== (size_t) -1)
1716 fprintf (stderr
, "Could not convert python path to string\n");
1719 progname_copy
= PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1722 fprintf (stderr
, "out of memory\n");
1725 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1726 if (count
== (size_t) -1)
1728 fprintf (stderr
, "Could not convert python path to string\n");
1731 setlocale (LC_ALL
, oldloc
);
1733 /* Note that Py_SetProgramName expects the string it is passed to
1734 remain alive for the duration of the program's execution, so
1735 it is not freed after this call. */
1736 Py_SetProgramName (progname_copy
);
1738 Py_SetProgramName (progname
);
1743 PyEval_InitThreads ();
1746 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1747 /* Add _gdb module to the list of known built-in modules. */
1748 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1750 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1752 if (gdb_module
== NULL
)
1755 /* The casts to (char*) are for python 2.4. */
1756 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1757 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1758 (char*) host_name
) < 0
1759 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1760 (char*) target_name
) < 0)
1763 /* Add stream constants. */
1764 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1765 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1766 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1769 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1770 if (gdbpy_gdb_error
== NULL
1771 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1774 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1775 gdbpy_gdb_error
, NULL
);
1776 if (gdbpy_gdb_memory_error
== NULL
1777 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1778 gdbpy_gdb_memory_error
) < 0)
1781 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1782 if (gdbpy_gdberror_exc
== NULL
1783 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1784 gdbpy_gdberror_exc
) < 0)
1787 gdbpy_initialize_gdb_readline ();
1789 if (gdbpy_initialize_auto_load () < 0
1790 || gdbpy_initialize_values () < 0
1791 || gdbpy_initialize_frames () < 0
1792 || gdbpy_initialize_commands () < 0
1793 || gdbpy_initialize_symbols () < 0
1794 || gdbpy_initialize_symtabs () < 0
1795 || gdbpy_initialize_blocks () < 0
1796 || gdbpy_initialize_functions () < 0
1797 || gdbpy_initialize_parameters () < 0
1798 || gdbpy_initialize_types () < 0
1799 || gdbpy_initialize_pspace () < 0
1800 || gdbpy_initialize_objfile () < 0
1801 || gdbpy_initialize_breakpoints () < 0
1802 || gdbpy_initialize_finishbreakpoints () < 0
1803 || gdbpy_initialize_lazy_string () < 0
1804 || gdbpy_initialize_linetable () < 0
1805 || gdbpy_initialize_thread () < 0
1806 || gdbpy_initialize_inferior () < 0
1807 || gdbpy_initialize_events () < 0
1808 || gdbpy_initialize_eventregistry () < 0
1809 || gdbpy_initialize_py_events () < 0
1810 || gdbpy_initialize_event () < 0
1811 || gdbpy_initialize_stop_event () < 0
1812 || gdbpy_initialize_signal_event () < 0
1813 || gdbpy_initialize_breakpoint_event () < 0
1814 || gdbpy_initialize_continue_event () < 0
1815 || gdbpy_initialize_inferior_call_pre_event () < 0
1816 || gdbpy_initialize_inferior_call_post_event () < 0
1817 || gdbpy_initialize_register_changed_event () < 0
1818 || gdbpy_initialize_memory_changed_event () < 0
1819 || gdbpy_initialize_exited_event () < 0
1820 || gdbpy_initialize_thread_event () < 0
1821 || gdbpy_initialize_new_objfile_event () < 0
1822 || gdbpy_initialize_clear_objfiles_event () < 0
1823 || gdbpy_initialize_arch () < 0
1824 || gdbpy_initialize_xmethods () < 0
1825 || gdbpy_initialize_unwind () < 0)
1828 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1829 if (gdbpy_to_string_cst
== NULL
)
1831 gdbpy_children_cst
= PyString_FromString ("children");
1832 if (gdbpy_children_cst
== NULL
)
1834 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1835 if (gdbpy_display_hint_cst
== NULL
)
1837 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1838 if (gdbpy_doc_cst
== NULL
)
1840 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1841 if (gdbpy_enabled_cst
== NULL
)
1843 gdbpy_value_cst
= PyString_FromString ("value");
1844 if (gdbpy_value_cst
== NULL
)
1847 /* Release the GIL while gdb runs. */
1848 PyThreadState_Swap (NULL
);
1849 PyEval_ReleaseLock ();
1851 make_final_cleanup (finalize_python
, NULL
);
1853 gdb_python_initialized
= 1;
1857 gdbpy_print_stack ();
1858 /* Do not set 'gdb_python_initialized'. */
1861 #endif /* HAVE_PYTHON */
1866 /* Perform the remaining python initializations.
1867 These must be done after GDB is at least mostly initialized.
1868 E.g., The "info pretty-printer" command needs the "info" prefix
1870 This is the extension_language_ops.finish_initialization "method". */
1873 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1876 char *gdb_pythondir
;
1878 struct cleanup
*cleanup
;
1880 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1882 /* Add the initial data-directory to sys.path. */
1884 gdb_pythondir
= concat (gdb_datadir
, SLASH_STRING
, "python", NULL
);
1885 make_cleanup (xfree
, gdb_pythondir
);
1887 sys_path
= PySys_GetObject ("path");
1889 /* If sys.path is not defined yet, define it first. */
1890 if (!(sys_path
&& PyList_Check (sys_path
)))
1893 PySys_SetPath (L
"");
1897 sys_path
= PySys_GetObject ("path");
1899 if (sys_path
&& PyList_Check (sys_path
))
1901 PyObject
*pythondir
;
1904 pythondir
= PyString_FromString (gdb_pythondir
);
1905 if (pythondir
== NULL
)
1908 err
= PyList_Insert (sys_path
, 0, pythondir
);
1909 Py_DECREF (pythondir
);
1916 /* Import the gdb module to finish the initialization, and
1917 add it to __main__ for convenience. */
1918 m
= PyImport_AddModule ("__main__");
1922 gdb_python_module
= PyImport_ImportModule ("gdb");
1923 if (gdb_python_module
== NULL
)
1925 gdbpy_print_stack ();
1926 /* This is passed in one call to warning so that blank lines aren't
1927 inserted between each line of text. */
1929 "Could not load the Python gdb module from `%s'.\n"
1930 "Limited Python support is available from the _gdb module.\n"
1931 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1933 do_cleanups (cleanup
);
1937 if (gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) < 0)
1940 /* Keep the reference to gdb_python_module since it is in a global
1943 do_cleanups (cleanup
);
1947 gdbpy_print_stack ();
1948 warning (_("internal error: Unhandled Python exception"));
1949 do_cleanups (cleanup
);
1952 /* Return non-zero if Python has successfully initialized.
1953 This is the extension_languages_ops.initialized "method". */
1956 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1958 return gdb_python_initialized
;
1961 #endif /* HAVE_PYTHON */
1967 PyMethodDef python_GdbMethods
[] =
1969 { "history", gdbpy_history
, METH_VARARGS
,
1970 "Get a value from history" },
1971 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1972 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1973 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1974 a Python String containing the output of the command if to_string is\n\
1976 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1977 "Return a gdb parameter's value" },
1979 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1980 "Return a tuple of all breakpoint objects" },
1982 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1983 "Find the default visualizer for a Value." },
1985 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1986 "Return the current Progspace." },
1987 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1988 "Return a sequence of all progspaces." },
1990 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1991 "Return the current Objfile being loaded, or None." },
1992 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1993 "Return a sequence of all loaded objfiles." },
1995 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1996 "newest_frame () -> gdb.Frame.\n\
1997 Return the newest frame object." },
1998 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1999 "selected_frame () -> gdb.Frame.\n\
2000 Return the selected frame object." },
2001 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2002 "stop_reason_string (Integer) -> String.\n\
2003 Return a string explaining unwind stop reason." },
2005 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2006 METH_VARARGS
| METH_KEYWORDS
,
2007 "lookup_type (name [, block]) -> type\n\
2008 Return a Type corresponding to the given name." },
2009 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2010 METH_VARARGS
| METH_KEYWORDS
,
2011 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2012 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2013 a boolean indicating if name is a field of the current implied argument\n\
2014 `this' (when the current language is object-oriented)." },
2015 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2016 METH_VARARGS
| METH_KEYWORDS
,
2017 "lookup_global_symbol (name [, domain]) -> symbol\n\
2018 Return the symbol corresponding to the given name (or None)." },
2020 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2021 METH_VARARGS
| METH_KEYWORDS
,
2022 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2023 Look up the specified objfile.\n\
2024 If by_build_id is True, the objfile is looked up by using name\n\
2025 as its build id." },
2027 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
2028 "Return the block containing the given pc value, or None." },
2029 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
2030 "solib_name (Long) -> String.\n\
2031 Return the name of the shared library holding a given address, or None." },
2032 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2033 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2034 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2035 The first element contains any unparsed portion of the String parameter\n\
2036 (or None if the string was fully parsed). The second element contains\n\
2037 a tuple that contains all the locations that match, represented as\n\
2038 gdb.Symtab_and_line objects (or None)."},
2039 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2040 "parse_and_eval (String) -> Value.\n\
2041 Parse String as an expression, evaluate it, and return the result as a Value."
2043 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2044 "find_pc_line (pc) -> Symtab_and_line.\n\
2045 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2047 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2048 "Post an event into gdb's event loop." },
2050 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2051 "target_charset () -> string.\n\
2052 Return the name of the current target charset." },
2053 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2054 "target_wide_charset () -> string.\n\
2055 Return the name of the current target wide charset." },
2057 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2058 "string_to_argv (String) -> Array.\n\
2059 Parse String and return an argv-like array.\n\
2060 Arguments are separate by spaces and may be quoted."
2062 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2063 "Write a string using gdb's filtered stream." },
2064 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2065 "Flush gdb's filtered stdout stream." },
2066 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2067 "selected_thread () -> gdb.InferiorThread.\n\
2068 Return the selected thread object." },
2069 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2070 "selected_inferior () -> gdb.Inferior.\n\
2071 Return the selected inferior object." },
2072 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2073 "inferiors () -> (gdb.Inferior, ...).\n\
2074 Return a tuple containing all inferiors." },
2075 {NULL
, NULL
, 0, NULL
}
2079 struct PyModuleDef python_GdbModuleDef
=
2081 PyModuleDef_HEAD_INIT
,
2092 #endif /* HAVE_PYTHON */