gdb/interps.c

   1 /* Manages interpreters for GDB, the GNU debugger.
   2
   3    Copyright (C) 2000, 2002, 2003, 2007 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 "gdb_string.h"
  40 #include "gdb-events.h"
  41 #include "gdb_assert.h"
  42 #include "top.h"                /* For command_loop.  */
  43 #include "exceptions.h"
  44
  45 struct interp
  46 {
  47   /* This is the name in "-i=" and set interpreter. */
  48   const char *name;
  49
  50   /* Interpreters are stored in a linked list, this is the next
  51      one...  */
  52   struct interp *next;
  53
  54   /* This is a cookie that an instance of the interpreter can use.
  55      This is a bit confused right now as the exact initialization
  56      sequence for it, and how it relates to the interpreter's uiout
  57      object is a bit confused.  */
  58   void *data;
  59
  60   /* Has the init_proc been run? */
  61   int inited;
  62
  63   /* This is the ui_out used to collect results for this interpreter.
  64      It can be a formatter for stdout, as is the case for the console
  65      & mi outputs, or it might be a result formatter.  */
  66   struct ui_out *interpreter_out;
  67
  68   const struct interp_procs *procs;
  69   int quiet_p;
  70 };
  71
  72 /* Functions local to this file. */
  73 static void initialize_interps (void);
  74 static char **interpreter_completer (char *text, char *word);
  75
  76 /* The magic initialization routine for this module. */
  77
  78 void _initialize_interpreter (void);
  79
  80 /* Variables local to this file: */
  81
  82 static struct interp *interp_list = NULL;
  83 static struct interp *current_interpreter = NULL;
  84
  85 static int interpreter_initialized = 0;
  86
  87 /* interp_new - This allocates space for a new interpreter,
  88    fills the fields from the inputs, and returns a pointer to the
  89    interpreter. */
  90 struct interp *
  91 interp_new (const char *name, void *data, struct ui_out *uiout,
  92             const struct interp_procs *procs)
  93 {
  94   struct interp *new_interp;
  95
  96   new_interp = XMALLOC (struct interp);
  97
  98   new_interp->name = xstrdup (name);
  99   new_interp->data = data;
 100   new_interp->interpreter_out = uiout;
 101   new_interp->quiet_p = 0;
 102   new_interp->procs = procs;
 103   new_interp->inited = 0;
 104
 105   return new_interp;
 106 }
 107
 108 /* Add interpreter INTERP to the gdb interpreter list.  The
 109    interpreter must not have previously been added.  */
 110 void
 111 interp_add (struct interp *interp)
 112 {
 113   if (!interpreter_initialized)
 114     initialize_interps ();
 115
 116   gdb_assert (interp_lookup (interp->name) == NULL);
 117
 118   interp->next = interp_list;
 119   interp_list = interp;
 120 }
 121
 122 /* This sets the current interpreter to be INTERP.  If INTERP has not
 123    been initialized, then this will also run the init proc.  If the
 124    init proc is successful, return 1, if it fails, set the old
 125    interpreter back in place and return 0.  If we can't restore the
 126    old interpreter, then raise an internal error, since we are in
 127    pretty bad shape at this point. */
 128 int
 129 interp_set (struct interp *interp)
 130 {
 131   struct interp *old_interp = current_interpreter;
 132   int first_time = 0;
 133
 134
 135   char buffer[64];
 136
 137   if (current_interpreter != NULL)
 138     {
 139       do_all_continuations ();
 140       ui_out_flush (uiout);
 141       if (current_interpreter->procs->suspend_proc
 142           && !current_interpreter->procs->suspend_proc (current_interpreter->
 143                                                         data))
 144         {
 145           error (_("Could not suspend interpreter \"%s\"."),
 146                  current_interpreter->name);
 147         }
 148     }
 149   else
 150     {
 151       first_time = 1;
 152     }
 153
 154   current_interpreter = interp;
 155
 156   /* We use interpreter_p for the "set interpreter" variable, so we need
 157      to make sure we have a malloc'ed copy for the set command to free. */
 158   if (interpreter_p != NULL
 159       && strcmp (current_interpreter->name, interpreter_p) != 0)
 160     {
 161       xfree (interpreter_p);
 162
 163       interpreter_p = xstrdup (current_interpreter->name);
 164     }
 165
 166   uiout = interp->interpreter_out;
 167
 168   /* Run the init proc.  If it fails, try to restore the old interp. */
 169
 170   if (!interp->inited)
 171     {
 172       if (interp->procs->init_proc != NULL)
 173         {
 174           interp->data = interp->procs->init_proc ();
 175         }
 176       interp->inited = 1;
 177     }
 178
 179   /* Clear out any installed interpreter hooks/event handlers.  */
 180   clear_interpreter_hooks ();
 181
 182   if (interp->procs->resume_proc != NULL
 183       && (!interp->procs->resume_proc (interp->data)))
 184     {
 185       if (old_interp == NULL || !interp_set (old_interp))
 186         internal_error (__FILE__, __LINE__,
 187                         _("Failed to initialize new interp \"%s\" %s"),
 188                         interp->name, "and could not restore old interp!\n");
 189       return 0;
 190     }
 191
 192   /* Finally, put up the new prompt to show that we are indeed here.
 193      Also, display_gdb_prompt for the console does some readline magic
 194      which is needed for the console interpreter, at least... */
 195
 196   if (!first_time)
 197     {
 198       if (!interp_quiet_p (interp))
 199         {
 200           sprintf (buffer, "Switching to interpreter \"%.24s\".\n",
 201                    interp->name);
 202           ui_out_text (uiout, buffer);
 203         }
 204       display_gdb_prompt (NULL);
 205     }
 206
 207   return 1;
 208 }
 209
 210 /* interp_lookup - Looks up the interpreter for NAME.  If no such
 211    interpreter exists, return NULL, otherwise return a pointer to the
 212    interpreter.  */
 213 struct interp *
 214 interp_lookup (const char *name)
 215 {
 216   struct interp *interp;
 217
 218   if (name == NULL || strlen (name) == 0)
 219     return NULL;
 220
 221   for (interp = interp_list; interp != NULL; interp = interp->next)
 222     {
 223       if (strcmp (interp->name, name) == 0)
 224         return interp;
 225     }
 226
 227   return NULL;
 228 }
 229
 230 /* Returns the current interpreter. */
 231
 232 struct ui_out *
 233 interp_ui_out (struct interp *interp)
 234 {
 235   if (interp != NULL)
 236     return interp->interpreter_out;
 237
 238   return current_interpreter->interpreter_out;
 239 }
 240
 241 /* Returns true if the current interp is the passed in name. */
 242 int
 243 current_interp_named_p (const char *interp_name)
 244 {
 245   if (current_interpreter)
 246     return (strcmp (current_interpreter->name, interp_name) == 0);
 247
 248   return 0;
 249 }
 250
 251 /* This is called in display_gdb_prompt.  If the proc returns a zero
 252    value, display_gdb_prompt will return without displaying the
 253    prompt.  */
 254 int
 255 current_interp_display_prompt_p (void)
 256 {
 257   if (current_interpreter == NULL
 258       || current_interpreter->procs->prompt_proc_p == NULL)
 259     return 0;
 260   else
 261     return current_interpreter->procs->prompt_proc_p (current_interpreter->
 262                                                       data);
 263 }
 264
 265 /* Run the current command interpreter's main loop.  */
 266 void
 267 current_interp_command_loop (void)
 268 {
 269   /* Somewhat messy.  For the moment prop up all the old ways of
 270      selecting the command loop.  `deprecated_command_loop_hook'
 271      should be deprecated.  */
 272   if (deprecated_command_loop_hook != NULL)
 273     deprecated_command_loop_hook ();
 274   else if (current_interpreter != NULL
 275            && current_interpreter->procs->command_loop_proc != NULL)
 276     current_interpreter->procs->command_loop_proc (current_interpreter->data);
 277   else
 278     cli_command_loop ();
 279 }
 280
 281 int
 282 interp_quiet_p (struct interp *interp)
 283 {
 284   if (interp != NULL)
 285     return interp->quiet_p;
 286   else
 287     return current_interpreter->quiet_p;
 288 }
 289
 290 static int
 291 interp_set_quiet (struct interp *interp, int quiet)
 292 {
 293   int old_val = interp->quiet_p;
 294   interp->quiet_p = quiet;
 295   return old_val;
 296 }
 297
 298 /* interp_exec - This executes COMMAND_STR in the current
 299    interpreter. */
 300 int
 301 interp_exec_p (struct interp *interp)
 302 {
 303   return interp->procs->exec_proc != NULL;
 304 }
 305
 306 struct gdb_exception
 307 interp_exec (struct interp *interp, const char *command_str)
 308 {
 309   if (interp->procs->exec_proc != NULL)
 310     {
 311       return interp->procs->exec_proc (interp->data, command_str);
 312     }
 313   return exception_none;
 314 }
 315
 316 /* A convenience routine that nulls out all the common command hooks.
 317    Use it when removing your interpreter in its suspend proc.  */
 318 void
 319 clear_interpreter_hooks (void)
 320 {
 321   deprecated_init_ui_hook = 0;
 322   deprecated_print_frame_info_listing_hook = 0;
 323   /*print_frame_more_info_hook = 0; */
 324   deprecated_query_hook = 0;
 325   deprecated_warning_hook = 0;
 326   deprecated_create_breakpoint_hook = 0;
 327   deprecated_delete_breakpoint_hook = 0;
 328   deprecated_modify_breakpoint_hook = 0;
 329   deprecated_interactive_hook = 0;
 330   deprecated_readline_begin_hook = 0;
 331   deprecated_readline_hook = 0;
 332   deprecated_readline_end_hook = 0;
 333   deprecated_register_changed_hook = 0;
 334   deprecated_memory_changed_hook = 0;
 335   deprecated_context_hook = 0;
 336   deprecated_target_wait_hook = 0;
 337   deprecated_call_command_hook = 0;
 338   deprecated_error_hook = 0;
 339   deprecated_error_begin_hook = 0;
 340   deprecated_command_loop_hook = 0;
 341   clear_gdb_event_hooks ();
 342 }
 343
 344 /* This is a lazy init routine, called the first time the interpreter
 345    module is used.  I put it here just in case, but I haven't thought
 346    of a use for it yet.  I will probably bag it soon, since I don't
 347    think it will be necessary.  */
 348 static void
 349 initialize_interps (void)
 350 {
 351   interpreter_initialized = 1;
 352   /* Don't know if anything needs to be done here... */
 353 }
 354
 355 static void
 356 interpreter_exec_cmd (char *args, int from_tty)
 357 {
 358   struct interp *old_interp, *interp_to_use;
 359   char **prules = NULL;
 360   char **trule = NULL;
 361   unsigned int nrules;
 362   unsigned int i;
 363   int old_quiet, use_quiet;
 364
 365   prules = buildargv (args);
 366   if (prules == NULL)
 367     {
 368       error (_("unable to parse arguments"));
 369     }
 370
 371   nrules = 0;
 372   if (prules != NULL)
 373     {
 374       for (trule = prules; *trule != NULL; trule++)
 375         {
 376           nrules++;
 377         }
 378     }
 379
 380   if (nrules < 2)
 381     error (_("usage: interpreter-exec <interpreter> [ <command> ... ]"));
 382
 383   old_interp = current_interpreter;
 384
 385   interp_to_use = interp_lookup (prules[0]);
 386   if (interp_to_use == NULL)
 387     error (_("Could not find interpreter \"%s\"."), prules[0]);
 388
 389   /* Temporarily set interpreters quiet */
 390   old_quiet = interp_set_quiet (old_interp, 1);
 391   use_quiet = interp_set_quiet (interp_to_use, 1);
 392
 393   if (!interp_set (interp_to_use))
 394     error (_("Could not switch to interpreter \"%s\"."), prules[0]);
 395
 396   for (i = 1; i < nrules; i++)
 397     {
 398       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
 399       if (e.reason < 0)
 400         {
 401           interp_set (old_interp);
 402           interp_set_quiet (interp_to_use, use_quiet);
 403           interp_set_quiet (old_interp, old_quiet);
 404           error (_("error in command: \"%s\"."), prules[i]);
 405         }
 406     }
 407
 408   interp_set (old_interp);
 409   interp_set_quiet (interp_to_use, use_quiet);
 410   interp_set_quiet (old_interp, old_quiet);
 411 }
 412
 413 /* List the possible interpreters which could complete the given text. */
 414 static char **
 415 interpreter_completer (char *text, char *word)
 416 {
 417   int alloced = 0;
 418   int textlen;
 419   int num_matches;
 420   char **matches;
 421   struct interp *interp;
 422
 423   /* We expect only a very limited number of interpreters, so just
 424      allocate room for all of them plus one for the last that must be NULL
 425      to correctly end the list. */
 426   for (interp = interp_list; interp != NULL; interp = interp->next)
 427     ++alloced;
 428   matches = (char **) xcalloc (alloced + 1, sizeof (char *));
 429
 430   num_matches = 0;
 431   textlen = strlen (text);
 432   for (interp = interp_list; interp != NULL; interp = interp->next)
 433     {
 434       if (strncmp (interp->name, text, textlen) == 0)
 435         {
 436           matches[num_matches] =
 437             (char *) xmalloc (strlen (word) + strlen (interp->name) + 1);
 438           if (word == text)
 439             strcpy (matches[num_matches], interp->name);
 440           else if (word > text)
 441             {
 442               /* Return some portion of interp->name */
 443               strcpy (matches[num_matches], interp->name + (word - text));
 444             }
 445           else
 446             {
 447               /* Return some of text plus interp->name */
 448               strncpy (matches[num_matches], word, text - word);
 449               matches[num_matches][text - word] = '\0';
 450               strcat (matches[num_matches], interp->name);
 451             }
 452           ++num_matches;
 453         }
 454     }
 455
 456   if (num_matches == 0)
 457     {
 458       xfree (matches);
 459       matches = NULL;
 460     }
 461
 462   return matches;
 463 }
 464
 465 /* This just adds the "interpreter-exec" command.  */
 466 void
 467 _initialize_interpreter (void)
 468 {
 469   struct cmd_list_element *c;
 470
 471   c = add_cmd ("interpreter-exec", class_support,
 472                interpreter_exec_cmd, _("\
 473 Execute a command in an interpreter.  It takes two arguments:\n\
 474 The first argument is the name of the interpreter to use.\n\
 475 The second argument is the command to execute.\n"), &cmdlist);
 476   set_cmd_completer (c, interpreter_completer);
 477 }