rua 0.3.1-mswin32 → 0.3.3-mswin32

data/README.txt

@@ -30,9 +30,10 @@ http://storehouse.sakura.ne.jp/rua/
     #rua.openlibs(:base, :package, :string)
     #rua.secure = false
     rua.abort_by_error = false
-    rua.error_handler = lambda do |e, ar|
+    rua.error_handler = lambda do |e|
       p e
-      p ar.to_hash
+      p e.cause
+      p e.info.to_hash
     end
     
     rua.str = 'xxx'

data/ext/rua.c

@@ -16,7 +16,7 @@ __declspec(dllexport) void Init_rua(void);
 
 #include "rua.h"
 
-#define VERSION "0.3.1"
+#define VERSION "0.3.3"
 #define REF_RBOBJ "self"
 
 static const char *insecure_methods[] = {
@@ -96,6 +96,8 @@ void Init_rua() {
   rb_define_method(Rua, "secure=", rua_set_secure, 1);
   rb_define_method(Rua, "abort_by_error", rua_get_abort_by_error, 0);
   rb_define_method(Rua, "abort_by_error=", rua_set_abort_by_error, 1);
+  rb_define_method(Rua, "wrap_error", rua_get_wrap_error, 0);
+  rb_define_method(Rua, "wrap_error=", rua_set_wrap_error, 1);
   rb_define_method(Rua, "error_handler", rua_get_error_handler, 0);
   rb_define_method(Rua, "error_handler=", rua_set_error_handler, 1);
   rb_define_method(Rua, "method_missing", rua_method_missing, -1);
@@ -109,6 +111,10 @@ void Init_rua() {
   rb_define_private_method(RuaThread, "initialize", rua_thread_initialize, 0);
   rb_define_method(RuaThread, "resume", rua_thread_resume, -1);
 
+  rb_define_alloc_func(RuaError, rua_error_alloc);
+  rb_define_method(RuaError, "cause", rua_error_cause, 0);
+  rb_define_method(RuaError, "info", rua_error_info, 0);
+
   rb_define_alloc_func(RuaDebug, rua_debug_alloc);
   rb_define_private_method(RuaDebug, "initialize", rua_debug_initialize, 0);
   rb_define_method(RuaDebug, "name", rua_debug_name, 0);
@@ -139,14 +145,17 @@ static VALUE rua_alloc(VALUE klass) {
 
   p->R = ALLOC(struct rua_state);
   p->R->rua = Qnil;
+  p->R->refs = Qnil;
   p->R->error_handler = Qnil;
   p->R->secure = 1;
   p->R->abort_by_error = 1;
+  p->R->wrap_error = 1;
   return Data_Wrap_Struct(klass, rua_mark, rua_free, p);
 }
 
 static void rua_mark(struct rua *p) {
   rb_gc_mark(p->R->rua);
+  rb_gc_mark(p->R->refs);
   rb_gc_mark(p->R->error_handler);
 }
 
@@ -171,9 +180,11 @@ static VALUE rua_initialize(int argc, VALUE *argv, VALUE self) {
   Data_Get_Struct(self, struct rua, p);
   p->L = lua_open();
   p->R->rua = self;
+  p->R->refs = rb_hash_new();
   p->R->error_handler = Qnil;
   p->R->secure = 1;
   p->R->abort_by_error = 1;
+  p->R->wrap_error = 1;
 
   if (argc > 0) {
     rua_openlibs(argc, argv, self);
@@ -240,6 +251,7 @@ static VALUE rua_openlibs(int argc, VALUE *argv, VALUE self) {
  */
 static VALUE rua_eval(VALUE self, VALUE str) {
   struct rua *p;
+  VALUE errinfo;
   const char *errmsg;
   int pretop;
 
@@ -249,9 +261,18 @@ static VALUE rua_eval(VALUE self, VALUE str) {
   luaL_loadstring(p->L, StringValuePtr(str));
 
   if (lua_pcall(p->L, 0, LUA_MULTRET, 0) != 0) {
-    errmsg = lua_tostring(p->L, -1);
-    lua_pop(p->L, 1);
-    rb_raise(RuaError, "%s", errmsg);
+    if (lua_islightuserdata(p->L, -1)) {
+      errinfo = (VALUE) lua_touserdata(p->L, -1);
+      lua_pop(p->L, 1);
+      rb_exc_raise(errinfo);
+    } else if (lua_isstring(p->L, -1)){
+      errmsg = lua_tostring(p->L, -1);
+      lua_pop(p->L, 1);
+      rb_raise(RuaError, "%s", errmsg);
+    } else {
+      lua_pop(p->L, 1);
+      rb_raise(RuaError, "must not happen");
+    }
   }
 
   return rua_tomultiretval(p->L, pretop, p->R);
@@ -346,6 +367,35 @@ static VALUE rua_set_abort_by_error(VALUE self, VALUE abort_by_error) {
   return Qnil;
 }
 
+/**
+ * get wrap error flag.
+ */
+static VALUE rua_get_wrap_error(VALUE self) {
+  struct rua *p;
+
+  Data_Get_Struct(self, struct rua, p);
+  return p->R->wrap_error ? Qtrue : Qfalse;
+}
+
+/**
+ * set wrap error flag.
+ */
+static VALUE rua_set_wrap_error(VALUE self, VALUE wrap_error) {
+  struct rua *p;
+
+  Data_Get_Struct(self, struct rua, p);
+
+  switch (TYPE(wrap_error)) {
+  case T_TRUE:  p->R->wrap_error = 1; break;
+  case T_FALSE: p->R->wrap_error = 0; break;
+  default:
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected TrueClass or FalseClass)", rua_classname_ptr(wrap_error));
+    break;
+  }
+
+  return Qnil;
+}
+
 /**
  * get error handler.
  */
@@ -406,11 +456,12 @@ static VALUE rua_ref_alloc(VALUE klass) {
 
 static void rua_ref_mark(struct rua_ref *p) {
   rb_gc_mark(p->R->rua);
+  rb_gc_mark(p->R->refs);
   rb_gc_mark(p->R->error_handler);
 }
 
 static void rua_ref_free(struct rua_ref *p) {
-  luaL_unref(p->L, LUA_REGISTRYINDEX, p->ref);
+  //luaL_unref(p->L, LUA_REGISTRYINDEX, p->ref);
 
   if (p->R) {
     free(p->R);
@@ -434,6 +485,7 @@ static VALUE rua_func_initialize(VALUE self) {
 static VALUE rua_func_call(int argc, VALUE *argv, VALUE self) {
   struct rua_ref *p;
   int pretop, i;
+  VALUE errinfo;
   const char *errmsg;
 
   Data_Get_Struct(self, struct rua_ref, p);
@@ -445,9 +497,18 @@ static VALUE rua_func_call(int argc, VALUE *argv, VALUE self) {
   }
 
   if (lua_pcall(p->L, argc, LUA_MULTRET, 0) != 0) {
-    errmsg = lua_tostring(p->L, -1);
-    lua_pop(p->L, 1);
-    rb_raise(RuaError, "%s", errmsg);
+    if (lua_islightuserdata(p->L, -1)) {
+      errinfo = (VALUE) lua_touserdata(p->L, -1);
+      lua_pop(p->L, 1);
+      rb_exc_raise(errinfo);
+    } else if (lua_isstring(p->L, -1)){
+      errmsg = lua_tostring(p->L, -1);
+      lua_pop(p->L, 1);
+      rb_raise(RuaError, "%s", errmsg);
+    } else {
+      lua_pop(p->L, 1);
+      rb_raise(RuaError, "must not happen");
+    }
   }
 
   return rua_tomultiretval(p->L, pretop, p->R);
@@ -487,7 +548,7 @@ static VALUE rua_thread_initialize(VALUE self) {
  */
 static VALUE rua_thread_resume(int argc, VALUE *argv, VALUE self) {
   struct rua_ref *p;
-  VALUE retval;
+  VALUE retval, errinfo;
   int pretop, i;
   const char *errmsg;
 
@@ -503,9 +564,18 @@ static VALUE rua_thread_resume(int argc, VALUE *argv, VALUE self) {
   }
 
   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);
+    if (lua_islightuserdata(p->L, -1)) {
+      errinfo = (VALUE) lua_touserdata(p->L, -1);
+      lua_pop(p->L, 2);
+      rb_exc_raise(errinfo);
+    } else if (lua_isstring(p->L, -1)){
+      errmsg = lua_tostring(p->L, -1);
+      lua_pop(p->L, 2);
+      rb_raise(RuaError, "%s", errmsg);
+    } else {
+      lua_pop(p->L, 2);
+      rb_raise(RuaError, "must not happen");
+    }
   }
 
   retval = rua_tomultiretval(p->L, pretop, p->R);
@@ -654,6 +724,41 @@ static VALUE rua_debug_to_hash(VALUE self) {
 
 // ------------------------------------------------------------------
 
+static VALUE rua_error_alloc(VALUE klass) {
+  struct rua_error *p = ALLOC(struct rua_error);
+
+  p->cause = Qnil;
+  p->info = Qnil;
+  return Data_Wrap_Struct(klass, rua_error_mark, -1, p);
+}
+
+static void rua_error_mark(struct rua_error *p) {
+  rb_gc_mark(p->cause);
+  rb_gc_mark(p->info);
+}
+
+/**
+ * get cause error.
+ */
+static VALUE rua_error_cause(VALUE self) {
+  struct rua_error *p;
+
+  Data_Get_Struct(self, struct rua_error, p);
+  return p->cause;
+}
+
+/**
+ * get debug info.
+ */
+static VALUE rua_error_info(VALUE self) {
+  struct rua_error *p;
+
+  Data_Get_Struct(self, struct rua_error, p);
+  return p->info;
+}
+
+// ------------------------------------------------------------------
+
 static VALUE rua_tomultiretval(lua_State *L, int pretop, struct rua_state *R) {
   VALUE retval;
   int nresults, i;
@@ -831,7 +936,7 @@ static void rua_newtable_from_ary(lua_State *L, VALUE ary, struct rua_state *R)
     entry = rb_ary_entry(ary, i);
     lua_pushnumber(L, i + 1);
     rua_pushrbval(L, entry, R);
-    lua_settable(L, tblidx);
+    lua_rawset(L, tblidx);
   }
 }
 
@@ -848,7 +953,7 @@ static void rua_newtable_from_hash(lua_State *L, VALUE hash, struct rua_state *R
     val = rb_hash_aref(hash, key);
     rua_pushrbval(L, key, R);
     rua_pushrbval(L, val, R);
-    lua_settable(L, tblidx);
+    lua_rawset(L, tblidx);
   }
 }
 
@@ -862,11 +967,13 @@ static void rua_newtable_from_obj(lua_State *L, VALUE obj, struct rua_state *R)
 
   lua_pushstring(L, REF_RBOBJ);
   lua_pushlightuserdata(L, (void *) obj);
-  lua_settable(L, tblidx);
+  lua_rawset(L, tblidx);
+  rb_hash_aset(R->refs, obj, Qtrue);
 
   for (i = 0; i < RARRAY(methods)->len; i++) {
     name = rb_ary_entry(methods, i);
     method = rb_funcall(obj, rb_intern("method"), 1, name);
+    rb_hash_aset(R->refs, method, Qtrue);
 
     if (R->secure && rua_name_is_insecure_method(StringValuePtr(name))) {
       continue;
@@ -874,13 +981,13 @@ static void rua_newtable_from_obj(lua_State *L, VALUE obj, struct rua_state *R)
 
     rua_pushrbval(L, name, R);
     rua_pushrbval(L, method, R);
-    lua_settable(L, tblidx);
+    lua_rawset(L, tblidx);
   }
 }
 
 static int rua_proc_call(lua_State *L) {
   struct rua_state *R;
-  VALUE proc, args, last, retval, errargs, errmsg;
+  VALUE proc, args, last, retval, errargs, error;
   int i, n, status;
   lua_Debug ar;
 
@@ -903,16 +1010,19 @@ static int rua_proc_call(lua_State *L) {
   }
 
   if (status != 0) {
-    errmsg = rb_check_convert_type(ruby_errinfo, T_STRING, "String", "to_s");
-
-    if (rua_obj_is_executable(R->error_handler)) {
-      errargs = rb_ary_new();
-      rb_ary_push(errargs, ruby_errinfo);
-
+    if (R->wrap_error) {
       if (lua_getstack(L, 1, &ar) && lua_getinfo(L, "nSlu", &ar)) {
-        rb_ary_push(errargs, rua_toruadebug(&ar));
+        error = rua_toruaerror(ruby_errinfo, rua_toruadebug(&ar));
+      } else {
+        error = rua_toruaerror(ruby_errinfo, Qnil);
       }
+    } else {
+      error = ruby_errinfo;
+    }
 
+    if (rua_obj_is_executable(R->error_handler)) {
+      errargs = rb_ary_new();
+      rb_ary_push(errargs, error);
       rb_ary_push(errargs, R->error_handler);
       retval = rb_protect(_rua_proc_call, errargs, &status);
 
@@ -924,7 +1034,8 @@ static int rua_proc_call(lua_State *L) {
     }
 
     if (R->abort_by_error) {
-      return luaL_error(L, "%s", StringValuePtr(errmsg));
+      lua_pushlightuserdata(L, (void *) error);
+      return lua_error(L);
     }
   }
 
@@ -967,9 +1078,22 @@ static VALUE rua_toruaobj(VALUE klass, lua_State *L, int idx, struct rua_state *
   p->R = R;
   lua_pushvalue(L, idx);
   p->ref = luaL_ref(L, LUA_REGISTRYINDEX);
+  rb_hash_aset(p->R->refs, ruaobj, Qtrue);
   return ruaobj;
 }
 
+static VALUE rua_toruaerror(VALUE cause, VALUE ruadebug) {
+  struct rua_error *p;
+  VALUE errmsg, ruaerr;
+
+  errmsg = rb_check_convert_type(cause, T_STRING, "String", "to_s");
+  ruaerr = rb_funcall(RuaError, rb_intern("new"), 1, errmsg);
+  Data_Get_Struct(ruaerr, struct rua_error, p);
+  p->cause = cause;
+  p->info = ruadebug;
+  return ruaerr;
+}
+
 static VALUE rua_toruadebug(lua_Debug *ar) {
   struct rua_debug *p;
   VALUE ruadebug;

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: rua
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
-date: 2007-11-25 00:00:00 +09:00
+  version: 0.3.3
+date: 2007-11-29 00:00:00 +09:00
 summary: Rua is a library for using Lua under Ruby.
 require_paths: 
 - lib/i386-mswin32