#include "top.h"
#include "event-loop.h"
#include "event-top.h"
+
#ifdef HAVE_POLL
+#if defined (HAVE_POLL_H)
#include <poll.h>
+#elif defined (HAVE_SYS_POLL_H)
+#include <sys/poll.h>
+#endif
#endif
+
#include <sys/types.h>
#include <string.h>
#include <errno.h>
ready. The procedure PROC associated with each event is always the
same (handle_file_event). Its duty is to invoke the handler
associated with the file descriptor whose state change generated
- the event, plus doing other cleanups adn such. */
+ the event, plus doing other cleanups and such. */
struct gdb_event
{
}
sighandler_list;
-/* Is any of the handlers ready? Check this variable using
+/* Are any of the handlers ready? Check this variable using
check_async_ready. This is used by process_event, to determine
whether or not to invoke the invoke_async_signal_handler
function. */
if (event_ptr->next_event == NULL)
event_queue.last_event = prev_ptr;
}
- free ((char *) event_ptr);
+ xfree (event_ptr);
/* Now call the procedure associated with the event. */
(*proc) (fd);
wait for something to happen (via gdb_wait_for_event), then process
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. */
+ occurs catch_errors() which calls this function returns zero. */
static int
gdb_do_one_event (void *data)
{
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;
{
#ifdef HAVE_POLL
/* Check to see if poll () is usable. If not, we'll switch to
- use select. This can happen on systems like
- m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
- On m68k-motorola-sysv, tty's are not stream-based and not
- `poll'able.*/
- fds.fd = fd;
- fds.events = POLLIN;
- if (poll (&fds, 1, 0) == 1 && (fds.revents & POLLNVAL))
- use_poll = 0;
+ use select. This can happen on systems like
+ m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
+ On m68k-motorola-sysv, tty's are not stream-based and not
+ `poll'able. */
+ fds.fd = fd;
+ fds.events = POLLIN;
+ if (poll (&fds, 1, 0) == 1 && (fds.revents & POLLNVAL))
+ use_poll = 0;
#else
- internal_error ("event-loop.c : use_poll without HAVE_POLL");
+ internal_error ("event-loop.c : use_poll without HAVE_POLL");
#endif /* HAVE_POLL */
}
if (use_poll)
if (gdb_notifier.poll_fds)
gdb_notifier.poll_fds =
(struct pollfd *) realloc (gdb_notifier.poll_fds,
- (gdb_notifier.num_fds) * sizeof (struct pollfd));
+ (gdb_notifier.num_fds) * sizeof (struct pollfd));
else
gdb_notifier.poll_fds =
(struct pollfd *) xmalloc (sizeof (struct pollfd));
{
#ifdef HAVE_POLL
/* Create a new poll_fds array by copying every fd's information but the
- one we want to get rid of. */
+ one we want to get rid of. */
new_poll_fds =
(struct pollfd *) xmalloc ((gdb_notifier.num_fds - 1) * sizeof (struct pollfd));
j++;
}
}
- free (gdb_notifier.poll_fds);
+ xfree (gdb_notifier.poll_fds);
gdb_notifier.poll_fds = new_poll_fds;
gdb_notifier.num_fds--;
#else
;
prev_ptr->next_file = file_ptr->next_file;
}
- free ((char *) file_ptr);
+ xfree (file_ptr);
}
/* Handle the given event by calling the procedure associated to the
else
file_ptr->error = 0;
#else
- internal_error ("event-loop.c : use_poll without HAVE_POLL");
+ internal_error ("event-loop.c : use_poll without HAVE_POLL");
#endif /* HAVE_POLL */
}
else
gdb_notifier.timeout_valid ? gdb_notifier.poll_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");
#else
gdb_notifier.ready_masks[1] = gdb_notifier.check_masks[1];
gdb_notifier.ready_masks[2] = gdb_notifier.check_masks[2];
num_found = select (gdb_notifier.num_fds,
- & gdb_notifier.ready_masks[0],
- & gdb_notifier.ready_masks[1],
- & gdb_notifier.ready_masks[2],
+ &gdb_notifier.ready_masks[0],
+ &gdb_notifier.ready_masks[1],
+ &gdb_notifier.ready_masks[2],
gdb_notifier.timeout_valid
? &gdb_notifier.select_timeout : NULL);
if (file_ptr)
{
/* Enqueue an event only if this is still a new event for
- this fd. */
+ this fd. */
if (file_ptr->ready_mask == 0)
{
file_event_ptr = create_file_event (file_ptr->fd);
if (sighandler_list.last_handler == (*async_handler_ptr))
sighandler_list.last_handler = prev_ptr;
}
- free ((char *) (*async_handler_ptr));
+ xfree ((*async_handler_ptr));
(*async_handler_ptr) = NULL;
}
;
prev_timer->next = timer_ptr->next;
}
- free ((char *) timer_ptr);
+ xfree (timer_ptr);
gdb_notifier.timeout_valid = 0;
}
timer_ptr = timer_ptr->next;
/* Call the procedure associated with that timer. */
(*saved_timer->proc) (saved_timer->client_data);
- free (saved_timer);
+ xfree (saved_timer);
}
gdb_notifier.timeout_valid = 0;
/* Oops it expired already. Tell select / poll to return
immediately. (Cannot simply test if delta.tv_sec is negative
- because time_t might be unsigned.) */
+ because time_t might be unsigned.) */
if (timer_list.first_timer->when.tv_sec < time_now.tv_sec
|| (timer_list.first_timer->when.tv_sec == time_now.tv_sec
&& timer_list.first_timer->when.tv_usec < time_now.tv_usec))