c/libuv
1
0
Fork 0
mirror of https://github.com/libuv/libuv synced 2025-03-28 21:13:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Split up uv_loop type

Browse Source
This commit is contained in:
Bert Belder 2011-06-17 18:39:18 +02:00
parent debae03771
commit 4eb06151bd
14 changed files with 185 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/benchmark-pump.c
View File

@ -79,7 +79,7 @@ static double gbit(int64_t bytes, int64_t passed_ms) {
}
static void show_stats(uv_handle_t *handle, int status) {
static void show_stats(uv_timer_t* handle, int status) {
int64_t diff;
#if PRINT_STATS

12
test/test-async.c
View File

@ -118,8 +118,8 @@ static void close_cb(uv_handle_t* handle) {
}
static void async1_cb(uv_handle_t* handle, int status) {
ASSERT(handle == (uv_handle_t*)&async1_handle);
static void async1_cb(uv_async_t* handle, int status) {
ASSERT(handle == &async1_handle);
ASSERT(status == 0);
async1_cb_called++;
@ -127,7 +127,7 @@ static void async1_cb(uv_handle_t* handle, int status) {
if (async1_cb_called > 2 && !async1_closed) {
async1_closed = 1;
uv_close(handle, close_cb);
uv_close((uv_handle_t*)handle, close_cb);
}
}
@ -147,10 +147,10 @@ static void async2_cb(uv_handle_t* handle, int status) {
#endif
static void prepare_cb(uv_handle_t* handle, int status) {
static void prepare_cb(uv_prepare_t* handle, int status) {
int r;
ASSERT(handle == (uv_handle_t*)&prepare_handle);
ASSERT(handle == &prepare_handle);
ASSERT(status == 0);
switch (prepare_cb_called) {
@ -172,7 +172,7 @@ static void prepare_cb(uv_handle_t* handle, int status) {
#endif
case 1:
r = uv_close(handle, close_cb);
r = uv_close((uv_handle_t*)handle, close_cb);
ASSERT(r == 0);
break;

6
test/test-callback-stack.c
View File

@ -109,10 +109,10 @@ static void read_cb(uv_tcp_t* tcp, ssize_t nread, uv_buf_t buf) {
}
static void timer_cb(uv_handle_t* handle, int status) {
static void timer_cb(uv_timer_t* handle, int status) {
int r;
ASSERT(handle == (uv_handle_t*)&timer);
ASSERT(handle == &timer);
ASSERT(status == 0);
ASSERT(nested == 0 && "timer_cb must be called from a fresh stack");
@ -126,7 +126,7 @@ static void timer_cb(uv_handle_t* handle, int status) {
timer_cb_called++;
r = uv_close(handle, close_cb);
r = uv_close((uv_handle_t*)handle, close_cb);
ASSERT(r == 0);
}

4
test/test-connection-fail.c
View File

@ -46,7 +46,7 @@ static void timer_close_cb(uv_handle_t* handle) {
}
static void timer_cb(uv_handle_t* handle, int status) {
static void timer_cb(uv_timer_t* handle, int status) {
ASSERT(status == 0);
timer_cb_calls++;
@ -62,7 +62,7 @@ static void timer_cb(uv_handle_t* handle, int status) {
uv_close((uv_handle_t*)&tcp, on_close);
/* Close the timer. */
uv_close(handle, timer_close_cb);
uv_close((uv_handle_t*)handle, timer_close_cb);
}

4
test/test-delayed-accept.c
View File

@ -49,7 +49,7 @@ static void close_cb(uv_handle_t* handle) {
}
static void do_accept(uv_handle_t* timer_handle, int status) {
static void do_accept(uv_timer_t* timer_handle, int status) {
uv_tcp_t* server;
uv_tcp_t* accepted_handle = (uv_tcp_t*)malloc(sizeof *accepted_handle);
int r;
@ -83,7 +83,7 @@ static void do_accept(uv_handle_t* timer_handle, int status) {
}
/* Dispose the timer. */
r = uv_close(timer_handle, close_cb);
r = uv_close((uv_handle_t*)timer_handle, close_cb);
ASSERT(r == 0);
}

24
test/test-loop-handles.c
View File

@ -109,8 +109,8 @@ static int idle_2_is_active = 0;
static int timer_cb_called = 0;
static void timer_cb(uv_handle_t* handle, int status) {
ASSERT(handle == (uv_handle_t*)&timer_handle);
static void timer_cb(uv_timer_t* handle, int status) {
ASSERT(handle == &timer_handle);
ASSERT(status == 0);
timer_cb_called++;
@ -129,22 +129,22 @@ static void idle_2_close_cb(uv_handle_t* handle) {
}
static void idle_2_cb(uv_handle_t* handle, int status) {
static void idle_2_cb(uv_idle_t* handle, int status) {
int r;
LOG("IDLE_2_CB\n");
ASSERT(handle == (uv_handle_t*)&idle_2_handle);
ASSERT(handle == &idle_2_handle);
ASSERT(status == 0);
idle_2_cb_called++;
r = uv_close(handle, idle_2_close_cb);
r = uv_close((uv_handle_t*)handle, idle_2_close_cb);
ASSERT(r == 0);
}
static void idle_1_cb(uv_handle_t* handle, int status) {
static void idle_1_cb(uv_idle_t* handle, int status) {
int r;
LOG("IDLE_1_CB\n");
@ -207,12 +207,12 @@ static void prepare_2_close_cb(uv_handle_t* handle) {
}
static void check_cb(uv_handle_t* handle, int status) {
static void check_cb(uv_check_t* handle, int status) {
int i, r;
LOG("CHECK_CB\n");
ASSERT(handle == (uv_handle_t*)&check_handle);
ASSERT(handle == &check_handle);
ASSERT(status == 0);
/* XXX
@ -254,12 +254,12 @@ static void check_cb(uv_handle_t* handle, int status) {
}
static void prepare_2_cb(uv_handle_t* handle, int status) {
static void prepare_2_cb(uv_prepare_t* handle, int status) {
int r;
LOG("PREPARE_2_CB\n");
ASSERT(handle == (uv_handle_t*)&prepare_2_handle);
ASSERT(handle == &prepare_2_handle);
ASSERT(status == 0);
/* XXX ASSERT(idles_1_active == 0); */
@ -278,12 +278,12 @@ static void prepare_2_cb(uv_handle_t* handle, int status) {
}
static void prepare_1_cb(uv_handle_t* handle, int status) {
static void prepare_1_cb(uv_prepare_t* handle, int status) {
int r;
LOG("PREPARE_1_CB\n");
ASSERT(handle == (uv_handle_t*)&prepare_1_handle);
ASSERT(handle == &prepare_1_handle);
ASSERT(status == 0);
/* XXX

6
test/test-shutdown-eof.c
View File

@ -120,9 +120,9 @@ void timer_close_cb(uv_handle_t* handle) {
}
void timer_cb(uv_handle_t* handle, int status) {
ASSERT(handle == (uv_handle_t*) &timer);
uv_close(handle, timer_close_cb);
void timer_cb(uv_timer_t* handle, int status) {
ASSERT(handle == &timer);
uv_close((uv_handle_t*) handle, timer_close_cb);
/*
* The most important assert of the test: we have not received

14
test/test-timer-again.c
View File

@ -41,10 +41,10 @@ static void close_cb(uv_handle_t* handle) {
}
static void repeat_1_cb(uv_handle_t* handle, int status) {
static void repeat_1_cb(uv_timer_t* handle, int status) {
int r;
ASSERT(handle == (uv_handle_t*)&repeat_1);
ASSERT(handle == &repeat_1);
ASSERT(status == 0);
ASSERT(uv_timer_get_repeat((uv_timer_t*)handle) == 50);
@ -57,7 +57,7 @@ static void repeat_1_cb(uv_handle_t* handle, int status) {
ASSERT(r == 0);
if (uv_now() >= start_time + 500) {
uv_close(handle, close_cb);
uv_close((uv_handle_t*)handle, close_cb);
/* We're not calling uv_timer_again on repeat_2 any more, so after this */
/* timer_2_cb is expected. */
repeat_2_cb_allowed = 1;
@ -66,8 +66,8 @@ static void repeat_1_cb(uv_handle_t* handle, int status) {
}
static void repeat_2_cb(uv_handle_t* handle, int status) {
ASSERT(handle == (uv_handle_t*) &repeat_2);
static void repeat_2_cb(uv_timer_t* handle, int status) {
ASSERT(handle == &repeat_2);
ASSERT(status == 0);
ASSERT(repeat_2_cb_allowed);
@ -76,8 +76,8 @@ static void repeat_2_cb(uv_handle_t* handle, int status) {
repeat_2_cb_called++;
if (uv_timer_get_repeat(&repeat_2) == 0) {
ASSERT(!uv_is_active(handle));
uv_close(handle, close_cb);
ASSERT(!uv_is_active((uv_handle_t*)handle));
uv_close((uv_handle_t*)handle, close_cb);
return;
}

10
test/test-timer.c
View File

@ -42,7 +42,7 @@ static void once_close_cb(uv_handle_t* handle) {
}
static void once_cb(uv_handle_t* handle, int status) {
static void once_cb(uv_timer_t* handle, int status) {
printf("ONCE_CB %d\n", once_cb_called);
ASSERT(handle != NULL);
@ -50,7 +50,7 @@ static void once_cb(uv_handle_t* handle, int status) {
once_cb_called++;
uv_close(handle, once_close_cb);
uv_close((uv_handle_t*)handle, once_close_cb);
/* Just call this randomly for the code coverage. */
uv_update_time();
@ -66,7 +66,7 @@ static void repeat_close_cb(uv_handle_t* handle) {
}
static void repeat_cb(uv_handle_t* handle, int status) {
static void repeat_cb(uv_timer_t* handle, int status) {
printf("REPEAT_CB\n");
ASSERT(handle != NULL);
@ -75,12 +75,12 @@ static void repeat_cb(uv_handle_t* handle, int status) {
repeat_cb_called++;
if (repeat_cb_called == 5) {
uv_close(handle, repeat_close_cb);
uv_close((uv_handle_t*)handle, repeat_close_cb);
}
}
static void never_cb(uv_handle_t* handle, int status) {
static void never_cb(uv_timer_t* handle, int status) {
FATAL("never_cb should never be called");
}

18
uv-unix.c
View File

@ -967,7 +967,7 @@ static void uv__prepare(EV_P_ ev_prepare* w, int revents) {
uv_prepare_t* prepare = w->data;
if (prepare->prepare_cb) {
prepare->prepare_cb((uv_handle_t*)prepare, 0);
prepare->prepare_cb(prepare, 0);
}
}
@ -985,7 +985,7 @@ int uv_prepare_init(uv_prepare_t* prepare) {
}
int uv_prepare_start(uv_prepare_t* prepare, uv_loop_cb cb) {
int uv_prepare_start(uv_prepare_t* prepare, uv_prepare_cb cb) {
int was_active = ev_is_active(&prepare->prepare_watcher);
prepare->prepare_cb = cb;
@ -1017,7 +1017,7 @@ static void uv__check(EV_P_ ev_check* w, int revents) {
uv_check_t* check = w->data;
if (check->check_cb) {
check->check_cb((uv_handle_t*)check, 0);
check->check_cb(check, 0);
}
}
@ -1035,7 +1035,7 @@ int uv_check_init(uv_check_t* check) {
}
int uv_check_start(uv_check_t* check, uv_loop_cb cb) {
int uv_check_start(uv_check_t* check, uv_check_cb cb) {
int was_active = ev_is_active(&check->check_watcher);
check->check_cb = cb;
@ -1067,7 +1067,7 @@ static void uv__idle(EV_P_ ev_idle* w, int revents) {
uv_idle_t* idle = (uv_idle_t*)(w->data);
if (idle->idle_cb) {
idle->idle_cb((uv_handle_t*)idle, 0);
idle->idle_cb(idle, 0);
}
}
@ -1086,7 +1086,7 @@ int uv_idle_init(uv_idle_t* idle) {
}
int uv_idle_start(uv_idle_t* idle, uv_loop_cb cb) {
int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb) {
int was_active = ev_is_active(&idle->idle_watcher);
idle->idle_cb = cb;
@ -1137,7 +1137,7 @@ static void uv__async(EV_P_ ev_async* w, int revents) {
uv_async_t* async = w->data;
if (async->async_cb) {
async->async_cb((uv_handle_t*)async, 0);
async->async_cb(async, 0);
}
}
@ -1172,7 +1172,7 @@ static void uv__timer_cb(EV_P_ ev_timer* w, int revents) {
}
if (timer->timer_cb) {
timer->timer_cb((uv_handle_t*)timer, 0);
timer->timer_cb(timer, 0);
}
}
@ -1188,7 +1188,7 @@ int uv_timer_init(uv_timer_t* timer) {
}
int uv_timer_start(uv_timer_t* timer, uv_loop_cb cb, int64_t timeout,
int uv_timer_start(uv_timer_t* timer, uv_timer_cb cb, int64_t timeout,
int64_t repeat) {
if (ev_is_active(&timer->timer_watcher)) {
return -1;

10
uv-unix.h
View File

@ -70,31 +70,31 @@ typedef struct {
/* UV_PREPARE */ \
#define UV_PREPARE_PRIVATE_FIELDS \
ev_prepare prepare_watcher; \
uv_loop_cb prepare_cb;
uv_prepare_cb prepare_cb;
/* UV_CHECK */
#define UV_CHECK_PRIVATE_FIELDS \
ev_check check_watcher; \
uv_loop_cb check_cb;
uv_check_cb check_cb;
/* UV_IDLE */
#define UV_IDLE_PRIVATE_FIELDS \
ev_idle idle_watcher; \
uv_loop_cb idle_cb;
uv_idle_cb idle_cb;
/* UV_ASYNC */
#define UV_ASYNC_PRIVATE_FIELDS \
ev_async async_watcher; \
uv_loop_cb async_cb;
uv_async_cb async_cb;
/* UV_TIMER */
#define UV_TIMER_PRIVATE_FIELDS \
ev_timer timer_watcher; \
uv_loop_cb timer_cb;
uv_timer_cb timer_cb;
#endif /* UV_UNIX_H */

252
uv-win.c
View File

@ -149,17 +149,6 @@ RB_PROTOTYPE_STATIC(uv_timer_tree_s, uv_timer_s, tree_entry, uv_timer_compare)
static struct uv_timer_tree_s uv_timers_ = RB_INITIALIZER(uv_timers_);
/* Lists of active uv_prepare / uv_check / uv_idle watchers */
static uv_handle_t* uv_prepare_handles_ = NULL;
static uv_handle_t* uv_check_handles_ = NULL;
static uv_handle_t* uv_idle_handles_ = NULL;
/* This pointer will refer to the prepare/check/idle handle whose callback */
/* is scheduled to be called next. This is needed to allow safe removal */
/* from one of the lists above while that list being iterated. */
static uv_handle_t* uv_next_loop_handle_ = NULL;
/* Head of a single-linked list of closed handles */
static uv_handle_t* uv_endgame_handles_ = NULL;
@ -569,7 +558,7 @@ static void uv_timer_endgame(uv_timer_t* handle) {
}
static void uv_loop_endgame(uv_handle_t* handle) {
static void uv_loop_watcher_endgame(uv_handle_t* handle) {
if (handle->flags & UV_HANDLE_CLOSING) {
assert(!(handle->flags & UV_HANDLE_CLOSED));
handle->flags |= UV_HANDLE_CLOSED;
@ -619,7 +608,7 @@ static void uv_process_endgames() {
case UV_PREPARE:
case UV_CHECK:
case UV_IDLE:
uv_loop_endgame(handle);
uv_loop_watcher_endgame(handle);
break;
case UV_ASYNC:
@ -1258,7 +1247,7 @@ int uv_timer_init(uv_timer_t* handle) {
}
int uv_timer_start(uv_timer_t* handle, uv_loop_cb timer_cb, int64_t timeout, int64_t repeat) {
int uv_timer_start(uv_timer_t* handle, uv_timer_cb timer_cb, int64_t timeout, int64_t repeat) {
if (handle->flags & UV_HANDLE_ACTIVE) {
RB_REMOVE(uv_timer_tree_s, &uv_timers_, handle);
}
@ -1341,140 +1330,103 @@ int64_t uv_now() {
}
int uv_loop_init(uv_handle_t* handle) {
handle->flags = 0;
handle->error = uv_ok_;
uv_refs_++;
return 0;
}
static int uv_loop_start(uv_handle_t* handle, uv_loop_cb loop_cb,
uv_handle_t** list) {
uv_handle_t* old_head;
if (handle->flags & UV_HANDLE_ACTIVE)
return 0;
old_head = *list;
handle->loop_next = old_head;
handle->loop_prev = NULL;
if (old_head) {
old_head->loop_prev = handle;
#define UV_LOOP_WATCHER_DEFINE(name, NAME) \
/* Lists of active loop (prepare / check / idle) watchers */ \
static uv_##name##_t* uv_##name##_handles_ = NULL; \
\
/* This pointer will refer to the prepare/check/idle handle whose */ \
/* callback is scheduled to be called next. This is needed to allow */ \
/* safe removal from one of the lists above while that list being */ \
/* iterated over. */ \
static uv_##name##_t* uv_next_##name##_handle_ = NULL; \
\
\
int uv_##name##_init(uv_##name##_t* handle) { \
handle->type = UV_##NAME; \
handle->flags = 0; \
handle->error = uv_ok_; \
\
uv_refs_++; \
\
uv_counters()->handle_init++; \
uv_counters()->prepare_init++; \
\
return 0; \
} \
\
\
int uv_##name##_start(uv_##name##_t* handle, uv_##name##_cb cb) { \
uv_##name##_t* old_head; \
\
assert(handle->type == UV_##NAME); \
\
if (handle->flags & UV_HANDLE_ACTIVE) \
return 0; \
\
old_head = uv_##name##_handles_; \
\
handle->name##_next = old_head; \
handle->name##_prev = NULL; \
\
if (old_head) { \
old_head->name##_prev = handle; \
} \
\
uv_##name##_handles_ = handle; \
\
handle->name##_cb = cb; \
handle->flags |= UV_HANDLE_ACTIVE; \
\
return 0; \
} \
\
\
int uv_##name##_stop(uv_##name##_t* handle) { \
assert(handle->type == UV_##NAME); \
\
if (!(handle->flags & UV_HANDLE_ACTIVE)) \
return 0; \
\
/* Update loop head if needed */ \
if (uv_##name##_handles_ == handle) { \
uv_##name##_handles_ = handle->name##_next; \
} \
\
/* Update the iterator-next pointer of needed */ \
if (uv_next_##name##_handle_ == handle) { \
uv_next_##name##_handle_ = handle->name##_next; \
} \
\
if (handle->name##_prev) { \
handle->name##_prev->name##_next = handle->name##_next; \
} \
if (handle->name##_next) { \
handle->name##_next->name##_prev = handle->name##_prev; \
} \
\
handle->flags &= ~UV_HANDLE_ACTIVE; \
\
return 0; \
} \
\
\
static void uv_##name##_invoke() { \
uv_##name##_t* handle; \
\
uv_next_##name##_handle_ = uv_##name##_handles_; \
\
while (uv_next_##name##_handle_ != NULL) { \
handle = uv_next_##name##_handle_; \
uv_next_##name##_handle_ = handle->name##_next; \
\
handle->name##_cb(handle, 0); \
} \
}
*list = handle;
handle->loop_cb = loop_cb;
handle->flags |= UV_HANDLE_ACTIVE;
return 0;
}
static int uv_loop_stop(uv_handle_t* handle, uv_handle_t** list) {
if (!(handle->flags & UV_HANDLE_ACTIVE))
return 0;
/* Update loop head if needed */
if (*list == handle) {
*list = handle->loop_next;
}
/* Update the iterator-next pointer of needed */
if (uv_next_loop_handle_ == handle) {
uv_next_loop_handle_ = handle->loop_next;
}
if (handle->loop_prev) {
handle->loop_prev->loop_next = handle->loop_next;
}
if (handle->loop_next) {
handle->loop_next->loop_prev = handle->loop_prev;
}
handle->flags &= ~UV_HANDLE_ACTIVE;
return 0;
}
static void uv_loop_invoke(uv_handle_t* list) {
uv_handle_t *handle;
uv_next_loop_handle_ = list;
while (uv_next_loop_handle_ != NULL) {
handle = uv_next_loop_handle_;
uv_next_loop_handle_ = handle->loop_next;
handle->loop_cb(handle, 0);
}
}
int uv_prepare_init(uv_prepare_t* handle) {
uv_counters()->handle_init++;
uv_counters()->prepare_init++;
handle->type = UV_PREPARE;
return uv_loop_init((uv_handle_t*)handle);
}
int uv_check_init(uv_check_t* handle) {
uv_counters()->handle_init++;
uv_counters()->check_init++;
handle->type = UV_CHECK;
return uv_loop_init((uv_handle_t*)handle);
}
int uv_idle_init(uv_idle_t* handle) {
uv_counters()->handle_init++;
uv_counters()->idle_init++;
handle->type = UV_IDLE;
return uv_loop_init((uv_handle_t*)handle);
}
int uv_prepare_start(uv_prepare_t* handle, uv_loop_cb loop_cb) {
assert(handle->type == UV_PREPARE);
return uv_loop_start((uv_handle_t*)handle, loop_cb, &uv_prepare_handles_);
}
int uv_check_start(uv_check_t* handle, uv_loop_cb loop_cb) {
assert(handle->type == UV_CHECK);
return uv_loop_start((uv_handle_t*)handle, loop_cb, &uv_check_handles_);
}
int uv_idle_start(uv_idle_t* handle, uv_loop_cb loop_cb) {
assert(handle->type == UV_IDLE);
return uv_loop_start((uv_handle_t*)handle, loop_cb, &uv_idle_handles_);
}
int uv_prepare_stop(uv_prepare_t* handle) {
assert(handle->type == UV_PREPARE);
return uv_loop_stop((uv_handle_t*)handle, &uv_prepare_handles_);
}
int uv_check_stop(uv_check_t* handle) {
assert(handle->type == UV_CHECK);
return uv_loop_stop((uv_handle_t*)handle, &uv_check_handles_);
}
int uv_idle_stop(uv_idle_t* handle) {
assert(handle->type == UV_IDLE);
return uv_loop_stop((uv_handle_t*)handle, &uv_idle_handles_);
}
UV_LOOP_WATCHER_DEFINE(prepare, PREPARE)
UV_LOOP_WATCHER_DEFINE(check, CHECK)
UV_LOOP_WATCHER_DEFINE(idle, IDLE)
int uv_is_active(uv_handle_t* handle) {
@ -1541,7 +1493,7 @@ static void uv_async_return_req(uv_async_t* handle, uv_req_t* req) {
handle->async_sent = 0;
if (req->cb) {
((uv_async_cb)req->cb)((uv_handle_t*)handle, 0);
((uv_async_cb)req->cb)((uv_async_t*) handle, 0);
}
if (handle->flags & UV_HANDLE_CLOSING) {
uv_want_endgame((uv_handle_t*)handle);
@ -1595,7 +1547,7 @@ static void uv_process_timers() {
timer->flags &= ~UV_HANDLE_ACTIVE;
}
timer->timer_cb((uv_handle_t*) timer, 0);
timer->timer_cb((uv_timer_t*) timer, 0);
}
}
@ -1676,18 +1628,18 @@ int uv_run() {
}
/* Call idle callbacks */
uv_loop_invoke(uv_idle_handles_);
uv_idle_invoke();
}
if (uv_refs_ <= 0) {
break;
}
uv_loop_invoke(uv_prepare_handles_);
uv_prepare_invoke();
uv_poll();
uv_loop_invoke(uv_check_handles_);
uv_check_invoke();
}
assert(uv_refs_ == 0);

30
uv-win.h
View File

@ -81,32 +81,32 @@ typedef struct uv_buf_t {
RB_ENTRY(uv_timer_s) tree_entry; \
int64_t due; \
int64_t repeat; \
uv_loop_cb timer_cb;
#define UV_LOOP_PRIVATE_FIELDS \
uv_handle_t* loop_prev; \
uv_handle_t* loop_next; \
uv_loop_cb loop_cb;
uv_timer_cb timer_cb;
#define UV_ASYNC_PRIVATE_FIELDS \
struct uv_req_s async_req; \
/* char to avoid alignment issues */ \
char volatile async_sent;
#define UV_PREPARE_PRIVATE_FIELDS /* empty */
#define UV_CHECK_PRIVATE_FIELDS /* empty */
#define UV_IDLE_PRIVATE_FIELDS /* empty */
#define UV_PREPARE_PRIVATE_FIELDS \
uv_prepare_t* prepare_prev; \
uv_prepare_t* prepare_next; \
uv_prepare_cb prepare_cb;
/*
* TODO: remove UV_LOOP_PRIVATE_FIELDS from UV_HANDLE_PRIVATE_FIELDS and
* use it in UV_(PREPARE|CHECK|IDLE)_PRIVATE_FIELDS instead.
*/
#define UV_CHECK_PRIVATE_FIELDS \
uv_check_t* check_prev; \
uv_check_t* check_next; \
uv_check_cb check_cb;
#define UV_IDLE_PRIVATE_FIELDS \
uv_idle_t* idle_prev; \
uv_idle_t* idle_next; \
uv_idle_cb idle_cb;
#define UV_HANDLE_PRIVATE_FIELDS \
uv_handle_t* endgame_next; \
unsigned int flags; \
uv_err_t error; \
UV_LOOP_PRIVATE_FIELDS
uv_err_t error;
int uv_utf16_to_utf8(wchar_t* utf16Buffer, size_t utf16Size, char* utf8Buffer, size_t utf8Size);

22
uv.h
View File

@ -47,6 +47,7 @@ typedef struct uv_prepare_s uv_prepare_t;
typedef struct uv_check_s uv_check_t;
typedef struct uv_idle_s uv_idle_t;
typedef struct uv_req_s uv_req_t;
typedef struct uv_async_s uv_async_t;
#if defined(__unix__) || defined(__POSIX__) || defined(__APPLE__)
@ -71,9 +72,12 @@ typedef void (*uv_connect_cb)(uv_req_t* req, int status);
typedef void (*uv_shutdown_cb)(uv_req_t* req, int status);
typedef void (*uv_connection_cb)(uv_tcp_t* server, int status);
typedef void (*uv_close_cb)(uv_handle_t* handle);
/* TODO: do loop_cb and async_cb really need a status argument? */
typedef void (*uv_loop_cb)(uv_handle_t* handle, int status);
typedef void (*uv_async_cb)(uv_handle_t* handle, int status);
typedef void (*uv_timer_cb)(uv_timer_t* handle, int status);
/* TODO: do these really need a status argument? */
typedef void (*uv_async_cb)(uv_async_t* handle, int status);
typedef void (*uv_prepare_cb)(uv_prepare_t* handle, int status);
typedef void (*uv_check_cb)(uv_check_t* handle, int status);
typedef void (*uv_idle_cb)(uv_idle_t* handle, int status);
/* Expand this list if necessary. */
@ -269,7 +273,7 @@ struct uv_prepare_s {
int uv_prepare_init(uv_prepare_t* prepare);
int uv_prepare_start(uv_prepare_t* prepare, uv_loop_cb cb);
int uv_prepare_start(uv_prepare_t* prepare, uv_prepare_cb cb);
int uv_prepare_stop(uv_prepare_t* prepare);
@ -286,7 +290,7 @@ struct uv_check_s {
int uv_check_init(uv_check_t* check);
int uv_check_start(uv_check_t* check, uv_loop_cb cb);
int uv_check_start(uv_check_t* check, uv_check_cb cb);
int uv_check_stop(uv_check_t* check);
@ -304,7 +308,7 @@ struct uv_idle_s {
int uv_idle_init(uv_idle_t* idle);
int uv_idle_start(uv_idle_t* idle, uv_loop_cb cb);
int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb);
int uv_idle_stop(uv_idle_t* idle);
@ -317,10 +321,10 @@ int uv_idle_stop(uv_idle_t* idle);
* after the call to async_send. Unlike all other libuv functions,
* uv_async_send can be called from another thread.
*/
typedef struct {
struct uv_async_s {
UV_HANDLE_FIELDS
UV_ASYNC_PRIVATE_FIELDS
} uv_async_t;
};
int uv_async_init(uv_async_t* async, uv_async_cb async_cb);
@ -338,7 +342,7 @@ struct uv_timer_s {
int uv_timer_init(uv_timer_t* timer);
int uv_timer_start(uv_timer_t* timer, uv_loop_cb cb, int64_t timeout, int64_t repeat);
int uv_timer_start(uv_timer_t* timer, uv_timer_cb cb, int64_t timeout, int64_t repeat);
int uv_timer_stop(uv_timer_t* timer);