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