GDB (xrefs)
py-cmd.c
Go to the documentation of this file.
1 /* gdb commands implemented in Python
2 
3  Copyright (C) 2008-2015 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. */
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. */
57 {
58  PyObject_HEAD
59 
60  /* The corresponding gdb command object, or NULL if the command is
61  no longer installed. */
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. */
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 
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 
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  {
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"));
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);
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 *
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
287  const char *text, const char *word)
288 {
289  PyObject *resultobj = NULL;
290  struct cleanup *cleanup;
291 
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. */
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 
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 *
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 = 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 = 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 = 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)
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
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 }
int gdb_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
Definition: py-utils.c:437
void set_cmd_context(struct cmd_list_element *cmd, void *context)
Definition: cli-decode.c:141
#define Py_DECREF(op)
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
PyTypeObject cmdpy_object_type
Definition: py-cmd.c:735
struct cmdpy_object cmdpy_object
Definition: py-cmd.c:71
struct cmd_list_element * sub_list
Definition: py-cmd.c:68
void * get_cmd_context(struct cmd_list_element *cmd)
Definition: cli-decode.c:147
void xfree(void *)
Definition: common-utils.c:97
int gdbpy_is_string(PyObject *obj)
Definition: py-utils.c:228
unsigned int allow_unknown
Definition: cli-decode.h:91
static void cmdpy_completer_handle_brkchars(struct cmd_list_element *command, const char *text, const char *word)
Definition: py-cmd.c:286
struct cmd_list_element * lookup_cmd_1(const char **text, struct cmd_list_element *clist, struct cmd_list_element **result_list, int ignore_help_classes)
Definition: cli-decode.c:1332
char * name
Definition: py-cmd.c:37
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:103
static PyObject * cmdpy_dont_repeat(PyObject *self, PyObject *args)
Definition: py-cmd.c:84
#define _(String)
Definition: gdb_locale.h:40
char * char_ptr
Definition: gdb_vecs.h:25
#define END_CATCH
void printf_filtered(const char *format,...)
Definition: utils.c:2388
static PyObject * invoke_cst
Definition: py-cmd.c:77
#define TRY
void set_cmd_completer_handle_brkchars(struct cmd_list_element *cmd, completer_ftype_void *completer_handle_brkchars)
Definition: cli-decode.c:167
const char *const name
Definition: aarch64-tdep.c:68
PyObject * gdbpy_doc_cst
Definition: python.c:119
static VEC(char_ptr)
Definition: py-cmd.c:332
#define CATCH(EXCEPTION, MASK)
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:159
void(* destroyer)(struct cmd_list_element *self, void *context)
Definition: cli-decode.h:191
PyObject_HEAD struct cmd_list_element * command
Definition: py-cmd.c:62
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
static void cmdpy_destroyer(struct cmd_list_element *self, void *context)
Definition: py-cmd.c:95
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
char * python_string_to_host_string(PyObject *obj)
Definition: py-utils.c:210
int gdbpy_initialize_commands(void)
Definition: py-cmd.c:676
const char * word
Definition: symtab.h:1448
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:781
char * gdbpy_parse_command_name(const char *name, struct cmd_list_element ***base_list, struct cmd_list_element **start_list)
Definition: py-cmd.c:428
struct cleanup * ensure_python_env(struct gdbarch *gdbarch, const struct language_defn *language)
Definition: python.c:247
static PyObject * complete_cst
Definition: py-cmd.c:78
PyObject * gdbpy_gdberror_exc
Definition: python.c:124
#define CMD_LIST_AMBIGUOUS
Definition: command.h:193
void * xmalloc(YYSIZE_T)
PyTypeObject cmdpy_object_type CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("cmdpy_object")
void set_gdb_completion_word_break_characters(completer_ftype *fn)
Definition: completer.c:461
Definition: value.c:172
static PyMethodDef cmdpy_object_methods[]
Definition: py-cmd.c:727
static int cmdpy_init(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-cmd.c:518
static void cmdpy_function(struct cmd_list_element *command, char *args, int from_tty)
Definition: py-cmd.c:119
PyObject * gdbpy_string_to_argv(PyObject *self, PyObject *args)
Definition: py-cmd.c:786
const struct language_defn * current_language
Definition: language.c:85
command_class
Definition: command.h:33
void gdbpy_print_stack(void)
Definition: python.c:1199
void(* func)(struct cmd_list_element *c, char *args, int from_tty)
Definition: cli-decode.h:111
char ** gdb_buildargv(const char *s)
Definition: utils.c:3036
completer_ftype * completer
Definition: py-cmd.c:39
int gdb_py_int_as_long(PyObject *obj, long *result)
Definition: py-utils.c:407
struct cmd_list_element ** prefixlist
Definition: cli-decode.h:152
PyObject * gdb_module
Definition: python.c:112
const char * host_charset(void)
Definition: charset.c:399
void dont_repeat(void)
Definition: top.c:582
completer_ftype * completer
Definition: cli-decode.h:177
static PyObject * cmdpy_completer_helper(struct cmd_list_element *command, const char *text, const char *word)
Definition: py-cmd.c:240
const char * prefixname
Definition: cli-decode.h:159
#define N_COMPLETERS
Definition: py-cmd.c:52
void error(const char *fmt,...)
Definition: errors.c:38
char * gdbpy_exception_to_string(PyObject *ptype, PyObject *pvalue)
Definition: py-utils.c:268
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
const ULONGEST const LONGEST len
Definition: target.h:309
#define PyVarObject_HEAD_INIT(type, size)