gdb/interps.c

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