/* Generic serial interface functions.
- Copyright (C) 1992-2018 Free Software Foundation, Inc.
+ Copyright (C) 1992-2023 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "serial.h"
#include "ser-base.h"
-#include "event-loop.h"
+#include "gdbsupport/event-loop.h"
-#include "gdb_select.h"
-#include "gdb_sys_time.h"
+#include "gdbsupport/gdb_select.h"
+#include "gdbsupport/gdb_sys_time.h"
#ifdef USE_WIN32API
#include <winsock2.h>
#endif
/* Value of scb->async_state: */
enum {
- /* >= 0 (TIMER_SCHEDULED) */
- /* The ID of the currently scheduled timer event. This state is
- rarely encountered. Timer events are one-off so as soon as the
- event is delivered the state is shanged to NOTHING_SCHEDULED. */
- FD_SCHEDULED = -1,
+ /* When >= 0, this contains the ID of the currently scheduled timer event.
+ This state is rarely encountered. Timer events are one-off so as soon as
+ the event is delivered the state is changed to NOTHING_SCHEDULED. */
+
/* The fd_event() handler is scheduled. It is called when ever the
file descriptor becomes ready. */
- NOTHING_SCHEDULED = -2
+ FD_SCHEDULED = -1,
+
/* Either no task is scheduled (just going into ASYNC mode) or a
timer event has just gone off and the current state has been
forced into nothing scheduled. */
+ NOTHING_SCHEDULED = -2
};
/* Identify and schedule the next ASYNC task based on scb->async_state
case NOTHING_SCHEDULED:
if (scb->bufcnt == 0)
{
- add_file_handler (scb->fd, fd_event, scb);
+ add_file_handler (scb->fd, fd_event, scb, "serial");
next_state = FD_SCHEDULED;
}
else
if (scb->bufcnt == 0)
{
delete_timer (scb->async_state);
- add_file_handler (scb->fd, fd_event, scb);
+ add_file_handler (scb->fd, fd_event, scb, "serial");
next_state = FD_SCHEDULED;
}
else
{
case FD_SCHEDULED:
if (scb->async_state != FD_SCHEDULED)
- fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
- scb->fd);
+ gdb_printf (gdb_stdlog, "[fd%d->fd-scheduled]\n",
+ scb->fd);
break;
default: /* TIMER SCHEDULED */
if (scb->async_state == FD_SCHEDULED)
- fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
- scb->fd);
+ gdb_printf (gdb_stdlog, "[fd%d->timer-scheduled]\n",
+ scb->fd);
break;
}
}
else if (scb->bufcnt == 0)
{
/* Prime the input FIFO. The readchar() function is used to
- pull characters out of the buffer. See also
- generic_readchar(). */
+ pull characters out of the buffer. See also
+ generic_readchar(). */
int nr;
do
/* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
error). Nag the client until all the data has been read. In the
case of errors, the client will need to close or de-async the
- device before naging stops. */
+ device before nagging stops. */
static void
push_event (void *context)
int nfds;
/* NOTE: Some OS's can scramble the READFDS when the select()
- call fails (ex the kernel with Red Hat 5.2). Initialize all
- arguments before each call. */
+ call fails (ex the kernel with Red Hat 5.2). Initialize all
+ arguments before each call. */
tv.tv_sec = timeout;
tv.tv_usec = 0;
while ((newline = strstr (current, "\n")) != NULL)
{
*newline = '\0';
- fputs_unfiltered (current, gdb_stderr);
- fputs_unfiltered ("\n", gdb_stderr);
+ gdb_puts (current, gdb_stderr);
+ gdb_puts ("\n", gdb_stderr);
current = newline + 1;
}
- fputs_unfiltered (current, gdb_stderr);
+ gdb_puts (current, gdb_stderr);
}
}
}
while (1)
{
/* N.B. The UI may destroy our world (for instance by calling
- remote_stop,) in which case we want to get out of here as
- quickly as possible. It is not safe to touch scb, since
- someone else might have freed it. The
- deprecated_ui_loop_hook signals that we should exit by
- returning 1. */
+ remote_stop,) in which case we want to get out of here as
+ quickly as possible. It is not safe to touch scb, since
+ someone else might have freed it. The
+ deprecated_ui_loop_hook signals that we should exit by
+ returning 1. */
if (deprecated_ui_loop_hook)
{
status = ser_base_wait_for (scb, delta);
if (timeout > 0)
- timeout -= delta;
+ timeout -= delta;
/* If we got a character or an error back from wait_for, then we can
- break from the loop before the timeout is completed. */
+ break from the loop before the timeout is completed. */
if (status != SERIAL_TIMEOUT)
break;
/* If we have exhausted the original timeout, then generate
- a SERIAL_TIMEOUT, and pass it out of the loop. */
+ a SERIAL_TIMEOUT, and pass it out of the loop. */
else if (timeout == 0)
{
status = SERIAL_TIMEOUT;
if (status <= 0)
{
if (status == 0)
- return SERIAL_EOF;
+ return SERIAL_EOF;
else
/* Got an error from read. */
return SERIAL_ERROR;
/* Force a re-schedule. */
scb->async_state = NOTHING_SCHEDULED;
if (serial_debug_p (scb))
- fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
- scb->fd);
+ gdb_printf (gdb_stdlog, "[fd%d->asynchronous]\n",
+ scb->fd);
reschedule (scb);
if (scb->error_fd != -1)
- add_file_handler (scb->error_fd, handle_error_fd, scb);
+ add_file_handler (scb->error_fd, handle_error_fd, scb, "serial-error");
}
else
{
if (serial_debug_p (scb))
- fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
- scb->fd);
+ gdb_printf (gdb_stdlog, "[fd%d->synchronous]\n",
+ scb->fd);
/* De-schedule whatever tasks are currently scheduled. */
switch (scb->async_state)
{
projects / binutils-gdb.git / blobdiff