/* Event loop machinery for GDB, the GNU debugger.
- Copyright 1999 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000, 2001, 2002, 2005, 2006, 2007
+ Free Software Foundation, Inc.
Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
-#include "top.h"
#include "event-loop.h"
#include "event-top.h"
#endif
#include <sys/types.h>
-#include <string.h>
+#include "gdb_string.h"
#include <errno.h>
-#include <setjmp.h>
#include <sys/time.h>
-
-/* Type of the mask arguments to select. */
-
-#ifndef HAVE_POLL
-#ifdef NO_FD_SET
-/* All this stuff below is not required if select is used as God(tm)
- intended, with the FD_* macros. Are there any implementations of
- select which don't have FD_SET and other standard FD_* macros? I
- don't think there are, but if I'm wrong, we need to catch them. */
-#error FD_SET must be defined if select function is to be used!
-
-#ifndef _AIX
-typedef long fd_mask;
-#endif
-#if defined(_IBMR2)
-#define SELECT_MASK void
-#else
-#define SELECT_MASK int
-#endif /* !_IBMR2 */
-
-/* Define "NBBY" (number of bits per byte) if it's not already defined. */
-
-#ifndef NBBY
-#define NBBY 8
-#endif
-
-/* Define the number of fd_masks in an fd_set */
-
-#ifndef FD_SETSIZE
-#ifdef OPEN_MAX
-#define FD_SETSIZE OPEN_MAX
-#else
-#define FD_SETSIZE 256
-#endif
-#endif
-#if !defined(howmany)
-#define howmany(x, y) (((x)+((y)-1))/(y))
-#endif
-#ifndef NFDBITS
-#define NFDBITS NBBY*sizeof(fd_mask)
-#endif
-#define MASK_SIZE howmany(FD_SETSIZE, NFDBITS)
-
-#endif /* NO_FD_SET */
-#endif /* !HAVE_POLL */
-
+#include "exceptions.h"
+#include "gdb_assert.h"
+#include "gdb_select.h"
typedef struct gdb_event gdb_event;
typedef void (event_handler_func) (int);
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
{
static unsigned char use_poll = USE_POLL;
+#ifdef USE_WIN32API
+#include <windows.h>
+#include <io.h>
+#endif
+
static struct
{
/* Ptr to head of file handler list. */
}
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. */
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 *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);
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
+int
gdb_do_one_event (void *data)
{
/* Any events already waiting in the queue? */
longer any event sources registered. */
while (1)
{
- int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
- if (result < 0)
+ int gdb_result;
+
+ gdb_result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
+ if (gdb_result < 0)
break;
- if (result == 0)
+
+ /* 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. */
+
+ if (gdb_result == 0)
{
/* FIXME: this should really be a call to a hook that is
interface specific, because interfaces can display the
prompt in their own way. */
display_gdb_prompt (0);
+ /* 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. */
}
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 (__FILE__, __LINE__,
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
if (use_poll)
#ifdef HAVE_POLL
create_file_handler (fd, POLLIN, proc, client_data);
#else
- internal_error ("event-loop.c : use_poll without HAVE_POLL");
+ internal_error (__FILE__, __LINE__,
+ _("use_poll without HAVE_POLL"));
#endif
}
else
file_ptr->ready_mask = 0;
file_ptr->next_file = gdb_notifier.first_file_handler;
gdb_notifier.first_file_handler = file_ptr;
- }
- file_ptr->proc = proc;
- file_ptr->client_data = client_data;
- file_ptr->mask = mask;
- if (use_poll)
- {
+ if (use_poll)
+ {
#ifdef HAVE_POLL
- gdb_notifier.num_fds++;
- if (gdb_notifier.poll_fds)
- gdb_notifier.poll_fds =
- (struct pollfd *) realloc (gdb_notifier.poll_fds,
- (gdb_notifier.num_fds) * sizeof (struct pollfd));
- else
- gdb_notifier.poll_fds =
- (struct pollfd *) xmalloc (sizeof (struct pollfd));
- (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd;
- (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask;
- (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
+ gdb_notifier.num_fds++;
+ if (gdb_notifier.poll_fds)
+ gdb_notifier.poll_fds =
+ (struct pollfd *) xrealloc (gdb_notifier.poll_fds,
+ (gdb_notifier.num_fds
+ * sizeof (struct pollfd)));
+ else
+ gdb_notifier.poll_fds =
+ (struct pollfd *) xmalloc (sizeof (struct pollfd));
+ (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd;
+ (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask;
+ (gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
#else
- internal_error ("event-loop.c : use_poll without HAVE_POLL");
+ internal_error (__FILE__, __LINE__,
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
- }
- else
- {
- if (mask & GDB_READABLE)
- FD_SET (fd, &gdb_notifier.check_masks[0]);
+ }
else
- FD_CLR (fd, &gdb_notifier.check_masks[0]);
+ {
+ if (mask & GDB_READABLE)
+ FD_SET (fd, &gdb_notifier.check_masks[0]);
+ else
+ FD_CLR (fd, &gdb_notifier.check_masks[0]);
- if (mask & GDB_WRITABLE)
- FD_SET (fd, &gdb_notifier.check_masks[1]);
- else
- FD_CLR (fd, &gdb_notifier.check_masks[1]);
+ if (mask & GDB_WRITABLE)
+ FD_SET (fd, &gdb_notifier.check_masks[1]);
+ else
+ FD_CLR (fd, &gdb_notifier.check_masks[1]);
- if (mask & GDB_EXCEPTION)
- FD_SET (fd, &gdb_notifier.check_masks[2]);
- else
- FD_CLR (fd, &gdb_notifier.check_masks[2]);
+ if (mask & GDB_EXCEPTION)
+ FD_SET (fd, &gdb_notifier.check_masks[2]);
+ else
+ FD_CLR (fd, &gdb_notifier.check_masks[2]);
- if (gdb_notifier.num_fds <= fd)
- gdb_notifier.num_fds = fd + 1;
+ if (gdb_notifier.num_fds <= fd)
+ gdb_notifier.num_fds = fd + 1;
+ }
}
+
+ file_ptr->proc = proc;
+ file_ptr->client_data = client_data;
+ file_ptr->mask = mask;
}
/* Remove the file descriptor FD from the list of monitored fd's:
j++;
}
}
- free (gdb_notifier.poll_fds);
+ xfree (gdb_notifier.poll_fds);
gdb_notifier.poll_fds = new_poll_fds;
gdb_notifier.num_fds--;
#else
- internal_error ("event-loop.c : use_poll without HAVE_POLL");
+ internal_error (__FILE__, __LINE__,
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
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
/* Work in progress. We may need to tell somebody what
kind of error we had. */
if (error_mask_returned & POLLHUP)
- printf_unfiltered ("Hangup detected on 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);
+ printf_unfiltered (_("Error detected on fd %d\n"), file_ptr->fd);
if (error_mask_returned & POLLNVAL)
- printf_unfiltered ("Invalid or non-`poll'able fd %d\n", file_ptr->fd);
+ printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"), file_ptr->fd);
file_ptr->error = 1;
}
else
file_ptr->error = 0;
#else
- internal_error ("event-loop.c : use_poll without HAVE_POLL");
+ internal_error (__FILE__, __LINE__,
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
else
{
if (file_ptr->ready_mask & GDB_EXCEPTION)
{
- printf_unfiltered ("Exception condition detected on fd %d\n", file_ptr->fd);
+ printf_unfiltered (_("Exception condition detected on fd %d\n"), file_ptr->fd);
file_ptr->error = 1;
}
else
/* Don't print anything if we get out of poll because of a
signal. */
if (num_found == -1 && errno != EINTR)
- perror_with_name ("Poll");
+ perror_with_name (("poll"));
#else
- internal_error ("event-loop.c : use_poll without HAVE_POLL");
+ internal_error (__FILE__, __LINE__,
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
else
gdb_notifier.ready_masks[0] = gdb_notifier.check_masks[0];
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.timeout_valid
- ? &gdb_notifier.select_timeout : NULL);
+ num_found = gdb_select (gdb_notifier.num_fds,
+ &gdb_notifier.ready_masks[0],
+ &gdb_notifier.ready_masks[1],
+ &gdb_notifier.ready_masks[2],
+ gdb_notifier.timeout_valid
+ ? &gdb_notifier.select_timeout : NULL);
/* Clear the masks after an error from select. */
if (num_found == -1)
FD_ZERO (&gdb_notifier.ready_masks[2]);
/* Dont print anything is we got a signal, let gdb handle it. */
if (errno != EINTR)
- perror_with_name ("Select");
+ perror_with_name (("select"));
}
}
file_ptr->ready_mask = (gdb_notifier.poll_fds + i)->revents;
}
#else
- internal_error ("event-loop.c : use_poll without HAVE_POLL");
+ internal_error (__FILE__, __LINE__,
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
else
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;
#ifdef HAVE_POLL
gdb_notifier.poll_timeout = delta.tv_sec * 1000;
#else
- internal_error ("event-loop.c : use_poll without HAVE_POLL");
+ internal_error (__FILE__, __LINE__,
+ _("use_poll without HAVE_POLL"));
#endif /* HAVE_POLL */
}
else
projects / deliverable / binutils-gdb.git / blobdiff