1 /* Top level stuff for GDB, the GNU debugger. 2 3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 5 2008, 2009, 2010 Free Software Foundation, 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 #include "defs.h" 23 #include "gdbcmd.h" 24 #include "call-cmds.h" 25 #include "cli/cli-cmds.h" 26 #include "cli/cli-script.h" 27 #include "cli/cli-setshow.h" 28 #include "cli/cli-decode.h" 29 #include "symtab.h" 30 #include "inferior.h" 31 #include "exceptions.h" 32 #include <signal.h> 33 #include "target.h" 34 #include "breakpoint.h" 35 #include "gdbtypes.h" 36 #include "expression.h" 37 #include "value.h" 38 #include "language.h" 39 #include "terminal.h" /* For job_control. */ 40 #include "annotate.h" 41 #include "completer.h" 42 #include "top.h" 43 #include "version.h" 44 #include "serial.h" 45 #include "doublest.h" 46 #include "gdb_assert.h" 47 #include "main.h" 48 #include "event-loop.h" 49 #include "gdbthread.h" 50 51 /* readline include files */ 52 #include "readline/readline.h" 53 #include "readline/history.h" 54 55 /* readline defines this. */ 56 #undef savestring 57 58 #include <sys/types.h> 59 60 #include "event-top.h" 61 #include "gdb_string.h" 62 #include "gdb_stat.h" 63 #include <ctype.h> 64 #include "ui-out.h" 65 #include "cli-out.h" 66 67 /* Default command line prompt. This is overriden in some configs. */ 68 69 #ifndef DEFAULT_PROMPT 70 #define DEFAULT_PROMPT "(gdb) " 71 #endif 72 73 /* Initialization file name for gdb. This is overridden in some configs. */ 74 75 #ifndef PATH_MAX 76 # ifdef FILENAME_MAX 77 # define PATH_MAX FILENAME_MAX 78 # else 79 # define PATH_MAX 512 80 # endif 81 #endif 82 83 #ifndef GDBINIT_FILENAME 84 #define GDBINIT_FILENAME ".gdbinit" 85 #endif 86 char gdbinit[PATH_MAX + 1] = GDBINIT_FILENAME; 87 88 int inhibit_gdbinit = 0; 89 90 /* If nonzero, and GDB has been configured to be able to use windows, 91 attempt to open them upon startup. */ 92 93 int use_windows = 0; 94 95 extern char lang_frame_mismatch_warn[]; /* language.c */ 96 97 /* Flag for whether we want all the "from_tty" gubbish printed. */ 98 99 int caution = 1; /* Default is yes, sigh. */ 100 static void 101 show_caution (struct ui_file *file, int from_tty, 102 struct cmd_list_element *c, const char *value) 103 { 104 fprintf_filtered (file, _("\ 105 Whether to confirm potentially dangerous operations is %s.\n"), 106 value); 107 } 108 109 /* stdio stream that command input is being read from. Set to stdin normally. 110 Set by source_command to the file we are sourcing. Set to NULL if we are 111 executing a user-defined command or interacting via a GUI. */ 112 113 FILE *instream; 114 115 /* Flag to indicate whether a user defined command is currently running. */ 116 117 int in_user_command; 118 119 /* Current working directory. */ 120 121 char *current_directory; 122 123 /* The directory name is actually stored here (usually). */ 124 char gdb_dirbuf[1024]; 125 126 /* Function to call before reading a command, if nonzero. 127 The function receives two args: an input stream, 128 and a prompt string. */ 129 130 void (*window_hook) (FILE *, char *); 131 132 int epoch_interface; 133 int xgdb_verbose; 134 135 /* Buffer used for reading command lines, and the size 136 allocated for it so far. */ 137 138 char *line; 139 int linesize = 100; 140 141 /* Nonzero if the current command is modified by "server ". This 142 affects things like recording into the command history, commands 143 repeating on RETURN, etc. This is so a user interface (emacs, GUI, 144 whatever) can issue its own commands and also send along commands 145 from the user, and have the user not notice that the user interface 146 is issuing commands too. */ 147 int server_command; 148 149 /* Baud rate specified for talking to serial target systems. Default 150 is left as -1, so targets can choose their own defaults. */ 151 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1 152 or (unsigned int)-1. This is a Bad User Interface. */ 153 154 int baud_rate = -1; 155 156 /* Timeout limit for response from target. */ 157 158 /* The default value has been changed many times over the years. It 159 was originally 5 seconds. But that was thought to be a long time 160 to sit and wait, so it was changed to 2 seconds. That was thought 161 to be plenty unless the connection was going through some terminal 162 server or multiplexer or other form of hairy serial connection. 163 164 In mid-1996, remote_timeout was moved from remote.c to top.c and 165 it began being used in other remote-* targets. It appears that the 166 default was changed to 20 seconds at that time, perhaps because the 167 Renesas E7000 ICE didn't always respond in a timely manner. 168 169 But if 5 seconds is a long time to sit and wait for retransmissions, 170 20 seconds is far worse. This demonstrates the difficulty of using 171 a single variable for all protocol timeouts. 172 173 As remote.c is used much more than remote-e7000.c, it was changed 174 back to 2 seconds in 1999. */ 175 176 int remote_timeout = 2; 177 178 /* Non-zero tells remote* modules to output debugging info. */ 179 180 int remote_debug = 0; 181 182 /* Sbrk location on entry to main. Used for statistics only. */ 183 #ifdef HAVE_SBRK 184 char *lim_at_start; 185 #endif 186 187 /* Hooks for alternate command interfaces. */ 188 189 /* Called after most modules have been initialized, but before taking users 190 command file. 191 192 If the UI fails to initialize and it wants GDB to continue 193 using the default UI, then it should clear this hook before returning. */ 194 195 void (*deprecated_init_ui_hook) (char *argv0); 196 197 /* This hook is called from within gdb's many mini-event loops which could 198 steal control from a real user interface's event loop. It returns 199 non-zero if the user is requesting a detach, zero otherwise. */ 200 201 int (*deprecated_ui_loop_hook) (int); 202 203 /* Called instead of command_loop at top level. Can be invoked via 204 throw_exception(). */ 205 206 void (*deprecated_command_loop_hook) (void); 207 208 209 /* Called from print_frame_info to list the line we stopped in. */ 210 211 void (*deprecated_print_frame_info_listing_hook) (struct symtab * s, int line, 212 int stopline, int noerror); 213 /* Replaces most of query. */ 214 215 int (*deprecated_query_hook) (const char *, va_list); 216 217 /* Replaces most of warning. */ 218 219 void (*deprecated_warning_hook) (const char *, va_list); 220 221 /* These three functions support getting lines of text from the user. 222 They are used in sequence. First deprecated_readline_begin_hook is 223 called with a text string that might be (for example) a message for 224 the user to type in a sequence of commands to be executed at a 225 breakpoint. If this function calls back to a GUI, it might take 226 this opportunity to pop up a text interaction window with this 227 message. Next, deprecated_readline_hook is called with a prompt 228 that is emitted prior to collecting the user input. It can be 229 called multiple times. Finally, deprecated_readline_end_hook is 230 called to notify the GUI that we are done with the interaction 231 window and it can close it. */ 232 233 void (*deprecated_readline_begin_hook) (char *, ...); 234 char *(*deprecated_readline_hook) (char *); 235 void (*deprecated_readline_end_hook) (void); 236 237 /* Called as appropriate to notify the interface that we have attached 238 to or detached from an already running process. */ 239 240 void (*deprecated_attach_hook) (void); 241 void (*deprecated_detach_hook) (void); 242 243 /* Called during long calculations to allow GUI to repair window damage, and to 244 check for stop buttons, etc... */ 245 246 void (*deprecated_interactive_hook) (void); 247 248 /* Tell the GUI someone changed the register REGNO. -1 means 249 that the caller does not know which register changed or 250 that several registers have changed (see value_assign). */ 251 void (*deprecated_register_changed_hook) (int regno); 252 253 /* Called when going to wait for the target. Usually allows the GUI to run 254 while waiting for target events. */ 255 256 ptid_t (*deprecated_target_wait_hook) (ptid_t ptid, 257 struct target_waitstatus *status, 258 int options); 259 260 /* Used by UI as a wrapper around command execution. May do various things 261 like enabling/disabling buttons, etc... */ 262 263 void (*deprecated_call_command_hook) (struct cmd_list_element * c, char *cmd, 264 int from_tty); 265 266 /* Called after a `set' command has finished. Is only run if the 267 `set' command succeeded. */ 268 269 void (*deprecated_set_hook) (struct cmd_list_element * c); 270 271 /* Called when the current thread changes. Argument is thread id. */ 272 273 void (*deprecated_context_hook) (int id); 274 275 /* Handler for SIGHUP. */ 276 277 #ifdef SIGHUP 278 /* NOTE 1999-04-29: This function will be static again, once we modify 279 gdb to use the event loop as the default command loop and we merge 280 event-top.c into this file, top.c */ 281 /* static */ int 282 quit_cover (void *s) 283 { 284 caution = 0; /* Throw caution to the wind -- we're exiting. 285 This prevents asking the user dumb questions. */ 286 quit_command ((char *) 0, 0); 287 return 0; 288 } 289 #endif /* defined SIGHUP */ 290 291 /* Line number we are currently in in a file which is being sourced. */ 292 /* NOTE 1999-04-29: This variable will be static again, once we modify 293 gdb to use the event loop as the default command loop and we merge 294 event-top.c into this file, top.c */ 295 /* static */ int source_line_number; 296 297 /* Name of the file we are sourcing. */ 298 /* NOTE 1999-04-29: This variable will be static again, once we modify 299 gdb to use the event loop as the default command loop and we merge 300 event-top.c into this file, top.c */ 301 /* static */ const char *source_file_name; 302 303 /* Clean up on error during a "source" command (or execution of a 304 user-defined command). */ 305 306 void 307 do_restore_instream_cleanup (void *stream) 308 { 309 /* Restore the previous input stream. */ 310 instream = stream; 311 } 312 313 /* Read commands from STREAM. */ 314 void 315 read_command_file (FILE *stream) 316 { 317 struct cleanup *cleanups; 318 319 cleanups = make_cleanup (do_restore_instream_cleanup, instream); 320 instream = stream; 321 command_loop (); 322 do_cleanups (cleanups); 323 } 324 325 void (*pre_init_ui_hook) (void); 326 327 #ifdef __MSDOS__ 328 void 329 do_chdir_cleanup (void *old_dir) 330 { 331 chdir (old_dir); 332 xfree (old_dir); 333 } 334 #endif 335 336 void 337 prepare_execute_command (void) 338 { 339 free_all_values (); 340 341 /* With multiple threads running while the one we're examining is stopped, 342 the dcache can get stale without us being able to detect it. 343 For the duration of the command, though, use the dcache to help 344 things like backtrace. */ 345 if (non_stop) 346 target_dcache_invalidate (); 347 } 348 349 /* Execute the line P as a command, in the current user context. 350 Pass FROM_TTY as second argument to the defining function. */ 351 352 void 353 execute_command (char *p, int from_tty) 354 { 355 struct cmd_list_element *c; 356 enum language flang; 357 static int warned = 0; 358 char *line; 359 360 prepare_execute_command (); 361 362 /* Force cleanup of any alloca areas if using C alloca instead of 363 a builtin alloca. */ 364 alloca (0); 365 366 /* This can happen when command_line_input hits end of file. */ 367 if (p == NULL) 368 return; 369 370 target_log_command (p); 371 372 while (*p == ' ' || *p == '\t') 373 p++; 374 if (*p) 375 { 376 char *arg; 377 line = p; 378 379 /* If trace-commands is set then this will print this command. */ 380 print_command_trace (p); 381 382 c = lookup_cmd (&p, cmdlist, "", 0, 1); 383 384 /* Pass null arg rather than an empty one. */ 385 arg = *p ? p : 0; 386 387 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy 388 while the is_complete_command(cfunc) test is just plain 389 bogus. They should both be replaced by a test of the form 390 c->strip_trailing_white_space_p. */ 391 /* NOTE: cagney/2002-02-02: The function.cfunc in the below 392 can't be replaced with func. This is because it is the 393 cfunc, and not the func, that has the value that the 394 is_complete_command hack is testing for. */ 395 /* Clear off trailing whitespace, except for set and complete 396 command. */ 397 if (arg 398 && c->type != set_cmd 399 && !is_complete_command (c)) 400 { 401 p = arg + strlen (arg) - 1; 402 while (p >= arg && (*p == ' ' || *p == '\t')) 403 p--; 404 *(p + 1) = '\0'; 405 } 406 407 /* If this command has been pre-hooked, run the hook first. */ 408 execute_cmd_pre_hook (c); 409 410 if (c->flags & DEPRECATED_WARN_USER) 411 deprecated_cmd_warning (&line); 412 413 if (c->class == class_user) 414 execute_user_command (c, arg); 415 else if (c->type == set_cmd || c->type == show_cmd) 416 do_setshow_command (arg, from_tty & caution, c); 417 else if (!cmd_func_p (c)) 418 error (_("That is not a command, just a help topic.")); 419 else if (deprecated_call_command_hook) 420 deprecated_call_command_hook (c, arg, from_tty & caution); 421 else 422 cmd_func (c, arg, from_tty & caution); 423 424 /* If this command has been post-hooked, run the hook last. */ 425 execute_cmd_post_hook (c); 426 427 } 428 429 /* Tell the user if the language has changed (except first time). 430 First make sure that a new frame has been selected, in case this 431 command or the hooks changed the program state. */ 432 deprecated_safe_get_selected_frame (); 433 if (current_language != expected_language) 434 { 435 if (language_mode == language_mode_auto && info_verbose) 436 { 437 language_info (1); /* Print what changed. */ 438 } 439 warned = 0; 440 } 441 442 /* Warn the user if the working language does not match the 443 language of the current frame. Only warn the user if we are 444 actually running the program, i.e. there is a stack. */ 445 /* FIXME: This should be cacheing the frame and only running when 446 the frame changes. */ 447 448 if (has_stack_frames ()) 449 { 450 flang = get_frame_language (); 451 if (!warned 452 && flang != language_unknown 453 && flang != current_language->la_language) 454 { 455 printf_filtered ("%s\n", lang_frame_mismatch_warn); 456 warned = 1; 457 } 458 } 459 } 460 461 /* Run execute_command for P and FROM_TTY. Capture its output into the 462 returned string, do not display it to the screen. BATCH_FLAG will be 463 temporarily set to true. */ 464 465 char * 466 execute_command_to_string (char *p, int from_tty) 467 { 468 struct ui_file *str_file; 469 struct cleanup *cleanup; 470 char *retval; 471 472 /* GDB_STDOUT should be better already restored during these 473 restoration callbacks. */ 474 cleanup = set_batch_flag_and_make_cleanup_restore_page_info (); 475 476 str_file = mem_fileopen (); 477 478 make_cleanup_restore_ui_file (&gdb_stdout); 479 make_cleanup_restore_ui_file (&gdb_stderr); 480 make_cleanup_ui_file_delete (str_file); 481 482 gdb_stdout = str_file; 483 gdb_stderr = str_file; 484 485 execute_command (p, from_tty); 486 487 retval = ui_file_xstrdup (str_file, NULL); 488 489 do_cleanups (cleanup); 490 491 return retval; 492 } 493 494 /* Read commands from `instream' and execute them 495 until end of file or error reading instream. */ 496 497 void 498 command_loop (void) 499 { 500 struct cleanup *old_chain; 501 char *command; 502 int stdin_is_tty = ISATTY (stdin); 503 504 while (instream && !feof (instream)) 505 { 506 if (window_hook && instream == stdin) 507 (*window_hook) (instream, get_prompt ()); 508 509 quit_flag = 0; 510 if (instream == stdin && stdin_is_tty) 511 reinitialize_more_filter (); 512 old_chain = make_cleanup (null_cleanup, 0); 513 514 /* Get a command-line. This calls the readline package. */ 515 command = command_line_input (instream == stdin ? 516 get_prompt () : (char *) NULL, 517 instream == stdin, "prompt"); 518 if (command == 0) 519 return; 520 521 make_command_stats_cleanup (1); 522 523 execute_command (command, instream == stdin); 524 525 /* Do any commands attached to breakpoint we are stopped at. */ 526 bpstat_do_actions (); 527 528 do_cleanups (old_chain); 529 } 530 } 531 532 /* Commands call this if they do not want to be repeated by null lines. */ 533 534 void 535 dont_repeat (void) 536 { 537 if (server_command) 538 return; 539 540 /* If we aren't reading from standard input, we are saving the last 541 thing read from stdin in line and don't want to delete it. Null lines 542 won't repeat here in any case. */ 543 if (instream == stdin) 544 *line = 0; 545 } 546 547 /* Read a line from the stream "instream" without command line editing. 548 549 It prints PROMPT_ARG once at the start. 550 Action is compatible with "readline", e.g. space for the result is 551 malloc'd and should be freed by the caller. 552 553 A NULL return means end of file. */ 554 char * 555 gdb_readline (char *prompt_arg) 556 { 557 int c; 558 char *result; 559 int input_index = 0; 560 int result_size = 80; 561 562 if (prompt_arg) 563 { 564 /* Don't use a _filtered function here. It causes the assumed 565 character position to be off, since the newline we read from 566 the user is not accounted for. */ 567 fputs_unfiltered (prompt_arg, gdb_stdout); 568 gdb_flush (gdb_stdout); 569 } 570 571 result = (char *) xmalloc (result_size); 572 573 while (1) 574 { 575 /* Read from stdin if we are executing a user defined command. 576 This is the right thing for prompt_for_continue, at least. */ 577 c = fgetc (instream ? instream : stdin); 578 579 if (c == EOF) 580 { 581 if (input_index > 0) 582 /* The last line does not end with a newline. Return it, and 583 if we are called again fgetc will still return EOF and 584 we'll return NULL then. */ 585 break; 586 xfree (result); 587 return NULL; 588 } 589 590 if (c == '\n') 591 { 592 if (input_index > 0 && result[input_index - 1] == '\r') 593 input_index--; 594 break; 595 } 596 597 result[input_index++] = c; 598 while (input_index >= result_size) 599 { 600 result_size *= 2; 601 result = (char *) xrealloc (result, result_size); 602 } 603 } 604 605 result[input_index++] = '\0'; 606 return result; 607 } 608 609 /* Variables which control command line editing and history 610 substitution. These variables are given default values at the end 611 of this file. */ 612 static int command_editing_p; 613 614 /* NOTE 1999-04-29: This variable will be static again, once we modify 615 gdb to use the event loop as the default command loop and we merge 616 event-top.c into this file, top.c */ 617 618 /* static */ int history_expansion_p; 619 620 static int write_history_p; 621 static void 622 show_write_history_p (struct ui_file *file, int from_tty, 623 struct cmd_list_element *c, const char *value) 624 { 625 fprintf_filtered (file, _("Saving of the history record on exit is %s.\n"), 626 value); 627 } 628 629 static int history_size; 630 static void 631 show_history_size (struct ui_file *file, int from_tty, 632 struct cmd_list_element *c, const char *value) 633 { 634 fprintf_filtered (file, _("The size of the command history is %s.\n"), 635 value); 636 } 637 638 static char *history_filename; 639 static void 640 show_history_filename (struct ui_file *file, int from_tty, 641 struct cmd_list_element *c, const char *value) 642 { 643 fprintf_filtered (file, _("\ 644 The filename in which to record the command history is \"%s\".\n"), 645 value); 646 } 647 648 /* This is like readline(), but it has some gdb-specific behavior. 649 gdb may want readline in both the synchronous and async modes during 650 a single gdb invocation. At the ordinary top-level prompt we might 651 be using the async readline. That means we can't use 652 rl_pre_input_hook, since it doesn't work properly in async mode. 653 However, for a secondary prompt (" >", such as occurs during a 654 `define'), gdb wants a synchronous response. 655 656 We used to call readline() directly, running it in synchronous 657 mode. But mixing modes this way is not supported, and as of 658 readline 5.x it no longer works; the arrow keys come unbound during 659 the synchronous call. So we make a nested call into the event 660 loop. That's what gdb_readline_wrapper is for. */ 661 662 /* A flag set as soon as gdb_readline_wrapper_line is called; we can't 663 rely on gdb_readline_wrapper_result, which might still be NULL if 664 the user types Control-D for EOF. */ 665 static int gdb_readline_wrapper_done; 666 667 /* The result of the current call to gdb_readline_wrapper, once a newline 668 is seen. */ 669 static char *gdb_readline_wrapper_result; 670 671 /* Any intercepted hook. Operate-and-get-next sets this, expecting it 672 to be called after the newline is processed (which will redisplay 673 the prompt). But in gdb_readline_wrapper we will not get a new 674 prompt until the next call, or until we return to the event loop. 675 So we disable this hook around the newline and restore it before we 676 return. */ 677 static void (*saved_after_char_processing_hook) (void); 678 679 /* This function is called when readline has seen a complete line of 680 text. */ 681 682 static void 683 gdb_readline_wrapper_line (char *line) 684 { 685 gdb_assert (!gdb_readline_wrapper_done); 686 gdb_readline_wrapper_result = line; 687 gdb_readline_wrapper_done = 1; 688 689 /* Prevent operate-and-get-next from acting too early. */ 690 saved_after_char_processing_hook = after_char_processing_hook; 691 after_char_processing_hook = NULL; 692 693 /* Prevent parts of the prompt from being redisplayed if annotations 694 are enabled, and readline's state getting out of sync. */ 695 if (async_command_editing_p) 696 rl_callback_handler_remove (); 697 } 698 699 struct gdb_readline_wrapper_cleanup 700 { 701 void (*handler_orig) (char *); 702 int already_prompted_orig; 703 }; 704 705 static void 706 gdb_readline_wrapper_cleanup (void *arg) 707 { 708 struct gdb_readline_wrapper_cleanup *cleanup = arg; 709 710 rl_already_prompted = cleanup->already_prompted_orig; 711 712 gdb_assert (input_handler == gdb_readline_wrapper_line); 713 input_handler = cleanup->handler_orig; 714 gdb_readline_wrapper_result = NULL; 715 gdb_readline_wrapper_done = 0; 716 717 after_char_processing_hook = saved_after_char_processing_hook; 718 saved_after_char_processing_hook = NULL; 719 720 xfree (cleanup); 721 } 722 723 char * 724 gdb_readline_wrapper (char *prompt) 725 { 726 struct cleanup *back_to; 727 struct gdb_readline_wrapper_cleanup *cleanup; 728 char *retval; 729 730 cleanup = xmalloc (sizeof (*cleanup)); 731 cleanup->handler_orig = input_handler; 732 input_handler = gdb_readline_wrapper_line; 733 734 cleanup->already_prompted_orig = rl_already_prompted; 735 736 back_to = make_cleanup (gdb_readline_wrapper_cleanup, cleanup); 737 738 /* Display our prompt and prevent double prompt display. */ 739 display_gdb_prompt (prompt); 740 rl_already_prompted = 1; 741 742 if (after_char_processing_hook) 743 (*after_char_processing_hook) (); 744 gdb_assert (after_char_processing_hook == NULL); 745 746 /* gdb_do_one_event argument is unused. */ 747 while (gdb_do_one_event (NULL) >= 0) 748 if (gdb_readline_wrapper_done) 749 break; 750 751 retval = gdb_readline_wrapper_result; 752 do_cleanups (back_to); 753 return retval; 754 } 755 756 757 /* The current saved history number from operate-and-get-next. 758 This is -1 if not valid. */ 759 static int operate_saved_history = -1; 760 761 /* This is put on the appropriate hook and helps operate-and-get-next 762 do its work. */ 763 static void 764 gdb_rl_operate_and_get_next_completion (void) 765 { 766 int delta = where_history () - operate_saved_history; 767 768 /* The `key' argument to rl_get_previous_history is ignored. */ 769 rl_get_previous_history (delta, 0); 770 operate_saved_history = -1; 771 772 /* readline doesn't automatically update the display for us. */ 773 rl_redisplay (); 774 775 after_char_processing_hook = NULL; 776 rl_pre_input_hook = NULL; 777 } 778 779 /* This is a gdb-local readline command handler. It accepts the 780 current command line (like RET does) and, if this command was taken 781 from the history, arranges for the next command in the history to 782 appear on the command line when the prompt returns. 783 We ignore the arguments. */ 784 static int 785 gdb_rl_operate_and_get_next (int count, int key) 786 { 787 int where; 788 789 /* Use the async hook. */ 790 after_char_processing_hook = gdb_rl_operate_and_get_next_completion; 791 792 /* Find the current line, and find the next line to use. */ 793 where = where_history(); 794 795 /* FIXME: kettenis/20020817: max_input_history is renamed into 796 history_max_entries in readline-4.2. When we do a new readline 797 import, we should probably change it here too, even though 798 readline maintains backwards compatibility for now by still 799 defining max_input_history. */ 800 if ((history_is_stifled () && (history_length >= max_input_history)) || 801 (where >= history_length - 1)) 802 operate_saved_history = where; 803 else 804 operate_saved_history = where + 1; 805 806 return rl_newline (1, key); 807 } 808 809 /* Read one line from the command input stream `instream' 810 into the local static buffer `linebuffer' (whose current length 811 is `linelength'). 812 The buffer is made bigger as necessary. 813 Returns the address of the start of the line. 814 815 NULL is returned for end of file. 816 817 *If* the instream == stdin & stdin is a terminal, the line read 818 is copied into the file line saver (global var char *line, 819 length linesize) so that it can be duplicated. 820 821 This routine either uses fancy command line editing or 822 simple input as the user has requested. */ 823 824 char * 825 command_line_input (char *prompt_arg, int repeat, char *annotation_suffix) 826 { 827 static char *linebuffer = 0; 828 static unsigned linelength = 0; 829 char *p; 830 char *p1; 831 char *rl; 832 char *local_prompt = prompt_arg; 833 char *nline; 834 char got_eof = 0; 835 836 /* The annotation suffix must be non-NULL. */ 837 if (annotation_suffix == NULL) 838 annotation_suffix = ""; 839 840 if (annotation_level > 1 && instream == stdin) 841 { 842 local_prompt = alloca ((prompt_arg == NULL ? 0 : strlen (prompt_arg)) 843 + strlen (annotation_suffix) + 40); 844 if (prompt_arg == NULL) 845 local_prompt[0] = '\0'; 846 else 847 strcpy (local_prompt, prompt_arg); 848 strcat (local_prompt, "\n\032\032"); 849 strcat (local_prompt, annotation_suffix); 850 strcat (local_prompt, "\n"); 851 } 852 853 if (linebuffer == 0) 854 { 855 linelength = 80; 856 linebuffer = (char *) xmalloc (linelength); 857 } 858 859 p = linebuffer; 860 861 /* Control-C quits instantly if typed while in this loop 862 since it should not wait until the user types a newline. */ 863 immediate_quit++; 864 #ifdef STOP_SIGNAL 865 if (job_control) 866 signal (STOP_SIGNAL, handle_stop_sig); 867 #endif 868 869 while (1) 870 { 871 /* Make sure that all output has been output. Some machines may let 872 you get away with leaving out some of the gdb_flush, but not all. */ 873 wrap_here (""); 874 gdb_flush (gdb_stdout); 875 gdb_flush (gdb_stderr); 876 877 if (source_file_name != NULL) 878 ++source_line_number; 879 880 if (annotation_level > 1 && instream == stdin) 881 { 882 puts_unfiltered ("\n\032\032pre-"); 883 puts_unfiltered (annotation_suffix); 884 puts_unfiltered ("\n"); 885 } 886 887 /* Don't use fancy stuff if not talking to stdin. */ 888 if (deprecated_readline_hook && input_from_terminal_p ()) 889 { 890 rl = (*deprecated_readline_hook) (local_prompt); 891 } 892 else if (command_editing_p && input_from_terminal_p ()) 893 { 894 rl = gdb_readline_wrapper (local_prompt); 895 } 896 else 897 { 898 rl = gdb_readline (local_prompt); 899 } 900 901 if (annotation_level > 1 && instream == stdin) 902 { 903 puts_unfiltered ("\n\032\032post-"); 904 puts_unfiltered (annotation_suffix); 905 puts_unfiltered ("\n"); 906 } 907 908 if (!rl || rl == (char *) EOF) 909 { 910 got_eof = 1; 911 break; 912 } 913 if (strlen (rl) + 1 + (p - linebuffer) > linelength) 914 { 915 linelength = strlen (rl) + 1 + (p - linebuffer); 916 nline = (char *) xrealloc (linebuffer, linelength); 917 p += nline - linebuffer; 918 linebuffer = nline; 919 } 920 p1 = rl; 921 /* Copy line. Don't copy null at end. (Leaves line alone 922 if this was just a newline) */ 923 while (*p1) 924 *p++ = *p1++; 925 926 xfree (rl); /* Allocated in readline. */ 927 928 if (p == linebuffer || *(p - 1) != '\\') 929 break; 930 931 p--; /* Put on top of '\'. */ 932 local_prompt = (char *) 0; 933 } 934 935 #ifdef STOP_SIGNAL 936 if (job_control) 937 signal (STOP_SIGNAL, SIG_DFL); 938 #endif 939 immediate_quit--; 940 941 if (got_eof) 942 return NULL; 943 944 #define SERVER_COMMAND_LENGTH 7 945 server_command = 946 (p - linebuffer > SERVER_COMMAND_LENGTH) 947 && strncmp (linebuffer, "server ", SERVER_COMMAND_LENGTH) == 0; 948 if (server_command) 949 { 950 /* Note that we don't set `line'. Between this and the check in 951 dont_repeat, this insures that repeating will still do the 952 right thing. */ 953 *p = '\0'; 954 return linebuffer + SERVER_COMMAND_LENGTH; 955 } 956 957 /* Do history expansion if that is wished. */ 958 if (history_expansion_p && instream == stdin 959 && ISATTY (instream)) 960 { 961 char *history_value; 962 int expanded; 963 964 *p = '\0'; /* Insert null now. */ 965 expanded = history_expand (linebuffer, &history_value); 966 if (expanded) 967 { 968 /* Print the changes. */ 969 printf_unfiltered ("%s\n", history_value); 970 971 /* If there was an error, call this function again. */ 972 if (expanded < 0) 973 { 974 xfree (history_value); 975 return command_line_input (prompt_arg, repeat, annotation_suffix); 976 } 977 if (strlen (history_value) > linelength) 978 { 979 linelength = strlen (history_value) + 1; 980 linebuffer = (char *) xrealloc (linebuffer, linelength); 981 } 982 strcpy (linebuffer, history_value); 983 p = linebuffer + strlen (linebuffer); 984 } 985 xfree (history_value); 986 } 987 988 /* If we just got an empty line, and that is supposed 989 to repeat the previous command, return the value in the 990 global buffer. */ 991 if (repeat && p == linebuffer) 992 return line; 993 for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++); 994 if (repeat && !*p1) 995 return line; 996 997 *p = 0; 998 999 /* Add line to history if appropriate. */ 1000 if (instream == stdin 1001 && ISATTY (stdin) && *linebuffer) 1002 add_history (linebuffer); 1003 1004 /* Note: lines consisting solely of comments are added to the command 1005 history. This is useful when you type a command, and then 1006 realize you don't want to execute it quite yet. You can comment 1007 out the command and then later fetch it from the value history 1008 and remove the '#'. The kill ring is probably better, but some 1009 people are in the habit of commenting things out. */ 1010 if (*p1 == '#') 1011 *p1 = '\0'; /* Found a comment. */ 1012 1013 /* Save into global buffer if appropriate. */ 1014 if (repeat) 1015 { 1016 if (linelength > linesize) 1017 { 1018 line = xrealloc (line, linelength); 1019 linesize = linelength; 1020 } 1021 strcpy (line, linebuffer); 1022 return line; 1023 } 1024 1025 return linebuffer; 1026 } 1027 1028 /* Print the GDB banner. */ 1029 void 1030 print_gdb_version (struct ui_file *stream) 1031 { 1032 /* From GNU coding standards, first line is meant to be easy for a 1033 program to parse, and is just canonical program name and version 1034 number, which starts after last space. */ 1035 1036 fprintf_filtered (stream, "GNU gdb %s%s\n", PKGVERSION, version); 1037 1038 /* Second line is a copyright notice. */ 1039 1040 fprintf_filtered (stream, "Copyright (C) 2010 Free Software Foundation, Inc.\n"); 1041 1042 /* Following the copyright is a brief statement that the program is 1043 free software, that users are free to copy and change it on 1044 certain conditions, that it is covered by the GNU GPL, and that 1045 there is no warranty. */ 1046 1047 fprintf_filtered (stream, "\ 1048 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n\ 1049 This is free software: you are free to change and redistribute it.\n\ 1050 There is NO WARRANTY, to the extent permitted by law. Type \"show copying\"\n\ 1051 and \"show warranty\" for details.\n"); 1052 1053 /* After the required info we print the configuration information. */ 1054 1055 fprintf_filtered (stream, "This GDB was configured as \""); 1056 if (strcmp (host_name, target_name) != 0) 1057 { 1058 fprintf_filtered (stream, "--host=%s --target=%s", host_name, target_name); 1059 } 1060 else 1061 { 1062 fprintf_filtered (stream, "%s", host_name); 1063 } 1064 fprintf_filtered (stream, "\"."); 1065 1066 if (REPORT_BUGS_TO[0]) 1067 { 1068 fprintf_filtered (stream, 1069 _("\nFor bug reporting instructions, please see:\n")); 1070 fprintf_filtered (stream, "%s.", REPORT_BUGS_TO); 1071 } 1072 } 1073 1074 /* get_prompt: access method for the GDB prompt string. */ 1075 1076 char * 1077 get_prompt (void) 1078 { 1079 return PROMPT (0); 1080 } 1081 1082 void 1083 set_prompt (char *s) 1084 { 1085 /* ??rehrauer: I don't know why this fails, since it looks as though 1086 assignments to prompt are wrapped in calls to xstrdup... 1087 if (prompt != NULL) 1088 xfree (prompt); 1089 */ 1090 PROMPT (0) = xstrdup (s); 1091 } 1092 1093 1094 struct qt_args 1095 { 1096 char *args; 1097 int from_tty; 1098 }; 1099 1100 /* Callback for iterate_over_inferiors. Kills or detaches the given 1101 inferior, depending on how we originally gained control of it. */ 1102 1103 static int 1104 kill_or_detach (struct inferior *inf, void *args) 1105 { 1106 struct qt_args *qt = args; 1107 struct thread_info *thread; 1108 1109 if (inf->pid == 0) 1110 return 0; 1111 1112 thread = any_thread_of_process (inf->pid); 1113 if (thread != NULL) 1114 { 1115 switch_to_thread (thread->ptid); 1116 1117 /* Leave core files alone. */ 1118 if (target_has_execution) 1119 { 1120 if (inf->attach_flag) 1121 target_detach (qt->args, qt->from_tty); 1122 else 1123 target_kill (); 1124 } 1125 } 1126 1127 return 0; 1128 } 1129 1130 /* Callback for iterate_over_inferiors. Prints info about what GDB 1131 will do to each inferior on a "quit". ARG points to a struct 1132 ui_out where output is to be collected. */ 1133 1134 static int 1135 print_inferior_quit_action (struct inferior *inf, void *arg) 1136 { 1137 struct ui_file *stb = arg; 1138 1139 if (inf->pid == 0) 1140 return 0; 1141 1142 if (inf->attach_flag) 1143 fprintf_filtered (stb, 1144 _("\tInferior %d [%s] will be detached.\n"), inf->num, 1145 target_pid_to_str (pid_to_ptid (inf->pid))); 1146 else 1147 fprintf_filtered (stb, 1148 _("\tInferior %d [%s] will be killed.\n"), inf->num, 1149 target_pid_to_str (pid_to_ptid (inf->pid))); 1150 1151 return 0; 1152 } 1153 1154 /* If necessary, make the user confirm that we should quit. Return 1155 non-zero if we should quit, zero if we shouldn't. */ 1156 1157 int 1158 quit_confirm (void) 1159 { 1160 struct ui_file *stb; 1161 struct cleanup *old_chain; 1162 char *str; 1163 int qr; 1164 1165 /* Don't even ask if we're only debugging a core file inferior. */ 1166 if (!have_live_inferiors ()) 1167 return 1; 1168 1169 /* Build the query string as a single string. */ 1170 stb = mem_fileopen (); 1171 old_chain = make_cleanup_ui_file_delete (stb); 1172 1173 /* This is something of a hack. But there's no reliable way to see 1174 if a GUI is running. The `use_windows' variable doesn't cut 1175 it. */ 1176 if (deprecated_init_ui_hook) 1177 fprintf_filtered (stb, _("A debugging session is active.\n" 1178 "Do you still want to close the debugger?")); 1179 else 1180 { 1181 fprintf_filtered (stb, _("A debugging session is active.\n\n")); 1182 iterate_over_inferiors (print_inferior_quit_action, stb); 1183 fprintf_filtered (stb, _("\nQuit anyway? ")); 1184 } 1185 1186 str = ui_file_xstrdup (stb, NULL); 1187 make_cleanup (xfree, str); 1188 1189 qr = query ("%s", str); 1190 do_cleanups (old_chain); 1191 return qr; 1192 } 1193 1194 /* Helper routine for quit_force that requires error handling. */ 1195 1196 static int 1197 quit_target (void *arg) 1198 { 1199 struct qt_args *qt = (struct qt_args *)arg; 1200 1201 /* Kill or detach all inferiors. */ 1202 iterate_over_inferiors (kill_or_detach, qt); 1203 1204 /* Give all pushed targets a chance to do minimal cleanup, and pop 1205 them all out. */ 1206 pop_all_targets (1); 1207 1208 /* Save the history information if it is appropriate to do so. */ 1209 if (write_history_p && history_filename) 1210 write_history (history_filename); 1211 1212 do_final_cleanups (ALL_CLEANUPS); /* Do any final cleanups before exiting */ 1213 1214 return 0; 1215 } 1216 1217 /* Quit without asking for confirmation. */ 1218 1219 void 1220 quit_force (char *args, int from_tty) 1221 { 1222 int exit_code = 0; 1223 struct qt_args qt; 1224 1225 /* An optional expression may be used to cause gdb to terminate with the 1226 value of that expression. */ 1227 if (args) 1228 { 1229 struct value *val = parse_and_eval (args); 1230 1231 exit_code = (int) value_as_long (val); 1232 } 1233 else if (return_child_result) 1234 exit_code = return_child_result_value; 1235 1236 qt.args = args; 1237 qt.from_tty = from_tty; 1238 1239 /* We want to handle any quit errors and exit regardless. */ 1240 catch_errors (quit_target, &qt, 1241 "Quitting: ", RETURN_MASK_ALL); 1242 1243 exit (exit_code); 1244 } 1245 1246 /* If OFF, the debugger will run in non-interactive mode, which means 1247 that it will automatically select the default answer to all the 1248 queries made to the user. If ON, gdb will wait for the user to 1249 answer all queries. If AUTO, gdb will determine whether to run 1250 in interactive mode or not depending on whether stdin is a terminal 1251 or not. */ 1252 static enum auto_boolean interactive_mode = AUTO_BOOLEAN_AUTO; 1253 1254 /* Implement the "show interactive-mode" option. */ 1255 1256 static void 1257 show_interactive_mode (struct ui_file *file, int from_tty, 1258 struct cmd_list_element *c, 1259 const char *value) 1260 { 1261 if (interactive_mode == AUTO_BOOLEAN_AUTO) 1262 fprintf_filtered (file, "\ 1263 Debugger's interactive mode is %s (currently %s).\n", 1264 value, input_from_terminal_p () ? "on" : "off"); 1265 else 1266 fprintf_filtered (file, "Debugger's interactive mode is %s.\n", value); 1267 } 1268 1269 /* Returns whether GDB is running on a terminal and input is 1270 currently coming from that terminal. */ 1271 1272 int 1273 input_from_terminal_p (void) 1274 { 1275 if (interactive_mode != AUTO_BOOLEAN_AUTO) 1276 return interactive_mode == AUTO_BOOLEAN_TRUE; 1277 1278 if (batch_flag) 1279 return 0; 1280 1281 if (gdb_has_a_terminal () && instream == stdin) 1282 return 1; 1283 1284 /* If INSTREAM is unset, and we are not in a user command, we 1285 must be in Insight. That's like having a terminal, for our 1286 purposes. */ 1287 if (instream == NULL && !in_user_command) 1288 return 1; 1289 1290 return 0; 1291 } 1292 1293 static void 1294 dont_repeat_command (char *ignored, int from_tty) 1295 { 1296 *line = 0; /* Can't call dont_repeat here because we're not 1297 necessarily reading from stdin. */ 1298 } 1299 1300 /* Functions to manipulate command line editing control variables. */ 1301 1302 /* Number of commands to print in each call to show_commands. */ 1303 #define Hist_print 10 1304 void 1305 show_commands (char *args, int from_tty) 1306 { 1307 /* Index for history commands. Relative to history_base. */ 1308 int offset; 1309 1310 /* Number of the history entry which we are planning to display next. 1311 Relative to history_base. */ 1312 static int num = 0; 1313 1314 /* The first command in the history which doesn't exist (i.e. one more 1315 than the number of the last command). Relative to history_base. */ 1316 int hist_len; 1317 1318 /* Print out some of the commands from the command history. */ 1319 /* First determine the length of the history list. */ 1320 hist_len = history_size; 1321 for (offset = 0; offset < history_size; offset++) 1322 { 1323 if (!history_get (history_base + offset)) 1324 { 1325 hist_len = offset; 1326 break; 1327 } 1328 } 1329 1330 if (args) 1331 { 1332 if (args[0] == '+' && args[1] == '\0') 1333 /* "info editing +" should print from the stored position. */ 1334 ; 1335 else 1336 /* "info editing <exp>" should print around command number <exp>. */ 1337 num = (parse_and_eval_long (args) - history_base) - Hist_print / 2; 1338 } 1339 /* "show commands" means print the last Hist_print commands. */ 1340 else 1341 { 1342 num = hist_len - Hist_print; 1343 } 1344 1345 if (num < 0) 1346 num = 0; 1347 1348 /* If there are at least Hist_print commands, we want to display the last 1349 Hist_print rather than, say, the last 6. */ 1350 if (hist_len - num < Hist_print) 1351 { 1352 num = hist_len - Hist_print; 1353 if (num < 0) 1354 num = 0; 1355 } 1356 1357 for (offset = num; offset < num + Hist_print && offset < hist_len; offset++) 1358 { 1359 printf_filtered ("%5d %s\n", history_base + offset, 1360 (history_get (history_base + offset))->line); 1361 } 1362 1363 /* The next command we want to display is the next one that we haven't 1364 displayed yet. */ 1365 num += Hist_print; 1366 1367 /* If the user repeats this command with return, it should do what 1368 "show commands +" does. This is unnecessary if arg is null, 1369 because "show commands +" is not useful after "show commands". */ 1370 if (from_tty && args) 1371 { 1372 args[0] = '+'; 1373 args[1] = '\0'; 1374 } 1375 } 1376 1377 /* Called by do_setshow_command. */ 1378 static void 1379 set_history_size_command (char *args, int from_tty, struct cmd_list_element *c) 1380 { 1381 if (history_size == INT_MAX) 1382 unstifle_history (); 1383 else if (history_size >= 0) 1384 stifle_history (history_size); 1385 else 1386 { 1387 history_size = INT_MAX; 1388 error (_("History size must be non-negative")); 1389 } 1390 } 1391 1392 void 1393 set_history (char *args, int from_tty) 1394 { 1395 printf_unfiltered (_("\"set history\" must be followed by the name of a history subcommand.\n")); 1396 help_list (sethistlist, "set history ", -1, gdb_stdout); 1397 } 1398 1399 void 1400 show_history (char *args, int from_tty) 1401 { 1402 cmd_show_list (showhistlist, from_tty, ""); 1403 } 1404 1405 int info_verbose = 0; /* Default verbose msgs off */ 1406 1407 /* Called by do_setshow_command. An elaborate joke. */ 1408 void 1409 set_verbose (char *args, int from_tty, struct cmd_list_element *c) 1410 { 1411 char *cmdname = "verbose"; 1412 struct cmd_list_element *showcmd; 1413 1414 showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1); 1415 1416 if (info_verbose) 1417 { 1418 c->doc = "Set verbose printing of informational messages."; 1419 showcmd->doc = "Show verbose printing of informational messages."; 1420 } 1421 else 1422 { 1423 c->doc = "Set verbosity."; 1424 showcmd->doc = "Show verbosity."; 1425 } 1426 } 1427 1428 /* Init the history buffer. Note that we are called after the init file(s) 1429 * have been read so that the user can change the history file via his 1430 * .gdbinit file (for instance). The GDBHISTFILE environment variable 1431 * overrides all of this. 1432 */ 1433 1434 void 1435 init_history (void) 1436 { 1437 char *tmpenv; 1438 1439 tmpenv = getenv ("HISTSIZE"); 1440 if (tmpenv) 1441 history_size = atoi (tmpenv); 1442 else if (!history_size) 1443 history_size = 256; 1444 1445 stifle_history (history_size); 1446 1447 tmpenv = getenv ("GDBHISTFILE"); 1448 if (tmpenv) 1449 history_filename = xstrdup (tmpenv); 1450 else if (!history_filename) 1451 { 1452 /* We include the current directory so that if the user changes 1453 directories the file written will be the same as the one 1454 that was read. */ 1455 #ifdef __MSDOS__ 1456 /* No leading dots in file names are allowed on MSDOS. */ 1457 history_filename = concat (current_directory, "/_gdb_history", 1458 (char *)NULL); 1459 #else 1460 history_filename = concat (current_directory, "/.gdb_history", 1461 (char *)NULL); 1462 #endif 1463 } 1464 read_history (history_filename); 1465 } 1466 1467 static void 1468 show_new_async_prompt (struct ui_file *file, int from_tty, 1469 struct cmd_list_element *c, const char *value) 1470 { 1471 fprintf_filtered (file, _("Gdb's prompt is \"%s\".\n"), value); 1472 } 1473 1474 static void 1475 show_async_command_editing_p (struct ui_file *file, int from_tty, 1476 struct cmd_list_element *c, const char *value) 1477 { 1478 fprintf_filtered (file, _("\ 1479 Editing of command lines as they are typed is %s.\n"), 1480 value); 1481 } 1482 1483 static void 1484 show_annotation_level (struct ui_file *file, int from_tty, 1485 struct cmd_list_element *c, const char *value) 1486 { 1487 fprintf_filtered (file, _("Annotation_level is %s.\n"), value); 1488 } 1489 1490 static void 1491 show_exec_done_display_p (struct ui_file *file, int from_tty, 1492 struct cmd_list_element *c, const char *value) 1493 { 1494 fprintf_filtered (file, _("\ 1495 Notification of completion for asynchronous execution commands is %s.\n"), 1496 value); 1497 } 1498 static void 1499 init_main (void) 1500 { 1501 /* initialize the prompt stack to a simple "(gdb) " prompt or to 1502 whatever the DEFAULT_PROMPT is. */ 1503 the_prompts.top = 0; 1504 PREFIX (0) = ""; 1505 PROMPT (0) = xstrdup (DEFAULT_PROMPT); 1506 SUFFIX (0) = ""; 1507 /* Set things up for annotation_level > 1, if the user ever decides 1508 to use it. */ 1509 async_annotation_suffix = "prompt"; 1510 /* Set the variable associated with the setshow prompt command. */ 1511 new_async_prompt = xstrdup (PROMPT (0)); 1512 1513 /* If gdb was started with --annotate=2, this is equivalent to the 1514 user entering the command 'set annotate 2' at the gdb prompt, so 1515 we need to do extra processing. */ 1516 if (annotation_level > 1) 1517 set_async_annotation_level (NULL, 0, NULL); 1518 1519 /* Set the important stuff up for command editing. */ 1520 command_editing_p = 1; 1521 history_expansion_p = 0; 1522 write_history_p = 0; 1523 1524 /* Setup important stuff for command line editing. */ 1525 rl_completion_word_break_hook = gdb_completion_word_break_characters; 1526 rl_completion_entry_function = readline_line_completion_function; 1527 rl_completer_word_break_characters = default_word_break_characters (); 1528 rl_completer_quote_characters = get_gdb_completer_quote_characters (); 1529 rl_readline_name = "gdb"; 1530 rl_terminal_name = getenv ("TERM"); 1531 1532 /* The name for this defun comes from Bash, where it originated. 1533 15 is Control-o, the same binding this function has in Bash. */ 1534 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next, 15); 1535 1536 add_setshow_string_cmd ("prompt", class_support, 1537 &new_async_prompt, _("\ 1538 Set gdb's prompt"), _("\ 1539 Show gdb's prompt"), NULL, 1540 set_async_prompt, 1541 show_new_async_prompt, 1542 &setlist, &showlist); 1543 1544 add_com ("dont-repeat", class_support, dont_repeat_command, _("\ 1545 Don't repeat this command.\n\ 1546 Primarily used inside of user-defined commands that should not be repeated when\n\ 1547 hitting return.")); 1548 1549 add_setshow_boolean_cmd ("editing", class_support, 1550 &async_command_editing_p, _("\ 1551 Set editing of command lines as they are typed."), _("\ 1552 Show editing of command lines as they are typed."), _("\ 1553 Use \"on\" to enable the editing, and \"off\" to disable it.\n\ 1554 Without an argument, command line editing is enabled. To edit, use\n\ 1555 EMACS-like or VI-like commands like control-P or ESC."), 1556 set_async_editing_command, 1557 show_async_command_editing_p, 1558 &setlist, &showlist); 1559 1560 add_setshow_boolean_cmd ("save", no_class, &write_history_p, _("\ 1561 Set saving of the history record on exit."), _("\ 1562 Show saving of the history record on exit."), _("\ 1563 Use \"on\" to enable the saving, and \"off\" to disable it.\n\ 1564 Without an argument, saving is enabled."), 1565 NULL, 1566 show_write_history_p, 1567 &sethistlist, &showhistlist); 1568 1569 add_setshow_integer_cmd ("size", no_class, &history_size, _("\ 1570 Set the size of the command history,"), _("\ 1571 Show the size of the command history,"), _("\ 1572 ie. the number of previous commands to keep a record of."), 1573 set_history_size_command, 1574 show_history_size, 1575 &sethistlist, &showhistlist); 1576 1577 add_setshow_filename_cmd ("filename", no_class, &history_filename, _("\ 1578 Set the filename in which to record the command history"), _("\ 1579 Show the filename in which to record the command history"), _("\ 1580 (the list of previous commands of which a record is kept)."), 1581 NULL, 1582 show_history_filename, 1583 &sethistlist, &showhistlist); 1584 1585 add_setshow_boolean_cmd ("confirm", class_support, &caution, _("\ 1586 Set whether to confirm potentially dangerous operations."), _("\ 1587 Show whether to confirm potentially dangerous operations."), NULL, 1588 NULL, 1589 show_caution, 1590 &setlist, &showlist); 1591 1592 add_setshow_zinteger_cmd ("annotate", class_obscure, &annotation_level, _("\ 1593 Set annotation_level."), _("\ 1594 Show annotation_level."), _("\ 1595 0 == normal; 1 == fullname (for use when running under emacs)\n\ 1596 2 == output annotated suitably for use by programs that control GDB."), 1597 set_async_annotation_level, 1598 show_annotation_level, 1599 &setlist, &showlist); 1600 1601 add_setshow_boolean_cmd ("exec-done-display", class_support, 1602 &exec_done_display_p, _("\ 1603 Set notification of completion for asynchronous execution commands."), _("\ 1604 Show notification of completion for asynchronous execution commands."), _("\ 1605 Use \"on\" to enable the notification, and \"off\" to disable it."), 1606 NULL, 1607 show_exec_done_display_p, 1608 &setlist, &showlist); 1609 1610 add_setshow_auto_boolean_cmd ("interactive-mode", class_support, 1611 &interactive_mode, _("\ 1612 Set whether GDB should run in interactive mode or not"), _("\ 1613 Show whether GDB runs in interactive mode"), _("\ 1614 If on, run in interactive mode and wait for the user to answer\n\ 1615 all queries. If off, run in non-interactive mode and automatically\n\ 1616 assume the default answer to all queries. If auto (the default),\n\ 1617 determine which mode to use based on the standard input settings"), 1618 NULL, 1619 show_interactive_mode, 1620 &setlist, &showlist); 1621 1622 add_setshow_filename_cmd ("data-directory", class_maintenance, 1623 &gdb_datadir, _("Set GDB's data directory."), 1624 _("Show GDB's data directory."), 1625 _("\ 1626 When set, GDB uses the specified path to search for data files."), 1627 NULL, NULL, 1628 &setlist, 1629 &showlist); 1630 } 1631 1632 void 1633 gdb_init (char *argv0) 1634 { 1635 if (pre_init_ui_hook) 1636 pre_init_ui_hook (); 1637 1638 /* Run the init function of each source file */ 1639 1640 #ifdef __MSDOS__ 1641 /* Make sure we return to the original directory upon exit, come 1642 what may, since the OS doesn't do that for us. */ 1643 make_final_cleanup (do_chdir_cleanup, xstrdup (current_directory)); 1644 #endif 1645 1646 init_cmd_lists (); /* This needs to be done first */ 1647 initialize_targets (); /* Setup target_terminal macros for utils.c */ 1648 initialize_utils (); /* Make errors and warnings possible */ 1649 initialize_all_files (); 1650 /* This creates the current_program_space. Do this after all the 1651 _initialize_foo routines have had a chance to install their 1652 per-sspace data keys. Also do this before 1653 initialize_current_architecture is called, because it accesses 1654 exec_bfd of the current program space. */ 1655 initialize_progspace (); 1656 initialize_inferiors (); 1657 initialize_current_architecture (); 1658 init_cli_cmds(); 1659 init_main (); /* But that omits this file! Do it now */ 1660 1661 initialize_stdin_serial (); 1662 1663 async_init_signals (); 1664 1665 /* We need a default language for parsing expressions, so simple things like 1666 "set width 0" won't fail if no language is explicitly set in a config file 1667 or implicitly set by reading an executable during startup. */ 1668 set_language (language_c); 1669 expected_language = current_language; /* don't warn about the change. */ 1670 1671 /* Allow another UI to initialize. If the UI fails to initialize, 1672 and it wants GDB to revert to the CLI, it should clear 1673 deprecated_init_ui_hook. */ 1674 if (deprecated_init_ui_hook) 1675 deprecated_init_ui_hook (argv0); 1676 } 1677