1/* Manages interpreters for GDB, the GNU debugger. 2 3 Copyright (C) 2000-2020 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 "gdbsupport/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#include "main.h" 42 43/* Each UI has its own independent set of interpreters. */ 44 45struct ui_interp_info 46{ 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; 51 52 /* The interpreter that is active while `interp_exec' is active, NULL 53 at all other times. */ 54 struct interp *command_interpreter; 55}; 56 57/* Get UI's ui_interp_info object. Never returns NULL. */ 58 59static struct ui_interp_info * 60get_interp_info (struct ui *ui) 61{ 62 if (ui->interp_info == NULL) 63 ui->interp_info = XCNEW (struct ui_interp_info); 64 return ui->interp_info; 65} 66 67/* Get the current UI's ui_interp_info object. Never returns 68 NULL. */ 69 70static struct ui_interp_info * 71get_current_interp_info (void) 72{ 73 return get_interp_info (current_ui); 74} 75 76/* The magic initialization routine for this module. */ 77 78static struct interp *interp_lookup_existing (struct ui *ui, 79 const char *name); 80 81interp::interp (const char *name) 82 : m_name (xstrdup (name)) 83{ 84 this->inited = false; 85} 86 87interp::~interp () 88{ 89 xfree (m_name); 90} 91 92/* An interpreter factory. Maps an interpreter name to the factory 93 function that instantiates an interpreter by that name. */ 94 95struct interp_factory 96{ 97 interp_factory (const char *name_, interp_factory_func func_) 98 : name (name_), func (func_) 99 {} 100 101 /* This is the name in "-i=INTERP" and "interpreter-exec INTERP". */ 102 const char *name; 103 104 /* The function that creates the interpreter. */ 105 interp_factory_func func; 106}; 107 108/* The registered interpreter factories. */ 109static std::vector<interp_factory> interpreter_factories; 110 111/* See interps.h. */ 112 113void 114interp_factory_register (const char *name, interp_factory_func func) 115{ 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) 119 { 120 internal_error (__FILE__, __LINE__, 121 _("interpreter factory already registered: \"%s\"\n"), 122 name); 123 } 124 125 interpreter_factories.emplace_back (name, func); 126} 127 128/* Add interpreter INTERP to the gdb interpreter list. The 129 interpreter must not have previously been added. */ 130void 131interp_add (struct ui *ui, struct interp *interp) 132{ 133 struct ui_interp_info *ui_interp = get_interp_info (ui); 134 135 gdb_assert (interp_lookup_existing (ui, interp->name ()) == NULL); 136 137 interp->next = ui_interp->interp_list; 138 ui_interp->interp_list = interp; 139} 140 141/* This sets the current interpreter to be INTERP. If INTERP has not 142 been initialized, then this will also run the init method. 143 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. */ 151 152static void 153interp_set (struct interp *interp, bool top_level) 154{ 155 struct ui_interp_info *ui_interp = get_current_interp_info (); 156 struct interp *old_interp = ui_interp->current_interpreter; 157 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); 162 163 if (old_interp != NULL) 164 { 165 current_uiout->flush (); 166 old_interp->suspend (); 167 } 168 169 ui_interp->current_interpreter = interp; 170 if (top_level) 171 ui_interp->top_level_interpreter = interp; 172 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) 177 { 178 xfree (interpreter_p); 179 180 interpreter_p = xstrdup (interp->name ()); 181 } 182 183 /* Run the init proc. */ 184 if (!interp->inited) 185 { 186 interp->init (top_level); 187 interp->inited = true; 188 } 189 190 /* Do this only after the interpreter is initialized. */ 191 current_uiout = interp->interp_ui_out (); 192 193 /* Clear out any installed interpreter hooks/event handlers. */ 194 clear_interpreter_hooks (); 195 196 interp->resume (); 197} 198 199/* Look up the interpreter for NAME. If no such interpreter exists, 200 return NULL, otherwise return a pointer to the interpreter. */ 201 202static struct interp * 203interp_lookup_existing (struct ui *ui, const char *name) 204{ 205 struct ui_interp_info *ui_interp = get_interp_info (ui); 206 struct interp *interp; 207 208 for (interp = ui_interp->interp_list; 209 interp != NULL; 210 interp = interp->next) 211 { 212 if (strcmp (interp->name (), name) == 0) 213 return interp; 214 } 215 216 return NULL; 217} 218 219/* See interps.h. */ 220 221struct interp * 222interp_lookup (struct ui *ui, const char *name) 223{ 224 if (name == NULL || strlen (name) == 0) 225 return NULL; 226 227 /* Only create each interpreter once per top level. */ 228 struct interp *interp = interp_lookup_existing (ui, name); 229 if (interp != NULL) 230 return interp; 231 232 for (const interp_factory &factory : interpreter_factories) 233 if (strcmp (factory.name, name) == 0) 234 { 235 interp = factory.func (name); 236 interp_add (ui, interp); 237 return interp; 238 } 239 240 return NULL; 241} 242 243/* See interps.h. */ 244 245void 246set_top_level_interpreter (const char *name) 247{ 248 /* Find it. */ 249 struct interp *interp = interp_lookup (current_ui, name); 250 251 if (interp == NULL) 252 error (_("Interpreter `%s' unrecognized"), name); 253 /* Install it. */ 254 interp_set (interp, true); 255} 256 257void 258current_interp_set_logging (ui_file_up logfile, bool logging_redirect, 259 bool debug_redirect) 260{ 261 struct ui_interp_info *ui_interp = get_current_interp_info (); 262 struct interp *interp = ui_interp->current_interpreter; 263 264 interp->set_logging (std::move (logfile), logging_redirect, debug_redirect); 265} 266 267/* Temporarily overrides the current interpreter. */ 268struct interp * 269scoped_restore_interp::set_interp (const char *name) 270{ 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; 274 275 if (interp) 276 ui_interp->current_interpreter = interp; 277 return old_interp; 278} 279 280/* Returns true if the current interp is the passed in name. */ 281int 282current_interp_named_p (const char *interp_name) 283{ 284 struct ui_interp_info *ui_interp = get_current_interp_info (); 285 struct interp *interp = ui_interp->current_interpreter; 286 287 if (interp != NULL) 288 return (strcmp (interp->name (), interp_name) == 0); 289 290 return 0; 291} 292 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. */ 302 303struct interp * 304command_interp (void) 305{ 306 struct ui_interp_info *ui_interp = get_current_interp_info (); 307 308 if (ui_interp->command_interpreter != NULL) 309 return ui_interp->command_interpreter; 310 else 311 return ui_interp->current_interpreter; 312} 313 314/* See interps.h. */ 315 316void 317interp_pre_command_loop (struct interp *interp) 318{ 319 gdb_assert (interp != NULL); 320 321 interp->pre_command_loop (); 322} 323 324/* See interp.h */ 325 326int 327interp_supports_command_editing (struct interp *interp) 328{ 329 return interp->supports_command_editing (); 330} 331 332/* interp_exec - This executes COMMAND_STR in the current 333 interpreter. */ 334 335struct gdb_exception 336interp_exec (struct interp *interp, const char *command_str) 337{ 338 struct ui_interp_info *ui_interp = get_current_interp_info (); 339 340 /* See `command_interp' for why we do this. */ 341 scoped_restore save_command_interp 342 = make_scoped_restore (&ui_interp->command_interpreter, interp); 343 344 return interp->exec (command_str); 345} 346 347/* A convenience routine that nulls out all the common command hooks. 348 Use it when removing your interpreter in its suspend proc. */ 349void 350clear_interpreter_hooks (void) 351{ 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_readline_begin_hook = 0; 357 deprecated_readline_hook = 0; 358 deprecated_readline_end_hook = 0; 359 deprecated_context_hook = 0; 360 deprecated_target_wait_hook = 0; 361 deprecated_call_command_hook = 0; 362 deprecated_error_begin_hook = 0; 363} 364 365static void 366interpreter_exec_cmd (const char *args, int from_tty) 367{ 368 struct ui_interp_info *ui_interp = get_current_interp_info (); 369 struct interp *old_interp, *interp_to_use; 370 unsigned int nrules; 371 unsigned int i; 372 373 if (args == NULL) 374 error_no_arg (_("interpreter-exec command")); 375 376 gdb_argv prules (args); 377 nrules = prules.count (); 378 379 if (nrules < 2) 380 error (_("Usage: interpreter-exec INTERPRETER COMMAND...")); 381 382 old_interp = ui_interp->current_interpreter; 383 384 interp_to_use = interp_lookup (current_ui, prules[0]); 385 if (interp_to_use == NULL) 386 error (_("Could not find interpreter \"%s\"."), prules[0]); 387 388 interp_set (interp_to_use, false); 389 390 for (i = 1; i < nrules; i++) 391 { 392 struct gdb_exception e = interp_exec (interp_to_use, prules[i]); 393 394 if (e.reason < 0) 395 { 396 interp_set (old_interp, 0); 397 error (_("error in command: \"%s\"."), prules[i]); 398 } 399 } 400 401 interp_set (old_interp, 0); 402} 403 404/* See interps.h. */ 405 406void 407interpreter_completer (struct cmd_list_element *ignore, 408 completion_tracker &tracker, 409 const char *text, const char *word) 410{ 411 int textlen = strlen (text); 412 413 for (const interp_factory &interp : interpreter_factories) 414 { 415 if (strncmp (interp.name, text, textlen) == 0) 416 { 417 tracker.add_completion 418 (make_completion_match_str (interp.name, text, word)); 419 } 420 } 421} 422 423struct interp * 424top_level_interpreter (void) 425{ 426 struct ui_interp_info *ui_interp = get_current_interp_info (); 427 428 return ui_interp->top_level_interpreter; 429} 430 431/* See interps.h. */ 432 433struct interp * 434current_interpreter (void) 435{ 436 struct ui_interp_info *ui_interp = get_interp_info (current_ui); 437 438 return ui_interp->current_interpreter; 439} 440 441/* This just adds the "interpreter-exec" command. */ 442void _initialize_interpreter (); 443void 444_initialize_interpreter () 445{ 446 struct cmd_list_element *c; 447 448 c = add_cmd ("interpreter-exec", class_support, 449 interpreter_exec_cmd, _("\ 450Execute a command in an interpreter.\n\ 451Usage: interpreter-exec INTERPRETER COMMAND...\n\ 452The first argument is the name of the interpreter to use.\n\ 453The following arguments are the commands to execute.\n\ 454A command can have arguments, separated by spaces.\n\ 455These spaces must be escaped using \\ or the command\n\ 456and its arguments must be enclosed in double quotes."), &cmdlist); 457 set_cmd_completer (c, interpreter_completer); 458} 459