gdb/interps.c

   1 /* Manages interpreters for GDB, the GNU debugger.
   2
   3    Copyright (C) 2000-2021 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 "main.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 /* The magic initialization routine for this module.  */
  76
  77 static struct interp *interp_lookup_existing (struct ui *ui,
  78                                               const char *name);
  79
  80 interp::interp (const char *name)
  81   : m_name (xstrdup (name))
  82 {
  83   this->inited = false;
  84 }
  85
  86 interp::~interp ()
  87 {
  88   xfree (m_name);
  89 }
  90
  91 /* An interpreter factory.  Maps an interpreter name to the factory
  92    function that instantiates an interpreter by that name.  */
  93
  94 struct interp_factory
  95 {
  96   interp_factory (const char *name_, interp_factory_func func_)
  97   : name (name_), func (func_)
  98   {}
  99
 100   /* This is the name in "-i=INTERP" and "interpreter-exec INTERP".  */
 101   const char *name;
 102
 103   /* The function that creates the interpreter.  */
 104   interp_factory_func func;
 105 };
 106
 107 /* The registered interpreter factories.  */
 108 static std::vector<interp_factory> interpreter_factories;
 109
 110 /* See interps.h.  */
 111
 112 void
 113 interp_factory_register (const char *name, interp_factory_func func)
 114 {
 115   /* Assert that no factory for NAME is already registered.  */
 116   for (const interp_factory &f : interpreter_factories)
 117     if (strcmp (f.name, name) == 0)
 118       {
 119         internal_error (__FILE__, __LINE__,
 120                         _("interpreter factory already registered: \"%s\"\n"),
 121                         name);
 122       }
 123
 124   interpreter_factories.emplace_back (name, func);
 125 }
 126
 127 /* Add interpreter INTERP to the gdb interpreter list.  The
 128    interpreter must not have previously been added.  */
 129 void
 130 interp_add (struct ui *ui, struct interp *interp)
 131 {
 132   struct ui_interp_info *ui_interp = get_interp_info (ui);
 133
 134   gdb_assert (interp_lookup_existing (ui, interp->name ()) == NULL);
 135
 136   interp->next = ui_interp->interp_list;
 137   ui_interp->interp_list = interp;
 138 }
 139
 140 /* This sets the current interpreter to be INTERP.  If INTERP has not
 141    been initialized, then this will also run the init method.
 142
 143    The TOP_LEVEL parameter tells if this new interpreter is
 144    the top-level one.  The top-level is what is requested
 145    on the command line, and is responsible for reporting general
 146    notification about target state changes.  For example, if
 147    MI is the top-level interpreter, then it will always report
 148    events such as target stops and new thread creation, even if they
 149    are caused by CLI commands.  */
 150
 151 static void
 152 interp_set (struct interp *interp, bool top_level)
 153 {
 154   struct ui_interp_info *ui_interp = get_current_interp_info ();
 155   struct interp *old_interp = ui_interp->current_interpreter;
 156
 157   /* If we already have an interpreter, then trying to
 158      set top level interpreter is kinda pointless.  */
 159   gdb_assert (!top_level || !ui_interp->current_interpreter);
 160   gdb_assert (!top_level || !ui_interp->top_level_interpreter);
 161
 162   if (old_interp != NULL)
 163     {
 164       current_uiout->flush ();
 165       old_interp->suspend ();
 166     }
 167
 168   ui_interp->current_interpreter = interp;
 169   if (top_level)
 170     ui_interp->top_level_interpreter = interp;
 171
 172   /* We use interpreter_p for the "set interpreter" variable, so we need
 173      to make sure we have a malloc'ed copy for the set command to free.  */
 174   if (interpreter_p != NULL
 175       && strcmp (interp->name (), interpreter_p) != 0)
 176     {
 177       xfree (interpreter_p);
 178
 179       interpreter_p = xstrdup (interp->name ());
 180     }
 181
 182   /* Run the init proc.  */
 183   if (!interp->inited)
 184     {
 185       interp->init (top_level);
 186       interp->inited = true;
 187     }
 188
 189   /* Do this only after the interpreter is initialized.  */
 190   current_uiout = interp->interp_ui_out ();
 191
 192   /* Clear out any installed interpreter hooks/event handlers.  */
 193   clear_interpreter_hooks ();
 194
 195   interp->resume ();
 196 }
 197
 198 /* Look up the interpreter for NAME.  If no such interpreter exists,
 199    return NULL, otherwise return a pointer to the interpreter.  */
 200
 201 static struct interp *
 202 interp_lookup_existing (struct ui *ui, const char *name)
 203 {
 204   struct ui_interp_info *ui_interp = get_interp_info (ui);
 205   struct interp *interp;
 206
 207   for (interp = ui_interp->interp_list;
 208        interp != NULL;
 209        interp = interp->next)
 210     {
 211       if (strcmp (interp->name (), name) == 0)
 212         return interp;
 213     }
 214
 215   return NULL;
 216 }
 217
 218 /* See interps.h.  */
 219
 220 struct interp *
 221 interp_lookup (struct ui *ui, const char *name)
 222 {
 223   if (name == NULL || strlen (name) == 0)
 224     return NULL;
 225
 226   /* Only create each interpreter once per top level.  */
 227   struct interp *interp = interp_lookup_existing (ui, name);
 228   if (interp != NULL)
 229     return interp;
 230
 231   for (const interp_factory &factory : interpreter_factories)
 232     if (strcmp (factory.name, name) == 0)
 233       {
 234         interp = factory.func (name);
 235         interp_add (ui, interp);
 236         return interp;
 237       }
 238
 239   return NULL;
 240 }
 241
 242 /* See interps.h.  */
 243
 244 void
 245 set_top_level_interpreter (const char *name)
 246 {
 247   /* Find it.  */
 248   struct interp *interp = interp_lookup (current_ui, name);
 249
 250   if (interp == NULL)
 251     error (_("Interpreter `%s' unrecognized"), name);
 252   /* Install it.  */
 253   interp_set (interp, true);
 254 }
 255
 256 void
 257 current_interp_set_logging (ui_file_up logfile, bool logging_redirect,
 258                             bool debug_redirect)
 259 {
 260   struct ui_interp_info *ui_interp = get_current_interp_info ();
 261   struct interp *interp = ui_interp->current_interpreter;
 262
 263   interp->set_logging (std::move (logfile), logging_redirect, debug_redirect);
 264 }
 265
 266 /* Temporarily overrides the current interpreter.  */
 267 struct interp *
 268 scoped_restore_interp::set_interp (const char *name)
 269 {
 270   struct ui_interp_info *ui_interp = get_current_interp_info ();
 271   struct interp *interp = interp_lookup (current_ui, name);
 272   struct interp *old_interp = ui_interp->current_interpreter;
 273
 274   if (interp)
 275     ui_interp->current_interpreter = interp;
 276   return old_interp;
 277 }
 278
 279 /* Returns true if the current interp is the passed in name.  */
 280 int
 281 current_interp_named_p (const char *interp_name)
 282 {
 283   struct ui_interp_info *ui_interp = get_current_interp_info ();
 284   struct interp *interp = ui_interp->current_interpreter;
 285
 286   if (interp != NULL)
 287     return (strcmp (interp->name (), interp_name) == 0);
 288
 289   return 0;
 290 }
 291
 292 /* The interpreter that was active when a command was executed.
 293    Normally that'd always be CURRENT_INTERPRETER, except that MI's
 294    -interpreter-exec command doesn't actually flip the current
 295    interpreter when running its sub-command.  The
 296    `command_interpreter' global tracks when interp_exec is called
 297    (IOW, when -interpreter-exec is called).  If that is set, it is
 298    INTERP in '-interpreter-exec INTERP "CMD"' or in 'interpreter-exec
 299    INTERP "CMD".  Otherwise, interp_exec isn't active, and so the
 300    interpreter running the command is the current interpreter.  */
 301
 302 struct interp *
 303 command_interp (void)
 304 {
 305   struct ui_interp_info *ui_interp = get_current_interp_info ();
 306
 307   if (ui_interp->command_interpreter != NULL)
 308     return ui_interp->command_interpreter;
 309   else
 310     return ui_interp->current_interpreter;
 311 }
 312
 313 /* See interps.h.  */
 314
 315 void
 316 interp_pre_command_loop (struct interp *interp)
 317 {
 318   gdb_assert (interp != NULL);
 319
 320   interp->pre_command_loop ();
 321 }
 322
 323 /* See interp.h  */
 324
 325 int
 326 interp_supports_command_editing (struct interp *interp)
 327 {
 328   return interp->supports_command_editing ();
 329 }
 330
 331 /* interp_exec - This executes COMMAND_STR in the current
 332    interpreter.  */
 333
 334 struct gdb_exception
 335 interp_exec (struct interp *interp, const char *command_str)
 336 {
 337   struct ui_interp_info *ui_interp = get_current_interp_info ();
 338
 339   /* See `command_interp' for why we do this.  */
 340   scoped_restore save_command_interp
 341     = make_scoped_restore (&ui_interp->command_interpreter, interp);
 342
 343   return interp->exec (command_str);
 344 }
 345
 346 /* A convenience routine that nulls out all the common command hooks.
 347    Use it when removing your interpreter in its suspend proc.  */
 348 void
 349 clear_interpreter_hooks (void)
 350 {
 351   deprecated_print_frame_info_listing_hook = 0;
 352   /*print_frame_more_info_hook = 0; */
 353   deprecated_query_hook = 0;
 354   deprecated_warning_hook = 0;
 355   deprecated_readline_begin_hook = 0;
 356   deprecated_readline_hook = 0;
 357   deprecated_readline_end_hook = 0;
 358   deprecated_context_hook = 0;
 359   deprecated_target_wait_hook = 0;
 360   deprecated_call_command_hook = 0;
 361   deprecated_error_begin_hook = 0;
 362 }
 363
 364 static void
 365 interpreter_exec_cmd (const char *args, int from_tty)
 366 {
 367   struct ui_interp_info *ui_interp = get_current_interp_info ();
 368   struct interp *old_interp, *interp_to_use;
 369   unsigned int nrules;
 370   unsigned int i;
 371
 372   /* Interpreters may clobber stdout/stderr (e.g.  in mi_interp::resume at time
 373      of writing), preserve their state here.  */
 374   scoped_restore save_stdout = make_scoped_restore (&gdb_stdout);
 375   scoped_restore save_stderr = make_scoped_restore (&gdb_stderr);
 376   scoped_restore save_stdlog = make_scoped_restore (&gdb_stdlog);
 377   scoped_restore save_stdtarg = make_scoped_restore (&gdb_stdtarg);
 378   scoped_restore save_stdtargerr = make_scoped_restore (&gdb_stdtargerr);
 379
 380   if (args == NULL)
 381     error_no_arg (_("interpreter-exec command"));
 382
 383   gdb_argv prules (args);
 384   nrules = prules.count ();
 385
 386   if (nrules < 2)
 387     error (_("Usage: interpreter-exec INTERPRETER COMMAND..."));
 388
 389   old_interp = ui_interp->current_interpreter;
 390
 391   interp_to_use = interp_lookup (current_ui, prules[0]);
 392   if (interp_to_use == NULL)
 393     error (_("Could not find interpreter \"%s\"."), prules[0]);
 394
 395   interp_set (interp_to_use, false);
 396
 397   for (i = 1; i < nrules; i++)
 398     {
 399       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
 400
 401       if (e.reason < 0)
 402         {
 403           interp_set (old_interp, 0);
 404           error (_("error in command: \"%s\"."), prules[i]);
 405         }
 406     }
 407
 408   interp_set (old_interp, 0);
 409 }
 410
 411 /* See interps.h.  */
 412
 413 void
 414 interpreter_completer (struct cmd_list_element *ignore,
 415                        completion_tracker &tracker,
 416                        const char *text, const char *word)
 417 {
 418   int textlen = strlen (text);
 419
 420   for (const interp_factory &interp : interpreter_factories)
 421     {
 422       if (strncmp (interp.name, text, textlen) == 0)
 423         {
 424           tracker.add_completion
 425             (make_completion_match_str (interp.name, text, word));
 426         }
 427     }
 428 }
 429
 430 struct interp *
 431 top_level_interpreter (void)
 432 {
 433   struct ui_interp_info *ui_interp = get_current_interp_info ();
 434
 435   return ui_interp->top_level_interpreter;
 436 }
 437
 438 /* See interps.h.  */
 439
 440 struct interp *
 441 current_interpreter (void)
 442 {
 443   struct ui_interp_info *ui_interp = get_interp_info (current_ui);
 444
 445   return ui_interp->current_interpreter;
 446 }
 447
 448 /* This just adds the "interpreter-exec" command.  */
 449 void _initialize_interpreter ();
 450 void
 451 _initialize_interpreter ()
 452 {
 453   struct cmd_list_element *c;
 454
 455   c = add_cmd ("interpreter-exec", class_support,
 456                interpreter_exec_cmd, _("\
 457 Execute a command in an interpreter.\n\
 458 Usage: interpreter-exec INTERPRETER COMMAND...\n\
 459 The first argument is the name of the interpreter to use.\n\
 460 The following arguments are the commands to execute.\n\
 461 A command can have arguments, separated by spaces.\n\
 462 These spaces must be escaped using \\ or the command\n\
 463 and its arguments must be enclosed in double quotes."), &cmdlist);
 464   set_cmd_completer (c, interpreter_completer);
 465 }