void
async_enable_stdin (void *dummy)
{
/* See NOTE in async_disable_stdin() */
/* FIXME: cagney/1999-09-27: Call this before clearing
sync_execution. Current target_terminal_ours() implementations
check for sync_execution before switching the terminal. */
target_terminal_ours ();
pop_prompt ();
sync_execution = 0;
}
void
async_enable_stdin (void *dummy)
{
if (stdin_enabled)
return;
stdin_enabled = 1;
/* See NOTE in async_disable_stdin() */
/* FIXME: cagney/1999-09-27: Call this before clearing
sync_execution. Current target_terminal_ours() implementations
check for sync_execution before switching the terminal. */
target_terminal_ours ();
pop_prompt ();
/* This is bogus... We shouldn't have to lie about the type of
execution in order to implement the terminal_ours...
sync_execution = 0;
*/
}
/* Called by do_setshow_command. */
void
set_async_prompt (char *args, int from_tty, struct cmd_list_element *c)
{
/* APPLE LOCAL begin Inform user about debugging optimized code */
if (currently_inside_optimized_code
&& the_prompts.top > 0
&& (strstr (PROMPT (0), "[opt> ") != 0))
{
char *new_str;
pop_prompt ();
PROMPT (0) = savestring (new_async_prompt, strlen (new_async_prompt));
new_str = (char *) xmalloc (strlen (new_async_prompt) + 7);
sprintf (new_str, "%s[opt> ", new_async_prompt);
push_prompt ("", new_str, "");
xfree (new_str);
}
else
/* APPLE LOCAL end Inform user about debugging optimized code */
PROMPT (0) = savestring (new_async_prompt, strlen (new_async_prompt));
}
/* Used when the user requests a different annotation level, with
'set annotate'. It pushes a new prompt (with prefix and suffix) on top
of the prompt stack, if the annotation level desired is 2, otherwise
it pops the top of the prompt stack when we want the annotation level
to be the normal ones (1 or 0). */
static void
change_annotation_level (void)
{
char *prefix, *suffix;
if (!PREFIX (0) || !PROMPT (0) || !SUFFIX (0))
{
/* The prompt stack has not been initialized to "", we are
using gdb w/o the --async switch */
warning (_("Command has same effect as set annotate"));
return;
}
if (annotation_level > 1)
{
if (!strcmp (PREFIX (0), "") && !strcmp (SUFFIX (0), ""))
{
/* Push a new prompt if the previous annotation_level was not >1. */
prefix = (char *) alloca (strlen (async_annotation_suffix) + 10);
strcpy (prefix, "\n\032\032pre-");
strcat (prefix, async_annotation_suffix);
strcat (prefix, "\n");
suffix = (char *) alloca (strlen (async_annotation_suffix) + 6);
strcpy (suffix, "\n\032\032");
strcat (suffix, async_annotation_suffix);
strcat (suffix, "\n");
push_prompt (prefix, (char *) 0, suffix);
}
}
else
{
if (strcmp (PREFIX (0), "") && strcmp (SUFFIX (0), ""))
{
/* Pop the top of the stack, we are going back to annotation < 1. */
pop_prompt ();
}
}
}
/* 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;
extern char *line;
extern int linesize;
char *nline;
char got_eof = 0;
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;
pop_prompt ();
}
#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)
{
got_eof = 1;
command_handler (0);
}
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--; /* Put on top of '\'. */
readline_input_state.linebuffer = savestring (linebuffer,
strlen (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;
push_prompt ("", "", "");
display_gdb_prompt (0);
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 (line);
display_gdb_prompt (0);
return;
}
for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++);
if (repeat && !*p1)
{
command_handler (line);
display_gdb_prompt (0);
return;
}
*p = 0;
/* Add line to history if appropriate. */
if (instream == stdin
&& ISATTY (stdin) && *linebuffer)
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 > linesize)
{
line = xrealloc (line, linelength);
linesize = linelength;
}
strcpy (line, linebuffer);
if (!more_to_come)
{
command_handler (line);
display_gdb_prompt (0);
}
return;
}
command_handler (linebuffer);
display_gdb_prompt (0);
return;
}