void async_disable_stdin (void) { if (!stdin_enabled) return; stdin_enabled = 0; /* Just don't do this... sync_execution = 1; */ push_prompt ("", "", ""); /* FIXME: cagney/1999-09-27: At present this call is technically redundant since infcmd.c and infrun.c both already call target_terminal_inferior(). As the terminal handling (in sync/async mode) is refined, the duplicate calls can be eliminated (Here or in infcmd.c/infrun.c). */ target_terminal_inferior (); /* Add the reinstate of stdin to the list of cleanups to be done in case the target errors out and dies. These cleanups are also done in case of normal successful termination of the execution command, by complete_execution(). */ make_exec_error_cleanup (async_enable_stdin, NULL); }
void async_disable_stdin (void) { if (!sync_execution) { sync_execution = 1; push_prompt ("", "", ""); } }
/* APPLE LOCAL begin Inform user about debugging optimized code */ void adjust_prompts_for_optimized_code (void) { /* Case 1: gdb_prompt_is_optimized == false. */ if (!gdb_prompt_is_optimized) { /* If we're inside optimized code AND the user wants to be told about it, append '[opt> ' to the prompt. Actually, create a second duplicate prompt, and append to that. This allows for easy removal later. */ if (dwarf2_inform_debugging_optimized_code && currently_inside_optimized_code) { char *old_prompt = get_prompt (); char *new_prompt; if (strstr (old_prompt, "[opt> ") == 0) { new_prompt = (char *) xmalloc (strlen (old_prompt) + 7); sprintf (new_prompt, "%s[opt> ", old_prompt); push_prompt ("", new_prompt, ""); xfree (new_prompt); } gdb_prompt_is_optimized = 1; } } /* Case 2: gdb_prompt_is_optimized == true. */ else if (gdb_prompt_is_optimized) { /* If we're not inside optimized code, or the user does not want to be told about it, pop the '[opt> ' version of the prompt from the prompt stack. */ if (!dwarf2_inform_debugging_optimized_code || !currently_inside_optimized_code) { if (the_prompts.top > 0 && strstr (PROMPT (0), "[opt> ") != 0) { xfree (PREFIX (0)); xfree (PROMPT (0)); xfree (SUFFIX (0)); the_prompts.top--; } gdb_prompt_is_optimized = 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; }