/* Ask user a y-or-n question and return 1 iff answer is yes.
* Takes three args which are given to printf to print the question.
* The first, a control string, should end in "? ".
* It should NOT say how to answer, because we do that here. */
int query(char *ctlstr, int arg1, int arg2)
{
/*FIXME: move this function to use a variadic argument list */
register int answer;
/* Automatically answer "yes" if input is not from a terminal. */
#if 0
if (!input_from_terminal_p())
return 1;
#endif /* 0 */
while (1) {
printf("%s %i%i", ctlstr, arg1, arg2);
printf("(y or n) ");
fflush(stdout);
answer = fgetc(stdin);
clearerr(stdin); /* in case of C-d */
if (answer != '\n') {
while (fgetc(stdin) != '\n') {
clearerr(stdin);
}
}
if (answer >= 'a') {
answer -= 040;
}
if (answer == 'Y') {
return 1;
}
if (answer == 'N') {
return 0;
}
printf("Please answer y or n.\n");
}
}
static int
tui_query_hook (const char * msg, va_list argp)
{
int retval;
int ans2;
int answer;
/* Automatically answer "yes" if input is not from a terminal. */
if (!input_from_terminal_p ())
return 1;
echo ();
while (1)
{
wrap_here (""); /* Flush any buffered output */
gdb_flush (gdb_stdout);
vfprintf_filtered (gdb_stdout, msg, argp);
printf_filtered ("(y or n) ");
wrap_here ("");
gdb_flush (gdb_stdout);
answer = tui_getc (stdin);
clearerr (stdin); /* in case of C-d */
if (answer == EOF) /* C-d */
{
retval = 1;
break;
}
/* Eat rest of input line, to EOF or newline */
if (answer != '\n')
do
{
ans2 = tui_getc (stdin);
clearerr (stdin);
}
while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
if (answer >= 'a')
answer -= 040;
if (answer == 'Y')
{
retval = 1;
break;
}
if (answer == 'N')
{
retval = 0;
break;
}
printf_filtered ("Please answer y or n.\n");
}
noecho ();
return retval;
}
char *
handle_line_of_input (struct buffer *cmd_line_buffer,
char *rl, int repeat, char *annotation_suffix)
{
char *p1;
char *cmd;
if (rl == NULL)
return (char *) EOF;
cmd = command_line_append_input_line (cmd_line_buffer, rl);
if (cmd == NULL)
return NULL;
/* We have a complete command line now. Prepare for the next
command, but leave ownership of memory to the buffer . */
cmd_line_buffer->used_size = 0;
if (annotation_level > 1 && instream == stdin)
{
printf_unfiltered (("\n\032\032post-"));
puts_unfiltered (annotation_suffix);
printf_unfiltered (("\n"));
}
#define SERVER_COMMAND_PREFIX "server "
if (startswith (cmd, SERVER_COMMAND_PREFIX))
{
/* Note that we don't set `saved_command_line'. Between this
and the check in dont_repeat, this insures that repeating
will still do the right thing. */
return cmd + strlen (SERVER_COMMAND_PREFIX);
}
/* Do history expansion if that is wished. */
if (history_expansion_p && instream == stdin
&& ISATTY (instream))
{
char *history_value;
int expanded;
expanded = history_expand (cmd, &history_value);
if (expanded)
{
size_t len;
/* Print the changes. */
printf_unfiltered ("%s\n", history_value);
/* If there was an error, call this function again. */
if (expanded < 0)
{
xfree (history_value);
return cmd;
}
/* history_expand returns an allocated string. Just replace
our buffer with it. */
len = strlen (history_value);
xfree (buffer_finish (cmd_line_buffer));
cmd_line_buffer->buffer = history_value;
cmd_line_buffer->buffer_size = len + 1;
cmd = history_value;
}
}
/* If we just got an empty line, and that is supposed to repeat the
previous command, return the previously saved command. */
for (p1 = cmd; *p1 == ' ' || *p1 == '\t'; p1++)
;
if (repeat && *p1 == '\0')
return saved_command_line;
/* Add command to history if appropriate. Note: lines consisting
solely of comments are also added to the command history. This
is useful when you type a command, and then realize you don't
want to execute it quite yet. You can comment out the command
and then later fetch it from the value history and remove the
'#'. The kill ring is probably better, but some people are in
the habit of commenting things out. */
if (*cmd != '\0' && input_from_terminal_p ())
gdb_add_history (cmd);
/* Save into global buffer if appropriate. */
if (repeat)
{
xfree (saved_command_line);
saved_command_line = xstrdup (cmd);
return saved_command_line;
}
else
return cmd;
}
/* NOTE: 1999-04-30 This is the asynchronous version of the
command_line_input function; command_line_input will become
obsolete once we use the event loop as the default mechanism in
GDB. */
static void
command_line_handler (char *rl)
{
static char *linebuffer = 0;
static unsigned linelength = 0;
char *p;
char *p1;
char *nline;
int repeat = (instream == stdin);
if (annotation_level > 1 && instream == stdin)
{
printf_unfiltered (("\n\032\032post-"));
puts_unfiltered (async_annotation_suffix);
printf_unfiltered (("\n"));
}
if (linebuffer == 0)
{
linelength = 80;
linebuffer = (char *) xmalloc (linelength);
}
p = linebuffer;
if (more_to_come)
{
strcpy (linebuffer, readline_input_state.linebuffer);
p = readline_input_state.linebuffer_ptr;
xfree (readline_input_state.linebuffer);
more_to_come = 0;
}
#ifdef STOP_SIGNAL
if (job_control)
signal (STOP_SIGNAL, handle_stop_sig);
#endif
/* Make sure that all output has been output. Some machines may let
you get away with leaving out some of the gdb_flush, but not
all. */
wrap_here ("");
gdb_flush (gdb_stdout);
gdb_flush (gdb_stderr);
if (source_file_name != NULL)
++source_line_number;
/* If we are in this case, then command_handler will call quit
and exit from gdb. */
if (!rl || rl == (char *) EOF)
{
command_handler (0);
return; /* Lint. */
}
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;
/* Copy line. Don't copy null at end. (Leaves line alone
if this was just a newline). */
while (*p1)
*p++ = *p1++;
xfree (rl); /* Allocated in readline. */
if (p > linebuffer && *(p - 1) == '\\')
{
*p = '\0';
p--; /* Put on top of '\'. */
readline_input_state.linebuffer = xstrdup (linebuffer);
readline_input_state.linebuffer_ptr = p;
/* We will not invoke a execute_command if there is more
input expected to complete the command. So, we need to
print an empty prompt here. */
more_to_come = 1;
display_gdb_prompt ("");
return;
}
#ifdef STOP_SIGNAL
if (job_control)
signal (STOP_SIGNAL, SIG_DFL);
#endif
#define SERVER_COMMAND_LENGTH 7
server_command =
(p - linebuffer > SERVER_COMMAND_LENGTH)
&& strncmp (linebuffer, "server ", SERVER_COMMAND_LENGTH) == 0;
if (server_command)
{
/* Note that we don't set `line'. Between this and the check in
dont_repeat, this insures that repeating will still do the
right thing. */
*p = '\0';
command_handler (linebuffer + SERVER_COMMAND_LENGTH);
display_gdb_prompt (0);
return;
}
/* Do history expansion if that is wished. */
if (history_expansion_p && instream == stdin
&& ISATTY (instream))
{
char *history_value;
int expanded;
*p = '\0'; /* Insert null now. */
expanded = history_expand (linebuffer, &history_value);
if (expanded)
{
/* Print the changes. */
printf_unfiltered ("%s\n", history_value);
/* If there was an error, call this function again. */
if (expanded < 0)
{
xfree (history_value);
return;
}
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 we just got an empty line, and that is supposed to repeat the
previous command, return the value in the global buffer. */
if (repeat && p == linebuffer && *p != '\\')
{
command_handler (saved_command_line);
display_gdb_prompt (0);
return;
}
for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++);
if (repeat && !*p1)
{
command_handler (saved_command_line);
display_gdb_prompt (0);
return;
}
*p = 0;
/* Add line to history if appropriate. */
if (*linebuffer && input_from_terminal_p ())
add_history (linebuffer);
/* Note: lines consisting solely of comments are added to the command
history. This is useful when you type a command, and then
realize you don't want to execute it quite yet. You can comment
out the command and then later fetch it from the value history
and remove the '#'. The kill ring is probably better, but some
people are in the habit of commenting things out. */
if (*p1 == '#')
*p1 = '\0'; /* Found a comment. */
/* Save into global buffer if appropriate. */
if (repeat)
{
if (linelength > saved_command_line_size)
{
saved_command_line = xrealloc (saved_command_line, linelength);
saved_command_line_size = linelength;
}
strcpy (saved_command_line, linebuffer);
if (!more_to_come)
{
command_handler (saved_command_line);
display_gdb_prompt (0);
}
return;
}
command_handler (linebuffer);
display_gdb_prompt (0);
return;
}
