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 void
 255 current_interp_set_logging (ui_file_up logfile,
 256                             bool logging_redirect)
 257 {
 258   struct ui_interp_info *ui_interp = get_current_interp_info ();
 259   struct interp *interp = ui_interp->current_interpreter;
 260
 261   interp->set_logging (std::move (logfile), logging_redirect);
 262 }
 263
 264 /* Temporarily overrides the current interpreter.  */
 265 struct interp *
 266 scoped_restore_interp::set_interp (const char *name)
 267 {
 268   struct ui_interp_info *ui_interp = get_current_interp_info ();
 269   struct interp *interp = interp_lookup (current_ui, name);
 270   struct interp *old_interp = ui_interp->current_interpreter;
 271
 272   if (interp)
 273     ui_interp->current_interpreter = interp;
 274   return old_interp;
 275 }
 276
 277 /* Returns the interpreter's name.  */
 278
 279 const char *
 280 interp_name (struct interp *interp)
 281 {
 282   return interp->name;
 283 }
 284
 285 /* Returns true if the current interp is the passed in name.  */
 286 int
 287 current_interp_named_p (const char *interp_name)
 288 {
 289   struct ui_interp_info *ui_interp = get_current_interp_info ();
 290   struct interp *interp = ui_interp->current_interpreter;
 291
 292   if (interp != NULL)
 293     return (strcmp (interp->name, interp_name) == 0);
 294
 295   return 0;
 296 }
 297
 298 /* The interpreter that was active when a command was executed.
 299    Normally that'd always be CURRENT_INTERPRETER, except that MI's
 300    -interpreter-exec command doesn't actually flip the current
 301    interpreter when running its sub-command.  The
 302    `command_interpreter' global tracks when interp_exec is called
 303    (IOW, when -interpreter-exec is called).  If that is set, it is
 304    INTERP in '-interpreter-exec INTERP "CMD"' or in 'interpreter-exec
 305    INTERP "CMD".  Otherwise, interp_exec isn't active, and so the
 306    interpreter running the command is the current interpreter.  */
 307
 308 struct interp *
 309 command_interp (void)
 310 {
 311   struct ui_interp_info *ui_interp = get_current_interp_info ();
 312
 313   if (ui_interp->command_interpreter != NULL)
 314     return ui_interp->command_interpreter;
 315   else
 316     return ui_interp->current_interpreter;
 317 }
 318
 319 /* See interps.h.  */
 320
 321 void
 322 interp_pre_command_loop (struct interp *interp)
 323 {
 324   gdb_assert (interp != NULL);
 325
 326   interp->pre_command_loop ();
 327 }
 328
 329 /* See interp.h  */
 330
 331 int
 332 interp_supports_command_editing (struct interp *interp)
 333 {
 334   return interp->supports_command_editing ();
 335 }
 336
 337 /* interp_exec - This executes COMMAND_STR in the current
 338    interpreter.  */
 339
 340 struct gdb_exception
 341 interp_exec (struct interp *interp, const char *command_str)
 342 {
 343   struct ui_interp_info *ui_interp = get_current_interp_info ();
 344
 345   /* See `command_interp' for why we do this.  */
 346   scoped_restore save_command_interp
 347     = make_scoped_restore (&ui_interp->command_interpreter, interp);
 348
 349   return interp->exec (command_str);
 350 }
 351
 352 /* A convenience routine that nulls out all the common command hooks.
 353    Use it when removing your interpreter in its suspend proc.  */
 354 void
 355 clear_interpreter_hooks (void)
 356 {
 357   deprecated_print_frame_info_listing_hook = 0;
 358   /*print_frame_more_info_hook = 0; */
 359   deprecated_query_hook = 0;
 360   deprecated_warning_hook = 0;
 361   deprecated_interactive_hook = 0;
 362   deprecated_readline_begin_hook = 0;
 363   deprecated_readline_hook = 0;
 364   deprecated_readline_end_hook = 0;
 365   deprecated_context_hook = 0;
 366   deprecated_target_wait_hook = 0;
 367   deprecated_call_command_hook = 0;
 368   deprecated_error_begin_hook = 0;
 369 }
 370
 371 static void
 372 interpreter_exec_cmd (const char *args, int from_tty)
 373 {
 374   struct ui_interp_info *ui_interp = get_current_interp_info ();
 375   struct interp *old_interp, *interp_to_use;
 376   unsigned int nrules;
 377   unsigned int i;
 378
 379   if (args == NULL)
 380     error_no_arg (_("interpreter-exec command"));
 381
 382   gdb_argv prules (args);
 383   nrules = prules.count ();
 384
 385   if (nrules < 2)
 386     error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
 387
 388   old_interp = ui_interp->current_interpreter;
 389
 390   interp_to_use = interp_lookup (current_ui, prules[0]);
 391   if (interp_to_use == NULL)
 392     error (_("Could not find interpreter \"%s\"."), prules[0]);
 393
 394   interp_set (interp_to_use, false);
 395
 396   for (i = 1; i < nrules; i++)
 397     {
 398       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
 399
 400       if (e.reason < 0)
 401         {
 402           interp_set (old_interp, 0);
 403           error (_("error in command: \"%s\"."), prules[i]);
 404         }
 405     }
 406
 407   interp_set (old_interp, 0);
 408 }
 409
 410 /* See interps.h.  */
 411
 412 void
 413 interpreter_completer (struct cmd_list_element *ignore,
 414                        completion_tracker &tracker,
 415                        const char *text, const char *word)
 416 {
 417   int textlen = strlen (text);
 418
 419   for (const interp_factory &interp : interpreter_factories)
 420     {
 421       if (strncmp (interp.name, text, textlen) == 0)
 422         {
 423           tracker.add_completion
 424             (make_completion_match_str (interp.name, text, word));
 425         }
 426     }
 427 }
 428
 429 struct interp *
 430 top_level_interpreter (void)
 431 {
 432   struct ui_interp_info *ui_interp = get_current_interp_info ();
 433
 434   return ui_interp->top_level_interpreter;
 435 }
 436
 437 /* See interps.h.  */
 438
 439 struct interp *
 440 current_interpreter (void)
 441 {
 442   struct ui_interp_info *ui_interp = get_interp_info (current_ui);
 443
 444   return ui_interp->current_interpreter;
 445 }
 446
 447 /* This just adds the "interpreter-exec" command.  */
 448 void
 449 _initialize_interpreter (void)
 450 {
 451   struct cmd_list_element *c;
 452
 453   c = add_cmd ("interpreter-exec", class_support,
 454                interpreter_exec_cmd, _("\
 455 Execute a command in an interpreter.  It takes two arguments:\n\
 456 The first argument is the name of the interpreter to use.\n\
 457 The second argument is the command to execute.\n"), &cmdlist);
 458   set_cmd_completer (c, interpreter_completer);
 459 }