rua 0.2.0-mswin32 → 0.2.1-mswin32

data/README.txt

@@ -1,4 +1,4 @@
-= rua
+= Rua
 
 Copyright (c) 2007 SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
 
@@ -6,6 +6,14 @@ Copyright (c) 2007 SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
 
 Rua is a library for using Lua under Ruby.
 
+== Project Page
+
+http://rubyforge.org/projects/rua
+
+== Download
+
+http://rubyforge.org/frs/?group_id=4845
+
 == Example
 
     require 'rua'

data/ext/rua.c

@@ -0,0 +1,732 @@
+#ifdef _WIN32
+#pragma warning(disable:4311)
+#pragma warning(disable:4312)
+__declspec(dllexport) void Init_rua(void);
+#endif
+
+#include <stddef.h>
+#include <string.h>
+
+#include "ruby.h"
+
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+
+#include "rua.h"
+
+#define VERSION "0.2.1"
+#define REF_RBOBJ "self"
+
+static const char *insecure_methods[] = {
+  "__id__",
+  "__send__",
+  "ancestors",
+  "autoload",
+  "autoload?",
+  "class",
+  "class_eval",
+  "class_variable_defined?",
+  "class_variables",
+  "const_defined?",
+  "const_get",
+  "const_missing",
+  "const_set",
+  "constants",
+  "extend",
+  "freeze",
+  "id",
+  "include?",
+  "included_modules",
+  "instance_eval",
+  "instance_method",
+  "instance_methods",
+  "instance_variable_defined?",
+  "instance_variable_get",
+  "instance_variable_set",
+  "instance_variables",
+  "method",
+  "method_defined?",
+  "method_missing",
+  "methods",
+  "module_eval",
+  "private_class_method",
+  "private_instance_methods",
+  "private_method_defined?",
+  "private_methods",
+  "protected_instance_methods",
+  "protected_method_defined?",
+  "protected_methods",
+  "public_class_method",
+  "public_instance_methods",
+  "public_method_defined?",
+  "public_methods",
+  "respond_to?",
+  "send",
+  "singleton_methods",
+  "taint",
+  "to_ary",
+  "to_hash",
+  "to_int",
+  "to_str",
+  "type",
+  "untaint"
+};
+
+static const int insecure_method_num = sizeof(insecure_methods) / sizeof(char*);
+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(VERSION));
+  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);
+  rb_define_method(Rua, "[]", rua_get, 1);
+  rb_define_method(Rua, "[]=", rua_set, 2);
+  rb_define_method(Rua, "secure", rua_get_secure, 0);
+  rb_define_method(Rua, "secure=", rua_set_secure, 1);
+  rb_define_method(Rua, "method_missing", rua_method_missing, -1);
+
+  rb_define_alloc_func(RuaFunc, rua_func_alloc);
+  rb_define_private_method(RuaFunc, "initialize", rua_func_initialize, 0);
+  rb_define_method(RuaFunc, "call", rua_func_call, -1);
+  //rb_define_method(RuaFunc, "[]", rua_func_get, 1);
+  //rb_define_method(RuaFunc, "[]=", rua_func_set, 2);
+
+  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"));
+  s_string  = ID2SYM(rb_intern("string"));
+  s_table   = ID2SYM(rb_intern("table"));
+  s_math    = ID2SYM(rb_intern("math"));
+  s_io      = ID2SYM(rb_intern("io"));
+  s_debug   = ID2SYM(rb_intern("debug"));
+}
+
+// ------------------------------------------------------------------
+
+static VALUE rua_alloc(VALUE klass) {
+  struct rua *p = ALLOC(struct rua);
+
+  return Data_Wrap_Struct(klass, 0, rua_free, p);
+}
+
+static void rua_free(struct rua *p) {
+  if (p->L) {
+    lua_close(p->L);
+  }
+
+  free(p);
+}
+
+/*
+ * new Rua instance.
+ */
+static VALUE rua_initialize(int argc, VALUE *argv, VALUE self) {
+  struct rua *p;
+  VALUE error_handler;
+
+  Data_Get_Struct(self, struct rua, p);
+  p->L = NULL;
+
+  if (rb_scan_args(argc, argv, "01", &error_handler) < 1) {
+    error_handler = Qnil;
+  } else if (!rua_obj_is_executable(error_handler)) {
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected Proc or Method)", rua_classname_ptr(error_handler));
+  }
+
+  p->L = lua_open();
+  p->R.secure = 1;
+  p->R.error_handler = error_handler;
+  return Qnil;
+}
+
+/*
+ * open libraries.
+ * see http://www.lua.org/manual/5.1/manual.html#5.
+ */
+static VALUE rua_openlibs(int argc, VALUE *argv, VALUE self) {
+  struct rua *p;
+  VALUE arg;
+  int i;
+
+  if (argc < 1) {
+    rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
+  }
+
+  for (i = 0; i < argc; i++) {
+    Check_Type(argv[i], T_SYMBOL);
+  }
+
+  Data_Get_Struct(self, struct rua, p);
+
+  for (i = 0; i < argc; i++) {
+    arg = argv[i];
+
+    if (s_all == arg) {
+      luaL_openlibs(p->L);
+    } else if (s_base == arg) {
+      lua_pushcfunction(p->L, luaopen_base);
+      lua_call(p->L, 0, 0);
+    } else if (s_package == arg) {
+      lua_pushcfunction(p->L, luaopen_package);
+      lua_call(p->L, 0, 0);
+    } else if (s_string == arg) {
+      lua_pushcfunction(p->L, luaopen_string);
+      lua_call(p->L, 0, 0);
+    } else if (s_table == arg) {
+      lua_pushcfunction(p->L, luaopen_table);
+      lua_call(p->L, 0, 0);
+    } else if (s_math == arg) {
+      lua_pushcfunction(p->L, luaopen_math);
+      lua_call(p->L, 0, 0);
+    } else if (s_io == arg) {
+      lua_pushcfunction(p->L, luaopen_io);
+      lua_call(p->L, 0, 0);
+    } else if (s_debug == arg) {
+      lua_pushcfunction(p->L, luaopen_debug);
+      lua_call(p->L, 0, 0);
+    } else {
+      rb_raise(rb_eArgError, "unknown library '%s' (available: base, package, table, math, io, debug, all)", rua_to_sptr(arg));
+    }
+  }
+
+  return Qnil;
+}
+
+/*
+ * evaluates string.
+ */
+static VALUE rua_eval(VALUE self, VALUE str) {
+  struct rua *p;
+  const char *errmsg;
+  int pretop;
+
+  Check_Type(str, T_STRING);
+  Data_Get_Struct(self, struct rua, p);
+  pretop = lua_gettop(p->L);
+  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);
+  }
+
+  return rua_tomultiretval(p->L, pretop, p->R);
+}
+
+/*
+ * set global variable.
+ */
+static VALUE rua_get(VALUE self, VALUE key) {
+  struct rua *p;
+  VALUE retval;
+
+  Data_Get_Struct(self, struct rua, p);
+  lua_getglobal(p->L, rua_to_sptr(key));
+  retval = rua_torbval(p->L, -1, p->R);
+  lua_pop(p->L, 1);
+  return retval;
+}
+
+/*
+ * set global variable.
+ */
+static VALUE rua_set(VALUE self, VALUE key, VALUE val) {
+  struct rua *p;
+
+  Data_Get_Struct(self, struct rua, p);
+
+  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->R);
+  lua_setglobal(p->L, rua_to_sptr(key));
+  return Qnil;
+}
+
+/*
+ * get secure flag.
+ */
+static VALUE rua_get_secure(VALUE self) {
+  struct rua *p;
+
+  Data_Get_Struct(self, struct rua, p);
+  return p->R.secure ? Qtrue : Qfalse;
+}
+
+/*
+ * set secure flag.
+ */
+static VALUE rua_set_secure(VALUE self, VALUE secure) {
+  struct rua *p;
+
+  Data_Get_Struct(self, struct rua, p);
+
+  switch (TYPE(secure)) {
+  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;
+  }
+
+  return Qnil;
+}
+
+/*
+ * dispatch Rua#[], Rua#[]=.
+ */
+static VALUE rua_method_missing(int argc, VALUE *argv, VALUE self) {
+  const char *name;
+  size_t len;
+
+  name = rb_id2name(rb_to_id(argv[0]));
+
+  if (!name) {
+    rb_raise(rb_eRuntimeError, "fail: unknown method or property");
+  }
+
+  len = strlen(name);
+
+  if (argc = 2 && name[len - 1] == '=') {
+    argv[0] = rb_str_new(name, (long) len - 1);
+    return rua_set(self, argv[0], argv[1]);
+  } else if(argc = 1) {
+    return rua_get(self, argv[0]);
+  } else {
+    return rb_call_super(argc, argv);
+  }
+}
+
+// ------------------------------------------------------------------
+
+static VALUE rua_func_alloc(VALUE klass) {
+  struct rua_ref *p = ALLOC(struct rua_ref);
+
+  return Data_Wrap_Struct(klass, 0, -1, p);
+}
+
+/*
+ * new RuaFunc instance.
+ */
+static VALUE rua_func_initialize(VALUE self) {
+  return Qnil;
+}
+
+/*
+ * call Lua function.
+ */
+static VALUE rua_func_call(int argc, VALUE *argv, VALUE self) {
+  struct rua_ref *p;
+  int pretop, i;
+  const char *errmsg;
+
+  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->R);
+  }
+
+  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);
+  }
+
+  return rua_tomultiretval(p->L, pretop, p->R);
+}
+
+/*
+ * set local variable.
+ */
+//static VALUE rua_func_get(VALUE self, VALUE key) {
+//}
+
+/*
+ * set local variable.
+ */
+//static VALUE rua_func_set(VALUE self, VALUE key, VALUE val) {
+//}
+
+// ------------------------------------------------------------------
+
+static VALUE rua_thread_alloc(VALUE klass) {
+  struct rua_ref *p = ALLOC(struct rua_ref);
+
+  return Data_Wrap_Struct(klass, 0, -1, p);
+}
+
+/*
+ * new RuaThread instance.
+ */
+static VALUE rua_thread_initialize(VALUE self) {
+  return Qnil;
+}
+
+/*
+ * resume Lua coroutine.
+ */
+static VALUE rua_thread_resume(int argc, VALUE *argv, VALUE self) {
+  struct rua_ref *p;
+  VALUE retval;
+  int pretop, i;
+  const char *errmsg;
+
+  Data_Get_Struct(self, struct rua_ref, p);
+  lua_getglobal(p->L, "coroutine");
+  pretop = lua_gettop(p->L);
+  lua_pushstring(p->L, "resume");
+  lua_rawget(p->L, pretop);
+  lua_rawgeti(p->L, LUA_REGISTRYINDEX, p->ref);
+
+  for (i = 0; i < argc; i ++) {
+    rua_pushrbval(p->L, argv[i], p->R);
+  }
+
+  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);
+  }
+
+  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) {
+    return Qnil;
+  } else if (nresults == 1) {
+    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(L, -i, R));
+    }
+
+    lua_pop(L, nresults);
+    return retval;
+  }
+}
+
+static VALUE rua_torbval(lua_State *L, int idx, struct rua_state R) {
+  VALUE rbval = Qnil;
+
+  switch (lua_type(L, idx)) {
+  case LUA_TNUMBER:
+    rbval = rb_float_new(lua_tonumber(L, idx));
+    break;
+
+  case LUA_TBOOLEAN:
+    rbval = lua_toboolean(L, idx) ? Qtrue : Qfalse;
+    break;
+
+  case LUA_TSTRING:
+    rbval = rb_str_new2(lua_tostring(L, idx));
+    break;
+
+  case LUA_TTABLE:
+    if (rua_is_rbobj(L, idx)) {
+      rbval = rua_torbobj(L, idx);
+    } else {
+      rbval = rua_tohash(L, idx, R);
+    }
+
+    break;
+
+  case LUA_TFUNCTION:
+    rbval = rua_toruaobj(RuaFunc, L, idx, R);
+    break;
+
+  case LUA_TTHREAD:
+    rbval = rua_toruaobj(RuaThread, L, idx, R);
+    break;
+
+  case LUA_TLIGHTUSERDATA:
+    rbval = (VALUE) lua_touserdata(L, idx);
+    break;
+  }
+
+  return rbval;
+}
+
+static int rua_is_rbobj(lua_State *L, int idx) {
+  int tblidx, is_rbobj;
+
+  lua_pushvalue(L, idx);
+  tblidx = lua_gettop(L);
+  lua_pushstring(L, REF_RBOBJ);
+  lua_rawget(L, tblidx);
+  is_rbobj = lua_islightuserdata(L, -1);
+  lua_pop(L, 2);
+  return is_rbobj;
+}
+
+static VALUE rua_torbobj(lua_State *L, int idx) {
+  VALUE rbobj;
+  int tblidx;
+
+  lua_pushvalue(L, idx);
+  tblidx = lua_gettop(L);
+  lua_pushstring(L, REF_RBOBJ);
+  lua_rawget(L, tblidx);
+  rbobj = (VALUE) lua_touserdata(L, -1);
+  lua_pop(L, 2);
+  return rbobj;
+}
+
+static VALUE rua_tohash(lua_State *L, int idx, struct rua_state R) {
+  VALUE hash, key, val;
+  int tblidx;
+
+  lua_pushvalue(L, idx);
+  tblidx = lua_gettop(L);
+  hash = rb_hash_new();
+  lua_pushnil(L);
+
+  while (lua_next(L, tblidx) != 0) {
+    key = rua_torbval(L, -2, R);
+    val = rua_torbval(L, -1, R);
+    rb_hash_aset(hash, key, val);
+    lua_pop(L, 1);
+  }
+
+  lua_pop(L, 1);
+  return hash;
+}
+
+static void rua_pushrbval(lua_State *L, VALUE rbval, struct rua_state R) {
+  struct rua_ref *p;
+
+  switch (TYPE(rbval)) {
+  case T_NIL:
+    lua_pushnil(L);
+    break;
+
+  case T_FLOAT:
+  case T_FIXNUM:
+  case T_BIGNUM:
+    lua_pushnumber(L, rb_num2dbl(rbval));
+    break;
+
+  case T_STRING:
+    lua_pushstring(L, StringValuePtr(rbval));
+    break;
+
+  case T_TRUE:
+    lua_pushboolean(L, 1);
+    break;
+
+  case T_FALSE:
+    lua_pushboolean(L, 0);
+    break;
+
+  case T_ARRAY:
+    rua_newtable_from_ary(L, rbval, R);
+    break;
+
+  case T_HASH:
+    rua_newtable_from_hash(L, rbval, R);
+    break;
+
+  default:
+    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_ref, p);
+      lua_rawgeti(L, LUA_REGISTRYINDEX, p->ref);
+    } else if (rb_obj_is_kind_of(rbval, RuaThread)) {
+      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 *) R.error_handler);
+      lua_pushlightuserdata(L, (void *) R.secure);
+      lua_pushcclosure(L, rua_proc_call, 3);
+    } else {
+      rua_newtable_from_obj(L, rbval, R);
+    }
+
+    break;
+  }
+}
+
+static void rua_newtable_from_ary(lua_State *L, VALUE ary, struct rua_state R) {
+  VALUE entry;
+  int i, tblidx;
+
+  lua_newtable(L);
+  tblidx = lua_gettop(L);
+
+  for (i = 0; i < RARRAY(ary)->len; i++) {
+    entry = rb_ary_entry(ary, i);
+    lua_pushnumber(L, i + 1);
+    rua_pushrbval(L, entry, R);
+    lua_settable(L, tblidx);
+  }
+}
+
+static void rua_newtable_from_hash(lua_State *L, VALUE hash, struct rua_state R) {
+  VALUE keys, key, val;
+  int i, tblidx;
+
+  lua_newtable(L);
+  tblidx = lua_gettop(L);
+  keys = rb_check_convert_type(hash, T_ARRAY, "Array", "keys");
+
+  for (i = 0; i < RARRAY(keys)->len; i++) {
+    key = rb_ary_entry(keys, i);
+    val = rb_hash_aref(hash, key);
+    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, struct rua_state R) {
+  VALUE methods, name, method;
+  int i, tblidx;
+
+  lua_newtable(L);
+  tblidx = lua_gettop(L);
+  methods = rb_check_convert_type(obj, T_ARRAY, "Array", "methods");
+
+  lua_pushstring(L, REF_RBOBJ);
+  lua_pushlightuserdata(L, (void *) obj);
+  lua_settable(L, tblidx);
+
+  for (i = 0; i < RARRAY(methods)->len; i++) {
+    name = rb_ary_entry(methods, i);
+    method = rb_funcall(obj, rb_intern("method"), 1, name);
+
+    if (R.secure && rua_name_is_insecure_method(StringValuePtr(name))) {
+      continue;
+    }
+
+    rua_pushrbval(L, name, R);
+    rua_pushrbval(L, method, R);
+    lua_settable(L, tblidx);
+  }
+}
+
+static int rua_proc_call(lua_State *L) {
+  struct rua_state R;
+  VALUE proc, args, retval, errargs;
+  int i, n, status;
+
+  proc = (VALUE) lua_touserdata(L, lua_upvalueindex(1));
+  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, R));
+  }
+
+  rb_ary_push(args, proc);
+  retval = rb_protect(_rua_proc_call, args, &status);
+
+  if (status != 0) {
+    if (rua_obj_is_executable(R.error_handler)) {
+      errargs = rb_ary_new();
+      rb_ary_push(errargs, ruby_errinfo);
+      rb_ary_push(errargs, R.error_handler);
+      retval = rb_protect(_rua_proc_call, errargs, &status);
+
+      if (status != 0) {
+        fprintf(stderr, "warning: %s\n", rua_to_sptr(ruby_errinfo));
+      }
+    } else {
+      retval = Qnil;
+    }
+  }
+  
+  rua_pushrbval(L, retval, R);
+  return 1;
+}
+
+static VALUE _rua_proc_call(VALUE args) {
+  VALUE proc = rb_ary_pop(args);
+
+  return rb_apply(proc, rb_intern("call"), args);
+}
+
+static VALUE rua_toruaobj(VALUE klass, lua_State *L, int idx, struct rua_state R) {
+  struct rua_ref *p;
+  VALUE ruaobj;
+
+  ruaobj = rb_funcall(klass, rb_intern("new"), 0);
+  Data_Get_Struct(ruaobj, struct rua_ref , p);
+  p->L = L;
+  p->R = R;
+  lua_pushvalue(L, idx);
+  p->ref = luaL_ref(L, LUA_REGISTRYINDEX);
+  return ruaobj;
+}
+
+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));
+}
+
+static int rua_name_is_insecure_method(const char *name) {
+  int i;
+
+  for (i = 0; i < insecure_method_num; i++) {
+    if (strcmp(insecure_methods[i], name) == 0) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+static VALUE rua_to_s(VALUE v) {
+  return rb_check_convert_type(v, T_STRING, "String", "to_s");
+}
+
+static const char *rua_to_sptr(VALUE v) {
+  VALUE str = rua_to_s(v);
+
+  return StringValuePtr(str);
+}
+
+static VALUE rua_classname(VALUE v) {
+  VALUE klass = rb_obj_class(v);
+
+  return rb_class_name(klass);
+}
+
+static const char *rua_classname_ptr(VALUE v) {
+  VALUE klassname = rua_classname(v);
+
+  return StringValuePtr(klassname);
+}

data/ext/rua.h

@@ -0,0 +1,61 @@
+#ifndef __RUA_H__
+#define __RUA_H__
+
+struct rua_state {
+  VALUE error_handler;
+  int secure;
+};
+
+struct rua {
+  lua_State *L;
+  struct rua_state R;
+};
+
+struct rua_ref {
+  lua_State *L;
+  struct rua_state R;
+  int ref;
+};
+
+void Init_rua();
+static VALUE rua_alloc(VALUE klass);
+static void rua_free(struct rua *p);
+static VALUE rua_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE rua_openlibs(int argc, VALUE *argv, VALUE self);
+static VALUE rua_eval(VALUE self, VALUE str);
+static VALUE rua_get(VALUE self, VALUE key);
+static VALUE rua_set(VALUE self, VALUE key, VALUE val);
+static VALUE rua_get_secure(VALUE self);
+static VALUE rua_set_secure(VALUE self, VALUE secure);
+static VALUE rua_method_missing(int argc, VALUE *argv, VALUE self);
+
+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_func_get(VALUE self, VALUE key);
+//static VALUE rua_func_set(VALUE self, VALUE key, VALUE val);
+
+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_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, 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_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);
+static const char *rua_to_sptr(VALUE v);
+static VALUE rua_classname(VALUE v);
+static const char *rua_classname_ptr(VALUE v);
+
+#endif

metadata

@@ -3,9 +3,9 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: rua
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 date: 2007-11-18 00:00:00 +09:00
-summary: rua is a library for using Lua under Ruby.
+summary: Rua is a library for using Lua under Ruby.
 require_paths: 
 - lib/i386-mswin32
 email: sgwr_dts@yahoo.co.jp
@@ -15,7 +15,7 @@ description:
 autorequire: 
 default_executable: 
 bindir: bin
-has_rdoc: false
+has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
   - - ">"
@@ -31,12 +31,17 @@ authors:
 files: 
 - README.txt
 - lib/i386-mswin32/rua.so
+- ext/rua.c
+- ext/rua.h
 test_files: []
 
-rdoc_options: []
-
-extra_rdoc_files: []
-
+rdoc_options: 
+- --title
+- Rua - RDoc Documentation
+extra_rdoc_files: 
+- README.txt
+- ext/rua.c
+- ext/rua.h
 executables: []
 
 extensions: []