1 /* Manages interpreters for GDB, the GNU debugger.
3 Copyright (C) 2000-2016 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"
42 /* Each UI has its own independent set of interpreters. */
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
;
51 /* The interpreter that is active while `interp_exec' is active, NULL
52 at all other times. */
53 struct interp
*command_interpreter
;
56 /* Get UI's ui_interp_info object. Never returns NULL. */
58 static struct ui_interp_info
*
59 get_interp_info (struct ui
*ui
)
61 if (ui
->interp_info
== NULL
)
62 ui
->interp_info
= XCNEW (struct ui_interp_info
);
63 return ui
->interp_info
;
66 /* Get the current UI's ui_interp_info object. Never returns
69 static struct ui_interp_info
*
70 get_current_interp_info (void)
72 return get_interp_info (current_ui
);
77 /* This is the name in "-i=" and set interpreter. */
80 /* Interpreters are stored in a linked list, this is the next
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. */
90 /* Has the init_proc been run? */
93 const struct interp_procs
*procs
;
97 /* The magic initialization routine for this module. */
99 void _initialize_interpreter (void);
101 static struct interp
*interp_lookup_existing (struct ui
*ui
,
104 /* interp_new - This allocates space for a new interpreter,
105 fills the fields from the inputs, and returns a pointer to the
108 interp_new (const char *name
, const struct interp_procs
*procs
, void *data
)
110 struct interp
*new_interp
;
112 new_interp
= XNEW (struct interp
);
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;
120 /* Check for required procs. */
121 gdb_assert (procs
->command_loop_proc
!= NULL
);
126 /* An interpreter factory. Maps an interpreter name to the factory
127 function that instantiates an interpreter by that name. */
129 struct interp_factory
131 /* This is the name in "-i=INTERP" and "interpreter-exec INTERP". */
134 /* The function that creates the interpreter. */
135 interp_factory_func func
;
138 typedef struct interp_factory
*interp_factory_p
;
139 DEF_VEC_P(interp_factory_p
);
141 /* The registered interpreter factories. */
142 static VEC(interp_factory_p
) *interpreter_factories
= NULL
;
147 interp_factory_register (const char *name
, interp_factory_func func
)
149 struct interp_factory
*f
;
152 /* Assert that no factory for NAME is already registered. */
154 VEC_iterate (interp_factory_p
, interpreter_factories
, ix
, f
);
156 if (strcmp (f
->name
, name
) == 0)
158 internal_error (__FILE__
, __LINE__
,
159 _("interpreter factory already registered: \"%s\"\n"),
163 f
= XNEW (struct interp_factory
);
166 VEC_safe_push (interp_factory_p
, interpreter_factories
, f
);
169 /* Add interpreter INTERP to the gdb interpreter list. The
170 interpreter must not have previously been added. */
172 interp_add (struct ui
*ui
, struct interp
*interp
)
174 struct ui_interp_info
*ui_interp
= get_interp_info (ui
);
176 gdb_assert (interp_lookup_existing (ui
, interp
->name
) == NULL
);
178 interp
->next
= ui_interp
->interp_list
;
179 ui_interp
->interp_list
= interp
;
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.
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. */
197 interp_set (struct interp
*interp
, int top_level
)
199 struct ui_interp_info
*ui_interp
= get_current_interp_info ();
200 struct interp
*old_interp
= ui_interp
->current_interpreter
;
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
);
209 if (old_interp
!= NULL
)
211 ui_out_flush (current_uiout
);
212 if (old_interp
->procs
->suspend_proc
213 && !old_interp
->procs
->suspend_proc (old_interp
->data
))
215 error (_("Could not suspend interpreter \"%s\"."),
224 ui_interp
->current_interpreter
= interp
;
226 ui_interp
->top_level_interpreter
= interp
;
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)
233 xfree (interpreter_p
);
235 interpreter_p
= xstrdup (interp
->name
);
238 /* Run the init proc. If it fails, try to restore the old interp. */
242 if (interp
->procs
->init_proc
!= NULL
)
244 interp
->data
= interp
->procs
->init_proc (interp
, top_level
);
249 /* Do this only after the interpreter is initialized. */
250 current_uiout
= interp
->procs
->ui_out_proc (interp
);
252 /* Clear out any installed interpreter hooks/event handlers. */
253 clear_interpreter_hooks ();
255 if (interp
->procs
->resume_proc
!= NULL
256 && (!interp
->procs
->resume_proc (interp
->data
)))
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");
265 if (!first_time
&& !interp_quiet_p (interp
))
267 xsnprintf (buffer
, sizeof (buffer
),
268 "Switching to interpreter \"%.24s\".\n", interp
->name
);
269 ui_out_text (current_uiout
, buffer
);
275 /* Look up the interpreter for NAME. If no such interpreter exists,
276 return NULL, otherwise return a pointer to the interpreter. */
278 static struct interp
*
279 interp_lookup_existing (struct ui
*ui
, const char *name
)
281 struct ui_interp_info
*ui_interp
= get_interp_info (ui
);
282 struct interp
*interp
;
284 for (interp
= ui_interp
->interp_list
;
286 interp
= interp
->next
)
288 if (strcmp (interp
->name
, name
) == 0)
298 interp_lookup (struct ui
*ui
, const char *name
)
300 struct interp_factory
*factory
;
301 struct interp
*interp
;
304 if (name
== NULL
|| strlen (name
) == 0)
307 /* Only create each interpreter once per top level. */
308 interp
= interp_lookup_existing (ui
, name
);
313 VEC_iterate (interp_factory_p
, interpreter_factories
, ix
, factory
);
315 if (strcmp (factory
->name
, name
) == 0)
317 interp
= factory
->func (name
);
318 interp_add (ui
, interp
);
325 /* Returns the current interpreter. */
328 interp_ui_out (struct interp
*interp
)
330 struct ui_interp_info
*ui_interp
= get_current_interp_info ();
333 interp
= ui_interp
->current_interpreter
;
334 return interp
->procs
->ui_out_proc (interp
);
338 current_interp_set_logging (int start_log
, struct ui_file
*out
,
339 struct ui_file
*logfile
)
341 struct ui_interp_info
*ui_interp
= get_current_interp_info ();
342 struct interp
*interp
= ui_interp
->current_interpreter
;
345 || interp
->procs
->set_logging_proc
== NULL
)
348 return interp
->procs
->set_logging_proc (interp
, start_log
, out
, logfile
);
351 /* Temporarily overrides the current interpreter. */
353 interp_set_temp (const char *name
)
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
;
360 ui_interp
->current_interpreter
= interp
;
364 /* Returns the interpreter's cookie. */
367 interp_data (struct interp
*interp
)
372 /* Returns the interpreter's name. */
375 interp_name (struct interp
*interp
)
380 /* Returns true if the current interp is the passed in name. */
382 current_interp_named_p (const char *interp_name
)
384 struct ui_interp_info
*ui_interp
= get_current_interp_info ();
385 struct interp
*interp
= ui_interp
->current_interpreter
;
388 return (strcmp (interp
->name
, interp_name
) == 0);
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. */
404 command_interp (void)
406 struct ui_interp_info
*ui_interp
= get_current_interp_info ();
408 if (ui_interp
->command_interpreter
!= NULL
)
409 return ui_interp
->command_interpreter
;
411 return ui_interp
->current_interpreter
;
414 /* Run the current command interpreter's main loop. */
416 current_interp_command_loop (void)
418 struct ui_interp_info
*ui_interp
= get_current_interp_info ();
419 struct interp
*interp
= ui_interp
->current_interpreter
;
421 gdb_assert (ui_interp
->current_interpreter
!= NULL
);
423 interp
->procs
->command_loop_proc (interp
->data
);
427 interp_quiet_p (struct interp
*interp
)
429 struct ui_interp_info
*ui_interp
= get_current_interp_info ();
432 return interp
->quiet_p
;
434 return ui_interp
->current_interpreter
->quiet_p
;
438 interp_set_quiet (struct interp
*interp
, int quiet
)
440 int old_val
= interp
->quiet_p
;
442 interp
->quiet_p
= quiet
;
446 /* interp_exec - This executes COMMAND_STR in the current
450 interp_exec (struct interp
*interp
, const char *command_str
)
452 struct ui_interp_info
*ui_interp
= get_current_interp_info ();
454 struct gdb_exception ex
;
455 struct interp
*save_command_interp
;
457 gdb_assert (interp
->procs
->exec_proc
!= NULL
);
459 /* See `command_interp' for why we do this. */
460 save_command_interp
= ui_interp
->command_interpreter
;
461 ui_interp
->command_interpreter
= interp
;
463 ex
= interp
->procs
->exec_proc (interp
->data
, command_str
);
465 ui_interp
->command_interpreter
= save_command_interp
;
470 /* A convenience routine that nulls out all the common command hooks.
471 Use it when removing your interpreter in its suspend proc. */
473 clear_interpreter_hooks (void)
475 deprecated_print_frame_info_listing_hook
= 0;
476 /*print_frame_more_info_hook = 0; */
477 deprecated_query_hook
= 0;
478 deprecated_warning_hook
= 0;
479 deprecated_interactive_hook
= 0;
480 deprecated_readline_begin_hook
= 0;
481 deprecated_readline_hook
= 0;
482 deprecated_readline_end_hook
= 0;
483 deprecated_context_hook
= 0;
484 deprecated_target_wait_hook
= 0;
485 deprecated_call_command_hook
= 0;
486 deprecated_error_begin_hook
= 0;
490 interpreter_exec_cmd (char *args
, int from_tty
)
492 struct ui_interp_info
*ui_interp
= get_current_interp_info ();
493 struct interp
*old_interp
, *interp_to_use
;
494 char **prules
= NULL
;
498 int old_quiet
, use_quiet
;
499 struct cleanup
*cleanup
;
502 error_no_arg (_("interpreter-exec command"));
504 prules
= gdb_buildargv (args
);
505 cleanup
= make_cleanup_freeargv (prules
);
508 for (trule
= prules
; *trule
!= NULL
; trule
++)
512 error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
514 old_interp
= ui_interp
->current_interpreter
;
516 interp_to_use
= interp_lookup (current_ui
, prules
[0]);
517 if (interp_to_use
== NULL
)
518 error (_("Could not find interpreter \"%s\"."), prules
[0]);
520 /* Temporarily set interpreters quiet. */
521 old_quiet
= interp_set_quiet (old_interp
, 1);
522 use_quiet
= interp_set_quiet (interp_to_use
, 1);
524 if (!interp_set (interp_to_use
, 0))
525 error (_("Could not switch to interpreter \"%s\"."), prules
[0]);
527 for (i
= 1; i
< nrules
; i
++)
529 struct gdb_exception e
= interp_exec (interp_to_use
, prules
[i
]);
533 interp_set (old_interp
, 0);
534 interp_set_quiet (interp_to_use
, use_quiet
);
535 interp_set_quiet (old_interp
, old_quiet
);
536 error (_("error in command: \"%s\"."), prules
[i
]);
540 interp_set (old_interp
, 0);
541 interp_set_quiet (interp_to_use
, use_quiet
);
542 interp_set_quiet (old_interp
, old_quiet
);
544 do_cleanups (cleanup
);
547 /* List the possible interpreters which could complete the given text. */
548 static VEC (char_ptr
) *
549 interpreter_completer (struct cmd_list_element
*ignore
,
550 const char *text
, const char *word
)
552 struct interp_factory
*interp
;
554 VEC (char_ptr
) *matches
= NULL
;
557 textlen
= strlen (text
);
559 VEC_iterate (interp_factory_p
, interpreter_factories
, ix
, interp
);
562 if (strncmp (interp
->name
, text
, textlen
) == 0)
566 match
= (char *) xmalloc (strlen (word
) + strlen (interp
->name
) + 1);
568 strcpy (match
, interp
->name
);
569 else if (word
> text
)
571 /* Return some portion of interp->name. */
572 strcpy (match
, interp
->name
+ (word
- text
));
576 /* Return some of text plus interp->name. */
577 strncpy (match
, word
, text
- word
);
578 match
[text
- word
] = '\0';
579 strcat (match
, interp
->name
);
581 VEC_safe_push (char_ptr
, matches
, match
);
589 top_level_interpreter (void)
591 struct ui_interp_info
*ui_interp
= get_current_interp_info ();
593 return ui_interp
->top_level_interpreter
;
597 top_level_interpreter_data (void)
599 struct interp
*interp
;
601 interp
= top_level_interpreter ();
602 gdb_assert (interp
!= NULL
);
606 /* This just adds the "interpreter-exec" command. */
608 _initialize_interpreter (void)
610 struct cmd_list_element
*c
;
612 c
= add_cmd ("interpreter-exec", class_support
,
613 interpreter_exec_cmd
, _("\
614 Execute a command in an interpreter. It takes two arguments:\n\
615 The first argument is the name of the interpreter to use.\n\
616 The second argument is the command to execute.\n"), &cmdlist
);
617 set_cmd_completer (c
, interpreter_completer
);