GDB 7.6.50

gdb/event-loop.c

 /* Event loop machinery for GDB, the GNU debugger.
-   Copyright (C) 1999-2002, 2005-2012 Free Software Foundation, Inc.
+   Copyright (C) 1999-2013 Free Software Foundation, Inc.
    Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "event-loop.h"
 #include "event-top.h"
+#include "queue.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 "gdb_string.h"
+#include <string.h>
 #include <errno.h>
 #include <sys/time.h>
 #include "exceptions.h"
 #include "gdb_assert.h"
 #include "gdb_select.h"
 
 /* Tell create_file_handler what events we are interested in.
    This is used by the select version of the event loop.  */
 
 #define GDB_READABLE    (1<<1)
@@ skipping 17 matching lines @@
    be called.  We have 2 queues, one for file handlers that we listen
    to in the event loop, and one for the file handlers+events that are
    ready.  The procedure PROC associated with each event is dependant
    of the event source.  In the case of monitored file descriptors, it
    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 and such.  In the
    case of async signal handlers, it is
    invoke_async_signal_handler.  */
 
-struct gdb_event
+typedef struct gdb_event
   {
     /* Procedure to call to service this event.  */
     event_handler_func *proc;
 
     /* Data to pass to the event handler.  */
     event_data data;
-
-    /* Next in list of events or NULL.  */
-    struct gdb_event *next_event;
-  };
+  } *gdb_event_p;
 
 /* Information about each file descriptor we register with the event
    loop.  */
 
 typedef struct file_handler
   {
     int fd;                     /* File descriptor.  */
     int mask;                   /* Events we want to monitor: POLLIN, etc.  */
     int ready_mask;             /* Events that have been seen since
                                    the last time.  */
@@ skipping 41 matching lines @@
     struct async_event_handler *next_handler;
 
     /* Function to call to do the work.  */
     async_event_handler_func *proc;
 
     /* Argument to PROC.  */
     gdb_client_data client_data;
   }
 async_event_handler;
 
-
-/* Event queue:  
-   - the first event in the queue is the head of the queue.
-   It will be the next to be serviced.
-   - the last event in the queue 
-
-   Events can be inserted at the front of the queue or at the end of
-   the queue.  Events will be extracted from the queue for processing
-   starting from the head.  Therefore, events inserted at the head of
-   the queue will be processed in a last in first out fashion, while
-   those inserted at the tail of the queue will be processed in a first
-   in first out manner.  All the fields are NULL if the queue is
-   empty.  */
-
-static struct
-  {
-    gdb_event *first_event;     /* First pending event.  */
-    gdb_event *last_event;      /* Last pending event.  */
-  }
-event_queue;
+DECLARE_QUEUE_P(gdb_event_p);
+DEFINE_QUEUE_P(gdb_event_p);
+static QUEUE(gdb_event_p) *event_queue = NULL;
 
 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
    These are the input file descriptor, and the target file
    descriptor.  We have two flavors of the notifier, one for platforms
    that have the POLL function, the other for those that don't, and
    only support SELECT.  Each of the elements in the gdb_notifier list is
    basically a description of what kind of events gdb is interested
    in, for each fd.  */
 
 /* As of 1999-04-30 only the input file descriptor is registered with the
@@ skipping 91 matching lines @@
     async_event_handler *last_handler;
   }
 async_event_handler_list;
 
 static int invoke_async_signal_handlers (void);
 static void create_file_handler (int fd, int mask, handler_func *proc,
                                  gdb_client_data client_data);
 static void handle_file_event (event_data data);
 static void check_async_event_handlers (void);
 static int gdb_wait_for_event (int);