1 /* General python/gdb code
3 Copyright (C) 2008-2014 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 "exceptions.h"
31 #include "event-loop.h"
33 #include "readline/tilde.h"
35 #include "extension-priv.h"
36 #include "cli/cli-utils.h"
39 /* Declared constants and enum for python stack printing. */
40 static const char python_excp_none[] = "none";
41 static const char python_excp_full[] = "full";
42 static const char python_excp_message[] = "message";
44 /* "set python print-stack" choices. */
45 static const char *const python_excp_enums[] =
53 /* The exception printing variable. 'full' if we want to print the
54 error message and stack, 'none' if we want to print nothing, and
55 'message' if we only want to print the error message. 'message' is
57 static const char *gdbpy_should_print_stack = python_excp_message;
60 /* Forward decls, these are defined later. */
61 static const struct extension_language_script_ops python_extension_script_ops;
62 static const struct extension_language_ops python_extension_ops;
65 /* The main struct describing GDB's interface to the Python
66 extension language. */
67 const struct extension_language_defn extension_language_python =
79 &python_extension_script_ops,
89 #include "libiberty.h"
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 static PyMethodDef GdbMethods[];
111 static struct PyModuleDef 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 void gdbpy_finish_initialization
137 (const struct extension_language_defn *);
138 static int gdbpy_initialized (const struct extension_language_defn *);
139 static void gdbpy_eval_from_control_command
140 (const struct extension_language_defn *, struct command_line *cmd);
141 static void gdbpy_start_type_printers (const struct extension_language_defn *,
142 struct ext_lang_type_printers *);
143 static enum ext_lang_rc gdbpy_apply_type_printers
144 (const struct extension_language_defn *,
145 const struct ext_lang_type_printers *, struct type *, char **);
146 static void gdbpy_free_type_printers (const struct extension_language_defn *,
147 struct ext_lang_type_printers *);
148 static void gdbpy_clear_quit_flag (const struct extension_language_defn *);
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 static const struct extension_language_script_ops python_extension_script_ops =
159 gdbpy_source_objfile_script,
160 gdbpy_auto_load_enabled
163 /* The interface between gdb proper and python extensions. */
165 static 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; it is NULL at other times. */
1268 static struct objfile *gdbpy_current_objfile;
1270 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1271 as Python code. This does not throw any errors. If an exception
1272 occurs python will print the traceback and clear the error indicator.
1273 This is the extension_language_script_ops.objfile_script_sourcer
1277 gdbpy_source_objfile_script (const struct extension_language_defn *extlang,
1278 struct objfile *objfile, FILE *file,
1279 const char *filename)
1281 struct cleanup *cleanups;
1283 if (!gdb_python_initialized)
1286 cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
1287 gdbpy_current_objfile = objfile;
1289 python_run_simple_file (file, filename);
1291 do_cleanups (cleanups);
1292 gdbpy_current_objfile = NULL;
1295 /* Return the current Objfile, or None if there isn't one. */
1298 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
1302 if (! gdbpy_current_objfile)
1305 result = objfile_to_objfile_object (gdbpy_current_objfile);
1311 /* Return a sequence holding all the Objfiles. */
1314 gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
1316 struct objfile *objf;
1319 list = PyList_New (0);
1325 PyObject *item = objfile_to_objfile_object (objf);
1327 if (!item || PyList_Append (list, item) == -1)
1337 /* Compute the list of active python type printers and store them in
1338 EXT_PRINTERS->py_type_printers. The product of this function is used by
1339 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1340 This is the extension_language_ops.start_type_printers "method". */
1343 gdbpy_start_type_printers (const struct extension_language_defn *extlang,
1344 struct ext_lang_type_printers *ext_printers)
1346 struct cleanup *cleanups;
1347 PyObject *type_module, *func = NULL, *printers_obj = NULL;
1349 if (!gdb_python_initialized)
1352 cleanups = ensure_python_env (get_current_arch (), current_language);
1354 type_module = PyImport_ImportModule ("gdb.types");
1355 if (type_module == NULL)
1357 gdbpy_print_stack ();
1361 func = PyObject_GetAttrString (type_module, "get_type_recognizers");
1364 gdbpy_print_stack ();
1368 printers_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
1369 if (printers_obj == NULL)
1370 gdbpy_print_stack ();
1372 ext_printers->py_type_printers = printers_obj;
1375 Py_XDECREF (type_module);
1377 do_cleanups (cleanups);
1380 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1381 a newly allocated string holding the type's replacement name, and return
1382 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1383 If there's a Python error return EXT_LANG_RC_ERROR.
1384 Otherwise, return EXT_LANG_RC_NOP.
1385 This is the extension_language_ops.apply_type_printers "method". */
1387 static enum ext_lang_rc
1388 gdbpy_apply_type_printers (const struct extension_language_defn *extlang,
1389 const struct ext_lang_type_printers *ext_printers,
1390 struct type *type, char **prettied_type)
1392 struct cleanup *cleanups;
1393 PyObject *type_obj, *type_module = NULL, *func = NULL;
1394 PyObject *result_obj = NULL;
1395 PyObject *printers_obj = ext_printers->py_type_printers;
1396 char *result = NULL;
1398 if (printers_obj == NULL)
1399 return EXT_LANG_RC_NOP;
1401 if (!gdb_python_initialized)
1402 return EXT_LANG_RC_NOP;
1404 cleanups = ensure_python_env (get_current_arch (), current_language);
1406 type_obj = type_to_type_object (type);
1407 if (type_obj == NULL)
1409 gdbpy_print_stack ();
1413 type_module = PyImport_ImportModule ("gdb.types");
1414 if (type_module == NULL)
1416 gdbpy_print_stack ();
1420 func = PyObject_GetAttrString (type_module, "apply_type_recognizers");
1423 gdbpy_print_stack ();
1427 result_obj = PyObject_CallFunctionObjArgs (func, printers_obj,
1428 type_obj, (char *) NULL);
1429 if (result_obj == NULL)
1431 gdbpy_print_stack ();
1435 if (result_obj != Py_None)
1437 result = python_string_to_host_string (result_obj);
1439 gdbpy_print_stack ();
1443 Py_XDECREF (type_obj);
1444 Py_XDECREF (type_module);
1446 Py_XDECREF (result_obj);
1447 do_cleanups (cleanups);
1449 *prettied_type = result;
1450 return result != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_ERROR;
1453 /* Free the result of start_type_printers.
1454 This is the extension_language_ops.free_type_printers "method". */
1457 gdbpy_free_type_printers (const struct extension_language_defn *extlang,
1458 struct ext_lang_type_printers *ext_printers)
1460 struct cleanup *cleanups;
1461 PyObject *printers = ext_printers->py_type_printers;
1463 if (printers == NULL)
1466 if (!gdb_python_initialized)
1469 cleanups = ensure_python_env (get_current_arch (), current_language);
1470 Py_DECREF (printers);
1471 do_cleanups (cleanups);
1474 #else /* HAVE_PYTHON */
1476 /* Dummy implementation of the gdb "python-interactive" and "python"
1480 python_interactive_command (char *arg, int from_tty)
1482 arg = skip_spaces (arg);
1484 error (_("Python scripting is not supported in this copy of GDB."));
1487 struct command_line *l = get_command_line (python_control, "");
1488 struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
1490 execute_control_command_untraced (l);
1491 do_cleanups (cleanups);
1496 python_command (char *arg, int from_tty)
1498 python_interactive_command (arg, from_tty);
1501 #endif /* HAVE_PYTHON */
1505 /* Lists for 'set python' commands. */
1507 static struct cmd_list_element *user_set_python_list;
1508 static struct cmd_list_element *user_show_python_list;
1510 /* Function for use by 'set python' prefix command. */
1513 user_set_python (char *args, int from_tty)
1515 help_list (user_set_python_list, "set python ", all_commands,
1519 /* Function for use by 'show python' prefix command. */
1522 user_show_python (char *args, int from_tty)
1524 cmd_show_list (user_show_python_list, from_tty, "");
1527 /* Initialize the Python code. */
1531 /* This is installed as a final cleanup and cleans up the
1532 interpreter. This lets Python's 'atexit' work. */
1535 finalize_python (void *ignore)
1537 struct active_ext_lang_state *previous_active;
1539 /* We don't use ensure_python_env here because if we ever ran the
1540 cleanup, gdb would crash -- because the cleanup calls into the
1541 Python interpreter, which we are about to destroy. It seems
1542 clearer to make the needed calls explicitly here than to create a
1543 cleanup and then mysteriously discard it. */
1545 /* This is only called as a final cleanup so we can assume the active
1546 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1547 previous_active = set_active_ext_lang (&extension_language_python);
1549 (void) PyGILState_Ensure ();
1550 python_gdbarch = target_gdbarch ();
1551 python_language = current_language;
1555 restore_active_ext_lang (previous_active);
1559 /* Provide a prototype to silence -Wmissing-prototypes. */
1560 extern initialize_file_ftype _initialize_python;
1563 _initialize_python (void)
1568 size_t progsize, count;
1570 wchar_t *progname_copy;
1573 add_com ("python-interactive", class_obscure,
1574 python_interactive_command,
1577 Start an interactive Python prompt.\n\
1579 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1582 Alternatively, a single-line Python command can be given as an\n\
1583 argument, and if the command is an expression, the result will be\n\
1584 printed. For example:\n\
1586 (gdb) python-interactive 2 + 3\n\
1589 #else /* HAVE_PYTHON */
1591 Start a Python interactive prompt.\n\
1593 Python scripting is not supported in this copy of GDB.\n\
1594 This command is only a placeholder.")
1595 #endif /* HAVE_PYTHON */
1597 add_com_alias ("pi", "python-interactive", class_obscure, 1);
1599 add_com ("python", class_obscure, python_command,
1602 Evaluate a Python command.\n\
1604 The command can be given as an argument, for instance:\n\
1608 If no argument is given, the following lines are read and used\n\
1609 as the Python commands. Type a line containing \"end\" to indicate\n\
1610 the end of the command.")
1611 #else /* HAVE_PYTHON */
1613 Evaluate a Python command.\n\
1615 Python scripting is not supported in this copy of GDB.\n\
1616 This command is only a placeholder.")
1617 #endif /* HAVE_PYTHON */
1619 add_com_alias ("py", "python", class_obscure, 1);
1621 /* Add set/show python print-stack. */
1622 add_prefix_cmd ("python", no_class, user_show_python,
1623 _("Prefix command for python preference settings."),
1624 &user_show_python_list, "show python ", 0,
1627 add_prefix_cmd ("python", no_class, user_set_python,
1628 _("Prefix command for python preference settings."),
1629 &user_set_python_list, "set python ", 0,
1632 add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums,
1633 &gdbpy_should_print_stack, _("\
1634 Set mode for Python stack dump on error."), _("\
1635 Show the mode of Python stack printing on error."), _("\
1636 none == no stack or message will be printed.\n\
1637 full == a message and a stack will be printed.\n\
1638 message == an error message without a stack will be printed."),
1640 &user_set_python_list,
1641 &user_show_python_list);
1644 #ifdef WITH_PYTHON_PATH
1645 /* Work around problem where python gets confused about where it is,
1646 and then can't find its libraries, etc.
1647 NOTE: Python assumes the following layout:
1649 /foo/lib/pythonX.Y/...
1650 This must be done before calling Py_Initialize. */
1651 progname = concat (ldirname (python_libdir), SLASH_STRING, "bin",
1652 SLASH_STRING, "python", NULL);
1654 oldloc = setlocale (LC_ALL, NULL);
1655 setlocale (LC_ALL, "");
1656 progsize = strlen (progname);
1657 if (progsize == (size_t) -1)
1659 fprintf (stderr, "Could not convert python path to string\n");
1662 progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t));
1665 fprintf (stderr, "out of memory\n");
1668 count = mbstowcs (progname_copy, progname, progsize + 1);
1669 if (count == (size_t) -1)
1671 fprintf (stderr, "Could not convert python path to string\n");
1674 setlocale (LC_ALL, oldloc);
1676 /* Note that Py_SetProgramName expects the string it is passed to
1677 remain alive for the duration of the program's execution, so
1678 it is not freed after this call. */
1679 Py_SetProgramName (progname_copy);
1681 Py_SetProgramName (progname);
1686 PyEval_InitThreads ();
1689 gdb_module = PyModule_Create (&GdbModuleDef);
1690 /* Add _gdb module to the list of known built-in modules. */
1691 _PyImport_FixupBuiltin (gdb_module, "_gdb");
1693 gdb_module = Py_InitModule ("_gdb", GdbMethods);
1695 if (gdb_module == NULL)
1698 /* The casts to (char*) are for python 2.4. */
1699 if (PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version) < 0
1700 || PyModule_AddStringConstant (gdb_module, "HOST_CONFIG",
1701 (char*) host_name) < 0
1702 || PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
1703 (char*) target_name) < 0)
1706 /* Add stream constants. */
1707 if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0
1708 || PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0
1709 || PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0)
1712 gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
1713 if (gdbpy_gdb_error == NULL
1714 || gdb_pymodule_addobject (gdb_module, "error", gdbpy_gdb_error) < 0)
1717 gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
1718 gdbpy_gdb_error, NULL);
1719 if (gdbpy_gdb_memory_error == NULL
1720 || gdb_pymodule_addobject (gdb_module, "MemoryError",
1721 gdbpy_gdb_memory_error) < 0)
1724 gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
1725 if (gdbpy_gdberror_exc == NULL
1726 || gdb_pymodule_addobject (gdb_module, "GdbError",
1727 gdbpy_gdberror_exc) < 0)
1730 gdbpy_initialize_gdb_readline ();
1732 if (gdbpy_initialize_auto_load () < 0
1733 || gdbpy_initialize_values () < 0
1734 || gdbpy_initialize_frames () < 0
1735 || gdbpy_initialize_commands () < 0
1736 || gdbpy_initialize_symbols () < 0
1737 || gdbpy_initialize_symtabs () < 0
1738 || gdbpy_initialize_blocks () < 0
1739 || gdbpy_initialize_functions () < 0
1740 || gdbpy_initialize_parameters () < 0
1741 || gdbpy_initialize_types () < 0
1742 || gdbpy_initialize_pspace () < 0
1743 || gdbpy_initialize_objfile () < 0
1744 || gdbpy_initialize_breakpoints () < 0
1745 || gdbpy_initialize_finishbreakpoints () < 0
1746 || gdbpy_initialize_lazy_string () < 0
1747 || gdbpy_initialize_linetable () < 0
1748 || gdbpy_initialize_thread () < 0
1749 || gdbpy_initialize_inferior () < 0
1750 || gdbpy_initialize_events () < 0
1751 || gdbpy_initialize_eventregistry () < 0
1752 || gdbpy_initialize_py_events () < 0
1753 || gdbpy_initialize_event () < 0
1754 || gdbpy_initialize_stop_event () < 0
1755 || gdbpy_initialize_signal_event () < 0
1756 || gdbpy_initialize_breakpoint_event () < 0
1757 || gdbpy_initialize_continue_event () < 0
1758 || gdbpy_initialize_exited_event () < 0
1759 || gdbpy_initialize_thread_event () < 0
1760 || gdbpy_initialize_new_objfile_event () < 0
1761 || gdbpy_initialize_arch () < 0
1762 || gdbpy_initialize_xmethods () < 0)
1765 gdbpy_to_string_cst = PyString_FromString ("to_string");
1766 if (gdbpy_to_string_cst == NULL)
1768 gdbpy_children_cst = PyString_FromString ("children");
1769 if (gdbpy_children_cst == NULL)
1771 gdbpy_display_hint_cst = PyString_FromString ("display_hint");
1772 if (gdbpy_display_hint_cst == NULL)
1774 gdbpy_doc_cst = PyString_FromString ("__doc__");
1775 if (gdbpy_doc_cst == NULL)
1777 gdbpy_enabled_cst = PyString_FromString ("enabled");
1778 if (gdbpy_enabled_cst == NULL)
1780 gdbpy_value_cst = PyString_FromString ("value");
1781 if (gdbpy_value_cst == NULL)
1784 /* Release the GIL while gdb runs. */
1785 PyThreadState_Swap (NULL);
1786 PyEval_ReleaseLock ();
1788 make_final_cleanup (finalize_python, NULL);
1790 gdb_python_initialized = 1;
1794 gdbpy_print_stack ();
1795 /* Do not set 'gdb_python_initialized'. */
1798 #endif /* HAVE_PYTHON */
1803 /* Perform the remaining python initializations.
1804 These must be done after GDB is at least mostly initialized.
1805 E.g., The "info pretty-printer" command needs the "info" prefix
1807 This is the extension_language_ops.finish_initialization "method". */
1810 gdbpy_finish_initialization (const struct extension_language_defn *extlang)
1813 char *gdb_pythondir;
1815 struct cleanup *cleanup;
1817 cleanup = ensure_python_env (get_current_arch (), current_language);
1819 /* Add the initial data-directory to sys.path. */
1821 gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
1822 make_cleanup (xfree, gdb_pythondir);
1824 sys_path = PySys_GetObject ("path");
1826 /* If sys.path is not defined yet, define it first. */
1827 if (!(sys_path && PyList_Check (sys_path)))
1830 PySys_SetPath (L"");
1834 sys_path = PySys_GetObject ("path");
1836 if (sys_path && PyList_Check (sys_path))
1838 PyObject *pythondir;
1841 pythondir = PyString_FromString (gdb_pythondir);
1842 if (pythondir == NULL)
1845 err = PyList_Insert (sys_path, 0, pythondir);
1846 Py_DECREF (pythondir);
1853 /* Import the gdb module to finish the initialization, and
1854 add it to __main__ for convenience. */
1855 m = PyImport_AddModule ("__main__");
1859 gdb_python_module = PyImport_ImportModule ("gdb");
1860 if (gdb_python_module == NULL)
1862 gdbpy_print_stack ();
1863 /* This is passed in one call to warning so that blank lines aren't
1864 inserted between each line of text. */
1866 "Could not load the Python gdb module from `%s'.\n"
1867 "Limited Python support is available from the _gdb module.\n"
1868 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1870 do_cleanups (cleanup);
1874 if (gdb_pymodule_addobject (m, "gdb", gdb_python_module) < 0)
1877 /* Keep the reference to gdb_python_module since it is in a global
1880 do_cleanups (cleanup);
1884 gdbpy_print_stack ();
1885 warning (_("internal error: Unhandled Python exception"));
1886 do_cleanups (cleanup);
1889 /* Return non-zero if Python has successfully initialized.
1890 This is the extension_languages_ops.initialized "method". */
1893 gdbpy_initialized (const struct extension_language_defn *extlang)
1895 return gdb_python_initialized;
1898 #endif /* HAVE_PYTHON */
1904 static PyMethodDef GdbMethods[] =
1906 { "history", gdbpy_history, METH_VARARGS,
1907 "Get a value from history" },
1908 { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
1909 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1910 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1911 a Python String containing the output of the command if to_string is\n\
1913 { "parameter", gdbpy_parameter, METH_VARARGS,
1914 "Return a gdb parameter's value" },
1916 { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
1917 "Return a tuple of all breakpoint objects" },
1919 { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
1920 "Find the default visualizer for a Value." },
1922 { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS,
1923 "Return the current Progspace." },
1924 { "progspaces", gdbpy_progspaces, METH_NOARGS,
1925 "Return a sequence of all progspaces." },
1927 { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
1928 "Return the current Objfile being loaded, or None." },
1929 { "objfiles", gdbpy_objfiles, METH_NOARGS,
1930 "Return a sequence of all loaded objfiles." },
1932 { "newest_frame", gdbpy_newest_frame, METH_NOARGS,
1933 "newest_frame () -> gdb.Frame.\n\
1934 Return the newest frame object." },
1935 { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
1936 "selected_frame () -> gdb.Frame.\n\
1937 Return the selected frame object." },
1938 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
1939 "stop_reason_string (Integer) -> String.\n\
1940 Return a string explaining unwind stop reason." },
1942 { "lookup_type", (PyCFunction) gdbpy_lookup_type,
1943 METH_VARARGS | METH_KEYWORDS,
1944 "lookup_type (name [, block]) -> type\n\
1945 Return a Type corresponding to the given name." },
1946 { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
1947 METH_VARARGS | METH_KEYWORDS,
1948 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1949 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1950 a boolean indicating if name is a field of the current implied argument\n\
1951 `this' (when the current language is object-oriented)." },
1952 { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol,
1953 METH_VARARGS | METH_KEYWORDS,
1954 "lookup_global_symbol (name [, domain]) -> symbol\n\
1955 Return the symbol corresponding to the given name (or None)." },
1956 { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
1957 "Return the block containing the given pc value, or None." },
1958 { "solib_name", gdbpy_solib_name, METH_VARARGS,
1959 "solib_name (Long) -> String.\n\
1960 Return the name of the shared library holding a given address, or None." },
1961 { "decode_line", gdbpy_decode_line, METH_VARARGS,
1962 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1963 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1964 The first element contains any unparsed portion of the String parameter\n\
1965 (or None if the string was fully parsed). The second element contains\n\
1966 a tuple that contains all the locations that match, represented as\n\
1967 gdb.Symtab_and_line objects (or None)."},
1968 { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
1969 "parse_and_eval (String) -> Value.\n\
1970 Parse String as an expression, evaluate it, and return the result as a Value."
1972 { "find_pc_line", gdbpy_find_pc_line, METH_VARARGS,
1973 "find_pc_line (pc) -> Symtab_and_line.\n\
1974 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1976 { "post_event", gdbpy_post_event, METH_VARARGS,
1977 "Post an event into gdb's event loop." },
1979 { "target_charset", gdbpy_target_charset, METH_NOARGS,
1980 "target_charset () -> string.\n\
1981 Return the name of the current target charset." },
1982 { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
1983 "target_wide_charset () -> string.\n\
1984 Return the name of the current target wide charset." },
1986 { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS,
1987 "string_to_argv (String) -> Array.\n\
1988 Parse String and return an argv-like array.\n\
1989 Arguments are separate by spaces and may be quoted."
1991 { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS,
1992 "Write a string using gdb's filtered stream." },
1993 { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS,
1994 "Flush gdb's filtered stdout stream." },
1995 { "selected_thread", gdbpy_selected_thread, METH_NOARGS,
1996 "selected_thread () -> gdb.InferiorThread.\n\
1997 Return the selected thread object." },
1998 { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS,
1999 "selected_inferior () -> gdb.Inferior.\n\
2000 Return the selected inferior object." },
2001 { "inferiors", gdbpy_inferiors, METH_NOARGS,
2002 "inferiors () -> (gdb.Inferior, ...).\n\
2003 Return a tuple containing all inferiors." },
2004 {NULL, NULL, 0, NULL}
2008 static struct PyModuleDef GdbModuleDef =
2010 PyModuleDef_HEAD_INIT,
2021 #endif /* HAVE_PYTHON */