void start_event_loop (void) { /* Loop until there is nothing to do. This is the entry point to the event loop engine. gdb_do_one_event will process one event for each invocation. It blocks waiting for an event and then processes it. */ while (1) { int result = 0; TRY { result = gdb_do_one_event (); } CATCH (ex, RETURN_MASK_ALL) { exception_print (gdb_stderr, ex); /* If any exception escaped to here, we better enable stdin. Otherwise, any command that calls async_disable_stdin, and then throws, will leave stdin inoperable. */ async_enable_stdin (); /* If we long-jumped out of do_one_event, we probably didn't get around to resetting the prompt, which leaves readline in a messed-up state. Reset it here. */ current_ui->prompt_state = PROMPT_NEEDED; observer_notify_command_error (); /* This call looks bizarre, but it is required. If the user entered a command that caused an error, after_char_processing_hook won't be called from rl_callback_read_char_wrapper. Using a cleanup there won't work, since we want this function to be called after a new prompt is printed. */ if (after_char_processing_hook) (*after_char_processing_hook) (); /* Maybe better to set a flag to be checked somewhere as to whether display the prompt or not. */ } END_CATCH if (result < 0) break; }
/* 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 (); observer_notify_command_error (); } 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); }