#include "defs.h"
#include "gdbcmd.h"
#include "call-cmds.h"
#include "cli/cli-cmds.h"
#include "cli/cli-script.h"
#include "cli/cli-setshow.h"
#include "cli/cli-decode.h"
#include "symtab.h"
#include "inferior.h"
#include "exceptions.h"
#include <signal.h>
#include "target.h"
#include "breakpoint.h"
#include "gdbtypes.h"
#include "expression.h"
#include "value.h"
#include "language.h"
#include "terminal.h"
#include "annotate.h"
#include "completer.h"
#include "top.h"
#include "version.h"
#include "serial.h"
#include "doublest.h"
#include "gdb_assert.h"
#include "inlining.h"
#include "checkpoint.h"
#include "readline/readline.h"
#include "readline/history.h"
#undef savestring
#include <sys/types.h>
#include "event-top.h"
#include "gdb_string.h"
#include "gdb_stat.h"
#include <ctype.h>
#include "ui-out.h"
#include "cli-out.h"
#ifndef DEFAULT_PROMPT
#define DEFAULT_PROMPT "(gdb) "
#endif
#ifndef PATH_MAX
# ifdef FILENAME_MAX
# define PATH_MAX FILENAME_MAX
# else
# define PATH_MAX 512
# endif
#endif
#ifndef GDBINIT_FILENAME
#define GDBINIT_FILENAME ".gdbinit"
#endif
char gdbinit[PATH_MAX + 1] = GDBINIT_FILENAME;
#ifndef GDBINIT_GLOBAL
#define GDBINIT_GLOBAL "/etc/gdb.conf"
#endif
char gdbinit_global[] = GDBINIT_GLOBAL;
int inhibit_gdbinit = 0;
int use_windows = 0;
extern char lang_frame_mismatch_warn[];
int caution = 1;
static void
show_caution (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("\
Whether to confirm potentially dangerous operations is %s.\n"),
value);
}
FILE *instream;
char *current_directory;
char gdb_dirbuf[1024];
void (*window_hook) (FILE *, char *);
int epoch_interface;
int xgdb_verbose;
static char *gdb_prompt_string;
char *line;
int linesize = 100;
int server_command;
int baud_rate = -1;
int remote_timeout = 2;
int remote_debug = 0;
int target_executing = 0;
static int control_level;
int gdb_quitting = 0;
#ifdef HAVE_SBRK
char *lim_at_start;
#endif
#ifndef STOP_SIGNAL
#ifdef SIGTSTP
#define STOP_SIGNAL SIGTSTP
static void stop_sig (int);
#endif
#endif
void (*deprecated_init_ui_hook) (char *argv0);
int (*deprecated_ui_loop_hook) (int);
void (*deprecated_command_loop_hook) (void);
void (*deprecated_print_frame_info_listing_hook) (struct symtab * s, int line,
int stopline, int noerror);
void (*print_frame_more_info_hook) (struct ui_out *uiout,
struct symtab_and_line *sal,
struct frame_info *fi);
int (*deprecated_query_hook) (const char *, va_list);
void (*deprecated_warning_hook) (const char *, va_list);
void (*deprecated_readline_begin_hook) (char *, ...);
char *(*deprecated_readline_hook) (char *);
void (*deprecated_readline_end_hook) (void);
void (*deprecated_create_breakpoint_hook) (struct breakpoint * bpt);
void (*deprecated_delete_breakpoint_hook) (struct breakpoint * bpt);
void (*deprecated_modify_breakpoint_hook) (struct breakpoint * bpt);
void (*deprecated_attach_hook) (void);
void (*deprecated_detach_hook) (void);
void (*deprecated_interactive_hook) (void);
void (*deprecated_registers_changed_hook) (void);
void (*deprecated_register_changed_hook) (int regno);
void (*deprecated_memory_changed_hook) (CORE_ADDR addr, int len);
ptid_t (*deprecated_target_wait_hook) (ptid_t ptid,
struct target_waitstatus * status,
gdb_client_data client_data);
void (*deprecated_call_command_hook) (struct cmd_list_element * c, char *cmd,
int from_tty);
void (*deprecated_set_hook) (struct cmd_list_element * c);
void (*print_source_lines_hook) (struct symtab * s, int line, int stopline);
void (*state_change_hook) (Debugger_state new_state);
void (*frame_changed_hook) (int new_frame_number);
void (*stack_changed_hook) (void);
char *(*command_line_input_hook) (char *, int, char *);
void (*deprecated_context_hook) (int id);
void (*deprecated_error_hook) (void);
void (*stepping_command_hook) (void);
void (*continue_command_hook) (void);
int (*run_command_hook) (void);
void (*hand_call_function_hook) (void);
#ifdef SIGHUP
int
quit_cover (void *s)
{
caution = 0;
quit_command ((char *) 0, 0);
return 0;
}
#endif
int source_line_number;
char *source_file_name;
void
do_restore_instream_cleanup (void *stream)
{
instream = stream;
}
void
read_command_file (FILE *stream)
{
struct cleanup *cleanups;
cleanups = make_cleanup (do_restore_instream_cleanup, instream);
instream = stream;
if (target_can_async_p ())
{
gdb_set_async_override (1);
make_cleanup (gdb_set_async_override, 0);
}
command_loop ();
do_cleanups (cleanups);
}
void (*pre_init_ui_hook) (void);
#ifdef __MSDOS__
void
do_chdir_cleanup (void *old_dir)
{
chdir (old_dir);
xfree (old_dir);
}
#endif
void
execute_command (char *p, int from_tty)
{
struct cmd_list_element *c;
enum language flang;
static int warned = 0;
char *tmp_line;
free_all_values ();
stepping_into_inlined_subroutine = 0;
alloca (0);
if (p == NULL)
return;
serial_log_command (p);
while (*p == ' ' || *p == '\t')
p++;
if (*p)
{
char *arg;
tmp_line = p;
c = lookup_cmd (&p, cmdlist, "", 0, 1);
if (target_can_async_p () && target_executing)
if (strcmp (c->name, "help") != 0
&& strcmp (c->name, "pwd") != 0
&& strcmp (c->name, "show") != 0
&& strcmp (c->name, "stop") != 0)
error (_("Cannot execute this command while the target is running."));
arg = *p ? p : 0;
if (arg
&& c->type != set_cmd
&& !is_complete_command (c))
{
p = arg + strlen (arg) - 1;
while (p >= arg && (*p == ' ' || *p == '\t'))
p--;
*(p + 1) = '\0';
}
execute_cmd_pre_hook (c);
if (c->flags & DEPRECATED_WARN_USER)
deprecated_cmd_warning (&tmp_line);
if (c->class == class_user)
execute_user_command (c, arg);
else if (c->type == set_cmd || c->type == show_cmd)
do_setshow_command (arg, from_tty & caution, c);
else if (!cmd_func_p (c))
error (_("That is not a command, just a help topic."));
else if (deprecated_call_command_hook)
deprecated_call_command_hook (c, arg, from_tty & caution);
else
cmd_func (c, arg, from_tty & caution);
execute_cmd_post_hook (c);
}
if (current_language != expected_language)
{
if (language_mode == language_mode_auto)
{
language_info (1);
}
warned = 0;
}
if (target_has_stack)
{
flang = get_frame_language ();
if (!warned
&& flang != language_unknown
&& flang != current_language->la_language)
{
printf_filtered ("%s\n", lang_frame_mismatch_warn);
warned = 1;
}
}
}
void
command_loop (void)
{
struct cleanup *old_chain;
char *command;
int stdin_is_tty = ISATTY (stdin);
long time_at_cmd_start;
#ifdef HAVE_SBRK
long space_at_cmd_start = 0;
#endif
extern int display_time;
extern int display_space;
while (instream && !feof (instream))
{
if (window_hook && instream == stdin)
(*window_hook) (instream, get_prompt ());
quit_flag = 0;
if (instream == stdin && stdin_is_tty)
reinitialize_more_filter ();
old_chain = make_cleanup (null_cleanup, 0);
command = command_line_input (instream == stdin ?
get_prompt () : (char *) NULL,
instream == stdin, "prompt");
if (command == 0)
return;
time_at_cmd_start = get_run_time ();
if (display_space)
{
#ifdef HAVE_SBRK
char *lim = (char *) sbrk (0);
space_at_cmd_start = lim - lim_at_start;
#endif
}
execute_command (command, instream == stdin);
bpstat_do_actions (&stop_bpstat);
do_cleanups (old_chain);
if (display_time)
{
long cmd_time = get_run_time () - time_at_cmd_start;
printf_unfiltered (_("Command execution time: %ld.%06ld\n"),
cmd_time / 1000000, cmd_time % 1000000);
}
if (display_space)
{
#ifdef HAVE_SBRK
char *lim = (char *) sbrk (0);
long space_now = lim - lim_at_start;
long space_diff = space_now - space_at_cmd_start;
printf_unfiltered (_("Space used: %ld (%c%ld for this command)\n"),
space_now,
(space_diff >= 0 ? '+' : '-'),
space_diff);
#endif
}
}
}
void
simplified_command_loop (char *(*read_input_func) (char *),
void (*execute_command_func) (char *, int))
{
struct cleanup *old_chain;
char *command;
int stdin_is_tty = ISATTY (stdin);
while (instream && !feof (instream))
{
quit_flag = 0;
if (instream == stdin && stdin_is_tty)
reinitialize_more_filter ();
old_chain = make_cleanup (null_cleanup, 0);
command = (*read_input_func) (instream == stdin ?
get_prompt () : (char *) NULL);
if (command == 0)
return;
(*execute_command_func) (command, instream == stdin);
bpstat_do_actions (&stop_bpstat);
do_cleanups (old_chain);
}
}
void
dont_repeat (void)
{
if (server_command)
return;
if (instream == stdin)
*line = 0;
}
char *
gdb_readline (char *prompt_arg)
{
int c;
char *result;
int input_index = 0;
int result_size = 80;
if (prompt_arg)
{
fputs_unfiltered (prompt_arg, gdb_stdout);
gdb_flush (gdb_stdout);
}
result = (char *) xmalloc (result_size);
while (1)
{
c = fgetc (instream ? instream : stdin);
if (c == EOF)
{
if (input_index > 0)
break;
xfree (result);
return NULL;
}
if (c == '\n')
{
if (input_index > 0 && result[input_index - 1] == '\r')
input_index--;
break;
}
result[input_index++] = c;
while (input_index >= result_size)
{
result_size *= 2;
result = (char *) xrealloc (result, result_size);
}
}
result[input_index++] = '\0';
return result;
}
static int command_editing_p;
int history_expansion_p;
static int write_history_p;
static void
show_write_history_p (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Saving of the history record on exit is %s.\n"),
value);
}
static int history_size;
static void
show_history_size (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("The size of the command history is %s.\n"),
value);
}
static char *history_filename;
static void
show_history_filename (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("\
The filename in which to record the command history is \"%s\".\n"),
value);
}
char *
gdb_readline_wrapper (char *prompt)
{
if (after_char_processing_hook)
{
rl_pre_input_hook = (Function *) after_char_processing_hook;
after_char_processing_hook = NULL;
}
return readline (prompt);
}
#ifdef STOP_SIGNAL
static void
stop_sig (int signo)
{
#if STOP_SIGNAL == SIGTSTP
signal (SIGTSTP, SIG_DFL);
#if HAVE_SIGPROCMASK
{
sigset_t zero;
sigemptyset (&zero);
sigprocmask (SIG_SETMASK, &zero, 0);
}
#elif HAVE_SIGSETMASK
sigsetmask (0);
#endif
kill (getpid (), SIGTSTP);
signal (SIGTSTP, stop_sig);
#else
signal (STOP_SIGNAL, stop_sig);
#endif
printf_unfiltered ("%s", get_prompt ());
gdb_flush (gdb_stdout);
dont_repeat ();
}
#endif
static void
float_handler (int signo)
{
signal (SIGFPE, float_handler);
error (_("Erroneous arithmetic operation."));
}
static void
do_nothing (int signo)
{
signal (signo, do_nothing);
}
static int operate_saved_history = -1;
static void
gdb_rl_operate_and_get_next_completion (void)
{
int delta = where_history () - operate_saved_history;
rl_get_previous_history (delta, 0);
operate_saved_history = -1;
rl_redisplay ();
after_char_processing_hook = NULL;
rl_pre_input_hook = NULL;
}
static int
gdb_rl_operate_and_get_next (int count, int key)
{
int where;
after_char_processing_hook = gdb_rl_operate_and_get_next_completion;
where = where_history();
if ((history_is_stifled () && (history_length >= max_input_history)) ||
(where >= history_length - 1))
operate_saved_history = where;
else
operate_saved_history = where + 1;
return rl_newline (1, key);
}
char *
command_line_input (char *prompt_arg, int repeat, char *annotation_suffix)
{
static char *linebuffer = 0;
static unsigned linelength = 0;
char *p;
char *p1;
char *rl;
char *local_prompt = prompt_arg;
char *nline;
char got_eof = 0;
if (annotation_suffix == NULL)
annotation_suffix = "";
if (command_line_input_hook && (instream == stdin))
{
char *ret_val;
ret_val = command_line_input_hook (prompt_arg, repeat, annotation_suffix);
return ret_val;
}
if (annotation_level > 1 && instream == stdin)
{
local_prompt = alloca ((prompt_arg == NULL ? 0 : strlen (prompt_arg))
+ strlen (annotation_suffix) + 40);
if (prompt_arg == NULL)
local_prompt[0] = '\0';
else
strcpy (local_prompt, prompt_arg);
strcat (local_prompt, "\n\032\032");
strcat (local_prompt, annotation_suffix);
strcat (local_prompt, "\n");
}
if (linebuffer == 0)
{
linelength = 80;
linebuffer = (char *) xmalloc (linelength);
}
p = linebuffer;
immediate_quit++;
#ifdef STOP_SIGNAL
if (job_control)
signal (STOP_SIGNAL, handle_stop_sig);
#endif
while (1)
{
wrap_here ("");
gdb_flush (gdb_stdout);
gdb_flush (gdb_stderr);
if (source_file_name != NULL)
++source_line_number;
if (annotation_level > 1 && instream == stdin)
{
puts_unfiltered ("\n\032\032pre-");
puts_unfiltered (annotation_suffix);
puts_unfiltered ("\n");
}
if (deprecated_readline_hook && instream == NULL)
{
rl = (*deprecated_readline_hook) (local_prompt);
}
else if (command_editing_p && instream == stdin && ISATTY (instream))
{
rl = gdb_readline_wrapper (local_prompt);
}
else
{
rl = gdb_readline (local_prompt);
}
if (annotation_level > 1 && instream == stdin)
{
puts_unfiltered ("\n\032\032post-");
puts_unfiltered (annotation_suffix);
puts_unfiltered ("\n");
}
if (!rl || rl == (char *) EOF)
{
got_eof = 1;
break;
}
if (strlen (rl) + 1 + (p - linebuffer) > linelength)
{
linelength = strlen (rl) + 1 + (p - linebuffer);
nline = (char *) xrealloc (linebuffer, linelength);
p += nline - linebuffer;
linebuffer = nline;
}
p1 = rl;
while (*p1)
*p++ = *p1++;
xfree (rl);
if (p == linebuffer || *(p - 1) != '\\')
break;
p--;
local_prompt = (char *) 0;
}
#ifdef STOP_SIGNAL
if (job_control)
signal (STOP_SIGNAL, SIG_DFL);
#endif
immediate_quit--;
if (got_eof)
return NULL;
#define SERVER_COMMAND_LENGTH 7
server_command =
(p - linebuffer > SERVER_COMMAND_LENGTH)
&& strncmp (linebuffer, "server ", SERVER_COMMAND_LENGTH) == 0;
if (server_command)
{
*p = '\0';
return linebuffer + SERVER_COMMAND_LENGTH;
}
if (history_expansion_p && instream == stdin
&& ISATTY (instream))
{
char *history_value;
int expanded;
*p = '\0';
expanded = history_expand (linebuffer, &history_value);
if (expanded)
{
printf_unfiltered ("%s\n", history_value);
if (expanded < 0)
{
xfree (history_value);
return command_line_input (prompt_arg, repeat, annotation_suffix);
}
if (strlen (history_value) > linelength)
{
linelength = strlen (history_value) + 1;
linebuffer = (char *) xrealloc (linebuffer, linelength);
}
strcpy (linebuffer, history_value);
p = linebuffer + strlen (linebuffer);
xfree (history_value);
}
}
if (repeat && p == linebuffer)
return line;
for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++);
if (repeat && !*p1)
return line;
*p = 0;
if (instream == stdin
&& ISATTY (stdin) && *linebuffer)
add_history (linebuffer);
if (*p1 == '#')
*p1 = '\0';
if (repeat)
{
if (linelength > linesize)
{
line = xrealloc (line, linelength);
linesize = linelength;
}
strcpy (line, linebuffer);
return line;
}
return linebuffer;
}
void
print_gdb_version (struct ui_file *stream)
{
fprintf_filtered (stream, "GNU gdb %s (%s)\n", version, build_date);
fprintf_filtered (stream, "Copyright 2004 Free Software Foundation, Inc.\n");
fprintf_filtered (stream, "\
GDB is free software, covered by the GNU General Public License, and you are\n\
welcome to change it and/or distribute copies of it under certain conditions.\n\
Type \"show copying\" to see the conditions.\n\
There is absolutely no warranty for GDB. Type \"show warranty\" for details.\n");
fprintf_filtered (stream, "This GDB was configured as \"");
if (strcmp (host_name, target_name) != 0)
{
fprintf_filtered (stream, "--host=%s --target=%s", host_name, target_name);
}
else
{
fprintf_filtered (stream, "%s", host_name);
}
fprintf_filtered (stream, "\".");
}
char *
get_prompt (void)
{
return PROMPT (0);
}
void
set_prompt (char *s)
{
PROMPT (0) = savestring (s, strlen (s));
}
int
quit_confirm (void)
{
if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
{
char *s;
if (deprecated_init_ui_hook)
s = "A debugging session is active.\nDo you still want to close the debugger?";
else if (attach_flag)
s = "The program is running. Quit anyway (and detach it)? ";
else
s = "The program is running. Exit anyway? ";
if (!query ("%s", s))
return 0;
}
return 1;
}
struct qt_args
{
char *args;
int from_tty;
};
static int
quit_target (void *arg)
{
struct qt_args *qt = (struct qt_args *)arg;
if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
{
if (attach_flag)
target_detach (qt->args, qt->from_tty);
else
target_kill ();
}
clear_all_checkpoints ();
target_close (¤t_target, 1);
if (write_history_p && history_filename)
write_history (history_filename);
if (state_change_hook)
state_change_hook (STATE_NOT_ACTIVE);
do_final_cleanups (ALL_CLEANUPS);
return 0;
}
void
quit_force (char *args, int from_tty)
{
int exit_code = 0;
struct qt_args qt;
gdb_quitting = 1;
if (args)
{
struct value *val = parse_and_eval (args);
exit_code = (int) value_as_long (val);
}
qt.args = args;
qt.from_tty = from_tty;
catch_errors (quit_target, &qt,
"Quitting: ", RETURN_MASK_ALL);
exit (exit_code);
}
int
input_from_terminal_p (void)
{
return gdb_has_a_terminal () && (instream == stdin) & caution;
}
static void
dont_repeat_command (char *ignored, int from_tty)
{
*line = 0;
}
#define Hist_print 10
void
show_commands (char *args, int from_tty)
{
int offset;
static int num = 0;
int hist_len;
hist_len = history_size;
for (offset = 0; offset < history_size; offset++)
{
if (!history_get (history_base + offset))
{
hist_len = offset;
break;
}
}
if (args)
{
if (args[0] == '+' && args[1] == '\0')
;
else
num = (parse_and_eval_long (args) - history_base) - Hist_print / 2;
}
else
{
num = hist_len - Hist_print;
}
if (num < 0)
num = 0;
if (hist_len - num < Hist_print)
{
num = hist_len - Hist_print;
if (num < 0)
num = 0;
}
for (offset = num; offset < num + Hist_print && offset < hist_len; offset++)
{
printf_filtered ("%5d %s\n", history_base + offset,
(history_get (history_base + offset))->line);
}
num += Hist_print;
if (from_tty && args)
{
args[0] = '+';
args[1] = '\0';
}
}
static void
set_history_size_command (char *args, int from_tty, struct cmd_list_element *c)
{
if (history_size == INT_MAX)
unstifle_history ();
else if (history_size >= 0)
stifle_history (history_size);
else
{
history_size = INT_MAX;
error (_("History size must be non-negative"));
}
}
void
set_history (char *args, int from_tty)
{
printf_unfiltered (_("\"set history\" must be followed by the name of a history subcommand.\n"));
help_list (sethistlist, "set history ", -1, gdb_stdout);
}
void
show_history (char *args, int from_tty)
{
cmd_show_list (showhistlist, from_tty, "");
}
int info_verbose = 0;
void
set_verbose (char *args, int from_tty, struct cmd_list_element *c)
{
char *cmdname = "verbose";
struct cmd_list_element *showcmd;
showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
if (info_verbose)
{
c->doc = "Set verbose printing of informational messages.";
showcmd->doc = "Show verbose printing of informational messages.";
}
else
{
c->doc = "Set verbosity.";
showcmd->doc = "Show verbosity.";
}
}
void
init_history (void)
{
char *tmpenv;
int ret;
tmpenv = getenv ("HISTSIZE");
if (tmpenv)
history_size = atoi (tmpenv);
else if (!history_size)
history_size = 256;
stifle_history (history_size);
tmpenv = getenv ("GDBHISTFILE");
if (tmpenv)
history_filename = savestring (tmpenv, strlen (tmpenv));
else if (!history_filename)
{
#ifdef __MSDOS__
history_filename = concat (current_directory, "/_gdb_history",
(char *)NULL);
#else
history_filename = concat (current_directory, "/.gdb_history",
(char *)NULL);
#endif
}
ret = read_history (history_filename);
if ((ret != 0) && (ret != ENOENT))
warning ("unable to read history from \"%s\": %s", history_filename, strerror (ret));
}
static void
show_new_async_prompt (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Gdb's prompt is \"%s\".\n"), value);
}
static void
show_async_command_editing_p (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("\
Editing of command lines as they are typed is %s.\n"),
value);
}
static void
show_annotation_level (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Annotation_level is %s.\n"), value);
}
static void
show_exec_done_display_p (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("\
Notification of completion for asynchronous execution commands is %s.\n"),
value);
}
static void
init_main (void)
{
struct cmd_list_element *c;
the_prompts.top = 0;
PREFIX (0) = "";
PROMPT (0) = savestring (DEFAULT_PROMPT, strlen (DEFAULT_PROMPT));
SUFFIX (0) = "";
async_annotation_suffix = "prompt";
new_async_prompt = savestring (PROMPT (0), strlen (PROMPT (0)));
if (annotation_level > 1)
set_async_annotation_level (NULL, 0, NULL);
command_editing_p = 1;
history_expansion_p = 0;
write_history_p = 0;
rl_completion_entry_function = readline_line_completion_function;
rl_completer_word_break_characters = default_word_break_characters ();
rl_completer_quote_characters = get_gdb_completer_quote_characters ();
rl_readline_name = "gdb";
rl_terminal_name = getenv ("TERM");
rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next, 15);
add_setshow_string_cmd ("prompt", class_support,
&new_async_prompt, _("\
Set gdb's prompt"), _("\
Show gdb's prompt"), NULL,
set_async_prompt,
show_new_async_prompt,
&setlist, &showlist);
add_com ("dont-repeat", class_support, dont_repeat_command, _("\
Don't repeat this command.\n\
Primarily used inside of user-defined commands that should not be repeated when\n\
hitting return."));
add_setshow_boolean_cmd ("editing", class_support,
&async_command_editing_p, _("\
Set editing of command lines as they are typed."), _("\
Show editing of command lines as they are typed."), _("\
Use \"on\" to enable the editing, and \"off\" to disable it.\n\
Without an argument, command line editing is enabled. To edit, use\n\
EMACS-like or VI-like commands like control-P or ESC."),
set_async_editing_command,
show_async_command_editing_p,
&setlist, &showlist);
add_setshow_boolean_cmd ("save", no_class, &write_history_p, _("\
Set saving of the history record on exit."), _("\
Show saving of the history record on exit."), _("\
Use \"on\" to enable the saving, and \"off\" to disable it.\n\
Without an argument, saving is enabled."),
NULL,
show_write_history_p,
&sethistlist, &showhistlist);
add_setshow_integer_cmd ("size", no_class, &history_size, _("\
Set the size of the command history,"), _("\
Show the size of the command history,"), _("\
ie. the number of previous commands to keep a record of."),
set_history_size_command,
show_history_size,
&sethistlist, &showhistlist);
add_setshow_filename_cmd ("filename", no_class, &history_filename, _("\
Set the filename in which to record the command history"), _("\
Show the filename in which to record the command history"), _("\
(the list of previous commands of which a record is kept)."),
NULL,
show_history_filename,
&sethistlist, &showhistlist);
add_setshow_boolean_cmd ("confirm", class_support, &caution, _("\
Set whether to confirm potentially dangerous operations."), _("\
Show whether to confirm potentially dangerous operations."), NULL,
NULL,
show_caution,
&setlist, &showlist);
add_setshow_zinteger_cmd ("annotate", class_obscure, &annotation_level, _("\
Set annotation_level."), _("\
Show annotation_level."), _("\
0 == normal; 1 == fullname (for use when running under emacs)\n\
2 == output annotated suitably for use by programs that control GDB."),
set_async_annotation_level,
show_annotation_level,
&setlist, &showlist);
add_setshow_boolean_cmd ("exec-done-display", class_support,
&exec_done_display_p, _("\
Set notification of completion for asynchronous execution commands."), _("\
Show notification of completion for asynchronous execution commands."), _("\
Use \"on\" to enable the notification, and \"off\" to disable it."),
NULL,
show_exec_done_display_p,
&setlist, &showlist);
}
void
gdb_init (char *argv0)
{
if (pre_init_ui_hook)
pre_init_ui_hook ();
getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
current_directory = gdb_dirbuf;
#ifdef __MSDOS__
make_final_cleanup (do_chdir_cleanup, xstrdup (current_directory));
#endif
init_cmd_lists ();
initialize_targets ();
initialize_utils ();
initialize_all_files ();
initialize_current_architecture ();
init_cli_cmds();
init_main ();
async_init_signals ();
set_language (language_c);
expected_language = current_language;
if (deprecated_init_ui_hook)
deprecated_init_ui_hook (argv0);
}