Merge GDB 7.5.1

gdb/serial.h

 /* Remote serial support interface definitions for GDB, the GNU Debugger.
    Copyright (C) 1992-1996, 1998-2001, 2004-2012 Free Software
    Foundation, Inc.
 
    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.
@@ skipping 19 matching lines @@
 /* For most routines, if a failure is indicated, then errno should be
    examined.  */
 
 /* Terminal state pointer.  This is specific to each type of
    interface.  */
 
 typedef void *serial_ttystate;
 struct serial;
 
 /* Try to open NAME.  Returns a new `struct serial *' on success, NULL
-   on failure.  Note that some open calls can block and, if possible, 
-   should be  written to be non-blocking, with calls to ui_look_hook 
-   so they can be cancelled.  An async interface for open could be
-   added to GDB if necessary.  */
+   on failure.  The new serial object has a reference count of 1.
+   Note that some open calls can block and, if possible, should be
+   written to be non-blocking, with calls to ui_look_hook so they can
+   be cancelled.  An async interface for open could be added to GDB if
+   necessary.  */
 
 extern struct serial *serial_open (const char *name);
 
+/* Returns true if SCB is open.  */
+
+extern int serial_is_open (struct serial *scb);
+
 /* Find an already opened serial stream using a file handle.  */
 
 extern struct serial *serial_for_fd (int fd);
 
 /* Open a new serial stream using a file handle.  */
 
 extern struct serial *serial_fdopen (const int fd);
 
-/* Push out all buffers, close the device and destroy SCB.  */
+/* Push out all buffers, close the device and unref SCB.  */
 
 extern void serial_close (struct serial *scb);
 
+/* Increment reference count of SCB.  */
+
+extern void serial_ref (struct serial *scb);
+
+/* Decrement reference count of SCB.  */
+
+extern void serial_unref (struct serial *scb);
+
 /* Create a pipe, and put the read end in files[0], and the write end
    in filde[1].  Returns 0 for success, negative value for error (in
    which case errno contains the error).  */
 
 extern int gdb_pipe (int fildes[2]);
 
 /* Create a pipe with each end wrapped in a `struct serial' interface.
    Put the read end in scbs[0], and the write end in scbs[1].  Returns
    0 for success, negative value for error (in which case errno
    contains the error).  */
@@ skipping 137 matching lines @@
 
 extern void serial_debug (struct serial *scb, int debug_p);
 
 extern int serial_debug_p (struct serial *scb);
 
 
 /* Details of an instance of a serial object.  */
 
 struct serial
   {
+    /* serial objects are ref counted (but not the underlying
+       connection, just the object's lifetime in memory).  */
+    int refcnt;
+
     int fd;                     /* File descriptor */
     /* File descriptor for a separate error stream that should be
        immediately forwarded to gdb_stderr.  This may be -1.
        If != -1, this descriptor should be non-blocking or
        ops->avail should be non-NULL.  */
     int error_fd;               
     struct serial_ops *ops;     /* Function vector */
     void *state;                /* Local context info for open FD */
     serial_ttystate ttystate;   /* Not used (yet) */
     int bufcnt;                 /* Amount of data remaining in receive
                                    buffer.  -ve for sticky errors.  */
     unsigned char *bufp;        /* Current byte */
     unsigned char buf[BUFSIZ];  /* Da buffer itself */
     int current_timeout;        /* (ser-unix.c termio{,s} only), last
                                    value of VTIME */
     int timeout_remaining;      /* (ser-unix.c termio{,s} only), we
                                    still need to wait for this many
                                    more seconds.  */
     char *name;                 /* The name of the device or host */
     struct serial *next;        /* Pointer to the next `struct serial *' */
-    int refcnt;                 /* Number of pointers to this block */
     int debug_p;                /* Trace this serial devices operation.  */
     int async_state;            /* Async internal state.  */
     void *async_context;        /* Async event thread's context */
     serial_event_ftype *async_handler;/* Async event handler */
   };
 
 struct serial_ops
   {
     char *name;
     struct serial_ops *next;
@@ skipping 57 matching lines @@
 /* Windows-only: find or create handles that we can wait on for this
    serial device.  */
 extern void serial_wait_handle (struct serial *, HANDLE *, HANDLE *);
 
 /* Windows-only: signal that we are done with the wait handles.  */
 extern void serial_done_wait_handle (struct serial *);
 
 #endif /* USE_WIN32API */
 
 #endif /* SERIAL_H */