gdb/interps.c

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