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