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