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 static PyMethodDef GdbMethods
[];
109 static struct PyModuleDef 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 cmd_list_element
*alias
, *prefix
, *cmd
;
571 volatile struct gdb_exception except
;
573 if (! PyArg_ParseTuple (args
, "s", &arg
))
576 newarg
= concat ("show ", arg
, (char *) NULL
);
578 TRY_CATCH (except
, RETURN_MASK_ALL
)
580 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
583 GDB_PY_HANDLE_EXCEPTION (except
);
585 return PyErr_Format (PyExc_RuntimeError
,
586 _("Could not find parameter `%s'."), arg
);
589 return PyErr_Format (PyExc_RuntimeError
,
590 _("`%s' is not a parameter."), arg
);
591 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
594 /* Wrapper for target_charset. */
597 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
599 const char *cset
= target_charset (python_gdbarch
);
601 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
604 /* Wrapper for target_wide_charset. */
607 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
609 const char *cset
= target_wide_charset (python_gdbarch
);
611 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
614 /* A Python function which evaluates a string using the gdb CLI. */
617 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
620 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
621 int from_tty
, to_string
;
622 volatile struct gdb_exception except
;
623 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
626 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
627 &PyBool_Type
, &from_tty_obj
,
628 &PyBool_Type
, &to_string_obj
))
634 int cmp
= PyObject_IsTrue (from_tty_obj
);
643 int cmp
= PyObject_IsTrue (to_string_obj
);
649 TRY_CATCH (except
, RETURN_MASK_ALL
)
651 /* Copy the argument text in case the command modifies it. */
652 char *copy
= xstrdup (arg
);
653 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
655 make_cleanup_restore_integer (&interpreter_async
);
656 interpreter_async
= 0;
658 prevent_dont_repeat ();
660 result
= execute_command_to_string (copy
, from_tty
);
664 execute_command (copy
, from_tty
);
667 do_cleanups (cleanup
);
669 GDB_PY_HANDLE_EXCEPTION (except
);
671 /* Do any commands attached to breakpoint we stopped at. */
672 bpstat_do_actions ();
676 PyObject
*r
= PyString_FromString (result
);
683 /* Implementation of gdb.solib_name (Long) -> String.
684 Returns the name of the shared library holding a given address, or None. */
687 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
693 if (!PyArg_ParseTuple (args
, GDB_PY_LL_ARG
, &pc
))
696 soname
= solib_name_from_address (current_program_space
, pc
);
698 str_obj
= PyString_Decode (soname
, strlen (soname
), host_charset (), NULL
);
708 /* A Python function which is a wrapper for decode_line_1. */
711 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
713 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
715 struct symtab_and_line sal
;
716 const char *arg
= NULL
;
717 char *copy_to_free
= NULL
, *copy
= NULL
;
718 struct cleanup
*cleanups
;
719 PyObject
*result
= NULL
;
720 PyObject
*return_result
= NULL
;
721 PyObject
*unparsed
= NULL
;
722 volatile struct gdb_exception except
;
724 if (! PyArg_ParseTuple (args
, "|s", &arg
))
727 cleanups
= make_cleanup (null_cleanup
, NULL
);
730 TRY_CATCH (except
, RETURN_MASK_ALL
)
734 copy
= xstrdup (arg
);
736 sals
= decode_line_1 (©
, 0, 0, 0);
740 set_default_source_symtab_and_line ();
741 sal
= get_current_source_symtab_and_line ();
747 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
749 make_cleanup (xfree
, copy_to_free
);
750 make_cleanup (xfree
, sals
.sals
);
753 if (except
.reason
< 0)
755 do_cleanups (cleanups
);
756 /* We know this will always throw. */
757 gdbpy_convert_exception (except
);
765 result
= PyTuple_New (sals
.nelts
);
768 for (i
= 0; i
< sals
.nelts
; ++i
)
772 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
779 PyTuple_SetItem (result
, i
, obj
);
788 return_result
= PyTuple_New (2);
795 if (copy
&& strlen (copy
) > 0)
797 unparsed
= PyString_FromString (copy
);
798 if (unparsed
== NULL
)
801 Py_DECREF (return_result
);
802 return_result
= NULL
;
812 PyTuple_SetItem (return_result
, 0, unparsed
);
813 PyTuple_SetItem (return_result
, 1, result
);
816 do_cleanups (cleanups
);
818 return return_result
;
821 /* Parse a string and evaluate it as an expression. */
823 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
825 const char *expr_str
;
826 struct value
*result
= NULL
;
827 volatile struct gdb_exception except
;
829 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
832 TRY_CATCH (except
, RETURN_MASK_ALL
)
834 result
= parse_and_eval (expr_str
);
836 GDB_PY_HANDLE_EXCEPTION (except
);
838 return value_to_value_object (result
);
841 /* Implementation of gdb.find_pc_line function.
842 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
845 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
847 gdb_py_ulongest pc_llu
;
848 volatile struct gdb_exception except
;
849 PyObject
*result
= NULL
; /* init for gcc -Wall */
851 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
854 TRY_CATCH (except
, RETURN_MASK_ALL
)
856 struct symtab_and_line sal
;
859 pc
= (CORE_ADDR
) pc_llu
;
860 sal
= find_pc_line (pc
, 0);
861 result
= symtab_and_line_to_sal_object (sal
);
863 GDB_PY_HANDLE_EXCEPTION (except
);
868 /* Read a file as Python code.
869 This is the extension_language_script_ops.script_sourcer "method".
870 FILE is the file to load. FILENAME is name of the file FILE.
871 This does not throw any errors. If an exception occurs python will print
872 the traceback and clear the error indicator. */
875 gdbpy_source_script (const struct extension_language_defn
*extlang
,
876 FILE *file
, const char *filename
)
878 struct cleanup
*cleanup
;
880 cleanup
= ensure_python_env (get_current_arch (), current_language
);
881 python_run_simple_file (file
, filename
);
882 do_cleanups (cleanup
);
887 /* Posting and handling events. */
889 /* A single event. */
892 /* The Python event. This is just a callable object. */
894 /* The next event. */
895 struct gdbpy_event
*next
;
898 /* All pending events. */
899 static struct gdbpy_event
*gdbpy_event_list
;
900 /* The final link of the event list. */
901 static struct gdbpy_event
**gdbpy_event_list_end
;
903 /* We use a file handler, and not an async handler, so that we can
904 wake up the main thread even when it is blocked in poll(). */
905 static struct serial
*gdbpy_event_fds
[2];
907 /* The file handler callback. This reads from the internal pipe, and
908 then processes the Python event queue. This will always be run in
909 the main gdb thread. */
912 gdbpy_run_events (struct serial
*scb
, void *context
)
914 struct cleanup
*cleanup
;
916 cleanup
= ensure_python_env (get_current_arch (), current_language
);
918 /* Flush the fd. Do this before flushing the events list, so that
919 any new event post afterwards is sure to re-awake the event
921 while (serial_readchar (gdbpy_event_fds
[0], 0) >= 0)
924 while (gdbpy_event_list
)
926 PyObject
*call_result
;
928 /* Dispatching the event might push a new element onto the event
929 loop, so we update here "atomically enough". */
930 struct gdbpy_event
*item
= gdbpy_event_list
;
931 gdbpy_event_list
= gdbpy_event_list
->next
;
932 if (gdbpy_event_list
== NULL
)
933 gdbpy_event_list_end
= &gdbpy_event_list
;
936 call_result
= PyObject_CallObject (item
->event
, NULL
);
937 if (call_result
== NULL
)
940 Py_XDECREF (call_result
);
941 Py_DECREF (item
->event
);
945 do_cleanups (cleanup
);
948 /* Submit an event to the gdb thread. */
950 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
952 struct gdbpy_event
*event
;
956 if (!PyArg_ParseTuple (args
, "O", &func
))
959 if (!PyCallable_Check (func
))
961 PyErr_SetString (PyExc_RuntimeError
,
962 _("Posted event is not callable"));
968 /* From here until the end of the function, we have the GIL, so we
969 can operate on our global data structures without worrying. */
970 wakeup
= gdbpy_event_list
== NULL
;
972 event
= XNEW (struct gdbpy_event
);
975 *gdbpy_event_list_end
= event
;
976 gdbpy_event_list_end
= &event
->next
;
978 /* Wake up gdb when needed. */
981 char c
= 'q'; /* Anything. */
983 if (serial_write (gdbpy_event_fds
[1], &c
, 1))
984 return PyErr_SetFromErrno (PyExc_IOError
);
990 /* Initialize the Python event handler. */
992 gdbpy_initialize_events (void)
994 if (serial_pipe (gdbpy_event_fds
) == 0)
996 gdbpy_event_list_end
= &gdbpy_event_list
;
997 serial_async (gdbpy_event_fds
[0], gdbpy_run_events
, NULL
);
1005 /* This is the extension_language_ops.before_prompt "method". */
1007 static enum ext_lang_rc
1008 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1009 const char *current_gdb_prompt
)
1011 struct cleanup
*cleanup
;
1012 char *prompt
= NULL
;
1014 if (!gdb_python_initialized
)
1015 return EXT_LANG_RC_NOP
;
1017 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1019 if (gdb_python_module
1020 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1024 hook
= PyObject_GetAttrString (gdb_python_module
, "prompt_hook");
1028 make_cleanup_py_decref (hook
);
1030 if (PyCallable_Check (hook
))
1033 PyObject
*current_prompt
;
1035 current_prompt
= PyString_FromString (current_gdb_prompt
);
1036 if (current_prompt
== NULL
)
1039 result
= PyObject_CallFunctionObjArgs (hook
, current_prompt
, NULL
);
1041 Py_DECREF (current_prompt
);
1046 make_cleanup_py_decref (result
);
1048 /* Return type should be None, or a String. If it is None,
1049 fall through, we will not set a prompt. If it is a
1050 string, set PROMPT. Anything else, set an exception. */
1051 if (result
!= Py_None
&& ! PyString_Check (result
))
1053 PyErr_Format (PyExc_RuntimeError
,
1054 _("Return from prompt_hook must " \
1055 "be either a Python string, or None"));
1059 if (result
!= Py_None
)
1061 prompt
= python_string_to_host_string (result
);
1066 make_cleanup (xfree
, prompt
);
1071 /* If a prompt has been set, PROMPT will not be NULL. If it is
1072 NULL, do not set the prompt. */
1074 set_prompt (prompt
);
1076 do_cleanups (cleanup
);
1077 return prompt
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_NOP
;
1080 gdbpy_print_stack ();
1081 do_cleanups (cleanup
);
1082 return EXT_LANG_RC_ERROR
;
1089 /* A python function to write a single string using gdb's filtered
1090 output stream . The optional keyword STREAM can be used to write
1091 to a particular stream. The default stream is to gdb_stdout. */
1094 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1097 static char *keywords
[] = {"text", "stream", NULL
};
1098 int stream_type
= 0;
1099 volatile struct gdb_exception except
;
1101 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1105 TRY_CATCH (except
, RETURN_MASK_ALL
)
1107 switch (stream_type
)
1111 fprintf_filtered (gdb_stderr
, "%s", arg
);
1116 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1120 fprintf_filtered (gdb_stdout
, "%s", arg
);
1123 GDB_PY_HANDLE_EXCEPTION (except
);
1128 /* A python function to flush a gdb stream. The optional keyword
1129 STREAM can be used to flush a particular stream. The default stream
1133 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1135 static char *keywords
[] = {"stream", NULL
};
1136 int stream_type
= 0;
1138 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1142 switch (stream_type
)
1146 gdb_flush (gdb_stderr
);
1151 gdb_flush (gdb_stdlog
);
1155 gdb_flush (gdb_stdout
);
1161 /* Print a python exception trace, print just a message, or print
1162 nothing and clear the python exception, depending on
1163 gdbpy_should_print_stack. Only call this if a python exception is
1166 gdbpy_print_stack (void)
1168 volatile struct gdb_exception except
;
1170 /* Print "none", just clear exception. */
1171 if (gdbpy_should_print_stack
== python_excp_none
)
1175 /* Print "full" message and backtrace. */
1176 else if (gdbpy_should_print_stack
== python_excp_full
)
1179 /* PyErr_Print doesn't necessarily end output with a newline.
1180 This works because Python's stdout/stderr is fed through
1182 TRY_CATCH (except
, RETURN_MASK_ALL
)
1187 /* Print "message", just error print message. */
1190 PyObject
*ptype
, *pvalue
, *ptraceback
;
1191 char *msg
= NULL
, *type
= NULL
;
1193 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1195 /* Fetch the error message contained within ptype, pvalue. */
1196 msg
= gdbpy_exception_to_string (ptype
, pvalue
);
1197 type
= gdbpy_obj_to_string (ptype
);
1199 TRY_CATCH (except
, RETURN_MASK_ALL
)
1203 /* An error occurred computing the string representation of the
1205 fprintf_filtered (gdb_stderr
,
1206 _("Error occurred computing Python error" \
1210 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1215 Py_XDECREF (pvalue
);
1216 Py_XDECREF (ptraceback
);
1223 /* Return the current Progspace.
1224 There always is one. */
1227 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1231 result
= pspace_to_pspace_object (current_program_space
);
1237 /* Return a sequence holding all the Progspaces. */
1240 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1242 struct program_space
*ps
;
1245 list
= PyList_New (0);
1251 PyObject
*item
= pspace_to_pspace_object (ps
);
1253 if (!item
|| PyList_Append (list
, item
) == -1)
1265 /* The "current" objfile. This is set when gdb detects that a new
1266 objfile has been loaded. It is only set for the duration of a call to
1267 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1269 static struct objfile
*gdbpy_current_objfile
;
1271 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1272 as Python code. This does not throw any errors. If an exception
1273 occurs python will print the traceback and clear the error indicator.
1274 This is the extension_language_script_ops.objfile_script_sourcer
1278 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1279 struct objfile
*objfile
, FILE *file
,
1280 const char *filename
)
1282 struct cleanup
*cleanups
;
1284 if (!gdb_python_initialized
)
1287 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1288 gdbpy_current_objfile
= objfile
;
1290 python_run_simple_file (file
, filename
);
1292 do_cleanups (cleanups
);
1293 gdbpy_current_objfile
= NULL
;
1296 /* Set the current objfile to OBJFILE and then execute SCRIPT
1297 as Python code. This does not throw any errors. If an exception
1298 occurs python will print the traceback and clear the error indicator.
1299 This is the extension_language_script_ops.objfile_script_executor
1303 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1304 struct objfile
*objfile
, const char *name
,
1307 struct cleanup
*cleanups
;
1309 if (!gdb_python_initialized
)
1312 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1313 gdbpy_current_objfile
= objfile
;
1315 PyRun_SimpleString (script
);
1317 do_cleanups (cleanups
);
1318 gdbpy_current_objfile
= NULL
;
1321 /* Return the current Objfile, or None if there isn't one. */
1324 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1328 if (! gdbpy_current_objfile
)
1331 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1337 /* Return a sequence holding all the Objfiles. */
1340 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1342 struct objfile
*objf
;
1345 list
= PyList_New (0);
1351 PyObject
*item
= objfile_to_objfile_object (objf
);
1353 if (!item
|| PyList_Append (list
, item
) == -1)
1363 /* Compute the list of active python type printers and store them in
1364 EXT_PRINTERS->py_type_printers. The product of this function is used by
1365 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1366 This is the extension_language_ops.start_type_printers "method". */
1369 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1370 struct ext_lang_type_printers
*ext_printers
)
1372 struct cleanup
*cleanups
;
1373 PyObject
*type_module
, *func
= NULL
, *printers_obj
= NULL
;
1375 if (!gdb_python_initialized
)
1378 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1380 type_module
= PyImport_ImportModule ("gdb.types");
1381 if (type_module
== NULL
)
1383 gdbpy_print_stack ();
1387 func
= PyObject_GetAttrString (type_module
, "get_type_recognizers");
1390 gdbpy_print_stack ();
1394 printers_obj
= PyObject_CallFunctionObjArgs (func
, (char *) NULL
);
1395 if (printers_obj
== NULL
)
1396 gdbpy_print_stack ();
1398 ext_printers
->py_type_printers
= printers_obj
;
1401 Py_XDECREF (type_module
);
1403 do_cleanups (cleanups
);
1406 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1407 a newly allocated string holding the type's replacement name, and return
1408 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1409 If there's a Python error return EXT_LANG_RC_ERROR.
1410 Otherwise, return EXT_LANG_RC_NOP.
1411 This is the extension_language_ops.apply_type_printers "method". */
1413 static enum ext_lang_rc
1414 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1415 const struct ext_lang_type_printers
*ext_printers
,
1416 struct type
*type
, char **prettied_type
)
1418 struct cleanup
*cleanups
;
1419 PyObject
*type_obj
, *type_module
= NULL
, *func
= NULL
;
1420 PyObject
*result_obj
= NULL
;
1421 PyObject
*printers_obj
= ext_printers
->py_type_printers
;
1422 char *result
= NULL
;
1424 if (printers_obj
== NULL
)
1425 return EXT_LANG_RC_NOP
;
1427 if (!gdb_python_initialized
)
1428 return EXT_LANG_RC_NOP
;
1430 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1432 type_obj
= type_to_type_object (type
);
1433 if (type_obj
== NULL
)
1435 gdbpy_print_stack ();
1439 type_module
= PyImport_ImportModule ("gdb.types");
1440 if (type_module
== NULL
)
1442 gdbpy_print_stack ();
1446 func
= PyObject_GetAttrString (type_module
, "apply_type_recognizers");
1449 gdbpy_print_stack ();
1453 result_obj
= PyObject_CallFunctionObjArgs (func
, printers_obj
,
1454 type_obj
, (char *) NULL
);
1455 if (result_obj
== NULL
)
1457 gdbpy_print_stack ();
1461 if (result_obj
!= Py_None
)
1463 result
= python_string_to_host_string (result_obj
);
1465 gdbpy_print_stack ();
1469 Py_XDECREF (type_obj
);
1470 Py_XDECREF (type_module
);
1472 Py_XDECREF (result_obj
);
1473 do_cleanups (cleanups
);
1475 *prettied_type
= result
;
1476 return result
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_ERROR
;
1479 /* Free the result of start_type_printers.
1480 This is the extension_language_ops.free_type_printers "method". */
1483 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1484 struct ext_lang_type_printers
*ext_printers
)
1486 struct cleanup
*cleanups
;
1487 PyObject
*printers
= ext_printers
->py_type_printers
;
1489 if (printers
== NULL
)
1492 if (!gdb_python_initialized
)
1495 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1496 Py_DECREF (printers
);
1497 do_cleanups (cleanups
);
1500 #else /* HAVE_PYTHON */
1502 /* Dummy implementation of the gdb "python-interactive" and "python"
1506 python_interactive_command (char *arg
, int from_tty
)
1508 arg
= skip_spaces (arg
);
1510 error (_("Python scripting is not supported in this copy of GDB."));
1513 struct command_line
*l
= get_command_line (python_control
, "");
1514 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1516 execute_control_command_untraced (l
);
1517 do_cleanups (cleanups
);
1522 python_command (char *arg
, int from_tty
)
1524 python_interactive_command (arg
, from_tty
);
1527 #endif /* HAVE_PYTHON */
1531 /* Lists for 'set python' commands. */
1533 static struct cmd_list_element
*user_set_python_list
;
1534 static struct cmd_list_element
*user_show_python_list
;
1536 /* Function for use by 'set python' prefix command. */
1539 user_set_python (char *args
, int from_tty
)
1541 help_list (user_set_python_list
, "set python ", all_commands
,
1545 /* Function for use by 'show python' prefix command. */
1548 user_show_python (char *args
, int from_tty
)
1550 cmd_show_list (user_show_python_list
, from_tty
, "");
1553 /* Initialize the Python code. */
1557 /* This is installed as a final cleanup and cleans up the
1558 interpreter. This lets Python's 'atexit' work. */
1561 finalize_python (void *ignore
)
1563 struct active_ext_lang_state
*previous_active
;
1565 /* We don't use ensure_python_env here because if we ever ran the
1566 cleanup, gdb would crash -- because the cleanup calls into the
1567 Python interpreter, which we are about to destroy. It seems
1568 clearer to make the needed calls explicitly here than to create a
1569 cleanup and then mysteriously discard it. */
1571 /* This is only called as a final cleanup so we can assume the active
1572 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1573 previous_active
= set_active_ext_lang (&extension_language_python
);
1575 (void) PyGILState_Ensure ();
1576 python_gdbarch
= target_gdbarch ();
1577 python_language
= current_language
;
1581 restore_active_ext_lang (previous_active
);
1585 /* Provide a prototype to silence -Wmissing-prototypes. */
1586 extern initialize_file_ftype _initialize_python
;
1589 _initialize_python (void)
1594 size_t progsize
, count
;
1596 wchar_t *progname_copy
;
1599 add_com ("python-interactive", class_obscure
,
1600 python_interactive_command
,
1603 Start an interactive Python prompt.\n\
1605 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1608 Alternatively, a single-line Python command can be given as an\n\
1609 argument, and if the command is an expression, the result will be\n\
1610 printed. For example:\n\
1612 (gdb) python-interactive 2 + 3\n\
1615 #else /* HAVE_PYTHON */
1617 Start a Python interactive prompt.\n\
1619 Python scripting is not supported in this copy of GDB.\n\
1620 This command is only a placeholder.")
1621 #endif /* HAVE_PYTHON */
1623 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1625 add_com ("python", class_obscure
, python_command
,
1628 Evaluate a Python command.\n\
1630 The command can be given as an argument, for instance:\n\
1634 If no argument is given, the following lines are read and used\n\
1635 as the Python commands. Type a line containing \"end\" to indicate\n\
1636 the end of the command.")
1637 #else /* HAVE_PYTHON */
1639 Evaluate a Python command.\n\
1641 Python scripting is not supported in this copy of GDB.\n\
1642 This command is only a placeholder.")
1643 #endif /* HAVE_PYTHON */
1645 add_com_alias ("py", "python", class_obscure
, 1);
1647 /* Add set/show python print-stack. */
1648 add_prefix_cmd ("python", no_class
, user_show_python
,
1649 _("Prefix command for python preference settings."),
1650 &user_show_python_list
, "show python ", 0,
1653 add_prefix_cmd ("python", no_class
, user_set_python
,
1654 _("Prefix command for python preference settings."),
1655 &user_set_python_list
, "set python ", 0,
1658 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1659 &gdbpy_should_print_stack
, _("\
1660 Set mode for Python stack dump on error."), _("\
1661 Show the mode of Python stack printing on error."), _("\
1662 none == no stack or message will be printed.\n\
1663 full == a message and a stack will be printed.\n\
1664 message == an error message without a stack will be printed."),
1666 &user_set_python_list
,
1667 &user_show_python_list
);
1670 #ifdef WITH_PYTHON_PATH
1671 /* Work around problem where python gets confused about where it is,
1672 and then can't find its libraries, etc.
1673 NOTE: Python assumes the following layout:
1675 /foo/lib/pythonX.Y/...
1676 This must be done before calling Py_Initialize. */
1677 progname
= concat (ldirname (python_libdir
), SLASH_STRING
, "bin",
1678 SLASH_STRING
, "python", NULL
);
1680 oldloc
= setlocale (LC_ALL
, NULL
);
1681 setlocale (LC_ALL
, "");
1682 progsize
= strlen (progname
);
1683 if (progsize
== (size_t) -1)
1685 fprintf (stderr
, "Could not convert python path to string\n");
1688 progname_copy
= PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1691 fprintf (stderr
, "out of memory\n");
1694 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1695 if (count
== (size_t) -1)
1697 fprintf (stderr
, "Could not convert python path to string\n");
1700 setlocale (LC_ALL
, oldloc
);
1702 /* Note that Py_SetProgramName expects the string it is passed to
1703 remain alive for the duration of the program's execution, so
1704 it is not freed after this call. */
1705 Py_SetProgramName (progname_copy
);
1707 Py_SetProgramName (progname
);
1712 PyEval_InitThreads ();
1715 gdb_module
= PyModule_Create (&GdbModuleDef
);
1716 /* Add _gdb module to the list of known built-in modules. */
1717 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1719 gdb_module
= Py_InitModule ("_gdb", GdbMethods
);
1721 if (gdb_module
== NULL
)
1724 /* The casts to (char*) are for python 2.4. */
1725 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1726 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1727 (char*) host_name
) < 0
1728 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1729 (char*) target_name
) < 0)
1732 /* Add stream constants. */
1733 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1734 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1735 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1738 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1739 if (gdbpy_gdb_error
== NULL
1740 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1743 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1744 gdbpy_gdb_error
, NULL
);
1745 if (gdbpy_gdb_memory_error
== NULL
1746 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1747 gdbpy_gdb_memory_error
) < 0)
1750 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1751 if (gdbpy_gdberror_exc
== NULL
1752 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1753 gdbpy_gdberror_exc
) < 0)
1756 gdbpy_initialize_gdb_readline ();
1758 if (gdbpy_initialize_auto_load () < 0
1759 || gdbpy_initialize_values () < 0
1760 || gdbpy_initialize_frames () < 0
1761 || gdbpy_initialize_commands () < 0
1762 || gdbpy_initialize_symbols () < 0
1763 || gdbpy_initialize_symtabs () < 0
1764 || gdbpy_initialize_blocks () < 0
1765 || gdbpy_initialize_functions () < 0
1766 || gdbpy_initialize_parameters () < 0
1767 || gdbpy_initialize_types () < 0
1768 || gdbpy_initialize_pspace () < 0
1769 || gdbpy_initialize_objfile () < 0
1770 || gdbpy_initialize_breakpoints () < 0
1771 || gdbpy_initialize_finishbreakpoints () < 0
1772 || gdbpy_initialize_lazy_string () < 0
1773 || gdbpy_initialize_linetable () < 0
1774 || gdbpy_initialize_thread () < 0
1775 || gdbpy_initialize_inferior () < 0
1776 || gdbpy_initialize_events () < 0
1777 || gdbpy_initialize_eventregistry () < 0
1778 || gdbpy_initialize_py_events () < 0
1779 || gdbpy_initialize_event () < 0
1780 || gdbpy_initialize_stop_event () < 0
1781 || gdbpy_initialize_signal_event () < 0
1782 || gdbpy_initialize_breakpoint_event () < 0
1783 || gdbpy_initialize_continue_event () < 0
1784 || gdbpy_initialize_inferior_call_pre_event () < 0
1785 || gdbpy_initialize_inferior_call_post_event () < 0
1786 || gdbpy_initialize_register_changed_event () < 0
1787 || gdbpy_initialize_memory_changed_event () < 0
1788 || gdbpy_initialize_exited_event () < 0
1789 || gdbpy_initialize_thread_event () < 0
1790 || gdbpy_initialize_new_objfile_event () < 0
1791 || gdbpy_initialize_clear_objfiles_event () < 0
1792 || gdbpy_initialize_arch () < 0
1793 || gdbpy_initialize_xmethods () < 0)
1796 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1797 if (gdbpy_to_string_cst
== NULL
)
1799 gdbpy_children_cst
= PyString_FromString ("children");
1800 if (gdbpy_children_cst
== NULL
)
1802 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1803 if (gdbpy_display_hint_cst
== NULL
)
1805 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1806 if (gdbpy_doc_cst
== NULL
)
1808 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1809 if (gdbpy_enabled_cst
== NULL
)
1811 gdbpy_value_cst
= PyString_FromString ("value");
1812 if (gdbpy_value_cst
== NULL
)
1815 /* Release the GIL while gdb runs. */
1816 PyThreadState_Swap (NULL
);
1817 PyEval_ReleaseLock ();
1819 make_final_cleanup (finalize_python
, NULL
);
1821 gdb_python_initialized
= 1;
1825 gdbpy_print_stack ();
1826 /* Do not set 'gdb_python_initialized'. */
1829 #endif /* HAVE_PYTHON */
1834 /* Perform the remaining python initializations.
1835 These must be done after GDB is at least mostly initialized.
1836 E.g., The "info pretty-printer" command needs the "info" prefix
1838 This is the extension_language_ops.finish_initialization "method". */
1841 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1844 char *gdb_pythondir
;
1846 struct cleanup
*cleanup
;
1848 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1850 /* Add the initial data-directory to sys.path. */
1852 gdb_pythondir
= concat (gdb_datadir
, SLASH_STRING
, "python", NULL
);
1853 make_cleanup (xfree
, gdb_pythondir
);
1855 sys_path
= PySys_GetObject ("path");
1857 /* If sys.path is not defined yet, define it first. */
1858 if (!(sys_path
&& PyList_Check (sys_path
)))
1861 PySys_SetPath (L
"");
1865 sys_path
= PySys_GetObject ("path");
1867 if (sys_path
&& PyList_Check (sys_path
))
1869 PyObject
*pythondir
;
1872 pythondir
= PyString_FromString (gdb_pythondir
);
1873 if (pythondir
== NULL
)
1876 err
= PyList_Insert (sys_path
, 0, pythondir
);
1877 Py_DECREF (pythondir
);
1884 /* Import the gdb module to finish the initialization, and
1885 add it to __main__ for convenience. */
1886 m
= PyImport_AddModule ("__main__");
1890 gdb_python_module
= PyImport_ImportModule ("gdb");
1891 if (gdb_python_module
== NULL
)
1893 gdbpy_print_stack ();
1894 /* This is passed in one call to warning so that blank lines aren't
1895 inserted between each line of text. */
1897 "Could not load the Python gdb module from `%s'.\n"
1898 "Limited Python support is available from the _gdb module.\n"
1899 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1901 do_cleanups (cleanup
);
1905 if (gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) < 0)
1908 /* Keep the reference to gdb_python_module since it is in a global
1911 do_cleanups (cleanup
);
1915 gdbpy_print_stack ();
1916 warning (_("internal error: Unhandled Python exception"));
1917 do_cleanups (cleanup
);
1920 /* Return non-zero if Python has successfully initialized.
1921 This is the extension_languages_ops.initialized "method". */
1924 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1926 return gdb_python_initialized
;
1929 #endif /* HAVE_PYTHON */
1935 static PyMethodDef GdbMethods
[] =
1937 { "history", gdbpy_history
, METH_VARARGS
,
1938 "Get a value from history" },
1939 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1940 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1941 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1942 a Python String containing the output of the command if to_string is\n\
1944 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1945 "Return a gdb parameter's value" },
1947 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1948 "Return a tuple of all breakpoint objects" },
1950 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1951 "Find the default visualizer for a Value." },
1953 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1954 "Return the current Progspace." },
1955 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1956 "Return a sequence of all progspaces." },
1958 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1959 "Return the current Objfile being loaded, or None." },
1960 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1961 "Return a sequence of all loaded objfiles." },
1963 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1964 "newest_frame () -> gdb.Frame.\n\
1965 Return the newest frame object." },
1966 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1967 "selected_frame () -> gdb.Frame.\n\
1968 Return the selected frame object." },
1969 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1970 "stop_reason_string (Integer) -> String.\n\
1971 Return a string explaining unwind stop reason." },
1973 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1974 METH_VARARGS
| METH_KEYWORDS
,
1975 "lookup_type (name [, block]) -> type\n\
1976 Return a Type corresponding to the given name." },
1977 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1978 METH_VARARGS
| METH_KEYWORDS
,
1979 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1980 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1981 a boolean indicating if name is a field of the current implied argument\n\
1982 `this' (when the current language is object-oriented)." },
1983 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1984 METH_VARARGS
| METH_KEYWORDS
,
1985 "lookup_global_symbol (name [, domain]) -> symbol\n\
1986 Return the symbol corresponding to the given name (or None)." },
1988 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1989 METH_VARARGS
| METH_KEYWORDS
,
1990 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1991 Look up the specified objfile.\n\
1992 If by_build_id is True, the objfile is looked up by using name\n\
1993 as its build id." },
1995 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
1996 "Return the block containing the given pc value, or None." },
1997 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
1998 "solib_name (Long) -> String.\n\
1999 Return the name of the shared library holding a given address, or None." },
2000 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2001 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2002 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2003 The first element contains any unparsed portion of the String parameter\n\
2004 (or None if the string was fully parsed). The second element contains\n\
2005 a tuple that contains all the locations that match, represented as\n\
2006 gdb.Symtab_and_line objects (or None)."},
2007 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2008 "parse_and_eval (String) -> Value.\n\
2009 Parse String as an expression, evaluate it, and return the result as a Value."
2011 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2012 "find_pc_line (pc) -> Symtab_and_line.\n\
2013 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2015 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2016 "Post an event into gdb's event loop." },
2018 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2019 "target_charset () -> string.\n\
2020 Return the name of the current target charset." },
2021 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2022 "target_wide_charset () -> string.\n\
2023 Return the name of the current target wide charset." },
2025 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2026 "string_to_argv (String) -> Array.\n\
2027 Parse String and return an argv-like array.\n\
2028 Arguments are separate by spaces and may be quoted."
2030 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2031 "Write a string using gdb's filtered stream." },
2032 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2033 "Flush gdb's filtered stdout stream." },
2034 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2035 "selected_thread () -> gdb.InferiorThread.\n\
2036 Return the selected thread object." },
2037 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2038 "selected_inferior () -> gdb.Inferior.\n\
2039 Return the selected inferior object." },
2040 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2041 "inferiors () -> (gdb.Inferior, ...).\n\
2042 Return a tuple containing all inferiors." },
2043 {NULL
, NULL
, 0, NULL
}
2047 static struct PyModuleDef GdbModuleDef
=
2049 PyModuleDef_HEAD_INIT
,
2060 #endif /* HAVE_PYTHON */