/* NOTE: 1999-04-30 This is the asynchronous version of the command_loop function. The command_loop function will be obsolete when we switch to use the event loop at every execution of gdb. */ static void command_handler (char *command) { int stdin_is_tty = ISATTY (stdin); struct cleanup *stat_chain; clear_quit_flag (); if (instream == stdin && stdin_is_tty) reinitialize_more_filter (); /* If readline returned a NULL command, it means that the connection with the terminal is gone. This happens at the end of a testsuite run, after Expect has hung up but GDB is still alive. In such a case, we just quit gdb killing the inferior program too. */ if (command == 0) { printf_unfiltered ("quit\n"); execute_command ("quit", stdin == instream); } stat_chain = make_command_stats_cleanup (1); execute_command (command, instream == stdin); /* Do any commands attached to breakpoint we stopped at. */ bpstat_do_actions (); do_cleanups (stat_chain); }
/* Do any commands attached to breakpoint we stopped at. Only if we are always running synchronously. Or if we have just executed a command that doesn't start the target. */ void command_line_handler_continuation (struct continuation_arg *arg) { extern int display_time; extern int display_space; long time_at_cmd_start = arg->data.longint; long space_at_cmd_start = arg->next->data.longint; bpstat_do_actions (&stop_bpstat); /*do_cleanups (old_chain); *//*?????FIXME????? */ 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 command_handler (char *command) { struct cleanup *stat_chain; char *c; clear_quit_flag (); if (instream == stdin) reinitialize_more_filter (); stat_chain = make_command_stats_cleanup (1); /* Do not execute commented lines. */ for (c = command; *c == ' ' || *c == '\t'; c++) ; if (c[0] != '#') { execute_command (command, instream == stdin); /* Do any commands attached to breakpoint we stopped at. */ bpstat_do_actions (); } do_cleanups (stat_chain); }
static SCM gdbscm_execute_gdb_command (SCM command_scm, SCM rest) { int from_tty_arg_pos = -1, to_string_arg_pos = -1; int from_tty = 0, to_string = 0; volatile struct gdb_exception except; const SCM keywords[] = { from_tty_keyword, to_string_keyword, SCM_BOOL_F }; char *command; char *result = NULL; struct cleanup *cleanups; gdbscm_parse_function_args (FUNC_NAME, SCM_ARG1, keywords, "s#tt", command_scm, &command, rest, &from_tty_arg_pos, &from_tty, &to_string_arg_pos, &to_string); /* Note: The contents of "command" may get modified while it is executed. */ cleanups = make_cleanup (xfree, command); TRY_CATCH (except, RETURN_MASK_ALL) { struct cleanup *inner_cleanups; inner_cleanups = make_cleanup_restore_integer (&interpreter_async); interpreter_async = 0; prevent_dont_repeat (); if (to_string) result = execute_command_to_string (command, from_tty); else { execute_command (command, from_tty); result = NULL; } /* Do any commands attached to breakpoint we stopped at. */ bpstat_do_actions (); do_cleanups (inner_cleanups); } do_cleanups (cleanups); GDBSCM_HANDLE_GDB_EXCEPTION (except); if (result) { SCM r = gdbscm_scm_from_c_string (result); xfree (result); return r; } return SCM_UNSPECIFIED; }
void inferior_event_handler (enum inferior_event_type event_type, gdb_client_data client_data) { switch (event_type) { case INF_REG_EVENT: fetch_inferior_event (client_data); break; case INF_EXEC_COMPLETE: if (!non_stop) { /* Unregister the inferior from the event loop. This is done so that when the inferior is not running we don't get distracted by spurious inferior output. */ if (target_has_execution && target_can_async_p ()) target_async (0); } /* Do all continuations associated with the whole inferior (not a particular thread). */ if (!ptid_equal (inferior_ptid, null_ptid)) do_all_inferior_continuations (0); /* When running a command list (from a user command, say), these are only run when the command list is all done. */ if (interpreter_async) { check_frame_language_change (); /* Don't propagate breakpoint commands errors. Either we're stopping or some command resumes the inferior. The user will be informed. */ TRY { bpstat_do_actions (); } CATCH (e, RETURN_MASK_ALL) { exception_print (gdb_stderr, e); } END_CATCH } break; default: printf_unfiltered (_("Event type not recognized.\n")); break; }
void command_handler (const char *command) { struct ui *ui = current_ui; const char *c; if (ui->instream == ui->stdin_stream) reinitialize_more_filter (); scoped_command_stats stat_reporter (true); /* Do not execute commented lines. */ for (c = command; *c == ' ' || *c == '\t'; c++) ; if (c[0] != '#') { execute_command (command, ui->instream == ui->stdin_stream); /* Do any commands attached to breakpoint we stopped at. */ bpstat_do_actions (); } }
/* General function to handle events in the inferior. So far it just takes care of detecting errors reported by select() or poll(), otherwise it assumes that all is OK, and goes on reading data from the fd. This however may not always be what we want to do. */ void inferior_event_handler (enum inferior_event_type event_type, gdb_client_data client_data) { struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup (); switch (event_type) { case INF_REG_EVENT: /* Use catch errors for now, until the inner layers of fetch_inferior_event (i.e. readchar) can return meaningful error status. If an error occurs while getting an event from the target, just cancel the current command. */ if (!catch_errors (fetch_inferior_event_wrapper, client_data, "", RETURN_MASK_ALL)) { bpstat_clear_actions (); do_all_intermediate_continuations (1); do_all_continuations (1); async_enable_stdin (); display_gdb_prompt (0); } break; case INF_EXEC_COMPLETE: if (!non_stop) { /* Unregister the inferior from the event loop. This is done so that when the inferior is not running we don't get distracted by spurious inferior output. */ if (target_has_execution) target_async (NULL, 0); } /* Do all continuations associated with the whole inferior (not a particular thread). */ if (!ptid_equal (inferior_ptid, null_ptid)) do_all_inferior_continuations (0); /* If we were doing a multi-step (eg: step n, next n), but it got interrupted by a breakpoint, still do the pending continuations. The continuation itself is responsible for distinguishing the cases. The continuations are allowed to touch the inferior memory, e.g. to remove breakpoints, so run them before running breakpoint commands, which may resume the target. */ if (non_stop && target_has_execution && !ptid_equal (inferior_ptid, null_ptid)) do_all_intermediate_continuations_thread (inferior_thread (), 0); else do_all_intermediate_continuations (0); /* Always finish the previous command before running any breakpoint commands. Any stop cancels the previous command. E.g. a "finish" or "step-n" command interrupted by an unrelated breakpoint is canceled. */ if (non_stop && target_has_execution && !ptid_equal (inferior_ptid, null_ptid)) do_all_continuations_thread (inferior_thread (), 0); else do_all_continuations (0); /* When running a command list (from a user command, say), these are only run when the command list is all done. */ if (interpreter_async) { volatile struct gdb_exception e; check_frame_language_change (); /* Don't propagate breakpoint commands errors. Either we're stopping or some command resumes the inferior. The user will be informed. */ TRY_CATCH (e, RETURN_MASK_ALL) { bpstat_do_actions (); } exception_print (gdb_stderr, e); } break; case INF_EXEC_CONTINUE: /* Is there anything left to do for the command issued to complete? */ if (non_stop) do_all_intermediate_continuations_thread (inferior_thread (), 0); else do_all_intermediate_continuations (0); break; case INF_TIMER: default: printf_unfiltered (_("Event type not recognized.\n")); break; } discard_cleanups (cleanup_if_error); }
/* General function to handle events in the inferior. So far it just takes care of detecting errors reported by select() or poll(), otherwise it assumes that all is OK, and goes on reading data from the fd. This however may not always be what we want to do. */ void inferior_event_handler (enum inferior_event_type event_type, gdb_client_data client_data) { struct gdb_exception e; int was_sync = 0; switch (event_type) { case INF_ERROR: printf_unfiltered (_("error detected from target.\n")); pop_all_targets_above (file_stratum, 0); discard_all_intermediate_continuations (); discard_all_continuations (); async_enable_stdin (); break; case INF_REG_EVENT: /* Use catch errors for now, until the inner layers of fetch_inferior_event (i.e. readchar) can return meaningful error status. If an error occurs while getting an event from the target, just get rid of the target. */ if (!catch_errors (fetch_inferior_event_wrapper, client_data, "", RETURN_MASK_ALL)) { pop_all_targets_above (file_stratum, 0); discard_all_intermediate_continuations (); discard_all_continuations (); async_enable_stdin (); display_gdb_prompt (0); } break; case INF_EXEC_COMPLETE: if (!non_stop) { /* Unregister the inferior from the event loop. This is done so that when the inferior is not running we don't get distracted by spurious inferior output. */ if (target_has_execution) target_async (NULL, 0); } /* The call to async_enable_stdin below resets 'sync_execution'. However, if sync_execution is 1 now, we also need to show the prompt below, so save the current value. */ was_sync = sync_execution; async_enable_stdin (); /* Do all continuations associated with the whole inferior (not a particular thread). */ if (!ptid_equal (inferior_ptid, null_ptid)) do_all_inferior_continuations (); /* If we were doing a multi-step (eg: step n, next n), but it got interrupted by a breakpoint, still do the pending continuations. The continuation itself is responsible for distinguishing the cases. The continuations are allowed to touch the inferior memory, e.g. to remove breakpoints, so run them before running breakpoint commands, which may resume the target. */ if (non_stop && target_has_execution && !ptid_equal (inferior_ptid, null_ptid)) do_all_intermediate_continuations_thread (inferior_thread ()); else do_all_intermediate_continuations (); /* Always finish the previous command before running any breakpoint commands. Any stop cancels the previous command. E.g. a "finish" or "step-n" command interrupted by an unrelated breakpoint is canceled. */ if (non_stop && target_has_execution && !ptid_equal (inferior_ptid, null_ptid)) do_all_continuations_thread (inferior_thread ()); else do_all_continuations (); if (current_language != expected_language && language_mode == language_mode_auto) language_info (1); /* Print what changed. */ /* Don't propagate breakpoint commands errors. Either we're stopping or some command resumes the inferior. The user will be informed. */ TRY_CATCH (e, RETURN_MASK_ALL) { bpstat_do_actions (); } if (!was_sync && exec_done_display_p && (ptid_equal (inferior_ptid, null_ptid) || !is_running (inferior_ptid))) printf_unfiltered (_("completed.\n")); break; case INF_EXEC_CONTINUE: /* Is there anything left to do for the command issued to complete? */ if (non_stop) do_all_intermediate_continuations_thread (inferior_thread ()); else do_all_intermediate_continuations (); break; case INF_QUIT_REQ: /* FIXME: ezannoni 1999-10-04. This call should really be a target vector entry, so that it can be used for any kind of targets. */ async_remote_interrupt_twice (NULL); break; case INF_TIMER: default: printf_unfiltered (_("Event type not recognized.\n")); break; } }
/* NOTE: 1999-04-30 This is the asynchronous version of the command_loop function. The command_loop function will be obsolete when we switch to use the event loop at every execution of gdb. */ static void command_handler (char *command) { struct cleanup *old_chain; int stdin_is_tty = ISATTY (stdin); struct continuation_arg *arg1; struct continuation_arg *arg2; long time_at_cmd_start; #ifdef HAVE_SBRK long space_at_cmd_start = 0; #endif extern int display_time; extern int display_space; quit_flag = 0; if (instream == stdin && stdin_is_tty) reinitialize_more_filter (); old_chain = make_cleanup (null_cleanup, 0); /* If readline returned a NULL command, it means that the connection with the terminal is gone. This happens at the end of a testsuite run, after Expect has hung up but GDB is still alive. In such a case, we just quit gdb killing the inferior program too. */ if (command == 0) quit_command ((char *) 0, stdin == instream); 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); /* Set things up for this function to be compete later, once the execution has completed, if we are doing an execution command, otherwise, just go ahead and finish. */ if (target_can_async_p () && target_executing) { arg1 = (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg)); arg2 = (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg)); arg1->next = arg2; arg2->next = NULL; arg1->data.longint = time_at_cmd_start; #ifdef HAVE_SBRK arg2->data.longint = space_at_cmd_start; #endif add_continuation (command_line_handler_continuation, arg1); } /* Do any commands attached to breakpoint we stopped at. Only if we are always running synchronously. Or if we have just executed a command that doesn't start the target. */ if (!target_can_async_p () || !target_executing) { 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 } } }
/* NOTE: 1999-04-30 This is the asynchronous version of the command_loop function. The command_loop function will be obsolete when we switch to use the event loop at every execution of gdb. */ static void command_handler (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; quit_flag = 0; if (instream == stdin && stdin_is_tty) reinitialize_more_filter (); /* If readline returned a NULL command, it means that the connection with the terminal is gone. This happens at the end of a testsuite run, after Expect has hung up but GDB is still alive. In such a case, we just quit gdb killing the inferior program too. */ if (command == 0) { printf_unfiltered ("quit\n"); execute_command ("quit", stdin == instream); } 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); /* Do any commands attached to breakpoint we stopped at. */ bpstat_do_actions (); 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 } }