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