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