gdb/interps.c

   1 /* Manages interpreters for GDB, the GNU debugger.
   2
   3    Copyright (C) 2000-2017 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   struct gdb_exception ex;
 358   struct interp *save_command_interp;
 359
 360   /* See `command_interp' for why we do this.  */
 361   save_command_interp = ui_interp->command_interpreter;
 362   ui_interp->command_interpreter = interp;
 363
 364   ex = interp->exec (command_str);
 365
 366   ui_interp->command_interpreter = save_command_interp;
 367
 368   return ex;
 369 }
 370
 371 /* A convenience routine that nulls out all the common command hooks.
 372    Use it when removing your interpreter in its suspend proc.  */
 373 void
 374 clear_interpreter_hooks (void)
 375 {
 376   deprecated_print_frame_info_listing_hook = 0;
 377   /*print_frame_more_info_hook = 0; */
 378   deprecated_query_hook = 0;
 379   deprecated_warning_hook = 0;
 380   deprecated_interactive_hook = 0;
 381   deprecated_readline_begin_hook = 0;
 382   deprecated_readline_hook = 0;
 383   deprecated_readline_end_hook = 0;
 384   deprecated_context_hook = 0;
 385   deprecated_target_wait_hook = 0;
 386   deprecated_call_command_hook = 0;
 387   deprecated_error_begin_hook = 0;
 388 }
 389
 390 static void
 391 interpreter_exec_cmd (const char *args, int from_tty)
 392 {
 393   struct ui_interp_info *ui_interp = get_current_interp_info ();
 394   struct interp *old_interp, *interp_to_use;
 395   unsigned int nrules;
 396   unsigned int i;
 397
 398   if (args == NULL)
 399     error_no_arg (_("interpreter-exec command"));
 400
 401   gdb_argv prules (args);
 402   nrules = prules.count ();
 403
 404   if (nrules < 2)
 405     error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
 406
 407   old_interp = ui_interp->current_interpreter;
 408
 409   interp_to_use = interp_lookup (current_ui, prules[0]);
 410   if (interp_to_use == NULL)
 411     error (_("Could not find interpreter \"%s\"."), prules[0]);
 412
 413   interp_set (interp_to_use, false);
 414
 415   for (i = 1; i < nrules; i++)
 416     {
 417       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
 418
 419       if (e.reason < 0)
 420         {
 421           interp_set (old_interp, 0);
 422           error (_("error in command: \"%s\"."), prules[i]);
 423         }
 424     }
 425
 426   interp_set (old_interp, 0);
 427 }
 428
 429 /* See interps.h.  */
 430
 431 void
 432 interpreter_completer (struct cmd_list_element *ignore,
 433                        completion_tracker &tracker,
 434                        const char *text, const char *word)
 435 {
 436   int textlen = strlen (text);
 437
 438   for (const interp_factory &interp : interpreter_factories)
 439     {
 440       if (strncmp (interp.name, text, textlen) == 0)
 441         {
 442           char *match;
 443
 444           match = (char *) xmalloc (strlen (word) + strlen (interp.name) + 1);
 445           if (word == text)
 446             strcpy (match, interp.name);
 447           else if (word > text)
 448             {
 449               /* Return some portion of interp->name.  */
 450               strcpy (match, interp.name + (word - text));
 451             }
 452           else
 453             {
 454               /* Return some of text plus interp->name.  */
 455               strncpy (match, word, text - word);
 456               match[text - word] = '\0';
 457               strcat (match, interp.name);
 458             }
 459           tracker.add_completion (gdb::unique_xmalloc_ptr<char> (match));
 460         }
 461     }
 462 }
 463
 464 struct interp *
 465 top_level_interpreter (void)
 466 {
 467   struct ui_interp_info *ui_interp = get_current_interp_info ();
 468
 469   return ui_interp->top_level_interpreter;
 470 }
 471
 472 /* See interps.h.  */
 473
 474 struct interp *
 475 current_interpreter (void)
 476 {
 477   struct ui_interp_info *ui_interp = get_interp_info (current_ui);
 478
 479   return ui_interp->current_interpreter;
 480 }
 481
 482 /* This just adds the "interpreter-exec" command.  */
 483 void
 484 _initialize_interpreter (void)
 485 {
 486   struct cmd_list_element *c;
 487
 488   c = add_cmd ("interpreter-exec", class_support,
 489                interpreter_exec_cmd, _("\
 490 Execute a command in an interpreter.  It takes two arguments:\n\
 491 The first argument is the name of the interpreter to use.\n\
 492 The second argument is the command to execute.\n"), &cmdlist);
 493   set_cmd_completer (c, interpreter_completer);
 494 }