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