1 /* gdb commands implemented in Python 2 3 Copyright (C) 2008-2016 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 "python-internal.h" 25 #include "charset.h" 26 #include "gdbcmd.h" 27 #include "cli/cli-decode.h" 28 #include "completer.h" 29 #include "language.h" 30 31 /* Struct representing built-in completion types. */ 32 struct cmdpy_completer 33 { 34 /* Python symbol name. 35 This isn't a const char * for Python 2.4's sake. 36 PyModule_AddIntConstant only takes a char *, sigh. */ 37 char *name; 38 /* Completion function. */ 39 completer_ftype *completer; 40 }; 41 42 static const struct cmdpy_completer completers[] = 43 { 44 { "COMPLETE_NONE", noop_completer }, 45 { "COMPLETE_FILENAME", filename_completer }, 46 { "COMPLETE_LOCATION", location_completer }, 47 { "COMPLETE_COMMAND", command_completer }, 48 { "COMPLETE_SYMBOL", make_symbol_completion_list_fn }, 49 { "COMPLETE_EXPRESSION", expression_completer }, 50 }; 51 52 #define N_COMPLETERS (sizeof (completers) / sizeof (completers[0])) 53 54 /* A gdb command. For the time being only ordinary commands (not 55 set/show commands) are allowed. */ 56 struct cmdpy_object 57 { 58 PyObject_HEAD 59 60 /* The corresponding gdb command object, or NULL if the command is 61 no longer installed. */ 62 struct cmd_list_element *command; 63 64 /* A prefix command requires storage for a list of its sub-commands. 65 A pointer to this is passed to add_prefix_command, and to add_cmd 66 for sub-commands of that prefix. If this Command is not a prefix 67 command, then this field is unused. */ 68 struct cmd_list_element *sub_list; 69 }; 70 71 typedef struct cmdpy_object cmdpy_object; 72 73 extern PyTypeObject cmdpy_object_type 74 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("cmdpy_object"); 75 76 /* Constants used by this module. */ 77 static PyObject *invoke_cst; 78 static PyObject *complete_cst; 79 80 81 82 /* Python function which wraps dont_repeat. */ 83 static PyObject * 84 cmdpy_dont_repeat (PyObject *self, PyObject *args) 85 { 86 dont_repeat (); 87 Py_RETURN_NONE; 88 } 89 90 91 92 /* Called if the gdb cmd_list_element is destroyed. */ 93 94 static void 95 cmdpy_destroyer (struct cmd_list_element *self, void *context) 96 { 97 cmdpy_object *cmd; 98 struct cleanup *cleanup; 99 100 cleanup = ensure_python_env (get_current_arch (), current_language); 101 102 /* Release our hold on the command object. */ 103 cmd = (cmdpy_object *) context; 104 cmd->command = NULL; 105 Py_DECREF (cmd); 106 107 /* We allocated the name, doc string, and perhaps the prefix 108 name. */ 109 xfree ((char *) self->name); 110 xfree ((char *) self->doc); 111 xfree ((char *) self->prefixname); 112 113 do_cleanups (cleanup); 114 } 115 116 /* Called by gdb to invoke the command. */ 117 118 static void 119 cmdpy_function (struct cmd_list_element *command, char *args, int from_tty) 120 { 121 cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command); 122 PyObject *argobj, *ttyobj, *result; 123 struct cleanup *cleanup; 124 125 cleanup = ensure_python_env (get_current_arch (), current_language); 126 127 if (! obj) 128 error (_("Invalid invocation of Python command object.")); 129 if (! PyObject_HasAttr ((PyObject *) obj, invoke_cst)) 130 { 131 if (obj->command->prefixname) 132 { 133 /* A prefix command does not need an invoke method. */ 134 do_cleanups (cleanup); 135 return; 136 } 137 error (_("Python command object missing 'invoke' method.")); 138 } 139 140 if (! args) 141 args = ""; 142 argobj = PyUnicode_Decode (args, strlen (args), host_charset (), NULL); 143 if (! argobj) 144 { 145 gdbpy_print_stack (); 146 error (_("Could not convert arguments to Python string.")); 147 } 148 149 ttyobj = from_tty ? Py_True : Py_False; 150 Py_INCREF (ttyobj); 151 result = PyObject_CallMethodObjArgs ((PyObject *) obj, invoke_cst, argobj, 152 ttyobj, NULL); 153 Py_DECREF (argobj); 154 Py_DECREF (ttyobj); 155 156 if (! result) 157 { 158 PyObject *ptype, *pvalue, *ptraceback; 159 char *msg; 160 161 PyErr_Fetch (&ptype, &pvalue, &ptraceback); 162 163 /* Try to fetch an error message contained within ptype, pvalue. 164 When fetching the error message we need to make our own copy, 165 we no longer own ptype, pvalue after the call to PyErr_Restore. */ 166 167 msg = gdbpy_exception_to_string (ptype, pvalue); 168 make_cleanup (xfree, msg); 169 170 if (msg == NULL) 171 { 172 /* An error occurred computing the string representation of the 173 error message. This is rare, but we should inform the user. */ 174 printf_filtered (_("An error occurred in a Python command\n" 175 "and then another occurred computing the " 176 "error message.\n")); 177 gdbpy_print_stack (); 178 } 179 180 /* Don't print the stack for gdb.GdbError exceptions. 181 It is generally used to flag user errors. 182 183 We also don't want to print "Error occurred in Python command" 184 for user errors. However, a missing message for gdb.GdbError 185 exceptions is arguably a bug, so we flag it as such. */ 186 187 if (! PyErr_GivenExceptionMatches (ptype, gdbpy_gdberror_exc) 188 || msg == NULL || *msg == '\0') 189 { 190 PyErr_Restore (ptype, pvalue, ptraceback); 191 gdbpy_print_stack (); 192 if (msg != NULL && *msg != '\0') 193 error (_("Error occurred in Python command: %s"), msg); 194 else 195 error (_("Error occurred in Python command.")); 196 } 197 else 198 { 199 Py_XDECREF (ptype); 200 Py_XDECREF (pvalue); 201 Py_XDECREF (ptraceback); 202 error ("%s", msg); 203 } 204 } 205 206 Py_DECREF (result); 207 do_cleanups (cleanup); 208 } 209 210 /* Helper function for the Python command completers (both "pure" 211 completer and brkchar handler). This function takes COMMAND, TEXT 212 and WORD and tries to call the Python method for completion with 213 these arguments. 214 215 This function is usually called twice: once when we are figuring out 216 the break characters to be used, and another to perform the real 217 completion itself. The reason for this two step dance is that we 218 need to know the set of "brkchars" to use early on, before we 219 actually try to perform the completion. But if a Python command 220 supplies a "complete" method then we have to call that method 221 first: it may return as its result the kind of completion to 222 perform and that will in turn specify which brkchars to use. IOW, 223 we need the result of the "complete" method before we actually 224 perform the completion. The only situation when this function is 225 not called twice is when the user uses the "complete" command: in 226 this scenario, there is no call to determine the "brkchars". 227 228 Ideally, it would be nice to cache the result of the first call (to 229 determine the "brkchars") and return this value directly in the 230 second call (to perform the actual completion). However, due to 231 the peculiarity of the "complete" command mentioned above, it is 232 possible to put GDB in a bad state if you perform a TAB-completion 233 and then a "complete"-completion sequentially. Therefore, we just 234 recalculate everything twice for TAB-completions. 235 236 This function returns the PyObject representing the Python method 237 call. */ 238 239 static PyObject * 240 cmdpy_completer_helper (struct cmd_list_element *command, 241 const char *text, const char *word) 242 { 243 cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command); 244 PyObject *textobj, *wordobj; 245 PyObject *resultobj; 246 247 if (obj == NULL) 248 error (_("Invalid invocation of Python command object.")); 249 if (!PyObject_HasAttr ((PyObject *) obj, complete_cst)) 250 { 251 /* If there is no complete method, don't error. */ 252 return NULL; 253 } 254 255 textobj = PyUnicode_Decode (text, strlen (text), host_charset (), NULL); 256 if (textobj == NULL) 257 error (_("Could not convert argument to Python string.")); 258 wordobj = PyUnicode_Decode (word, strlen (word), host_charset (), NULL); 259 if (wordobj == NULL) 260 { 261 Py_DECREF (textobj); 262 error (_("Could not convert argument to Python string.")); 263 } 264 265 resultobj = PyObject_CallMethodObjArgs ((PyObject *) obj, complete_cst, 266 textobj, wordobj, NULL); 267 Py_DECREF (textobj); 268 Py_DECREF (wordobj); 269 if (!resultobj) 270 { 271 /* Just swallow errors here. */ 272 PyErr_Clear (); 273 } 274 275 Py_XINCREF (resultobj); 276 277 return resultobj; 278 } 279 280 /* Python function called to determine the break characters of a 281 certain completer. We are only interested in knowing if the 282 completer registered by the user will return one of the integer 283 codes (see COMPLETER_* symbols). */ 284 285 static void 286 cmdpy_completer_handle_brkchars (struct cmd_list_element *command, 287 const char *text, const char *word) 288 { 289 PyObject *resultobj = NULL; 290 struct cleanup *cleanup; 291 292 cleanup = ensure_python_env (get_current_arch (), current_language); 293 294 /* Calling our helper to obtain the PyObject of the Python 295 function. */ 296 resultobj = cmdpy_completer_helper (command, text, word); 297 298 /* Check if there was an error. */ 299 if (resultobj == NULL) 300 goto done; 301 302 if (PyInt_Check (resultobj)) 303 { 304 /* User code may also return one of the completion constants, 305 thus requesting that sort of completion. We are only 306 interested in this kind of return. */ 307 long value; 308 309 if (!gdb_py_int_as_long (resultobj, &value)) 310 { 311 /* Ignore. */ 312 PyErr_Clear (); 313 } 314 else if (value >= 0 && value < (long) N_COMPLETERS) 315 { 316 /* This is the core of this function. Depending on which 317 completer type the Python function returns, we have to 318 adjust the break characters accordingly. */ 319 set_gdb_completion_word_break_characters 320 (completers[value].completer); 321 } 322 } 323 324 done: 325 326 Py_XDECREF (resultobj); 327 do_cleanups (cleanup); 328 } 329 330 /* Called by gdb for command completion. */ 331 332 static VEC (char_ptr) * 333 cmdpy_completer (struct cmd_list_element *command, 334 const char *text, const char *word) 335 { 336 PyObject *resultobj = NULL; 337 VEC (char_ptr) *result = NULL; 338 struct cleanup *cleanup; 339 340 cleanup = ensure_python_env (get_current_arch (), current_language); 341 342 /* Calling our helper to obtain the PyObject of the Python 343 function. */ 344 resultobj = cmdpy_completer_helper (command, text, word); 345 346 /* If the result object of calling the Python function is NULL, it 347 means that there was an error. In this case, just give up and 348 return NULL. */ 349 if (resultobj == NULL) 350 goto done; 351 352 result = NULL; 353 if (PyInt_Check (resultobj)) 354 { 355 /* User code may also return one of the completion constants, 356 thus requesting that sort of completion. */ 357 long value; 358 359 if (! gdb_py_int_as_long (resultobj, &value)) 360 { 361 /* Ignore. */ 362 PyErr_Clear (); 363 } 364 else if (value >= 0 && value < (long) N_COMPLETERS) 365 result = completers[value].completer (command, text, word); 366 } 367 else 368 { 369 PyObject *iter = PyObject_GetIter (resultobj); 370 PyObject *elt; 371 372 if (iter == NULL) 373 goto done; 374 375 while ((elt = PyIter_Next (iter)) != NULL) 376 { 377 char *item; 378 379 if (! gdbpy_is_string (elt)) 380 { 381 /* Skip problem elements. */ 382 Py_DECREF (elt); 383 continue; 384 } 385 item = python_string_to_host_string (elt); 386 Py_DECREF (elt); 387 if (item == NULL) 388 { 389 /* Skip problem elements. */ 390 PyErr_Clear (); 391 continue; 392 } 393 VEC_safe_push (char_ptr, result, item); 394 } 395 396 Py_DECREF (iter); 397 398 /* If we got some results, ignore problems. Otherwise, report 399 the problem. */ 400 if (result != NULL && PyErr_Occurred ()) 401 PyErr_Clear (); 402 } 403 404 done: 405 406 Py_XDECREF (resultobj); 407 do_cleanups (cleanup); 408 409 return result; 410 } 411 412 /* Helper for cmdpy_init which locates the command list to use and 413 pulls out the command name. 414 415 NAME is the command name list. The final word in the list is the 416 name of the new command. All earlier words must be existing prefix 417 commands. 418 419 *BASE_LIST is set to the final prefix command's list of 420 *sub-commands. 421 422 START_LIST is the list in which the search starts. 423 424 This function returns the xmalloc()d name of the new command. On 425 error sets the Python error and returns NULL. */ 426 427 char * 428 gdbpy_parse_command_name (const char *name, 429 struct cmd_list_element ***base_list, 430 struct cmd_list_element **start_list) 431 { 432 struct cmd_list_element *elt; 433 int len = strlen (name); 434 int i, lastchar; 435 char *prefix_text; 436 const char *prefix_text2; 437 char *result; 438 439 /* Skip trailing whitespace. */ 440 for (i = len - 1; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i) 441 ; 442 if (i < 0) 443 { 444 PyErr_SetString (PyExc_RuntimeError, _("No command name found.")); 445 return NULL; 446 } 447 lastchar = i; 448 449 /* Find first character of the final word. */ 450 for (; i > 0 && (isalnum (name[i - 1]) 451 || name[i - 1] == '-' 452 || name[i - 1] == '_'); 453 --i) 454 ; 455 result = (char *) xmalloc (lastchar - i + 2); 456 memcpy (result, &name[i], lastchar - i + 1); 457 result[lastchar - i + 1] = '\0'; 458 459 /* Skip whitespace again. */ 460 for (--i; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i) 461 ; 462 if (i < 0) 463 { 464 *base_list = start_list; 465 return result; 466 } 467 468 prefix_text = (char *) xmalloc (i + 2); 469 memcpy (prefix_text, name, i + 1); 470 prefix_text[i + 1] = '\0'; 471 472 prefix_text2 = prefix_text; 473 elt = lookup_cmd_1 (&prefix_text2, *start_list, NULL, 1); 474 if (elt == NULL || elt == CMD_LIST_AMBIGUOUS) 475 { 476 PyErr_Format (PyExc_RuntimeError, _("Could not find command prefix %s."), 477 prefix_text); 478 xfree (prefix_text); 479 xfree (result); 480 return NULL; 481 } 482 483 if (elt->prefixlist) 484 { 485 xfree (prefix_text); 486 *base_list = elt->prefixlist; 487 return result; 488 } 489 490 PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command."), 491 prefix_text); 492 xfree (prefix_text); 493 xfree (result); 494 return NULL; 495 } 496 497 /* Object initializer; sets up gdb-side structures for command. 498 499 Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]). 500 501 NAME is the name of the command. It may consist of multiple words, 502 in which case the final word is the name of the new command, and 503 earlier words must be prefix commands. 504 505 COMMAND_CLASS is the kind of command. It should be one of the COMMAND_* 506 constants defined in the gdb module. 507 508 COMPLETER_CLASS is the kind of completer. If not given, the 509 "complete" method will be used. Otherwise, it should be one of the 510 COMPLETE_* constants defined in the gdb module. 511 512 If PREFIX is True, then this command is a prefix command. 513 514 The documentation for the command is taken from the doc string for 515 the python class. */ 516 517 static int 518 cmdpy_init (PyObject *self, PyObject *args, PyObject *kw) 519 { 520 cmdpy_object *obj = (cmdpy_object *) self; 521 const char *name; 522 int cmdtype; 523 int completetype = -1; 524 char *docstring = NULL; 525 struct cmd_list_element **cmd_list; 526 char *cmd_name, *pfx_name; 527 static char *keywords[] = { "name", "command_class", "completer_class", 528 "prefix", NULL }; 529 PyObject *is_prefix = NULL; 530 int cmp; 531 532 if (obj->command) 533 { 534 /* Note: this is apparently not documented in Python. We return 535 0 for success, -1 for failure. */ 536 PyErr_Format (PyExc_RuntimeError, 537 _("Command object already initialized.")); 538 return -1; 539 } 540 541 if (! PyArg_ParseTupleAndKeywords (args, kw, "si|iO", 542 keywords, &name, &cmdtype, 543 &completetype, &is_prefix)) 544 return -1; 545 546 if (cmdtype != no_class && cmdtype != class_run 547 && cmdtype != class_vars && cmdtype != class_stack 548 && cmdtype != class_files && cmdtype != class_support 549 && cmdtype != class_info && cmdtype != class_breakpoint 550 && cmdtype != class_trace && cmdtype != class_obscure 551 && cmdtype != class_maintenance && cmdtype != class_user) 552 { 553 PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument.")); 554 return -1; 555 } 556 557 if (completetype < -1 || completetype >= (int) N_COMPLETERS) 558 { 559 PyErr_Format (PyExc_RuntimeError, 560 _("Invalid completion type argument.")); 561 return -1; 562 } 563 564 cmd_name = gdbpy_parse_command_name (name, &cmd_list, &cmdlist); 565 if (! cmd_name) 566 return -1; 567 568 pfx_name = NULL; 569 if (is_prefix != NULL) 570 { 571 cmp = PyObject_IsTrue (is_prefix); 572 if (cmp == 1) 573 { 574 int i, out; 575 576 /* Make a normalized form of the command name. */ 577 pfx_name = (char *) xmalloc (strlen (name) + 2); 578 579 i = 0; 580 out = 0; 581 while (name[i]) 582 { 583 /* Skip whitespace. */ 584 while (name[i] == ' ' || name[i] == '\t') 585 ++i; 586 /* Copy non-whitespace characters. */ 587 while (name[i] && name[i] != ' ' && name[i] != '\t') 588 pfx_name[out++] = name[i++]; 589 /* Add a single space after each word -- including the final 590 word. */ 591 pfx_name[out++] = ' '; 592 } 593 pfx_name[out] = '\0'; 594 } 595 else if (cmp < 0) 596 { 597 xfree (cmd_name); 598 return -1; 599 } 600 } 601 if (PyObject_HasAttr (self, gdbpy_doc_cst)) 602 { 603 PyObject *ds_obj = PyObject_GetAttr (self, gdbpy_doc_cst); 604 605 if (ds_obj && gdbpy_is_string (ds_obj)) 606 { 607 docstring = python_string_to_host_string (ds_obj); 608 if (docstring == NULL) 609 { 610 xfree (cmd_name); 611 xfree (pfx_name); 612 Py_DECREF (ds_obj); 613 return -1; 614 } 615 } 616 617 Py_XDECREF (ds_obj); 618 } 619 if (! docstring) 620 docstring = xstrdup (_("This command is not documented.")); 621 622 Py_INCREF (self); 623 624 TRY 625 { 626 struct cmd_list_element *cmd; 627 628 if (pfx_name) 629 { 630 int allow_unknown; 631 632 /* If we have our own "invoke" method, then allow unknown 633 sub-commands. */ 634 allow_unknown = PyObject_HasAttr (self, invoke_cst); 635 cmd = add_prefix_cmd (cmd_name, (enum command_class) cmdtype, 636 NULL, docstring, &obj->sub_list, 637 pfx_name, allow_unknown, cmd_list); 638 } 639 else 640 cmd = add_cmd (cmd_name, (enum command_class) cmdtype, NULL, 641 docstring, cmd_list); 642 643 /* There appears to be no API to set this. */ 644 cmd->func = cmdpy_function; 645 cmd->destroyer = cmdpy_destroyer; 646 647 obj->command = cmd; 648 set_cmd_context (cmd, self); 649 set_cmd_completer (cmd, ((completetype == -1) ? cmdpy_completer 650 : completers[completetype].completer)); 651 if (completetype == -1) 652 set_cmd_completer_handle_brkchars (cmd, 653 cmdpy_completer_handle_brkchars); 654 } 655 CATCH (except, RETURN_MASK_ALL) 656 { 657 xfree (cmd_name); 658 xfree (docstring); 659 xfree (pfx_name); 660 Py_DECREF (self); 661 PyErr_Format (except.reason == RETURN_QUIT 662 ? PyExc_KeyboardInterrupt : PyExc_RuntimeError, 663 "%s", except.message); 664 return -1; 665 } 666 END_CATCH 667 668 return 0; 669 } 670 671 672 673 /* Initialize the 'commands' code. */ 674 675 int 676 gdbpy_initialize_commands (void) 677 { 678 int i; 679 680 cmdpy_object_type.tp_new = PyType_GenericNew; 681 if (PyType_Ready (&cmdpy_object_type) < 0) 682 return -1; 683 684 /* Note: alias and user are special; pseudo appears to be unused, 685 and there is no reason to expose tui, I think. */ 686 if (PyModule_AddIntConstant (gdb_module, "COMMAND_NONE", no_class) < 0 687 || PyModule_AddIntConstant (gdb_module, "COMMAND_RUNNING", class_run) < 0 688 || PyModule_AddIntConstant (gdb_module, "COMMAND_DATA", class_vars) < 0 689 || PyModule_AddIntConstant (gdb_module, "COMMAND_STACK", class_stack) < 0 690 || PyModule_AddIntConstant (gdb_module, "COMMAND_FILES", class_files) < 0 691 || PyModule_AddIntConstant (gdb_module, "COMMAND_SUPPORT", 692 class_support) < 0 693 || PyModule_AddIntConstant (gdb_module, "COMMAND_STATUS", class_info) < 0 694 || PyModule_AddIntConstant (gdb_module, "COMMAND_BREAKPOINTS", 695 class_breakpoint) < 0 696 || PyModule_AddIntConstant (gdb_module, "COMMAND_TRACEPOINTS", 697 class_trace) < 0 698 || PyModule_AddIntConstant (gdb_module, "COMMAND_OBSCURE", 699 class_obscure) < 0 700 || PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE", 701 class_maintenance) < 0 702 || PyModule_AddIntConstant (gdb_module, "COMMAND_USER", class_user) < 0) 703 return -1; 704 705 for (i = 0; i < N_COMPLETERS; ++i) 706 { 707 if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0) 708 return -1; 709 } 710 711 if (gdb_pymodule_addobject (gdb_module, "Command", 712 (PyObject *) &cmdpy_object_type) < 0) 713 return -1; 714 715 invoke_cst = PyString_FromString ("invoke"); 716 if (invoke_cst == NULL) 717 return -1; 718 complete_cst = PyString_FromString ("complete"); 719 if (complete_cst == NULL) 720 return -1; 721 722 return 0; 723 } 724 725 726 727 static PyMethodDef cmdpy_object_methods[] = 728 { 729 { "dont_repeat", cmdpy_dont_repeat, METH_NOARGS, 730 "Prevent command repetition when user enters empty line." }, 731 732 { 0 } 733 }; 734 735 PyTypeObject cmdpy_object_type = 736 { 737 PyVarObject_HEAD_INIT (NULL, 0) 738 "gdb.Command", /*tp_name*/ 739 sizeof (cmdpy_object), /*tp_basicsize*/ 740 0, /*tp_itemsize*/ 741 0, /*tp_dealloc*/ 742 0, /*tp_print*/ 743 0, /*tp_getattr*/ 744 0, /*tp_setattr*/ 745 0, /*tp_compare*/ 746 0, /*tp_repr*/ 747 0, /*tp_as_number*/ 748 0, /*tp_as_sequence*/ 749 0, /*tp_as_mapping*/ 750 0, /*tp_hash */ 751 0, /*tp_call*/ 752 0, /*tp_str*/ 753 0, /*tp_getattro*/ 754 0, /*tp_setattro*/ 755 0, /*tp_as_buffer*/ 756 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 757 "GDB command object", /* tp_doc */ 758 0, /* tp_traverse */ 759 0, /* tp_clear */ 760 0, /* tp_richcompare */ 761 0, /* tp_weaklistoffset */ 762 0, /* tp_iter */ 763 0, /* tp_iternext */ 764 cmdpy_object_methods, /* tp_methods */ 765 0, /* tp_members */ 766 0, /* tp_getset */ 767 0, /* tp_base */ 768 0, /* tp_dict */ 769 0, /* tp_descr_get */ 770 0, /* tp_descr_set */ 771 0, /* tp_dictoffset */ 772 cmdpy_init, /* tp_init */ 773 0, /* tp_alloc */ 774 }; 775 776 777 778 /* Utility to build a buildargv-like result from ARGS. 779 This intentionally parses arguments the way libiberty/argv.c:buildargv 780 does. It splits up arguments in a reasonable way, and we want a standard 781 way of parsing arguments. Several gdb commands use buildargv to parse their 782 arguments. Plus we want to be able to write compatible python 783 implementations of gdb commands. */ 784 785 PyObject * 786 gdbpy_string_to_argv (PyObject *self, PyObject *args) 787 { 788 PyObject *py_argv; 789 const char *input; 790 791 if (!PyArg_ParseTuple (args, "s", &input)) 792 return NULL; 793 794 py_argv = PyList_New (0); 795 if (py_argv == NULL) 796 return NULL; 797 798 /* buildargv uses NULL to represent an empty argument list, but we can't use 799 that in Python. Instead, if ARGS is "" then return an empty list. 800 This undoes the NULL -> "" conversion that cmdpy_function does. */ 801 802 if (*input != '\0') 803 { 804 char **c_argv = gdb_buildargv (input); 805 int i; 806 807 for (i = 0; c_argv[i] != NULL; ++i) 808 { 809 PyObject *argp = PyString_FromString (c_argv[i]); 810 811 if (argp == NULL 812 || PyList_Append (py_argv, argp) < 0) 813 { 814 Py_XDECREF (argp); 815 Py_DECREF (py_argv); 816 freeargv (c_argv); 817 return NULL; 818 } 819 Py_DECREF (argp); 820 } 821 822 freeargv (c_argv); 823 } 824 825 return py_argv; 826 } 827