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 ui
*ui
= current_ui
;
324 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
326 arg
= skip_spaces (arg
);
328 ensure_python_env (get_current_arch (), current_language
);
332 int len
= strlen (arg
);
333 char *script
= (char *) xmalloc (len
+ 2);
335 strcpy (script
, arg
);
337 script
[len
+ 1] = '\0';
338 err
= eval_python_command (script
);
343 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
349 gdbpy_print_stack ();
350 error (_("Error while executing Python code."));
354 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
357 On Windows hosts few users would build Python themselves (this is no
358 trivial task on this platform), and thus use binaries built by
359 someone else instead. There may happen situation where the Python
360 library and GDB are using two different versions of the C runtime
361 library. Python, being built with VC, would use one version of the
362 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
363 A FILE * from one runtime does not necessarily operate correctly in
366 To work around this potential issue, we create on Windows hosts the
367 FILE object using Python routines, thus making sure that it is
368 compatible with the Python library. */
371 python_run_simple_file (FILE *file
, const char *filename
)
375 PyRun_SimpleFile (file
, filename
);
380 PyObject
*python_file
;
381 struct cleanup
*cleanup
;
383 /* Because we have a string for a filename, and are using Python to
384 open the file, we need to expand any tilde in the path first. */
385 full_path
= tilde_expand (filename
);
386 cleanup
= make_cleanup (xfree
, full_path
);
387 python_file
= PyFile_FromString (full_path
, "r");
390 do_cleanups (cleanup
);
391 gdbpy_print_stack ();
392 error (_("Error while opening file: %s"), full_path
);
395 make_cleanup_py_decref (python_file
);
396 PyRun_SimpleFile (PyFile_AsFile (python_file
), filename
);
397 do_cleanups (cleanup
);
402 /* Given a command_line, return a command string suitable for passing
403 to Python. Lines in the string are separated by newlines. The
404 return value is allocated using xmalloc and the caller is
405 responsible for freeing it. */
408 compute_python_string (struct command_line
*l
)
410 struct command_line
*iter
;
415 for (iter
= l
; iter
; iter
= iter
->next
)
416 size
+= strlen (iter
->line
) + 1;
418 script
= (char *) xmalloc (size
+ 1);
420 for (iter
= l
; iter
; iter
= iter
->next
)
422 int len
= strlen (iter
->line
);
424 strcpy (&script
[here
], iter
->line
);
426 script
[here
++] = '\n';
432 /* Take a command line structure representing a 'python' command, and
433 evaluate its body using the Python interpreter. */
436 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
437 struct command_line
*cmd
)
441 struct cleanup
*cleanup
;
443 if (cmd
->body_count
!= 1)
444 error (_("Invalid \"python\" block structure."));
446 cleanup
= ensure_python_env (get_current_arch (), current_language
);
448 script
= compute_python_string (cmd
->body_list
[0]);
449 ret
= PyRun_SimpleString (script
);
452 error (_("Error while executing Python code."));
454 do_cleanups (cleanup
);
457 /* Implementation of the gdb "python" command. */
460 python_command (char *arg
, int from_tty
)
462 struct cleanup
*cleanup
;
464 cleanup
= ensure_python_env (get_current_arch (), current_language
);
466 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
468 arg
= skip_spaces (arg
);
471 if (PyRun_SimpleString (arg
))
472 error (_("Error while executing Python code."));
476 struct command_line
*l
= get_command_line (python_control
, "");
478 make_cleanup_free_command_lines (&l
);
479 execute_control_command_untraced (l
);
482 do_cleanups (cleanup
);
487 /* Transform a gdb parameters's value into a Python value. May return
488 NULL (and set a Python exception) on error. Helper function for
491 gdbpy_parameter_value (enum var_types type
, void *var
)
496 case var_string_noescape
:
497 case var_optional_filename
:
501 char *str
= * (char **) var
;
505 return host_string_to_python_string (str
);
516 case var_auto_boolean
:
518 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
520 if (ab
== AUTO_BOOLEAN_TRUE
)
522 else if (ab
== AUTO_BOOLEAN_FALSE
)
529 if ((* (int *) var
) == INT_MAX
)
533 return PyLong_FromLong (* (int *) var
);
537 unsigned int val
= * (unsigned int *) var
;
541 return PyLong_FromUnsignedLong (val
);
545 return PyErr_Format (PyExc_RuntimeError
,
546 _("Programmer error: unhandled type."));
549 /* A Python function which returns a gdb parameter's value as a Python
553 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
555 struct gdb_exception except
= exception_none
;
556 struct cmd_list_element
*alias
, *prefix
, *cmd
;
561 if (! PyArg_ParseTuple (args
, "s", &arg
))
564 newarg
= concat ("show ", arg
, (char *) NULL
);
568 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
570 CATCH (ex
, RETURN_MASK_ALL
)
577 GDB_PY_HANDLE_EXCEPTION (except
);
579 return PyErr_Format (PyExc_RuntimeError
,
580 _("Could not find parameter `%s'."), arg
);
583 return PyErr_Format (PyExc_RuntimeError
,
584 _("`%s' is not a parameter."), arg
);
585 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
588 /* Wrapper for target_charset. */
591 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
593 const char *cset
= target_charset (python_gdbarch
);
595 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
598 /* Wrapper for target_wide_charset. */
601 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
603 const char *cset
= target_wide_charset (python_gdbarch
);
605 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
608 /* A Python function which evaluates a string using the gdb CLI. */
611 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
614 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
615 int from_tty
, to_string
;
616 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
619 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
620 &PyBool_Type
, &from_tty_obj
,
621 &PyBool_Type
, &to_string_obj
))
627 int cmp
= PyObject_IsTrue (from_tty_obj
);
636 int cmp
= PyObject_IsTrue (to_string_obj
);
644 /* Copy the argument text in case the command modifies it. */
645 char *copy
= xstrdup (arg
);
646 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
647 struct interp
*interp
;
649 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
651 make_cleanup_restore_current_uiout ();
653 /* Use the console interpreter uiout to have the same print format
654 for console or MI. */
655 interp
= interp_lookup (current_ui
, "console");
656 current_uiout
= interp_ui_out (interp
);
658 prevent_dont_repeat ();
660 result
= execute_command_to_string (copy
, from_tty
);
664 execute_command (copy
, from_tty
);
667 do_cleanups (cleanup
);
669 CATCH (except
, RETURN_MASK_ALL
)
671 GDB_PY_HANDLE_EXCEPTION (except
);
675 /* Do any commands attached to breakpoint we stopped at. */
676 bpstat_do_actions ();
680 PyObject
*r
= PyString_FromString (result
);
687 /* Implementation of gdb.solib_name (Long) -> String.
688 Returns the name of the shared library holding a given address, or None. */
691 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
697 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
700 soname
= solib_name_from_address (current_program_space
, pc
);
702 str_obj
= host_string_to_python_string (soname
);
712 /* A Python function which is a wrapper for decode_line_1. */
715 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
717 struct gdb_exception except
= exception_none
;
718 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
720 struct symtab_and_line sal
;
722 struct cleanup
*cleanups
;
723 PyObject
*result
= NULL
;
724 PyObject
*return_result
= NULL
;
725 PyObject
*unparsed
= NULL
;
726 struct event_location
*location
= NULL
;
728 if (! PyArg_ParseTuple (args
, "|s", &arg
))
731 cleanups
= make_cleanup (null_cleanup
, NULL
);
737 location
= string_to_event_location_basic (&arg
, python_language
);
738 make_cleanup_delete_event_location (location
);
743 if (location
!= NULL
)
744 sals
= decode_line_1 (location
, 0, NULL
, NULL
, 0);
747 set_default_source_symtab_and_line ();
748 sal
= get_current_source_symtab_and_line ();
753 CATCH (ex
, RETURN_MASK_ALL
)
759 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
760 make_cleanup (xfree
, sals
.sals
);
762 if (except
.reason
< 0)
764 do_cleanups (cleanups
);
765 /* We know this will always throw. */
766 gdbpy_convert_exception (except
);
774 result
= PyTuple_New (sals
.nelts
);
777 for (i
= 0; i
< sals
.nelts
; ++i
)
781 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
788 PyTuple_SetItem (result
, i
, obj
);
797 return_result
= PyTuple_New (2);
804 if (arg
!= NULL
&& strlen (arg
) > 0)
806 unparsed
= PyString_FromString (arg
);
807 if (unparsed
== NULL
)
810 Py_DECREF (return_result
);
811 return_result
= NULL
;
821 PyTuple_SetItem (return_result
, 0, unparsed
);
822 PyTuple_SetItem (return_result
, 1, result
);
825 do_cleanups (cleanups
);
827 return return_result
;
830 /* Parse a string and evaluate it as an expression. */
832 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
834 const char *expr_str
;
835 struct value
*result
= NULL
;
837 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
842 result
= parse_and_eval (expr_str
);
844 CATCH (except
, RETURN_MASK_ALL
)
846 GDB_PY_HANDLE_EXCEPTION (except
);
850 return value_to_value_object (result
);
853 /* Implementation of gdb.find_pc_line function.
854 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
857 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
859 gdb_py_ulongest pc_llu
;
860 PyObject
*result
= NULL
; /* init for gcc -Wall */
862 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
867 struct symtab_and_line sal
;
870 pc
= (CORE_ADDR
) pc_llu
;
871 sal
= find_pc_line (pc
, 0);
872 result
= symtab_and_line_to_sal_object (sal
);
874 CATCH (except
, RETURN_MASK_ALL
)
876 GDB_PY_HANDLE_EXCEPTION (except
);
883 /* Implementation of gdb.invalidate_cached_frames. */
886 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
888 reinit_frame_cache ();
892 /* Read a file as Python code.
893 This is the extension_language_script_ops.script_sourcer "method".
894 FILE is the file to load. FILENAME is name of the file FILE.
895 This does not throw any errors. If an exception occurs python will print
896 the traceback and clear the error indicator. */
899 gdbpy_source_script (const struct extension_language_defn
*extlang
,
900 FILE *file
, const char *filename
)
902 struct cleanup
*cleanup
;
904 cleanup
= ensure_python_env (get_current_arch (), current_language
);
905 python_run_simple_file (file
, filename
);
906 do_cleanups (cleanup
);
911 /* Posting and handling events. */
913 /* A single event. */
916 /* The Python event. This is just a callable object. */
918 /* The next event. */
919 struct gdbpy_event
*next
;
922 /* All pending events. */
923 static struct gdbpy_event
*gdbpy_event_list
;
924 /* The final link of the event list. */
925 static struct gdbpy_event
**gdbpy_event_list_end
;
927 /* So that we can wake up the main thread even when it is blocked in
929 static struct serial_event
*gdbpy_serial_event
;
931 /* The file handler callback. This reads from the internal pipe, and
932 then processes the Python event queue. This will always be run in
933 the main gdb thread. */
936 gdbpy_run_events (int error
, gdb_client_data client_data
)
938 struct cleanup
*cleanup
;
940 cleanup
= ensure_python_env (get_current_arch (), current_language
);
942 /* Clear the event fd. Do this before flushing the events list, so
943 that any new event post afterwards is sure to re-awake the event
945 serial_event_clear (gdbpy_serial_event
);
947 while (gdbpy_event_list
)
949 PyObject
*call_result
;
951 /* Dispatching the event might push a new element onto the event
952 loop, so we update here "atomically enough". */
953 struct gdbpy_event
*item
= gdbpy_event_list
;
954 gdbpy_event_list
= gdbpy_event_list
->next
;
955 if (gdbpy_event_list
== NULL
)
956 gdbpy_event_list_end
= &gdbpy_event_list
;
959 call_result
= PyObject_CallObject (item
->event
, NULL
);
960 if (call_result
== NULL
)
963 Py_XDECREF (call_result
);
964 Py_DECREF (item
->event
);
968 do_cleanups (cleanup
);
971 /* Submit an event to the gdb thread. */
973 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
975 struct gdbpy_event
*event
;
979 if (!PyArg_ParseTuple (args
, "O", &func
))
982 if (!PyCallable_Check (func
))
984 PyErr_SetString (PyExc_RuntimeError
,
985 _("Posted event is not callable"));
991 /* From here until the end of the function, we have the GIL, so we
992 can operate on our global data structures without worrying. */
993 wakeup
= gdbpy_event_list
== NULL
;
995 event
= XNEW (struct gdbpy_event
);
998 *gdbpy_event_list_end
= event
;
999 gdbpy_event_list_end
= &event
->next
;
1001 /* Wake up gdb when needed. */
1003 serial_event_set (gdbpy_serial_event
);
1008 /* Initialize the Python event handler. */
1010 gdbpy_initialize_events (void)
1012 gdbpy_event_list_end
= &gdbpy_event_list
;
1014 gdbpy_serial_event
= make_serial_event ();
1015 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1016 gdbpy_run_events
, NULL
);
1023 /* This is the extension_language_ops.before_prompt "method". */
1025 static enum ext_lang_rc
1026 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1027 const char *current_gdb_prompt
)
1029 struct cleanup
*cleanup
;
1030 char *prompt
= NULL
;
1032 if (!gdb_python_initialized
)
1033 return EXT_LANG_RC_NOP
;
1035 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1037 if (gdb_python_module
1038 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1042 hook
= PyObject_GetAttrString (gdb_python_module
, "prompt_hook");
1046 make_cleanup_py_decref (hook
);
1048 if (PyCallable_Check (hook
))
1051 PyObject
*current_prompt
;
1053 current_prompt
= PyString_FromString (current_gdb_prompt
);
1054 if (current_prompt
== NULL
)
1057 result
= PyObject_CallFunctionObjArgs (hook
, current_prompt
, NULL
);
1059 Py_DECREF (current_prompt
);
1064 make_cleanup_py_decref (result
);
1066 /* Return type should be None, or a String. If it is None,
1067 fall through, we will not set a prompt. If it is a
1068 string, set PROMPT. Anything else, set an exception. */
1069 if (result
!= Py_None
&& ! PyString_Check (result
))
1071 PyErr_Format (PyExc_RuntimeError
,
1072 _("Return from prompt_hook must " \
1073 "be either a Python string, or None"));
1077 if (result
!= Py_None
)
1079 prompt
= python_string_to_host_string (result
);
1084 make_cleanup (xfree
, prompt
);
1089 /* If a prompt has been set, PROMPT will not be NULL. If it is
1090 NULL, do not set the prompt. */
1092 set_prompt (prompt
);
1094 do_cleanups (cleanup
);
1095 return prompt
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_NOP
;
1098 gdbpy_print_stack ();
1099 do_cleanups (cleanup
);
1100 return EXT_LANG_RC_ERROR
;
1107 /* A python function to write a single string using gdb's filtered
1108 output stream . The optional keyword STREAM can be used to write
1109 to a particular stream. The default stream is to gdb_stdout. */
1112 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1115 static char *keywords
[] = {"text", "stream", NULL
};
1116 int stream_type
= 0;
1118 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1124 switch (stream_type
)
1128 fprintf_filtered (gdb_stderr
, "%s", arg
);
1133 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1137 fprintf_filtered (gdb_stdout
, "%s", arg
);
1140 CATCH (except
, RETURN_MASK_ALL
)
1142 GDB_PY_HANDLE_EXCEPTION (except
);
1149 /* A python function to flush a gdb stream. The optional keyword
1150 STREAM can be used to flush a particular stream. The default stream
1154 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1156 static char *keywords
[] = {"stream", NULL
};
1157 int stream_type
= 0;
1159 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1163 switch (stream_type
)
1167 gdb_flush (gdb_stderr
);
1172 gdb_flush (gdb_stdlog
);
1176 gdb_flush (gdb_stdout
);
1182 /* Return non-zero if print-stack is not "none". */
1185 gdbpy_print_python_errors_p (void)
1187 return gdbpy_should_print_stack
!= python_excp_none
;
1190 /* Print a python exception trace, print just a message, or print
1191 nothing and clear the python exception, depending on
1192 gdbpy_should_print_stack. Only call this if a python exception is
1195 gdbpy_print_stack (void)
1198 /* Print "none", just clear exception. */
1199 if (gdbpy_should_print_stack
== python_excp_none
)
1203 /* Print "full" message and backtrace. */
1204 else if (gdbpy_should_print_stack
== python_excp_full
)
1207 /* PyErr_Print doesn't necessarily end output with a newline.
1208 This works because Python's stdout/stderr is fed through
1214 CATCH (except
, RETURN_MASK_ALL
)
1219 /* Print "message", just error print message. */
1222 PyObject
*ptype
, *pvalue
, *ptraceback
;
1223 char *msg
= NULL
, *type
= NULL
;
1225 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1227 /* Fetch the error message contained within ptype, pvalue. */
1228 msg
= gdbpy_exception_to_string (ptype
, pvalue
);
1229 type
= gdbpy_obj_to_string (ptype
);
1235 /* An error occurred computing the string representation of the
1237 fprintf_filtered (gdb_stderr
,
1238 _("Error occurred computing Python error" \
1242 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1245 CATCH (except
, RETURN_MASK_ALL
)
1251 Py_XDECREF (pvalue
);
1252 Py_XDECREF (ptraceback
);
1259 /* Return the current Progspace.
1260 There always is one. */
1263 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1267 result
= pspace_to_pspace_object (current_program_space
);
1273 /* Return a sequence holding all the Progspaces. */
1276 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1278 struct program_space
*ps
;
1281 list
= PyList_New (0);
1287 PyObject
*item
= pspace_to_pspace_object (ps
);
1289 if (!item
|| PyList_Append (list
, item
) == -1)
1301 /* The "current" objfile. This is set when gdb detects that a new
1302 objfile has been loaded. It is only set for the duration of a call to
1303 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1305 static struct objfile
*gdbpy_current_objfile
;
1307 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1308 as Python code. This does not throw any errors. If an exception
1309 occurs python will print the traceback and clear the error indicator.
1310 This is the extension_language_script_ops.objfile_script_sourcer
1314 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1315 struct objfile
*objfile
, FILE *file
,
1316 const char *filename
)
1318 struct cleanup
*cleanups
;
1320 if (!gdb_python_initialized
)
1323 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1324 gdbpy_current_objfile
= objfile
;
1326 python_run_simple_file (file
, filename
);
1328 do_cleanups (cleanups
);
1329 gdbpy_current_objfile
= NULL
;
1332 /* Set the current objfile to OBJFILE and then execute SCRIPT
1333 as Python code. This does not throw any errors. If an exception
1334 occurs python will print the traceback and clear the error indicator.
1335 This is the extension_language_script_ops.objfile_script_executor
1339 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1340 struct objfile
*objfile
, const char *name
,
1343 struct cleanup
*cleanups
;
1345 if (!gdb_python_initialized
)
1348 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1349 gdbpy_current_objfile
= objfile
;
1351 PyRun_SimpleString (script
);
1353 do_cleanups (cleanups
);
1354 gdbpy_current_objfile
= NULL
;
1357 /* Return the current Objfile, or None if there isn't one. */
1360 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1364 if (! gdbpy_current_objfile
)
1367 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1373 /* Return a sequence holding all the Objfiles. */
1376 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1378 struct objfile
*objf
;
1381 list
= PyList_New (0);
1387 PyObject
*item
= objfile_to_objfile_object (objf
);
1389 if (!item
|| PyList_Append (list
, item
) == -1)
1399 /* Compute the list of active python type printers and store them in
1400 EXT_PRINTERS->py_type_printers. The product of this function is used by
1401 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1402 This is the extension_language_ops.start_type_printers "method". */
1405 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1406 struct ext_lang_type_printers
*ext_printers
)
1408 struct cleanup
*cleanups
;
1409 PyObject
*type_module
, *func
= NULL
, *printers_obj
= NULL
;
1411 if (!gdb_python_initialized
)
1414 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1416 type_module
= PyImport_ImportModule ("gdb.types");
1417 if (type_module
== NULL
)
1419 gdbpy_print_stack ();
1423 func
= PyObject_GetAttrString (type_module
, "get_type_recognizers");
1426 gdbpy_print_stack ();
1430 printers_obj
= PyObject_CallFunctionObjArgs (func
, (char *) NULL
);
1431 if (printers_obj
== NULL
)
1432 gdbpy_print_stack ();
1434 ext_printers
->py_type_printers
= printers_obj
;
1437 Py_XDECREF (type_module
);
1439 do_cleanups (cleanups
);
1442 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1443 a newly allocated string holding the type's replacement name, and return
1444 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1445 If there's a Python error return EXT_LANG_RC_ERROR.
1446 Otherwise, return EXT_LANG_RC_NOP.
1447 This is the extension_language_ops.apply_type_printers "method". */
1449 static enum ext_lang_rc
1450 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1451 const struct ext_lang_type_printers
*ext_printers
,
1452 struct type
*type
, char **prettied_type
)
1454 struct cleanup
*cleanups
;
1455 PyObject
*type_obj
, *type_module
= NULL
, *func
= NULL
;
1456 PyObject
*result_obj
= NULL
;
1457 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1458 char *result
= NULL
;
1460 if (printers_obj
== NULL
)
1461 return EXT_LANG_RC_NOP
;
1463 if (!gdb_python_initialized
)
1464 return EXT_LANG_RC_NOP
;
1466 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1468 type_obj
= type_to_type_object (type
);
1469 if (type_obj
== NULL
)
1471 gdbpy_print_stack ();
1475 type_module
= PyImport_ImportModule ("gdb.types");
1476 if (type_module
== NULL
)
1478 gdbpy_print_stack ();
1482 func
= PyObject_GetAttrString (type_module
, "apply_type_recognizers");
1485 gdbpy_print_stack ();
1489 result_obj
= PyObject_CallFunctionObjArgs (func
, printers_obj
,
1490 type_obj
, (char *) NULL
);
1491 if (result_obj
== NULL
)
1493 gdbpy_print_stack ();
1497 if (result_obj
!= Py_None
)
1499 result
= python_string_to_host_string (result_obj
);
1501 gdbpy_print_stack ();
1505 Py_XDECREF (type_obj
);
1506 Py_XDECREF (type_module
);
1508 Py_XDECREF (result_obj
);
1509 do_cleanups (cleanups
);
1511 *prettied_type
= result
;
1512 return result
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_ERROR
;
1515 /* Free the result of start_type_printers.
1516 This is the extension_language_ops.free_type_printers "method". */
1519 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1520 struct ext_lang_type_printers
*ext_printers
)
1522 struct cleanup
*cleanups
;
1523 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1525 if (printers
== NULL
)
1528 if (!gdb_python_initialized
)
1531 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1532 Py_DECREF (printers
);
1533 do_cleanups (cleanups
);
1536 #else /* HAVE_PYTHON */
1538 /* Dummy implementation of the gdb "python-interactive" and "python"
1542 python_interactive_command (char *arg
, int from_tty
)
1544 arg
= skip_spaces (arg
);
1546 error (_("Python scripting is not supported in this copy of GDB."));
1549 struct command_line
*l
= get_command_line (python_control
, "");
1550 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1552 execute_control_command_untraced (l
);
1553 do_cleanups (cleanups
);
1558 python_command (char *arg
, int from_tty
)
1560 python_interactive_command (arg
, from_tty
);
1563 #endif /* HAVE_PYTHON */
1567 /* Lists for 'set python' commands. */
1569 static struct cmd_list_element
*user_set_python_list
;
1570 static struct cmd_list_element
*user_show_python_list
;
1572 /* Function for use by 'set python' prefix command. */
1575 user_set_python (char *args
, int from_tty
)
1577 help_list (user_set_python_list
, "set python ", all_commands
,
1581 /* Function for use by 'show python' prefix command. */
1584 user_show_python (char *args
, int from_tty
)
1586 cmd_show_list (user_show_python_list
, from_tty
, "");
1589 /* Initialize the Python code. */
1593 /* This is installed as a final cleanup and cleans up the
1594 interpreter. This lets Python's 'atexit' work. */
1597 finalize_python (void *ignore
)
1599 struct active_ext_lang_state
*previous_active
;
1601 /* We don't use ensure_python_env here because if we ever ran the
1602 cleanup, gdb would crash -- because the cleanup calls into the
1603 Python interpreter, which we are about to destroy. It seems
1604 clearer to make the needed calls explicitly here than to create a
1605 cleanup and then mysteriously discard it. */
1607 /* This is only called as a final cleanup so we can assume the active
1608 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1609 previous_active
= set_active_ext_lang (&extension_language_python
);
1611 (void) PyGILState_Ensure ();
1612 python_gdbarch
= target_gdbarch ();
1613 python_language
= current_language
;
1617 restore_active_ext_lang (previous_active
);
1621 /* Provide a prototype to silence -Wmissing-prototypes. */
1622 extern initialize_file_ftype _initialize_python
;
1625 _initialize_python (void)
1630 size_t progsize
, count
;
1632 wchar_t *progname_copy
;
1635 add_com ("python-interactive", class_obscure
,
1636 python_interactive_command
,
1639 Start an interactive Python prompt.\n\
1641 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1644 Alternatively, a single-line Python command can be given as an\n\
1645 argument, and if the command is an expression, the result will be\n\
1646 printed. For example:\n\
1648 (gdb) python-interactive 2 + 3\n\
1651 #else /* HAVE_PYTHON */
1653 Start a Python interactive prompt.\n\
1655 Python scripting is not supported in this copy of GDB.\n\
1656 This command is only a placeholder.")
1657 #endif /* HAVE_PYTHON */
1659 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1661 add_com ("python", class_obscure
, python_command
,
1664 Evaluate a Python command.\n\
1666 The command can be given as an argument, for instance:\n\
1670 If no argument is given, the following lines are read and used\n\
1671 as the Python commands. Type a line containing \"end\" to indicate\n\
1672 the end of the command.")
1673 #else /* HAVE_PYTHON */
1675 Evaluate a Python command.\n\
1677 Python scripting is not supported in this copy of GDB.\n\
1678 This command is only a placeholder.")
1679 #endif /* HAVE_PYTHON */
1681 add_com_alias ("py", "python", class_obscure
, 1);
1683 /* Add set/show python print-stack. */
1684 add_prefix_cmd ("python", no_class
, user_show_python
,
1685 _("Prefix command for python preference settings."),
1686 &user_show_python_list
, "show python ", 0,
1689 add_prefix_cmd ("python", no_class
, user_set_python
,
1690 _("Prefix command for python preference settings."),
1691 &user_set_python_list
, "set python ", 0,
1694 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1695 &gdbpy_should_print_stack
, _("\
1696 Set mode for Python stack dump on error."), _("\
1697 Show the mode of Python stack printing on error."), _("\
1698 none == no stack or message will be printed.\n\
1699 full == a message and a stack will be printed.\n\
1700 message == an error message without a stack will be printed."),
1702 &user_set_python_list
,
1703 &user_show_python_list
);
1706 #ifdef WITH_PYTHON_PATH
1707 /* Work around problem where python gets confused about where it is,
1708 and then can't find its libraries, etc.
1709 NOTE: Python assumes the following layout:
1711 /foo/lib/pythonX.Y/...
1712 This must be done before calling Py_Initialize. */
1713 progname
= concat (ldirname (python_libdir
), SLASH_STRING
, "bin",
1714 SLASH_STRING
, "python", (char *) NULL
);
1716 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1717 setlocale (LC_ALL
, "");
1718 progsize
= strlen (progname
);
1719 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1723 fprintf (stderr
, "out of memory\n");
1726 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1727 if (count
== (size_t) -1)
1730 fprintf (stderr
, "Could not convert python path to string\n");
1733 setlocale (LC_ALL
, oldloc
);
1736 /* Note that Py_SetProgramName expects the string it is passed to
1737 remain alive for the duration of the program's execution, so
1738 it is not freed after this call. */
1739 Py_SetProgramName (progname_copy
);
1741 Py_SetProgramName (progname
);
1746 PyEval_InitThreads ();
1749 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1750 /* Add _gdb module to the list of known built-in modules. */
1751 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1753 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1755 if (gdb_module
== NULL
)
1758 /* The casts to (char*) are for python 2.4. */
1759 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1760 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1761 (char*) host_name
) < 0
1762 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1763 (char*) target_name
) < 0)
1766 /* Add stream constants. */
1767 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1768 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1769 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1772 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1773 if (gdbpy_gdb_error
== NULL
1774 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1777 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1778 gdbpy_gdb_error
, NULL
);
1779 if (gdbpy_gdb_memory_error
== NULL
1780 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1781 gdbpy_gdb_memory_error
) < 0)
1784 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1785 if (gdbpy_gdberror_exc
== NULL
1786 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1787 gdbpy_gdberror_exc
) < 0)
1790 gdbpy_initialize_gdb_readline ();
1792 if (gdbpy_initialize_auto_load () < 0
1793 || gdbpy_initialize_values () < 0
1794 || gdbpy_initialize_frames () < 0
1795 || gdbpy_initialize_commands () < 0
1796 || gdbpy_initialize_symbols () < 0
1797 || gdbpy_initialize_symtabs () < 0
1798 || gdbpy_initialize_blocks () < 0
1799 || gdbpy_initialize_functions () < 0
1800 || gdbpy_initialize_parameters () < 0
1801 || gdbpy_initialize_types () < 0
1802 || gdbpy_initialize_pspace () < 0
1803 || gdbpy_initialize_objfile () < 0
1804 || gdbpy_initialize_breakpoints () < 0
1805 || gdbpy_initialize_finishbreakpoints () < 0
1806 || gdbpy_initialize_lazy_string () < 0
1807 || gdbpy_initialize_linetable () < 0
1808 || gdbpy_initialize_thread () < 0
1809 || gdbpy_initialize_inferior () < 0
1810 || gdbpy_initialize_events () < 0
1811 || gdbpy_initialize_eventregistry () < 0
1812 || gdbpy_initialize_py_events () < 0
1813 || gdbpy_initialize_event () < 0
1814 || gdbpy_initialize_stop_event () < 0
1815 || gdbpy_initialize_signal_event () < 0
1816 || gdbpy_initialize_breakpoint_event () < 0
1817 || gdbpy_initialize_continue_event () < 0
1818 || gdbpy_initialize_inferior_call_pre_event () < 0
1819 || gdbpy_initialize_inferior_call_post_event () < 0
1820 || gdbpy_initialize_register_changed_event () < 0
1821 || gdbpy_initialize_memory_changed_event () < 0
1822 || gdbpy_initialize_exited_event () < 0
1823 || gdbpy_initialize_thread_event () < 0
1824 || gdbpy_initialize_new_objfile_event () < 0
1825 || gdbpy_initialize_clear_objfiles_event () < 0
1826 || gdbpy_initialize_arch () < 0
1827 || gdbpy_initialize_xmethods () < 0
1828 || gdbpy_initialize_unwind () < 0)
1831 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1832 if (gdbpy_to_string_cst
== NULL
)
1834 gdbpy_children_cst
= PyString_FromString ("children");
1835 if (gdbpy_children_cst
== NULL
)
1837 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1838 if (gdbpy_display_hint_cst
== NULL
)
1840 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1841 if (gdbpy_doc_cst
== NULL
)
1843 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1844 if (gdbpy_enabled_cst
== NULL
)
1846 gdbpy_value_cst
= PyString_FromString ("value");
1847 if (gdbpy_value_cst
== NULL
)
1850 /* Release the GIL while gdb runs. */
1851 PyThreadState_Swap (NULL
);
1852 PyEval_ReleaseLock ();
1854 make_final_cleanup (finalize_python
, NULL
);
1856 gdb_python_initialized
= 1;
1860 gdbpy_print_stack ();
1861 /* Do not set 'gdb_python_initialized'. */
1864 #endif /* HAVE_PYTHON */
1869 /* Perform the remaining python initializations.
1870 These must be done after GDB is at least mostly initialized.
1871 E.g., The "info pretty-printer" command needs the "info" prefix
1873 This is the extension_language_ops.finish_initialization "method". */
1876 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1879 char *gdb_pythondir
;
1881 struct cleanup
*cleanup
;
1883 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1885 /* Add the initial data-directory to sys.path. */
1887 gdb_pythondir
= concat (gdb_datadir
, SLASH_STRING
, "python", (char *) NULL
);
1888 make_cleanup (xfree
, gdb_pythondir
);
1890 sys_path
= PySys_GetObject ("path");
1892 /* If sys.path is not defined yet, define it first. */
1893 if (!(sys_path
&& PyList_Check (sys_path
)))
1896 PySys_SetPath (L
"");
1900 sys_path
= PySys_GetObject ("path");
1902 if (sys_path
&& PyList_Check (sys_path
))
1904 PyObject
*pythondir
;
1907 pythondir
= PyString_FromString (gdb_pythondir
);
1908 if (pythondir
== NULL
)
1911 err
= PyList_Insert (sys_path
, 0, pythondir
);
1912 Py_DECREF (pythondir
);
1919 /* Import the gdb module to finish the initialization, and
1920 add it to __main__ for convenience. */
1921 m
= PyImport_AddModule ("__main__");
1925 gdb_python_module
= PyImport_ImportModule ("gdb");
1926 if (gdb_python_module
== NULL
)
1928 gdbpy_print_stack ();
1929 /* This is passed in one call to warning so that blank lines aren't
1930 inserted between each line of text. */
1932 "Could not load the Python gdb module from `%s'.\n"
1933 "Limited Python support is available from the _gdb module.\n"
1934 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1936 do_cleanups (cleanup
);
1940 if (gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) < 0)
1943 /* Keep the reference to gdb_python_module since it is in a global
1946 do_cleanups (cleanup
);
1950 gdbpy_print_stack ();
1951 warning (_("internal error: Unhandled Python exception"));
1952 do_cleanups (cleanup
);
1955 /* Return non-zero if Python has successfully initialized.
1956 This is the extension_languages_ops.initialized "method". */
1959 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1961 return gdb_python_initialized
;
1964 #endif /* HAVE_PYTHON */
1970 PyMethodDef python_GdbMethods
[] =
1972 { "history", gdbpy_history
, METH_VARARGS
,
1973 "Get a value from history" },
1974 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1975 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1976 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1977 a Python String containing the output of the command if to_string is\n\
1979 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1980 "Return a gdb parameter's value" },
1982 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1983 "Return a tuple of all breakpoint objects" },
1985 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1986 "Find the default visualizer for a Value." },
1988 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1989 "Return the current Progspace." },
1990 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1991 "Return a sequence of all progspaces." },
1993 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1994 "Return the current Objfile being loaded, or None." },
1995 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1996 "Return a sequence of all loaded objfiles." },
1998 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1999 "newest_frame () -> gdb.Frame.\n\
2000 Return the newest frame object." },
2001 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2002 "selected_frame () -> gdb.Frame.\n\
2003 Return the selected frame object." },
2004 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2005 "stop_reason_string (Integer) -> String.\n\
2006 Return a string explaining unwind stop reason." },
2008 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2009 METH_VARARGS
| METH_KEYWORDS
,
2010 "lookup_type (name [, block]) -> type\n\
2011 Return a Type corresponding to the given name." },
2012 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2013 METH_VARARGS
| METH_KEYWORDS
,
2014 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2015 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2016 a boolean indicating if name is a field of the current implied argument\n\
2017 `this' (when the current language is object-oriented)." },
2018 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2019 METH_VARARGS
| METH_KEYWORDS
,
2020 "lookup_global_symbol (name [, domain]) -> symbol\n\
2021 Return the symbol corresponding to the given name (or None)." },
2023 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2024 METH_VARARGS
| METH_KEYWORDS
,
2025 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2026 Look up the specified objfile.\n\
2027 If by_build_id is True, the objfile is looked up by using name\n\
2028 as its build id." },
2030 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
2031 "Return the block containing the given pc value, or None." },
2032 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
2033 "solib_name (Long) -> String.\n\
2034 Return the name of the shared library holding a given address, or None." },
2035 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2036 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2037 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2038 The first element contains any unparsed portion of the String parameter\n\
2039 (or None if the string was fully parsed). The second element contains\n\
2040 a tuple that contains all the locations that match, represented as\n\
2041 gdb.Symtab_and_line objects (or None)."},
2042 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2043 "parse_and_eval (String) -> Value.\n\
2044 Parse String as an expression, evaluate it, and return the result as a Value."
2046 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2047 "find_pc_line (pc) -> Symtab_and_line.\n\
2048 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2050 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2051 "Post an event into gdb's event loop." },
2053 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2054 "target_charset () -> string.\n\
2055 Return the name of the current target charset." },
2056 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2057 "target_wide_charset () -> string.\n\
2058 Return the name of the current target wide charset." },
2060 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2061 "string_to_argv (String) -> Array.\n\
2062 Parse String and return an argv-like array.\n\
2063 Arguments are separate by spaces and may be quoted."
2065 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2066 "Write a string using gdb's filtered stream." },
2067 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2068 "Flush gdb's filtered stdout stream." },
2069 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2070 "selected_thread () -> gdb.InferiorThread.\n\
2071 Return the selected thread object." },
2072 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2073 "selected_inferior () -> gdb.Inferior.\n\
2074 Return the selected inferior object." },
2075 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2076 "inferiors () -> (gdb.Inferior, ...).\n\
2077 Return a tuple containing all inferiors." },
2079 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2080 "invalidate_cached_frames () -> None.\n\
2081 Invalidate any cached frame objects in gdb.\n\
2082 Intended for internal use only." },
2084 {NULL
, NULL
, 0, NULL
}
2088 struct PyModuleDef python_GdbModuleDef
=
2090 PyModuleDef_HEAD_INIT
,
2101 #endif /* HAVE_PYTHON */