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 "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 static const struct extension_language_script_ops python_extension_script_ops;
61 static 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 void gdbpy_finish_initialization
135 (const struct extension_language_defn *);
136 static int gdbpy_initialized (const struct extension_language_defn *);
137 static void gdbpy_eval_from_control_command
138 (const struct extension_language_defn *, struct command_line *cmd);
139 static void gdbpy_start_type_printers (const struct extension_language_defn *,
140 struct ext_lang_type_printers *);
141 static enum ext_lang_rc gdbpy_apply_type_printers
142 (const struct extension_language_defn *,
143 const struct ext_lang_type_printers *, struct type *, char **);
144 static void gdbpy_free_type_printers (const struct extension_language_defn *,
145 struct ext_lang_type_printers *);
146 static void gdbpy_clear_quit_flag (const struct extension_language_defn *);
147 static void gdbpy_set_quit_flag (const struct extension_language_defn *);
148 static int gdbpy_check_quit_flag (const struct extension_language_defn *);
149 static enum ext_lang_rc gdbpy_before_prompt_hook
150 (const struct extension_language_defn *, const char *current_gdb_prompt);
152 /* The interface between gdb proper and loading of python scripts. */
154 static const struct extension_language_script_ops python_extension_script_ops =
157 gdbpy_source_objfile_script,
158 gdbpy_auto_load_enabled
161 /* The interface between gdb proper and python extensions. */
163 static const struct extension_language_ops python_extension_ops =
165 gdbpy_finish_initialization,
168 gdbpy_eval_from_control_command,
170 gdbpy_start_type_printers,
171 gdbpy_apply_type_printers,
172 gdbpy_free_type_printers,
174 gdbpy_apply_val_pretty_printer,
176 gdbpy_apply_frame_filter,
178 gdbpy_preserve_values,
180 gdbpy_breakpoint_has_cond,
181 gdbpy_breakpoint_cond_says_stop,
183 gdbpy_clear_quit_flag,
185 gdbpy_check_quit_flag,
187 gdbpy_before_prompt_hook,
189 gdbpy_clone_xmethod_worker_data,
190 gdbpy_free_xmethod_worker_data,
191 gdbpy_get_matching_xmethod_workers,
192 gdbpy_get_xmethod_arg_types,
196 /* Architecture and language to be used in callbacks from
197 the Python interpreter. */
198 struct gdbarch *python_gdbarch;
199 const struct language_defn *python_language;
201 /* Restore global language and architecture and Python GIL state
202 when leaving the Python interpreter. */
206 struct active_ext_lang_state *previous_active;
207 PyGILState_STATE state;
208 struct gdbarch *gdbarch;
209 const struct language_defn *language;
210 PyObject *error_type, *error_value, *error_traceback;
214 restore_python_env (void *p)
216 struct python_env *env = (struct python_env *)p;
218 /* Leftover Python error is forbidden by Python Exception Handling. */
219 if (PyErr_Occurred ())
221 /* This order is similar to the one calling error afterwards. */
222 gdbpy_print_stack ();
223 warning (_("internal error: Unhandled Python exception"));
226 PyErr_Restore (env->error_type, env->error_value, env->error_traceback);
228 PyGILState_Release (env->state);
229 python_gdbarch = env->gdbarch;
230 python_language = env->language;
232 restore_active_ext_lang (env->previous_active);
237 /* Called before entering the Python interpreter to install the
238 current language and architecture to be used for Python values.
239 Also set the active extension language for GDB so that SIGINT's
240 are directed our way, and if necessary install the right SIGINT
244 ensure_python_env (struct gdbarch *gdbarch,
245 const struct language_defn *language)
247 struct python_env *env = xmalloc (sizeof *env);
249 /* We should not ever enter Python unless initialized. */
250 if (!gdb_python_initialized)
251 error (_("Python not initialized"));
253 env->previous_active = set_active_ext_lang (&extension_language_python);
255 env->state = PyGILState_Ensure ();
256 env->gdbarch = python_gdbarch;
257 env->language = python_language;
259 python_gdbarch = gdbarch;
260 python_language = language;
262 /* Save it and ensure ! PyErr_Occurred () afterwards. */
263 PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
265 return make_cleanup (restore_python_env, env);
268 /* Clear the quit flag. */
271 gdbpy_clear_quit_flag (const struct extension_language_defn *extlang)
273 /* This clears the flag as a side effect. */
274 PyOS_InterruptOccurred ();
277 /* Set the quit flag. */
280 gdbpy_set_quit_flag (const struct extension_language_defn *extlang)
282 PyErr_SetInterrupt ();
285 /* Return true if the quit flag has been set, false otherwise. */
288 gdbpy_check_quit_flag (const struct extension_language_defn *extlang)
290 return PyOS_InterruptOccurred ();
293 /* Evaluate a Python command like PyRun_SimpleString, but uses
294 Py_single_input which prints the result of expressions, and does
295 not automatically print the stack on errors. */
298 eval_python_command (const char *command)
302 m = PyImport_AddModule ("__main__");
306 d = PyModule_GetDict (m);
309 v = PyRun_StringFlags (command, Py_single_input, d, d, NULL);
322 /* Implementation of the gdb "python-interactive" command. */
325 python_interactive_command (char *arg, int from_tty)
327 struct cleanup *cleanup;
330 cleanup = make_cleanup_restore_integer (&interpreter_async);
331 interpreter_async = 0;
333 arg = skip_spaces (arg);
335 ensure_python_env (get_current_arch (), current_language);
339 int len = strlen (arg);
340 char *script = xmalloc (len + 2);
342 strcpy (script, arg);
344 script[len + 1] = '\0';
345 err = eval_python_command (script);
350 err = PyRun_InteractiveLoop (instream, "<stdin>");
356 gdbpy_print_stack ();
357 error (_("Error while executing Python code."));
360 do_cleanups (cleanup);
363 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
366 On Windows hosts few users would build Python themselves (this is no
367 trivial task on this platform), and thus use binaries built by
368 someone else instead. There may happen situation where the Python
369 library and GDB are using two different versions of the C runtime
370 library. Python, being built with VC, would use one version of the
371 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
372 A FILE * from one runtime does not necessarily operate correctly in
375 To work around this potential issue, we create on Windows hosts the
376 FILE object using Python routines, thus making sure that it is
377 compatible with the Python library. */
380 python_run_simple_file (FILE *file, const char *filename)
384 PyRun_SimpleFile (file, filename);
389 PyObject *python_file;
390 struct cleanup *cleanup;
392 /* Because we have a string for a filename, and are using Python to
393 open the file, we need to expand any tilde in the path first. */
394 full_path = tilde_expand (filename);
395 cleanup = make_cleanup (xfree, full_path);
396 python_file = PyFile_FromString (full_path, "r");
399 do_cleanups (cleanup);
400 gdbpy_print_stack ();
401 error (_("Error while opening file: %s"), full_path);
404 make_cleanup_py_decref (python_file);
405 PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
406 do_cleanups (cleanup);
411 /* Given a command_line, return a command string suitable for passing
412 to Python. Lines in the string are separated by newlines. The
413 return value is allocated using xmalloc and the caller is
414 responsible for freeing it. */
417 compute_python_string (struct command_line *l)
419 struct command_line *iter;
424 for (iter = l; iter; iter = iter->next)
425 size += strlen (iter->line) + 1;
427 script = xmalloc (size + 1);
429 for (iter = l; iter; iter = iter->next)
431 int len = strlen (iter->line);
433 strcpy (&script[here], iter->line);
435 script[here++] = '\n';
441 /* Take a command line structure representing a 'python' command, and
442 evaluate its body using the Python interpreter. */
445 gdbpy_eval_from_control_command (const struct extension_language_defn *extlang,
446 struct command_line *cmd)
450 struct cleanup *cleanup;
452 if (cmd->body_count != 1)
453 error (_("Invalid \"python\" block structure."));
455 cleanup = ensure_python_env (get_current_arch (), current_language);
457 script = compute_python_string (cmd->body_list[0]);
458 ret = PyRun_SimpleString (script);
461 error (_("Error while executing Python code."));
463 do_cleanups (cleanup);
466 /* Implementation of the gdb "python" command. */
469 python_command (char *arg, int from_tty)
471 struct cleanup *cleanup;
473 cleanup = ensure_python_env (get_current_arch (), current_language);
475 make_cleanup_restore_integer (&interpreter_async);
476 interpreter_async = 0;
478 arg = skip_spaces (arg);
481 if (PyRun_SimpleString (arg))
482 error (_("Error while executing Python code."));
486 struct command_line *l = get_command_line (python_control, "");
488 make_cleanup_free_command_lines (&l);
489 execute_control_command_untraced (l);
492 do_cleanups (cleanup);
497 /* Transform a gdb parameters's value into a Python value. May return
498 NULL (and set a Python exception) on error. Helper function for
501 gdbpy_parameter_value (enum var_types type, void *var)
506 case var_string_noescape:
507 case var_optional_filename:
511 char *str = * (char **) var;
515 return PyString_Decode (str, strlen (str), host_charset (), NULL);
526 case var_auto_boolean:
528 enum auto_boolean ab = * (enum auto_boolean *) var;
530 if (ab == AUTO_BOOLEAN_TRUE)
532 else if (ab == AUTO_BOOLEAN_FALSE)
539 if ((* (int *) var) == INT_MAX)
543 return PyLong_FromLong (* (int *) var);
547 unsigned int val = * (unsigned int *) var;
551 return PyLong_FromUnsignedLong (val);
555 return PyErr_Format (PyExc_RuntimeError,
556 _("Programmer error: unhandled type."));
559 /* A Python function which returns a gdb parameter's value as a Python
563 gdbpy_parameter (PyObject *self, PyObject *args)
565 struct cmd_list_element *alias, *prefix, *cmd;
569 volatile struct gdb_exception except;
571 if (! PyArg_ParseTuple (args, "s", &arg))
574 newarg = concat ("show ", arg, (char *) NULL);
576 TRY_CATCH (except, RETURN_MASK_ALL)
578 found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
581 GDB_PY_HANDLE_EXCEPTION (except);
583 return PyErr_Format (PyExc_RuntimeError,
584 _("Could not find parameter `%s'."), arg);
587 return PyErr_Format (PyExc_RuntimeError,
588 _("`%s' is not a parameter."), arg);
589 return gdbpy_parameter_value (cmd->var_type, cmd->var);
592 /* Wrapper for target_charset. */
595 gdbpy_target_charset (PyObject *self, PyObject *args)
597 const char *cset = target_charset (python_gdbarch);
599 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
602 /* Wrapper for target_wide_charset. */
605 gdbpy_target_wide_charset (PyObject *self, PyObject *args)
607 const char *cset = target_wide_charset (python_gdbarch);
609 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
612 /* A Python function which evaluates a string using the gdb CLI. */
615 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
618 PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
619 int from_tty, to_string;
620 volatile struct gdb_exception except;
621 static char *keywords[] = {"command", "from_tty", "to_string", NULL };
624 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
625 &PyBool_Type, &from_tty_obj,
626 &PyBool_Type, &to_string_obj))
632 int cmp = PyObject_IsTrue (from_tty_obj);
641 int cmp = PyObject_IsTrue (to_string_obj);
647 TRY_CATCH (except, RETURN_MASK_ALL)
649 /* Copy the argument text in case the command modifies it. */
650 char *copy = xstrdup (arg);
651 struct cleanup *cleanup = make_cleanup (xfree, copy);
653 make_cleanup_restore_integer (&interpreter_async);
654 interpreter_async = 0;
656 prevent_dont_repeat ();
658 result = execute_command_to_string (copy, from_tty);
662 execute_command (copy, from_tty);
665 do_cleanups (cleanup);
667 GDB_PY_HANDLE_EXCEPTION (except);
669 /* Do any commands attached to breakpoint we stopped at. */
670 bpstat_do_actions ();
674 PyObject *r = PyString_FromString (result);
681 /* Implementation of gdb.solib_name (Long) -> String.
682 Returns the name of the shared library holding a given address, or None. */
685 gdbpy_solib_name (PyObject *self, PyObject *args)
691 if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc))
694 soname = solib_name_from_address (current_program_space, pc);
696 str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL);
706 /* A Python function which is a wrapper for decode_line_1. */
709 gdbpy_decode_line (PyObject *self, PyObject *args)
711 struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
713 struct symtab_and_line sal;
714 const char *arg = NULL;
715 char *copy_to_free = NULL, *copy = NULL;
716 struct cleanup *cleanups;
717 PyObject *result = NULL;
718 PyObject *return_result = NULL;
719 PyObject *unparsed = NULL;
720 volatile struct gdb_exception except;
722 if (! PyArg_ParseTuple (args, "|s", &arg))
725 cleanups = make_cleanup (null_cleanup, NULL);
728 TRY_CATCH (except, RETURN_MASK_ALL)
732 copy = xstrdup (arg);
734 sals = decode_line_1 (©, 0, 0, 0);
738 set_default_source_symtab_and_line ();
739 sal = get_current_source_symtab_and_line ();
745 if (sals.sals != NULL && sals.sals != &sal)
747 make_cleanup (xfree, copy_to_free);
748 make_cleanup (xfree, sals.sals);
751 if (except.reason < 0)
753 do_cleanups (cleanups);
754 /* We know this will always throw. */
755 gdbpy_convert_exception (except);
763 result = PyTuple_New (sals.nelts);
766 for (i = 0; i < sals.nelts; ++i)
770 obj = symtab_and_line_to_sal_object (sals.sals[i]);
777 PyTuple_SetItem (result, i, obj);
786 return_result = PyTuple_New (2);
793 if (copy && strlen (copy) > 0)
795 unparsed = PyString_FromString (copy);
796 if (unparsed == NULL)
799 Py_DECREF (return_result);
800 return_result = NULL;
810 PyTuple_SetItem (return_result, 0, unparsed);
811 PyTuple_SetItem (return_result, 1, result);
814 do_cleanups (cleanups);
816 return return_result;
819 /* Parse a string and evaluate it as an expression. */
821 gdbpy_parse_and_eval (PyObject *self, PyObject *args)
823 const char *expr_str;
824 struct value *result = NULL;
825 volatile struct gdb_exception except;
827 if (!PyArg_ParseTuple (args, "s", &expr_str))
830 TRY_CATCH (except, RETURN_MASK_ALL)
832 result = parse_and_eval (expr_str);
834 GDB_PY_HANDLE_EXCEPTION (except);
836 return value_to_value_object (result);
839 /* Implementation of gdb.find_pc_line function.
840 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
843 gdbpy_find_pc_line (PyObject *self, PyObject *args)
845 gdb_py_ulongest pc_llu;
846 volatile struct gdb_exception except;
847 PyObject *result = NULL; /* init for gcc -Wall */
849 if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu))
852 TRY_CATCH (except, RETURN_MASK_ALL)
854 struct symtab_and_line sal;
857 pc = (CORE_ADDR) pc_llu;
858 sal = find_pc_line (pc, 0);
859 result = symtab_and_line_to_sal_object (sal);
861 GDB_PY_HANDLE_EXCEPTION (except);
866 /* Read a file as Python code.
867 This is the extension_language_script_ops.script_sourcer "method".
868 FILE is the file to load. FILENAME is name of the file FILE.
869 This does not throw any errors. If an exception occurs python will print
870 the traceback and clear the error indicator. */
873 gdbpy_source_script (const struct extension_language_defn *extlang,
874 FILE *file, const char *filename)
876 struct cleanup *cleanup;
878 cleanup = ensure_python_env (get_current_arch (), current_language);
879 python_run_simple_file (file, filename);
880 do_cleanups (cleanup);
885 /* Posting and handling events. */
887 /* A single event. */
890 /* The Python event. This is just a callable object. */
892 /* The next event. */
893 struct gdbpy_event *next;
896 /* All pending events. */
897 static struct gdbpy_event *gdbpy_event_list;
898 /* The final link of the event list. */
899 static struct gdbpy_event **gdbpy_event_list_end;
901 /* We use a file handler, and not an async handler, so that we can
902 wake up the main thread even when it is blocked in poll(). */
903 static struct serial *gdbpy_event_fds[2];
905 /* The file handler callback. This reads from the internal pipe, and
906 then processes the Python event queue. This will always be run in
907 the main gdb thread. */
910 gdbpy_run_events (struct serial *scb, void *context)
912 struct cleanup *cleanup;
914 cleanup = ensure_python_env (get_current_arch (), current_language);
916 /* Flush the fd. Do this before flushing the events list, so that
917 any new event post afterwards is sure to re-awake the event
919 while (serial_readchar (gdbpy_event_fds[0], 0) >= 0)
922 while (gdbpy_event_list)
924 PyObject *call_result;
926 /* Dispatching the event might push a new element onto the event
927 loop, so we update here "atomically enough". */
928 struct gdbpy_event *item = gdbpy_event_list;
929 gdbpy_event_list = gdbpy_event_list->next;
930 if (gdbpy_event_list == NULL)
931 gdbpy_event_list_end = &gdbpy_event_list;
934 call_result = PyObject_CallObject (item->event, NULL);
935 if (call_result == NULL)
938 Py_XDECREF (call_result);
939 Py_DECREF (item->event);
943 do_cleanups (cleanup);
946 /* Submit an event to the gdb thread. */
948 gdbpy_post_event (PyObject *self, PyObject *args)
950 struct gdbpy_event *event;
954 if (!PyArg_ParseTuple (args, "O", &func))
957 if (!PyCallable_Check (func))
959 PyErr_SetString (PyExc_RuntimeError,
960 _("Posted event is not callable"));
966 /* From here until the end of the function, we have the GIL, so we
967 can operate on our global data structures without worrying. */
968 wakeup = gdbpy_event_list == NULL;
970 event = XNEW (struct gdbpy_event);
973 *gdbpy_event_list_end = event;
974 gdbpy_event_list_end = &event->next;
976 /* Wake up gdb when needed. */
979 char c = 'q'; /* Anything. */
981 if (serial_write (gdbpy_event_fds[1], &c, 1))
982 return PyErr_SetFromErrno (PyExc_IOError);
988 /* Initialize the Python event handler. */
990 gdbpy_initialize_events (void)
992 if (serial_pipe (gdbpy_event_fds) == 0)
994 gdbpy_event_list_end = &gdbpy_event_list;
995 serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL);
1003 /* This is the extension_language_ops.before_prompt "method". */
1005 static enum ext_lang_rc
1006 gdbpy_before_prompt_hook (const struct extension_language_defn *extlang,
1007 const char *current_gdb_prompt)
1009 struct cleanup *cleanup;
1010 char *prompt = NULL;
1012 if (!gdb_python_initialized)
1013 return EXT_LANG_RC_NOP;
1015 cleanup = ensure_python_env (get_current_arch (), current_language);
1017 if (gdb_python_module
1018 && PyObject_HasAttrString (gdb_python_module, "prompt_hook"))
1022 hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook");
1026 make_cleanup_py_decref (hook);
1028 if (PyCallable_Check (hook))
1031 PyObject *current_prompt;
1033 current_prompt = PyString_FromString (current_gdb_prompt);
1034 if (current_prompt == NULL)
1037 result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL);
1039 Py_DECREF (current_prompt);
1044 make_cleanup_py_decref (result);
1046 /* Return type should be None, or a String. If it is None,
1047 fall through, we will not set a prompt. If it is a
1048 string, set PROMPT. Anything else, set an exception. */
1049 if (result != Py_None && ! PyString_Check (result))
1051 PyErr_Format (PyExc_RuntimeError,
1052 _("Return from prompt_hook must " \
1053 "be either a Python string, or None"));
1057 if (result != Py_None)
1059 prompt = python_string_to_host_string (result);
1064 make_cleanup (xfree, prompt);
1069 /* If a prompt has been set, PROMPT will not be NULL. If it is
1070 NULL, do not set the prompt. */
1072 set_prompt (prompt);
1074 do_cleanups (cleanup);
1075 return prompt != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_NOP;
1078 gdbpy_print_stack ();
1079 do_cleanups (cleanup);
1080 return EXT_LANG_RC_ERROR;
1087 /* A python function to write a single string using gdb's filtered
1088 output stream . The optional keyword STREAM can be used to write
1089 to a particular stream. The default stream is to gdb_stdout. */
1092 gdbpy_write (PyObject *self, PyObject *args, PyObject *kw)
1095 static char *keywords[] = {"text", "stream", NULL };
1096 int stream_type = 0;
1097 volatile struct gdb_exception except;
1099 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
1103 TRY_CATCH (except, RETURN_MASK_ALL)
1105 switch (stream_type)
1109 fprintf_filtered (gdb_stderr, "%s", arg);
1114 fprintf_filtered (gdb_stdlog, "%s", arg);
1118 fprintf_filtered (gdb_stdout, "%s", arg);
1121 GDB_PY_HANDLE_EXCEPTION (except);
1126 /* A python function to flush a gdb stream. The optional keyword
1127 STREAM can be used to flush a particular stream. The default stream
1131 gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw)
1133 static char *keywords[] = {"stream", NULL };
1134 int stream_type = 0;
1136 if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
1140 switch (stream_type)
1144 gdb_flush (gdb_stderr);
1149 gdb_flush (gdb_stdlog);
1153 gdb_flush (gdb_stdout);
1159 /* Print a python exception trace, print just a message, or print
1160 nothing and clear the python exception, depending on
1161 gdbpy_should_print_stack. Only call this if a python exception is
1164 gdbpy_print_stack (void)
1166 volatile struct gdb_exception except;
1168 /* Print "none", just clear exception. */
1169 if (gdbpy_should_print_stack == python_excp_none)
1173 /* Print "full" message and backtrace. */
1174 else if (gdbpy_should_print_stack == python_excp_full)
1177 /* PyErr_Print doesn't necessarily end output with a newline.
1178 This works because Python's stdout/stderr is fed through
1180 TRY_CATCH (except, RETURN_MASK_ALL)
1185 /* Print "message", just error print message. */
1188 PyObject *ptype, *pvalue, *ptraceback;
1189 char *msg = NULL, *type = NULL;
1191 PyErr_Fetch (&ptype, &pvalue, &ptraceback);
1193 /* Fetch the error message contained within ptype, pvalue. */
1194 msg = gdbpy_exception_to_string (ptype, pvalue);
1195 type = gdbpy_obj_to_string (ptype);
1197 TRY_CATCH (except, RETURN_MASK_ALL)
1201 /* An error occurred computing the string representation of the
1203 fprintf_filtered (gdb_stderr,
1204 _("Error occurred computing Python error" \
1208 fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
1213 Py_XDECREF (pvalue);
1214 Py_XDECREF (ptraceback);
1221 /* Return the current Progspace.
1222 There always is one. */
1225 gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2)
1229 result = pspace_to_pspace_object (current_program_space);
1235 /* Return a sequence holding all the Progspaces. */
1238 gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
1240 struct program_space *ps;
1243 list = PyList_New (0);
1249 PyObject *item = pspace_to_pspace_object (ps);
1251 if (!item || PyList_Append (list, item) == -1)
1263 /* The "current" objfile. This is set when gdb detects that a new
1264 objfile has been loaded. It is only set for the duration of a call to
1265 gdbpy_source_objfile_script; it is NULL at other times. */
1266 static struct objfile *gdbpy_current_objfile;
1268 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1269 as Python code. This does not throw any errors. If an exception
1270 occurs python will print the traceback and clear the error indicator.
1271 This is the extension_language_script_ops.objfile_script_sourcer
1275 gdbpy_source_objfile_script (const struct extension_language_defn *extlang,
1276 struct objfile *objfile, FILE *file,
1277 const char *filename)
1279 struct cleanup *cleanups;
1281 if (!gdb_python_initialized)
1284 cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
1285 gdbpy_current_objfile = objfile;
1287 python_run_simple_file (file, filename);
1289 do_cleanups (cleanups);
1290 gdbpy_current_objfile = NULL;
1293 /* Return the current Objfile, or None if there isn't one. */
1296 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
1300 if (! gdbpy_current_objfile)
1303 result = objfile_to_objfile_object (gdbpy_current_objfile);
1309 /* Return a sequence holding all the Objfiles. */
1312 gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
1314 struct objfile *objf;
1317 list = PyList_New (0);
1323 PyObject *item = objfile_to_objfile_object (objf);
1325 if (!item || PyList_Append (list, item) == -1)
1335 /* Compute the list of active python type printers and store them in
1336 EXT_PRINTERS->py_type_printers. The product of this function is used by
1337 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1338 This is the extension_language_ops.start_type_printers "method". */
1341 gdbpy_start_type_printers (const struct extension_language_defn *extlang,
1342 struct ext_lang_type_printers *ext_printers)
1344 struct cleanup *cleanups;
1345 PyObject *type_module, *func = NULL, *printers_obj = NULL;
1347 if (!gdb_python_initialized)
1350 cleanups = ensure_python_env (get_current_arch (), current_language);
1352 type_module = PyImport_ImportModule ("gdb.types");
1353 if (type_module == NULL)
1355 gdbpy_print_stack ();
1359 func = PyObject_GetAttrString (type_module, "get_type_recognizers");
1362 gdbpy_print_stack ();
1366 printers_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
1367 if (printers_obj == NULL)
1368 gdbpy_print_stack ();
1370 ext_printers->py_type_printers = printers_obj;
1373 Py_XDECREF (type_module);
1375 do_cleanups (cleanups);
1378 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1379 a newly allocated string holding the type's replacement name, and return
1380 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1381 If there's a Python error return EXT_LANG_RC_ERROR.
1382 Otherwise, return EXT_LANG_RC_NOP.
1383 This is the extension_language_ops.apply_type_printers "method". */
1385 static enum ext_lang_rc
1386 gdbpy_apply_type_printers (const struct extension_language_defn *extlang,
1387 const struct ext_lang_type_printers *ext_printers,
1388 struct type *type, char **prettied_type)
1390 struct cleanup *cleanups;
1391 PyObject *type_obj, *type_module = NULL, *func = NULL;
1392 PyObject *result_obj = NULL;
1393 PyObject *printers_obj = ext_printers->py_type_printers;
1394 char *result = NULL;
1396 if (printers_obj == NULL)
1397 return EXT_LANG_RC_NOP;
1399 if (!gdb_python_initialized)
1400 return EXT_LANG_RC_NOP;
1402 cleanups = ensure_python_env (get_current_arch (), current_language);
1404 type_obj = type_to_type_object (type);
1405 if (type_obj == NULL)
1407 gdbpy_print_stack ();
1411 type_module = PyImport_ImportModule ("gdb.types");
1412 if (type_module == NULL)
1414 gdbpy_print_stack ();
1418 func = PyObject_GetAttrString (type_module, "apply_type_recognizers");
1421 gdbpy_print_stack ();
1425 result_obj = PyObject_CallFunctionObjArgs (func, printers_obj,
1426 type_obj, (char *) NULL);
1427 if (result_obj == NULL)
1429 gdbpy_print_stack ();
1433 if (result_obj != Py_None)
1435 result = python_string_to_host_string (result_obj);
1437 gdbpy_print_stack ();
1441 Py_XDECREF (type_obj);
1442 Py_XDECREF (type_module);
1444 Py_XDECREF (result_obj);
1445 do_cleanups (cleanups);
1447 *prettied_type = result;
1448 return result != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_ERROR;
1451 /* Free the result of start_type_printers.
1452 This is the extension_language_ops.free_type_printers "method". */
1455 gdbpy_free_type_printers (const struct extension_language_defn *extlang,
1456 struct ext_lang_type_printers *ext_printers)
1458 struct cleanup *cleanups;
1459 PyObject *printers = ext_printers->py_type_printers;
1461 if (printers == NULL)
1464 if (!gdb_python_initialized)
1467 cleanups = ensure_python_env (get_current_arch (), current_language);
1468 Py_DECREF (printers);
1469 do_cleanups (cleanups);
1472 #else /* HAVE_PYTHON */
1474 /* Dummy implementation of the gdb "python-interactive" and "python"
1478 python_interactive_command (char *arg, int from_tty)
1480 arg = skip_spaces (arg);
1482 error (_("Python scripting is not supported in this copy of GDB."));
1485 struct command_line *l = get_command_line (python_control, "");
1486 struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
1488 execute_control_command_untraced (l);
1489 do_cleanups (cleanups);
1494 python_command (char *arg, int from_tty)
1496 python_interactive_command (arg, from_tty);
1499 #endif /* HAVE_PYTHON */
1503 /* Lists for 'set python' commands. */
1505 static struct cmd_list_element *user_set_python_list;
1506 static struct cmd_list_element *user_show_python_list;
1508 /* Function for use by 'set python' prefix command. */
1511 user_set_python (char *args, int from_tty)
1513 help_list (user_set_python_list, "set python ", all_commands,
1517 /* Function for use by 'show python' prefix command. */
1520 user_show_python (char *args, int from_tty)
1522 cmd_show_list (user_show_python_list, from_tty, "");
1525 /* Initialize the Python code. */
1529 /* This is installed as a final cleanup and cleans up the
1530 interpreter. This lets Python's 'atexit' work. */
1533 finalize_python (void *ignore)
1535 struct active_ext_lang_state *previous_active;
1537 /* We don't use ensure_python_env here because if we ever ran the
1538 cleanup, gdb would crash -- because the cleanup calls into the
1539 Python interpreter, which we are about to destroy. It seems
1540 clearer to make the needed calls explicitly here than to create a
1541 cleanup and then mysteriously discard it. */
1543 /* This is only called as a final cleanup so we can assume the active
1544 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1545 previous_active = set_active_ext_lang (&extension_language_python);
1547 (void) PyGILState_Ensure ();
1548 python_gdbarch = target_gdbarch ();
1549 python_language = current_language;
1553 restore_active_ext_lang (previous_active);
1557 /* Provide a prototype to silence -Wmissing-prototypes. */
1558 extern initialize_file_ftype _initialize_python;
1561 _initialize_python (void)
1566 size_t progsize, count;
1568 wchar_t *progname_copy;
1571 add_com ("python-interactive", class_obscure,
1572 python_interactive_command,
1575 Start an interactive Python prompt.\n\
1577 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1580 Alternatively, a single-line Python command can be given as an\n\
1581 argument, and if the command is an expression, the result will be\n\
1582 printed. For example:\n\
1584 (gdb) python-interactive 2 + 3\n\
1587 #else /* HAVE_PYTHON */
1589 Start a Python interactive prompt.\n\
1591 Python scripting is not supported in this copy of GDB.\n\
1592 This command is only a placeholder.")
1593 #endif /* HAVE_PYTHON */
1595 add_com_alias ("pi", "python-interactive", class_obscure, 1);
1597 add_com ("python", class_obscure, python_command,
1600 Evaluate a Python command.\n\
1602 The command can be given as an argument, for instance:\n\
1606 If no argument is given, the following lines are read and used\n\
1607 as the Python commands. Type a line containing \"end\" to indicate\n\
1608 the end of the command.")
1609 #else /* HAVE_PYTHON */
1611 Evaluate a Python command.\n\
1613 Python scripting is not supported in this copy of GDB.\n\
1614 This command is only a placeholder.")
1615 #endif /* HAVE_PYTHON */
1617 add_com_alias ("py", "python", class_obscure, 1);
1619 /* Add set/show python print-stack. */
1620 add_prefix_cmd ("python", no_class, user_show_python,
1621 _("Prefix command for python preference settings."),
1622 &user_show_python_list, "show python ", 0,
1625 add_prefix_cmd ("python", no_class, user_set_python,
1626 _("Prefix command for python preference settings."),
1627 &user_set_python_list, "set python ", 0,
1630 add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums,
1631 &gdbpy_should_print_stack, _("\
1632 Set mode for Python stack dump on error."), _("\
1633 Show the mode of Python stack printing on error."), _("\
1634 none == no stack or message will be printed.\n\
1635 full == a message and a stack will be printed.\n\
1636 message == an error message without a stack will be printed."),
1638 &user_set_python_list,
1639 &user_show_python_list);
1642 #ifdef WITH_PYTHON_PATH
1643 /* Work around problem where python gets confused about where it is,
1644 and then can't find its libraries, etc.
1645 NOTE: Python assumes the following layout:
1647 /foo/lib/pythonX.Y/...
1648 This must be done before calling Py_Initialize. */
1649 progname = concat (ldirname (python_libdir), SLASH_STRING, "bin",
1650 SLASH_STRING, "python", NULL);
1652 oldloc = setlocale (LC_ALL, NULL);
1653 setlocale (LC_ALL, "");
1654 progsize = strlen (progname);
1655 if (progsize == (size_t) -1)
1657 fprintf (stderr, "Could not convert python path to string\n");
1660 progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t));
1663 fprintf (stderr, "out of memory\n");
1666 count = mbstowcs (progname_copy, progname, progsize + 1);
1667 if (count == (size_t) -1)
1669 fprintf (stderr, "Could not convert python path to string\n");
1672 setlocale (LC_ALL, oldloc);
1674 /* Note that Py_SetProgramName expects the string it is passed to
1675 remain alive for the duration of the program's execution, so
1676 it is not freed after this call. */
1677 Py_SetProgramName (progname_copy);
1679 Py_SetProgramName (progname);
1684 PyEval_InitThreads ();
1687 gdb_module = PyModule_Create (&GdbModuleDef);
1688 /* Add _gdb module to the list of known built-in modules. */
1689 _PyImport_FixupBuiltin (gdb_module, "_gdb");
1691 gdb_module = Py_InitModule ("_gdb", GdbMethods);
1693 if (gdb_module == NULL)
1696 /* The casts to (char*) are for python 2.4. */
1697 if (PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version) < 0
1698 || PyModule_AddStringConstant (gdb_module, "HOST_CONFIG",
1699 (char*) host_name) < 0
1700 || PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
1701 (char*) target_name) < 0)
1704 /* Add stream constants. */
1705 if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0
1706 || PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0
1707 || PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0)
1710 gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
1711 if (gdbpy_gdb_error == NULL
1712 || gdb_pymodule_addobject (gdb_module, "error", gdbpy_gdb_error) < 0)
1715 gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
1716 gdbpy_gdb_error, NULL);
1717 if (gdbpy_gdb_memory_error == NULL
1718 || gdb_pymodule_addobject (gdb_module, "MemoryError",
1719 gdbpy_gdb_memory_error) < 0)
1722 gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
1723 if (gdbpy_gdberror_exc == NULL
1724 || gdb_pymodule_addobject (gdb_module, "GdbError",
1725 gdbpy_gdberror_exc) < 0)
1728 gdbpy_initialize_gdb_readline ();
1730 if (gdbpy_initialize_auto_load () < 0
1731 || gdbpy_initialize_values () < 0
1732 || gdbpy_initialize_frames () < 0
1733 || gdbpy_initialize_commands () < 0
1734 || gdbpy_initialize_symbols () < 0
1735 || gdbpy_initialize_symtabs () < 0
1736 || gdbpy_initialize_blocks () < 0
1737 || gdbpy_initialize_functions () < 0
1738 || gdbpy_initialize_parameters () < 0
1739 || gdbpy_initialize_types () < 0
1740 || gdbpy_initialize_pspace () < 0
1741 || gdbpy_initialize_objfile () < 0
1742 || gdbpy_initialize_breakpoints () < 0
1743 || gdbpy_initialize_finishbreakpoints () < 0
1744 || gdbpy_initialize_lazy_string () < 0
1745 || gdbpy_initialize_linetable () < 0
1746 || gdbpy_initialize_thread () < 0
1747 || gdbpy_initialize_inferior () < 0
1748 || gdbpy_initialize_events () < 0
1749 || gdbpy_initialize_eventregistry () < 0
1750 || gdbpy_initialize_py_events () < 0
1751 || gdbpy_initialize_event () < 0
1752 || gdbpy_initialize_stop_event () < 0
1753 || gdbpy_initialize_signal_event () < 0
1754 || gdbpy_initialize_breakpoint_event () < 0
1755 || gdbpy_initialize_continue_event () < 0
1756 || gdbpy_initialize_exited_event () < 0
1757 || gdbpy_initialize_thread_event () < 0
1758 || gdbpy_initialize_new_objfile_event () < 0
1759 || gdbpy_initialize_arch () < 0
1760 || gdbpy_initialize_xmethods () < 0)
1763 gdbpy_to_string_cst = PyString_FromString ("to_string");
1764 if (gdbpy_to_string_cst == NULL)
1766 gdbpy_children_cst = PyString_FromString ("children");
1767 if (gdbpy_children_cst == NULL)
1769 gdbpy_display_hint_cst = PyString_FromString ("display_hint");
1770 if (gdbpy_display_hint_cst == NULL)
1772 gdbpy_doc_cst = PyString_FromString ("__doc__");
1773 if (gdbpy_doc_cst == NULL)
1775 gdbpy_enabled_cst = PyString_FromString ("enabled");
1776 if (gdbpy_enabled_cst == NULL)
1778 gdbpy_value_cst = PyString_FromString ("value");
1779 if (gdbpy_value_cst == NULL)
1782 /* Release the GIL while gdb runs. */
1783 PyThreadState_Swap (NULL);
1784 PyEval_ReleaseLock ();
1786 make_final_cleanup (finalize_python, NULL);
1788 gdb_python_initialized = 1;
1792 gdbpy_print_stack ();
1793 /* Do not set 'gdb_python_initialized'. */
1796 #endif /* HAVE_PYTHON */
1801 /* Perform the remaining python initializations.
1802 These must be done after GDB is at least mostly initialized.
1803 E.g., The "info pretty-printer" command needs the "info" prefix
1805 This is the extension_language_ops.finish_initialization "method". */
1808 gdbpy_finish_initialization (const struct extension_language_defn *extlang)
1811 char *gdb_pythondir;
1813 struct cleanup *cleanup;
1815 cleanup = ensure_python_env (get_current_arch (), current_language);
1817 /* Add the initial data-directory to sys.path. */
1819 gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
1820 make_cleanup (xfree, gdb_pythondir);
1822 sys_path = PySys_GetObject ("path");
1824 /* If sys.path is not defined yet, define it first. */
1825 if (!(sys_path && PyList_Check (sys_path)))
1828 PySys_SetPath (L"");
1832 sys_path = PySys_GetObject ("path");
1834 if (sys_path && PyList_Check (sys_path))
1836 PyObject *pythondir;
1839 pythondir = PyString_FromString (gdb_pythondir);
1840 if (pythondir == NULL)
1843 err = PyList_Insert (sys_path, 0, pythondir);
1844 Py_DECREF (pythondir);
1851 /* Import the gdb module to finish the initialization, and
1852 add it to __main__ for convenience. */
1853 m = PyImport_AddModule ("__main__");
1857 gdb_python_module = PyImport_ImportModule ("gdb");
1858 if (gdb_python_module == NULL)
1860 gdbpy_print_stack ();
1861 /* This is passed in one call to warning so that blank lines aren't
1862 inserted between each line of text. */
1864 "Could not load the Python gdb module from `%s'.\n"
1865 "Limited Python support is available from the _gdb module.\n"
1866 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1868 do_cleanups (cleanup);
1872 if (gdb_pymodule_addobject (m, "gdb", gdb_python_module) < 0)
1875 /* Keep the reference to gdb_python_module since it is in a global
1878 do_cleanups (cleanup);
1882 gdbpy_print_stack ();
1883 warning (_("internal error: Unhandled Python exception"));
1884 do_cleanups (cleanup);
1887 /* Return non-zero if Python has successfully initialized.
1888 This is the extension_languages_ops.initialized "method". */
1891 gdbpy_initialized (const struct extension_language_defn *extlang)
1893 return gdb_python_initialized;
1896 #endif /* HAVE_PYTHON */
1902 static PyMethodDef GdbMethods[] =
1904 { "history", gdbpy_history, METH_VARARGS,
1905 "Get a value from history" },
1906 { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
1907 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1908 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1909 a Python String containing the output of the command if to_string is\n\
1911 { "parameter", gdbpy_parameter, METH_VARARGS,
1912 "Return a gdb parameter's value" },
1914 { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
1915 "Return a tuple of all breakpoint objects" },
1917 { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
1918 "Find the default visualizer for a Value." },
1920 { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS,
1921 "Return the current Progspace." },
1922 { "progspaces", gdbpy_progspaces, METH_NOARGS,
1923 "Return a sequence of all progspaces." },
1925 { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
1926 "Return the current Objfile being loaded, or None." },
1927 { "objfiles", gdbpy_objfiles, METH_NOARGS,
1928 "Return a sequence of all loaded objfiles." },
1930 { "newest_frame", gdbpy_newest_frame, METH_NOARGS,
1931 "newest_frame () -> gdb.Frame.\n\
1932 Return the newest frame object." },
1933 { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
1934 "selected_frame () -> gdb.Frame.\n\
1935 Return the selected frame object." },
1936 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
1937 "stop_reason_string (Integer) -> String.\n\
1938 Return a string explaining unwind stop reason." },
1940 { "lookup_type", (PyCFunction) gdbpy_lookup_type,
1941 METH_VARARGS | METH_KEYWORDS,
1942 "lookup_type (name [, block]) -> type\n\
1943 Return a Type corresponding to the given name." },
1944 { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
1945 METH_VARARGS | METH_KEYWORDS,
1946 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1947 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1948 a boolean indicating if name is a field of the current implied argument\n\
1949 `this' (when the current language is object-oriented)." },
1950 { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol,
1951 METH_VARARGS | METH_KEYWORDS,
1952 "lookup_global_symbol (name [, domain]) -> symbol\n\
1953 Return the symbol corresponding to the given name (or None)." },
1954 { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
1955 "Return the block containing the given pc value, or None." },
1956 { "solib_name", gdbpy_solib_name, METH_VARARGS,
1957 "solib_name (Long) -> String.\n\
1958 Return the name of the shared library holding a given address, or None." },
1959 { "decode_line", gdbpy_decode_line, METH_VARARGS,
1960 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1961 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1962 The first element contains any unparsed portion of the String parameter\n\
1963 (or None if the string was fully parsed). The second element contains\n\
1964 a tuple that contains all the locations that match, represented as\n\
1965 gdb.Symtab_and_line objects (or None)."},
1966 { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
1967 "parse_and_eval (String) -> Value.\n\
1968 Parse String as an expression, evaluate it, and return the result as a Value."
1970 { "find_pc_line", gdbpy_find_pc_line, METH_VARARGS,
1971 "find_pc_line (pc) -> Symtab_and_line.\n\
1972 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1974 { "post_event", gdbpy_post_event, METH_VARARGS,
1975 "Post an event into gdb's event loop." },
1977 { "target_charset", gdbpy_target_charset, METH_NOARGS,
1978 "target_charset () -> string.\n\
1979 Return the name of the current target charset." },
1980 { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
1981 "target_wide_charset () -> string.\n\
1982 Return the name of the current target wide charset." },
1984 { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS,
1985 "string_to_argv (String) -> Array.\n\
1986 Parse String and return an argv-like array.\n\
1987 Arguments are separate by spaces and may be quoted."
1989 { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS,
1990 "Write a string using gdb's filtered stream." },
1991 { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS,
1992 "Flush gdb's filtered stdout stream." },
1993 { "selected_thread", gdbpy_selected_thread, METH_NOARGS,
1994 "selected_thread () -> gdb.InferiorThread.\n\
1995 Return the selected thread object." },
1996 { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS,
1997 "selected_inferior () -> gdb.Inferior.\n\
1998 Return the selected inferior object." },
1999 { "inferiors", gdbpy_inferiors, METH_NOARGS,
2000 "inferiors () -> (gdb.Inferior, ...).\n\
2001 Return a tuple containing all inferiors." },
2002 {NULL, NULL, 0, NULL}
2006 static struct PyModuleDef GdbModuleDef =
2008 PyModuleDef_HEAD_INIT,
2019 #endif /* HAVE_PYTHON */