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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [interps.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Manages interpreters for GDB, the GNU debugger.
2
 
3
   Copyright (C) 2000, 2002, 2003, 2007, 2008 Free Software Foundation, Inc.
4
 
5
   Written by Jim Ingham <jingham@apple.com> of Apple Computer, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
21
 
22
/* This is just a first cut at separating out the "interpreter"
23
   functions of gdb into self-contained modules.  There are a couple
24
   of open areas that need to be sorted out:
25
 
26
   1) The interpreter explicitly contains a UI_OUT, and can insert itself
27
   into the event loop, but it doesn't explicitly contain hooks for readline.
28
   I did this because it seems to me many interpreters won't want to use
29
   the readline command interface, and it is probably simpler to just let
30
   them take over the input in their resume proc.  */
31
 
32
#include "defs.h"
33
#include "gdbcmd.h"
34
#include "ui-out.h"
35
#include "event-loop.h"
36
#include "event-top.h"
37
#include "interps.h"
38
#include "completer.h"
39
#include "gdb_string.h"
40
#include "gdb-events.h"
41
#include "gdb_assert.h"
42
#include "top.h"                /* For command_loop.  */
43
#include "exceptions.h"
44
 
45
struct interp
46
{
47
  /* This is the name in "-i=" and set interpreter. */
48
  const char *name;
49
 
50
  /* Interpreters are stored in a linked list, this is the next
51
     one...  */
52
  struct interp *next;
53
 
54
  /* This is a cookie that an instance of the interpreter can use.
55
     This is a bit confused right now as the exact initialization
56
     sequence for it, and how it relates to the interpreter's uiout
57
     object is a bit confused.  */
58
  void *data;
59
 
60
  /* Has the init_proc been run? */
61
  int inited;
62
 
63
  /* This is the ui_out used to collect results for this interpreter.
64
     It can be a formatter for stdout, as is the case for the console
65
     & mi outputs, or it might be a result formatter.  */
66
  struct ui_out *interpreter_out;
67
 
68
  const struct interp_procs *procs;
69
  int quiet_p;
70
};
71
 
72
/* Functions local to this file. */
73
static void initialize_interps (void);
74
static char **interpreter_completer (char *text, char *word);
75
 
76
/* The magic initialization routine for this module. */
77
 
78
void _initialize_interpreter (void);
79
 
80
/* Variables local to this file: */
81
 
82
static struct interp *interp_list = NULL;
83
static struct interp *current_interpreter = NULL;
84
 
85
static int interpreter_initialized = 0;
86
 
87
/* interp_new - This allocates space for a new interpreter,
88
   fills the fields from the inputs, and returns a pointer to the
89
   interpreter. */
90
struct interp *
91
interp_new (const char *name, void *data, struct ui_out *uiout,
92
            const struct interp_procs *procs)
93
{
94
  struct interp *new_interp;
95
 
96
  new_interp = XMALLOC (struct interp);
97
 
98
  new_interp->name = xstrdup (name);
99
  new_interp->data = data;
100
  new_interp->interpreter_out = uiout;
101
  new_interp->quiet_p = 0;
102
  new_interp->procs = procs;
103
  new_interp->inited = 0;
104
 
105
  return new_interp;
106
}
107
 
108
/* Add interpreter INTERP to the gdb interpreter list.  The
109
   interpreter must not have previously been added.  */
110
void
111
interp_add (struct interp *interp)
112
{
113
  if (!interpreter_initialized)
114
    initialize_interps ();
115
 
116
  gdb_assert (interp_lookup (interp->name) == NULL);
117
 
118
  interp->next = interp_list;
119
  interp_list = interp;
120
}
121
 
122
/* This sets the current interpreter to be INTERP.  If INTERP has not
123
   been initialized, then this will also run the init proc.  If the
124
   init proc is successful, return 1, if it fails, set the old
125
   interpreter back in place and return 0.  If we can't restore the
126
   old interpreter, then raise an internal error, since we are in
127
   pretty bad shape at this point. */
128
int
129
interp_set (struct interp *interp)
130
{
131
  struct interp *old_interp = current_interpreter;
132
  int first_time = 0;
133
 
134
 
135
  char buffer[64];
136
 
137
  if (current_interpreter != NULL)
138
    {
139
      do_all_continuations ();
140
      ui_out_flush (uiout);
141
      if (current_interpreter->procs->suspend_proc
142
          && !current_interpreter->procs->suspend_proc (current_interpreter->
143
                                                        data))
144
        {
145
          error (_("Could not suspend interpreter \"%s\"."),
146
                 current_interpreter->name);
147
        }
148
    }
149
  else
150
    {
151
      first_time = 1;
152
    }
153
 
154
  current_interpreter = interp;
155
 
156
  /* We use interpreter_p for the "set interpreter" variable, so we need
157
     to make sure we have a malloc'ed copy for the set command to free. */
158
  if (interpreter_p != NULL
159
      && strcmp (current_interpreter->name, interpreter_p) != 0)
160
    {
161
      xfree (interpreter_p);
162
 
163
      interpreter_p = xstrdup (current_interpreter->name);
164
    }
165
 
166
  uiout = interp->interpreter_out;
167
 
168
  /* Run the init proc.  If it fails, try to restore the old interp. */
169
 
170
  if (!interp->inited)
171
    {
172
      if (interp->procs->init_proc != NULL)
173
        {
174
          interp->data = interp->procs->init_proc ();
175
        }
176
      interp->inited = 1;
177
    }
178
 
179
  /* Clear out any installed interpreter hooks/event handlers.  */
180
  clear_interpreter_hooks ();
181
 
182
  if (interp->procs->resume_proc != NULL
183
      && (!interp->procs->resume_proc (interp->data)))
184
    {
185
      if (old_interp == NULL || !interp_set (old_interp))
186
        internal_error (__FILE__, __LINE__,
187
                        _("Failed to initialize new interp \"%s\" %s"),
188
                        interp->name, "and could not restore old interp!\n");
189
      return 0;
190
    }
191
 
192
  /* Finally, put up the new prompt to show that we are indeed here.
193
     Also, display_gdb_prompt for the console does some readline magic
194
     which is needed for the console interpreter, at least... */
195
 
196
  if (!first_time)
197
    {
198
      if (!interp_quiet_p (interp))
199
        {
200
          sprintf (buffer, "Switching to interpreter \"%.24s\".\n",
201
                   interp->name);
202
          ui_out_text (uiout, buffer);
203
        }
204
      display_gdb_prompt (NULL);
205
    }
206
 
207
  return 1;
208
}
209
 
210
/* interp_lookup - Looks up the interpreter for NAME.  If no such
211
   interpreter exists, return NULL, otherwise return a pointer to the
212
   interpreter.  */
213
struct interp *
214
interp_lookup (const char *name)
215
{
216
  struct interp *interp;
217
 
218
  if (name == NULL || strlen (name) == 0)
219
    return NULL;
220
 
221
  for (interp = interp_list; interp != NULL; interp = interp->next)
222
    {
223
      if (strcmp (interp->name, name) == 0)
224
        return interp;
225
    }
226
 
227
  return NULL;
228
}
229
 
230
/* Returns the current interpreter. */
231
 
232
struct ui_out *
233
interp_ui_out (struct interp *interp)
234
{
235
  if (interp != NULL)
236
    return interp->interpreter_out;
237
 
238
  return current_interpreter->interpreter_out;
239
}
240
 
241
/* Returns true if the current interp is the passed in name. */
242
int
243
current_interp_named_p (const char *interp_name)
244
{
245
  if (current_interpreter)
246
    return (strcmp (current_interpreter->name, interp_name) == 0);
247
 
248
  return 0;
249
}
250
 
251
/* This is called in display_gdb_prompt.  If the proc returns a zero
252
   value, display_gdb_prompt will return without displaying the
253
   prompt.  */
254
int
255
current_interp_display_prompt_p (void)
256
{
257
  if (current_interpreter == NULL
258
      || current_interpreter->procs->prompt_proc_p == NULL)
259
    return 0;
260
  else
261
    return current_interpreter->procs->prompt_proc_p (current_interpreter->
262
                                                      data);
263
}
264
 
265
/* Run the current command interpreter's main loop.  */
266
void
267
current_interp_command_loop (void)
268
{
269
  /* Somewhat messy.  For the moment prop up all the old ways of
270
     selecting the command loop.  `deprecated_command_loop_hook'
271
     should be deprecated.  */
272
  if (deprecated_command_loop_hook != NULL)
273
    deprecated_command_loop_hook ();
274
  else if (current_interpreter != NULL
275
           && current_interpreter->procs->command_loop_proc != NULL)
276
    current_interpreter->procs->command_loop_proc (current_interpreter->data);
277
  else
278
    cli_command_loop ();
279
}
280
 
281
int
282
interp_quiet_p (struct interp *interp)
283
{
284
  if (interp != NULL)
285
    return interp->quiet_p;
286
  else
287
    return current_interpreter->quiet_p;
288
}
289
 
290
static int
291
interp_set_quiet (struct interp *interp, int quiet)
292
{
293
  int old_val = interp->quiet_p;
294
  interp->quiet_p = quiet;
295
  return old_val;
296
}
297
 
298
/* interp_exec - This executes COMMAND_STR in the current
299
   interpreter. */
300
int
301
interp_exec_p (struct interp *interp)
302
{
303
  return interp->procs->exec_proc != NULL;
304
}
305
 
306
struct gdb_exception
307
interp_exec (struct interp *interp, const char *command_str)
308
{
309
  if (interp->procs->exec_proc != NULL)
310
    {
311
      return interp->procs->exec_proc (interp->data, command_str);
312
    }
313
  return exception_none;
314
}
315
 
316
/* A convenience routine that nulls out all the common command hooks.
317
   Use it when removing your interpreter in its suspend proc.  */
318
void
319
clear_interpreter_hooks (void)
320
{
321
  deprecated_init_ui_hook = 0;
322
  deprecated_print_frame_info_listing_hook = 0;
323
  /*print_frame_more_info_hook = 0; */
324
  deprecated_query_hook = 0;
325
  deprecated_warning_hook = 0;
326
  deprecated_create_breakpoint_hook = 0;
327
  deprecated_delete_breakpoint_hook = 0;
328
  deprecated_modify_breakpoint_hook = 0;
329
  deprecated_interactive_hook = 0;
330
  deprecated_readline_begin_hook = 0;
331
  deprecated_readline_hook = 0;
332
  deprecated_readline_end_hook = 0;
333
  deprecated_register_changed_hook = 0;
334
  deprecated_memory_changed_hook = 0;
335
  deprecated_context_hook = 0;
336
  deprecated_target_wait_hook = 0;
337
  deprecated_call_command_hook = 0;
338
  deprecated_error_hook = 0;
339
  deprecated_error_begin_hook = 0;
340
  deprecated_command_loop_hook = 0;
341
  clear_gdb_event_hooks ();
342
}
343
 
344
/* This is a lazy init routine, called the first time the interpreter
345
   module is used.  I put it here just in case, but I haven't thought
346
   of a use for it yet.  I will probably bag it soon, since I don't
347
   think it will be necessary.  */
348
static void
349
initialize_interps (void)
350
{
351
  interpreter_initialized = 1;
352
  /* Don't know if anything needs to be done here... */
353
}
354
 
355
static void
356
interpreter_exec_cmd (char *args, int from_tty)
357
{
358
  struct interp *old_interp, *interp_to_use;
359
  char **prules = NULL;
360
  char **trule = NULL;
361
  unsigned int nrules;
362
  unsigned int i;
363
  int old_quiet, use_quiet;
364
 
365
  prules = buildargv (args);
366
  if (prules == NULL)
367
    {
368
      error (_("unable to parse arguments"));
369
    }
370
 
371
  nrules = 0;
372
  if (prules != NULL)
373
    {
374
      for (trule = prules; *trule != NULL; trule++)
375
        {
376
          nrules++;
377
        }
378
    }
379
 
380
  if (nrules < 2)
381
    error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
382
 
383
  old_interp = current_interpreter;
384
 
385
  interp_to_use = interp_lookup (prules[0]);
386
  if (interp_to_use == NULL)
387
    error (_("Could not find interpreter \"%s\"."), prules[0]);
388
 
389
  /* Temporarily set interpreters quiet */
390
  old_quiet = interp_set_quiet (old_interp, 1);
391
  use_quiet = interp_set_quiet (interp_to_use, 1);
392
 
393
  if (!interp_set (interp_to_use))
394
    error (_("Could not switch to interpreter \"%s\"."), prules[0]);
395
 
396
  for (i = 1; i < nrules; i++)
397
    {
398
      struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
399
      if (e.reason < 0)
400
        {
401
          interp_set (old_interp);
402
          interp_set_quiet (interp_to_use, use_quiet);
403
          interp_set_quiet (old_interp, old_quiet);
404
          error (_("error in command: \"%s\"."), prules[i]);
405
        }
406
    }
407
 
408
  interp_set (old_interp);
409
  interp_set_quiet (interp_to_use, use_quiet);
410
  interp_set_quiet (old_interp, old_quiet);
411
}
412
 
413
/* List the possible interpreters which could complete the given text. */
414
static char **
415
interpreter_completer (char *text, char *word)
416
{
417
  int alloced = 0;
418
  int textlen;
419
  int num_matches;
420
  char **matches;
421
  struct interp *interp;
422
 
423
  /* We expect only a very limited number of interpreters, so just
424
     allocate room for all of them plus one for the last that must be NULL
425
     to correctly end the list. */
426
  for (interp = interp_list; interp != NULL; interp = interp->next)
427
    ++alloced;
428
  matches = (char **) xcalloc (alloced + 1, sizeof (char *));
429
 
430
  num_matches = 0;
431
  textlen = strlen (text);
432
  for (interp = interp_list; interp != NULL; interp = interp->next)
433
    {
434
      if (strncmp (interp->name, text, textlen) == 0)
435
        {
436
          matches[num_matches] =
437
            (char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
438
          if (word == text)
439
            strcpy (matches[num_matches], interp->name);
440
          else if (word > text)
441
            {
442
              /* Return some portion of interp->name */
443
              strcpy (matches[num_matches], interp->name + (word - text));
444
            }
445
          else
446
            {
447
              /* Return some of text plus interp->name */
448
              strncpy (matches[num_matches], word, text - word);
449
              matches[num_matches][text - word] = '\0';
450
              strcat (matches[num_matches], interp->name);
451
            }
452
          ++num_matches;
453
        }
454
    }
455
 
456
  if (num_matches == 0)
457
    {
458
      xfree (matches);
459
      matches = NULL;
460
    }
461
 
462
  return matches;
463
}
464
 
465
/* This just adds the "interpreter-exec" command.  */
466
void
467
_initialize_interpreter (void)
468
{
469
  struct cmd_list_element *c;
470
 
471
  c = add_cmd ("interpreter-exec", class_support,
472
               interpreter_exec_cmd, _("\
473
Execute a command in an interpreter.  It takes two arguments:\n\
474
The first argument is the name of the interpreter to use.\n\
475
The second argument is the command to execute.\n"), &cmdlist);
476
  set_cmd_completer (c, interpreter_completer);
477
}

powered by: WebSVN 2.1.0

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