rua 0.1.3 → 0.1.4

data/README.txt

@@ -45,3 +45,24 @@ Rua is a library for using Lua under Ruby.
     
     rua.f.call
     p rua.eval('return 1, 2, 3')
+    
+    co = rua.eval(<<-EOS)
+      function foo (a)
+        print('foo', a)
+        return coroutine.yield(2 * a)
+      end
+    
+      return coroutine.create(function (a, b)
+        print('co-body', a, b)
+        local r = foo(a + 1)
+        print('co-body', r)
+        local r, s = coroutine.yield(a + b, a - b)
+        print('co-body', r, s)
+        return b, 'end'
+      end)
+    EOS
+    
+    p co.resume(1, 10)
+    p co.resume('r')
+    p co.resume('x', 'y')
+    p co.resume('x', 'y')

data/ext/rua.c

@@ -71,16 +71,17 @@ static const char *insecure_methods[] = {
 };
 
 static const int insecure_method_num = sizeof(insecure_methods) / sizeof(char*);
-static VALUE Rua, RuaFunc, RuaError;
+static VALUE Rua, RuaFunc, RuaThread, RuaError;
 static VALUE s_all, s_base, s_package, s_string, s_table, s_math, s_io, s_debug;
 
 void Init_rua() {
   Rua = rb_define_class("Rua", rb_cObject);
   RuaFunc = rb_define_class("RuaFunc", rb_cObject);
+  RuaThread = rb_define_class("RuaThread", rb_cObject);
   RuaError = rb_define_class("RuaError", rb_eStandardError);
 
   rb_define_alloc_func(Rua, rua_alloc);
-  rb_define_const(Rua, "VERSION", rb_str_new2("0.1.3"));
+  rb_define_const(Rua, "VERSION", rb_str_new2("0.1.4"));
   rb_define_private_method(Rua, "initialize", rua_initialize, -1);
   rb_define_method(Rua, "openlibs", rua_openlibs, -1);
   rb_define_method(Rua, "eval", rua_eval, 1);
@@ -94,6 +95,10 @@ void Init_rua() {
   rb_define_private_method(RuaFunc, "initialize", rua_func_initialize, 0);
   rb_define_method(RuaFunc, "call", rua_func_call, -1);
 
+  rb_define_alloc_func(RuaThread, rua_thread_alloc);
+  rb_define_private_method(RuaThread, "initialize", rua_thread_initialize, 0);
+  rb_define_method(RuaThread, "resume", rua_thread_resume, -1);
+
   s_all     = ID2SYM(rb_intern("all"));
   s_base    = ID2SYM(rb_intern("base"));
   s_package = ID2SYM(rb_intern("package"));
@@ -194,8 +199,8 @@ static VALUE rua_eval(VALUE self, VALUE str) {
   const char *errmsg;
   int pretop, nresults, i;
 
-  Data_Get_Struct(self, struct rua, p);
   Check_Type(str, T_STRING);
+  Data_Get_Struct(self, struct rua, p);
   pretop = lua_gettop(p->L);
   luaL_loadstring(p->L, StringValuePtr(str));
 
@@ -350,6 +355,62 @@ static VALUE rua_func_call(int argc, VALUE *argv, VALUE self) {
 
 // ------------------------------------------------------------------
 
+static VALUE rua_thread_alloc(VALUE klass) {
+  struct rua_thread *p = ALLOC(struct rua_thread);
+
+  return Data_Wrap_Struct(klass, 0, -1, p);
+}
+
+static VALUE rua_thread_initialize(VALUE self) {
+  return Qnil;
+}
+
+static VALUE rua_thread_resume(int argc, VALUE *argv, VALUE self) {
+  struct rua_thread *p;
+  VALUE retval;
+  int pretop, nresults, i;
+  const char *errmsg;
+
+  Data_Get_Struct(self, struct rua_thread , p);
+  lua_getglobal(p->L, "coroutine");
+  pretop = lua_gettop(p->L);
+  lua_pushstring(p->L, "resume");
+  lua_gettable(p->L, pretop);
+  lua_rawgeti(p->L, LUA_REGISTRYINDEX, p->ref);
+
+  for (i = 0; i < argc; i ++) {
+    rua_pushrbval(p->L, argv[i], p->error_handler, p->secure);
+  }
+
+  if (lua_pcall(p->L, argc + 1, LUA_MULTRET, 0) != 0) {
+    errmsg = lua_tostring(p->L, -1);
+    lua_pop(p->L, 2);
+    rb_raise(RuaError, "%s", errmsg);
+  }
+
+  nresults = lua_gettop(p->L) - pretop;
+
+  if (nresults == 0) {
+    lua_pop(p->L, 1);
+    return Qnil;
+  } else if (nresults == 1) {
+    retval = rua_torbval(p->L, -1, p->error_handler, p->secure);
+    lua_pop(p->L, 2);
+    return retval;
+  } else {
+    retval = rb_ary_new();
+
+    for (i = nresults; i > 0; i--) {
+      rb_ary_push(retval, rua_torbval(p->L, -i, p->error_handler, p->secure));
+    }
+
+    lua_pop(p->L, nresults + 1);
+    return retval;
+  }
+}
+
+// ------------------------------------------------------------------
+
 static VALUE rua_torbval(lua_State *L, int idx, VALUE error_handler, int secure) {
   VALUE rbval = Qnil;
 
@@ -374,6 +435,10 @@ static VALUE rua_torbval(lua_State *L, int idx, VALUE error_handler, int secure)
     rbval = rua_toruafunc(L, idx, error_handler, secure);
     break;
 
+  case LUA_TTHREAD:
+    rbval = rua_toruathread(L, idx, error_handler, secure);
+    break;
+
   case LUA_TLIGHTUSERDATA:
     rbval = (VALUE) lua_touserdata(L, idx);
     break;
@@ -403,7 +468,8 @@ static VALUE rua_tohash(lua_State *L, int idx, VALUE error_handler, int secure)
 }
 
 static void rua_pushrbval(lua_State *L, VALUE rbval, VALUE error_handler, int secure) {
-  struct rua_func *p;
+  struct rua_func *pf;
+  struct rua_thread *pt;
 
   switch (TYPE(rbval)) {
   case T_NIL:
@@ -441,8 +507,11 @@ static void rua_pushrbval(lua_State *L, VALUE rbval, VALUE error_handler, int se
       fprintf(stderr, "warning: convert insecure value %s", rua_to_sptr(rbval));
       lua_pushnil(L);
     } else if (rb_obj_is_kind_of(rbval, RuaFunc)) {
-      Data_Get_Struct(rbval, struct rua_func, p);
-      lua_rawgeti(L, LUA_REGISTRYINDEX, p->ref);
+      Data_Get_Struct(rbval, struct rua_func, pf);
+      lua_rawgeti(L, LUA_REGISTRYINDEX, pf->ref);
+    } else if (rb_obj_is_kind_of(rbval, RuaThread)) {
+      Data_Get_Struct(rbval, struct rua_thread, pt);
+      lua_rawgeti(L, LUA_REGISTRYINDEX, pt->ref);
     } else if (rua_obj_is_executable(rbval)) {
       lua_pushlightuserdata(L, (void *) rbval);
       lua_pushlightuserdata(L, (void *) error_handler);
@@ -563,10 +632,23 @@ static VALUE rua_toruafunc(lua_State *L, int idx, VALUE error_handler, int secur
   p->secure = secure;
   lua_pushvalue(L, idx);
   p->ref = luaL_ref(L, LUA_REGISTRYINDEX);
-  lua_pop(L, 1);
   return f;
 }
 
+static VALUE rua_toruathread(lua_State *L, int idx, VALUE error_handler, int secure) {
+  struct rua_thread *p;
+  VALUE t;
+
+  t = rb_funcall(RuaThread, rb_intern("new"), 0);
+  Data_Get_Struct(t, struct rua_thread, p);
+  p->L = L;
+  p->error_handler = error_handler;
+  p->secure = secure;
+  lua_pushvalue(L, idx);
+  p->ref = luaL_ref(L, LUA_REGISTRYINDEX);
+  return t;
+}
+
 static VALUE rua_obj_is_executable(VALUE obj) {
   return (rb_obj_is_kind_of(obj, rb_cProc) || rb_obj_is_kind_of(obj, rb_cMethod));
 }

data/ext/rua.h

@@ -14,6 +14,13 @@ struct rua_func {
   int secure;
 };
 
+struct rua_thread {
+  lua_State *L;
+  int ref;
+  VALUE error_handler;
+  int secure;
+};
+
 void Init_rua();
 static VALUE rua_alloc(VALUE klass);
 static void rua_free(struct rua *p);
@@ -30,6 +37,10 @@ static VALUE rua_func_alloc(VALUE klass);
 static VALUE rua_func_initialize(VALUE self);
 static VALUE rua_func_call(int argc, VALUE *argv, VALUE self);
 
+static VALUE rua_thread_alloc(VALUE klass);
+static VALUE rua_thread_initialize(VALUE self);
+static VALUE rua_thread_resume(int argc, VALUE *argv, VALUE self);
+
 static VALUE rua_torbval(lua_State *L, int idx, VALUE error_handler, int secure);
 static VALUE rua_tohash(lua_State *L, int idx, VALUE error_handler, int secure);
 static void rua_pushrbval(lua_State *L, VALUE rbval, VALUE error_handler, int secure);
@@ -39,6 +50,7 @@ static void rua_newtable_from_obj(lua_State *L, VALUE obj, VALUE error_handler,
 static int rua_proc_call(lua_State *L);
 static VALUE _rua_proc_call(VALUE args);
 static VALUE rua_toruafunc(lua_State *L, int idx, VALUE error_handler, int secure);
+static VALUE rua_toruathread(lua_State *L, int idx, VALUE error_handler, int secure);
 static VALUE rua_obj_is_executable(VALUE obj);
 static int rua_name_is_insecure_method(const char *name);
 static VALUE rua_to_s(VALUE v);

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: rua
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
-date: 2007-11-14 00:00:00 +09:00
+  version: 0.1.4
+date: 2007-11-15 00:00:00 +09:00
 summary: rua is a library for using Lua under Ruby.
 require_paths: 
 - lib