OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [ser-mingw.c] - Diff between revs 834 and 842

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 834 Rev 842
/* Serial interface for local (hardwired) serial ports on Windows systems
/* Serial interface for local (hardwired) serial ports on Windows systems
 
 
   Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 
 
   This file is part of GDB.
   This file is part of GDB.
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
#include "defs.h"
#include "defs.h"
#include "serial.h"
#include "serial.h"
#include "ser-base.h"
#include "ser-base.h"
#include "ser-tcp.h"
#include "ser-tcp.h"
 
 
#include <windows.h>
#include <windows.h>
#include <conio.h>
#include <conio.h>
 
 
#include <fcntl.h>
#include <fcntl.h>
#include <unistd.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/types.h>
 
 
#include "gdb_assert.h"
#include "gdb_assert.h"
#include "gdb_string.h"
#include "gdb_string.h"
 
 
#include "command.h"
#include "command.h"
 
 
void _initialize_ser_windows (void);
void _initialize_ser_windows (void);
 
 
struct ser_windows_state
struct ser_windows_state
{
{
  int in_progress;
  int in_progress;
  OVERLAPPED ov;
  OVERLAPPED ov;
  DWORD lastCommMask;
  DWORD lastCommMask;
  HANDLE except_event;
  HANDLE except_event;
};
};
 
 
/* Open up a real live device for serial I/O.  */
/* Open up a real live device for serial I/O.  */
 
 
static int
static int
ser_windows_open (struct serial *scb, const char *name)
ser_windows_open (struct serial *scb, const char *name)
{
{
  HANDLE h;
  HANDLE h;
  struct ser_windows_state *state;
  struct ser_windows_state *state;
  COMMTIMEOUTS timeouts;
  COMMTIMEOUTS timeouts;
 
 
  h = CreateFile (name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
  h = CreateFile (name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
                  OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
                  OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
  if (h == INVALID_HANDLE_VALUE)
  if (h == INVALID_HANDLE_VALUE)
    {
    {
      errno = ENOENT;
      errno = ENOENT;
      return -1;
      return -1;
    }
    }
 
 
  scb->fd = _open_osfhandle ((intptr_t) h, O_RDWR);
  scb->fd = _open_osfhandle ((intptr_t) h, O_RDWR);
  if (scb->fd < 0)
  if (scb->fd < 0)
    {
    {
      errno = ENOENT;
      errno = ENOENT;
      return -1;
      return -1;
    }
    }
 
 
  if (!SetCommMask (h, EV_RXCHAR))
  if (!SetCommMask (h, EV_RXCHAR))
    {
    {
      errno = EINVAL;
      errno = EINVAL;
      return -1;
      return -1;
    }
    }
 
 
  timeouts.ReadIntervalTimeout = MAXDWORD;
  timeouts.ReadIntervalTimeout = MAXDWORD;
  timeouts.ReadTotalTimeoutConstant = 0;
  timeouts.ReadTotalTimeoutConstant = 0;
  timeouts.ReadTotalTimeoutMultiplier = 0;
  timeouts.ReadTotalTimeoutMultiplier = 0;
  timeouts.WriteTotalTimeoutConstant = 0;
  timeouts.WriteTotalTimeoutConstant = 0;
  timeouts.WriteTotalTimeoutMultiplier = 0;
  timeouts.WriteTotalTimeoutMultiplier = 0;
  if (!SetCommTimeouts (h, &timeouts))
  if (!SetCommTimeouts (h, &timeouts))
    {
    {
      errno = EINVAL;
      errno = EINVAL;
      return -1;
      return -1;
    }
    }
 
 
  state = xmalloc (sizeof (struct ser_windows_state));
  state = xmalloc (sizeof (struct ser_windows_state));
  memset (state, 0, sizeof (struct ser_windows_state));
  memset (state, 0, sizeof (struct ser_windows_state));
  scb->state = state;
  scb->state = state;
 
 
  /* Create a manual reset event to watch the input buffer.  */
  /* Create a manual reset event to watch the input buffer.  */
  state->ov.hEvent = CreateEvent (0, TRUE, FALSE, 0);
  state->ov.hEvent = CreateEvent (0, TRUE, FALSE, 0);
 
 
  /* Create a (currently unused) handle to record exceptions.  */
  /* Create a (currently unused) handle to record exceptions.  */
  state->except_event = CreateEvent (0, TRUE, FALSE, 0);
  state->except_event = CreateEvent (0, TRUE, FALSE, 0);
 
 
  return 0;
  return 0;
}
}
 
 
/* Wait for the output to drain away, as opposed to flushing (discarding)
/* Wait for the output to drain away, as opposed to flushing (discarding)
   it.  */
   it.  */
 
 
static int
static int
ser_windows_drain_output (struct serial *scb)
ser_windows_drain_output (struct serial *scb)
{
{
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 
 
  return (FlushFileBuffers (h) != 0) ? 0 : -1;
  return (FlushFileBuffers (h) != 0) ? 0 : -1;
}
}
 
 
static int
static int
ser_windows_flush_output (struct serial *scb)
ser_windows_flush_output (struct serial *scb)
{
{
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 
 
  return (PurgeComm (h, PURGE_TXCLEAR) != 0) ? 0 : -1;
  return (PurgeComm (h, PURGE_TXCLEAR) != 0) ? 0 : -1;
}
}
 
 
static int
static int
ser_windows_flush_input (struct serial *scb)
ser_windows_flush_input (struct serial *scb)
{
{
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 
 
  return (PurgeComm (h, PURGE_RXCLEAR) != 0) ? 0 : -1;
  return (PurgeComm (h, PURGE_RXCLEAR) != 0) ? 0 : -1;
}
}
 
 
static int
static int
ser_windows_send_break (struct serial *scb)
ser_windows_send_break (struct serial *scb)
{
{
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 
 
  if (SetCommBreak (h) == 0)
  if (SetCommBreak (h) == 0)
    return -1;
    return -1;
 
 
  /* Delay for 250 milliseconds.  */
  /* Delay for 250 milliseconds.  */
  Sleep (250);
  Sleep (250);
 
 
  if (ClearCommBreak (h))
  if (ClearCommBreak (h))
    return -1;
    return -1;
 
 
  return 0;
  return 0;
}
}
 
 
static void
static void
ser_windows_raw (struct serial *scb)
ser_windows_raw (struct serial *scb)
{
{
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  DCB state;
  DCB state;
 
 
  if (GetCommState (h, &state) == 0)
  if (GetCommState (h, &state) == 0)
    return;
    return;
 
 
  state.fParity = FALSE;
  state.fParity = FALSE;
  state.fOutxCtsFlow = FALSE;
  state.fOutxCtsFlow = FALSE;
  state.fOutxDsrFlow = FALSE;
  state.fOutxDsrFlow = FALSE;
  state.fDtrControl = DTR_CONTROL_ENABLE;
  state.fDtrControl = DTR_CONTROL_ENABLE;
  state.fDsrSensitivity = FALSE;
  state.fDsrSensitivity = FALSE;
  state.fOutX = FALSE;
  state.fOutX = FALSE;
  state.fInX = FALSE;
  state.fInX = FALSE;
  state.fNull = FALSE;
  state.fNull = FALSE;
  state.fAbortOnError = FALSE;
  state.fAbortOnError = FALSE;
  state.ByteSize = 8;
  state.ByteSize = 8;
  state.Parity = NOPARITY;
  state.Parity = NOPARITY;
 
 
  scb->current_timeout = 0;
  scb->current_timeout = 0;
 
 
  if (SetCommState (h, &state) == 0)
  if (SetCommState (h, &state) == 0)
    warning (_("SetCommState failed\n"));
    warning (_("SetCommState failed\n"));
}
}
 
 
static int
static int
ser_windows_setstopbits (struct serial *scb, int num)
ser_windows_setstopbits (struct serial *scb, int num)
{
{
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  DCB state;
  DCB state;
 
 
  if (GetCommState (h, &state) == 0)
  if (GetCommState (h, &state) == 0)
    return -1;
    return -1;
 
 
  switch (num)
  switch (num)
    {
    {
    case SERIAL_1_STOPBITS:
    case SERIAL_1_STOPBITS:
      state.StopBits = ONESTOPBIT;
      state.StopBits = ONESTOPBIT;
      break;
      break;
    case SERIAL_1_AND_A_HALF_STOPBITS:
    case SERIAL_1_AND_A_HALF_STOPBITS:
      state.StopBits = ONE5STOPBITS;
      state.StopBits = ONE5STOPBITS;
      break;
      break;
    case SERIAL_2_STOPBITS:
    case SERIAL_2_STOPBITS:
      state.StopBits = TWOSTOPBITS;
      state.StopBits = TWOSTOPBITS;
      break;
      break;
    default:
    default:
      return 1;
      return 1;
    }
    }
 
 
  return (SetCommState (h, &state) != 0) ? 0 : -1;
  return (SetCommState (h, &state) != 0) ? 0 : -1;
}
}
 
 
static int
static int
ser_windows_setbaudrate (struct serial *scb, int rate)
ser_windows_setbaudrate (struct serial *scb, int rate)
{
{
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  DCB state;
  DCB state;
 
 
  if (GetCommState (h, &state) == 0)
  if (GetCommState (h, &state) == 0)
    return -1;
    return -1;
 
 
  state.BaudRate = rate;
  state.BaudRate = rate;
 
 
  return (SetCommState (h, &state) != 0) ? 0 : -1;
  return (SetCommState (h, &state) != 0) ? 0 : -1;
}
}
 
 
static void
static void
ser_windows_close (struct serial *scb)
ser_windows_close (struct serial *scb)
{
{
  struct ser_windows_state *state;
  struct ser_windows_state *state;
 
 
  /* Stop any pending selects.  */
  /* Stop any pending selects.  */
  CancelIo ((HANDLE) _get_osfhandle (scb->fd));
  CancelIo ((HANDLE) _get_osfhandle (scb->fd));
  state = scb->state;
  state = scb->state;
  CloseHandle (state->ov.hEvent);
  CloseHandle (state->ov.hEvent);
  CloseHandle (state->except_event);
  CloseHandle (state->except_event);
 
 
  if (scb->fd < 0)
  if (scb->fd < 0)
    return;
    return;
 
 
  close (scb->fd);
  close (scb->fd);
  scb->fd = -1;
  scb->fd = -1;
 
 
  xfree (scb->state);
  xfree (scb->state);
}
}
 
 
static void
static void
ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
{
{
  struct ser_windows_state *state;
  struct ser_windows_state *state;
  COMSTAT status;
  COMSTAT status;
  DWORD errors;
  DWORD errors;
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
  HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
 
 
  state = scb->state;
  state = scb->state;
 
 
  *except = state->except_event;
  *except = state->except_event;
  *read = state->ov.hEvent;
  *read = state->ov.hEvent;
 
 
  if (state->in_progress)
  if (state->in_progress)
    return;
    return;
 
 
  /* Reset the mask - we are only interested in any characters which
  /* Reset the mask - we are only interested in any characters which
     arrive after this point, not characters which might have arrived
     arrive after this point, not characters which might have arrived
     and already been read.  */
     and already been read.  */
 
 
  /* This really, really shouldn't be necessary - just the second one.
  /* This really, really shouldn't be necessary - just the second one.
     But otherwise an internal flag for EV_RXCHAR does not get
     But otherwise an internal flag for EV_RXCHAR does not get
     cleared, and we get a duplicated event, if the last batch
     cleared, and we get a duplicated event, if the last batch
     of characters included at least two arriving close together.  */
     of characters included at least two arriving close together.  */
  if (!SetCommMask (h, 0))
  if (!SetCommMask (h, 0))
    warning (_("ser_windows_wait_handle: reseting mask failed"));
    warning (_("ser_windows_wait_handle: reseting mask failed"));
 
 
  if (!SetCommMask (h, EV_RXCHAR))
  if (!SetCommMask (h, EV_RXCHAR))
    warning (_("ser_windows_wait_handle: reseting mask failed (2)"));
    warning (_("ser_windows_wait_handle: reseting mask failed (2)"));
 
 
  /* There's a potential race condition here; we must check cbInQue
  /* There's a potential race condition here; we must check cbInQue
     and not wait if that's nonzero.  */
     and not wait if that's nonzero.  */
 
 
  ClearCommError (h, &errors, &status);
  ClearCommError (h, &errors, &status);
  if (status.cbInQue > 0)
  if (status.cbInQue > 0)
    {
    {
      SetEvent (state->ov.hEvent);
      SetEvent (state->ov.hEvent);
      return;
      return;
    }
    }
 
 
  state->in_progress = 1;
  state->in_progress = 1;
  ResetEvent (state->ov.hEvent);
  ResetEvent (state->ov.hEvent);
  state->lastCommMask = -2;
  state->lastCommMask = -2;
  if (WaitCommEvent (h, &state->lastCommMask, &state->ov))
  if (WaitCommEvent (h, &state->lastCommMask, &state->ov))
    {
    {
      gdb_assert (state->lastCommMask & EV_RXCHAR);
      gdb_assert (state->lastCommMask & EV_RXCHAR);
      SetEvent (state->ov.hEvent);
      SetEvent (state->ov.hEvent);
    }
    }
  else
  else
    gdb_assert (GetLastError () == ERROR_IO_PENDING);
    gdb_assert (GetLastError () == ERROR_IO_PENDING);
}
}
 
 
static int
static int
ser_windows_read_prim (struct serial *scb, size_t count)
ser_windows_read_prim (struct serial *scb, size_t count)
{
{
  struct ser_windows_state *state;
  struct ser_windows_state *state;
  OVERLAPPED ov;
  OVERLAPPED ov;
  DWORD bytes_read, bytes_read_tmp;
  DWORD bytes_read, bytes_read_tmp;
  HANDLE h;
  HANDLE h;
  gdb_byte *p;
  gdb_byte *p;
 
 
  state = scb->state;
  state = scb->state;
  if (state->in_progress)
  if (state->in_progress)
    {
    {
      WaitForSingleObject (state->ov.hEvent, INFINITE);
      WaitForSingleObject (state->ov.hEvent, INFINITE);
      state->in_progress = 0;
      state->in_progress = 0;
      ResetEvent (state->ov.hEvent);
      ResetEvent (state->ov.hEvent);
    }
    }
 
 
  memset (&ov, 0, sizeof (OVERLAPPED));
  memset (&ov, 0, sizeof (OVERLAPPED));
  ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
  ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
  h = (HANDLE) _get_osfhandle (scb->fd);
  h = (HANDLE) _get_osfhandle (scb->fd);
 
 
  if (!ReadFile (h, scb->buf, /* count */ 1, &bytes_read, &ov))
  if (!ReadFile (h, scb->buf, /* count */ 1, &bytes_read, &ov))
    {
    {
      if (GetLastError () != ERROR_IO_PENDING
      if (GetLastError () != ERROR_IO_PENDING
          || !GetOverlappedResult (h, &ov, &bytes_read, TRUE))
          || !GetOverlappedResult (h, &ov, &bytes_read, TRUE))
        bytes_read = -1;
        bytes_read = -1;
    }
    }
 
 
  CloseHandle (ov.hEvent);
  CloseHandle (ov.hEvent);
  return bytes_read;
  return bytes_read;
}
}
 
 
static int
static int
ser_windows_write_prim (struct serial *scb, const void *buf, size_t len)
ser_windows_write_prim (struct serial *scb, const void *buf, size_t len)
{
{
  struct ser_windows_state *state;
  struct ser_windows_state *state;
  OVERLAPPED ov;
  OVERLAPPED ov;
  DWORD bytes_written;
  DWORD bytes_written;
  HANDLE h;
  HANDLE h;
 
 
  memset (&ov, 0, sizeof (OVERLAPPED));
  memset (&ov, 0, sizeof (OVERLAPPED));
  ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
  ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
  h = (HANDLE) _get_osfhandle (scb->fd);
  h = (HANDLE) _get_osfhandle (scb->fd);
  if (!WriteFile (h, buf, len, &bytes_written, &ov))
  if (!WriteFile (h, buf, len, &bytes_written, &ov))
    {
    {
      if (GetLastError () != ERROR_IO_PENDING
      if (GetLastError () != ERROR_IO_PENDING
          || !GetOverlappedResult (h, &ov, &bytes_written, TRUE))
          || !GetOverlappedResult (h, &ov, &bytes_written, TRUE))
        bytes_written = -1;
        bytes_written = -1;
    }
    }
 
 
  CloseHandle (ov.hEvent);
  CloseHandle (ov.hEvent);
  return bytes_written;
  return bytes_written;
}
}
 
 
/* On Windows, gdb_select is implemented using WaitForMulpleObjects.
/* On Windows, gdb_select is implemented using WaitForMulpleObjects.
   A "select thread" is created for each file descriptor.  These
   A "select thread" is created for each file descriptor.  These
   threads looks for activity on the corresponding descriptor, using
   threads looks for activity on the corresponding descriptor, using
   whatever techniques are appropriate for the descriptor type.  When
   whatever techniques are appropriate for the descriptor type.  When
   that activity occurs, the thread signals an appropriate event,
   that activity occurs, the thread signals an appropriate event,
   which wakes up WaitForMultipleObjects.
   which wakes up WaitForMultipleObjects.
 
 
   Each select thread is in one of two states: stopped or started.
   Each select thread is in one of two states: stopped or started.
   Select threads begin in the stopped state.  When gdb_select is
   Select threads begin in the stopped state.  When gdb_select is
   called, threads corresponding to the descriptors of interest are
   called, threads corresponding to the descriptors of interest are
   started by calling a wait_handle function.  Each thread that
   started by calling a wait_handle function.  Each thread that
   notices activity signals the appropriate event and then reenters
   notices activity signals the appropriate event and then reenters
   the stopped state.  Before gdb_select returns it calls the
   the stopped state.  Before gdb_select returns it calls the
   wait_handle_done functions, which return the threads to the stopped
   wait_handle_done functions, which return the threads to the stopped
   state.  */
   state.  */
 
 
enum select_thread_state {
enum select_thread_state {
  STS_STARTED,
  STS_STARTED,
  STS_STOPPED
  STS_STOPPED
};
};
 
 
struct ser_console_state
struct ser_console_state
{
{
  /* Signaled by the select thread to indicate that data is available
  /* Signaled by the select thread to indicate that data is available
     on the file descriptor.  */
     on the file descriptor.  */
  HANDLE read_event;
  HANDLE read_event;
  /* Signaled by the select thread to indicate that an exception has
  /* Signaled by the select thread to indicate that an exception has
     occurred on the file descriptor.  */
     occurred on the file descriptor.  */
  HANDLE except_event;
  HANDLE except_event;
  /* Signaled by the select thread to indicate that it has entered the
  /* Signaled by the select thread to indicate that it has entered the
     started state.  HAVE_STARTED and HAVE_STOPPED are never signaled
     started state.  HAVE_STARTED and HAVE_STOPPED are never signaled
     simultaneously.  */
     simultaneously.  */
  HANDLE have_started;
  HANDLE have_started;
  /* Signaled by the select thread to indicate that it has stopped,
  /* Signaled by the select thread to indicate that it has stopped,
     either because data is available (and READ_EVENT is signaled),
     either because data is available (and READ_EVENT is signaled),
     because an exception has occurred (and EXCEPT_EVENT is signaled),
     because an exception has occurred (and EXCEPT_EVENT is signaled),
     or because STOP_SELECT was signaled.  */
     or because STOP_SELECT was signaled.  */
  HANDLE have_stopped;
  HANDLE have_stopped;
 
 
  /* Signaled by the main program to tell the select thread to enter
  /* Signaled by the main program to tell the select thread to enter
     the started state.  */
     the started state.  */
  HANDLE start_select;
  HANDLE start_select;
  /* Signaled by the main program to tell the select thread to enter
  /* Signaled by the main program to tell the select thread to enter
     the stopped state. */
     the stopped state. */
  HANDLE stop_select;
  HANDLE stop_select;
  /* Signaled by the main program to tell the select thread to
  /* Signaled by the main program to tell the select thread to
     exit.  */
     exit.  */
  HANDLE exit_select;
  HANDLE exit_select;
 
 
  /* The handle for the select thread.  */
  /* The handle for the select thread.  */
  HANDLE thread;
  HANDLE thread;
  /* The state of the select thread.  This field is only accessed in
  /* The state of the select thread.  This field is only accessed in
     the main program, never by the select thread itself.  */
     the main program, never by the select thread itself.  */
  enum select_thread_state thread_state;
  enum select_thread_state thread_state;
};
};
 
 
/* Called by a select thread to enter the stopped state.  This
/* Called by a select thread to enter the stopped state.  This
   function does not return until the thread has re-entered the
   function does not return until the thread has re-entered the
   started state.  */
   started state.  */
static void
static void
select_thread_wait (struct ser_console_state *state)
select_thread_wait (struct ser_console_state *state)
{
{
  HANDLE wait_events[2];
  HANDLE wait_events[2];
 
 
  /* There are two things that can wake us up: a request that we enter
  /* There are two things that can wake us up: a request that we enter
     the started state, or that we exit this thread.  */
     the started state, or that we exit this thread.  */
  wait_events[0] = state->start_select;
  wait_events[0] = state->start_select;
  wait_events[1] = state->exit_select;
  wait_events[1] = state->exit_select;
  if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE)
  if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE)
      != WAIT_OBJECT_0)
      != WAIT_OBJECT_0)
    /* Either the EXIT_SELECT event was signaled (requesting that the
    /* Either the EXIT_SELECT event was signaled (requesting that the
       thread exit) or an error has occurred.  In either case, we exit
       thread exit) or an error has occurred.  In either case, we exit
       the thread.  */
       the thread.  */
    ExitThread (0);
    ExitThread (0);
 
 
  /* We are now in the started state.  */
  /* We are now in the started state.  */
  SetEvent (state->have_started);
  SetEvent (state->have_started);
}
}
 
 
typedef DWORD WINAPI (*thread_fn_type)(void *);
typedef DWORD WINAPI (*thread_fn_type)(void *);
 
 
/* Create a new select thread for SCB executing THREAD_FN.  The STATE
/* Create a new select thread for SCB executing THREAD_FN.  The STATE
   will be filled in by this function before return.  */
   will be filled in by this function before return.  */
void
void
create_select_thread (thread_fn_type thread_fn,
create_select_thread (thread_fn_type thread_fn,
                      struct serial *scb,
                      struct serial *scb,
                      struct ser_console_state *state)
                      struct ser_console_state *state)
{
{
  DWORD threadId;
  DWORD threadId;
 
 
  /* Create all of the events.  These are all auto-reset events.  */
  /* Create all of the events.  These are all auto-reset events.  */
  state->read_event = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->read_event = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->except_event = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->except_event = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->have_started = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->have_started = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->have_stopped = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->have_stopped = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->start_select = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->start_select = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->stop_select = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->stop_select = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->exit_select = CreateEvent (NULL, FALSE, FALSE, NULL);
  state->exit_select = CreateEvent (NULL, FALSE, FALSE, NULL);
 
 
  state->thread = CreateThread (NULL, 0, thread_fn, scb, 0, &threadId);
  state->thread = CreateThread (NULL, 0, thread_fn, scb, 0, &threadId);
  /* The thread begins in the stopped state.  */
  /* The thread begins in the stopped state.  */
  state->thread_state = STS_STOPPED;
  state->thread_state = STS_STOPPED;
}
}
 
 
/* Destroy the select thread indicated by STATE.  */
/* Destroy the select thread indicated by STATE.  */
static void
static void
destroy_select_thread (struct ser_console_state *state)
destroy_select_thread (struct ser_console_state *state)
{
{
  /* Ask the thread to exit.  */
  /* Ask the thread to exit.  */
  SetEvent (state->exit_select);
  SetEvent (state->exit_select);
  /* Wait until it does.  */
  /* Wait until it does.  */
  WaitForSingleObject (state->thread, INFINITE);
  WaitForSingleObject (state->thread, INFINITE);
 
 
  /* Destroy the events.  */
  /* Destroy the events.  */
  CloseHandle (state->read_event);
  CloseHandle (state->read_event);
  CloseHandle (state->except_event);
  CloseHandle (state->except_event);
  CloseHandle (state->have_started);
  CloseHandle (state->have_started);
  CloseHandle (state->have_stopped);
  CloseHandle (state->have_stopped);
  CloseHandle (state->start_select);
  CloseHandle (state->start_select);
  CloseHandle (state->stop_select);
  CloseHandle (state->stop_select);
  CloseHandle (state->exit_select);
  CloseHandle (state->exit_select);
}
}
 
 
/* Called by gdb_select to start the select thread indicated by STATE.
/* Called by gdb_select to start the select thread indicated by STATE.
   This function does not return until the thread has started.  */
   This function does not return until the thread has started.  */
static void
static void
start_select_thread (struct ser_console_state *state)
start_select_thread (struct ser_console_state *state)
{
{
  /* Ask the thread to start.  */
  /* Ask the thread to start.  */
  SetEvent (state->start_select);
  SetEvent (state->start_select);
  /* Wait until it does.  */
  /* Wait until it does.  */
  WaitForSingleObject (state->have_started, INFINITE);
  WaitForSingleObject (state->have_started, INFINITE);
  /* The thread is now started.  */
  /* The thread is now started.  */
  state->thread_state = STS_STARTED;
  state->thread_state = STS_STARTED;
}
}
 
 
/* Called by gdb_select to stop the select thread indicated by STATE.
/* Called by gdb_select to stop the select thread indicated by STATE.
   This function does not return until the thread has stopped.  */
   This function does not return until the thread has stopped.  */
static void
static void
stop_select_thread (struct ser_console_state *state)
stop_select_thread (struct ser_console_state *state)
{
{
  /* If the thread is already in the stopped state, we have nothing to
  /* If the thread is already in the stopped state, we have nothing to
     do.  Some of the wait_handle functions avoid calling
     do.  Some of the wait_handle functions avoid calling
     start_select_thread if they notice activity on the relevant file
     start_select_thread if they notice activity on the relevant file
     descriptors.  The wait_handle_done functions still call
     descriptors.  The wait_handle_done functions still call
     stop_select_thread -- but it is already stopped.  */
     stop_select_thread -- but it is already stopped.  */
  if (state->thread_state != STS_STARTED)
  if (state->thread_state != STS_STARTED)
    return;
    return;
  /* Ask the thread to stop.  */
  /* Ask the thread to stop.  */
  SetEvent (state->stop_select);
  SetEvent (state->stop_select);
  /* Wait until it does.  */
  /* Wait until it does.  */
  WaitForSingleObject (state->have_stopped, INFINITE);
  WaitForSingleObject (state->have_stopped, INFINITE);
  /* The thread is now stopped.  */
  /* The thread is now stopped.  */
  state->thread_state = STS_STOPPED;
  state->thread_state = STS_STOPPED;
}
}
 
 
static DWORD WINAPI
static DWORD WINAPI
console_select_thread (void *arg)
console_select_thread (void *arg)
{
{
  struct serial *scb = arg;
  struct serial *scb = arg;
  struct ser_console_state *state;
  struct ser_console_state *state;
  int event_index;
  int event_index;
  HANDLE h;
  HANDLE h;
 
 
  state = scb->state;
  state = scb->state;
  h = (HANDLE) _get_osfhandle (scb->fd);
  h = (HANDLE) _get_osfhandle (scb->fd);
 
 
  while (1)
  while (1)
    {
    {
      HANDLE wait_events[2];
      HANDLE wait_events[2];
      INPUT_RECORD record;
      INPUT_RECORD record;
      DWORD n_records;
      DWORD n_records;
 
 
      select_thread_wait (state);
      select_thread_wait (state);
 
 
      while (1)
      while (1)
        {
        {
          wait_events[0] = state->stop_select;
          wait_events[0] = state->stop_select;
          wait_events[1] = h;
          wait_events[1] = h;
 
 
          event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
          event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
 
 
          if (event_index == WAIT_OBJECT_0
          if (event_index == WAIT_OBJECT_0
              || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
              || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
            break;
            break;
 
 
          if (event_index != WAIT_OBJECT_0 + 1)
          if (event_index != WAIT_OBJECT_0 + 1)
            {
            {
              /* Wait must have failed; assume an error has occured, e.g.
              /* Wait must have failed; assume an error has occured, e.g.
                 the handle has been closed.  */
                 the handle has been closed.  */
              SetEvent (state->except_event);
              SetEvent (state->except_event);
              break;
              break;
            }
            }
 
 
          /* We've got a pending event on the console.  See if it's
          /* We've got a pending event on the console.  See if it's
             of interest.  */
             of interest.  */
          if (!PeekConsoleInput (h, &record, 1, &n_records) || n_records != 1)
          if (!PeekConsoleInput (h, &record, 1, &n_records) || n_records != 1)
            {
            {
              /* Something went wrong.  Maybe the console is gone.  */
              /* Something went wrong.  Maybe the console is gone.  */
              SetEvent (state->except_event);
              SetEvent (state->except_event);
              break;
              break;
            }
            }
 
 
          if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
          if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
            {
            {
              WORD keycode = record.Event.KeyEvent.wVirtualKeyCode;
              WORD keycode = record.Event.KeyEvent.wVirtualKeyCode;
 
 
              /* Ignore events containing only control keys.  We must
              /* Ignore events containing only control keys.  We must
                 recognize "enhanced" keys which we are interested in
                 recognize "enhanced" keys which we are interested in
                 reading via getch, if they do not map to ASCII.  But we
                 reading via getch, if they do not map to ASCII.  But we
                 do not want to report input available for e.g. the
                 do not want to report input available for e.g. the
                 control key alone.  */
                 control key alone.  */
 
 
              if (record.Event.KeyEvent.uChar.AsciiChar != 0
              if (record.Event.KeyEvent.uChar.AsciiChar != 0
                  || keycode == VK_PRIOR
                  || keycode == VK_PRIOR
                  || keycode == VK_NEXT
                  || keycode == VK_NEXT
                  || keycode == VK_END
                  || keycode == VK_END
                  || keycode == VK_HOME
                  || keycode == VK_HOME
                  || keycode == VK_LEFT
                  || keycode == VK_LEFT
                  || keycode == VK_UP
                  || keycode == VK_UP
                  || keycode == VK_RIGHT
                  || keycode == VK_RIGHT
                  || keycode == VK_DOWN
                  || keycode == VK_DOWN
                  || keycode == VK_INSERT
                  || keycode == VK_INSERT
                  || keycode == VK_DELETE)
                  || keycode == VK_DELETE)
                {
                {
                  /* This is really a keypress.  */
                  /* This is really a keypress.  */
                  SetEvent (state->read_event);
                  SetEvent (state->read_event);
                  break;
                  break;
                }
                }
            }
            }
 
 
          /* Otherwise discard it and wait again.  */
          /* Otherwise discard it and wait again.  */
          ReadConsoleInput (h, &record, 1, &n_records);
          ReadConsoleInput (h, &record, 1, &n_records);
        }
        }
 
 
      SetEvent(state->have_stopped);
      SetEvent(state->have_stopped);
    }
    }
  return 0;
  return 0;
}
}
 
 
static int
static int
fd_is_pipe (int fd)
fd_is_pipe (int fd)
{
{
  if (PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, NULL, NULL))
  if (PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, NULL, NULL))
    return 1;
    return 1;
  else
  else
    return 0;
    return 0;
}
}
 
 
static int
static int
fd_is_file (int fd)
fd_is_file (int fd)
{
{
  if (GetFileType ((HANDLE) _get_osfhandle (fd)) == FILE_TYPE_DISK)
  if (GetFileType ((HANDLE) _get_osfhandle (fd)) == FILE_TYPE_DISK)
    return 1;
    return 1;
  else
  else
    return 0;
    return 0;
}
}
 
 
static DWORD WINAPI
static DWORD WINAPI
pipe_select_thread (void *arg)
pipe_select_thread (void *arg)
{
{
  struct serial *scb = arg;
  struct serial *scb = arg;
  struct ser_console_state *state;
  struct ser_console_state *state;
  int event_index;
  int event_index;
  HANDLE h;
  HANDLE h;
 
 
  state = scb->state;
  state = scb->state;
  h = (HANDLE) _get_osfhandle (scb->fd);
  h = (HANDLE) _get_osfhandle (scb->fd);
 
 
  while (1)
  while (1)
    {
    {
      DWORD n_avail;
      DWORD n_avail;
 
 
      select_thread_wait (state);
      select_thread_wait (state);
 
 
      /* Wait for something to happen on the pipe.  */
      /* Wait for something to happen on the pipe.  */
      while (1)
      while (1)
        {
        {
          if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
          if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
            {
            {
              SetEvent (state->except_event);
              SetEvent (state->except_event);
              break;
              break;
            }
            }
 
 
          if (n_avail > 0)
          if (n_avail > 0)
            {
            {
              SetEvent (state->read_event);
              SetEvent (state->read_event);
              break;
              break;
            }
            }
 
 
          /* Delay 10ms before checking again, but allow the stop
          /* Delay 10ms before checking again, but allow the stop
             event to wake us.  */
             event to wake us.  */
          if (WaitForSingleObject (state->stop_select, 10) == WAIT_OBJECT_0)
          if (WaitForSingleObject (state->stop_select, 10) == WAIT_OBJECT_0)
            break;
            break;
        }
        }
 
 
      SetEvent (state->have_stopped);
      SetEvent (state->have_stopped);
    }
    }
  return 0;
  return 0;
}
}
 
 
static DWORD WINAPI
static DWORD WINAPI
file_select_thread (void *arg)
file_select_thread (void *arg)
{
{
  struct serial *scb = arg;
  struct serial *scb = arg;
  struct ser_console_state *state;
  struct ser_console_state *state;
  int event_index;
  int event_index;
  HANDLE h;
  HANDLE h;
 
 
  state = scb->state;
  state = scb->state;
  h = (HANDLE) _get_osfhandle (scb->fd);
  h = (HANDLE) _get_osfhandle (scb->fd);
 
 
  while (1)
  while (1)
    {
    {
      select_thread_wait (state);
      select_thread_wait (state);
 
 
      if (SetFilePointer (h, 0, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
      if (SetFilePointer (h, 0, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
        SetEvent (state->except_event);
        SetEvent (state->except_event);
      else
      else
        SetEvent (state->read_event);
        SetEvent (state->read_event);
 
 
      SetEvent (state->have_stopped);
      SetEvent (state->have_stopped);
    }
    }
  return 0;
  return 0;
}
}
 
 
static void
static void
ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
{
{
  struct ser_console_state *state = scb->state;
  struct ser_console_state *state = scb->state;
 
 
  if (state == NULL)
  if (state == NULL)
    {
    {
      thread_fn_type thread_fn;
      thread_fn_type thread_fn;
      int is_tty;
      int is_tty;
 
 
      is_tty = isatty (scb->fd);
      is_tty = isatty (scb->fd);
      if (!is_tty && !fd_is_file (scb->fd) && !fd_is_pipe (scb->fd))
      if (!is_tty && !fd_is_file (scb->fd) && !fd_is_pipe (scb->fd))
        {
        {
          *read = NULL;
          *read = NULL;
          *except = NULL;
          *except = NULL;
          return;
          return;
        }
        }
 
 
      state = xmalloc (sizeof (struct ser_console_state));
      state = xmalloc (sizeof (struct ser_console_state));
      memset (state, 0, sizeof (struct ser_console_state));
      memset (state, 0, sizeof (struct ser_console_state));
      scb->state = state;
      scb->state = state;
 
 
      if (is_tty)
      if (is_tty)
        thread_fn = console_select_thread;
        thread_fn = console_select_thread;
      else if (fd_is_pipe (scb->fd))
      else if (fd_is_pipe (scb->fd))
        thread_fn = pipe_select_thread;
        thread_fn = pipe_select_thread;
      else
      else
        thread_fn = file_select_thread;
        thread_fn = file_select_thread;
 
 
      create_select_thread (thread_fn, scb, state);
      create_select_thread (thread_fn, scb, state);
    }
    }
 
 
  *read = state->read_event;
  *read = state->read_event;
  *except = state->except_event;
  *except = state->except_event;
 
 
  /* Start from a blank state.  */
  /* Start from a blank state.  */
  ResetEvent (state->read_event);
  ResetEvent (state->read_event);
  ResetEvent (state->except_event);
  ResetEvent (state->except_event);
  ResetEvent (state->stop_select);
  ResetEvent (state->stop_select);
 
 
  /* First check for a key already in the buffer.  If there is one,
  /* First check for a key already in the buffer.  If there is one,
     we don't need a thread.  This also catches the second key of
     we don't need a thread.  This also catches the second key of
     multi-character returns from getch, for instance for arrow
     multi-character returns from getch, for instance for arrow
     keys.  The second half is in a C library internal buffer,
     keys.  The second half is in a C library internal buffer,
     and PeekConsoleInput will not find it.  */
     and PeekConsoleInput will not find it.  */
  if (_kbhit ())
  if (_kbhit ())
    {
    {
      SetEvent (state->read_event);
      SetEvent (state->read_event);
      return;
      return;
    }
    }
 
 
  /* Otherwise, start the select thread.  */
  /* Otherwise, start the select thread.  */
  start_select_thread (state);
  start_select_thread (state);
}
}
 
 
static void
static void
ser_console_done_wait_handle (struct serial *scb)
ser_console_done_wait_handle (struct serial *scb)
{
{
  struct ser_console_state *state = scb->state;
  struct ser_console_state *state = scb->state;
 
 
  if (state == NULL)
  if (state == NULL)
    return;
    return;
 
 
  stop_select_thread (state);
  stop_select_thread (state);
}
}
 
 
static void
static void
ser_console_close (struct serial *scb)
ser_console_close (struct serial *scb)
{
{
  struct ser_console_state *state = scb->state;
  struct ser_console_state *state = scb->state;
 
 
  if (scb->state)
  if (scb->state)
    {
    {
      destroy_select_thread (state);
      destroy_select_thread (state);
      xfree (scb->state);
      xfree (scb->state);
    }
    }
}
}
 
 
struct ser_console_ttystate
struct ser_console_ttystate
{
{
  int is_a_tty;
  int is_a_tty;
};
};
 
 
static serial_ttystate
static serial_ttystate
ser_console_get_tty_state (struct serial *scb)
ser_console_get_tty_state (struct serial *scb)
{
{
  if (isatty (scb->fd))
  if (isatty (scb->fd))
    {
    {
      struct ser_console_ttystate *state;
      struct ser_console_ttystate *state;
      state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
      state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
      state->is_a_tty = 1;
      state->is_a_tty = 1;
      return state;
      return state;
    }
    }
  else
  else
    return NULL;
    return NULL;
}
}
 
 
struct pipe_state
struct pipe_state
{
{
  /* Since we use the pipe_select_thread for our select emulation,
  /* Since we use the pipe_select_thread for our select emulation,
     we need to place the state structure it requires at the front
     we need to place the state structure it requires at the front
     of our state.  */
     of our state.  */
  struct ser_console_state wait;
  struct ser_console_state wait;
 
 
  /* The pex obj for our (one-stage) pipeline.  */
  /* The pex obj for our (one-stage) pipeline.  */
  struct pex_obj *pex;
  struct pex_obj *pex;
 
 
  /* Streams for the pipeline's input and output.  */
  /* Streams for the pipeline's input and output.  */
  FILE *input, *output;
  FILE *input, *output;
};
};
 
 
static struct pipe_state *
static struct pipe_state *
make_pipe_state (void)
make_pipe_state (void)
{
{
  struct pipe_state *ps = XMALLOC (struct pipe_state);
  struct pipe_state *ps = XMALLOC (struct pipe_state);
 
 
  memset (ps, 0, sizeof (*ps));
  memset (ps, 0, sizeof (*ps));
  ps->wait.read_event = INVALID_HANDLE_VALUE;
  ps->wait.read_event = INVALID_HANDLE_VALUE;
  ps->wait.except_event = INVALID_HANDLE_VALUE;
  ps->wait.except_event = INVALID_HANDLE_VALUE;
  ps->wait.start_select = INVALID_HANDLE_VALUE;
  ps->wait.start_select = INVALID_HANDLE_VALUE;
  ps->wait.stop_select = INVALID_HANDLE_VALUE;
  ps->wait.stop_select = INVALID_HANDLE_VALUE;
 
 
  return ps;
  return ps;
}
}
 
 
static void
static void
free_pipe_state (struct pipe_state *ps)
free_pipe_state (struct pipe_state *ps)
{
{
  int saved_errno = errno;
  int saved_errno = errno;
 
 
  if (ps->wait.read_event != INVALID_HANDLE_VALUE)
  if (ps->wait.read_event != INVALID_HANDLE_VALUE)
    destroy_select_thread (&ps->wait);
    destroy_select_thread (&ps->wait);
 
 
  /* Close the pipe to the child.  We must close the pipe before
  /* Close the pipe to the child.  We must close the pipe before
     calling pex_free because pex_free will wait for the child to exit
     calling pex_free because pex_free will wait for the child to exit
     and the child will not exit until the pipe is closed.  */
     and the child will not exit until the pipe is closed.  */
  if (ps->input)
  if (ps->input)
    fclose (ps->input);
    fclose (ps->input);
  if (ps->pex)
  if (ps->pex)
    pex_free (ps->pex);
    pex_free (ps->pex);
  /* pex_free closes ps->output.  */
  /* pex_free closes ps->output.  */
 
 
  xfree (ps);
  xfree (ps);
 
 
  errno = saved_errno;
  errno = saved_errno;
}
}
 
 
static void
static void
cleanup_pipe_state (void *untyped)
cleanup_pipe_state (void *untyped)
{
{
  struct pipe_state *ps = untyped;
  struct pipe_state *ps = untyped;
 
 
  free_pipe_state (ps);
  free_pipe_state (ps);
}
}
 
 
static int
static int
pipe_windows_open (struct serial *scb, const char *name)
pipe_windows_open (struct serial *scb, const char *name)
{
{
  struct pipe_state *ps;
  struct pipe_state *ps;
  FILE *pex_stderr;
  FILE *pex_stderr;
  char **argv;
  char **argv;
  struct cleanup *back_to;
  struct cleanup *back_to;
 
 
  if (name == NULL)
  if (name == NULL)
    error_no_arg (_("child command"));
    error_no_arg (_("child command"));
 
 
  argv = gdb_buildargv (name);
  argv = gdb_buildargv (name);
  back_to = make_cleanup_freeargv (argv);
  back_to = make_cleanup_freeargv (argv);
 
 
  if (! argv[0] || argv[0][0] == '\0')
  if (! argv[0] || argv[0][0] == '\0')
    error ("missing child command");
    error ("missing child command");
 
 
  ps = make_pipe_state ();
  ps = make_pipe_state ();
  make_cleanup (cleanup_pipe_state, ps);
  make_cleanup (cleanup_pipe_state, ps);
 
 
  ps->pex = pex_init (PEX_USE_PIPES, "target remote pipe", NULL);
  ps->pex = pex_init (PEX_USE_PIPES, "target remote pipe", NULL);
  if (! ps->pex)
  if (! ps->pex)
    goto fail;
    goto fail;
  ps->input = pex_input_pipe (ps->pex, 1);
  ps->input = pex_input_pipe (ps->pex, 1);
  if (! ps->input)
  if (! ps->input)
    goto fail;
    goto fail;
 
 
  {
  {
    int err;
    int err;
    const char *err_msg
    const char *err_msg
      = pex_run (ps->pex, PEX_SEARCH | PEX_BINARY_INPUT | PEX_BINARY_OUTPUT
      = pex_run (ps->pex, PEX_SEARCH | PEX_BINARY_INPUT | PEX_BINARY_OUTPUT
                 | PEX_STDERR_TO_PIPE,
                 | PEX_STDERR_TO_PIPE,
                 argv[0], argv, NULL, NULL,
                 argv[0], argv, NULL, NULL,
                 &err);
                 &err);
 
 
    if (err_msg)
    if (err_msg)
      {
      {
        /* Our caller expects us to return -1, but all they'll do with
        /* Our caller expects us to return -1, but all they'll do with
           it generally is print the message based on errno.  We have
           it generally is print the message based on errno.  We have
           all the same information here, plus err_msg provided by
           all the same information here, plus err_msg provided by
           pex_run, so we just raise the error here.  */
           pex_run, so we just raise the error here.  */
        if (err)
        if (err)
          error ("error starting child process '%s': %s: %s",
          error ("error starting child process '%s': %s: %s",
                 name, err_msg, safe_strerror (err));
                 name, err_msg, safe_strerror (err));
        else
        else
          error ("error starting child process '%s': %s",
          error ("error starting child process '%s': %s",
                 name, err_msg);
                 name, err_msg);
      }
      }
  }
  }
 
 
  ps->output = pex_read_output (ps->pex, 1);
  ps->output = pex_read_output (ps->pex, 1);
  if (! ps->output)
  if (! ps->output)
    goto fail;
    goto fail;
  scb->fd = fileno (ps->output);
  scb->fd = fileno (ps->output);
 
 
  pex_stderr = pex_read_err (ps->pex, 1);
  pex_stderr = pex_read_err (ps->pex, 1);
  if (! pex_stderr)
  if (! pex_stderr)
    goto fail;
    goto fail;
  scb->error_fd = fileno (pex_stderr);
  scb->error_fd = fileno (pex_stderr);
 
 
  scb->state = (void *) ps;
  scb->state = (void *) ps;
 
 
  discard_cleanups (back_to);
  discard_cleanups (back_to);
  return 0;
  return 0;
 
 
 fail:
 fail:
  do_cleanups (back_to);
  do_cleanups (back_to);
  return -1;
  return -1;
}
}
 
 
 
 
static void
static void
pipe_windows_close (struct serial *scb)
pipe_windows_close (struct serial *scb)
{
{
  struct pipe_state *ps = scb->state;
  struct pipe_state *ps = scb->state;
 
 
  /* In theory, we should try to kill the subprocess here, but the pex
  /* In theory, we should try to kill the subprocess here, but the pex
     interface doesn't give us enough information to do that.  Usually
     interface doesn't give us enough information to do that.  Usually
     closing the input pipe will get the message across.  */
     closing the input pipe will get the message across.  */
 
 
  free_pipe_state (ps);
  free_pipe_state (ps);
}
}
 
 
 
 
static int
static int
pipe_windows_read (struct serial *scb, size_t count)
pipe_windows_read (struct serial *scb, size_t count)
{
{
  HANDLE pipeline_out = (HANDLE) _get_osfhandle (scb->fd);
  HANDLE pipeline_out = (HANDLE) _get_osfhandle (scb->fd);
  DWORD available;
  DWORD available;
  DWORD bytes_read;
  DWORD bytes_read;
 
 
  if (pipeline_out == INVALID_HANDLE_VALUE)
  if (pipeline_out == INVALID_HANDLE_VALUE)
    return -1;
    return -1;
 
 
  if (! PeekNamedPipe (pipeline_out, NULL, 0, NULL, &available, NULL))
  if (! PeekNamedPipe (pipeline_out, NULL, 0, NULL, &available, NULL))
    return -1;
    return -1;
 
 
  if (count > available)
  if (count > available)
    count = available;
    count = available;
 
 
  if (! ReadFile (pipeline_out, scb->buf, count, &bytes_read, NULL))
  if (! ReadFile (pipeline_out, scb->buf, count, &bytes_read, NULL))
    return -1;
    return -1;
 
 
  return bytes_read;
  return bytes_read;
}
}
 
 
 
 
static int
static int
pipe_windows_write (struct serial *scb, const void *buf, size_t count)
pipe_windows_write (struct serial *scb, const void *buf, size_t count)
{
{
  struct pipe_state *ps = scb->state;
  struct pipe_state *ps = scb->state;
  HANDLE pipeline_in;
  HANDLE pipeline_in;
  DWORD written;
  DWORD written;
 
 
  int pipeline_in_fd = fileno (ps->input);
  int pipeline_in_fd = fileno (ps->input);
  if (pipeline_in_fd < 0)
  if (pipeline_in_fd < 0)
    return -1;
    return -1;
 
 
  pipeline_in = (HANDLE) _get_osfhandle (pipeline_in_fd);
  pipeline_in = (HANDLE) _get_osfhandle (pipeline_in_fd);
  if (pipeline_in == INVALID_HANDLE_VALUE)
  if (pipeline_in == INVALID_HANDLE_VALUE)
    return -1;
    return -1;
 
 
  if (! WriteFile (pipeline_in, buf, count, &written, NULL))
  if (! WriteFile (pipeline_in, buf, count, &written, NULL))
    return -1;
    return -1;
 
 
  return written;
  return written;
}
}
 
 
 
 
static void
static void
pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
pipe_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
{
{
  struct pipe_state *ps = scb->state;
  struct pipe_state *ps = scb->state;
 
 
  /* Have we allocated our events yet?  */
  /* Have we allocated our events yet?  */
  if (ps->wait.read_event == INVALID_HANDLE_VALUE)
  if (ps->wait.read_event == INVALID_HANDLE_VALUE)
    /* Start the thread.  */
    /* Start the thread.  */
    create_select_thread (pipe_select_thread, scb, &ps->wait);
    create_select_thread (pipe_select_thread, scb, &ps->wait);
 
 
  *read = ps->wait.read_event;
  *read = ps->wait.read_event;
  *except = ps->wait.except_event;
  *except = ps->wait.except_event;
 
 
  /* Start from a blank state.  */
  /* Start from a blank state.  */
  ResetEvent (ps->wait.read_event);
  ResetEvent (ps->wait.read_event);
  ResetEvent (ps->wait.except_event);
  ResetEvent (ps->wait.except_event);
  ResetEvent (ps->wait.stop_select);
  ResetEvent (ps->wait.stop_select);
 
 
  start_select_thread (&ps->wait);
  start_select_thread (&ps->wait);
}
}
 
 
static void
static void
pipe_done_wait_handle (struct serial *scb)
pipe_done_wait_handle (struct serial *scb)
{
{
  struct pipe_state *ps = scb->state;
  struct pipe_state *ps = scb->state;
 
 
  /* Have we allocated our events yet?  */
  /* Have we allocated our events yet?  */
  if (ps->wait.read_event == INVALID_HANDLE_VALUE)
  if (ps->wait.read_event == INVALID_HANDLE_VALUE)
    return;
    return;
 
 
  stop_select_thread (&ps->wait);
  stop_select_thread (&ps->wait);
}
}
 
 
static int
static int
pipe_avail (struct serial *scb, int fd)
pipe_avail (struct serial *scb, int fd)
{
{
  HANDLE h = (HANDLE) _get_osfhandle (fd);
  HANDLE h = (HANDLE) _get_osfhandle (fd);
  DWORD numBytes;
  DWORD numBytes;
  BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
  BOOL r = PeekNamedPipe (h, NULL, 0, NULL, &numBytes, NULL);
  if (r == FALSE)
  if (r == FALSE)
    numBytes = 0;
    numBytes = 0;
  return numBytes;
  return numBytes;
}
}
 
 
struct net_windows_state
struct net_windows_state
{
{
  struct ser_console_state base;
  struct ser_console_state base;
 
 
  HANDLE sock_event;
  HANDLE sock_event;
};
};
 
 
static DWORD WINAPI
static DWORD WINAPI
net_windows_select_thread (void *arg)
net_windows_select_thread (void *arg)
{
{
  struct serial *scb = arg;
  struct serial *scb = arg;
  struct net_windows_state *state;
  struct net_windows_state *state;
  int event_index;
  int event_index;
 
 
  state = scb->state;
  state = scb->state;
 
 
  while (1)
  while (1)
    {
    {
      HANDLE wait_events[2];
      HANDLE wait_events[2];
      WSANETWORKEVENTS events;
      WSANETWORKEVENTS events;
 
 
      select_thread_wait (&state->base);
      select_thread_wait (&state->base);
 
 
      wait_events[0] = state->base.stop_select;
      wait_events[0] = state->base.stop_select;
      wait_events[1] = state->sock_event;
      wait_events[1] = state->sock_event;
 
 
      event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
      event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
 
 
      if (event_index == WAIT_OBJECT_0
      if (event_index == WAIT_OBJECT_0
          || WaitForSingleObject (state->base.stop_select, 0) == WAIT_OBJECT_0)
          || WaitForSingleObject (state->base.stop_select, 0) == WAIT_OBJECT_0)
        /* We have been requested to stop.  */
        /* We have been requested to stop.  */
        ;
        ;
      else if (event_index != WAIT_OBJECT_0 + 1)
      else if (event_index != WAIT_OBJECT_0 + 1)
        /* Some error has occured.  Assume that this is an error
        /* Some error has occured.  Assume that this is an error
           condition.  */
           condition.  */
        SetEvent (state->base.except_event);
        SetEvent (state->base.except_event);
      else
      else
        {
        {
          /* Enumerate the internal network events, and reset the
          /* Enumerate the internal network events, and reset the
             object that signalled us to catch the next event.  */
             object that signalled us to catch the next event.  */
          WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
          WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
 
 
          gdb_assert (events.lNetworkEvents & (FD_READ | FD_CLOSE));
          gdb_assert (events.lNetworkEvents & (FD_READ | FD_CLOSE));
 
 
          if (events.lNetworkEvents & FD_READ)
          if (events.lNetworkEvents & FD_READ)
            SetEvent (state->base.read_event);
            SetEvent (state->base.read_event);
 
 
          if (events.lNetworkEvents & FD_CLOSE)
          if (events.lNetworkEvents & FD_CLOSE)
            SetEvent (state->base.except_event);
            SetEvent (state->base.except_event);
        }
        }
 
 
      SetEvent (state->base.have_stopped);
      SetEvent (state->base.have_stopped);
    }
    }
}
}
 
 
static void
static void
net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
{
{
  struct net_windows_state *state = scb->state;
  struct net_windows_state *state = scb->state;
 
 
  /* Start from a clean slate.  */
  /* Start from a clean slate.  */
  ResetEvent (state->base.read_event);
  ResetEvent (state->base.read_event);
  ResetEvent (state->base.except_event);
  ResetEvent (state->base.except_event);
  ResetEvent (state->base.stop_select);
  ResetEvent (state->base.stop_select);
 
 
  *read = state->base.read_event;
  *read = state->base.read_event;
  *except = state->base.except_event;
  *except = state->base.except_event;
 
 
  /* Check any pending events.  This both avoids starting the thread
  /* Check any pending events.  This both avoids starting the thread
     unnecessarily, and handles stray FD_READ events (see below).  */
     unnecessarily, and handles stray FD_READ events (see below).  */
  if (WaitForSingleObject (state->sock_event, 0) == WAIT_OBJECT_0)
  if (WaitForSingleObject (state->sock_event, 0) == WAIT_OBJECT_0)
    {
    {
      WSANETWORKEVENTS events;
      WSANETWORKEVENTS events;
      int any = 0;
      int any = 0;
 
 
      /* Enumerate the internal network events, and reset the object that
      /* Enumerate the internal network events, and reset the object that
         signalled us to catch the next event.  */
         signalled us to catch the next event.  */
      WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
      WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
 
 
      /* You'd think that FD_READ or FD_CLOSE would be set here.  But,
      /* You'd think that FD_READ or FD_CLOSE would be set here.  But,
         sometimes, neither is.  I suspect that the FD_READ is set and
         sometimes, neither is.  I suspect that the FD_READ is set and
         the corresponding event signalled while recv is running, and
         the corresponding event signalled while recv is running, and
         the FD_READ is then lowered when recv consumes all the data,
         the FD_READ is then lowered when recv consumes all the data,
         but there's no way to un-signal the event.  This isn't a
         but there's no way to un-signal the event.  This isn't a
         problem for the call in net_select_thread, since any new
         problem for the call in net_select_thread, since any new
         events after this point will not have been drained by recv.
         events after this point will not have been drained by recv.
         It just means that we can't have the obvious assert here.  */
         It just means that we can't have the obvious assert here.  */
 
 
      /* If there is a read event, it might be still valid, or it might
      /* If there is a read event, it might be still valid, or it might
         not be - it may have been signalled before we last called
         not be - it may have been signalled before we last called
         recv.  Double-check that there is data.  */
         recv.  Double-check that there is data.  */
      if (events.lNetworkEvents & FD_READ)
      if (events.lNetworkEvents & FD_READ)
        {
        {
          unsigned long available;
          unsigned long available;
 
 
          if (ioctlsocket (scb->fd, FIONREAD, &available) == 0
          if (ioctlsocket (scb->fd, FIONREAD, &available) == 0
              && available > 0)
              && available > 0)
            {
            {
              SetEvent (state->base.read_event);
              SetEvent (state->base.read_event);
              any = 1;
              any = 1;
            }
            }
          else
          else
            /* Oops, no data.  This call to recv will cause future
            /* Oops, no data.  This call to recv will cause future
               data to retrigger the event, e.g. while we are
               data to retrigger the event, e.g. while we are
               in net_select_thread.  */
               in net_select_thread.  */
            recv (scb->fd, NULL, 0, 0);
            recv (scb->fd, NULL, 0, 0);
        }
        }
 
 
      /* If there's a close event, then record it - it is obviously
      /* If there's a close event, then record it - it is obviously
         still valid, and it will not be resignalled.  */
         still valid, and it will not be resignalled.  */
      if (events.lNetworkEvents & FD_CLOSE)
      if (events.lNetworkEvents & FD_CLOSE)
        {
        {
          SetEvent (state->base.except_event);
          SetEvent (state->base.except_event);
          any = 1;
          any = 1;
        }
        }
 
 
      /* If we set either handle, there's no need to wake the thread.  */
      /* If we set either handle, there's no need to wake the thread.  */
      if (any)
      if (any)
        return;
        return;
    }
    }
 
 
  start_select_thread (&state->base);
  start_select_thread (&state->base);
}
}
 
 
static void
static void
net_windows_done_wait_handle (struct serial *scb)
net_windows_done_wait_handle (struct serial *scb)
{
{
  struct net_windows_state *state = scb->state;
  struct net_windows_state *state = scb->state;
 
 
  stop_select_thread (&state->base);
  stop_select_thread (&state->base);
}
}
 
 
static int
static int
net_windows_open (struct serial *scb, const char *name)
net_windows_open (struct serial *scb, const char *name)
{
{
  struct net_windows_state *state;
  struct net_windows_state *state;
  int ret;
  int ret;
  DWORD threadId;
  DWORD threadId;
 
 
  ret = net_open (scb, name);
  ret = net_open (scb, name);
  if (ret != 0)
  if (ret != 0)
    return ret;
    return ret;
 
 
  state = xmalloc (sizeof (struct net_windows_state));
  state = xmalloc (sizeof (struct net_windows_state));
  memset (state, 0, sizeof (struct net_windows_state));
  memset (state, 0, sizeof (struct net_windows_state));
  scb->state = state;
  scb->state = state;
 
 
  /* Associate an event with the socket.  */
  /* Associate an event with the socket.  */
  state->sock_event = CreateEvent (0, TRUE, FALSE, 0);
  state->sock_event = CreateEvent (0, TRUE, FALSE, 0);
  WSAEventSelect (scb->fd, state->sock_event, FD_READ | FD_CLOSE);
  WSAEventSelect (scb->fd, state->sock_event, FD_READ | FD_CLOSE);
 
 
  /* Start the thread.  */
  /* Start the thread.  */
  create_select_thread (net_windows_select_thread, scb, &state->base);
  create_select_thread (net_windows_select_thread, scb, &state->base);
 
 
  return 0;
  return 0;
}
}
 
 
 
 
static void
static void
net_windows_close (struct serial *scb)
net_windows_close (struct serial *scb)
{
{
  struct net_windows_state *state = scb->state;
  struct net_windows_state *state = scb->state;
 
 
  destroy_select_thread (&state->base);
  destroy_select_thread (&state->base);
  CloseHandle (state->sock_event);
  CloseHandle (state->sock_event);
 
 
  xfree (scb->state);
  xfree (scb->state);
 
 
  net_close (scb);
  net_close (scb);
}
}
 
 
void
void
_initialize_ser_windows (void)
_initialize_ser_windows (void)
{
{
  WSADATA wsa_data;
  WSADATA wsa_data;
  struct serial_ops *ops;
  struct serial_ops *ops;
 
 
  /* First register the serial port driver.  */
  /* First register the serial port driver.  */
 
 
  ops = XMALLOC (struct serial_ops);
  ops = XMALLOC (struct serial_ops);
  memset (ops, 0, sizeof (struct serial_ops));
  memset (ops, 0, sizeof (struct serial_ops));
  ops->name = "hardwire";
  ops->name = "hardwire";
  ops->next = 0;
  ops->next = 0;
  ops->open = ser_windows_open;
  ops->open = ser_windows_open;
  ops->close = ser_windows_close;
  ops->close = ser_windows_close;
 
 
  ops->flush_output = ser_windows_flush_output;
  ops->flush_output = ser_windows_flush_output;
  ops->flush_input = ser_windows_flush_input;
  ops->flush_input = ser_windows_flush_input;
  ops->send_break = ser_windows_send_break;
  ops->send_break = ser_windows_send_break;
 
 
  /* These are only used for stdin; we do not need them for serial
  /* These are only used for stdin; we do not need them for serial
     ports, so supply the standard dummies.  */
     ports, so supply the standard dummies.  */
  ops->get_tty_state = ser_base_get_tty_state;
  ops->get_tty_state = ser_base_get_tty_state;
  ops->set_tty_state = ser_base_set_tty_state;
  ops->set_tty_state = ser_base_set_tty_state;
  ops->print_tty_state = ser_base_print_tty_state;
  ops->print_tty_state = ser_base_print_tty_state;
  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
 
 
  ops->go_raw = ser_windows_raw;
  ops->go_raw = ser_windows_raw;
  ops->setbaudrate = ser_windows_setbaudrate;
  ops->setbaudrate = ser_windows_setbaudrate;
  ops->setstopbits = ser_windows_setstopbits;
  ops->setstopbits = ser_windows_setstopbits;
  ops->drain_output = ser_windows_drain_output;
  ops->drain_output = ser_windows_drain_output;
  ops->readchar = ser_base_readchar;
  ops->readchar = ser_base_readchar;
  ops->write = ser_base_write;
  ops->write = ser_base_write;
  ops->async = ser_base_async;
  ops->async = ser_base_async;
  ops->read_prim = ser_windows_read_prim;
  ops->read_prim = ser_windows_read_prim;
  ops->write_prim = ser_windows_write_prim;
  ops->write_prim = ser_windows_write_prim;
  ops->wait_handle = ser_windows_wait_handle;
  ops->wait_handle = ser_windows_wait_handle;
 
 
  serial_add_interface (ops);
  serial_add_interface (ops);
 
 
  /* Next create the dummy serial driver used for terminals.  We only
  /* Next create the dummy serial driver used for terminals.  We only
     provide the TTY-related methods.  */
     provide the TTY-related methods.  */
 
 
  ops = XMALLOC (struct serial_ops);
  ops = XMALLOC (struct serial_ops);
  memset (ops, 0, sizeof (struct serial_ops));
  memset (ops, 0, sizeof (struct serial_ops));
 
 
  ops->name = "terminal";
  ops->name = "terminal";
  ops->next = 0;
  ops->next = 0;
 
 
  ops->close = ser_console_close;
  ops->close = ser_console_close;
  ops->get_tty_state = ser_console_get_tty_state;
  ops->get_tty_state = ser_console_get_tty_state;
  ops->set_tty_state = ser_base_set_tty_state;
  ops->set_tty_state = ser_base_set_tty_state;
  ops->print_tty_state = ser_base_print_tty_state;
  ops->print_tty_state = ser_base_print_tty_state;
  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
  ops->drain_output = ser_base_drain_output;
  ops->drain_output = ser_base_drain_output;
  ops->wait_handle = ser_console_wait_handle;
  ops->wait_handle = ser_console_wait_handle;
  ops->done_wait_handle = ser_console_done_wait_handle;
  ops->done_wait_handle = ser_console_done_wait_handle;
 
 
  serial_add_interface (ops);
  serial_add_interface (ops);
 
 
  /* The pipe interface.  */
  /* The pipe interface.  */
 
 
  ops = XMALLOC (struct serial_ops);
  ops = XMALLOC (struct serial_ops);
  memset (ops, 0, sizeof (struct serial_ops));
  memset (ops, 0, sizeof (struct serial_ops));
  ops->name = "pipe";
  ops->name = "pipe";
  ops->next = 0;
  ops->next = 0;
  ops->open = pipe_windows_open;
  ops->open = pipe_windows_open;
  ops->close = pipe_windows_close;
  ops->close = pipe_windows_close;
  ops->readchar = ser_base_readchar;
  ops->readchar = ser_base_readchar;
  ops->write = ser_base_write;
  ops->write = ser_base_write;
  ops->flush_output = ser_base_flush_output;
  ops->flush_output = ser_base_flush_output;
  ops->flush_input = ser_base_flush_input;
  ops->flush_input = ser_base_flush_input;
  ops->send_break = ser_base_send_break;
  ops->send_break = ser_base_send_break;
  ops->go_raw = ser_base_raw;
  ops->go_raw = ser_base_raw;
  ops->get_tty_state = ser_base_get_tty_state;
  ops->get_tty_state = ser_base_get_tty_state;
  ops->set_tty_state = ser_base_set_tty_state;
  ops->set_tty_state = ser_base_set_tty_state;
  ops->print_tty_state = ser_base_print_tty_state;
  ops->print_tty_state = ser_base_print_tty_state;
  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
  ops->setbaudrate = ser_base_setbaudrate;
  ops->setbaudrate = ser_base_setbaudrate;
  ops->setstopbits = ser_base_setstopbits;
  ops->setstopbits = ser_base_setstopbits;
  ops->drain_output = ser_base_drain_output;
  ops->drain_output = ser_base_drain_output;
  ops->async = ser_base_async;
  ops->async = ser_base_async;
  ops->read_prim = pipe_windows_read;
  ops->read_prim = pipe_windows_read;
  ops->write_prim = pipe_windows_write;
  ops->write_prim = pipe_windows_write;
  ops->wait_handle = pipe_wait_handle;
  ops->wait_handle = pipe_wait_handle;
  ops->done_wait_handle = pipe_done_wait_handle;
  ops->done_wait_handle = pipe_done_wait_handle;
  ops->avail = pipe_avail;
  ops->avail = pipe_avail;
 
 
  serial_add_interface (ops);
  serial_add_interface (ops);
 
 
  /* If WinSock works, register the TCP/UDP socket driver.  */
  /* If WinSock works, register the TCP/UDP socket driver.  */
 
 
  if (WSAStartup (MAKEWORD (1, 0), &wsa_data) != 0)
  if (WSAStartup (MAKEWORD (1, 0), &wsa_data) != 0)
    /* WinSock is unavailable.  */
    /* WinSock is unavailable.  */
    return;
    return;
 
 
  ops = XMALLOC (struct serial_ops);
  ops = XMALLOC (struct serial_ops);
  memset (ops, 0, sizeof (struct serial_ops));
  memset (ops, 0, sizeof (struct serial_ops));
  ops->name = "tcp";
  ops->name = "tcp";
  ops->next = 0;
  ops->next = 0;
  ops->open = net_windows_open;
  ops->open = net_windows_open;
  ops->close = net_windows_close;
  ops->close = net_windows_close;
  ops->readchar = ser_base_readchar;
  ops->readchar = ser_base_readchar;
  ops->write = ser_base_write;
  ops->write = ser_base_write;
  ops->flush_output = ser_base_flush_output;
  ops->flush_output = ser_base_flush_output;
  ops->flush_input = ser_base_flush_input;
  ops->flush_input = ser_base_flush_input;
  ops->send_break = ser_tcp_send_break;
  ops->send_break = ser_tcp_send_break;
  ops->go_raw = ser_base_raw;
  ops->go_raw = ser_base_raw;
  ops->get_tty_state = ser_base_get_tty_state;
  ops->get_tty_state = ser_base_get_tty_state;
  ops->set_tty_state = ser_base_set_tty_state;
  ops->set_tty_state = ser_base_set_tty_state;
  ops->print_tty_state = ser_base_print_tty_state;
  ops->print_tty_state = ser_base_print_tty_state;
  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
  ops->setbaudrate = ser_base_setbaudrate;
  ops->setbaudrate = ser_base_setbaudrate;
  ops->setstopbits = ser_base_setstopbits;
  ops->setstopbits = ser_base_setstopbits;
  ops->drain_output = ser_base_drain_output;
  ops->drain_output = ser_base_drain_output;
  ops->async = ser_base_async;
  ops->async = ser_base_async;
  ops->read_prim = net_read_prim;
  ops->read_prim = net_read_prim;
  ops->write_prim = net_write_prim;
  ops->write_prim = net_write_prim;
  ops->wait_handle = net_windows_wait_handle;
  ops->wait_handle = net_windows_wait_handle;
  ops->done_wait_handle = net_windows_done_wait_handle;
  ops->done_wait_handle = net_windows_done_wait_handle;
  serial_add_interface (ops);
  serial_add_interface (ops);
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.