gdb/interps.c

   1 /* Manages interpreters for GDB, the GNU debugger.
   2
   3    Copyright (C) 2000, 2002, 2003, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    Written by Jim Ingham <jingham@apple.com> of Apple Computer, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 /* This is just a first cut at separating out the "interpreter"
  24    functions of gdb into self-contained modules.  There are a couple
  25    of open areas that need to be sorted out:
  26
  27    1) The interpreter explicitly contains a UI_OUT, and can insert itself
  28    into the event loop, but it doesn't explicitly contain hooks for readline.
  29    I did this because it seems to me many interpreters won't want to use
  30    the readline command interface, and it is probably simpler to just let
  31    them take over the input in their resume proc.  */
  32
  33 #include "defs.h"
  34 #include "gdbcmd.h"
  35 #include "ui-out.h"
  36 #include "event-loop.h"
  37 #include "event-top.h"
  38 #include "interps.h"
  39 #include "completer.h"
  40 #include "gdb_string.h"
  41 #include "gdb_assert.h"
  42 #include "top.h"                /* For command_loop.  */
  43 #include "exceptions.h"
  44 #include "continuations.h"
  45
  46 /* True if the current interpreter in is async mode.  See interps.h
  47    for more details.  This starts out disabled, until all the explicit
  48    command line arguments (e.g., `gdb -ex "start" -ex "next"') are
  49    processed.  */
  50 int interpreter_async = 0;
  51
  52 struct interp
  53 {
  54   /* This is the name in "-i=" and set interpreter.  */
  55   const char *name;
  56
  57   /* Interpreters are stored in a linked list, this is the next
  58      one...  */
  59   struct interp *next;
  60
  61   /* This is a cookie that an instance of the interpreter can use.
  62      This is a bit confused right now as the exact initialization
  63      sequence for it, and how it relates to the interpreter's uiout
  64      object is a bit confused.  */
  65   void *data;
  66
  67   /* Has the init_proc been run?  */
  68   int inited;
  69
  70   /* This is the ui_out used to collect results for this interpreter.
  71      It can be a formatter for stdout, as is the case for the console
  72      & mi outputs, or it might be a result formatter.  */
  73   struct ui_out *interpreter_out;
  74
  75   const struct interp_procs *procs;
  76   int quiet_p;
  77 };
  78
  79 /* Functions local to this file.  */
  80 static void initialize_interps (void);
  81 static char **interpreter_completer (struct cmd_list_element *cmd,
  82                                      char *text, char *word);
  83
  84 /* The magic initialization routine for this module.  */
  85
  86 void _initialize_interpreter (void);
  87
  88 /* Variables local to this file: */
  89
  90 static struct interp *interp_list = NULL;
  91 static struct interp *current_interpreter = NULL;
  92 static struct interp *top_level_interpreter_ptr = NULL;
  93
  94 static int interpreter_initialized = 0;
  95
  96 /* interp_new - This allocates space for a new interpreter,
  97    fills the fields from the inputs, and returns a pointer to the
  98    interpreter.  */
  99 struct interp *
 100 interp_new (const char *name, void *data, struct ui_out *uiout,
 101             const struct interp_procs *procs)
 102 {
 103   struct interp *new_interp;
 104
 105   new_interp = XMALLOC (struct interp);
 106
 107   new_interp->name = xstrdup (name);
 108   new_interp->data = data;
 109   new_interp->interpreter_out = uiout;
 110   new_interp->quiet_p = 0;
 111   new_interp->procs = procs;
 112   new_interp->inited = 0;
 113
 114   return new_interp;
 115 }
 116
 117 /* Add interpreter INTERP to the gdb interpreter list.  The
 118    interpreter must not have previously been added.  */
 119 void
 120 interp_add (struct interp *interp)
 121 {
 122   if (!interpreter_initialized)
 123     initialize_interps ();
 124
 125   gdb_assert (interp_lookup (interp->name) == NULL);
 126
 127   interp->next = interp_list;
 128   interp_list = interp;
 129 }
 130
 131 /* This sets the current interpreter to be INTERP.  If INTERP has not
 132    been initialized, then this will also run the init proc.  If the
 133    init proc is successful, return 1, if it fails, set the old
 134    interpreter back in place and return 0.  If we can't restore the
 135    old interpreter, then raise an internal error, since we are in
 136    pretty bad shape at this point.
 137
 138    The TOP_LEVEL parameter tells if this new interpreter is
 139    the top-level one.  The top-level is what is requested
 140    on the command line, and is responsible for reporting general
 141    notification about target state changes.  For example, if
 142    MI is the top-level interpreter, then it will always report
 143    events such as target stops and new thread creation, even if they
 144    are caused by CLI commands.  */
 145 int
 146 interp_set (struct interp *interp, int top_level)
 147 {
 148   struct interp *old_interp = current_interpreter;
 149   int first_time = 0;
 150   char buffer[64];
 151
 152   /* If we already have an interpreter, then trying to
 153      set top level interpreter is kinda pointless.  */
 154   gdb_assert (!top_level || !current_interpreter);
 155   gdb_assert (!top_level || !top_level_interpreter_ptr);
 156
 157   if (current_interpreter != NULL)
 158     {
 159       ui_out_flush (current_uiout);
 160       if (current_interpreter->procs->suspend_proc
 161           && !current_interpreter->procs->suspend_proc (current_interpreter->
 162                                                         data))
 163         {
 164           error (_("Could not suspend interpreter \"%s\"."),
 165                  current_interpreter->name);
 166         }
 167     }
 168   else
 169     {
 170       first_time = 1;
 171     }
 172
 173   current_interpreter = interp;
 174   if (top_level)
 175     top_level_interpreter_ptr = interp;
 176
 177   /* We use interpreter_p for the "set interpreter" variable, so we need
 178      to make sure we have a malloc'ed copy for the set command to free.  */
 179   if (interpreter_p != NULL
 180       && strcmp (current_interpreter->name, interpreter_p) != 0)
 181     {
 182       xfree (interpreter_p);
 183
 184       interpreter_p = xstrdup (current_interpreter->name);
 185     }
 186
 187   current_uiout = interp->interpreter_out;
 188
 189   /* Run the init proc.  If it fails, try to restore the old interp.  */
 190
 191   if (!interp->inited)
 192     {
 193       if (interp->procs->init_proc != NULL)
 194         {
 195           interp->data = interp->procs->init_proc (top_level);
 196         }
 197       interp->inited = 1;
 198     }
 199
 200   /* Clear out any installed interpreter hooks/event handlers.  */
 201   clear_interpreter_hooks ();
 202
 203   if (interp->procs->resume_proc != NULL
 204       && (!interp->procs->resume_proc (interp->data)))
 205     {
 206       if (old_interp == NULL || !interp_set (old_interp, 0))
 207         internal_error (__FILE__, __LINE__,
 208                         _("Failed to initialize new interp \"%s\" %s"),
 209                         interp->name, "and could not restore old interp!\n");
 210       return 0;
 211     }
 212
 213   /* Finally, put up the new prompt to show that we are indeed here.
 214      Also, display_gdb_prompt for the console does some readline magic
 215      which is needed for the console interpreter, at least...  */
 216
 217   if (!first_time)
 218     {
 219       if (!interp_quiet_p (interp))
 220         {
 221           sprintf (buffer, "Switching to interpreter \"%.24s\".\n",
 222                    interp->name);
 223           ui_out_text (current_uiout, buffer);
 224         }
 225       display_gdb_prompt (NULL);
 226     }
 227
 228   return 1;
 229 }
 230
 231 /* interp_lookup - Looks up the interpreter for NAME.  If no such
 232    interpreter exists, return NULL, otherwise return a pointer to the
 233    interpreter.  */
 234 struct interp *
 235 interp_lookup (const char *name)
 236 {
 237   struct interp *interp;
 238
 239   if (name == NULL || strlen (name) == 0)
 240     return NULL;
 241
 242   for (interp = interp_list; interp != NULL; interp = interp->next)
 243     {
 244       if (strcmp (interp->name, name) == 0)
 245         return interp;
 246     }
 247
 248   return NULL;
 249 }
 250
 251 /* Returns the current interpreter.  */
 252
 253 struct ui_out *
 254 interp_ui_out (struct interp *interp)
 255 {
 256   if (interp != NULL)
 257     return interp->interpreter_out;
 258
 259   return current_interpreter->interpreter_out;
 260 }
 261
 262 /* Returns true if the current interp is the passed in name.  */
 263 int
 264 current_interp_named_p (const char *interp_name)
 265 {
 266   if (current_interpreter)
 267     return (strcmp (current_interpreter->name, interp_name) == 0);
 268
 269   return 0;
 270 }
 271
 272 /* This is called in display_gdb_prompt.  If the proc returns a zero
 273    value, display_gdb_prompt will return without displaying the
 274    prompt.  */
 275 int
 276 current_interp_display_prompt_p (void)
 277 {
 278   if (current_interpreter == NULL
 279       || current_interpreter->procs->prompt_proc_p == NULL)
 280     return 0;
 281   else
 282     return current_interpreter->procs->prompt_proc_p (current_interpreter->
 283                                                       data);
 284 }
 285
 286 /* Run the current command interpreter's main loop.  */
 287 void
 288 current_interp_command_loop (void)
 289 {
 290   /* Somewhat messy.  For the moment prop up all the old ways of
 291      selecting the command loop.  `deprecated_command_loop_hook'
 292      should be deprecated.  */
 293   if (deprecated_command_loop_hook != NULL)
 294     deprecated_command_loop_hook ();
 295   else if (current_interpreter != NULL
 296            && current_interpreter->procs->command_loop_proc != NULL)
 297     current_interpreter->procs->command_loop_proc (current_interpreter->data);
 298   else
 299     cli_command_loop ();
 300 }
 301
 302 int
 303 interp_quiet_p (struct interp *interp)
 304 {
 305   if (interp != NULL)
 306     return interp->quiet_p;
 307   else
 308     return current_interpreter->quiet_p;
 309 }
 310
 311 static int
 312 interp_set_quiet (struct interp *interp, int quiet)
 313 {
 314   int old_val = interp->quiet_p;
 315
 316   interp->quiet_p = quiet;
 317   return old_val;
 318 }
 319
 320 /* interp_exec - This executes COMMAND_STR in the current
 321    interpreter.  */
 322 int
 323 interp_exec_p (struct interp *interp)
 324 {
 325   return interp->procs->exec_proc != NULL;
 326 }
 327
 328 struct gdb_exception
 329 interp_exec (struct interp *interp, const char *command_str)
 330 {
 331   if (interp->procs->exec_proc != NULL)
 332     {
 333       return interp->procs->exec_proc (interp->data, command_str);
 334     }
 335   return exception_none;
 336 }
 337
 338 /* A convenience routine that nulls out all the common command hooks.
 339    Use it when removing your interpreter in its suspend proc.  */
 340 void
 341 clear_interpreter_hooks (void)
 342 {
 343   deprecated_init_ui_hook = 0;
 344   deprecated_print_frame_info_listing_hook = 0;
 345   /*print_frame_more_info_hook = 0; */
 346   deprecated_query_hook = 0;
 347   deprecated_warning_hook = 0;
 348   deprecated_interactive_hook = 0;
 349   deprecated_readline_begin_hook = 0;
 350   deprecated_readline_hook = 0;
 351   deprecated_readline_end_hook = 0;
 352   deprecated_register_changed_hook = 0;
 353   deprecated_context_hook = 0;
 354   deprecated_target_wait_hook = 0;
 355   deprecated_call_command_hook = 0;
 356   deprecated_error_begin_hook = 0;
 357   deprecated_command_loop_hook = 0;
 358 }
 359
 360 /* This is a lazy init routine, called the first time the interpreter
 361    module is used.  I put it here just in case, but I haven't thought
 362    of a use for it yet.  I will probably bag it soon, since I don't
 363    think it will be necessary.  */
 364 static void
 365 initialize_interps (void)
 366 {
 367   interpreter_initialized = 1;
 368   /* Don't know if anything needs to be done here...  */
 369 }
 370
 371 static void
 372 interpreter_exec_cmd (char *args, int from_tty)
 373 {
 374   struct interp *old_interp, *interp_to_use;
 375   char **prules = NULL;
 376   char **trule = NULL;
 377   unsigned int nrules;
 378   unsigned int i;
 379   int old_quiet, use_quiet;
 380
 381   if (args == NULL)
 382     error_no_arg (_("interpreter-exec command"));
 383
 384   prules = gdb_buildargv (args);
 385   make_cleanup_freeargv (prules);
 386
 387   nrules = 0;
 388   for (trule = prules; *trule != NULL; trule++)
 389     nrules++;
 390
 391   if (nrules < 2)
 392     error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
 393
 394   old_interp = current_interpreter;
 395
 396   interp_to_use = interp_lookup (prules[0]);
 397   if (interp_to_use == NULL)
 398     error (_("Could not find interpreter \"%s\"."), prules[0]);
 399
 400   /* Temporarily set interpreters quiet.  */
 401   old_quiet = interp_set_quiet (old_interp, 1);
 402   use_quiet = interp_set_quiet (interp_to_use, 1);
 403
 404   if (!interp_set (interp_to_use, 0))
 405     error (_("Could not switch to interpreter \"%s\"."), prules[0]);
 406
 407   for (i = 1; i < nrules; i++)
 408     {
 409       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
 410
 411       if (e.reason < 0)
 412         {
 413           interp_set (old_interp, 0);
 414           interp_set_quiet (interp_to_use, use_quiet);
 415           interp_set_quiet (old_interp, old_quiet);
 416           error (_("error in command: \"%s\"."), prules[i]);
 417         }
 418     }
 419
 420   interp_set (old_interp, 0);
 421   interp_set_quiet (interp_to_use, use_quiet);
 422   interp_set_quiet (old_interp, old_quiet);
 423 }
 424
 425 /* List the possible interpreters which could complete the given text.  */
 426 static char **
 427 interpreter_completer (struct cmd_list_element *ignore, char *text, char *word)
 428 {
 429   int alloced = 0;
 430   int textlen;
 431   int num_matches;
 432   char **matches;
 433   struct interp *interp;
 434
 435   /* We expect only a very limited number of interpreters, so just
 436      allocate room for all of them plus one for the last that must be NULL
 437      to correctly end the list.  */
 438   for (interp = interp_list; interp != NULL; interp = interp->next)
 439     ++alloced;
 440   matches = (char **) xcalloc (alloced + 1, sizeof (char *));
 441
 442   num_matches = 0;
 443   textlen = strlen (text);
 444   for (interp = interp_list; interp != NULL; interp = interp->next)
 445     {
 446       if (strncmp (interp->name, text, textlen) == 0)
 447         {
 448           matches[num_matches] =
 449             (char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
 450           if (word == text)
 451             strcpy (matches[num_matches], interp->name);
 452           else if (word > text)
 453             {
 454               /* Return some portion of interp->name.  */
 455               strcpy (matches[num_matches], interp->name + (word - text));
 456             }
 457           else
 458             {
 459               /* Return some of text plus interp->name.  */
 460               strncpy (matches[num_matches], word, text - word);
 461               matches[num_matches][text - word] = '\0';
 462               strcat (matches[num_matches], interp->name);
 463             }
 464           ++num_matches;
 465         }
 466     }
 467
 468   if (num_matches == 0)
 469     {
 470       xfree (matches);
 471       matches = NULL;
 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 }