1 /* General python/gdb code
3 Copyright (C) 2008, 2009 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/>. */
23 #include "cli/cli-script.h"
28 /* True if we should print the stack when catching a Python error,
30 static int gdbpy_should_print_stack
= 1;
35 #include "libiberty.h"
36 #include "cli/cli-decode.h"
39 #include "exceptions.h"
40 #include "python-internal.h"
43 #include "gdbthread.h"
45 static PyMethodDef GdbMethods
[];
49 PyObject
*gdbpy_doc_cst
;
51 /* Given a command_line, return a command string suitable for passing
52 to Python. Lines in the string are separated by newlines. The
53 return value is allocated using xmalloc and the caller is
54 responsible for freeing it. */
57 compute_python_string (struct command_line
*l
)
59 struct command_line
*iter
;
64 for (iter
= l
; iter
; iter
= iter
->next
)
65 size
+= strlen (iter
->line
) + 1;
67 script
= xmalloc (size
+ 1);
69 for (iter
= l
; iter
; iter
= iter
->next
)
71 int len
= strlen (iter
->line
);
72 strcpy (&script
[here
], iter
->line
);
74 script
[here
++] = '\n';
80 /* Take a command line structure representing a 'python' command, and
81 evaluate its body using the Python interpreter. */
84 eval_python_from_control_command (struct command_line
*cmd
)
88 struct cleanup
*cleanup
;
89 PyGILState_STATE state
;
91 if (cmd
->body_count
!= 1)
92 error (_("Invalid \"python\" block structure."));
94 state
= PyGILState_Ensure ();
95 cleanup
= make_cleanup_py_restore_gil (&state
);
97 script
= compute_python_string (cmd
->body_list
[0]);
98 ret
= PyRun_SimpleString (script
);
102 gdbpy_print_stack ();
103 error (_("Error while executing Python code."));
106 do_cleanups (cleanup
);
109 /* Implementation of the gdb "python" command. */
112 python_command (char *arg
, int from_tty
)
114 struct cleanup
*cleanup
;
115 PyGILState_STATE state
;
117 state
= PyGILState_Ensure ();
118 cleanup
= make_cleanup_py_restore_gil (&state
);
120 while (arg
&& *arg
&& isspace (*arg
))
124 if (PyRun_SimpleString (arg
))
126 gdbpy_print_stack ();
127 error (_("Error while executing Python code."));
132 struct command_line
*l
= get_command_line (python_control
, "");
133 make_cleanup_free_command_lines (&l
);
134 execute_control_command_untraced (l
);
137 do_cleanups (cleanup
);
142 /* Transform a gdb parameters's value into a Python value. May return
143 NULL (and set a Python exception) on error. Helper function for
147 parameter_to_python (struct cmd_list_element
*cmd
)
149 switch (cmd
->var_type
)
152 case var_string_noescape
:
153 case var_optional_filename
:
157 char *str
= * (char **) cmd
->var
;
160 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
165 if (* (int *) cmd
->var
)
171 case var_auto_boolean
:
173 enum auto_boolean ab
= * (enum auto_boolean
*) cmd
->var
;
174 if (ab
== AUTO_BOOLEAN_TRUE
)
176 else if (ab
== AUTO_BOOLEAN_FALSE
)
183 if ((* (int *) cmd
->var
) == INT_MAX
)
187 return PyLong_FromLong (* (int *) cmd
->var
);
191 unsigned int val
= * (unsigned int *) cmd
->var
;
194 return PyLong_FromUnsignedLong (val
);
198 return PyErr_Format (PyExc_RuntimeError
, "programmer error: unhandled type");
201 /* A Python function which returns a gdb parameter's value as a Python
205 get_parameter (PyObject
*self
, PyObject
*args
)
207 struct cmd_list_element
*alias
, *prefix
, *cmd
;
210 volatile struct gdb_exception except
;
212 if (! PyArg_ParseTuple (args
, "s", &arg
))
215 newarg
= concat ("show ", arg
, (char *) NULL
);
217 TRY_CATCH (except
, RETURN_MASK_ALL
)
219 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
222 GDB_PY_HANDLE_EXCEPTION (except
);
224 return PyErr_Format (PyExc_RuntimeError
,
225 "could not find parameter `%s'", arg
);
228 return PyErr_Format (PyExc_RuntimeError
, "`%s' is not a variable", arg
);
229 return parameter_to_python (cmd
);
232 /* A Python function which evaluates a string using the gdb CLI. */
235 execute_gdb_command (PyObject
*self
, PyObject
*args
)
237 struct cmd_list_element
*alias
, *prefix
, *cmd
;
239 PyObject
*from_tty_obj
= NULL
;
242 volatile struct gdb_exception except
;
244 if (! PyArg_ParseTuple (args
, "s|O!", &arg
, &PyBool_Type
, &from_tty_obj
))
250 cmp
= PyObject_IsTrue (from_tty_obj
);
256 TRY_CATCH (except
, RETURN_MASK_ALL
)
258 execute_command (arg
, from_tty
);
260 GDB_PY_HANDLE_EXCEPTION (except
);
262 /* Do any commands attached to breakpoint we stopped at. */
263 bpstat_do_actions ();
272 /* A python function to write a single string using gdb's filtered
275 gdbpy_write (PyObject
*self
, PyObject
*args
)
278 if (! PyArg_ParseTuple (args
, "s", &arg
))
280 printf_filtered ("%s", arg
);
284 /* A python function to flush gdb's filtered output stream. */
286 gdbpy_flush (PyObject
*self
, PyObject
*args
)
288 gdb_flush (gdb_stdout
);
292 /* Print a python exception trace, or print nothing and clear the
293 python exception, depending on gdbpy_should_print_stack. Only call
294 this if a python exception is set. */
296 gdbpy_print_stack (void)
298 if (gdbpy_should_print_stack
)
304 #else /* HAVE_PYTHON */
306 /* Dummy implementation of the gdb "python" command. */
309 python_command (char *arg
, int from_tty
)
311 while (arg
&& *arg
&& isspace (*arg
))
314 error (_("Python scripting is not supported in this copy of GDB."));
317 struct command_line
*l
= get_command_line (python_control
, "");
318 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
319 execute_control_command_untraced (l
);
320 do_cleanups (cleanups
);
325 eval_python_from_control_command (struct command_line
*cmd
)
327 error (_("Python scripting is not supported in this copy of GDB."));
330 #endif /* HAVE_PYTHON */
334 /* Lists for 'maint set python' commands. */
336 static struct cmd_list_element
*set_python_list
;
337 static struct cmd_list_element
*show_python_list
;
339 /* Function for use by 'maint set python' prefix command. */
342 set_python (char *args
, int from_tty
)
344 help_list (set_python_list
, "maintenance set python ", -1, gdb_stdout
);
347 /* Function for use by 'maint show python' prefix command. */
350 show_python (char *args
, int from_tty
)
352 cmd_show_list (show_python_list
, from_tty
, "");
355 /* Initialize the Python code. */
357 /* Provide a prototype to silence -Wmissing-prototypes. */
358 extern initialize_file_ftype _initialize_python
;
361 _initialize_python (void)
363 add_com ("python", class_obscure
, python_command
,
366 Evaluate a Python command.\n\
368 The command can be given as an argument, for instance:\n\
372 If no argument is given, the following lines are read and used\n\
373 as the Python commands. Type a line containing \"end\" to indicate\n\
374 the end of the command.")
375 #else /* HAVE_PYTHON */
377 Evaluate a Python command.\n\
379 Python scripting is not supported in this copy of GDB.\n\
380 This command is only a placeholder.")
381 #endif /* HAVE_PYTHON */
384 add_prefix_cmd ("python", no_class
, show_python
,
385 _("Prefix command for python maintenance settings."),
386 &show_python_list
, "maintenance show python ", 0,
387 &maintenance_show_cmdlist
);
388 add_prefix_cmd ("python", no_class
, set_python
,
389 _("Prefix command for python maintenance settings."),
390 &set_python_list
, "maintenance set python ", 0,
391 &maintenance_set_cmdlist
);
393 add_setshow_boolean_cmd ("print-stack", class_maintenance
,
394 &gdbpy_should_print_stack
, _("\
395 Enable or disable printing of Python stack dump on error."), _("\
396 Show whether Python stack will be printed on error."), _("\
397 Enables or disables printing of Python stack traces."),
404 PyEval_InitThreads ();
406 gdb_module
= Py_InitModule ("gdb", GdbMethods
);
408 /* The casts to (char*) are for python 2.4. */
409 PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
);
410 PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", (char*) host_name
);
411 PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG", (char*) target_name
);
413 gdbpy_initialize_values ();
414 gdbpy_initialize_commands ();
415 gdbpy_initialize_functions ();
417 PyRun_SimpleString ("import gdb");
419 gdbpy_doc_cst
= PyString_FromString ("__doc__");
421 /* Create a couple objects which are used for Python's stdout and
423 PyRun_SimpleString ("\
425 class GdbOutputFile:\n\
433 def write(self, s):\n\
436 def writelines(self, iterable):\n\
437 for line in iterable:\n\
443 sys.stderr = GdbOutputFile()\n\
444 sys.stdout = GdbOutputFile()\n\
447 /* Release the GIL while gdb runs. */
448 PyThreadState_Swap (NULL
);
449 PyEval_ReleaseLock ();
451 #endif /* HAVE_PYTHON */
458 static PyMethodDef GdbMethods
[] =
460 { "history", gdbpy_history
, METH_VARARGS
,
461 "Get a value from history" },
462 { "execute", execute_gdb_command
, METH_VARARGS
,
463 "Execute a gdb command" },
464 { "get_parameter", get_parameter
, METH_VARARGS
,
465 "Return a gdb parameter's value" },
467 { "write", gdbpy_write
, METH_VARARGS
,
468 "Write a string using gdb's filtered stream." },
469 { "flush", gdbpy_flush
, METH_NOARGS
,
470 "Flush gdb's filtered stdout stream." },
472 {NULL
, NULL
, 0, NULL
}
475 #endif /* HAVE_PYTHON */