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 "continuations.h"
  41 #include "main.h"
  42
  43 /* Each UI has its own independent set of interpreters.  */
  44
  45 struct 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
  59 static struct ui_interp_info *
  60 get_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
  70 static struct ui_interp_info *
  71 get_current_interp_info (void)
  72 {
  73   return get_interp_info (current_ui);
  74 }
  75
  76 /* The magic initialization routine for this module.  */
  77
  78 static struct interp *interp_lookup_existing (struct ui *ui,
  79                                               const char *name);
  80
  81 interp::interp (const char *name)
  82   : m_name (xstrdup (name))
  83 {
  84   this->inited = false;
  85 }
  86
  87 interp::~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
  95 struct 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.  */
 109 static std::vector<interp_factory> interpreter_factories;
 110
 111 /* See interps.h.  */
 112
 113 void
 114 interp_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.  */
 130 void
 131 interp_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
 152 static void
 153 interp_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
 202 static struct interp *
 203 interp_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
 221 struct interp *
 222 interp_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
 245 void
 246 set_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
 257 void
 258 current_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.  */
 268 struct interp *
 269 scoped_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.  */
 281 int
 282 current_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
 303 struct interp *
 304 command_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
 316 void
 317 interp_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
 326 int
 327 interp_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
 335 struct gdb_exception
 336 interp_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.  */
 349 void
 350 clear_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
 365 static void
 366 interpreter_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   /* Interpreters may clobber stdout/stderr (e.g.  in mi_interp::resume at time
 374      of writing), preserve their state here.  */
 375   scoped_restore save_stdout = make_scoped_restore (&gdb_stdout);
 376   scoped_restore save_stderr = make_scoped_restore (&gdb_stderr);
 377   scoped_restore save_stdlog = make_scoped_restore (&gdb_stdlog);
 378   scoped_restore save_stdtarg = make_scoped_restore (&gdb_stdtarg);
 379   scoped_restore save_stdtargerr = make_scoped_restore (&gdb_stdtargerr);
 380
 381   if (args == NULL)
 382     error_no_arg (_("interpreter-exec command"));
 383
 384   gdb_argv prules (args);
 385   nrules = prules.count ();
 386
 387   if (nrules < 2)
 388     error (_("Usage: interpreter-exec INTERPRETER COMMAND..."));
 389
 390   old_interp = ui_interp->current_interpreter;
 391
 392   interp_to_use = interp_lookup (current_ui, prules[0]);
 393   if (interp_to_use == NULL)
 394     error (_("Could not find interpreter \"%s\"."), prules[0]);
 395
 396   interp_set (interp_to_use, false);
 397
 398   for (i = 1; i < nrules; i++)
 399     {
 400       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
 401
 402       if (e.reason < 0)
 403         {
 404           interp_set (old_interp, 0);
 405           error (_("error in command: \"%s\"."), prules[i]);
 406         }
 407     }
 408
 409   interp_set (old_interp, 0);
 410 }
 411
 412 /* See interps.h.  */
 413
 414 void
 415 interpreter_completer (struct cmd_list_element *ignore,
 416                        completion_tracker &tracker,
 417                        const char *text, const char *word)
 418 {
 419   int textlen = strlen (text);
 420
 421   for (const interp_factory &interp : interpreter_factories)
 422     {
 423       if (strncmp (interp.name, text, textlen) == 0)
 424         {
 425           tracker.add_completion
 426             (make_completion_match_str (interp.name, text, word));
 427         }
 428     }
 429 }
 430
 431 struct interp *
 432 top_level_interpreter (void)
 433 {
 434   struct ui_interp_info *ui_interp = get_current_interp_info ();
 435
 436   return ui_interp->top_level_interpreter;
 437 }
 438
 439 /* See interps.h.  */
 440
 441 struct interp *
 442 current_interpreter (void)
 443 {
 444   struct ui_interp_info *ui_interp = get_interp_info (current_ui);
 445
 446   return ui_interp->current_interpreter;
 447 }
 448
 449 /* This just adds the "interpreter-exec" command.  */
 450 void _initialize_interpreter ();
 451 void
 452 _initialize_interpreter ()
 453 {
 454   struct cmd_list_element *c;
 455
 456   c = add_cmd ("interpreter-exec", class_support,
 457                interpreter_exec_cmd, _("\
 458 Execute a command in an interpreter.\n\
 459 Usage: interpreter-exec INTERPRETER COMMAND...\n\
 460 The first argument is the name of the interpreter to use.\n\
 461 The following arguments are the commands to execute.\n\
 462 A command can have arguments, separated by spaces.\n\
 463 These spaces must be escaped using \\ or the command\n\
 464 and its arguments must be enclosed in double quotes."), &cmdlist);
 465   set_cmd_completer (c, interpreter_completer);
 466 }