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   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       ui_out_flush (current_uiout);
 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       ui_out_text (current_uiout, 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 /* Returns the current interpreter.  */
 323
 324 struct ui_out *
 325 interp_ui_out (struct interp *interp)
 326 {
 327   struct ui_interp_info *ui_interp = get_current_interp_info ();
 328
 329   if (interp == NULL)
 330     interp = ui_interp->current_interpreter;
 331   return interp->procs->ui_out_proc (interp);
 332 }
 333
 334 int
 335 current_interp_set_logging (int start_log, struct ui_file *out,
 336                             struct ui_file *logfile)
 337 {
 338   struct ui_interp_info *ui_interp = get_current_interp_info ();
 339   struct interp *interp = ui_interp->current_interpreter;
 340
 341   if (interp == NULL
 342       || interp->procs->set_logging_proc == NULL)
 343     return 0;
 344
 345   return interp->procs->set_logging_proc (interp, start_log, out, logfile);
 346 }
 347
 348 /* Temporarily overrides the current interpreter.  */
 349 struct interp *
 350 interp_set_temp (const char *name)
 351 {
 352   struct ui_interp_info *ui_interp = get_current_interp_info ();
 353   struct interp *interp = interp_lookup (current_ui, name);
 354   struct interp *old_interp = ui_interp->current_interpreter;
 355
 356   if (interp)
 357     ui_interp->current_interpreter = interp;
 358   return old_interp;
 359 }
 360
 361 /* Returns the interpreter's cookie.  */
 362
 363 void *
 364 interp_data (struct interp *interp)
 365 {
 366   return interp->data;
 367 }
 368
 369 /* Returns the interpreter's name.  */
 370
 371 const char *
 372 interp_name (struct interp *interp)
 373 {
 374   return interp->name;
 375 }
 376
 377 /* Returns true if the current interp is the passed in name.  */
 378 int
 379 current_interp_named_p (const char *interp_name)
 380 {
 381   struct ui_interp_info *ui_interp = get_current_interp_info ();
 382   struct interp *interp = ui_interp->current_interpreter;
 383
 384   if (interp != NULL)
 385     return (strcmp (interp->name, interp_name) == 0);
 386
 387   return 0;
 388 }
 389
 390 /* The interpreter that was active when a command was executed.
 391    Normally that'd always be CURRENT_INTERPRETER, except that MI's
 392    -interpreter-exec command doesn't actually flip the current
 393    interpreter when running its sub-command.  The
 394    `command_interpreter' global tracks when interp_exec is called
 395    (IOW, when -interpreter-exec is called).  If that is set, it is
 396    INTERP in '-interpreter-exec INTERP "CMD"' or in 'interpreter-exec
 397    INTERP "CMD".  Otherwise, interp_exec isn't active, and so the
 398    interpreter running the command is the current interpreter.  */
 399
 400 struct interp *
 401 command_interp (void)
 402 {
 403   struct ui_interp_info *ui_interp = get_current_interp_info ();
 404
 405   if (ui_interp->command_interpreter != NULL)
 406     return ui_interp->command_interpreter;
 407   else
 408     return ui_interp->current_interpreter;
 409 }
 410
 411 /* See interps.h.  */
 412
 413 void
 414 interp_pre_command_loop (struct interp *interp)
 415 {
 416   gdb_assert (interp != NULL);
 417
 418   if (interp->procs->pre_command_loop_proc != NULL)
 419     interp->procs->pre_command_loop_proc (interp);
 420 }
 421
 422 /* See interp.h  */
 423
 424 int
 425 interp_supports_command_editing (struct interp *interp)
 426 {
 427   if (interp->procs->supports_command_editing_proc != NULL)
 428     return interp->procs->supports_command_editing_proc (interp);
 429   return 0;
 430 }
 431
 432 int
 433 interp_quiet_p (struct interp *interp)
 434 {
 435   struct ui_interp_info *ui_interp = get_current_interp_info ();
 436
 437   if (interp != NULL)
 438     return interp->quiet_p;
 439   else
 440     return ui_interp->current_interpreter->quiet_p;
 441 }
 442
 443 static int
 444 interp_set_quiet (struct interp *interp, int quiet)
 445 {
 446   int old_val = interp->quiet_p;
 447
 448   interp->quiet_p = quiet;
 449   return old_val;
 450 }
 451
 452 /* interp_exec - This executes COMMAND_STR in the current
 453    interpreter.  */
 454
 455 struct gdb_exception
 456 interp_exec (struct interp *interp, const char *command_str)
 457 {
 458   struct ui_interp_info *ui_interp = get_current_interp_info ();
 459
 460   struct gdb_exception ex;
 461   struct interp *save_command_interp;
 462
 463   gdb_assert (interp->procs->exec_proc != NULL);
 464
 465   /* See `command_interp' for why we do this.  */
 466   save_command_interp = ui_interp->command_interpreter;
 467   ui_interp->command_interpreter = interp;
 468
 469   ex = interp->procs->exec_proc (interp->data, command_str);
 470
 471   ui_interp->command_interpreter = save_command_interp;
 472
 473   return ex;
 474 }
 475
 476 /* A convenience routine that nulls out all the common command hooks.
 477    Use it when removing your interpreter in its suspend proc.  */
 478 void
 479 clear_interpreter_hooks (void)
 480 {
 481   deprecated_print_frame_info_listing_hook = 0;
 482   /*print_frame_more_info_hook = 0; */
 483   deprecated_query_hook = 0;
 484   deprecated_warning_hook = 0;
 485   deprecated_interactive_hook = 0;
 486   deprecated_readline_begin_hook = 0;
 487   deprecated_readline_hook = 0;
 488   deprecated_readline_end_hook = 0;
 489   deprecated_context_hook = 0;
 490   deprecated_target_wait_hook = 0;
 491   deprecated_call_command_hook = 0;
 492   deprecated_error_begin_hook = 0;
 493 }
 494
 495 static void
 496 interpreter_exec_cmd (char *args, int from_tty)
 497 {
 498   struct ui_interp_info *ui_interp = get_current_interp_info ();
 499   struct interp *old_interp, *interp_to_use;
 500   char **prules = NULL;
 501   char **trule = NULL;
 502   unsigned int nrules;
 503   unsigned int i;
 504   int old_quiet, use_quiet;
 505   struct cleanup *cleanup;
 506
 507   if (args == NULL)
 508     error_no_arg (_("interpreter-exec command"));
 509
 510   prules = gdb_buildargv (args);
 511   cleanup = make_cleanup_freeargv (prules);
 512
 513   nrules = 0;
 514   for (trule = prules; *trule != NULL; trule++)
 515     nrules++;
 516
 517   if (nrules < 2)
 518     error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
 519
 520   old_interp = ui_interp->current_interpreter;
 521
 522   interp_to_use = interp_lookup (current_ui, prules[0]);
 523   if (interp_to_use == NULL)
 524     error (_("Could not find interpreter \"%s\"."), prules[0]);
 525
 526   /* Temporarily set interpreters quiet.  */
 527   old_quiet = interp_set_quiet (old_interp, 1);
 528   use_quiet = interp_set_quiet (interp_to_use, 1);
 529
 530   if (!interp_set (interp_to_use, 0))
 531     error (_("Could not switch to interpreter \"%s\"."), prules[0]);
 532
 533   for (i = 1; i < nrules; i++)
 534     {
 535       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
 536
 537       if (e.reason < 0)
 538         {
 539           interp_set (old_interp, 0);
 540           interp_set_quiet (interp_to_use, use_quiet);
 541           interp_set_quiet (old_interp, old_quiet);
 542           error (_("error in command: \"%s\"."), prules[i]);
 543         }
 544     }
 545
 546   interp_set (old_interp, 0);
 547   interp_set_quiet (interp_to_use, use_quiet);
 548   interp_set_quiet (old_interp, old_quiet);
 549
 550   do_cleanups (cleanup);
 551 }
 552
 553 /* List the possible interpreters which could complete the given text.  */
 554 static VEC (char_ptr) *
 555 interpreter_completer (struct cmd_list_element *ignore,
 556                        const char *text, const char *word)
 557 {
 558   struct interp_factory *interp;
 559   int textlen;
 560   VEC (char_ptr) *matches = NULL;
 561   int ix;
 562
 563   textlen = strlen (text);
 564   for (ix = 0;
 565        VEC_iterate (interp_factory_p, interpreter_factories, ix, interp);
 566        ++ix)
 567     {
 568       if (strncmp (interp->name, text, textlen) == 0)
 569         {
 570           char *match;
 571
 572           match = (char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
 573           if (word == text)
 574             strcpy (match, interp->name);
 575           else if (word > text)
 576             {
 577               /* Return some portion of interp->name.  */
 578               strcpy (match, interp->name + (word - text));
 579             }
 580           else
 581             {
 582               /* Return some of text plus interp->name.  */
 583               strncpy (match, word, text - word);
 584               match[text - word] = '\0';
 585               strcat (match, interp->name);
 586             }
 587           VEC_safe_push (char_ptr, matches, match);
 588         }
 589     }
 590
 591   return matches;
 592 }
 593
 594 struct interp *
 595 top_level_interpreter (void)
 596 {
 597   struct ui_interp_info *ui_interp = get_current_interp_info ();
 598
 599   return ui_interp->top_level_interpreter;
 600 }
 601
 602 void *
 603 top_level_interpreter_data (void)
 604 {
 605   struct interp *interp;
 606
 607   interp = top_level_interpreter ();
 608   gdb_assert (interp != NULL);
 609   return interp->data;
 610 }
 611
 612 /* See interps.h.  */
 613
 614 struct interp *
 615 current_interpreter (void)
 616 {
 617   struct ui_interp_info *ui_interp = get_interp_info (current_ui);
 618
 619   return ui_interp->current_interpreter;
 620 }
 621
 622 /* This just adds the "interpreter-exec" command.  */
 623 void
 624 _initialize_interpreter (void)
 625 {
 626   struct cmd_list_element *c;
 627
 628   c = add_cmd ("interpreter-exec", class_support,
 629                interpreter_exec_cmd, _("\
 630 Execute a command in an interpreter.  It takes two arguments:\n\
 631 The first argument is the name of the interpreter to use.\n\
 632 The second argument is the command to execute.\n"), &cmdlist);
 633   set_cmd_completer (c, interpreter_completer);
 634 }