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