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 void _initialize_interpreter (void);
  78
  79 static struct interp *interp_lookup_existing (struct ui *ui,
  80                                               const char *name);
  81
  82 interp::interp (const char *name)
  83 {
  84   this->name = xstrdup (name);
  85   this->inited = false;
  86 }
  87
  88 interp::~interp ()
  89 {}
  90
  91 /* An interpreter factory.  Maps an interpreter name to the factory
  92    function that instantiates an interpreter by that name.  */
  93
  94 struct interp_factory
  95 {
  96   /* This is the name in "-i=INTERP" and "interpreter-exec INTERP".  */
  97   const char *name;
  98
  99   /* The function that creates the interpreter.  */
 100   interp_factory_func func;
 101 };
 102
 103 typedef struct interp_factory *interp_factory_p;
 104 DEF_VEC_P(interp_factory_p);
 105
 106 /* The registered interpreter factories.  */
 107 static VEC(interp_factory_p) *interpreter_factories = NULL;
 108
 109 /* See interps.h.  */
 110
 111 void
 112 interp_factory_register (const char *name, interp_factory_func func)
 113 {
 114   struct interp_factory *f;
 115   int ix;
 116
 117   /* Assert that no factory for NAME is already registered.  */
 118   for (ix = 0;
 119        VEC_iterate (interp_factory_p, interpreter_factories, ix, f);
 120        ++ix)
 121     if (strcmp (f->name, name) == 0)
 122       {
 123         internal_error (__FILE__, __LINE__,
 124                         _("interpreter factory already registered: \"%s\"\n"),
 125                         name);
 126       }
 127
 128   f = XNEW (struct interp_factory);
 129   f->name = name;
 130   f->func = func;
 131   VEC_safe_push (interp_factory_p, interpreter_factories, f);
 132 }
 133
 134 /* Add interpreter INTERP to the gdb interpreter list.  The
 135    interpreter must not have previously been added.  */
 136 void
 137 interp_add (struct ui *ui, struct interp *interp)
 138 {
 139   struct ui_interp_info *ui_interp = get_interp_info (ui);
 140
 141   gdb_assert (interp_lookup_existing (ui, interp->name) == NULL);
 142
 143   interp->next = ui_interp->interp_list;
 144   ui_interp->interp_list = interp;
 145 }
 146
 147 /* This sets the current interpreter to be INTERP.  If INTERP has not
 148    been initialized, then this will also run the init method.
 149
 150    The TOP_LEVEL parameter tells if this new interpreter is
 151    the top-level one.  The top-level is what is requested
 152    on the command line, and is responsible for reporting general
 153    notification about target state changes.  For example, if
 154    MI is the top-level interpreter, then it will always report
 155    events such as target stops and new thread creation, even if they
 156    are caused by CLI commands.  */
 157
 158 static void
 159 interp_set (struct interp *interp, bool top_level)
 160 {
 161   struct ui_interp_info *ui_interp = get_current_interp_info ();
 162   struct interp *old_interp = ui_interp->current_interpreter;
 163
 164   /* If we already have an interpreter, then trying to
 165      set top level interpreter is kinda pointless.  */
 166   gdb_assert (!top_level || !ui_interp->current_interpreter);
 167   gdb_assert (!top_level || !ui_interp->top_level_interpreter);
 168
 169   if (old_interp != NULL)
 170     {
 171       current_uiout->flush ();
 172       old_interp->suspend ();
 173     }
 174
 175   ui_interp->current_interpreter = interp;
 176   if (top_level)
 177     ui_interp->top_level_interpreter = interp;
 178
 179   /* We use interpreter_p for the "set interpreter" variable, so we need
 180      to make sure we have a malloc'ed copy for the set command to free.  */
 181   if (interpreter_p != NULL
 182       && strcmp (interp->name, interpreter_p) != 0)
 183     {
 184       xfree (interpreter_p);
 185
 186       interpreter_p = xstrdup (interp->name);
 187     }
 188
 189   /* Run the init proc.  */
 190   if (!interp->inited)
 191     {
 192       interp->init (top_level);
 193       interp->inited = true;
 194     }
 195
 196   /* Do this only after the interpreter is initialized.  */
 197   current_uiout = interp->interp_ui_out ();
 198
 199   /* Clear out any installed interpreter hooks/event handlers.  */
 200   clear_interpreter_hooks ();
 201
 202   interp->resume ();
 203 }
 204
 205 /* Look up the interpreter for NAME.  If no such interpreter exists,
 206    return NULL, otherwise return a pointer to the interpreter.  */
 207
 208 static struct interp *
 209 interp_lookup_existing (struct ui *ui, const char *name)
 210 {
 211   struct ui_interp_info *ui_interp = get_interp_info (ui);
 212   struct interp *interp;
 213
 214   for (interp = ui_interp->interp_list;
 215        interp != NULL;
 216        interp = interp->next)
 217     {
 218       if (strcmp (interp->name, name) == 0)
 219         return interp;
 220     }
 221
 222   return NULL;
 223 }
 224
 225 /* See interps.h.  */
 226
 227 struct interp *
 228 interp_lookup (struct ui *ui, const char *name)
 229 {
 230   struct interp_factory *factory;
 231   struct interp *interp;
 232   int ix;
 233
 234   if (name == NULL || strlen (name) == 0)
 235     return NULL;
 236
 237   /* Only create each interpreter once per top level.  */
 238   interp = interp_lookup_existing (ui, name);
 239   if (interp != NULL)
 240     return interp;
 241
 242   for (ix = 0;
 243        VEC_iterate (interp_factory_p, interpreter_factories, ix, factory);
 244        ++ix)
 245     if (strcmp (factory->name, name) == 0)
 246       {
 247         interp = factory->func (name);
 248         interp_add (ui, interp);
 249         return interp;
 250       }
 251
 252   return NULL;
 253 }
 254
 255 /* See interps.h.  */
 256
 257 void
 258 set_top_level_interpreter (const char *name)
 259 {
 260   /* Find it.  */
 261   struct interp *interp = interp_lookup (current_ui, name);
 262
 263   if (interp == NULL)
 264     error (_("Interpreter `%s' unrecognized"), name);
 265   /* Install it.  */
 266   interp_set (interp, true);
 267 }
 268
 269 /* Returns the current interpreter.  */
 270
 271 struct ui_out *
 272 interp_ui_out (struct interp *interp)
 273 {
 274   struct ui_interp_info *ui_interp = get_current_interp_info ();
 275
 276   if (interp == NULL)
 277     interp = ui_interp->current_interpreter;
 278   return interp->interp_ui_out ();
 279 }
 280
 281 void
 282 current_interp_set_logging (ui_file_up logfile,
 283                             bool logging_redirect)
 284 {
 285   struct ui_interp_info *ui_interp = get_current_interp_info ();
 286   struct interp *interp = ui_interp->current_interpreter;
 287
 288   interp->set_logging (std::move (logfile), logging_redirect);
 289 }
 290
 291 /* Temporarily overrides the current interpreter.  */
 292 struct interp *
 293 interp_set_temp (const char *name)
 294 {
 295   struct ui_interp_info *ui_interp = get_current_interp_info ();
 296   struct interp *interp = interp_lookup (current_ui, name);
 297   struct interp *old_interp = ui_interp->current_interpreter;
 298
 299   if (interp)
 300     ui_interp->current_interpreter = interp;
 301   return old_interp;
 302 }
 303
 304 /* Returns the interpreter's name.  */
 305
 306 const char *
 307 interp_name (struct interp *interp)
 308 {
 309   return interp->name;
 310 }
 311
 312 /* Returns true if the current interp is the passed in name.  */
 313 int
 314 current_interp_named_p (const char *interp_name)
 315 {
 316   struct ui_interp_info *ui_interp = get_current_interp_info ();
 317   struct interp *interp = ui_interp->current_interpreter;
 318
 319   if (interp != NULL)
 320     return (strcmp (interp->name, interp_name) == 0);
 321
 322   return 0;
 323 }
 324
 325 /* The interpreter that was active when a command was executed.
 326    Normally that'd always be CURRENT_INTERPRETER, except that MI's
 327    -interpreter-exec command doesn't actually flip the current
 328    interpreter when running its sub-command.  The
 329    `command_interpreter' global tracks when interp_exec is called
 330    (IOW, when -interpreter-exec is called).  If that is set, it is
 331    INTERP in '-interpreter-exec INTERP "CMD"' or in 'interpreter-exec
 332    INTERP "CMD".  Otherwise, interp_exec isn't active, and so the
 333    interpreter running the command is the current interpreter.  */
 334
 335 struct interp *
 336 command_interp (void)
 337 {
 338   struct ui_interp_info *ui_interp = get_current_interp_info ();
 339
 340   if (ui_interp->command_interpreter != NULL)
 341     return ui_interp->command_interpreter;
 342   else
 343     return ui_interp->current_interpreter;
 344 }
 345
 346 /* See interps.h.  */
 347
 348 void
 349 interp_pre_command_loop (struct interp *interp)
 350 {
 351   gdb_assert (interp != NULL);
 352
 353   interp->pre_command_loop ();
 354 }
 355
 356 /* See interp.h  */
 357
 358 int
 359 interp_supports_command_editing (struct interp *interp)
 360 {
 361   return interp->supports_command_editing ();
 362 }
 363
 364 /* interp_exec - This executes COMMAND_STR in the current
 365    interpreter.  */
 366
 367 struct gdb_exception
 368 interp_exec (struct interp *interp, const char *command_str)
 369 {
 370   struct ui_interp_info *ui_interp = get_current_interp_info ();
 371
 372   struct gdb_exception ex;
 373   struct interp *save_command_interp;
 374
 375   /* See `command_interp' for why we do this.  */
 376   save_command_interp = ui_interp->command_interpreter;
 377   ui_interp->command_interpreter = interp;
 378
 379   ex = interp->exec (command_str);
 380
 381   ui_interp->command_interpreter = save_command_interp;
 382
 383   return ex;
 384 }
 385
 386 /* A convenience routine that nulls out all the common command hooks.
 387    Use it when removing your interpreter in its suspend proc.  */
 388 void
 389 clear_interpreter_hooks (void)
 390 {
 391   deprecated_print_frame_info_listing_hook = 0;
 392   /*print_frame_more_info_hook = 0; */
 393   deprecated_query_hook = 0;
 394   deprecated_warning_hook = 0;
 395   deprecated_interactive_hook = 0;
 396   deprecated_readline_begin_hook = 0;
 397   deprecated_readline_hook = 0;
 398   deprecated_readline_end_hook = 0;
 399   deprecated_context_hook = 0;
 400   deprecated_target_wait_hook = 0;
 401   deprecated_call_command_hook = 0;
 402   deprecated_error_begin_hook = 0;
 403 }
 404
 405 static void
 406 interpreter_exec_cmd (char *args, int from_tty)
 407 {
 408   struct ui_interp_info *ui_interp = get_current_interp_info ();
 409   struct interp *old_interp, *interp_to_use;
 410   char **prules = NULL;
 411   char **trule = NULL;
 412   unsigned int nrules;
 413   unsigned int i;
 414   struct cleanup *cleanup;
 415
 416   if (args == NULL)
 417     error_no_arg (_("interpreter-exec command"));
 418
 419   prules = gdb_buildargv (args);
 420   cleanup = make_cleanup_freeargv (prules);
 421
 422   nrules = 0;
 423   for (trule = prules; *trule != NULL; trule++)
 424     nrules++;
 425
 426   if (nrules < 2)
 427     error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
 428
 429   old_interp = ui_interp->current_interpreter;
 430
 431   interp_to_use = interp_lookup (current_ui, prules[0]);
 432   if (interp_to_use == NULL)
 433     error (_("Could not find interpreter \"%s\"."), prules[0]);
 434
 435   interp_set (interp_to_use, false);
 436
 437   for (i = 1; i < nrules; i++)
 438     {
 439       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
 440
 441       if (e.reason < 0)
 442         {
 443           interp_set (old_interp, 0);
 444           error (_("error in command: \"%s\"."), prules[i]);
 445         }
 446     }
 447
 448   interp_set (old_interp, 0);
 449
 450   do_cleanups (cleanup);
 451 }
 452
 453 /* See interps.h.  */
 454
 455 VEC (char_ptr) *
 456 interpreter_completer (struct cmd_list_element *ignore,
 457                        const char *text, const char *word)
 458 {
 459   struct interp_factory *interp;
 460   int textlen;
 461   VEC (char_ptr) *matches = NULL;
 462   int ix;
 463
 464   textlen = strlen (text);
 465   for (ix = 0;
 466        VEC_iterate (interp_factory_p, interpreter_factories, ix, interp);
 467        ++ix)
 468     {
 469       if (strncmp (interp->name, text, textlen) == 0)
 470         {
 471           char *match;
 472
 473           match = (char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
 474           if (word == text)
 475             strcpy (match, interp->name);
 476           else if (word > text)
 477             {
 478               /* Return some portion of interp->name.  */
 479               strcpy (match, interp->name + (word - text));
 480             }
 481           else
 482             {
 483               /* Return some of text plus interp->name.  */
 484               strncpy (match, word, text - word);
 485               match[text - word] = '\0';
 486               strcat (match, interp->name);
 487             }
 488           VEC_safe_push (char_ptr, matches, match);
 489         }
 490     }
 491
 492   return matches;
 493 }
 494
 495 struct interp *
 496 top_level_interpreter (void)
 497 {
 498   struct ui_interp_info *ui_interp = get_current_interp_info ();
 499
 500   return ui_interp->top_level_interpreter;
 501 }
 502
 503 /* See interps.h.  */
 504
 505 struct interp *
 506 current_interpreter (void)
 507 {
 508   struct ui_interp_info *ui_interp = get_interp_info (current_ui);
 509
 510   return ui_interp->current_interpreter;
 511 }
 512
 513 /* This just adds the "interpreter-exec" command.  */
 514 void
 515 _initialize_interpreter (void)
 516 {
 517   struct cmd_list_element *c;
 518
 519   c = add_cmd ("interpreter-exec", class_support,
 520                interpreter_exec_cmd, _("\
 521 Execute a command in an interpreter.  It takes two arguments:\n\
 522 The first argument is the name of the interpreter to use.\n\
 523 The second argument is the command to execute.\n"), &cmdlist);
 524   set_cmd_completer (c, interpreter_completer);
 525 }