1 /* gdb commands implemented in Python
3 Copyright (C) 2008-2022 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 "python-internal.h"
27 #include "cli/cli-decode.h"
28 #include "completer.h"
31 /* Struct representing built-in completion types. */
32 struct cmdpy_completer
34 /* Python symbol name. */
36 /* Completion function. */
37 completer_ftype
*completer
;
40 static const struct cmdpy_completer completers
[] =
42 { "COMPLETE_NONE", noop_completer
},
43 { "COMPLETE_FILENAME", filename_completer
},
44 { "COMPLETE_LOCATION", location_completer
},
45 { "COMPLETE_COMMAND", command_completer
},
46 { "COMPLETE_SYMBOL", symbol_completer
},
47 { "COMPLETE_EXPRESSION", expression_completer
},
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 extern PyTypeObject cmdpy_object_type
70 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("cmdpy_object");
72 /* Constants used by this module. */
73 static PyObject
*invoke_cst
;
74 static PyObject
*complete_cst
;
78 /* Python function which wraps dont_repeat. */
80 cmdpy_dont_repeat (PyObject
*self
, PyObject
*args
)
88 /* Called if the gdb cmd_list_element is destroyed. */
91 cmdpy_destroyer (struct cmd_list_element
*self
, void *context
)
95 /* Release our hold on the command object. */
96 gdbpy_ref
<cmdpy_object
> cmd ((cmdpy_object
*) context
);
100 /* Called by gdb to invoke the command. */
103 cmdpy_function (const char *args
, int from_tty
, cmd_list_element
*command
)
105 cmdpy_object
*obj
= (cmdpy_object
*) command
->context ();
107 gdbpy_enter enter_py
;
110 error (_("Invalid invocation of Python command object."));
111 if (! PyObject_HasAttr ((PyObject
*) obj
, invoke_cst
))
113 if (obj
->command
->is_prefix ())
115 /* A prefix command does not need an invoke method. */
118 error (_("Python command object missing 'invoke' method."));
123 gdbpy_ref
<> argobj (PyUnicode_Decode (args
, strlen (args
), host_charset (),
127 gdbpy_print_stack ();
128 error (_("Could not convert arguments to Python string."));
132 = gdbpy_ref
<>::new_reference (from_tty
? Py_True
: Py_False
);
133 gdbpy_ref
<> result (PyObject_CallMethodObjArgs ((PyObject
*) obj
, invoke_cst
,
134 argobj
.get (), ttyobj
.get (),
138 gdbpy_handle_exception ();
141 /* Helper function for the Python command completers (both "pure"
142 completer and brkchar handler). This function takes COMMAND, TEXT
143 and WORD and tries to call the Python method for completion with
146 This function is usually called twice: once when we are figuring out
147 the break characters to be used, and another to perform the real
148 completion itself. The reason for this two step dance is that we
149 need to know the set of "brkchars" to use early on, before we
150 actually try to perform the completion. But if a Python command
151 supplies a "complete" method then we have to call that method
152 first: it may return as its result the kind of completion to
153 perform and that will in turn specify which brkchars to use. IOW,
154 we need the result of the "complete" method before we actually
155 perform the completion. The only situation when this function is
156 not called twice is when the user uses the "complete" command: in
157 this scenario, there is no call to determine the "brkchars".
159 Ideally, it would be nice to cache the result of the first call (to
160 determine the "brkchars") and return this value directly in the
161 second call (to perform the actual completion). However, due to
162 the peculiarity of the "complete" command mentioned above, it is
163 possible to put GDB in a bad state if you perform a TAB-completion
164 and then a "complete"-completion sequentially. Therefore, we just
165 recalculate everything twice for TAB-completions.
167 This function returns a reference to the PyObject representing the
168 Python method call. */
171 cmdpy_completer_helper (struct cmd_list_element
*command
,
172 const char *text
, const char *word
)
174 cmdpy_object
*obj
= (cmdpy_object
*) command
->context ();
177 error (_("Invalid invocation of Python command object."));
178 if (!PyObject_HasAttr ((PyObject
*) obj
, complete_cst
))
180 /* If there is no complete method, don't error. */
184 gdbpy_ref
<> textobj (PyUnicode_Decode (text
, strlen (text
), host_charset (),
187 error (_("Could not convert argument to Python string."));
192 /* "brkchars" phase. */
193 wordobj
= gdbpy_ref
<>::new_reference (Py_None
);
197 wordobj
.reset (PyUnicode_Decode (word
, strlen (word
), host_charset (),
200 error (_("Could not convert argument to Python string."));
203 gdbpy_ref
<> resultobj (PyObject_CallMethodObjArgs ((PyObject
*) obj
,
206 wordobj
.get (), NULL
));
207 if (resultobj
== NULL
)
209 /* Just swallow errors here. */
216 /* Python function called to determine the break characters of a
217 certain completer. We are only interested in knowing if the
218 completer registered by the user will return one of the integer
219 codes (see COMPLETER_* symbols). */
222 cmdpy_completer_handle_brkchars (struct cmd_list_element
*command
,
223 completion_tracker
&tracker
,
224 const char *text
, const char *word
)
226 gdbpy_enter enter_py
;
228 /* Calling our helper to obtain a reference to the PyObject of the Python
230 gdbpy_ref
<> resultobj
= cmdpy_completer_helper (command
, text
, word
);
232 /* Check if there was an error. */
233 if (resultobj
== NULL
)
236 if (PyLong_Check (resultobj
.get ()))
238 /* User code may also return one of the completion constants,
239 thus requesting that sort of completion. We are only
240 interested in this kind of return. */
243 if (!gdb_py_int_as_long (resultobj
.get (), &value
))
248 else if (value
>= 0 && value
< (long) N_COMPLETERS
)
250 completer_handle_brkchars_ftype
*brkchars_fn
;
252 /* This is the core of this function. Depending on which
253 completer type the Python function returns, we have to
254 adjust the break characters accordingly. */
255 brkchars_fn
= (completer_handle_brkchars_func_for_completer
256 (completers
[value
].completer
));
257 brkchars_fn (command
, tracker
, text
, word
);
262 /* Called by gdb for command completion. */
265 cmdpy_completer (struct cmd_list_element
*command
,
266 completion_tracker
&tracker
,
267 const char *text
, const char *word
)
269 gdbpy_enter enter_py
;
271 /* Calling our helper to obtain a reference to the PyObject of the Python
273 gdbpy_ref
<> resultobj
= cmdpy_completer_helper (command
, text
, word
);
275 /* If the result object of calling the Python function is NULL, it
276 means that there was an error. In this case, just give up. */
277 if (resultobj
== NULL
)
280 if (PyLong_Check (resultobj
.get ()))
282 /* User code may also return one of the completion constants,
283 thus requesting that sort of completion. */
286 if (! gdb_py_int_as_long (resultobj
.get (), &value
))
291 else if (value
>= 0 && value
< (long) N_COMPLETERS
)
292 completers
[value
].completer (command
, tracker
, text
, word
);
296 gdbpy_ref
<> iter (PyObject_GetIter (resultobj
.get ()));
301 bool got_matches
= false;
304 gdbpy_ref
<> elt (PyIter_Next (iter
.get ()));
308 if (! gdbpy_is_string (elt
.get ()))
310 /* Skip problem elements. */
313 gdb::unique_xmalloc_ptr
<char>
314 item (python_string_to_host_string (elt
.get ()));
317 /* Skip problem elements. */
321 tracker
.add_completion (std::move (item
));
325 /* If we got some results, ignore problems. Otherwise, report
327 if (got_matches
&& PyErr_Occurred ())
332 /* Helper for cmdpy_init which locates the command list to use and
333 pulls out the command name.
335 NAME is the command name list. The final word in the list is the
336 name of the new command. All earlier words must be existing prefix
339 *BASE_LIST is set to the final prefix command's list of
342 START_LIST is the list in which the search starts.
344 This function returns the name of the new command. On error sets the Python
345 error and returns NULL. */
347 gdb::unique_xmalloc_ptr
<char>
348 gdbpy_parse_command_name (const char *name
,
349 struct cmd_list_element
***base_list
,
350 struct cmd_list_element
**start_list
)
352 struct cmd_list_element
*elt
;
353 int len
= strlen (name
);
355 const char *prefix_text2
;
357 /* Skip trailing whitespace. */
358 for (i
= len
- 1; i
>= 0 && (name
[i
] == ' ' || name
[i
] == '\t'); --i
)
362 PyErr_SetString (PyExc_RuntimeError
, _("No command name found."));
367 /* Find first character of the final word. */
368 for (; i
> 0 && valid_cmd_char_p (name
[i
- 1]); --i
)
371 gdb::unique_xmalloc_ptr
<char> result ((char *) xmalloc (lastchar
- i
+ 2));
372 memcpy (result
.get (), &name
[i
], lastchar
- i
+ 1);
373 result
.get ()[lastchar
- i
+ 1] = '\0';
375 /* Skip whitespace again. */
376 for (--i
; i
>= 0 && (name
[i
] == ' ' || name
[i
] == '\t'); --i
)
380 *base_list
= start_list
;
384 std::string
prefix_text (name
, i
+ 1);
386 prefix_text2
= prefix_text
.c_str ();
387 elt
= lookup_cmd_1 (&prefix_text2
, *start_list
, NULL
, NULL
, 1);
388 if (elt
== NULL
|| elt
== CMD_LIST_AMBIGUOUS
)
390 PyErr_Format (PyExc_RuntimeError
, _("Could not find command prefix %s."),
391 prefix_text
.c_str ());
395 if (elt
->is_prefix ())
397 *base_list
= elt
->subcommands
;
401 PyErr_Format (PyExc_RuntimeError
, _("'%s' is not a prefix command."),
402 prefix_text
.c_str ());
406 /* Object initializer; sets up gdb-side structures for command.
408 Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]).
410 NAME is the name of the command. It may consist of multiple words,
411 in which case the final word is the name of the new command, and
412 earlier words must be prefix commands.
414 COMMAND_CLASS is the kind of command. It should be one of the COMMAND_*
415 constants defined in the gdb module.
417 COMPLETER_CLASS is the kind of completer. If not given, the
418 "complete" method will be used. Otherwise, it should be one of the
419 COMPLETE_* constants defined in the gdb module.
421 If PREFIX is True, then this command is a prefix command.
423 The documentation for the command is taken from the doc string for
427 cmdpy_init (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
429 cmdpy_object
*obj
= (cmdpy_object
*) self
;
432 int completetype
= -1;
433 struct cmd_list_element
**cmd_list
;
434 static const char *keywords
[] = { "name", "command_class", "completer_class",
436 PyObject
*is_prefix_obj
= NULL
;
437 bool is_prefix
= false;
441 /* Note: this is apparently not documented in Python. We return
442 0 for success, -1 for failure. */
443 PyErr_Format (PyExc_RuntimeError
,
444 _("Command object already initialized."));
448 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "si|iO",
449 keywords
, &name
, &cmdtype
,
450 &completetype
, &is_prefix_obj
))
453 if (cmdtype
!= no_class
&& cmdtype
!= class_run
454 && cmdtype
!= class_vars
&& cmdtype
!= class_stack
455 && cmdtype
!= class_files
&& cmdtype
!= class_support
456 && cmdtype
!= class_info
&& cmdtype
!= class_breakpoint
457 && cmdtype
!= class_trace
&& cmdtype
!= class_obscure
458 && cmdtype
!= class_maintenance
&& cmdtype
!= class_user
459 && cmdtype
!= class_tui
)
461 PyErr_Format (PyExc_RuntimeError
, _("Invalid command class argument."));
465 if (completetype
< -1 || completetype
>= (int) N_COMPLETERS
)
467 PyErr_Format (PyExc_RuntimeError
,
468 _("Invalid completion type argument."));
472 gdb::unique_xmalloc_ptr
<char> cmd_name
473 = gdbpy_parse_command_name (name
, &cmd_list
, &cmdlist
);
474 if (cmd_name
== nullptr)
477 if (is_prefix_obj
!= NULL
)
479 int cmp
= PyObject_IsTrue (is_prefix_obj
);
486 gdb::unique_xmalloc_ptr
<char> docstring
= nullptr;
487 if (PyObject_HasAttr (self
, gdbpy_doc_cst
))
489 gdbpy_ref
<> ds_obj (PyObject_GetAttr (self
, gdbpy_doc_cst
));
491 if (ds_obj
!= NULL
&& gdbpy_is_string (ds_obj
.get ()))
493 docstring
= python_string_to_host_string (ds_obj
.get ());
494 if (docstring
== nullptr)
496 docstring
= gdbpy_fix_doc_string_indentation (std::move (docstring
));
499 if (docstring
== nullptr)
500 docstring
= make_unique_xstrdup (_("This command is not documented."));
502 gdbpy_ref
<> self_ref
= gdbpy_ref
<>::new_reference (self
);
506 struct cmd_list_element
*cmd
;
512 /* If we have our own "invoke" method, then allow unknown
514 allow_unknown
= PyObject_HasAttr (self
, invoke_cst
);
515 cmd
= add_prefix_cmd (cmd_name
.get (),
516 (enum command_class
) cmdtype
,
517 NULL
, docstring
.release (), &obj
->sub_list
,
518 allow_unknown
, cmd_list
);
521 cmd
= add_cmd (cmd_name
.get (), (enum command_class
) cmdtype
,
522 docstring
.release (), cmd_list
);
524 /* If successful, the above takes ownership of the name, since we set
525 name_allocated, so release it. */
528 /* There appears to be no API to set this. */
529 cmd
->func
= cmdpy_function
;
530 cmd
->destroyer
= cmdpy_destroyer
;
531 cmd
->doc_allocated
= 1;
532 cmd
->name_allocated
= 1;
535 cmd
->set_context (self_ref
.release ());
536 set_cmd_completer (cmd
, ((completetype
== -1) ? cmdpy_completer
537 : completers
[completetype
].completer
));
538 if (completetype
== -1)
539 set_cmd_completer_handle_brkchars (cmd
,
540 cmdpy_completer_handle_brkchars
);
542 catch (const gdb_exception
&except
)
544 gdbpy_convert_exception (except
);
553 /* Initialize the 'commands' code. */
556 gdbpy_initialize_commands (void)
560 cmdpy_object_type
.tp_new
= PyType_GenericNew
;
561 if (PyType_Ready (&cmdpy_object_type
) < 0)
564 /* Note: alias and user are special. */
565 if (PyModule_AddIntConstant (gdb_module
, "COMMAND_NONE", no_class
) < 0
566 || PyModule_AddIntConstant (gdb_module
, "COMMAND_RUNNING", class_run
) < 0
567 || PyModule_AddIntConstant (gdb_module
, "COMMAND_DATA", class_vars
) < 0
568 || PyModule_AddIntConstant (gdb_module
, "COMMAND_STACK", class_stack
) < 0
569 || PyModule_AddIntConstant (gdb_module
, "COMMAND_FILES", class_files
) < 0
570 || PyModule_AddIntConstant (gdb_module
, "COMMAND_SUPPORT",
572 || PyModule_AddIntConstant (gdb_module
, "COMMAND_STATUS", class_info
) < 0
573 || PyModule_AddIntConstant (gdb_module
, "COMMAND_BREAKPOINTS",
574 class_breakpoint
) < 0
575 || PyModule_AddIntConstant (gdb_module
, "COMMAND_TRACEPOINTS",
577 || PyModule_AddIntConstant (gdb_module
, "COMMAND_OBSCURE",
579 || PyModule_AddIntConstant (gdb_module
, "COMMAND_MAINTENANCE",
580 class_maintenance
) < 0
581 || PyModule_AddIntConstant (gdb_module
, "COMMAND_USER", class_user
) < 0
582 || PyModule_AddIntConstant (gdb_module
, "COMMAND_TUI", class_tui
) < 0)
585 for (i
= 0; i
< N_COMPLETERS
; ++i
)
587 if (PyModule_AddIntConstant (gdb_module
, completers
[i
].name
, i
) < 0)
591 if (gdb_pymodule_addobject (gdb_module
, "Command",
592 (PyObject
*) &cmdpy_object_type
) < 0)
595 invoke_cst
= PyUnicode_FromString ("invoke");
596 if (invoke_cst
== NULL
)
598 complete_cst
= PyUnicode_FromString ("complete");
599 if (complete_cst
== NULL
)
607 static PyMethodDef cmdpy_object_methods
[] =
609 { "dont_repeat", cmdpy_dont_repeat
, METH_NOARGS
,
610 "Prevent command repetition when user enters empty line." },
615 PyTypeObject cmdpy_object_type
=
617 PyVarObject_HEAD_INIT (NULL
, 0)
618 "gdb.Command", /*tp_name*/
619 sizeof (cmdpy_object
), /*tp_basicsize*/
628 0, /*tp_as_sequence*/
636 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
637 "GDB command object", /* tp_doc */
640 0, /* tp_richcompare */
641 0, /* tp_weaklistoffset */
644 cmdpy_object_methods
, /* tp_methods */
649 0, /* tp_descr_get */
650 0, /* tp_descr_set */
651 0, /* tp_dictoffset */
652 cmdpy_init
, /* tp_init */
658 /* Utility to build a buildargv-like result from ARGS.
659 This intentionally parses arguments the way libiberty/argv.c:buildargv
660 does. It splits up arguments in a reasonable way, and we want a standard
661 way of parsing arguments. Several gdb commands use buildargv to parse their
662 arguments. Plus we want to be able to write compatible python
663 implementations of gdb commands. */
666 gdbpy_string_to_argv (PyObject
*self
, PyObject
*args
)
670 if (!PyArg_ParseTuple (args
, "s", &input
))
673 gdbpy_ref
<> py_argv (PyList_New (0));
677 /* buildargv uses NULL to represent an empty argument list, but we can't use
678 that in Python. Instead, if ARGS is "" then return an empty list.
679 This undoes the NULL -> "" conversion that cmdpy_function does. */
683 gdb_argv
c_argv (input
);
685 for (char *arg
: c_argv
)
687 gdbpy_ref
<> argp (PyUnicode_FromString (arg
));
690 || PyList_Append (py_argv
.get (), argp
.get ()) < 0)
695 return py_argv
.release ();