1 /* gdb commands implemented in Python 2 3 Copyright (C) 2008-2013 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 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. 11 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. 16 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/>. */ 19 20 21 #include "defs.h" 22 #include "arch-utils.h" 23 #include "value.h" 24 #include "exceptions.h" 25 #include "python-internal.h" 26 #include "charset.h" 27 #include "gdbcmd.h" 28 #include "cli/cli-decode.h" 29 #include "completer.h" 30 #include "language.h" 31 32 /* Struct representing built-in completion types. */ 33 struct cmdpy_completer 34 { 35 /* Python symbol name. */ 36 char *name; 37 /* Completion function. */ 38 completer_ftype *completer; 39 }; 40 41 static struct cmdpy_completer completers[] = 42 { 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 }, 48 }; 49 50 #define N_COMPLETERS (sizeof (completers) / sizeof (completers[0])) 51 52 /* A gdb command. For the time being only ordinary commands (not 53 set/show commands) are allowed. */ 54 struct cmdpy_object 55 { 56 PyObject_HEAD 57 58 /* The corresponding gdb command object, or NULL if the command is 59 no longer installed. */ 60 struct cmd_list_element *command; 61 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; 67 }; 68 69 typedef struct cmdpy_object cmdpy_object; 70 71 static PyTypeObject cmdpy_object_type; 72 73 /* Constants used by this module. */ 74 static PyObject *invoke_cst; 75 static PyObject *complete_cst; 76 77 78 79 /* Python function which wraps dont_repeat. */ 80 static PyObject * 81 cmdpy_dont_repeat (PyObject *self, PyObject *args) 82 { 83 dont_repeat (); 84 Py_RETURN_NONE; 85 } 86 87 88 89 /* Called if the gdb cmd_list_element is destroyed. */ 90 91 static void 92 cmdpy_destroyer (struct cmd_list_element *self, void *context) 93 { 94 cmdpy_object *cmd; 95 struct cleanup *cleanup; 96 97 cleanup = ensure_python_env (get_current_arch (), current_language); 98 99 /* Release our hold on the command object. */ 100 cmd = (cmdpy_object *) context; 101 cmd->command = NULL; 102 Py_DECREF (cmd); 103 104 /* We allocated the name, doc string, and perhaps the prefix 105 name. */ 106 xfree (self->name); 107 xfree (self->doc); 108 xfree (self->prefixname); 109 110 do_cleanups (cleanup); 111 } 112 113 /* Called by gdb to invoke the command. */ 114 115 static void 116 cmdpy_function (struct cmd_list_element *command, char *args, int from_tty) 117 { 118 cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command); 119 PyObject *argobj, *ttyobj, *result; 120 struct cleanup *cleanup; 121 122 cleanup = ensure_python_env (get_current_arch (), current_language); 123 124 if (! obj) 125 error (_("Invalid invocation of Python command object.")); 126 if (! PyObject_HasAttr ((PyObject *) obj, invoke_cst)) 127 { 128 if (obj->command->prefixname) 129 { 130 /* A prefix command does not need an invoke method. */ 131 do_cleanups (cleanup); 132 return; 133 } 134 error (_("Python command object missing 'invoke' method.")); 135 } 136 137 if (! args) 138 args = ""; 139 argobj = PyUnicode_Decode (args, strlen (args), host_charset (), NULL); 140 if (! argobj) 141 { 142 gdbpy_print_stack (); 143 error (_("Could not convert arguments to Python string.")); 144 } 145 146 ttyobj = from_tty ? Py_True : Py_False; 147 Py_INCREF (ttyobj); 148 result = PyObject_CallMethodObjArgs ((PyObject *) obj, invoke_cst, argobj, 149 ttyobj, NULL); 150 Py_DECREF (argobj); 151 Py_DECREF (ttyobj); 152 153 if (! result) 154 { 155 PyObject *ptype, *pvalue, *ptraceback; 156 char *msg; 157 158 PyErr_Fetch (&ptype, &pvalue, &ptraceback); 159 160 /* Try to fetch an error message contained within ptype, pvalue. 161 When fetching the error message we need to make our own copy, 162 we no longer own ptype, pvalue after the call to PyErr_Restore. */ 163 164 msg = gdbpy_exception_to_string (ptype, pvalue); 165 make_cleanup (xfree, msg); 166 167 if (msg == NULL) 168 { 169 /* An error occurred computing the string representation of the 170 error message. This is rare, but we should inform the user. */ 171 printf_filtered (_("An error occurred in a Python command\n" 172 "and then another occurred computing the " 173 "error message.\n")); 174 gdbpy_print_stack (); 175 } 176 177 /* Don't print the stack for gdb.GdbError exceptions. 178 It is generally used to flag user errors. 179 180 We also don't want to print "Error occurred in Python command" 181 for user errors. However, a missing message for gdb.GdbError 182 exceptions is arguably a bug, so we flag it as such. */ 183 184 if (! PyErr_GivenExceptionMatches (ptype, gdbpy_gdberror_exc) 185 || msg == NULL || *msg == '\0') 186 { 187 PyErr_Restore (ptype, pvalue, ptraceback); 188 gdbpy_print_stack (); 189 if (msg != NULL && *msg != '\0') 190 error (_("Error occurred in Python command: %s"), msg); 191 else 192 error (_("Error occurred in Python command.")); 193 } 194 else 195 { 196 Py_XDECREF (ptype); 197 Py_XDECREF (pvalue); 198 Py_XDECREF (ptraceback); 199 error ("%s", msg); 200 } 201 } 202 203 Py_DECREF (result); 204 do_cleanups (cleanup); 205 } 206 207 /* Called by gdb for command completion. */ 208 209 static VEC (char_ptr) * 210 cmdpy_completer (struct cmd_list_element *command, char *text, char *word) 211 { 212 cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command); 213 PyObject *textobj, *wordobj, *resultobj = NULL; 214 VEC (char_ptr) *result = NULL; 215 struct cleanup *cleanup; 216 217 cleanup = ensure_python_env (get_current_arch (), current_language); 218 219 if (! obj) 220 error (_("Invalid invocation of Python command object.")); 221 if (! PyObject_HasAttr ((PyObject *) obj, complete_cst)) 222 { 223 /* If there is no complete method, don't error -- instead, just 224 say that there are no completions. */ 225 goto done; 226 } 227 228 textobj = PyUnicode_Decode (text, strlen (text), host_charset (), NULL); 229 if (! textobj) 230 error (_("Could not convert argument to Python string.")); 231 wordobj = PyUnicode_Decode (word, strlen (word), host_charset (), NULL); 232 if (! wordobj) 233 error (_("Could not convert argument to Python string.")); 234 235 resultobj = PyObject_CallMethodObjArgs ((PyObject *) obj, complete_cst, 236 textobj, wordobj, NULL); 237 Py_DECREF (textobj); 238 Py_DECREF (wordobj); 239 if (! resultobj) 240 { 241 /* Just swallow errors here. */ 242 PyErr_Clear (); 243 goto done; 244 } 245 make_cleanup_py_decref (resultobj); 246 247 result = NULL; 248 if (PySequence_Check (resultobj)) 249 { 250 Py_ssize_t i, len = PySequence_Size (resultobj); 251 Py_ssize_t out; 252 253 if (len < 0) 254 goto done; 255 256 for (i = out = 0; i < len; ++i) 257 { 258 PyObject *elt = PySequence_GetItem (resultobj, i); 259 char *item; 260 261 if (elt == NULL || ! gdbpy_is_string (elt)) 262 { 263 /* Skip problem elements. */ 264 PyErr_Clear (); 265 continue; 266 } 267 item = python_string_to_host_string (elt); 268 if (item == NULL) 269 { 270 /* Skip problem elements. */ 271 PyErr_Clear (); 272 continue; 273 } 274 VEC_safe_push (char_ptr, result, item); 275 } 276 } 277 else if (PyInt_Check (resultobj)) 278 { 279 /* User code may also return one of the completion constants, 280 thus requesting that sort of completion. */ 281 long value; 282 283 if (! gdb_py_int_as_long (resultobj, &value)) 284 { 285 /* Ignore. */ 286 PyErr_Clear (); 287 } 288 else if (value >= 0 && value < (long) N_COMPLETERS) 289 result = completers[value].completer (command, text, word); 290 } 291 292 done: 293 294 do_cleanups (cleanup); 295 296 return result; 297 } 298 299 /* Helper for cmdpy_init which locates the command list to use and 300 pulls out the command name. 301 302 NAME is the command name list. The final word in the list is the 303 name of the new command. All earlier words must be existing prefix 304 commands. 305 306 *BASE_LIST is set to the final prefix command's list of 307 *sub-commands. 308 309 START_LIST is the list in which the search starts. 310 311 This function returns the xmalloc()d name of the new command. On 312 error sets the Python error and returns NULL. */ 313 314 char * 315 gdbpy_parse_command_name (const char *name, 316 struct cmd_list_element ***base_list, 317 struct cmd_list_element **start_list) 318 { 319 struct cmd_list_element *elt; 320 int len = strlen (name); 321 int i, lastchar; 322 char *prefix_text, *prefix_text2; 323 char *result; 324 325 /* Skip trailing whitespace. */ 326 for (i = len - 1; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i) 327 ; 328 if (i < 0) 329 { 330 PyErr_SetString (PyExc_RuntimeError, _("No command name found.")); 331 return NULL; 332 } 333 lastchar = i; 334 335 /* Find first character of the final word. */ 336 for (; i > 0 && (isalnum (name[i - 1]) 337 || name[i - 1] == '-' 338 || name[i - 1] == '_'); 339 --i) 340 ; 341 result = xmalloc (lastchar - i + 2); 342 memcpy (result, &name[i], lastchar - i + 1); 343 result[lastchar - i + 1] = '\0'; 344 345 /* Skip whitespace again. */ 346 for (--i; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i) 347 ; 348 if (i < 0) 349 { 350 *base_list = start_list; 351 return result; 352 } 353 354 prefix_text = xmalloc (i + 2); 355 memcpy (prefix_text, name, i + 1); 356 prefix_text[i + 1] = '\0'; 357 358 prefix_text2 = prefix_text; 359 elt = lookup_cmd_1 (&prefix_text2, *start_list, NULL, 1); 360 if (!elt || elt == (struct cmd_list_element *) -1) 361 { 362 PyErr_Format (PyExc_RuntimeError, _("Could not find command prefix %s."), 363 prefix_text); 364 xfree (prefix_text); 365 xfree (result); 366 return NULL; 367 } 368 369 if (elt->prefixlist) 370 { 371 xfree (prefix_text); 372 *base_list = elt->prefixlist; 373 return result; 374 } 375 376 PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command."), 377 prefix_text); 378 xfree (prefix_text); 379 xfree (result); 380 return NULL; 381 } 382 383 /* Object initializer; sets up gdb-side structures for command. 384 385 Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]). 386 387 NAME is the name of the command. It may consist of multiple words, 388 in which case the final word is the name of the new command, and 389 earlier words must be prefix commands. 390 391 COMMAND_CLASS is the kind of command. It should be one of the COMMAND_* 392 constants defined in the gdb module. 393 394 COMPLETER_CLASS is the kind of completer. If not given, the 395 "complete" method will be used. Otherwise, it should be one of the 396 COMPLETE_* constants defined in the gdb module. 397 398 If PREFIX is True, then this command is a prefix command. 399 400 The documentation for the command is taken from the doc string for 401 the python class. */ 402 403 static int 404 cmdpy_init (PyObject *self, PyObject *args, PyObject *kw) 405 { 406 cmdpy_object *obj = (cmdpy_object *) self; 407 const char *name; 408 int cmdtype; 409 int completetype = -1; 410 char *docstring = NULL; 411 volatile struct gdb_exception except; 412 struct cmd_list_element **cmd_list; 413 char *cmd_name, *pfx_name; 414 static char *keywords[] = { "name", "command_class", "completer_class", 415 "prefix", NULL }; 416 PyObject *is_prefix = NULL; 417 int cmp; 418 419 if (obj->command) 420 { 421 /* Note: this is apparently not documented in Python. We return 422 0 for success, -1 for failure. */ 423 PyErr_Format (PyExc_RuntimeError, 424 _("Command object already initialized.")); 425 return -1; 426 } 427 428 if (! PyArg_ParseTupleAndKeywords (args, kw, "si|iO", 429 keywords, &name, &cmdtype, 430 &completetype, &is_prefix)) 431 return -1; 432 433 if (cmdtype != no_class && cmdtype != class_run 434 && cmdtype != class_vars && cmdtype != class_stack 435 && cmdtype != class_files && cmdtype != class_support 436 && cmdtype != class_info && cmdtype != class_breakpoint 437 && cmdtype != class_trace && cmdtype != class_obscure 438 && cmdtype != class_maintenance && cmdtype != class_user) 439 { 440 PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument.")); 441 return -1; 442 } 443 444 if (completetype < -1 || completetype >= (int) N_COMPLETERS) 445 { 446 PyErr_Format (PyExc_RuntimeError, 447 _("Invalid completion type argument.")); 448 return -1; 449 } 450 451 cmd_name = gdbpy_parse_command_name (name, &cmd_list, &cmdlist); 452 if (! cmd_name) 453 return -1; 454 455 pfx_name = NULL; 456 if (is_prefix != NULL) 457 { 458 cmp = PyObject_IsTrue (is_prefix); 459 if (cmp == 1) 460 { 461 int i, out; 462 463 /* Make a normalized form of the command name. */ 464 pfx_name = xmalloc (strlen (name) + 2); 465 466 i = 0; 467 out = 0; 468 while (name[i]) 469 { 470 /* Skip whitespace. */ 471 while (name[i] == ' ' || name[i] == '\t') 472 ++i; 473 /* Copy non-whitespace characters. */ 474 while (name[i] && name[i] != ' ' && name[i] != '\t') 475 pfx_name[out++] = name[i++]; 476 /* Add a single space after each word -- including the final 477 word. */ 478 pfx_name[out++] = ' '; 479 } 480 pfx_name[out] = '\0'; 481 } 482 else if (cmp < 0) 483 { 484 xfree (cmd_name); 485 return -1; 486 } 487 } 488 if (PyObject_HasAttr (self, gdbpy_doc_cst)) 489 { 490 PyObject *ds_obj = PyObject_GetAttr (self, gdbpy_doc_cst); 491 492 if (ds_obj && gdbpy_is_string (ds_obj)) 493 { 494 docstring = python_string_to_host_string (ds_obj); 495 if (docstring == NULL) 496 { 497 xfree (cmd_name); 498 xfree (pfx_name); 499 return -1; 500 } 501 } 502 } 503 if (! docstring) 504 docstring = xstrdup (_("This command is not documented.")); 505 506 Py_INCREF (self); 507 508 TRY_CATCH (except, RETURN_MASK_ALL) 509 { 510 struct cmd_list_element *cmd; 511 512 if (pfx_name) 513 { 514 int allow_unknown; 515 516 /* If we have our own "invoke" method, then allow unknown 517 sub-commands. */ 518 allow_unknown = PyObject_HasAttr (self, invoke_cst); 519 cmd = add_prefix_cmd (cmd_name, (enum command_class) cmdtype, 520 NULL, docstring, &obj->sub_list, 521 pfx_name, allow_unknown, cmd_list); 522 } 523 else 524 cmd = add_cmd (cmd_name, (enum command_class) cmdtype, NULL, 525 docstring, cmd_list); 526 527 /* There appears to be no API to set this. */ 528 cmd->func = cmdpy_function; 529 cmd->destroyer = cmdpy_destroyer; 530 531 obj->command = cmd; 532 set_cmd_context (cmd, self); 533 set_cmd_completer (cmd, ((completetype == -1) ? cmdpy_completer 534 : completers[completetype].completer)); 535 } 536 if (except.reason < 0) 537 { 538 xfree (cmd_name); 539 xfree (docstring); 540 xfree (pfx_name); 541 Py_DECREF (self); 542 PyErr_Format (except.reason == RETURN_QUIT 543 ? PyExc_KeyboardInterrupt : PyExc_RuntimeError, 544 "%s", except.message); 545 return -1; 546 } 547 return 0; 548 } 549 550 551 552 /* Initialize the 'commands' code. */ 553 554 void 555 gdbpy_initialize_commands (void) 556 { 557 int i; 558 559 cmdpy_object_type.tp_new = PyType_GenericNew; 560 if (PyType_Ready (&cmdpy_object_type) < 0) 561 return; 562 563 /* Note: alias and user are special; pseudo appears to be unused, 564 and there is no reason to expose tui or xdb, I think. */ 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", 571 class_support) < 0 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", 576 class_trace) < 0 577 || PyModule_AddIntConstant (gdb_module, "COMMAND_OBSCURE", 578 class_obscure) < 0 579 || PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE", 580 class_maintenance) < 0 581 || PyModule_AddIntConstant (gdb_module, "COMMAND_USER", class_user) < 0) 582 return; 583 584 for (i = 0; i < N_COMPLETERS; ++i) 585 { 586 if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0) 587 return; 588 } 589 590 Py_INCREF (&cmdpy_object_type); 591 PyModule_AddObject (gdb_module, "Command", 592 (PyObject *) &cmdpy_object_type); 593 594 invoke_cst = PyString_FromString ("invoke"); 595 complete_cst = PyString_FromString ("complete"); 596 } 597 598 599 600 static PyMethodDef cmdpy_object_methods[] = 601 { 602 { "dont_repeat", cmdpy_dont_repeat, METH_NOARGS, 603 "Prevent command repetition when user enters empty line." }, 604 605 { 0 } 606 }; 607 608 static PyTypeObject cmdpy_object_type = 609 { 610 PyVarObject_HEAD_INIT (NULL, 0) 611 "gdb.Command", /*tp_name*/ 612 sizeof (cmdpy_object), /*tp_basicsize*/ 613 0, /*tp_itemsize*/ 614 0, /*tp_dealloc*/ 615 0, /*tp_print*/ 616 0, /*tp_getattr*/ 617 0, /*tp_setattr*/ 618 0, /*tp_compare*/ 619 0, /*tp_repr*/ 620 0, /*tp_as_number*/ 621 0, /*tp_as_sequence*/ 622 0, /*tp_as_mapping*/ 623 0, /*tp_hash */ 624 0, /*tp_call*/ 625 0, /*tp_str*/ 626 0, /*tp_getattro*/ 627 0, /*tp_setattro*/ 628 0, /*tp_as_buffer*/ 629 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 630 "GDB command object", /* tp_doc */ 631 0, /* tp_traverse */ 632 0, /* tp_clear */ 633 0, /* tp_richcompare */ 634 0, /* tp_weaklistoffset */ 635 0, /* tp_iter */ 636 0, /* tp_iternext */ 637 cmdpy_object_methods, /* tp_methods */ 638 0, /* tp_members */ 639 0, /* tp_getset */ 640 0, /* tp_base */ 641 0, /* tp_dict */ 642 0, /* tp_descr_get */ 643 0, /* tp_descr_set */ 644 0, /* tp_dictoffset */ 645 cmdpy_init, /* tp_init */ 646 0, /* tp_alloc */ 647 }; 648 649 650 651 /* Utility to build a buildargv-like result from ARGS. 652 This intentionally parses arguments the way libiberty/argv.c:buildargv 653 does. It splits up arguments in a reasonable way, and we want a standard 654 way of parsing arguments. Several gdb commands use buildargv to parse their 655 arguments. Plus we want to be able to write compatible python 656 implementations of gdb commands. */ 657 658 PyObject * 659 gdbpy_string_to_argv (PyObject *self, PyObject *args) 660 { 661 PyObject *py_argv; 662 const char *input; 663 664 if (!PyArg_ParseTuple (args, "s", &input)) 665 return NULL; 666 667 py_argv = PyList_New (0); 668 669 /* buildargv uses NULL to represent an empty argument list, but we can't use 670 that in Python. Instead, if ARGS is "" then return an empty list. 671 This undoes the NULL -> "" conversion that cmdpy_function does. */ 672 673 if (*input != '\0') 674 { 675 char **c_argv = gdb_buildargv (input); 676 int i; 677 678 for (i = 0; c_argv[i] != NULL; ++i) 679 { 680 PyObject *argp = PyString_FromString (c_argv[i]); 681 682 if (argp == NULL 683 || PyList_Append (py_argv, argp) < 0) 684 { 685 Py_XDECREF (argp); 686 Py_DECREF (py_argv); 687 freeargv (c_argv); 688 return NULL; 689 } 690 Py_DECREF (argp); 691 } 692 693 freeargv (c_argv); 694 } 695 696 return py_argv; 697 } 698