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