Implement Async (#5)

app/test-uv.js

@@ -21,6 +21,11 @@ p(uv.Idle.prototype);
 print("Handle.prototype (via Idle.prototype)");
 p(Object.getPrototypeOf(uv.Idle.prototype));
 
+print("\nAsync.prototype");
+p(uv.Async.prototype);
+print("Handle.prototype (via Async.prototype)");
+p(Object.getPrototypeOf(uv.Async.prototype));
+
 print("\nTcp.prototype");
 p(uv.Tcp.prototype);
 print("Stream.prototype (via Tcp.prototype)");
@@ -29,13 +34,6 @@ p(streamProto);
 print("Handle.prototype (via Stream.prototype)");
 p(Object.getPrototypeOf(streamProto));
 
-print("\nTesting uv.walk");
-var timer = new uv.Timer();
-var tcp = new uv.Tcp();
-uv.walk(p);
-timer.close();
-tcp.close();
-
 var prepare = new uv.Prepare();
 prepare.start(function () {
   print("prepare...");
@@ -46,14 +44,28 @@ var check = new uv.Check();
 check.start(function () {
   print("check...");
 });
-check.unref();
 
 var idle = new uv.Idle();
 idle.start(function () {
   print("idle...");
   idle.stop();
 });
+
+var async = new uv.Async(function () {
+  print("async...");
+});
+p("async", async);
+async.send();
+
+print("\nTesting uv.walk");
+var timer = new uv.Timer();
+var tcp = new uv.Tcp();
+uv.walk(p);
+timer.close();
+tcp.close();
+check.unref();
 idle.unref();
+async.unref();
 
 print("\nTesting simple timeout");
 var timer = new uv.Timer();

implementations/duktape/duv/async.c

@@ -1 +1,22 @@
 #include "async.h"
+#include "utils.h"
+#include "callbacks.h"
+
+duk_ret_t duv_async(duk_context *ctx) {
+  dschema_check(ctx, (const duv_schema_entry[]) {
+    {"callback", duk_is_function},
+    {0,0}
+  });
+  uv_async_t *async = duk_push_fixed_buffer(ctx, sizeof(uv_async_t));
+  duv_check(ctx, uv_async_init(duv_loop(ctx), async, duv_on_async));
+  duv_setup_handle(ctx, (uv_handle_t*)async, DUV_ASYNC);
+  duk_insert(ctx, 0);
+  duk_put_prop_string(ctx, 0, "\xffon-async");
+  return 1;
+}
+
+duk_ret_t duv_async_send(duk_context *ctx) {
+  uv_async_t *async = duv_require_this_handle(ctx, DUV_ASYNC_MASK);
+  duv_check(ctx, uv_async_send(async));
+  return 0;
+}

implementations/duktape/duv/async.h

@@ -3,4 +3,7 @@
 
 #include "duv.h"
 
+duk_ret_t duv_async(duk_context *ctx);
+duk_ret_t duv_async_send(duk_context *ctx);
+
 #endif

implementations/duktape/duv/callbacks.c

@@ -31,6 +31,10 @@ void duv_on_idle(uv_idle_t *idle) {
   duv_call_callback((uv_handle_t*)idle, "\xffon-idle", 0);
 }
 
+void duv_on_async(uv_async_t *async) {
+  duv_call_callback((uv_handle_t*)async, "\xffon-async", 0);
+}
+
 void duv_on_read(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
   duk_context *ctx = stream->data;
   if (nread >= 0) {

implementations/duktape/duv/callbacks.h

@@ -19,6 +19,9 @@ void duv_on_check(uv_check_t *check);
 // Idle method callbacks
 void duv_on_idle(uv_idle_t *idle);
 
+// Async method callbacks
+void duv_on_async(uv_async_t *async);
+
 // Stream method callbacks
 void duv_on_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf);
 void duv_on_write(uv_write_t *shutdown, int status);

implementations/duktape/duv/duv.c

@@ -6,6 +6,7 @@
 #include "prepare.h"
 #include "check.h"
 #include "idle.h"
+#include "async.h"
 #include "stream.h"
 #include "tcp.h"
 
@@ -48,6 +49,11 @@ static const duk_function_list_entry duv_idle_methods[] = {
   {0,0,0}
 };
 
+static const duk_function_list_entry duv_async_methods[] = {
+  {"send", duv_async_send, 0},
+  {0,0,0}
+};
+
 static const duk_function_list_entry duv_stream_methods[] = {
   {"shutdown", duv_shutdown, 1},
   {"listen", duv_listen, 2},
@@ -86,6 +92,7 @@ static const duk_function_list_entry duv_funcs[] = {
   {"Prepare", duv_prepare, 0},
   {"Check", duv_new_check, 0},
   {"Idle", duv_idle, 0},
+  {"Async", duv_async, 1},
   {"Tcp", duv_tcp, 0},
 
   // // pipe.c
@@ -223,6 +230,17 @@ duk_ret_t duv_push_module(duk_context *ctx) {
 
   // stack: nucleus uv Handle.prototype
 
+  // uv.Async.prototype
+  duk_get_prop_string(ctx, -2, "Async");
+  duk_push_object(ctx);
+  duk_put_function_list(ctx, -1, duv_async_methods);
+  duk_dup(ctx, -3);
+  duk_set_prototype(ctx, -2);
+  duk_put_prop_string(ctx, -2, "prototype");
+  duk_pop(ctx);
+
+  // stack: nucleus uv Handle.prototype
+
   // uv.Stream.prototype
   duk_push_object(ctx);
   duk_put_function_list(ctx, -1, duv_stream_methods);

implementations/duktape/duv/duv.h

@@ -41,10 +41,10 @@ typedef enum {
   DUV_PREPARE_MASK = 1 << DUV_PREPARE,
   DUV_CHECK_MASK = 1 << DUV_CHECK,
   DUV_IDLE_MASK = 1 << DUV_IDLE,
+  DUV_ASYNC_MASK = 1 << DUV_ASYNC,
   DUV_POLL_MASK = 1 << DUV_POLL,
   DUV_SIGNAL_MASK = 1 << DUV_SIGNAL,
   DUV_PROCESS_MASK = 1 << DUV_PROCESS,
-  DUV_ASYNC_MASK = 1 << DUV_ASYNC,
   DUV_STREAM_MASK = 1 << DUV_TCP | 1 << DUV_PIPE | 1 << DUV_TTY,
   DUV_TCP_MASK = 1 << DUV_TCP,
   DUV_PIPE_MASK = 1 << DUV_PIPE,