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