1 /* Manages interpreters for GDB, the GNU debugger.
3 Copyright (C) 2000-2019 Free Software Foundation, Inc.
5 Written by Jim Ingham <jingham@apple.com> of Apple Computer, Inc.
7 This file is part of GDB.
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.
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.
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/>. */
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:
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. */
35 #include "event-loop.h"
36 #include "event-top.h"
38 #include "completer.h"
39 #include "top.h" /* For command_loop. */
40 #include "continuations.h"
43 /* Each UI has its own independent set of interpreters. */
47 /* Each top level has its own independent set of interpreters. */
48 struct interp *interp_list;
49 struct interp *current_interpreter;
50 struct interp *top_level_interpreter;
52 /* The interpreter that is active while `interp_exec' is active, NULL
53 at all other times. */
54 struct interp *command_interpreter;
57 /* Get UI's ui_interp_info object. Never returns NULL. */
59 static struct ui_interp_info *
60 get_interp_info (struct ui *ui)
62 if (ui->interp_info == NULL)
63 ui->interp_info = XCNEW (struct ui_interp_info);
64 return ui->interp_info;
67 /* Get the current UI's ui_interp_info object. Never returns
70 static struct ui_interp_info *
71 get_current_interp_info (void)
73 return get_interp_info (current_ui);
76 /* The magic initialization routine for this module. */
78 static struct interp *interp_lookup_existing (struct ui *ui,
81 interp::interp (const char *name)
82 : m_name (xstrdup (name))
92 /* An interpreter factory. Maps an interpreter name to the factory
93 function that instantiates an interpreter by that name. */
97 interp_factory (const char *name_, interp_factory_func func_)
98 : name (name_), func (func_)
101 /* This is the name in "-i=INTERP" and "interpreter-exec INTERP". */
104 /* The function that creates the interpreter. */
105 interp_factory_func func;
108 /* The registered interpreter factories. */
109 static std::vector<interp_factory> interpreter_factories;
114 interp_factory_register (const char *name, interp_factory_func func)
116 /* Assert that no factory for NAME is already registered. */
117 for (const interp_factory &f : interpreter_factories)
118 if (strcmp (f.name, name) == 0)
120 internal_error (__FILE__, __LINE__,
121 _("interpreter factory already registered: \"%s\"\n"),
125 interpreter_factories.emplace_back (name, func);
128 /* Add interpreter INTERP to the gdb interpreter list. The
129 interpreter must not have previously been added. */
131 interp_add (struct ui *ui, struct interp *interp)
133 struct ui_interp_info *ui_interp = get_interp_info (ui);
135 gdb_assert (interp_lookup_existing (ui, interp->name ()) == NULL);
137 interp->next = ui_interp->interp_list;
138 ui_interp->interp_list = interp;
141 /* This sets the current interpreter to be INTERP. If INTERP has not
142 been initialized, then this will also run the init method.
144 The TOP_LEVEL parameter tells if this new interpreter is
145 the top-level one. The top-level is what is requested
146 on the command line, and is responsible for reporting general
147 notification about target state changes. For example, if
148 MI is the top-level interpreter, then it will always report
149 events such as target stops and new thread creation, even if they
150 are caused by CLI commands. */
153 interp_set (struct interp *interp, bool top_level)
155 struct ui_interp_info *ui_interp = get_current_interp_info ();
156 struct interp *old_interp = ui_interp->current_interpreter;
158 /* If we already have an interpreter, then trying to
159 set top level interpreter is kinda pointless. */
160 gdb_assert (!top_level || !ui_interp->current_interpreter);
161 gdb_assert (!top_level || !ui_interp->top_level_interpreter);
163 if (old_interp != NULL)
165 current_uiout->flush ();
166 old_interp->suspend ();
169 ui_interp->current_interpreter = interp;
171 ui_interp->top_level_interpreter = interp;
173 /* We use interpreter_p for the "set interpreter" variable, so we need
174 to make sure we have a malloc'ed copy for the set command to free. */
175 if (interpreter_p != NULL
176 && strcmp (interp->name (), interpreter_p) != 0)
178 xfree (interpreter_p);
180 interpreter_p = xstrdup (interp->name ());
183 /* Run the init proc. */
186 interp->init (top_level);
187 interp->inited = true;
190 /* Do this only after the interpreter is initialized. */
191 current_uiout = interp->interp_ui_out ();
193 /* Clear out any installed interpreter hooks/event handlers. */
194 clear_interpreter_hooks ();
199 /* Look up the interpreter for NAME. If no such interpreter exists,
200 return NULL, otherwise return a pointer to the interpreter. */
202 static struct interp *
203 interp_lookup_existing (struct ui *ui, const char *name)
205 struct ui_interp_info *ui_interp = get_interp_info (ui);
206 struct interp *interp;
208 for (interp = ui_interp->interp_list;
210 interp = interp->next)
212 if (strcmp (interp->name (), name) == 0)
222 interp_lookup (struct ui *ui, const char *name)
224 if (name == NULL || strlen (name) == 0)
227 /* Only create each interpreter once per top level. */
228 struct interp *interp = interp_lookup_existing (ui, name);
232 for (const interp_factory &factory : interpreter_factories)
233 if (strcmp (factory.name, name) == 0)
235 interp = factory.func (name);
236 interp_add (ui, interp);
246 set_top_level_interpreter (const char *name)
249 struct interp *interp = interp_lookup (current_ui, name);
252 error (_("Interpreter `%s' unrecognized"), name);
254 interp_set (interp, true);
258 current_interp_set_logging (ui_file_up logfile, bool logging_redirect,
261 struct ui_interp_info *ui_interp = get_current_interp_info ();
262 struct interp *interp = ui_interp->current_interpreter;
264 interp->set_logging (std::move (logfile), logging_redirect, debug_redirect);
267 /* Temporarily overrides the current interpreter. */
269 scoped_restore_interp::set_interp (const char *name)
271 struct ui_interp_info *ui_interp = get_current_interp_info ();
272 struct interp *interp = interp_lookup (current_ui, name);
273 struct interp *old_interp = ui_interp->current_interpreter;
276 ui_interp->current_interpreter = interp;
280 /* Returns true if the current interp is the passed in name. */
282 current_interp_named_p (const char *interp_name)
284 struct ui_interp_info *ui_interp = get_current_interp_info ();
285 struct interp *interp = ui_interp->current_interpreter;
288 return (strcmp (interp->name (), interp_name) == 0);
293 /* The interpreter that was active when a command was executed.
294 Normally that'd always be CURRENT_INTERPRETER, except that MI's
295 -interpreter-exec command doesn't actually flip the current
296 interpreter when running its sub-command. The
297 `command_interpreter' global tracks when interp_exec is called
298 (IOW, when -interpreter-exec is called). If that is set, it is
299 INTERP in '-interpreter-exec INTERP "CMD"' or in 'interpreter-exec
300 INTERP "CMD". Otherwise, interp_exec isn't active, and so the
301 interpreter running the command is the current interpreter. */
304 command_interp (void)
306 struct ui_interp_info *ui_interp = get_current_interp_info ();
308 if (ui_interp->command_interpreter != NULL)
309 return ui_interp->command_interpreter;
311 return ui_interp->current_interpreter;
317 interp_pre_command_loop (struct interp *interp)
319 gdb_assert (interp != NULL);
321 interp->pre_command_loop ();
327 interp_supports_command_editing (struct interp *interp)
329 return interp->supports_command_editing ();
332 /* interp_exec - This executes COMMAND_STR in the current
336 interp_exec (struct interp *interp, const char *command_str)
338 struct ui_interp_info *ui_interp = get_current_interp_info ();
340 /* See `command_interp' for why we do this. */
341 scoped_restore save_command_interp
342 = make_scoped_restore (&ui_interp->command_interpreter, interp);
344 return interp->exec (command_str);
347 /* A convenience routine that nulls out all the common command hooks.
348 Use it when removing your interpreter in its suspend proc. */
350 clear_interpreter_hooks (void)
352 deprecated_print_frame_info_listing_hook = 0;
353 /*print_frame_more_info_hook = 0; */
354 deprecated_query_hook = 0;
355 deprecated_warning_hook = 0;
356 deprecated_interactive_hook = 0;
357 deprecated_readline_begin_hook = 0;
358 deprecated_readline_hook = 0;
359 deprecated_readline_end_hook = 0;
360 deprecated_context_hook = 0;
361 deprecated_target_wait_hook = 0;
362 deprecated_call_command_hook = 0;
363 deprecated_error_begin_hook = 0;
367 interpreter_exec_cmd (const char *args, int from_tty)
369 struct ui_interp_info *ui_interp = get_current_interp_info ();
370 struct interp *old_interp, *interp_to_use;
375 error_no_arg (_("interpreter-exec command"));
377 gdb_argv prules (args);
378 nrules = prules.count ();
381 error (_("Usage: interpreter-exec INTERPRETER [ COMMAND... ]"));
383 old_interp = ui_interp->current_interpreter;
385 interp_to_use = interp_lookup (current_ui, prules[0]);
386 if (interp_to_use == NULL)
387 error (_("Could not find interpreter \"%s\"."), prules[0]);
389 interp_set (interp_to_use, false);
391 for (i = 1; i < nrules; i++)
393 struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
397 interp_set (old_interp, 0);
398 error (_("error in command: \"%s\"."), prules[i]);
402 interp_set (old_interp, 0);
408 interpreter_completer (struct cmd_list_element *ignore,
409 completion_tracker &tracker,
410 const char *text, const char *word)
412 int textlen = strlen (text);
414 for (const interp_factory &interp : interpreter_factories)
416 if (strncmp (interp.name, text, textlen) == 0)
418 tracker.add_completion
419 (make_completion_match_str (interp.name, text, word));
425 top_level_interpreter (void)
427 struct ui_interp_info *ui_interp = get_current_interp_info ();
429 return ui_interp->top_level_interpreter;
435 current_interpreter (void)
437 struct ui_interp_info *ui_interp = get_interp_info (current_ui);
439 return ui_interp->current_interpreter;
442 /* This just adds the "interpreter-exec" command. */
444 _initialize_interpreter (void)
446 struct cmd_list_element *c;
448 c = add_cmd ("interpreter-exec", class_support,
449 interpreter_exec_cmd, _("\
450 Execute a command in an interpreter.\n\
451 It takes two arguments:\n\
452 The first argument is the name of the interpreter to use.\n\
453 The second argument is the command to execute."), &cmdlist);
454 set_cmd_completer (c, interpreter_completer);