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