#include "top.h"
#include "event-loop.h"
#include "event-top.h"
-#include "inferior.h" /* For fetch_inferior_event. */
#ifdef HAVE_POLL
#include <poll.h>
#else
int mask; /* Events we want to monitor: POLLIN, etc. */
int ready_mask; /* Events that have been seen since
the last time. */
- handler_func *proc; /* Procedure to call when fd is ready. */
+ handler_func *proc; /* Procedure to call when fd is ready. */
gdb_client_data client_data; /* Argument to pass to proc. */
- int error; /* Was an error detected on this fd? */
+ int error; /* Was an error detected on this fd? */
struct file_handler *next_file; /* Next registered file descriptor. */
}
file_handler;
int ready; /* If ready, call this handler from the main event loop,
using invoke_async_handler. */
struct async_signal_handler *next_handler; /* Ptr to next handler */
- sig_handler_func *proc; /* Function to call to do the work */
+ sig_handler_func *proc; /* Function to call to do the work */
gdb_client_data client_data; /* Argument to async_handler_func */
}
async_signal_handler;
/* Flag to tell whether the timeout struct should be used. */
int timeout_valid;
- }
+ }
gdb_notifier;
#endif /* HAVE_POLL */
struct timeval when;
int timer_id;
struct gdb_timer *next;
- timer_handler_func *proc; /* Function to call to do the work */
- gdb_client_data client_data; /* Argument to async_handler_func */
+ timer_handler_func *proc; /* Function to call to do the work */
+ gdb_client_data client_data; /* Argument to async_handler_func */
}
gdb_timer;
/* List of currently active timers. It is sorted in order of
- increasing timers.*/
+ increasing timers. */
static struct
{
/* Pointer to first in timer list. */
struct gdb_timer *first_timer;
- /* Length of timer list. */
+ /* Id of the last timer created. */
int num_timers;
}
timer_list;
function. */
static int async_handler_ready = 0;
-static void create_file_handler (int fd, int mask, handler_func *proc, gdb_client_data client_data);
+static void create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data);
static void invoke_async_signal_handler (void);
static void handle_file_event (int event_file_desc);
static int gdb_wait_for_event (void);
-static int gdb_do_one_event (void);
+static int gdb_do_one_event (void *data);
static int check_async_ready (void);
-static void async_queue_event (gdb_event *event_ptr, queue_position position);
-static gdb_event * create_file_event (int fd);
+static void async_queue_event (gdb_event * event_ptr, queue_position position);
+static gdb_event *create_file_event (int fd);
static int process_event (void);
static void handle_timer_event (int dummy);
static void poll_timers (void);
as last in first out. Event appended at the tail of the queue
will be processed first in first out. */
static void
-async_queue_event (gdb_event *event_ptr, queue_position position)
+async_queue_event (gdb_event * event_ptr, queue_position position)
{
if (position == TAIL)
{
/* Process one high level event. If nothing is ready at this time,
wait for something to happen (via gdb_wait_for_event), then process
- it. Returns 1 if something was done otherwise returns 0 (this can
- happen if there are no event sources to wait for). */
+ it. Returns >0 if something was done otherwise returns <0 (this
+ can happen if there are no event sources to wait for). If an error
+ occures catch_errors() which calls this function returns zero. */
+
static int
-gdb_do_one_event (void)
+gdb_do_one_event (void *data)
{
- int result = 0;
-
- while (1)
+ /* Any events already waiting in the queue? */
+ if (process_event ())
{
- if (!SET_TOP_LEVEL ())
- {
- /* Any events already waiting in the queue? */
- if (process_event ())
- {
- result = 1;
- break;
- }
-
- /* Are any timers that are ready? If so, put an event on the queue.*/
- poll_timers ();
-
- /* Wait for a new event. If gdb_wait_for_event returns -1,
- we should get out because this means that there are no
- event sources left. This will make the event loop stop,
- and the application exit. */
-
- result = gdb_wait_for_event ();
- if (result < 0)
- {
- result = 0;
- break;
- }
+ return 1;
+ }
+
+ /* Are any timers that are ready? If so, put an event on the queue. */
+ poll_timers ();
+
+ /* Wait for a new event. If gdb_wait_for_event returns -1,
+ we should get out because this means that there are no
+ event sources left. This will make the event loop stop,
+ and the application exit. */
+
+ if (gdb_wait_for_event () < 0)
+ {
+ return -1;
+ }
+
+ /* Handle any new events occurred while waiting. */
+ if (process_event ())
+ {
+ return 1;
+ }
+
+ /* If gdb_wait_for_event has returned 1, it means that one
+ event has been handled. We break out of the loop. */
+ return 1;
+}
- /* Handle any new events occurred while waiting. */
- if (process_event ())
- {
- result = 1;
- break;
- }
+/* Start up the event loop. This is the entry point to the event loop
+ from the command loop. */
- /* If gdb_wait_for_event has returned 1, it means that one
- event has been handled. We break out of the loop. */
- if (result)
- break;
- } /* end of if !set_top_level */
- else
+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, called via catch_errors()
+ will process one event for each invocation. It blocks waits for
+ an event and then processes it. >0 when an event is processed, 0
+ when catch_errors() caught an error and <0 when there are no
+ longer any event sources registered. */
+ while (1)
+ {
+ int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
+ if (result < 0)
+ break;
+ if (result == 0)
{
/* FIXME: this should really be a call to a hook that is
interface specific, because interfaces can display the
whether display the prompt or not. */
}
}
- return result;
-}
-\f
-
-/* Start up the event loop. This is the entry point to the event loop
- from the command loop. */
-void
-start_event_loop (void)
-{
- /* Loop until there is something to do. This is the entry point to
- the event loop engine. gdb_do_one_event will process one event
- for each invocation. It always returns 1, unless there are no
- more event sources registered. In this case it returns 0. */
- while (gdb_do_one_event () != 0)
- ;
/* We are done with the event loop. There are no more event sources
to listen to. So we exit GDB. */
doesn't have to know implementation details about the use of poll
vs. select. */
void
-add_file_handler (int fd, handler_func *proc, gdb_client_data client_data)
+add_file_handler (int fd, handler_func * proc, gdb_client_data client_data)
{
#ifdef HAVE_POLL
create_file_handler (fd, POLLIN, proc, client_data);
PROC is the procedure that will be called when an event occurs for
FD. CLIENT_DATA is the argument to pass to PROC. */
static void
-create_file_handler (int fd, int mask, handler_func *proc, gdb_client_data client_data)
+create_file_handler (int fd, int mask, handler_func * proc, gdb_client_data client_data)
{
file_handler *file_ptr;
}
/* It is a new file descriptor. Add it to the list. Otherwise, just
- change the data associated with it.*/
+ change the data associated with it. */
if (file_ptr == NULL)
{
file_ptr = (file_handler *) xmalloc (sizeof (file_handler));
if (error_mask_returned != 0)
{
/* Work in progress. We may need to tell somebody what
- kind of error we had. */
+ kind of error we had. */
/*if (error_mask_returned & POLLHUP)
- printf_unfiltered ("Hangup detected on fd %d\n", file_ptr->fd);
- if (error_mask_returned & POLLERR)
- printf_unfiltered ("Error detected on fd %d\n", file_ptr->fd);
- if (error_mask_returned & POLLNVAL)
- printf_unfiltered ("Invalid fd %d\n", file_ptr->fd);*/
+ printf_unfiltered ("Hangup detected on fd %d\n", file_ptr->fd);
+ if (error_mask_returned & POLLERR)
+ printf_unfiltered ("Error detected on fd %d\n", file_ptr->fd);
+ if (error_mask_returned & POLLNVAL)
+ printf_unfiltered ("Invalid fd %d\n", file_ptr->fd); */
file_ptr->error = 1;
- }
- else
+ }
+ else
file_ptr->error = 0;
#else /* ! HAVE_POLL */
if (file_ptr->ready_mask & GDB_EXCEPTION)
/* If there was a match, then call the handler. */
if (mask != 0)
- (*file_ptr->proc) (file_ptr->error, file_ptr->fd, file_ptr->client_data);
+ (*file_ptr->proc) (file_ptr->error, file_ptr->client_data);
break;
}
}
#ifdef HAVE_POLL
num_found =
- poll (gdb_notifier.poll_fds,
- (unsigned long) gdb_notifier.num_fds,
+ poll (gdb_notifier.poll_fds,
+ (unsigned long) gdb_notifier.num_fds,
gdb_notifier.timeout_valid ? gdb_notifier.timeout : -1);
/* Don't print anything if we get out of poll because of a
- signal.*/
+ signal. */
if (num_found == -1 && errno != EINTR)
perror_with_name ("Poll");
num_found = select (gdb_notifier.num_fds,
(SELECT_MASK *) & gdb_notifier.ready_masks[0],
(SELECT_MASK *) & gdb_notifier.ready_masks[MASK_SIZE],
- (SELECT_MASK *) & gdb_notifier.ready_masks[2 * MASK_SIZE],
- gdb_notifier.timeout_valid ? gdb_notifier.timeout : NULL);
+ (SELECT_MASK *) & gdb_notifier.ready_masks[2 * MASK_SIZE],
+ gdb_notifier.timeout_valid ? &gdb_notifier.timeout : NULL);
/* Clear the masks after an error from select. */
if (num_found == -1)
PROC is the function to call with CLIENT_DATA argument
whenever the handler is invoked. */
async_signal_handler *
-create_async_signal_handler (sig_handler_func *proc, gdb_client_data client_data)
+create_async_signal_handler (sig_handler_func * proc, gdb_client_data client_data)
{
async_signal_handler *async_handler_ptr;
some event. The caller of this function is the interrupt handler
associated with a signal. */
void
-mark_async_signal_handler (async_signal_handler *async_handler_ptr)
+mark_async_signal_handler (async_signal_handler * async_handler_ptr)
{
((async_signal_handler *) async_handler_ptr)->ready = 1;
async_handler_ready = 1;
/* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
Free the space allocated for it. */
void
-delete_async_signal_handler (async_signal_handler **async_handler_ptr)
+delete_async_signal_handler (async_signal_handler ** async_handler_ptr)
{
async_signal_handler *prev_ptr;
return async_handler_ready;
}
-/* FIXME: where does this function belong? */
-/* 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 (int error, gdb_client_data client_data, int fd)
-{
- if (error == 1)
- {
- printf_unfiltered ("error detected on fd %d\n", fd);
- delete_file_handler (fd);
- discard_all_continuations ();
- }
- else
- fetch_inferior_event (client_data);
-}
-
/* Create a timer that will expire in MILLISECONDS from now. When the
timer is ready, PROC will be executed. At creation, the timer is
aded to the timers queue. This queue is kept sorted in order of
- increasing timers. Return a handle to the timer struct.*/
+ increasing timers. Return a handle to the timer struct. */
int
-create_timer (int milliseconds, timer_handler_func *proc, gdb_client_data client_data)
+create_timer (int milliseconds, timer_handler_func * proc, gdb_client_data client_data)
{
struct gdb_timer *timer_ptr, *timer_index, *prev_timer;
struct timeval time_now, delta;
/* compute seconds */
delta.tv_sec = milliseconds / 1000;
/* compute microseconds */
- delta.tv_usec = (milliseconds % 1000) * 1000;
-
+ delta.tv_usec = (milliseconds % 1000) * 1000;
+
gettimeofday (&time_now, NULL);
timer_ptr = (struct gdb_timer *) xmalloc (sizeof (gdb_timer));
timer_ptr->when.tv_sec = time_now.tv_sec + delta.tv_sec;
timer_ptr->when.tv_usec = time_now.tv_usec + delta.tv_usec;
/* carry? */
- if (timer_ptr->when.tv_usec >= 1000000 )
+ if (timer_ptr->when.tv_usec >= 1000000)
{
timer_ptr->when.tv_sec += 1;
timer_ptr->when.tv_usec -= 1000000;
}
timer_ptr->proc = proc;
timer_ptr->client_data = client_data;
- timer_list.num_timers ++;
+ timer_list.num_timers++;
timer_ptr->timer_id = timer_list.num_timers;
/* Now add the timer to the timer queue, making sure it is sorted in
increasing order of expiration. */
- for (timer_index = timer_list.first_timer;
- timer_index != NULL;
+ for (timer_index = timer_list.first_timer;
+ timer_index != NULL;
timer_index = timer_index->next)
{
/* If the seconds field is greater or if it is the same, but the
microsecond field is greater. */
- if ((timer_index->when.tv_sec > timer_ptr->when.tv_sec) ||
+ if ((timer_index->when.tv_sec > timer_ptr->when.tv_sec) ||
((timer_index->when.tv_sec == timer_ptr->when.tv_sec)
&& (timer_index->when.tv_usec > timer_ptr->when.tv_usec)))
break;
}
-
+
if (timer_index == timer_list.first_timer)
{
timer_ptr->next = timer_list.first_timer;
}
else
{
- for (prev_timer = timer_list.first_timer;
- prev_timer->next != timer_index;
+ for (prev_timer = timer_list.first_timer;
+ prev_timer->next != timer_index;
prev_timer = prev_timer->next)
;
-
+
prev_timer->next = timer_ptr;
timer_ptr->next = timer_index;
}
/* When a timer event is put on the event queue, it will be handled by
this function. Just call the assiciated procedure and delete the
timer event from the event queue. Repeat this for each timer that
- has expired.*/
+ has expired. */
static void
handle_timer_event (int dummy)
{
struct timeval time_now;
struct gdb_timer *timer_ptr, *saved_timer;
-
+
gettimeofday (&time_now, NULL);
timer_ptr = timer_list.first_timer;
while (timer_ptr != NULL)
{
- if ((timer_ptr->when.tv_sec > time_now.tv_sec) ||
- ((timer_ptr->when.tv_sec == time_now.tv_sec) &&
+ if ((timer_ptr->when.tv_sec > time_now.tv_sec) ||
+ ((timer_ptr->when.tv_sec == time_now.tv_sec) &&
(timer_ptr->when.tv_usec > time_now.tv_usec)))
break;
saved_timer = timer_ptr;
timer_ptr = timer_ptr->next;
/* Call the procedure associated with that timer. */
- (*saved_timer->proc) (timer_ptr->client_data);
+ (*saved_timer->proc) (saved_timer->client_data);
free (saved_timer);
}
gdb_notifier.timeout_valid = 0;
}
-
+
/* Check whether any timers in the timers queue are ready. If at least
one timer is ready, stick an event onto the event queue. Even in
case more than one timer is ready, one event is enough, because the
handle_timer_event() will go through the timers list and call the
procedures associated with all that have expired. Update the
- timeout for the select() or poll() as well.*/
+ timeout for the select() or poll() as well. */
static void
poll_timers (void)
{
struct timeval time_now, delta;
gdb_event *event_ptr;
-
- if (timer_list.num_timers)
+
+ if (timer_list.first_timer != NULL)
{
gettimeofday (&time_now, NULL);
delta.tv_sec = timer_list.first_timer->when.tv_sec - time_now.tv_sec;
delta.tv_sec -= 1;
delta.tv_usec += 1000000;
}
-
+
/* Oops it expired already. Tell select / poll to return
- immediately. */
+ immediately. */
if (delta.tv_sec < 0)
{
delta.tv_sec = 0;
}
/* Now we need to update the timeout for select/ poll, because we
- don't want to sit there while this timer is expiring. */
+ don't want to sit there while this timer is expiring. */
#ifdef HAVE_POLL
- gdb_notifier.timeout = delta.tv_sec * 1000;
+ gdb_notifier.timeout = delta.tv_sec * 1000;
#else
- gdb_notifier.timeout.sec = delta.tv_sec;
- gdb_notifier.timeout.usec = delta.tv_usec;
+ gdb_notifier.timeout.tv_sec = delta.tv_sec;
+ gdb_notifier.timeout.tv_usec = delta.tv_usec;
#endif
gdb_notifier.timeout_valid = 1;
}
- else
+ else
gdb_notifier.timeout_valid = 0;
}
projects / deliverable / binutils-gdb.git / blobdiff