rua 0.1.5 → 0.2.0

data/ext/rua.c

@@ -15,8 +15,8 @@ __declspec(dllexport) void Init_rua(void);
 
 #include "rua.h"
 
-#define REF_RBOBJ "__self"
-#define VERSION "0.1.5"
+#define VERSION "0.2.0"
+#define REF_RBOBJ "self"
 
 static const char *insecure_methods[] = {
   "__id__",
@@ -142,8 +142,8 @@ static VALUE rua_initialize(int argc, VALUE *argv, VALUE self) {
   }
 
   p->L = lua_open();
-  p->secure = 1;
-  p->error_handler = error_handler;
+  p->R.secure = 1;
+  p->R.error_handler = error_handler;
   return Qnil;
 }
 
@@ -198,9 +198,8 @@ static VALUE rua_openlibs(int argc, VALUE *argv, VALUE self) {
 
 static VALUE rua_eval(VALUE self, VALUE str) {
   struct rua *p;
-  VALUE retval;
   const char *errmsg;
-  int pretop, nresults, i;
+  int pretop;
 
   Check_Type(str, T_STRING);
   Data_Get_Struct(self, struct rua, p);
@@ -208,30 +207,12 @@ static VALUE rua_eval(VALUE self, VALUE str) {
   luaL_loadstring(p->L, StringValuePtr(str));
 
   if (lua_pcall(p->L, 0, LUA_MULTRET, 0) != 0) {
-    RuaError = rb_const_get(rb_cObject, rb_intern("RuaError"));
     errmsg = lua_tostring(p->L, -1);
     lua_pop(p->L, 1);
     rb_raise(RuaError, "%s", errmsg);
   }
 
-  nresults = lua_gettop(p->L) - pretop;
-
-  if (nresults == 0) {
-    return Qnil;
-  } else if (nresults == 1) {
-    retval = rua_torbval(p->L, -1, p->error_handler, p->secure);
-    lua_pop(p->L, 1);
-    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);
-    return retval;
-  }
+  return rua_tomultiretval(p->L, pretop, p->R);
 }
 
 static VALUE rua_get(VALUE self, VALUE key) {
@@ -240,7 +221,7 @@ static VALUE rua_get(VALUE self, VALUE key) {
 
   Data_Get_Struct(self, struct rua, p);
   lua_getglobal(p->L, rua_to_sptr(key));
-  retval = rua_torbval(p->L, -1, p->error_handler, p->secure);
+  retval = rua_torbval(p->L, -1, p->R);
   lua_pop(p->L, 1);
   return retval;
 }
@@ -250,11 +231,11 @@ static VALUE rua_set(VALUE self, VALUE key, VALUE val) {
 
   Data_Get_Struct(self, struct rua, p);
 
-  if (p->secure && (rb_equal(rb_cModule, val) || rb_equal(rb_cClass, val))) {
+  if (p->R.secure && (rb_equal(rb_cModule, val) || rb_equal(rb_cClass, val))) {
     rb_raise(RuaError, "set insecure value %s", rua_to_sptr(val));
   }
 
-  rua_pushrbval(p->L, val, p->error_handler, p->secure);
+  rua_pushrbval(p->L, val, p->R);
   lua_setglobal(p->L, rua_to_sptr(key));
   return Qnil;
 }
@@ -263,7 +244,7 @@ static VALUE rua_get_secure(VALUE self) {
   struct rua *p;
 
   Data_Get_Struct(self, struct rua, p);
-  return p->secure ? Qtrue : Qfalse;
+  return p->R.secure ? Qtrue : Qfalse;
 }
 
 static VALUE rua_set_secure(VALUE self, VALUE secure) {
@@ -272,8 +253,8 @@ static VALUE rua_set_secure(VALUE self, VALUE secure) {
   Data_Get_Struct(self, struct rua, p);
 
   switch (TYPE(secure)) {
-  case T_TRUE:  p->secure = 1; break;
-  case T_FALSE: p->secure = 0; break;
+  case T_TRUE:  p->R.secure = 1; break;
+  case T_FALSE: p->R.secure = 0; break;
   default:
     rb_raise(rb_eTypeError, "wrong argument type %s (expected TrueClass or FalseClass)", rua_classname_ptr(secure));
     break;
@@ -307,7 +288,7 @@ static VALUE rua_method_missing(int argc, VALUE *argv, VALUE self) {
 // ------------------------------------------------------------------
 
 static VALUE rua_func_alloc(VALUE klass) {
-  struct rua_func *p = ALLOC(struct rua_func);
+  struct rua_ref *p = ALLOC(struct rua_ref);
 
   return Data_Wrap_Struct(klass, 0, -1, p);
 }
@@ -317,17 +298,16 @@ static VALUE rua_func_initialize(VALUE self) {
 }
 
 static VALUE rua_func_call(int argc, VALUE *argv, VALUE self) {
-  struct rua_func *p;
-  VALUE retval;
-  int pretop, nresults, i;
+  struct rua_ref *p;
+  int pretop, i;
   const char *errmsg;
 
-  Data_Get_Struct(self, struct rua_func, p);
+  Data_Get_Struct(self, struct rua_ref, p);
   pretop = lua_gettop(p->L);
   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);
+    rua_pushrbval(p->L, argv[i], p->R);
   }
 
   if (lua_pcall(p->L, argc, LUA_MULTRET, 0) != 0) {
@@ -336,30 +316,13 @@ static VALUE rua_func_call(int argc, VALUE *argv, VALUE self) {
     rb_raise(RuaError, "%s", errmsg);
   }
 
-  nresults = lua_gettop(p->L) - pretop;
-
-  if (nresults == 0) {
-    return Qnil;
-  } else if (nresults == 1) {
-    retval = rua_torbval(p->L, -1, p->error_handler, p->secure);
-    lua_pop(p->L, 1);
-    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);
-    return retval;
-  }
+  return rua_tomultiretval(p->L, pretop, p->R);
 }
 
 // ------------------------------------------------------------------
 
 static VALUE rua_thread_alloc(VALUE klass) {
-  struct rua_thread *p = ALLOC(struct rua_thread);
+  struct rua_ref *p = ALLOC(struct rua_ref);
 
   return Data_Wrap_Struct(klass, 0, -1, p);
 }
@@ -369,12 +332,12 @@ static VALUE rua_thread_initialize(VALUE self) {
 }
 
 static VALUE rua_thread_resume(int argc, VALUE *argv, VALUE self) {
-  struct rua_thread *p;
+  struct rua_ref *p;
   VALUE retval;
-  int pretop, nresults, i;
+  int pretop, i;
   const char *errmsg;
 
-  Data_Get_Struct(self, struct rua_thread , p);
+  Data_Get_Struct(self, struct rua_ref, p);
   lua_getglobal(p->L, "coroutine");
   pretop = lua_gettop(p->L);
   lua_pushstring(p->L, "resume");
@@ -382,7 +345,7 @@ static VALUE rua_thread_resume(int argc, VALUE *argv, VALUE self) {
   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);
+    rua_pushrbval(p->L, argv[i], p->R);
   }
 
   if (lua_pcall(p->L, argc + 1, LUA_MULTRET, 0) != 0) {
@@ -391,30 +354,38 @@ static VALUE rua_thread_resume(int argc, VALUE *argv, VALUE self) {
     rb_raise(RuaError, "%s", errmsg);
   }
 
-  nresults = lua_gettop(p->L) - pretop;
+  retval = rua_tomultiretval(p->L, pretop, p->R);
+  lua_pop(p->L, 1);
+  return retval;
+}
+
+// ------------------------------------------------------------------
+
+static VALUE rua_tomultiretval(lua_State *L, int pretop, struct rua_state R) {
+  VALUE retval;
+  int nresults, i;
+
+  nresults = lua_gettop(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);
+    retval = rua_torbval(L, -1, R);
+    lua_pop(L, 1);
     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));
+      rb_ary_push(retval, rua_torbval(L, -i, R));
     }
 
-    lua_pop(p->L, nresults + 1);
+    lua_pop(L, nresults);
     return retval;
   }
 }
 
-// ------------------------------------------------------------------
-
-static VALUE rua_torbval(lua_State *L, int idx, VALUE error_handler, int secure) {
+static VALUE rua_torbval(lua_State *L, int idx, struct rua_state R) {
   VALUE rbval = Qnil;
 
   switch (lua_type(L, idx)) {
@@ -434,17 +405,17 @@ static VALUE rua_torbval(lua_State *L, int idx, VALUE error_handler, int secure)
     if (rua_is_rbobj(L, idx)) {
       rbval = rua_torbobj(L, idx);
     } else {
-      rbval = rua_tohash(L, idx, error_handler, secure);
+      rbval = rua_tohash(L, idx, R);
     }
 
     break;
 
   case LUA_TFUNCTION:
-    rbval = rua_toruafunc(L, idx, error_handler, secure);
+    rbval = rua_toruaobj(RuaFunc, L, idx, R);
     break;
 
   case LUA_TTHREAD:
-    rbval = rua_toruathread(L, idx, error_handler, secure);
+    rbval = rua_toruaobj(RuaThread, L, idx, R);
     break;
 
   case LUA_TLIGHTUSERDATA:
@@ -475,12 +446,12 @@ static VALUE rua_torbobj(lua_State *L, int idx) {
   tblidx = lua_gettop(L);
   lua_pushstring(L, REF_RBOBJ);
   lua_rawget(L, tblidx);
-  rbobj = (VALUE) lua_topointer(L, -1);
+  rbobj = (VALUE) lua_touserdata(L, -1);
   lua_pop(L, 2);
   return rbobj;
 }
 
-static VALUE rua_tohash(lua_State *L, int idx, VALUE error_handler, int secure) {
+static VALUE rua_tohash(lua_State *L, int idx, struct rua_state R) {
   VALUE hash, key, val;
   int tblidx;
 
@@ -490,8 +461,8 @@ static VALUE rua_tohash(lua_State *L, int idx, VALUE error_handler, int secure)
   lua_pushnil(L);
 
   while (lua_next(L, tblidx) != 0) {
-    key = rua_torbval(L, -2, error_handler, secure);
-    val = rua_torbval(L, -1, error_handler, secure);
+    key = rua_torbval(L, -2, R);
+    val = rua_torbval(L, -1, R);
     rb_hash_aset(hash, key, val);
     lua_pop(L, 1);
   }
@@ -500,9 +471,8 @@ static VALUE rua_tohash(lua_State *L, int idx, VALUE error_handler, int secure)
   return hash;
 }
 
-static void rua_pushrbval(lua_State *L, VALUE rbval, VALUE error_handler, int secure) {
-  struct rua_func *pf;
-  struct rua_thread *pt;
+static void rua_pushrbval(lua_State *L, VALUE rbval, struct rua_state R) {
+  struct rua_ref *p;
 
   switch (TYPE(rbval)) {
   case T_NIL:
@@ -528,37 +498,37 @@ static void rua_pushrbval(lua_State *L, VALUE rbval, VALUE error_handler, int se
     break;
 
   case T_ARRAY:
-    rua_newtable_from_ary(L, rbval, error_handler, secure);
+    rua_newtable_from_ary(L, rbval, R);
     break;
 
   case T_HASH:
-    rua_newtable_from_hash(L, rbval, error_handler, secure);
+    rua_newtable_from_hash(L, rbval, R);
     break;
 
   default:
-    if (secure && (rb_equal(rb_cModule, rbval) || rb_equal(rb_cClass, rbval))) {
+    if (R.secure && (rb_equal(rb_cModule, rbval) || rb_equal(rb_cClass, rbval))) {
       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, pf);
-      lua_rawgeti(L, LUA_REGISTRYINDEX, pf->ref);
+      Data_Get_Struct(rbval, struct rua_ref, p);
+      lua_rawgeti(L, LUA_REGISTRYINDEX, p->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);
+      Data_Get_Struct(rbval, struct rua_ref, p);
+      lua_rawgeti(L, LUA_REGISTRYINDEX, p->ref);
     } else if (rua_obj_is_executable(rbval)) {
       lua_pushlightuserdata(L, (void *) rbval);
-      lua_pushlightuserdata(L, (void *) error_handler);
-      lua_pushlightuserdata(L, (void *) secure);
+      lua_pushlightuserdata(L, (void *) R.error_handler);
+      lua_pushlightuserdata(L, (void *) R.secure);
       lua_pushcclosure(L, rua_proc_call, 3);
     } else {
-      rua_newtable_from_obj(L, rbval, error_handler, secure);
+      rua_newtable_from_obj(L, rbval, R);
     }
 
     break;
   }
 }
 
-static void rua_newtable_from_ary(lua_State *L, VALUE ary, VALUE error_handler, int secure) {
+static void rua_newtable_from_ary(lua_State *L, VALUE ary, struct rua_state R) {
   VALUE entry;
   int i, tblidx;
 
@@ -568,12 +538,12 @@ static void rua_newtable_from_ary(lua_State *L, VALUE ary, VALUE error_handler,
   for (i = 0; i < RARRAY(ary)->len; i++) {
     entry = rb_ary_entry(ary, i);
     lua_pushnumber(L, i + 1);
-    rua_pushrbval(L, entry, error_handler, secure);
+    rua_pushrbval(L, entry, R);
     lua_settable(L, tblidx);
   }
 }
 
-static void rua_newtable_from_hash(lua_State *L, VALUE hash, VALUE error_handler, int secure) {
+static void rua_newtable_from_hash(lua_State *L, VALUE hash, struct rua_state R) {
   VALUE keys, key, val;
   int i, tblidx;
 
@@ -584,13 +554,13 @@ static void rua_newtable_from_hash(lua_State *L, VALUE hash, VALUE error_handler
   for (i = 0; i < RARRAY(keys)->len; i++) {
     key = rb_ary_entry(keys, i);
     val = rb_hash_aref(hash, key);
-    rua_pushrbval(L, key, error_handler, secure);
-    rua_pushrbval(L, val, error_handler, secure);
+    rua_pushrbval(L, key, R);
+    rua_pushrbval(L, val, R);
     lua_settable(L, tblidx);
   }
 }
 
-static void rua_newtable_from_obj(lua_State *L, VALUE obj, VALUE error_handler, int secure) {
+static void rua_newtable_from_obj(lua_State *L, VALUE obj, struct rua_state R) {
   VALUE methods, name, method;
   int i, tblidx;
 
@@ -606,38 +576,39 @@ static void rua_newtable_from_obj(lua_State *L, VALUE obj, VALUE error_handler,
     name = rb_ary_entry(methods, i);
     method = rb_funcall(obj, rb_intern("method"), 1, name);
 
-    if (secure && rua_name_is_insecure_method(StringValuePtr(name))) {
+    if (R.secure && rua_name_is_insecure_method(StringValuePtr(name))) {
       continue;
     }
 
-    rua_pushrbval(L, name, error_handler, secure);
-    rua_pushrbval(L, method, error_handler, secure);
+    rua_pushrbval(L, name, R);
+    rua_pushrbval(L, method, R);
     lua_settable(L, tblidx);
   }
 }
 
 static int rua_proc_call(lua_State *L) {
-  VALUE proc, args, retval, error_handler, errargs;
-  int i, n, status, secure;
+  struct rua_state R;
+  VALUE proc, args, retval, errargs;
+  int i, n, status;
 
   proc = (VALUE) lua_touserdata(L, lua_upvalueindex(1));
-  error_handler = (VALUE) lua_touserdata(L, lua_upvalueindex(2));
-  secure = (int) lua_touserdata(L, lua_upvalueindex(3));
+  R.error_handler = (VALUE) lua_touserdata(L, lua_upvalueindex(2));
+  R.secure = (int) lua_touserdata(L, lua_upvalueindex(3));
   args = rb_ary_new();
   n = lua_gettop(L);
 
   for (i = 0; i < n; i++) {
-    rb_ary_push(args, rua_torbval(L, i + 1, error_handler, secure));
+    rb_ary_push(args, rua_torbval(L, i + 1, R));
   }
 
   rb_ary_push(args, proc);
   retval = rb_protect(_rua_proc_call, args, &status);
 
   if (status != 0) {
-    if (rua_obj_is_executable(error_handler)) {
+    if (rua_obj_is_executable(R.error_handler)) {
       errargs = rb_ary_new();
       rb_ary_push(errargs, ruby_errinfo);
-      rb_ary_push(errargs, error_handler);
+      rb_ary_push(errargs, R.error_handler);
       retval = rb_protect(_rua_proc_call, errargs, &status);
 
       if (status != 0) {
@@ -648,7 +619,7 @@ static int rua_proc_call(lua_State *L) {
     }
   }
   
-  rua_pushrbval(L, retval, error_handler, secure);
+  rua_pushrbval(L, retval, R);
   return 1;
 }
 
@@ -658,32 +629,17 @@ static VALUE _rua_proc_call(VALUE args) {
   return rb_apply(proc, rb_intern("call"), args);
 }
 
-static VALUE rua_toruafunc(lua_State *L, int idx, VALUE error_handler, int secure) {
-  struct rua_func *p;
-  VALUE f;
-
-  f = rb_funcall(RuaFunc, rb_intern("new"), 0);
-  Data_Get_Struct(f, struct rua_func, p);
-  p->L = L;
-  p->error_handler = error_handler;
-  p->secure = secure;
-  lua_pushvalue(L, idx);
-  p->ref = luaL_ref(L, LUA_REGISTRYINDEX);
-  return f;
-}
-
-static VALUE rua_toruathread(lua_State *L, int idx, VALUE error_handler, int secure) {
-  struct rua_thread *p;
-  VALUE t;
+static VALUE rua_toruaobj(VALUE klass, lua_State *L, int idx, struct rua_state R) {
+  struct rua_ref *p;
+  VALUE ruaobj;
 
-  t = rb_funcall(RuaThread, rb_intern("new"), 0);
-  Data_Get_Struct(t, struct rua_thread, p);
+  ruaobj = rb_funcall(klass, rb_intern("new"), 0);
+  Data_Get_Struct(ruaobj, struct rua_ref , p);
   p->L = L;
-  p->error_handler = error_handler;
-  p->secure = secure;
+  p->R = R;
   lua_pushvalue(L, idx);
   p->ref = luaL_ref(L, LUA_REGISTRYINDEX);
-  return t;
+  return ruaobj;
 }
 
 static VALUE rua_obj_is_executable(VALUE obj) {

data/ext/rua.h

@@ -1,24 +1,20 @@
 #ifndef __RUA_H__
 #define __RUA_H__
 
-struct rua {
-  lua_State *L;
+struct rua_state {
   VALUE error_handler;
   int secure;
 };
 
-struct rua_func {
+struct rua {
   lua_State *L;
-  int ref;
-  VALUE error_handler;
-  int secure;
+  struct rua_state R;
 };
 
-struct rua_thread {
+struct rua_ref {
   lua_State *L;
+  struct rua_state R;
   int ref;
-  VALUE error_handler;
-  int secure;
 };
 
 void Init_rua();
@@ -41,18 +37,18 @@ 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_tomultiretval(lua_State *L, int pretop, struct rua_state R);
+static VALUE rua_torbval(lua_State *L, int idx, struct rua_state R);
 static int rua_is_rbobj(lua_State *L, int idx);
 static VALUE rua_torbobj(lua_State *L, int idx);
-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);
-static void rua_newtable_from_ary(lua_State *L, VALUE ary, VALUE error_handler, int secure);
-static void rua_newtable_from_hash(lua_State *L, VALUE hash, VALUE error_handler, int secure);
-static void rua_newtable_from_obj(lua_State *L, VALUE obj, VALUE error_handler, int secure);
+static VALUE rua_tohash(lua_State *L, int idx, struct rua_state R);
+static void rua_pushrbval(lua_State *L, VALUE rbval, struct rua_state R);
+static void rua_newtable_from_ary(lua_State *L, VALUE ary, struct rua_state R);
+static void rua_newtable_from_hash(lua_State *L, VALUE hash, struct rua_state R);
+static void rua_newtable_from_obj(lua_State *L, VALUE obj, struct rua_state R);
 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_toruaobj(VALUE klass, lua_State *L, int idx, struct rua_state R);
 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.5
-date: 2007-11-17 00:00:00 +09:00
+  version: 0.2.0
+date: 2007-11-18 00:00:00 +09:00
 summary: rua is a library for using Lua under Ruby.
 require_paths: 
 - lib