]> Git Repo - binutils.git/blob - gdb/python/py-cmd.c
83337899c28b4fe522551f3a57330e9ab36c7a4f
[binutils.git] / gdb / python / py-cmd.c
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 \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.065466 seconds and 2 git commands to generate.