};
enum io_state {
- IO,
- NEXT, /* eg starting, woken from idle, return from io_break. */
- IDLE,
- FINISHED,
- PROCESSING /* We expect them to change this now. */
+ IO_IO,
+ IO_NEXT, /* eg starting, woken from idle, return from io_break. */
+ IO_IDLE,
+ IO_FINISHED
};
static inline enum io_state from_ioplan(struct io_plan *op)
conn->finish = finish;
conn->finish_arg = conn->next_arg = arg;
conn->pollflag = 0;
- conn->state = NEXT;
+ conn->state = IO_NEXT;
conn->duplex = NULL;
conn->timeout = NULL;
if (!add_conn(conn)) {
conn->finish = finish;
conn->finish_arg = conn->next_arg = arg;
conn->pollflag = 0;
- conn->state = NEXT;
+ conn->state = IO_NEXT;
conn->duplex = old;
conn->timeout = NULL;
if (!add_duplex(conn)) {
conn->next = cb;
conn->next_arg = arg;
conn->pollflag = POLLOUT;
- return to_ioplan(IO);
+ return to_ioplan(IO_IO);
}
static enum io_result do_read(struct io_conn *conn)
conn->next = cb;
conn->next_arg = arg;
conn->pollflag = POLLIN;
- return to_ioplan(IO);
+ return to_ioplan(IO_IO);
}
static enum io_result do_read_partial(struct io_conn *conn)
conn->next = cb;
conn->next_arg = arg;
conn->pollflag = POLLIN;
- return to_ioplan(IO);
+ return to_ioplan(IO_IO);
}
static enum io_result do_write_partial(struct io_conn *conn)
conn->next = cb;
conn->next_arg = arg;
conn->pollflag = POLLOUT;
- return to_ioplan(IO);
+ return to_ioplan(IO_IO);
}
struct io_plan *io_idle(struct io_conn *conn)
{
conn->pollflag = 0;
- return to_ioplan(IDLE);
+ return to_ioplan(IO_IDLE);
}
void io_wake_(struct io_conn *conn,
{
/* It might have finished, but we haven't called its finish() yet. */
- if (conn->state == FINISHED)
+ if (conn->state == IO_FINISHED)
return;
- assert(conn->state == IDLE);
+ assert(conn->state == IO_IDLE);
conn->next = fn;
conn->next_arg = arg;
- backend_set_state(conn, to_ioplan(NEXT));
+ backend_set_state(conn, to_ioplan(IO_NEXT));
}
static struct io_plan *do_next(struct io_conn *conn)
struct io_plan *do_ready(struct io_conn *conn)
{
- assert(conn->state == IO);
+ assert(conn->state == IO_IO);
switch (conn->io(conn)) {
case RESULT_CLOSE:
return io_close(conn, NULL);
/* Close the connection, we're done. */
struct io_plan *io_close(struct io_conn *conn, void *arg)
{
- return to_ioplan(FINISHED);
+ return to_ioplan(IO_FINISHED);
}
/* Exit the loop, returning this (non-NULL) arg. */
conn->next = fn;
conn->next_arg = arg;
- return to_ioplan(NEXT);
+ return to_ioplan(IO_NEXT);
}
conn->duplex->duplex = NULL;
} else
del_fd(&conn->fd);
- if (conn->state == FINISHED)
+ if (conn->state == IO_FINISHED)
num_finished--;
- else if (conn->state == NEXT)
+ else if (conn->state == IO_NEXT)
num_next--;
}
if (pfd->events)
num_waiting++;
- if (state == NEXT)
+ if (state == IO_NEXT)
num_next++;
- else if (state == FINISHED)
+ else if (state == IO_FINISHED)
num_finished++;
conn->state = state;
continue;
c = (void *)fds[i];
for (duplex = c->duplex; c; c = duplex, duplex = NULL) {
- if (c->state == FINISHED) {
+ if (c->state == IO_FINISHED) {
del_conn(c);
free(c);
i--;
- } else if (!finished_only && c->state == NEXT) {
+ } else if (!finished_only && c->state == IO_NEXT) {
backend_set_state(c, c->next(c, c->next_arg));
num_next--;
}