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.  `deprecated_command_loop_hook'
272     should be deprecated.  */
273  if (deprecated_command_loop_hook != NULL)
274    deprecated_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
279    cli_command_loop ();
280}
281
282int
283interp_quiet_p (struct interp *interp)
284{
285  if (interp != NULL)
286    return interp->quiet_p;
287  else
288    return current_interpreter->quiet_p;
289}
290
291static int
292interp_set_quiet (struct interp *interp, int quiet)
293{
294  int old_val = interp->quiet_p;
295  interp->quiet_p = quiet;
296  return old_val;
297}
298
299/* interp_exec - This executes COMMAND_STR in the current
300   interpreter. */
301int
302interp_exec_p (struct interp *interp)
303{
304  return interp->procs->exec_proc != NULL;
305}
306
307int
308interp_exec (struct interp *interp, const char *command_str)
309{
310  if (interp->procs->exec_proc != NULL)
311    {
312      return interp->procs->exec_proc (interp->data, command_str);
313    }
314  return 0;
315}
316
317/* A convenience routine that nulls out all the
318   common command hooks.  Use it when removing your interpreter in its
319   suspend proc. */
320void
321clear_interpreter_hooks (void)
322{
323  deprecated_init_ui_hook = 0;
324  deprecated_print_frame_info_listing_hook = 0;
325  /*print_frame_more_info_hook = 0; */
326  deprecated_query_hook = 0;
327  deprecated_warning_hook = 0;
328  deprecated_create_breakpoint_hook = 0;
329  deprecated_delete_breakpoint_hook = 0;
330  deprecated_modify_breakpoint_hook = 0;
331  deprecated_interactive_hook = 0;
332  deprecated_registers_changed_hook = 0;
333  deprecated_readline_begin_hook = 0;
334  deprecated_readline_hook = 0;
335  deprecated_readline_end_hook = 0;
336  deprecated_register_changed_hook = 0;
337  deprecated_memory_changed_hook = 0;
338  deprecated_context_hook = 0;
339  deprecated_target_wait_hook = 0;
340  deprecated_call_command_hook = 0;
341  deprecated_error_hook = 0;
342  deprecated_error_begin_hook = 0;
343  deprecated_command_loop_hook = 0;
344  clear_gdb_event_hooks ();
345}
346
347/* This is a lazy init routine, called the first time
348   the interpreter module is used.  I put it here just in case, but I haven't
349   thought of a use for it yet.  I will probably bag it soon, since I don't
350   think it will be necessary. */
351static void
352initialize_interps (void)
353{
354  interpreter_initialized = 1;
355  /* Don't know if anything needs to be done here... */
356}
357
358static void
359interpreter_exec_cmd (char *args, int from_tty)
360{
361  struct interp *old_interp, *interp_to_use;
362  char **prules = NULL;
363  char **trule = NULL;
364  unsigned int nrules;
365  unsigned int i;
366  int old_quiet, use_quiet;
367
368  prules = buildargv (args);
369  if (prules == NULL)
370    {
371      error ("unable to parse arguments");
372    }
373
374  nrules = 0;
375  if (prules != NULL)
376    {
377      for (trule = prules; *trule != NULL; trule++)
378	{
379	  nrules++;
380	}
381    }
382
383  if (nrules < 2)
384    error ("usage: interpreter-exec <interpreter> [ <command> ... ]");
385
386  old_interp = current_interpreter;
387
388  interp_to_use = interp_lookup (prules[0]);
389  if (interp_to_use == NULL)
390    error ("Could not find interpreter \"%s\".", prules[0]);
391
392  /* Temporarily set interpreters quiet */
393  old_quiet = interp_set_quiet (old_interp, 1);
394  use_quiet = interp_set_quiet (interp_to_use, 1);
395
396  if (!interp_set (interp_to_use))
397    error ("Could not switch to interpreter \"%s\".", prules[0]);
398
399  for (i = 1; i < nrules; i++)
400    {
401      if (!interp_exec (interp_to_use, prules[i]))
402	{
403	  interp_set (old_interp);
404	  interp_set_quiet (interp_to_use, old_quiet);
405	  error ("error in command: \"%s\".", prules[i]);
406	  break;
407	}
408    }
409
410  interp_set (old_interp);
411  interp_set_quiet (interp_to_use, use_quiet);
412  interp_set_quiet (old_interp, old_quiet);
413}
414
415/* List the possible interpreters which could complete the given text. */
416static char **
417interpreter_completer (char *text, char *word)
418{
419  int alloced = 0;
420  int textlen;
421  int num_matches;
422  char **matches;
423  struct interp *interp;
424
425  /* We expect only a very limited number of interpreters, so just
426     allocate room for all of them. */
427  for (interp = interp_list; interp != NULL; interp = interp->next)
428    ++alloced;
429  matches = (char **) xmalloc (alloced * sizeof (char *));
430
431  num_matches = 0;
432  textlen = strlen (text);
433  for (interp = interp_list; interp != NULL; interp = interp->next)
434    {
435      if (strncmp (interp->name, text, textlen) == 0)
436	{
437	  matches[num_matches] =
438	    (char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
439	  if (word == text)
440	    strcpy (matches[num_matches], interp->name);
441	  else if (word > text)
442	    {
443	      /* Return some portion of interp->name */
444	      strcpy (matches[num_matches], interp->name + (word - text));
445	    }
446	  else
447	    {
448	      /* Return some of text plus interp->name */
449	      strncpy (matches[num_matches], word, text - word);
450	      matches[num_matches][text - word] = '\0';
451	      strcat (matches[num_matches], interp->name);
452	    }
453	  ++num_matches;
454	}
455    }
456
457  if (num_matches == 0)
458    {
459      xfree (matches);
460      matches = NULL;
461    }
462  else if (num_matches < alloced)
463    {
464      matches = (char **) xrealloc ((char *) matches, ((num_matches + 1)
465						       * sizeof (char *)));
466      matches[num_matches] = NULL;
467    }
468
469  return matches;
470}
471
472/* This just adds the "interpreter-exec" command.  */
473void
474_initialize_interpreter (void)
475{
476  struct cmd_list_element *c;
477
478  c = add_cmd ("interpreter-exec", class_support,
479	       interpreter_exec_cmd,
480	       "Execute a command in an interpreter.  It takes two arguments:\n\
481The first argument is the name of the interpreter to use.\n\
482The second argument is the command to execute.\n", &cmdlist);
483  set_cmd_completer (c, interpreter_completer);
484}
485