Make command line editing (use of readline) be per UI
[external/binutils.git] / gdb / interps.c
1 /* Manages interpreters for GDB, the GNU debugger.
2
3    Copyright (C) 2000-2016 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 "top.h"                /* For command_loop.  */
40 #include "continuations.h"
41
42 /* Each UI has its own independent set of interpreters.  */
43
44 struct ui_interp_info
45 {
46   /* Each top level has its own independent set of interpreters.  */
47   struct interp *interp_list;
48   struct interp *current_interpreter;
49   struct interp *top_level_interpreter;
50
51   /* The interpreter that is active while `interp_exec' is active, NULL
52      at all other times.  */
53   struct interp *command_interpreter;
54 };
55
56 /* Get UI's ui_interp_info object.  Never returns NULL.  */
57
58 static struct ui_interp_info *
59 get_interp_info (struct ui *ui)
60 {
61   if (ui->interp_info == NULL)
62     ui->interp_info = XCNEW (struct ui_interp_info);
63   return ui->interp_info;
64 }
65
66 /* Get the current UI's ui_interp_info object.  Never returns
67    NULL.  */
68
69 static struct ui_interp_info *
70 get_current_interp_info (void)
71 {
72   return get_interp_info (current_ui);
73 }
74
75 struct interp
76 {
77   /* This is the name in "-i=" and set interpreter.  */
78   const char *name;
79
80   /* Interpreters are stored in a linked list, this is the next
81      one...  */
82   struct interp *next;
83
84   /* This is a cookie that an instance of the interpreter can use.
85      This is a bit confused right now as the exact initialization
86      sequence for it, and how it relates to the interpreter's uiout
87      object is a bit confused.  */
88   void *data;
89
90   /* Has the init_proc been run?  */
91   int inited;
92
93   const struct interp_procs *procs;
94   int quiet_p;
95 };
96
97 /* The magic initialization routine for this module.  */
98
99 void _initialize_interpreter (void);
100
101 static struct interp *interp_lookup_existing (struct ui *ui,
102                                               const char *name);
103
104 /* interp_new - This allocates space for a new interpreter,
105    fills the fields from the inputs, and returns a pointer to the
106    interpreter.  */
107 struct interp *
108 interp_new (const char *name, const struct interp_procs *procs, void *data)
109 {
110   struct interp *new_interp;
111
112   new_interp = XNEW (struct interp);
113
114   new_interp->name = xstrdup (name);
115   new_interp->data = data;
116   new_interp->quiet_p = 0;
117   new_interp->procs = procs;
118   new_interp->inited = 0;
119
120   /* Check for required procs.  */
121   gdb_assert (procs->command_loop_proc != NULL);
122
123   return new_interp;
124 }
125
126 /* An interpreter factory.  Maps an interpreter name to the factory
127    function that instantiates an interpreter by that name.  */
128
129 struct interp_factory
130 {
131   /* This is the name in "-i=INTERP" and "interpreter-exec INTERP".  */
132   const char *name;
133
134   /* The function that creates the interpreter.  */
135   interp_factory_func func;
136 };
137
138 typedef struct interp_factory *interp_factory_p;
139 DEF_VEC_P(interp_factory_p);
140
141 /* The registered interpreter factories.  */
142 static VEC(interp_factory_p) *interpreter_factories = NULL;
143
144 /* See interps.h.  */
145
146 void
147 interp_factory_register (const char *name, interp_factory_func func)
148 {
149   struct interp_factory *f;
150   int ix;
151
152   /* Assert that no factory for NAME is already registered.  */
153   for (ix = 0;
154        VEC_iterate (interp_factory_p, interpreter_factories, ix, f);
155        ++ix)
156     if (strcmp (f->name, name) == 0)
157       {
158         internal_error (__FILE__, __LINE__,
159                         _("interpreter factory already registered: \"%s\"\n"),
160                         name);
161       }
162
163   f = XNEW (struct interp_factory);
164   f->name = name;
165   f->func = func;
166   VEC_safe_push (interp_factory_p, interpreter_factories, f);
167 }
168
169 /* Add interpreter INTERP to the gdb interpreter list.  The
170    interpreter must not have previously been added.  */
171 void
172 interp_add (struct ui *ui, struct interp *interp)
173 {
174   struct ui_interp_info *ui_interp = get_interp_info (ui);
175
176   gdb_assert (interp_lookup_existing (ui, interp->name) == NULL);
177
178   interp->next = ui_interp->interp_list;
179   ui_interp->interp_list = interp;
180 }
181
182 /* This sets the current interpreter to be INTERP.  If INTERP has not
183    been initialized, then this will also run the init proc.  If the
184    init proc is successful, return 1, if it fails, set the old
185    interpreter back in place and return 0.  If we can't restore the
186    old interpreter, then raise an internal error, since we are in
187    pretty bad shape at this point.
188
189    The TOP_LEVEL parameter tells if this new interpreter is
190    the top-level one.  The top-level is what is requested
191    on the command line, and is responsible for reporting general
192    notification about target state changes.  For example, if
193    MI is the top-level interpreter, then it will always report
194    events such as target stops and new thread creation, even if they
195    are caused by CLI commands.  */
196 int
197 interp_set (struct interp *interp, int top_level)
198 {
199   struct ui_interp_info *ui_interp = get_current_interp_info ();
200   struct interp *old_interp = ui_interp->current_interpreter;
201   int first_time = 0;
202   char buffer[64];
203
204   /* If we already have an interpreter, then trying to
205      set top level interpreter is kinda pointless.  */
206   gdb_assert (!top_level || !ui_interp->current_interpreter);
207   gdb_assert (!top_level || !ui_interp->top_level_interpreter);
208
209   if (old_interp != NULL)
210     {
211       ui_out_flush (current_uiout);
212       if (old_interp->procs->suspend_proc
213           && !old_interp->procs->suspend_proc (old_interp->data))
214         {
215           error (_("Could not suspend interpreter \"%s\"."),
216                  old_interp->name);
217         }
218     }
219   else
220     {
221       first_time = 1;
222     }
223
224   ui_interp->current_interpreter = interp;
225   if (top_level)
226     ui_interp->top_level_interpreter = interp;
227
228   /* We use interpreter_p for the "set interpreter" variable, so we need
229      to make sure we have a malloc'ed copy for the set command to free.  */
230   if (interpreter_p != NULL
231       && strcmp (interp->name, interpreter_p) != 0)
232     {
233       xfree (interpreter_p);
234
235       interpreter_p = xstrdup (interp->name);
236     }
237
238   /* Run the init proc.  If it fails, try to restore the old interp.  */
239
240   if (!interp->inited)
241     {
242       if (interp->procs->init_proc != NULL)
243         {
244           interp->data = interp->procs->init_proc (interp, top_level);
245         }
246       interp->inited = 1;
247     }
248
249   /* Do this only after the interpreter is initialized.  */
250   current_uiout = interp->procs->ui_out_proc (interp);
251
252   /* Clear out any installed interpreter hooks/event handlers.  */
253   clear_interpreter_hooks ();
254
255   if (interp->procs->resume_proc != NULL
256       && (!interp->procs->resume_proc (interp->data)))
257     {
258       if (old_interp == NULL || !interp_set (old_interp, 0))
259         internal_error (__FILE__, __LINE__,
260                         _("Failed to initialize new interp \"%s\" %s"),
261                         interp->name, "and could not restore old interp!\n");
262       return 0;
263     }
264
265   if (!first_time && !interp_quiet_p (interp))
266     {
267       xsnprintf (buffer, sizeof (buffer),
268                  "Switching to interpreter \"%.24s\".\n", interp->name);
269       ui_out_text (current_uiout, buffer);
270     }
271
272   return 1;
273 }
274
275 /* Look up the interpreter for NAME.  If no such interpreter exists,
276    return NULL, otherwise return a pointer to the interpreter.  */
277
278 static struct interp *
279 interp_lookup_existing (struct ui *ui, const char *name)
280 {
281   struct ui_interp_info *ui_interp = get_interp_info (ui);
282   struct interp *interp;
283
284   for (interp = ui_interp->interp_list;
285        interp != NULL;
286        interp = interp->next)
287     {
288       if (strcmp (interp->name, name) == 0)
289         return interp;
290     }
291
292   return NULL;
293 }
294
295 /* See interps.h.  */
296
297 struct interp *
298 interp_lookup (struct ui *ui, const char *name)
299 {
300   struct interp_factory *factory;
301   struct interp *interp;
302   int ix;
303
304   if (name == NULL || strlen (name) == 0)
305     return NULL;
306
307   /* Only create each interpreter once per top level.  */
308   interp = interp_lookup_existing (ui, name);
309   if (interp != NULL)
310     return interp;
311
312   for (ix = 0;
313        VEC_iterate (interp_factory_p, interpreter_factories, ix, factory);
314        ++ix)
315     if (strcmp (factory->name, name) == 0)
316       {
317         interp = factory->func (name);
318         interp_add (ui, interp);
319         return interp;
320       }
321
322   return NULL;
323 }
324
325 /* Returns the current interpreter.  */
326
327 struct ui_out *
328 interp_ui_out (struct interp *interp)
329 {
330   struct ui_interp_info *ui_interp = get_current_interp_info ();
331
332   if (interp == NULL)
333     interp = ui_interp->current_interpreter;
334   return interp->procs->ui_out_proc (interp);
335 }
336
337 int
338 current_interp_set_logging (int start_log, struct ui_file *out,
339                             struct ui_file *logfile)
340 {
341   struct ui_interp_info *ui_interp = get_current_interp_info ();
342   struct interp *interp = ui_interp->current_interpreter;
343
344   if (interp == NULL
345       || interp->procs->set_logging_proc == NULL)
346     return 0;
347
348   return interp->procs->set_logging_proc (interp, start_log, out, logfile);
349 }
350
351 /* Temporarily overrides the current interpreter.  */
352 struct interp *
353 interp_set_temp (const char *name)
354 {
355   struct ui_interp_info *ui_interp = get_current_interp_info ();
356   struct interp *interp = interp_lookup (current_ui, name);
357   struct interp *old_interp = ui_interp->current_interpreter;
358
359   if (interp)
360     ui_interp->current_interpreter = interp;
361   return old_interp;
362 }
363
364 /* Returns the interpreter's cookie.  */
365
366 void *
367 interp_data (struct interp *interp)
368 {
369   return interp->data;
370 }
371
372 /* Returns the interpreter's name.  */
373
374 const char *
375 interp_name (struct interp *interp)
376 {
377   return interp->name;
378 }
379
380 /* Returns true if the current interp is the passed in name.  */
381 int
382 current_interp_named_p (const char *interp_name)
383 {
384   struct ui_interp_info *ui_interp = get_current_interp_info ();
385   struct interp *interp = ui_interp->current_interpreter;
386
387   if (interp != NULL)
388     return (strcmp (interp->name, interp_name) == 0);
389
390   return 0;
391 }
392
393 /* The interpreter that was active when a command was executed.
394    Normally that'd always be CURRENT_INTERPRETER, except that MI's
395    -interpreter-exec command doesn't actually flip the current
396    interpreter when running its sub-command.  The
397    `command_interpreter' global tracks when interp_exec is called
398    (IOW, when -interpreter-exec is called).  If that is set, it is
399    INTERP in '-interpreter-exec INTERP "CMD"' or in 'interpreter-exec
400    INTERP "CMD".  Otherwise, interp_exec isn't active, and so the
401    interpreter running the command is the current interpreter.  */
402
403 struct interp *
404 command_interp (void)
405 {
406   struct ui_interp_info *ui_interp = get_current_interp_info ();
407
408   if (ui_interp->command_interpreter != NULL)
409     return ui_interp->command_interpreter;
410   else
411     return ui_interp->current_interpreter;
412 }
413
414 /* Run the current command interpreter's main loop.  */
415 void
416 current_interp_command_loop (void)
417 {
418   struct ui_interp_info *ui_interp = get_current_interp_info ();
419   struct interp *interp = ui_interp->current_interpreter;
420
421   gdb_assert (ui_interp->current_interpreter != NULL);
422
423   interp->procs->command_loop_proc (interp->data);
424 }
425
426 /* See interp.h  */
427
428 int
429 interp_supports_command_editing (struct interp *interp)
430 {
431   if (interp->procs->supports_command_editing_proc != NULL)
432     return interp->procs->supports_command_editing_proc (interp);
433   return 0;
434 }
435
436 int
437 interp_quiet_p (struct interp *interp)
438 {
439   struct ui_interp_info *ui_interp = get_current_interp_info ();
440
441   if (interp != NULL)
442     return interp->quiet_p;
443   else
444     return ui_interp->current_interpreter->quiet_p;
445 }
446
447 static int
448 interp_set_quiet (struct interp *interp, int quiet)
449 {
450   int old_val = interp->quiet_p;
451
452   interp->quiet_p = quiet;
453   return old_val;
454 }
455
456 /* interp_exec - This executes COMMAND_STR in the current 
457    interpreter.  */
458
459 struct gdb_exception
460 interp_exec (struct interp *interp, const char *command_str)
461 {
462   struct ui_interp_info *ui_interp = get_current_interp_info ();
463
464   struct gdb_exception ex;
465   struct interp *save_command_interp;
466
467   gdb_assert (interp->procs->exec_proc != NULL);
468
469   /* See `command_interp' for why we do this.  */
470   save_command_interp = ui_interp->command_interpreter;
471   ui_interp->command_interpreter = interp;
472
473   ex = interp->procs->exec_proc (interp->data, command_str);
474
475   ui_interp->command_interpreter = save_command_interp;
476
477   return ex;
478 }
479
480 /* A convenience routine that nulls out all the common command hooks.
481    Use it when removing your interpreter in its suspend proc.  */
482 void
483 clear_interpreter_hooks (void)
484 {
485   deprecated_print_frame_info_listing_hook = 0;
486   /*print_frame_more_info_hook = 0; */
487   deprecated_query_hook = 0;
488   deprecated_warning_hook = 0;
489   deprecated_interactive_hook = 0;
490   deprecated_readline_begin_hook = 0;
491   deprecated_readline_hook = 0;
492   deprecated_readline_end_hook = 0;
493   deprecated_context_hook = 0;
494   deprecated_target_wait_hook = 0;
495   deprecated_call_command_hook = 0;
496   deprecated_error_begin_hook = 0;
497 }
498
499 static void
500 interpreter_exec_cmd (char *args, int from_tty)
501 {
502   struct ui_interp_info *ui_interp = get_current_interp_info ();
503   struct interp *old_interp, *interp_to_use;
504   char **prules = NULL;
505   char **trule = NULL;
506   unsigned int nrules;
507   unsigned int i;
508   int old_quiet, use_quiet;
509   struct cleanup *cleanup;
510
511   if (args == NULL)
512     error_no_arg (_("interpreter-exec command"));
513
514   prules = gdb_buildargv (args);
515   cleanup = make_cleanup_freeargv (prules);
516
517   nrules = 0;
518   for (trule = prules; *trule != NULL; trule++)
519     nrules++;
520
521   if (nrules < 2)
522     error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
523
524   old_interp = ui_interp->current_interpreter;
525
526   interp_to_use = interp_lookup (current_ui, prules[0]);
527   if (interp_to_use == NULL)
528     error (_("Could not find interpreter \"%s\"."), prules[0]);
529
530   /* Temporarily set interpreters quiet.  */
531   old_quiet = interp_set_quiet (old_interp, 1);
532   use_quiet = interp_set_quiet (interp_to_use, 1);
533
534   if (!interp_set (interp_to_use, 0))
535     error (_("Could not switch to interpreter \"%s\"."), prules[0]);
536
537   for (i = 1; i < nrules; i++)
538     {
539       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
540
541       if (e.reason < 0)
542         {
543           interp_set (old_interp, 0);
544           interp_set_quiet (interp_to_use, use_quiet);
545           interp_set_quiet (old_interp, old_quiet);
546           error (_("error in command: \"%s\"."), prules[i]);
547         }
548     }
549
550   interp_set (old_interp, 0);
551   interp_set_quiet (interp_to_use, use_quiet);
552   interp_set_quiet (old_interp, old_quiet);
553
554   do_cleanups (cleanup);
555 }
556
557 /* List the possible interpreters which could complete the given text.  */
558 static VEC (char_ptr) *
559 interpreter_completer (struct cmd_list_element *ignore,
560                        const char *text, const char *word)
561 {
562   struct interp_factory *interp;
563   int textlen;
564   VEC (char_ptr) *matches = NULL;
565   int ix;
566
567   textlen = strlen (text);
568   for (ix = 0;
569        VEC_iterate (interp_factory_p, interpreter_factories, ix, interp);
570        ++ix)
571     {
572       if (strncmp (interp->name, text, textlen) == 0)
573         {
574           char *match;
575
576           match = (char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
577           if (word == text)
578             strcpy (match, interp->name);
579           else if (word > text)
580             {
581               /* Return some portion of interp->name.  */
582               strcpy (match, interp->name + (word - text));
583             }
584           else
585             {
586               /* Return some of text plus interp->name.  */
587               strncpy (match, word, text - word);
588               match[text - word] = '\0';
589               strcat (match, interp->name);
590             }
591           VEC_safe_push (char_ptr, matches, match);
592         }
593     }
594
595   return matches;
596 }
597
598 struct interp *
599 top_level_interpreter (void)
600 {
601   struct ui_interp_info *ui_interp = get_current_interp_info ();
602
603   return ui_interp->top_level_interpreter;
604 }
605
606 void *
607 top_level_interpreter_data (void)
608 {
609   struct interp *interp;
610
611   interp = top_level_interpreter ();
612   gdb_assert (interp != NULL);
613   return interp->data;
614 }
615
616 /* This just adds the "interpreter-exec" command.  */
617 void
618 _initialize_interpreter (void)
619 {
620   struct cmd_list_element *c;
621
622   c = add_cmd ("interpreter-exec", class_support,
623                interpreter_exec_cmd, _("\
624 Execute a command in an interpreter.  It takes two arguments:\n\
625 The first argument is the name of the interpreter to use.\n\
626 The second argument is the command to execute.\n"), &cmdlist);
627   set_cmd_completer (c, interpreter_completer);
628 }