1 /* Top level stuff for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008 Free Software Foundation, Inc.
7 This file is part of GDB.
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.
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.
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/>. */
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"
31 #include "exceptions.h"
34 #include "breakpoint.h"
36 #include "expression.h"
39 #include "terminal.h" /* For job_control. */
41 #include "completer.h"
46 #include "gdb_assert.h"
48 #include "event-loop.h"
49 #include "gdbthread.h"
51 /* readline include files */
52 #include "readline/readline.h"
53 #include "readline/history.h"
55 /* readline defines this. */
58 #include <sys/types.h>
60 #include "event-top.h"
61 #include "gdb_string.h"
67 /* Default command line prompt. This is overriden in some configs. */
69 #ifndef DEFAULT_PROMPT
70 #define DEFAULT_PROMPT "(gdb) "
73 /* Initialization file name for gdb. This is overridden in some configs. */
77 # define PATH_MAX FILENAME_MAX
83 #ifndef GDBINIT_FILENAME
84 #define GDBINIT_FILENAME ".gdbinit"
86 char gdbinit
[PATH_MAX
+ 1] = GDBINIT_FILENAME
;
88 int inhibit_gdbinit
= 0;
90 /* If nonzero, and GDB has been configured to be able to use windows,
91 attempt to open them upon startup. */
95 extern char lang_frame_mismatch_warn
[]; /* language.c */
97 /* Flag for whether we want all the "from_tty" gubbish printed. */
99 int caution
= 1; /* Default is yes, sigh. */
101 show_caution (struct ui_file
*file
, int from_tty
,
102 struct cmd_list_element
*c
, const char *value
)
104 fprintf_filtered (file
, _("\
105 Whether to confirm potentially dangerous operations is %s.\n"),
109 /* stdio stream that command input is being read from. Set to stdin normally.
110 Set by source_command to the file we are sourcing. Set to NULL if we are
111 executing a user-defined command or interacting via a GUI. */
115 /* Flag to indicate whether a user defined command is currently running. */
119 /* Current working directory. */
121 char *current_directory
;
123 /* The directory name is actually stored here (usually). */
124 char gdb_dirbuf
[1024];
126 /* Function to call before reading a command, if nonzero.
127 The function receives two args: an input stream,
128 and a prompt string. */
130 void (*window_hook
) (FILE *, char *);
135 /* gdb prints this when reading a command interactively */
136 static char *gdb_prompt_string
; /* the global prompt string */
138 /* Buffer used for reading command lines, and the size
139 allocated for it so far. */
144 /* Nonzero if the current command is modified by "server ". This
145 affects things like recording into the command history, commands
146 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
147 whatever) can issue its own commands and also send along commands
148 from the user, and have the user not notice that the user interface
149 is issuing commands too. */
152 /* Baud rate specified for talking to serial target systems. Default
153 is left as -1, so targets can choose their own defaults. */
154 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1
155 or (unsigned int)-1. This is a Bad User Interface. */
159 /* Timeout limit for response from target. */
161 /* The default value has been changed many times over the years. It
162 was originally 5 seconds. But that was thought to be a long time
163 to sit and wait, so it was changed to 2 seconds. That was thought
164 to be plenty unless the connection was going through some terminal
165 server or multiplexer or other form of hairy serial connection.
167 In mid-1996, remote_timeout was moved from remote.c to top.c and
168 it began being used in other remote-* targets. It appears that the
169 default was changed to 20 seconds at that time, perhaps because the
170 Renesas E7000 ICE didn't always respond in a timely manner.
172 But if 5 seconds is a long time to sit and wait for retransmissions,
173 20 seconds is far worse. This demonstrates the difficulty of using
174 a single variable for all protocol timeouts.
176 As remote.c is used much more than remote-e7000.c, it was changed
177 back to 2 seconds in 1999. */
179 int remote_timeout
= 2;
181 /* Non-zero tells remote* modules to output debugging info. */
183 int remote_debug
= 0;
185 /* Sbrk location on entry to main. Used for statistics only. */
190 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
194 #define STOP_SIGNAL SIGTSTP
195 static void stop_sig (int);
199 /* Hooks for alternate command interfaces. */
201 /* Called after most modules have been initialized, but before taking users
204 If the UI fails to initialize and it wants GDB to continue
205 using the default UI, then it should clear this hook before returning. */
207 void (*deprecated_init_ui_hook
) (char *argv0
);
209 /* This hook is called from within gdb's many mini-event loops which could
210 steal control from a real user interface's event loop. It returns
211 non-zero if the user is requesting a detach, zero otherwise. */
213 int (*deprecated_ui_loop_hook
) (int);
215 /* Called instead of command_loop at top level. Can be invoked via
216 throw_exception(). */
218 void (*deprecated_command_loop_hook
) (void);
221 /* Called from print_frame_info to list the line we stopped in. */
223 void (*deprecated_print_frame_info_listing_hook
) (struct symtab
* s
, int line
,
224 int stopline
, int noerror
);
225 /* Replaces most of query. */
227 int (*deprecated_query_hook
) (const char *, va_list);
229 /* Replaces most of warning. */
231 void (*deprecated_warning_hook
) (const char *, va_list);
233 /* These three functions support getting lines of text from the user.
234 They are used in sequence. First deprecated_readline_begin_hook is
235 called with a text string that might be (for example) a message for
236 the user to type in a sequence of commands to be executed at a
237 breakpoint. If this function calls back to a GUI, it might take
238 this opportunity to pop up a text interaction window with this
239 message. Next, deprecated_readline_hook is called with a prompt
240 that is emitted prior to collecting the user input. It can be
241 called multiple times. Finally, deprecated_readline_end_hook is
242 called to notify the GUI that we are done with the interaction
243 window and it can close it. */
245 void (*deprecated_readline_begin_hook
) (char *, ...);
246 char *(*deprecated_readline_hook
) (char *);
247 void (*deprecated_readline_end_hook
) (void);
249 /* Called as appropriate to notify the interface of the specified breakpoint
252 void (*deprecated_create_breakpoint_hook
) (struct breakpoint
* bpt
);
253 void (*deprecated_delete_breakpoint_hook
) (struct breakpoint
* bpt
);
254 void (*deprecated_modify_breakpoint_hook
) (struct breakpoint
* bpt
);
256 /* Called as appropriate to notify the interface that we have attached
257 to or detached from an already running process. */
259 void (*deprecated_attach_hook
) (void);
260 void (*deprecated_detach_hook
) (void);
262 /* Called during long calculations to allow GUI to repair window damage, and to
263 check for stop buttons, etc... */
265 void (*deprecated_interactive_hook
) (void);
267 /* Tell the GUI someone changed the register REGNO. -1 means
268 that the caller does not know which register changed or
269 that several registers have changed (see value_assign). */
270 void (*deprecated_register_changed_hook
) (int regno
);
272 /* Tell the GUI someone changed LEN bytes of memory at ADDR */
273 void (*deprecated_memory_changed_hook
) (CORE_ADDR addr
, int len
);
275 /* Called when going to wait for the target. Usually allows the GUI to run
276 while waiting for target events. */
278 ptid_t (*deprecated_target_wait_hook
) (ptid_t ptid
,
279 struct target_waitstatus
* status
);
281 /* Used by UI as a wrapper around command execution. May do various things
282 like enabling/disabling buttons, etc... */
284 void (*deprecated_call_command_hook
) (struct cmd_list_element
* c
, char *cmd
,
287 /* Called after a `set' command has finished. Is only run if the
288 `set' command succeeded. */
290 void (*deprecated_set_hook
) (struct cmd_list_element
* c
);
292 /* Called when the current thread changes. Argument is thread id. */
294 void (*deprecated_context_hook
) (int id
);
296 /* Takes control from error (). Typically used to prevent longjmps out of the
297 middle of the GUI. Usually used in conjunction with a catch routine. */
299 void (*deprecated_error_hook
) (void);
301 /* Handler for SIGHUP. */
304 /* NOTE 1999-04-29: This function will be static again, once we modify
305 gdb to use the event loop as the default command loop and we merge
306 event-top.c into this file, top.c */
310 caution
= 0; /* Throw caution to the wind -- we're exiting.
311 This prevents asking the user dumb questions. */
312 quit_command ((char *) 0, 0);
315 #endif /* defined SIGHUP */
317 /* Line number we are currently in in a file which is being sourced. */
318 /* NOTE 1999-04-29: This variable will be static again, once we modify
319 gdb to use the event loop as the default command loop and we merge
320 event-top.c into this file, top.c */
321 /* static */ int source_line_number
;
323 /* Name of the file we are sourcing. */
324 /* NOTE 1999-04-29: This variable will be static again, once we modify
325 gdb to use the event loop as the default command loop and we merge
326 event-top.c into this file, top.c */
327 /* static */ char *source_file_name
;
329 /* Clean up on error during a "source" command (or execution of a
330 user-defined command). */
333 do_restore_instream_cleanup (void *stream
)
335 /* Restore the previous input stream. */
339 /* Read commands from STREAM. */
341 read_command_file (FILE *stream
)
343 struct cleanup
*cleanups
;
345 cleanups
= make_cleanup (do_restore_instream_cleanup
, instream
);
348 do_cleanups (cleanups
);
351 void (*pre_init_ui_hook
) (void);
355 do_chdir_cleanup (void *old_dir
)
362 /* Execute the line P as a command.
363 Pass FROM_TTY as second argument to the defining function. */
366 execute_command (char *p
, int from_tty
)
368 struct cmd_list_element
*c
;
370 static int warned
= 0;
372 struct continuation_arg
*arg1
;
373 struct continuation_arg
*arg2
;
374 long time_at_cmd_start
= 0;
376 long space_at_cmd_start
= 0;
378 extern int display_time
;
379 extern int display_space
;
381 if (target_can_async_p ())
383 time_at_cmd_start
= get_run_time ();
388 char *lim
= (char *) sbrk (0);
389 space_at_cmd_start
= lim
- lim_at_start
;
396 /* Force cleanup of any alloca areas if using C alloca instead of
400 /* This can happen when command_line_input hits end of file. */
404 target_log_command (p
);
406 while (*p
== ' ' || *p
== '\t')
413 /* If trace-commands is set then this will print this command. */
414 print_command_trace (p
);
416 c
= lookup_cmd (&p
, cmdlist
, "", 0, 1);
418 /* If the target is running, we allow only a limited set of
420 if (target_can_async_p ()
421 && ((!non_stop
&& any_running ())
422 || (non_stop
&& is_running (inferior_ptid
)))
423 && !get_cmd_async_ok (c
))
424 error (_("Cannot execute this command while the target is running."));
426 /* Pass null arg rather than an empty one. */
429 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
430 while the is_complete_command(cfunc) test is just plain
431 bogus. They should both be replaced by a test of the form
432 c->strip_trailing_white_space_p. */
433 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
434 can't be replaced with func. This is because it is the
435 cfunc, and not the func, that has the value that the
436 is_complete_command hack is testing for. */
437 /* Clear off trailing whitespace, except for set and complete
440 && c
->type
!= set_cmd
441 && !is_complete_command (c
))
443 p
= arg
+ strlen (arg
) - 1;
444 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
449 /* If this command has been pre-hooked, run the hook first. */
450 execute_cmd_pre_hook (c
);
452 if (c
->flags
& DEPRECATED_WARN_USER
)
453 deprecated_cmd_warning (&line
);
455 if (c
->class == class_user
)
456 execute_user_command (c
, arg
);
457 else if (c
->type
== set_cmd
|| c
->type
== show_cmd
)
458 do_setshow_command (arg
, from_tty
& caution
, c
);
459 else if (!cmd_func_p (c
))
460 error (_("That is not a command, just a help topic."));
461 else if (deprecated_call_command_hook
)
462 deprecated_call_command_hook (c
, arg
, from_tty
& caution
);
464 cmd_func (c
, arg
, from_tty
& caution
);
466 /* If this command has been post-hooked, run the hook last. */
467 execute_cmd_post_hook (c
);
471 /* Tell the user if the language has changed (except first time). */
472 if (current_language
!= expected_language
)
474 if (language_mode
== language_mode_auto
)
476 language_info (1); /* Print what changed. */
481 /* Warn the user if the working language does not match the
482 language of the current frame. Only warn the user if we are
483 actually running the program, i.e. there is a stack. */
484 /* FIXME: This should be cacheing the frame and only running when
485 the frame changes. */
487 if (target_has_stack
&& !is_running (inferior_ptid
))
489 flang
= get_frame_language ();
491 && flang
!= language_unknown
492 && flang
!= current_language
->la_language
)
494 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
500 /* Read commands from `instream' and execute them
501 until end of file or error reading instream. */
506 struct cleanup
*old_chain
;
508 int stdin_is_tty
= ISATTY (stdin
);
509 long time_at_cmd_start
;
511 long space_at_cmd_start
= 0;
513 extern int display_time
;
514 extern int display_space
;
516 while (instream
&& !feof (instream
))
518 if (window_hook
&& instream
== stdin
)
519 (*window_hook
) (instream
, get_prompt ());
522 if (instream
== stdin
&& stdin_is_tty
)
523 reinitialize_more_filter ();
524 old_chain
= make_cleanup (null_cleanup
, 0);
526 /* Get a command-line. This calls the readline package. */
527 command
= command_line_input (instream
== stdin
?
528 get_prompt () : (char *) NULL
,
529 instream
== stdin
, "prompt");
533 time_at_cmd_start
= get_run_time ();
538 char *lim
= (char *) sbrk (0);
539 space_at_cmd_start
= lim
- lim_at_start
;
543 execute_command (command
, instream
== stdin
);
544 /* Do any commands attached to breakpoint we stopped at. */
545 bpstat_do_actions (&stop_bpstat
);
546 do_cleanups (old_chain
);
550 long cmd_time
= get_run_time () - time_at_cmd_start
;
552 printf_unfiltered (_("Command execution time: %ld.%06ld\n"),
553 cmd_time
/ 1000000, cmd_time
% 1000000);
559 char *lim
= (char *) sbrk (0);
560 long space_now
= lim
- lim_at_start
;
561 long space_diff
= space_now
- space_at_cmd_start
;
563 printf_unfiltered (_("Space used: %ld (%s%ld for this command)\n"),
565 (space_diff
>= 0 ? "+" : ""),
572 /* Commands call this if they do not want to be repeated by null lines. */
580 /* If we aren't reading from standard input, we are saving the last
581 thing read from stdin in line and don't want to delete it. Null lines
582 won't repeat here in any case. */
583 if (instream
== stdin
)
587 /* Read a line from the stream "instream" without command line editing.
589 It prints PROMPT_ARG once at the start.
590 Action is compatible with "readline", e.g. space for the result is
591 malloc'd and should be freed by the caller.
593 A NULL return means end of file. */
595 gdb_readline (char *prompt_arg
)
600 int result_size
= 80;
604 /* Don't use a _filtered function here. It causes the assumed
605 character position to be off, since the newline we read from
606 the user is not accounted for. */
607 fputs_unfiltered (prompt_arg
, gdb_stdout
);
608 gdb_flush (gdb_stdout
);
611 result
= (char *) xmalloc (result_size
);
615 /* Read from stdin if we are executing a user defined command.
616 This is the right thing for prompt_for_continue, at least. */
617 c
= fgetc (instream
? instream
: stdin
);
622 /* The last line does not end with a newline. Return it, and
623 if we are called again fgetc will still return EOF and
624 we'll return NULL then. */
632 if (input_index
> 0 && result
[input_index
- 1] == '\r')
637 result
[input_index
++] = c
;
638 while (input_index
>= result_size
)
641 result
= (char *) xrealloc (result
, result_size
);
645 result
[input_index
++] = '\0';
649 /* Variables which control command line editing and history
650 substitution. These variables are given default values at the end
652 static int command_editing_p
;
654 /* NOTE 1999-04-29: This variable will be static again, once we modify
655 gdb to use the event loop as the default command loop and we merge
656 event-top.c into this file, top.c */
658 /* static */ int history_expansion_p
;
660 static int write_history_p
;
662 show_write_history_p (struct ui_file
*file
, int from_tty
,
663 struct cmd_list_element
*c
, const char *value
)
665 fprintf_filtered (file
, _("Saving of the history record on exit is %s.\n"),
669 static int history_size
;
671 show_history_size (struct ui_file
*file
, int from_tty
,
672 struct cmd_list_element
*c
, const char *value
)
674 fprintf_filtered (file
, _("The size of the command history is %s.\n"),
678 static char *history_filename
;
680 show_history_filename (struct ui_file
*file
, int from_tty
,
681 struct cmd_list_element
*c
, const char *value
)
683 fprintf_filtered (file
, _("\
684 The filename in which to record the command history is \"%s\".\n"),
688 /* This is like readline(), but it has some gdb-specific behavior.
689 gdb may want readline in both the synchronous and async modes during
690 a single gdb invocation. At the ordinary top-level prompt we might
691 be using the async readline. That means we can't use
692 rl_pre_input_hook, since it doesn't work properly in async mode.
693 However, for a secondary prompt (" >", such as occurs during a
694 `define'), gdb wants a synchronous response.
696 We used to call readline() directly, running it in synchronous
697 mode. But mixing modes this way is not supported, and as of
698 readline 5.x it no longer works; the arrow keys come unbound during
699 the synchronous call. So we make a nested call into the event
700 loop. That's what gdb_readline_wrapper is for. */
702 /* A flag set as soon as gdb_readline_wrapper_line is called; we can't
703 rely on gdb_readline_wrapper_result, which might still be NULL if
704 the user types Control-D for EOF. */
705 static int gdb_readline_wrapper_done
;
707 /* The result of the current call to gdb_readline_wrapper, once a newline
709 static char *gdb_readline_wrapper_result
;
711 /* Any intercepted hook. Operate-and-get-next sets this, expecting it
712 to be called after the newline is processed (which will redisplay
713 the prompt). But in gdb_readline_wrapper we will not get a new
714 prompt until the next call, or until we return to the event loop.
715 So we disable this hook around the newline and restore it before we
717 static void (*saved_after_char_processing_hook
) (void);
719 /* This function is called when readline has seen a complete line of
723 gdb_readline_wrapper_line (char *line
)
725 gdb_assert (!gdb_readline_wrapper_done
);
726 gdb_readline_wrapper_result
= line
;
727 gdb_readline_wrapper_done
= 1;
729 /* Prevent operate-and-get-next from acting too early. */
730 saved_after_char_processing_hook
= after_char_processing_hook
;
731 after_char_processing_hook
= NULL
;
733 /* Prevent parts of the prompt from being redisplayed if annotations
734 are enabled, and readline's state getting out of sync. */
735 if (async_command_editing_p
)
736 rl_callback_handler_remove ();
739 struct gdb_readline_wrapper_cleanup
741 void (*handler_orig
) (char *);
742 int already_prompted_orig
;
746 gdb_readline_wrapper_cleanup (void *arg
)
748 struct gdb_readline_wrapper_cleanup
*cleanup
= arg
;
750 rl_already_prompted
= cleanup
->already_prompted_orig
;
752 gdb_assert (input_handler
== gdb_readline_wrapper_line
);
753 input_handler
= cleanup
->handler_orig
;
754 gdb_readline_wrapper_result
= NULL
;
755 gdb_readline_wrapper_done
= 0;
757 after_char_processing_hook
= saved_after_char_processing_hook
;
758 saved_after_char_processing_hook
= NULL
;
764 gdb_readline_wrapper (char *prompt
)
766 struct cleanup
*back_to
;
767 struct gdb_readline_wrapper_cleanup
*cleanup
;
770 cleanup
= xmalloc (sizeof (*cleanup
));
771 cleanup
->handler_orig
= input_handler
;
772 input_handler
= gdb_readline_wrapper_line
;
774 cleanup
->already_prompted_orig
= rl_already_prompted
;
776 back_to
= make_cleanup (gdb_readline_wrapper_cleanup
, cleanup
);
778 /* Display our prompt and prevent double prompt display. */
779 display_gdb_prompt (prompt
);
780 rl_already_prompted
= 1;
782 if (after_char_processing_hook
)
783 (*after_char_processing_hook
) ();
784 gdb_assert (after_char_processing_hook
== NULL
);
786 /* gdb_do_one_event argument is unused. */
787 while (gdb_do_one_event (NULL
) >= 0)
788 if (gdb_readline_wrapper_done
)
791 retval
= gdb_readline_wrapper_result
;
792 do_cleanups (back_to
);
801 #if STOP_SIGNAL == SIGTSTP
802 signal (SIGTSTP
, SIG_DFL
);
808 sigprocmask (SIG_SETMASK
, &zero
, 0);
810 #elif HAVE_SIGSETMASK
813 kill (getpid (), SIGTSTP
);
814 signal (SIGTSTP
, stop_sig
);
816 signal (STOP_SIGNAL
, stop_sig
);
818 printf_unfiltered ("%s", get_prompt ());
819 gdb_flush (gdb_stdout
);
821 /* Forget about any previous command -- null line now will do nothing. */
824 #endif /* STOP_SIGNAL */
826 /* Initialize signal handlers. */
828 float_handler (int signo
)
830 /* This message is based on ANSI C, section 4.7. Note that integer
831 divide by zero causes this, so "float" is a misnomer. */
832 signal (SIGFPE
, float_handler
);
833 error (_("Erroneous arithmetic operation."));
837 do_nothing (int signo
)
839 /* Under System V the default disposition of a signal is reinstated after
840 the signal is caught and delivered to an application process. On such
841 systems one must restore the replacement signal handler if one wishes
842 to continue handling the signal in one's program. On BSD systems this
843 is not needed but it is harmless, and it simplifies the code to just do
844 it unconditionally. */
845 signal (signo
, do_nothing
);
848 /* The current saved history number from operate-and-get-next.
849 This is -1 if not valid. */
850 static int operate_saved_history
= -1;
852 /* This is put on the appropriate hook and helps operate-and-get-next
855 gdb_rl_operate_and_get_next_completion (void)
857 int delta
= where_history () - operate_saved_history
;
858 /* The `key' argument to rl_get_previous_history is ignored. */
859 rl_get_previous_history (delta
, 0);
860 operate_saved_history
= -1;
862 /* readline doesn't automatically update the display for us. */
865 after_char_processing_hook
= NULL
;
866 rl_pre_input_hook
= NULL
;
869 /* This is a gdb-local readline command handler. It accepts the
870 current command line (like RET does) and, if this command was taken
871 from the history, arranges for the next command in the history to
872 appear on the command line when the prompt returns.
873 We ignore the arguments. */
875 gdb_rl_operate_and_get_next (int count
, int key
)
879 /* Use the async hook. */
880 after_char_processing_hook
= gdb_rl_operate_and_get_next_completion
;
882 /* Find the current line, and find the next line to use. */
883 where
= where_history();
885 /* FIXME: kettenis/20020817: max_input_history is renamed into
886 history_max_entries in readline-4.2. When we do a new readline
887 import, we should probably change it here too, even though
888 readline maintains backwards compatibility for now by still
889 defining max_input_history. */
890 if ((history_is_stifled () && (history_length
>= max_input_history
)) ||
891 (where
>= history_length
- 1))
892 operate_saved_history
= where
;
894 operate_saved_history
= where
+ 1;
896 return rl_newline (1, key
);
899 /* Read one line from the command input stream `instream'
900 into the local static buffer `linebuffer' (whose current length
902 The buffer is made bigger as necessary.
903 Returns the address of the start of the line.
905 NULL is returned for end of file.
907 *If* the instream == stdin & stdin is a terminal, the line read
908 is copied into the file line saver (global var char *line,
909 length linesize) so that it can be duplicated.
911 This routine either uses fancy command line editing or
912 simple input as the user has requested. */
915 command_line_input (char *prompt_arg
, int repeat
, char *annotation_suffix
)
917 static char *linebuffer
= 0;
918 static unsigned linelength
= 0;
922 char *local_prompt
= prompt_arg
;
926 /* The annotation suffix must be non-NULL. */
927 if (annotation_suffix
== NULL
)
928 annotation_suffix
= "";
930 if (annotation_level
> 1 && instream
== stdin
)
932 local_prompt
= alloca ((prompt_arg
== NULL
? 0 : strlen (prompt_arg
))
933 + strlen (annotation_suffix
) + 40);
934 if (prompt_arg
== NULL
)
935 local_prompt
[0] = '\0';
937 strcpy (local_prompt
, prompt_arg
);
938 strcat (local_prompt
, "\n\032\032");
939 strcat (local_prompt
, annotation_suffix
);
940 strcat (local_prompt
, "\n");
946 linebuffer
= (char *) xmalloc (linelength
);
951 /* Control-C quits instantly if typed while in this loop
952 since it should not wait until the user types a newline. */
956 signal (STOP_SIGNAL
, handle_stop_sig
);
961 /* Make sure that all output has been output. Some machines may let
962 you get away with leaving out some of the gdb_flush, but not all. */
964 gdb_flush (gdb_stdout
);
965 gdb_flush (gdb_stderr
);
967 if (source_file_name
!= NULL
)
968 ++source_line_number
;
970 if (annotation_level
> 1 && instream
== stdin
)
972 puts_unfiltered ("\n\032\032pre-");
973 puts_unfiltered (annotation_suffix
);
974 puts_unfiltered ("\n");
977 /* Don't use fancy stuff if not talking to stdin. */
978 if (deprecated_readline_hook
&& input_from_terminal_p ())
980 rl
= (*deprecated_readline_hook
) (local_prompt
);
982 else if (command_editing_p
&& input_from_terminal_p ())
984 rl
= gdb_readline_wrapper (local_prompt
);
988 rl
= gdb_readline (local_prompt
);
991 if (annotation_level
> 1 && instream
== stdin
)
993 puts_unfiltered ("\n\032\032post-");
994 puts_unfiltered (annotation_suffix
);
995 puts_unfiltered ("\n");
998 if (!rl
|| rl
== (char *) EOF
)
1003 if (strlen (rl
) + 1 + (p
- linebuffer
) > linelength
)
1005 linelength
= strlen (rl
) + 1 + (p
- linebuffer
);
1006 nline
= (char *) xrealloc (linebuffer
, linelength
);
1007 p
+= nline
- linebuffer
;
1011 /* Copy line. Don't copy null at end. (Leaves line alone
1012 if this was just a newline) */
1016 xfree (rl
); /* Allocated in readline. */
1018 if (p
== linebuffer
|| *(p
- 1) != '\\')
1021 p
--; /* Put on top of '\'. */
1022 local_prompt
= (char *) 0;
1027 signal (STOP_SIGNAL
, SIG_DFL
);
1034 #define SERVER_COMMAND_LENGTH 7
1036 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
1037 && strncmp (linebuffer
, "server ", SERVER_COMMAND_LENGTH
) == 0;
1040 /* Note that we don't set `line'. Between this and the check in
1041 dont_repeat, this insures that repeating will still do the
1044 return linebuffer
+ SERVER_COMMAND_LENGTH
;
1047 /* Do history expansion if that is wished. */
1048 if (history_expansion_p
&& instream
== stdin
1049 && ISATTY (instream
))
1051 char *history_value
;
1054 *p
= '\0'; /* Insert null now. */
1055 expanded
= history_expand (linebuffer
, &history_value
);
1058 /* Print the changes. */
1059 printf_unfiltered ("%s\n", history_value
);
1061 /* If there was an error, call this function again. */
1064 xfree (history_value
);
1065 return command_line_input (prompt_arg
, repeat
, annotation_suffix
);
1067 if (strlen (history_value
) > linelength
)
1069 linelength
= strlen (history_value
) + 1;
1070 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
1072 strcpy (linebuffer
, history_value
);
1073 p
= linebuffer
+ strlen (linebuffer
);
1075 xfree (history_value
);
1078 /* If we just got an empty line, and that is supposed
1079 to repeat the previous command, return the value in the
1081 if (repeat
&& p
== linebuffer
)
1083 for (p1
= linebuffer
; *p1
== ' ' || *p1
== '\t'; p1
++);
1089 /* Add line to history if appropriate. */
1090 if (instream
== stdin
1091 && ISATTY (stdin
) && *linebuffer
)
1092 add_history (linebuffer
);
1094 /* Note: lines consisting solely of comments are added to the command
1095 history. This is useful when you type a command, and then
1096 realize you don't want to execute it quite yet. You can comment
1097 out the command and then later fetch it from the value history
1098 and remove the '#'. The kill ring is probably better, but some
1099 people are in the habit of commenting things out. */
1101 *p1
= '\0'; /* Found a comment. */
1103 /* Save into global buffer if appropriate. */
1106 if (linelength
> linesize
)
1108 line
= xrealloc (line
, linelength
);
1109 linesize
= linelength
;
1111 strcpy (line
, linebuffer
);
1118 /* Print the GDB banner. */
1120 print_gdb_version (struct ui_file
*stream
)
1122 /* From GNU coding standards, first line is meant to be easy for a
1123 program to parse, and is just canonical program name and version
1124 number, which starts after last space. */
1126 fprintf_filtered (stream
, "GNU gdb %s%s\n", PKGVERSION
, version
);
1128 /* Second line is a copyright notice. */
1130 fprintf_filtered (stream
, "Copyright (C) 2008 Free Software Foundation, Inc.\n");
1132 /* Following the copyright is a brief statement that the program is
1133 free software, that users are free to copy and change it on
1134 certain conditions, that it is covered by the GNU GPL, and that
1135 there is no warranty. */
1137 fprintf_filtered (stream
, "\
1138 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n\
1139 This is free software: you are free to change and redistribute it.\n\
1140 There is NO WARRANTY, to the extent permitted by law. Type \"show copying\"\n\
1141 and \"show warranty\" for details.\n");
1143 /* After the required info we print the configuration information. */
1145 fprintf_filtered (stream
, "This GDB was configured as \"");
1146 if (strcmp (host_name
, target_name
) != 0)
1148 fprintf_filtered (stream
, "--host=%s --target=%s", host_name
, target_name
);
1152 fprintf_filtered (stream
, "%s", host_name
);
1154 fprintf_filtered (stream
, "\".");
1156 if (REPORT_BUGS_TO
[0])
1158 fprintf_filtered (stream
,
1159 _("\nFor bug reporting instructions, please see:\n"));
1160 fprintf_filtered (stream
, "%s.", REPORT_BUGS_TO
);
1164 /* get_prompt: access method for the GDB prompt string. */
1173 set_prompt (char *s
)
1175 /* ??rehrauer: I don't know why this fails, since it looks as though
1176 assignments to prompt are wrapped in calls to savestring...
1180 PROMPT (0) = savestring (s
, strlen (s
));
1184 /* If necessary, make the user confirm that we should quit. Return
1185 non-zero if we should quit, zero if we shouldn't. */
1190 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
1194 /* This is something of a hack. But there's no reliable way to
1195 see if a GUI is running. The `use_windows' variable doesn't
1197 if (deprecated_init_ui_hook
)
1198 s
= "A debugging session is active.\nDo you still want to close the debugger?";
1199 else if (attach_flag
)
1200 s
= "The program is running. Quit anyway (and detach it)? ";
1202 s
= "The program is running. Quit anyway (and kill it)? ";
1204 if (!query ("%s", s
))
1211 /* Helper routine for quit_force that requires error handling. */
1220 quit_target (void *arg
)
1222 struct qt_args
*qt
= (struct qt_args
*)arg
;
1224 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
1227 target_detach (qt
->args
, qt
->from_tty
);
1232 /* UDI wants this, to kill the TIP. */
1233 target_close (¤t_target
, 1);
1235 /* Save the history information if it is appropriate to do so. */
1236 if (write_history_p
&& history_filename
)
1237 write_history (history_filename
);
1239 do_final_cleanups (ALL_CLEANUPS
); /* Do any final cleanups before exiting */
1244 /* Quit without asking for confirmation. */
1247 quit_force (char *args
, int from_tty
)
1252 /* An optional expression may be used to cause gdb to terminate with the
1253 value of that expression. */
1256 struct value
*val
= parse_and_eval (args
);
1258 exit_code
= (int) value_as_long (val
);
1260 else if (return_child_result
)
1261 exit_code
= return_child_result_value
;
1264 qt
.from_tty
= from_tty
;
1266 /* We want to handle any quit errors and exit regardless. */
1267 catch_errors (quit_target
, &qt
,
1268 "Quitting: ", RETURN_MASK_ALL
);
1273 /* Returns whether GDB is running on a terminal and input is
1274 currently coming from that terminal. */
1277 input_from_terminal_p (void)
1279 if (gdb_has_a_terminal () && instream
== stdin
)
1282 /* If INSTREAM is unset, and we are not in a user command, we
1283 must be in Insight. That's like having a terminal, for our
1285 if (instream
== NULL
&& !in_user_command
)
1292 dont_repeat_command (char *ignored
, int from_tty
)
1294 *line
= 0; /* Can't call dont_repeat here because we're not
1295 necessarily reading from stdin. */
1298 /* Functions to manipulate command line editing control variables. */
1300 /* Number of commands to print in each call to show_commands. */
1301 #define Hist_print 10
1303 show_commands (char *args
, int from_tty
)
1305 /* Index for history commands. Relative to history_base. */
1308 /* Number of the history entry which we are planning to display next.
1309 Relative to history_base. */
1312 /* The first command in the history which doesn't exist (i.e. one more
1313 than the number of the last command). Relative to history_base. */
1316 /* Print out some of the commands from the command history. */
1317 /* First determine the length of the history list. */
1318 hist_len
= history_size
;
1319 for (offset
= 0; offset
< history_size
; offset
++)
1321 if (!history_get (history_base
+ offset
))
1330 if (args
[0] == '+' && args
[1] == '\0')
1331 /* "info editing +" should print from the stored position. */
1334 /* "info editing <exp>" should print around command number <exp>. */
1335 num
= (parse_and_eval_long (args
) - history_base
) - Hist_print
/ 2;
1337 /* "show commands" means print the last Hist_print commands. */
1340 num
= hist_len
- Hist_print
;
1346 /* If there are at least Hist_print commands, we want to display the last
1347 Hist_print rather than, say, the last 6. */
1348 if (hist_len
- num
< Hist_print
)
1350 num
= hist_len
- Hist_print
;
1355 for (offset
= num
; offset
< num
+ Hist_print
&& offset
< hist_len
; offset
++)
1357 printf_filtered ("%5d %s\n", history_base
+ offset
,
1358 (history_get (history_base
+ offset
))->line
);
1361 /* The next command we want to display is the next one that we haven't
1365 /* If the user repeats this command with return, it should do what
1366 "show commands +" does. This is unnecessary if arg is null,
1367 because "show commands +" is not useful after "show commands". */
1368 if (from_tty
&& args
)
1375 /* Called by do_setshow_command. */
1377 set_history_size_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1379 if (history_size
== INT_MAX
)
1380 unstifle_history ();
1381 else if (history_size
>= 0)
1382 stifle_history (history_size
);
1385 history_size
= INT_MAX
;
1386 error (_("History size must be non-negative"));
1391 set_history (char *args
, int from_tty
)
1393 printf_unfiltered (_("\"set history\" must be followed by the name of a history subcommand.\n"));
1394 help_list (sethistlist
, "set history ", -1, gdb_stdout
);
1398 show_history (char *args
, int from_tty
)
1400 cmd_show_list (showhistlist
, from_tty
, "");
1403 int info_verbose
= 0; /* Default verbose msgs off */
1405 /* Called by do_setshow_command. An elaborate joke. */
1407 set_verbose (char *args
, int from_tty
, struct cmd_list_element
*c
)
1409 char *cmdname
= "verbose";
1410 struct cmd_list_element
*showcmd
;
1412 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, 1);
1416 c
->doc
= "Set verbose printing of informational messages.";
1417 showcmd
->doc
= "Show verbose printing of informational messages.";
1421 c
->doc
= "Set verbosity.";
1422 showcmd
->doc
= "Show verbosity.";
1426 /* Init the history buffer. Note that we are called after the init file(s)
1427 * have been read so that the user can change the history file via his
1428 * .gdbinit file (for instance). The GDBHISTFILE environment variable
1429 * overrides all of this.
1437 tmpenv
= getenv ("HISTSIZE");
1439 history_size
= atoi (tmpenv
);
1440 else if (!history_size
)
1443 stifle_history (history_size
);
1445 tmpenv
= getenv ("GDBHISTFILE");
1447 history_filename
= savestring (tmpenv
, strlen (tmpenv
));
1448 else if (!history_filename
)
1450 /* We include the current directory so that if the user changes
1451 directories the file written will be the same as the one
1454 /* No leading dots in file names are allowed on MSDOS. */
1455 history_filename
= concat (current_directory
, "/_gdb_history",
1458 history_filename
= concat (current_directory
, "/.gdb_history",
1462 read_history (history_filename
);
1466 show_new_async_prompt (struct ui_file
*file
, int from_tty
,
1467 struct cmd_list_element
*c
, const char *value
)
1469 fprintf_filtered (file
, _("Gdb's prompt is \"%s\".\n"), value
);
1473 show_async_command_editing_p (struct ui_file
*file
, int from_tty
,
1474 struct cmd_list_element
*c
, const char *value
)
1476 fprintf_filtered (file
, _("\
1477 Editing of command lines as they are typed is %s.\n"),
1482 show_annotation_level (struct ui_file
*file
, int from_tty
,
1483 struct cmd_list_element
*c
, const char *value
)
1485 fprintf_filtered (file
, _("Annotation_level is %s.\n"), value
);
1489 show_exec_done_display_p (struct ui_file
*file
, int from_tty
,
1490 struct cmd_list_element
*c
, const char *value
)
1492 fprintf_filtered (file
, _("\
1493 Notification of completion for asynchronous execution commands is %s.\n"),
1499 struct cmd_list_element
*c
;
1501 /* initialize the prompt stack to a simple "(gdb) " prompt or to
1502 whatever the DEFAULT_PROMPT is. */
1503 the_prompts
.top
= 0;
1505 PROMPT (0) = savestring (DEFAULT_PROMPT
, strlen (DEFAULT_PROMPT
));
1507 /* Set things up for annotation_level > 1, if the user ever decides
1509 async_annotation_suffix
= "prompt";
1510 /* Set the variable associated with the setshow prompt command. */
1511 new_async_prompt
= savestring (PROMPT (0), strlen (PROMPT (0)));
1513 /* If gdb was started with --annotate=2, this is equivalent to the
1514 user entering the command 'set annotate 2' at the gdb prompt, so
1515 we need to do extra processing. */
1516 if (annotation_level
> 1)
1517 set_async_annotation_level (NULL
, 0, NULL
);
1519 /* Set the important stuff up for command editing. */
1520 command_editing_p
= 1;
1521 history_expansion_p
= 0;
1522 write_history_p
= 0;
1524 /* Setup important stuff for command line editing. */
1525 rl_completion_entry_function
= readline_line_completion_function
;
1526 rl_completer_word_break_characters
= default_word_break_characters ();
1527 rl_completer_quote_characters
= get_gdb_completer_quote_characters ();
1528 rl_readline_name
= "gdb";
1529 rl_terminal_name
= getenv ("TERM");
1531 /* The name for this defun comes from Bash, where it originated.
1532 15 is Control-o, the same binding this function has in Bash. */
1533 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next
, 15);
1535 add_setshow_string_cmd ("prompt", class_support
,
1536 &new_async_prompt
, _("\
1537 Set gdb's prompt"), _("\
1538 Show gdb's prompt"), NULL
,
1540 show_new_async_prompt
,
1541 &setlist
, &showlist
);
1543 add_com ("dont-repeat", class_support
, dont_repeat_command
, _("\
1544 Don't repeat this command.\n\
1545 Primarily used inside of user-defined commands that should not be repeated when\n\
1548 add_setshow_boolean_cmd ("editing", class_support
,
1549 &async_command_editing_p
, _("\
1550 Set editing of command lines as they are typed."), _("\
1551 Show editing of command lines as they are typed."), _("\
1552 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1553 Without an argument, command line editing is enabled. To edit, use\n\
1554 EMACS-like or VI-like commands like control-P or ESC."),
1555 set_async_editing_command
,
1556 show_async_command_editing_p
,
1557 &setlist
, &showlist
);
1559 add_setshow_boolean_cmd ("save", no_class
, &write_history_p
, _("\
1560 Set saving of the history record on exit."), _("\
1561 Show saving of the history record on exit."), _("\
1562 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
1563 Without an argument, saving is enabled."),
1565 show_write_history_p
,
1566 &sethistlist
, &showhistlist
);
1568 add_setshow_integer_cmd ("size", no_class
, &history_size
, _("\
1569 Set the size of the command history,"), _("\
1570 Show the size of the command history,"), _("\
1571 ie. the number of previous commands to keep a record of."),
1572 set_history_size_command
,
1574 &sethistlist
, &showhistlist
);
1576 add_setshow_filename_cmd ("filename", no_class
, &history_filename
, _("\
1577 Set the filename in which to record the command history"), _("\
1578 Show the filename in which to record the command history"), _("\
1579 (the list of previous commands of which a record is kept)."),
1581 show_history_filename
,
1582 &sethistlist
, &showhistlist
);
1584 add_setshow_boolean_cmd ("confirm", class_support
, &caution
, _("\
1585 Set whether to confirm potentially dangerous operations."), _("\
1586 Show whether to confirm potentially dangerous operations."), NULL
,
1589 &setlist
, &showlist
);
1591 add_setshow_zinteger_cmd ("annotate", class_obscure
, &annotation_level
, _("\
1592 Set annotation_level."), _("\
1593 Show annotation_level."), _("\
1594 0 == normal; 1 == fullname (for use when running under emacs)\n\
1595 2 == output annotated suitably for use by programs that control GDB."),
1596 set_async_annotation_level
,
1597 show_annotation_level
,
1598 &setlist
, &showlist
);
1600 add_setshow_boolean_cmd ("exec-done-display", class_support
,
1601 &exec_done_display_p
, _("\
1602 Set notification of completion for asynchronous execution commands."), _("\
1603 Show notification of completion for asynchronous execution commands."), _("\
1604 Use \"on\" to enable the notification, and \"off\" to disable it."),
1606 show_exec_done_display_p
,
1607 &setlist
, &showlist
);
1611 gdb_init (char *argv0
)
1613 if (pre_init_ui_hook
)
1614 pre_init_ui_hook ();
1616 /* Run the init function of each source file */
1618 getcwd (gdb_dirbuf
, sizeof (gdb_dirbuf
));
1619 current_directory
= gdb_dirbuf
;
1622 /* Make sure we return to the original directory upon exit, come
1623 what may, since the OS doesn't do that for us. */
1624 make_final_cleanup (do_chdir_cleanup
, xstrdup (current_directory
));
1627 init_cmd_lists (); /* This needs to be done first */
1628 initialize_targets (); /* Setup target_terminal macros for utils.c */
1629 initialize_utils (); /* Make errors and warnings possible */
1630 initialize_all_files ();
1631 initialize_current_architecture ();
1633 init_main (); /* But that omits this file! Do it now */
1635 initialize_stdin_serial ();
1637 async_init_signals ();
1639 /* We need a default language for parsing expressions, so simple things like
1640 "set width 0" won't fail if no language is explicitly set in a config file
1641 or implicitly set by reading an executable during startup. */
1642 set_language (language_c
);
1643 expected_language
= current_language
; /* don't warn about the change. */
1645 /* Allow another UI to initialize. If the UI fails to initialize,
1646 and it wants GDB to revert to the CLI, it should clear
1647 deprecated_init_ui_hook. */
1648 if (deprecated_init_ui_hook
)
1649 deprecated_init_ui_hook (argv0
);