OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [python/] [py-cmd.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* gdb commands implemented in Python
2
 
3
   Copyright (C) 2008, 2009, 2010 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 "exceptions.h"
25
#include "python-internal.h"
26
#include "charset.h"
27
#include "gdbcmd.h"
28
#include "cli/cli-decode.h"
29
#include "completer.h"
30
#include "language.h"
31
 
32
/* Struct representing built-in completion types.  */
33
struct cmdpy_completer
34
{
35
  /* Python symbol name.  */
36
  char *name;
37
  /* Completion function.  */
38
  char **(*completer) (struct cmd_list_element *, char *, char *);
39
};
40
 
41
static struct cmdpy_completer completers[] =
42
{
43
  { "COMPLETE_NONE", noop_completer },
44
  { "COMPLETE_FILENAME", filename_completer },
45
  { "COMPLETE_LOCATION", location_completer },
46
  { "COMPLETE_COMMAND", command_completer },
47
  { "COMPLETE_SYMBOL", make_symbol_completion_list_fn },
48
};
49
 
50
#define N_COMPLETERS (sizeof (completers) / sizeof (completers[0]))
51
 
52
/* A gdb command.  For the time being only ordinary commands (not
53
   set/show commands) are allowed.  */
54
struct cmdpy_object
55
{
56
  PyObject_HEAD
57
 
58
  /* The corresponding gdb command object, or NULL if the command is
59
     no longer installed.  */
60
  struct cmd_list_element *command;
61
 
62
  /* A prefix command requires storage for a list of its sub-commands.
63
     A pointer to this is passed to add_prefix_command, and to add_cmd
64
     for sub-commands of that prefix.  If this Command is not a prefix
65
     command, then this field is unused.  */
66
  struct cmd_list_element *sub_list;
67
};
68
 
69
typedef struct cmdpy_object cmdpy_object;
70
 
71
static PyTypeObject cmdpy_object_type;
72
 
73
 
74
/* Constants used by this module.  */
75
static PyObject *invoke_cst;
76
static PyObject *complete_cst;
77
 
78
 
79
 
80
/* Python function which wraps dont_repeat.  */
81
static PyObject *
82
cmdpy_dont_repeat (PyObject *self, PyObject *args)
83
{
84
  dont_repeat ();
85
  Py_RETURN_NONE;
86
}
87
 
88
 
89
 
90
/* Called if the gdb cmd_list_element is destroyed.  */
91
static void
92
cmdpy_destroyer (struct cmd_list_element *self, void *context)
93
{
94
  cmdpy_object *cmd;
95
  struct cleanup *cleanup;
96
 
97
  cleanup = ensure_python_env (get_current_arch (), current_language);
98
 
99
  /* Release our hold on the command object.  */
100
  cmd = (cmdpy_object *) context;
101
  cmd->command = NULL;
102
  Py_DECREF (cmd);
103
 
104
  /* We allocated the name, doc string, and perhaps the prefix
105
     name.  */
106
  xfree (self->name);
107
  xfree (self->doc);
108
  xfree (self->prefixname);
109
 
110
  do_cleanups (cleanup);
111
}
112
 
113
/* Called by gdb to invoke the command.  */
114
static void
115
cmdpy_function (struct cmd_list_element *command, char *args, int from_tty)
116
{
117
  cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
118
  PyObject *argobj, *ttyobj, *result;
119
  struct cleanup *cleanup;
120
 
121
  cleanup = ensure_python_env (get_current_arch (), current_language);
122
 
123
  if (! obj)
124
    error (_("Invalid invocation of Python command object."));
125
  if (! PyObject_HasAttr ((PyObject *) obj, invoke_cst))
126
    {
127
      if (obj->command->prefixname)
128
        {
129
          /* A prefix command does not need an invoke method.  */
130
          do_cleanups (cleanup);
131
          return;
132
        }
133
      error (_("Python command object missing 'invoke' method."));
134
    }
135
 
136
  if (! args)
137
    args = "";
138
  argobj = PyUnicode_Decode (args, strlen (args), host_charset (), NULL);
139
  if (! argobj)
140
    error (_("Could not convert arguments to Python string."));
141
 
142
  ttyobj = from_tty ? Py_True : Py_False;
143
  Py_INCREF (ttyobj);
144
  result = PyObject_CallMethodObjArgs ((PyObject *) obj, invoke_cst, argobj,
145
                                       ttyobj, NULL);
146
  Py_DECREF (argobj);
147
  Py_DECREF (ttyobj);
148
  if (! result)
149
    {
150
      PyObject *ptype, *pvalue, *ptraceback;
151
      char *s, *str;
152
 
153
      PyErr_Fetch (&ptype, &pvalue, &ptraceback);
154
 
155
      if (pvalue && PyString_Check (pvalue))
156
        {
157
          /* Make a temporary copy of the string data.  */
158
          char *s = PyString_AsString (pvalue);
159
          char *copy = alloca (strlen (s) + 1);
160
          strcpy (copy, s);
161
 
162
          PyErr_Restore (ptype, pvalue, ptraceback);
163
          gdbpy_print_stack ();
164
          error (_("Error occurred in Python command: %s"), copy);
165
        }
166
      else
167
        {
168
          PyErr_Restore (ptype, pvalue, ptraceback);
169
          gdbpy_print_stack ();
170
          error (_("Error occurred in Python command."));
171
        }
172
    }
173
  Py_DECREF (result);
174
  do_cleanups (cleanup);
175
}
176
 
177
/* Called by gdb for command completion.  */
178
static char **
179
cmdpy_completer (struct cmd_list_element *command, char *text, char *word)
180
{
181
  cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
182
  PyObject *textobj, *wordobj, *resultobj = NULL;
183
  char **result = NULL;
184
  struct cleanup *cleanup;
185
 
186
  cleanup = ensure_python_env (get_current_arch (), current_language);
187
 
188
  if (! obj)
189
    error (_("Invalid invocation of Python command object."));
190
  if (! PyObject_HasAttr ((PyObject *) obj, complete_cst))
191
    {
192
      /* If there is no complete method, don't error -- instead, just
193
         say that there are no completions.  */
194
      goto done;
195
    }
196
 
197
  textobj = PyUnicode_Decode (text, strlen (text), host_charset (), NULL);
198
  if (! textobj)
199
    error (_("Could not convert argument to Python string."));
200
  wordobj = PyUnicode_Decode (word, strlen (word), host_charset (), NULL);
201
  if (! wordobj)
202
    error (_("Could not convert argument to Python string."));
203
 
204
  resultobj = PyObject_CallMethodObjArgs ((PyObject *) obj, complete_cst,
205
                                          textobj, wordobj, NULL);
206
  Py_DECREF (textobj);
207
  Py_DECREF (wordobj);
208
  if (! resultobj)
209
    {
210
      /* Just swallow errors here.  */
211
      PyErr_Clear ();
212
      goto done;
213
    }
214
  make_cleanup_py_decref (resultobj);
215
 
216
  result = NULL;
217
  if (PySequence_Check (resultobj))
218
    {
219
      Py_ssize_t i, len = PySequence_Size (resultobj);
220
      Py_ssize_t out;
221
      if (len < 0)
222
        goto done;
223
 
224
      result = (char **) xmalloc ((len + 1) * sizeof (char *));
225
      for (i = out = 0; i < len; ++i)
226
        {
227
          int l;
228
          PyObject *elt = PySequence_GetItem (resultobj, i);
229
          if (elt == NULL || ! gdbpy_is_string (elt))
230
            {
231
              /* Skip problem elements.  */
232
              PyErr_Clear ();
233
              continue;
234
            }
235
          result[out] = python_string_to_host_string (elt);
236
          ++out;
237
        }
238
      result[out] = NULL;
239
    }
240
  else if (PyInt_Check (resultobj))
241
    {
242
      /* User code may also return one of the completion constants,
243
         thus requesting that sort of completion.  */
244
      long value = PyInt_AsLong (resultobj);
245
      if (value >= 0 && value < (long) N_COMPLETERS)
246
        result = completers[value].completer (command, text, word);
247
    }
248
 
249
 done:
250
 
251
  do_cleanups (cleanup);
252
 
253
  return result;
254
}
255
 
256
/* Helper for cmdpy_init which locates the command list to use and
257
   pulls out the command name.
258
 
259
   TEXT is the command name list.  The final word in the list is the
260
   name of the new command.  All earlier words must be existing prefix
261
   commands.
262
 
263
   *BASE_LIST is set to the final prefix command's list of
264
   *sub-commands.
265
 
266
   This function returns the xmalloc()d name of the new command.  On
267
   error sets the Python error and returns NULL.  */
268
static char *
269
parse_command_name (char *text, struct cmd_list_element ***base_list)
270
{
271
  struct cmd_list_element *elt;
272
  int len = strlen (text);
273
  int i, lastchar;
274
  char *prefix_text;
275
  char *result;
276
 
277
  /* Skip trailing whitespace.  */
278
  for (i = len - 1; i >= 0 && (text[i] == ' ' || text[i] == '\t'); --i)
279
    ;
280
  if (i < 0)
281
    {
282
      PyErr_SetString (PyExc_RuntimeError, _("no command name found"));
283
      return NULL;
284
    }
285
  lastchar = i;
286
 
287
  /* Find first character of the final word.  */
288
  for (; i > 0 && (isalnum (text[i - 1])
289
                   || text[i - 1] == '-'
290
                   || text[i - 1] == '_');
291
       --i)
292
    ;
293
  result = xmalloc (lastchar - i + 2);
294
  memcpy (result, &text[i], lastchar - i + 1);
295
  result[lastchar - i + 1] = '\0';
296
 
297
  /* Skip whitespace again.  */
298
  for (--i; i >= 0 && (text[i] == ' ' || text[i] == '\t'); --i)
299
    ;
300
  if (i < 0)
301
    {
302
      *base_list = &cmdlist;
303
      return result;
304
    }
305
 
306
  prefix_text = xmalloc (i + 2);
307
  memcpy (prefix_text, text, i + 1);
308
  prefix_text[i + 1] = '\0';
309
 
310
  text = prefix_text;
311
  elt = lookup_cmd_1 (&text, cmdlist, NULL, 1);
312
  if (!elt || elt == (struct cmd_list_element *) -1)
313
    {
314
      PyErr_Format (PyExc_RuntimeError, _("could not find command prefix %s"),
315
                    prefix_text);
316
      xfree (prefix_text);
317
      xfree (result);
318
      return NULL;
319
    }
320
 
321
  if (elt->prefixlist)
322
    {
323
      xfree (prefix_text);
324
      *base_list = elt->prefixlist;
325
      return result;
326
    }
327
 
328
  PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command"),
329
                prefix_text);
330
  xfree (prefix_text);
331
  xfree (result);
332
  return NULL;
333
}
334
 
335
/* Object initializer; sets up gdb-side structures for command.
336
 
337
   Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]).
338
 
339
   NAME is the name of the command.  It may consist of multiple words,
340
   in which case the final word is the name of the new command, and
341
   earlier words must be prefix commands.
342
 
343
   COMMAND_CLASS is the kind of command.  It should be one of the COMMAND_*
344
   constants defined in the gdb module.
345
 
346
   COMPLETER_CLASS is the kind of completer.  If not given, the
347
   "complete" method will be used.  Otherwise, it should be one of the
348
   COMPLETE_* constants defined in the gdb module.
349
 
350
   If PREFIX is True, then this command is a prefix command.
351
 
352
   The documentation for the command is taken from the doc string for
353
   the python class.
354
 
355
*/
356
static int
357
cmdpy_init (PyObject *self, PyObject *args, PyObject *kw)
358
{
359
  cmdpy_object *obj = (cmdpy_object *) self;
360
  char *name;
361
  int cmdtype;
362
  int completetype = -1;
363
  char *docstring = NULL;
364
  volatile struct gdb_exception except;
365
  struct cmd_list_element **cmd_list;
366
  char *cmd_name, *pfx_name;
367
  static char *keywords[] = { "name", "command_class", "completer_class",
368
                              "prefix", NULL };
369
  PyObject *is_prefix = NULL;
370
  int cmp;
371
 
372
  if (obj->command)
373
    {
374
      /* Note: this is apparently not documented in Python.  We return
375
 
376
      PyErr_Format (PyExc_RuntimeError,
377
                    _("command object already initialized"));
378
      return -1;
379
    }
380
 
381
  if (! PyArg_ParseTupleAndKeywords (args, kw, "si|iO", keywords, &name, &cmdtype,
382
                          &completetype, &is_prefix))
383
    return -1;
384
 
385
  if (cmdtype != no_class && cmdtype != class_run
386
      && cmdtype != class_vars && cmdtype != class_stack
387
      && cmdtype != class_files && cmdtype != class_support
388
      && cmdtype != class_info && cmdtype != class_breakpoint
389
      && cmdtype != class_trace && cmdtype != class_obscure
390
      && cmdtype != class_maintenance)
391
    {
392
      PyErr_Format (PyExc_RuntimeError, _("invalid command class argument"));
393
      return -1;
394
    }
395
 
396
  if (completetype < -1 || completetype >= (int) N_COMPLETERS)
397
    {
398
      PyErr_Format (PyExc_RuntimeError, _("invalid completion type argument"));
399
      return -1;
400
    }
401
 
402
  cmd_name = parse_command_name (name, &cmd_list);
403
  if (! cmd_name)
404
    return -1;
405
 
406
  pfx_name = NULL;
407
  if (is_prefix != NULL)
408
    {
409
      cmp = PyObject_IsTrue (is_prefix);
410
      if (cmp == 1)
411
        {
412
          int i, out;
413
 
414
          /* Make a normalized form of the command name.  */
415
          pfx_name = xmalloc (strlen (name) + 2);
416
 
417
          i = 0;
418
          out = 0;
419
          while (name[i])
420
            {
421
              /* Skip whitespace.  */
422
              while (name[i] == ' ' || name[i] == '\t')
423
                ++i;
424
              /* Copy non-whitespace characters.  */
425
              while (name[i] && name[i] != ' ' && name[i] != '\t')
426
                pfx_name[out++] = name[i++];
427
              /* Add a single space after each word -- including the final
428
                 word.  */
429
              pfx_name[out++] = ' ';
430
            }
431
          pfx_name[out] = '\0';
432
        }
433
      else if (cmp < 0)
434
          return -1;
435
    }
436
  if (PyObject_HasAttr (self, gdbpy_doc_cst))
437
    {
438
      PyObject *ds_obj = PyObject_GetAttr (self, gdbpy_doc_cst);
439
      if (ds_obj && gdbpy_is_string (ds_obj))
440
        docstring = python_string_to_host_string (ds_obj);
441
    }
442
  if (! docstring)
443
    docstring = xstrdup (_("This command is not documented."));
444
 
445
  Py_INCREF (self);
446
 
447
  TRY_CATCH (except, RETURN_MASK_ALL)
448
    {
449
      struct cmd_list_element *cmd;
450
 
451
      if (pfx_name)
452
        {
453
          int allow_unknown;
454
 
455
          /* If we have our own "invoke" method, then allow unknown
456
             sub-commands.  */
457
          allow_unknown = PyObject_HasAttr (self, invoke_cst);
458
          cmd = add_prefix_cmd (cmd_name, (enum command_class) cmdtype,
459
                                NULL, docstring, &obj->sub_list,
460
                                pfx_name, allow_unknown, cmd_list);
461
        }
462
      else
463
        cmd = add_cmd (cmd_name, (enum command_class) cmdtype, NULL,
464
                       docstring, cmd_list);
465
 
466
      /* There appears to be no API to set this.  */
467
      cmd->func = cmdpy_function;
468
      cmd->destroyer = cmdpy_destroyer;
469
 
470
      obj->command = cmd;
471
      set_cmd_context (cmd, self);
472
      set_cmd_completer (cmd, ((completetype == -1) ? cmdpy_completer
473
                               : completers[completetype].completer));
474
    }
475
  if (except.reason < 0)
476
    {
477
      xfree (cmd_name);
478
      xfree (docstring);
479
      xfree (pfx_name);
480
      Py_DECREF (self);
481
      PyErr_Format (except.reason == RETURN_QUIT
482
                    ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
483
                    "%s", except.message);
484
      return -1;
485
    }
486
  return 0;
487
}
488
 
489
 
490
 
491
/* Initialize the 'commands' code.  */
492
void
493
gdbpy_initialize_commands (void)
494
{
495
  int i;
496
 
497
  if (PyType_Ready (&cmdpy_object_type) < 0)
498
    return;
499
 
500
  /* Note: alias and user are special; pseudo appears to be unused,
501
     and there is no reason to expose tui or xdb, I think.  */
502
  if (PyModule_AddIntConstant (gdb_module, "COMMAND_NONE", no_class) < 0
503
      || PyModule_AddIntConstant (gdb_module, "COMMAND_RUNNING", class_run) < 0
504
      || PyModule_AddIntConstant (gdb_module, "COMMAND_DATA", class_vars) < 0
505
      || PyModule_AddIntConstant (gdb_module, "COMMAND_STACK", class_stack) < 0
506
      || PyModule_AddIntConstant (gdb_module, "COMMAND_FILES", class_files) < 0
507
      || PyModule_AddIntConstant (gdb_module, "COMMAND_SUPPORT",
508
                                  class_support) < 0
509
      || PyModule_AddIntConstant (gdb_module, "COMMAND_STATUS", class_info) < 0
510
      || PyModule_AddIntConstant (gdb_module, "COMMAND_BREAKPOINTS",
511
                                  class_breakpoint) < 0
512
      || PyModule_AddIntConstant (gdb_module, "COMMAND_TRACEPOINTS",
513
                                  class_trace) < 0
514
      || PyModule_AddIntConstant (gdb_module, "COMMAND_OBSCURE",
515
                                  class_obscure) < 0
516
      || PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE",
517
                                  class_maintenance) < 0)
518
    return;
519
 
520
  for (i = 0; i < N_COMPLETERS; ++i)
521
    {
522
      if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0)
523
        return;
524
    }
525
 
526
  Py_INCREF (&cmdpy_object_type);
527
  PyModule_AddObject (gdb_module, "Command",
528
                      (PyObject *) &cmdpy_object_type);
529
 
530
  invoke_cst = PyString_FromString ("invoke");
531
  complete_cst = PyString_FromString ("complete");
532
}
533
 
534
 
535
 
536
static PyMethodDef cmdpy_object_methods[] =
537
{
538
  { "dont_repeat", cmdpy_dont_repeat, METH_NOARGS,
539
    "Prevent command repetition when user enters empty line." },
540
 
541
  { 0 }
542
};
543
 
544
static PyTypeObject cmdpy_object_type =
545
{
546
  PyObject_HEAD_INIT (NULL)
547
  0,                               /*ob_size*/
548
  "gdb.Command",                  /*tp_name*/
549
  sizeof (cmdpy_object),          /*tp_basicsize*/
550
  0,                               /*tp_itemsize*/
551
  0,                               /*tp_dealloc*/
552
  0,                               /*tp_print*/
553
  0,                               /*tp_getattr*/
554
  0,                               /*tp_setattr*/
555
  0,                               /*tp_compare*/
556
  0,                               /*tp_repr*/
557
  0,                               /*tp_as_number*/
558
  0,                               /*tp_as_sequence*/
559
  0,                               /*tp_as_mapping*/
560
  0,                               /*tp_hash */
561
  0,                               /*tp_call*/
562
  0,                               /*tp_str*/
563
  0,                               /*tp_getattro*/
564
  0,                               /*tp_setattro*/
565
  0,                               /*tp_as_buffer*/
566
  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
567
  "GDB command object",           /* tp_doc */
568
  0,                               /* tp_traverse */
569
  0,                               /* tp_clear */
570
  0,                               /* tp_richcompare */
571
  0,                               /* tp_weaklistoffset */
572
  0,                               /* tp_iter */
573
  0,                               /* tp_iternext */
574
  cmdpy_object_methods,           /* tp_methods */
575
  0,                               /* tp_members */
576
  0,                               /* tp_getset */
577
  0,                               /* tp_base */
578
  0,                               /* tp_dict */
579
  0,                               /* tp_descr_get */
580
  0,                               /* tp_descr_set */
581
  0,                               /* tp_dictoffset */
582
  cmdpy_init,                     /* tp_init */
583
  0,                               /* tp_alloc */
584
  PyType_GenericNew               /* tp_new */
585
};

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.