1 /* gdb commands implemented in Python
3 Copyright (C) 2008, 2009, 2010 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/>. */
22 #include "arch-utils.h"
24 #include "exceptions.h"
25 #include "python-internal.h"
28 #include "cli/cli-decode.h"
29 #include "completer.h"
32 /* Struct representing built-in completion types. */
33 struct cmdpy_completer
35 /* Python symbol name. */
37 /* Completion function. */
38 char **(*completer
) (struct cmd_list_element
*, char *, char *);
41 static struct cmdpy_completer completers
[] =
43 { "COMPLETE_NONE", noop_completer
},
44 { "COMPLETE_FILENAME", filename_completer
},
45 { "COMPLETE_LOCATION", location_completer
},
46 { "COMPLETE_COMMAND", command_completer
},
47 { "COMPLETE_SYMBOL", make_symbol_completion_list_fn
},
50 #define N_COMPLETERS (sizeof (completers) / sizeof (completers[0]))
52 /* A gdb command. For the time being only ordinary commands (not
53 set/show commands) are allowed. */
58 /* The corresponding gdb command object, or NULL if the command is
59 no longer installed. */
60 struct cmd_list_element
*command
;
62 /* A prefix command requires storage for a list of its sub-commands.
63 A pointer to this is passed to add_prefix_command, and to add_cmd
64 for sub-commands of that prefix. If this Command is not a prefix
65 command, then this field is unused. */
66 struct cmd_list_element
*sub_list
;
69 typedef struct cmdpy_object cmdpy_object
;
71 static PyTypeObject cmdpy_object_type
;
74 /* Constants used by this module. */
75 static PyObject
*invoke_cst
;
76 static PyObject
*complete_cst
;
80 /* Python function which wraps dont_repeat. */
82 cmdpy_dont_repeat (PyObject
*self
, PyObject
*args
)
90 /* Called if the gdb cmd_list_element is destroyed. */
92 cmdpy_destroyer (struct cmd_list_element
*self
, void *context
)
95 struct cleanup
*cleanup
;
97 cleanup
= ensure_python_env (get_current_arch (), current_language
);
99 /* Release our hold on the command object. */
100 cmd
= (cmdpy_object
*) context
;
104 /* We allocated the name, doc string, and perhaps the prefix
108 xfree (self
->prefixname
);
110 do_cleanups (cleanup
);
113 /* Called by gdb to invoke the command. */
115 cmdpy_function (struct cmd_list_element
*command
, char *args
, int from_tty
)
117 cmdpy_object
*obj
= (cmdpy_object
*) get_cmd_context (command
);
118 PyObject
*argobj
, *ttyobj
, *result
;
119 struct cleanup
*cleanup
;
121 cleanup
= ensure_python_env (get_current_arch (), current_language
);
124 error (_("Invalid invocation of Python command object."));
125 if (! PyObject_HasAttr ((PyObject
*) obj
, invoke_cst
))
127 if (obj
->command
->prefixname
)
129 /* A prefix command does not need an invoke method. */
130 do_cleanups (cleanup
);
133 error (_("Python command object missing 'invoke' method."));
138 argobj
= PyUnicode_Decode (args
, strlen (args
), host_charset (), NULL
);
140 error (_("Could not convert arguments to Python string."));
142 ttyobj
= from_tty
? Py_True
: Py_False
;
144 result
= PyObject_CallMethodObjArgs ((PyObject
*) obj
, invoke_cst
, argobj
,
150 PyObject
*ptype
, *pvalue
, *ptraceback
;
152 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
154 if (pvalue
&& PyString_Check (pvalue
))
156 /* Make a temporary copy of the string data. */
157 char *s
= PyString_AsString (pvalue
);
158 char *copy
= alloca (strlen (s
) + 1);
161 PyErr_Restore (ptype
, pvalue
, ptraceback
);
162 gdbpy_print_stack ();
163 error (_("Error occurred in Python command: %s"), copy
);
167 PyErr_Restore (ptype
, pvalue
, ptraceback
);
168 gdbpy_print_stack ();
169 error (_("Error occurred in Python command."));
173 do_cleanups (cleanup
);
176 /* Called by gdb for command completion. */
178 cmdpy_completer (struct cmd_list_element
*command
, char *text
, char *word
)
180 cmdpy_object
*obj
= (cmdpy_object
*) get_cmd_context (command
);
181 PyObject
*textobj
, *wordobj
, *resultobj
= NULL
;
182 char **result
= NULL
;
183 struct cleanup
*cleanup
;
185 cleanup
= ensure_python_env (get_current_arch (), current_language
);
188 error (_("Invalid invocation of Python command object."));
189 if (! PyObject_HasAttr ((PyObject
*) obj
, complete_cst
))
191 /* If there is no complete method, don't error -- instead, just
192 say that there are no completions. */
196 textobj
= PyUnicode_Decode (text
, strlen (text
), host_charset (), NULL
);
198 error (_("Could not convert argument to Python string."));
199 wordobj
= PyUnicode_Decode (word
, strlen (word
), host_charset (), NULL
);
201 error (_("Could not convert argument to Python string."));
203 resultobj
= PyObject_CallMethodObjArgs ((PyObject
*) obj
, complete_cst
,
204 textobj
, wordobj
, NULL
);
209 /* Just swallow errors here. */
213 make_cleanup_py_decref (resultobj
);
216 if (PySequence_Check (resultobj
))
218 Py_ssize_t i
, len
= PySequence_Size (resultobj
);
223 result
= (char **) xmalloc ((len
+ 1) * sizeof (char *));
224 for (i
= out
= 0; i
< len
; ++i
)
226 PyObject
*elt
= PySequence_GetItem (resultobj
, i
);
227 if (elt
== NULL
|| ! gdbpy_is_string (elt
))
229 /* Skip problem elements. */
233 result
[out
] = python_string_to_host_string (elt
);
238 else if (PyInt_Check (resultobj
))
240 /* User code may also return one of the completion constants,
241 thus requesting that sort of completion. */
242 long value
= PyInt_AsLong (resultobj
);
243 if (value
>= 0 && value
< (long) N_COMPLETERS
)
244 result
= completers
[value
].completer (command
, text
, word
);
249 do_cleanups (cleanup
);
254 /* Helper for cmdpy_init which locates the command list to use and
255 pulls out the command name.
257 TEXT is the command name list. The final word in the list is the
258 name of the new command. All earlier words must be existing prefix
261 *BASE_LIST is set to the final prefix command's list of
264 START_LIST is the list in which the search starts.
266 This function returns the xmalloc()d name of the new command. On
267 error sets the Python error and returns NULL. */
269 gdbpy_parse_command_name (char *text
,
270 struct cmd_list_element
***base_list
,
271 struct cmd_list_element
**start_list
)
273 struct cmd_list_element
*elt
;
274 int len
= strlen (text
);
279 /* Skip trailing whitespace. */
280 for (i
= len
- 1; i
>= 0 && (text
[i
] == ' ' || text
[i
] == '\t'); --i
)
284 PyErr_SetString (PyExc_RuntimeError
, _("No command name found."));
289 /* Find first character of the final word. */
290 for (; i
> 0 && (isalnum (text
[i
- 1])
291 || text
[i
- 1] == '-'
292 || text
[i
- 1] == '_');
295 result
= xmalloc (lastchar
- i
+ 2);
296 memcpy (result
, &text
[i
], lastchar
- i
+ 1);
297 result
[lastchar
- i
+ 1] = '\0';
299 /* Skip whitespace again. */
300 for (--i
; i
>= 0 && (text
[i
] == ' ' || text
[i
] == '\t'); --i
)
304 *base_list
= start_list
;
308 prefix_text
= xmalloc (i
+ 2);
309 memcpy (prefix_text
, text
, i
+ 1);
310 prefix_text
[i
+ 1] = '\0';
313 elt
= lookup_cmd_1 (&text
, *start_list
, NULL
, 1);
314 if (!elt
|| elt
== (struct cmd_list_element
*) -1)
316 PyErr_Format (PyExc_RuntimeError
, _("Could not find command prefix %s."),
326 *base_list
= elt
->prefixlist
;
330 PyErr_Format (PyExc_RuntimeError
, _("'%s' is not a prefix command."),
337 /* Object initializer; sets up gdb-side structures for command.
339 Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]).
341 NAME is the name of the command. It may consist of multiple words,
342 in which case the final word is the name of the new command, and
343 earlier words must be prefix commands.
345 COMMAND_CLASS is the kind of command. It should be one of the COMMAND_*
346 constants defined in the gdb module.
348 COMPLETER_CLASS is the kind of completer. If not given, the
349 "complete" method will be used. Otherwise, it should be one of the
350 COMPLETE_* constants defined in the gdb module.
352 If PREFIX is True, then this command is a prefix command.
354 The documentation for the command is taken from the doc string for
359 cmdpy_init (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
361 cmdpy_object
*obj
= (cmdpy_object
*) self
;
364 int completetype
= -1;
365 char *docstring
= NULL
;
366 volatile struct gdb_exception except
;
367 struct cmd_list_element
**cmd_list
;
368 char *cmd_name
, *pfx_name
;
369 static char *keywords
[] = { "name", "command_class", "completer_class",
371 PyObject
*is_prefix
= NULL
;
376 /* Note: this is apparently not documented in Python. We return
377 0 for success, -1 for failure. */
378 PyErr_Format (PyExc_RuntimeError
,
379 _("Command object already initialized."));
383 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "si|iO", keywords
, &name
, &cmdtype
,
384 &completetype
, &is_prefix
))
387 if (cmdtype
!= no_class
&& cmdtype
!= class_run
388 && cmdtype
!= class_vars
&& cmdtype
!= class_stack
389 && cmdtype
!= class_files
&& cmdtype
!= class_support
390 && cmdtype
!= class_info
&& cmdtype
!= class_breakpoint
391 && cmdtype
!= class_trace
&& cmdtype
!= class_obscure
392 && cmdtype
!= class_maintenance
)
394 PyErr_Format (PyExc_RuntimeError
, _("Invalid command class argument."));
398 if (completetype
< -1 || completetype
>= (int) N_COMPLETERS
)
400 PyErr_Format (PyExc_RuntimeError
, _("Invalid completion type argument."));
404 cmd_name
= gdbpy_parse_command_name (name
, &cmd_list
, &cmdlist
);
409 if (is_prefix
!= NULL
)
411 cmp
= PyObject_IsTrue (is_prefix
);
416 /* Make a normalized form of the command name. */
417 pfx_name
= xmalloc (strlen (name
) + 2);
423 /* Skip whitespace. */
424 while (name
[i
] == ' ' || name
[i
] == '\t')
426 /* Copy non-whitespace characters. */
427 while (name
[i
] && name
[i
] != ' ' && name
[i
] != '\t')
428 pfx_name
[out
++] = name
[i
++];
429 /* Add a single space after each word -- including the final
431 pfx_name
[out
++] = ' ';
433 pfx_name
[out
] = '\0';
438 if (PyObject_HasAttr (self
, gdbpy_doc_cst
))
440 PyObject
*ds_obj
= PyObject_GetAttr (self
, gdbpy_doc_cst
);
441 if (ds_obj
&& gdbpy_is_string (ds_obj
))
442 docstring
= python_string_to_host_string (ds_obj
);
445 docstring
= xstrdup (_("This command is not documented."));
449 TRY_CATCH (except
, RETURN_MASK_ALL
)
451 struct cmd_list_element
*cmd
;
457 /* If we have our own "invoke" method, then allow unknown
459 allow_unknown
= PyObject_HasAttr (self
, invoke_cst
);
460 cmd
= add_prefix_cmd (cmd_name
, (enum command_class
) cmdtype
,
461 NULL
, docstring
, &obj
->sub_list
,
462 pfx_name
, allow_unknown
, cmd_list
);
465 cmd
= add_cmd (cmd_name
, (enum command_class
) cmdtype
, NULL
,
466 docstring
, cmd_list
);
468 /* There appears to be no API to set this. */
469 cmd
->func
= cmdpy_function
;
470 cmd
->destroyer
= cmdpy_destroyer
;
473 set_cmd_context (cmd
, self
);
474 set_cmd_completer (cmd
, ((completetype
== -1) ? cmdpy_completer
475 : completers
[completetype
].completer
));
477 if (except
.reason
< 0)
483 PyErr_Format (except
.reason
== RETURN_QUIT
484 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
485 "%s", except
.message
);
493 /* Initialize the 'commands' code. */
495 gdbpy_initialize_commands (void)
499 if (PyType_Ready (&cmdpy_object_type
) < 0)
502 /* Note: alias and user are special; pseudo appears to be unused,
503 and there is no reason to expose tui or xdb, I think. */
504 if (PyModule_AddIntConstant (gdb_module
, "COMMAND_NONE", no_class
) < 0
505 || PyModule_AddIntConstant (gdb_module
, "COMMAND_RUNNING", class_run
) < 0
506 || PyModule_AddIntConstant (gdb_module
, "COMMAND_DATA", class_vars
) < 0
507 || PyModule_AddIntConstant (gdb_module
, "COMMAND_STACK", class_stack
) < 0
508 || PyModule_AddIntConstant (gdb_module
, "COMMAND_FILES", class_files
) < 0
509 || PyModule_AddIntConstant (gdb_module
, "COMMAND_SUPPORT",
511 || PyModule_AddIntConstant (gdb_module
, "COMMAND_STATUS", class_info
) < 0
512 || PyModule_AddIntConstant (gdb_module
, "COMMAND_BREAKPOINTS",
513 class_breakpoint
) < 0
514 || PyModule_AddIntConstant (gdb_module
, "COMMAND_TRACEPOINTS",
516 || PyModule_AddIntConstant (gdb_module
, "COMMAND_OBSCURE",
518 || PyModule_AddIntConstant (gdb_module
, "COMMAND_MAINTENANCE",
519 class_maintenance
) < 0)
522 for (i
= 0; i
< N_COMPLETERS
; ++i
)
524 if (PyModule_AddIntConstant (gdb_module
, completers
[i
].name
, i
) < 0)
528 Py_INCREF (&cmdpy_object_type
);
529 PyModule_AddObject (gdb_module
, "Command",
530 (PyObject
*) &cmdpy_object_type
);
532 invoke_cst
= PyString_FromString ("invoke");
533 complete_cst
= PyString_FromString ("complete");
538 static PyMethodDef cmdpy_object_methods
[] =
540 { "dont_repeat", cmdpy_dont_repeat
, METH_NOARGS
,
541 "Prevent command repetition when user enters empty line." },
546 static PyTypeObject cmdpy_object_type
=
548 PyObject_HEAD_INIT (NULL
)
550 "gdb.Command", /*tp_name*/
551 sizeof (cmdpy_object
), /*tp_basicsize*/
560 0, /*tp_as_sequence*/
568 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
569 "GDB command object", /* tp_doc */
572 0, /* tp_richcompare */
573 0, /* tp_weaklistoffset */
576 cmdpy_object_methods
, /* tp_methods */
581 0, /* tp_descr_get */
582 0, /* tp_descr_set */
583 0, /* tp_dictoffset */
584 cmdpy_init
, /* tp_init */
586 PyType_GenericNew
/* tp_new */