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