gdb/interps.c

   1 /* Manages interpreters for GDB, the GNU debugger.
   2
   3    Copyright (C) 2000-2016 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 struct interp
  76 {
  77   /* This is the name in "-i=" and set interpreter.  */
  78   const char *name;
  79
  80   /* Interpreters are stored in a linked list, this is the next
  81      one...  */
  82   struct interp *next;
  83
  84   /* This is a cookie that an instance of the interpreter can use.
  85      This is a bit confused right now as the exact initialization
  86      sequence for it, and how it relates to the interpreter's uiout
  87      object is a bit confused.  */
  88   void *data;
  89
  90   /* Has the init_proc been run?  */
  91   int inited;
  92
  93   const struct interp_procs *procs;
  94   int quiet_p;
  95 };
  96
  97 /* The magic initialization routine for this module.  */
  98
  99 void _initialize_interpreter (void);
 100
 101 static struct interp *interp_lookup_existing (struct ui *ui,
 102                                               const char *name);
 103
 104 /* interp_new - This allocates space for a new interpreter,
 105    fills the fields from the inputs, and returns a pointer to the
 106    interpreter.  */
 107 struct interp *
 108 interp_new (const char *name, const struct interp_procs *procs, void *data)
 109 {
 110   struct interp *new_interp;
 111
 112   new_interp = XNEW (struct interp);
 113
 114   new_interp->name = xstrdup (name);
 115   new_interp->data = data;
 116   new_interp->quiet_p = 0;
 117   new_interp->procs = procs;
 118   new_interp->inited = 0;
 119
 120   /* Check for required procs.  */
 121   gdb_assert (procs->command_loop_proc != NULL);
 122
 123   return new_interp;
 124 }
 125
 126 /* An interpreter factory.  Maps an interpreter name to the factory
 127    function that instantiates an interpreter by that name.  */
 128
 129 struct interp_factory
 130 {
 131   /* This is the name in "-i=INTERP" and "interpreter-exec INTERP".  */
 132   const char *name;
 133
 134   /* The function that creates the interpreter.  */
 135   interp_factory_func func;
 136 };
 137
 138 typedef struct interp_factory *interp_factory_p;
 139 DEF_VEC_P(interp_factory_p);
 140
 141 /* The registered interpreter factories.  */
 142 static VEC(interp_factory_p) *interpreter_factories = NULL;
 143
 144 /* See interps.h.  */
 145
 146 void
 147 interp_factory_register (const char *name, interp_factory_func func)
 148 {
 149   struct interp_factory *f;
 150   int ix;
 151
 152   /* Assert that no factory for NAME is already registered.  */
 153   for (ix = 0;
 154        VEC_iterate (interp_factory_p, interpreter_factories, ix, f);
 155        ++ix)
 156     if (strcmp (f->name, name) == 0)
 157       {
 158         internal_error (__FILE__, __LINE__,
 159                         _("interpreter factory already registered: \"%s\"\n"),
 160                         name);
 161       }
 162
 163   f = XNEW (struct interp_factory);
 164   f->name = name;
 165   f->func = func;
 166   VEC_safe_push (interp_factory_p, interpreter_factories, f);
 167 }
 168
 169 /* Add interpreter INTERP to the gdb interpreter list.  The
 170    interpreter must not have previously been added.  */
 171 void
 172 interp_add (struct ui *ui, struct interp *interp)
 173 {
 174   struct ui_interp_info *ui_interp = get_interp_info (ui);
 175
 176   gdb_assert (interp_lookup_existing (ui, interp->name) == NULL);
 177
 178   interp->next = ui_interp->interp_list;
 179   ui_interp->interp_list = interp;
 180 }
 181
 182 /* This sets the current interpreter to be INTERP.  If INTERP has not
 183    been initialized, then this will also run the init proc.  If the
 184    init proc is successful, return 1, if it fails, set the old
 185    interpreter back in place and return 0.  If we can't restore the
 186    old interpreter, then raise an internal error, since we are in
 187    pretty bad shape at this point.
 188
 189    The TOP_LEVEL parameter tells if this new interpreter is
 190    the top-level one.  The top-level is what is requested
 191    on the command line, and is responsible for reporting general
 192    notification about target state changes.  For example, if
 193    MI is the top-level interpreter, then it will always report
 194    events such as target stops and new thread creation, even if they
 195    are caused by CLI commands.  */
 196 int
 197 interp_set (struct interp *interp, int top_level)
 198 {
 199   struct ui_interp_info *ui_interp = get_current_interp_info ();
 200   struct interp *old_interp = ui_interp->current_interpreter;
 201   int first_time = 0;
 202   char buffer[64];
 203
 204   /* If we already have an interpreter, then trying to
 205      set top level interpreter is kinda pointless.  */
 206   gdb_assert (!top_level || !ui_interp->current_interpreter);
 207   gdb_assert (!top_level || !ui_interp->top_level_interpreter);
 208
 209   if (old_interp != NULL)
 210     {
 211       ui_out_flush (current_uiout);
 212       if (old_interp->procs->suspend_proc
 213           && !old_interp->procs->suspend_proc (old_interp->data))
 214         {
 215           error (_("Could not suspend interpreter \"%s\"."),
 216                  old_interp->name);
 217         }
 218     }
 219   else
 220     {
 221       first_time = 1;
 222     }
 223
 224   ui_interp->current_interpreter = interp;
 225   if (top_level)
 226     ui_interp->top_level_interpreter = interp;
 227
 228   /* We use interpreter_p for the "set interpreter" variable, so we need
 229      to make sure we have a malloc'ed copy for the set command to free.  */
 230   if (interpreter_p != NULL
 231       && strcmp (interp->name, interpreter_p) != 0)
 232     {
 233       xfree (interpreter_p);
 234
 235       interpreter_p = xstrdup (interp->name);
 236     }
 237
 238   /* Run the init proc.  If it fails, try to restore the old interp.  */
 239
 240   if (!interp->inited)
 241     {
 242       if (interp->procs->init_proc != NULL)
 243         {
 244           interp->data = interp->procs->init_proc (interp, top_level);
 245         }
 246       interp->inited = 1;
 247     }
 248
 249   /* Do this only after the interpreter is initialized.  */
 250   current_uiout = interp->procs->ui_out_proc (interp);
 251
 252   /* Clear out any installed interpreter hooks/event handlers.  */
 253   clear_interpreter_hooks ();
 254
 255   if (interp->procs->resume_proc != NULL
 256       && (!interp->procs->resume_proc (interp->data)))
 257     {
 258       if (old_interp == NULL || !interp_set (old_interp, 0))
 259         internal_error (__FILE__, __LINE__,
 260                         _("Failed to initialize new interp \"%s\" %s"),
 261                         interp->name, "and could not restore old interp!\n");
 262       return 0;
 263     }
 264
 265   if (!first_time && !interp_quiet_p (interp))
 266     {
 267       xsnprintf (buffer, sizeof (buffer),
 268                  "Switching to interpreter \"%.24s\".\n", interp->name);
 269       ui_out_text (current_uiout, buffer);
 270     }
 271
 272   return 1;
 273 }
 274
 275 /* Look up the interpreter for NAME.  If no such interpreter exists,
 276    return NULL, otherwise return a pointer to the interpreter.  */
 277
 278 static struct interp *
 279 interp_lookup_existing (struct ui *ui, const char *name)
 280 {
 281   struct ui_interp_info *ui_interp = get_interp_info (ui);
 282   struct interp *interp;
 283
 284   for (interp = ui_interp->interp_list;
 285        interp != NULL;
 286        interp = interp->next)
 287     {
 288       if (strcmp (interp->name, name) == 0)
 289         return interp;
 290     }
 291
 292   return NULL;
 293 }
 294
 295 /* See interps.h.  */
 296
 297 struct interp *
 298 interp_lookup (struct ui *ui, const char *name)
 299 {
 300   struct interp_factory *factory;
 301   struct interp *interp;
 302   int ix;
 303
 304   if (name == NULL || strlen (name) == 0)
 305     return NULL;
 306
 307   /* Only create each interpreter once per top level.  */
 308   interp = interp_lookup_existing (ui, name);
 309   if (interp != NULL)
 310     return interp;
 311
 312   for (ix = 0;
 313        VEC_iterate (interp_factory_p, interpreter_factories, ix, factory);
 314        ++ix)
 315     if (strcmp (factory->name, name) == 0)
 316       {
 317         interp = factory->func (name);
 318         interp_add (ui, interp);
 319         return interp;
 320       }
 321
 322   return NULL;
 323 }
 324
 325 /* Returns the current interpreter.  */
 326
 327 struct ui_out *
 328 interp_ui_out (struct interp *interp)
 329 {
 330   struct ui_interp_info *ui_interp = get_current_interp_info ();
 331
 332   if (interp == NULL)
 333     interp = ui_interp->current_interpreter;
 334   return interp->procs->ui_out_proc (interp);
 335 }
 336
 337 int
 338 current_interp_set_logging (int start_log, struct ui_file *out,
 339                             struct ui_file *logfile)
 340 {
 341   struct ui_interp_info *ui_interp = get_current_interp_info ();
 342   struct interp *interp = ui_interp->current_interpreter;
 343
 344   if (interp == NULL
 345       || interp->procs->set_logging_proc == NULL)
 346     return 0;
 347
 348   return interp->procs->set_logging_proc (interp, start_log, out, logfile);
 349 }
 350
 351 /* Temporarily overrides the current interpreter.  */
 352 struct interp *
 353 interp_set_temp (const char *name)
 354 {
 355   struct ui_interp_info *ui_interp = get_current_interp_info ();
 356   struct interp *interp = interp_lookup (current_ui, name);
 357   struct interp *old_interp = ui_interp->current_interpreter;
 358
 359   if (interp)
 360     ui_interp->current_interpreter = interp;
 361   return old_interp;
 362 }
 363
 364 /* Returns the interpreter's cookie.  */
 365
 366 void *
 367 interp_data (struct interp *interp)
 368 {
 369   return interp->data;
 370 }
 371
 372 /* Returns the interpreter's name.  */
 373
 374 const char *
 375 interp_name (struct interp *interp)
 376 {
 377   return interp->name;
 378 }
 379
 380 /* Returns true if the current interp is the passed in name.  */
 381 int
 382 current_interp_named_p (const char *interp_name)
 383 {
 384   struct ui_interp_info *ui_interp = get_current_interp_info ();
 385   struct interp *interp = ui_interp->current_interpreter;
 386
 387   if (interp != NULL)
 388     return (strcmp (interp->name, interp_name) == 0);
 389
 390   return 0;
 391 }
 392
 393 /* The interpreter that was active when a command was executed.
 394    Normally that'd always be CURRENT_INTERPRETER, except that MI's
 395    -interpreter-exec command doesn't actually flip the current
 396    interpreter when running its sub-command.  The
 397    `command_interpreter' global tracks when interp_exec is called
 398    (IOW, when -interpreter-exec is called).  If that is set, it is
 399    INTERP in '-interpreter-exec INTERP "CMD"' or in 'interpreter-exec
 400    INTERP "CMD".  Otherwise, interp_exec isn't active, and so the
 401    interpreter running the command is the current interpreter.  */
 402
 403 struct interp *
 404 command_interp (void)
 405 {
 406   struct ui_interp_info *ui_interp = get_current_interp_info ();
 407
 408   if (ui_interp->command_interpreter != NULL)
 409     return ui_interp->command_interpreter;
 410   else
 411     return ui_interp->current_interpreter;
 412 }
 413
 414 /* Run the current command interpreter's main loop.  */
 415 void
 416 current_interp_command_loop (void)
 417 {
 418   struct ui_interp_info *ui_interp = get_current_interp_info ();
 419   struct interp *interp = ui_interp->current_interpreter;
 420
 421   gdb_assert (ui_interp->current_interpreter != NULL);
 422
 423   interp->procs->command_loop_proc (interp->data);
 424 }
 425
 426 /* See interp.h  */
 427
 428 int
 429 interp_supports_command_editing (struct interp *interp)
 430 {
 431   if (interp->procs->supports_command_editing_proc != NULL)
 432     return interp->procs->supports_command_editing_proc (interp);
 433   return 0;
 434 }
 435
 436 int
 437 interp_quiet_p (struct interp *interp)
 438 {
 439   struct ui_interp_info *ui_interp = get_current_interp_info ();
 440
 441   if (interp != NULL)
 442     return interp->quiet_p;
 443   else
 444     return ui_interp->current_interpreter->quiet_p;
 445 }
 446
 447 static int
 448 interp_set_quiet (struct interp *interp, int quiet)
 449 {
 450   int old_val = interp->quiet_p;
 451
 452   interp->quiet_p = quiet;
 453   return old_val;
 454 }
 455
 456 /* interp_exec - This executes COMMAND_STR in the current
 457    interpreter.  */
 458
 459 struct gdb_exception
 460 interp_exec (struct interp *interp, const char *command_str)
 461 {
 462   struct ui_interp_info *ui_interp = get_current_interp_info ();
 463
 464   struct gdb_exception ex;
 465   struct interp *save_command_interp;
 466
 467   gdb_assert (interp->procs->exec_proc != NULL);
 468
 469   /* See `command_interp' for why we do this.  */
 470   save_command_interp = ui_interp->command_interpreter;
 471   ui_interp->command_interpreter = interp;
 472
 473   ex = interp->procs->exec_proc (interp->data, command_str);
 474
 475   ui_interp->command_interpreter = save_command_interp;
 476
 477   return ex;
 478 }
 479
 480 /* A convenience routine that nulls out all the common command hooks.
 481    Use it when removing your interpreter in its suspend proc.  */
 482 void
 483 clear_interpreter_hooks (void)
 484 {
 485   deprecated_print_frame_info_listing_hook = 0;
 486   /*print_frame_more_info_hook = 0; */
 487   deprecated_query_hook = 0;
 488   deprecated_warning_hook = 0;
 489   deprecated_interactive_hook = 0;
 490   deprecated_readline_begin_hook = 0;
 491   deprecated_readline_hook = 0;
 492   deprecated_readline_end_hook = 0;
 493   deprecated_context_hook = 0;
 494   deprecated_target_wait_hook = 0;
 495   deprecated_call_command_hook = 0;
 496   deprecated_error_begin_hook = 0;
 497 }
 498
 499 static void
 500 interpreter_exec_cmd (char *args, int from_tty)
 501 {
 502   struct ui_interp_info *ui_interp = get_current_interp_info ();
 503   struct interp *old_interp, *interp_to_use;
 504   char **prules = NULL;
 505   char **trule = NULL;
 506   unsigned int nrules;
 507   unsigned int i;
 508   int old_quiet, use_quiet;
 509   struct cleanup *cleanup;
 510
 511   if (args == NULL)
 512     error_no_arg (_("interpreter-exec command"));
 513
 514   prules = gdb_buildargv (args);
 515   cleanup = make_cleanup_freeargv (prules);
 516
 517   nrules = 0;
 518   for (trule = prules; *trule != NULL; trule++)
 519     nrules++;
 520
 521   if (nrules < 2)
 522     error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
 523
 524   old_interp = ui_interp->current_interpreter;
 525
 526   interp_to_use = interp_lookup (current_ui, prules[0]);
 527   if (interp_to_use == NULL)
 528     error (_("Could not find interpreter \"%s\"."), prules[0]);
 529
 530   /* Temporarily set interpreters quiet.  */
 531   old_quiet = interp_set_quiet (old_interp, 1);
 532   use_quiet = interp_set_quiet (interp_to_use, 1);
 533
 534   if (!interp_set (interp_to_use, 0))
 535     error (_("Could not switch to interpreter \"%s\"."), prules[0]);
 536
 537   for (i = 1; i < nrules; i++)
 538     {
 539       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
 540
 541       if (e.reason < 0)
 542         {
 543           interp_set (old_interp, 0);
 544           interp_set_quiet (interp_to_use, use_quiet);
 545           interp_set_quiet (old_interp, old_quiet);
 546           error (_("error in command: \"%s\"."), prules[i]);
 547         }
 548     }
 549
 550   interp_set (old_interp, 0);
 551   interp_set_quiet (interp_to_use, use_quiet);
 552   interp_set_quiet (old_interp, old_quiet);
 553
 554   do_cleanups (cleanup);
 555 }
 556
 557 /* List the possible interpreters which could complete the given text.  */
 558 static VEC (char_ptr) *
 559 interpreter_completer (struct cmd_list_element *ignore,
 560                        const char *text, const char *word)
 561 {
 562   struct interp_factory *interp;
 563   int textlen;
 564   VEC (char_ptr) *matches = NULL;
 565   int ix;
 566
 567   textlen = strlen (text);
 568   for (ix = 0;
 569        VEC_iterate (interp_factory_p, interpreter_factories, ix, interp);
 570        ++ix)
 571     {
 572       if (strncmp (interp->name, text, textlen) == 0)
 573         {
 574           char *match;
 575
 576           match = (char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
 577           if (word == text)
 578             strcpy (match, interp->name);
 579           else if (word > text)
 580             {
 581               /* Return some portion of interp->name.  */
 582               strcpy (match, interp->name + (word - text));
 583             }
 584           else
 585             {
 586               /* Return some of text plus interp->name.  */
 587               strncpy (match, word, text - word);
 588               match[text - word] = '\0';
 589               strcat (match, interp->name);
 590             }
 591           VEC_safe_push (char_ptr, matches, match);
 592         }
 593     }
 594
 595   return matches;
 596 }
 597
 598 struct interp *
 599 top_level_interpreter (void)
 600 {
 601   struct ui_interp_info *ui_interp = get_current_interp_info ();
 602
 603   return ui_interp->top_level_interpreter;
 604 }
 605
 606 void *
 607 top_level_interpreter_data (void)
 608 {
 609   struct interp *interp;
 610
 611   interp = top_level_interpreter ();
 612   gdb_assert (interp != NULL);
 613   return interp->data;
 614 }
 615
 616 /* This just adds the "interpreter-exec" command.  */
 617 void
 618 _initialize_interpreter (void)
 619 {
 620   struct cmd_list_element *c;
 621
 622   c = add_cmd ("interpreter-exec", class_support,
 623                interpreter_exec_cmd, _("\
 624 Execute a command in an interpreter.  It takes two arguments:\n\
 625 The first argument is the name of the interpreter to use.\n\
 626 The second argument is the command to execute.\n"), &cmdlist);
 627   set_cmd_completer (c, interpreter_completer);
 628 }