rua 0.1.0

data/ext/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+dir_config('lua', '/usr/include/lua5.1', '/usr/lib')
+if have_header('lua.h') and have_header('lualib.h') and have_header('lauxlib.h') and have_library('lua5.1')
+  create_makefile('rua')
+end

data/ext/rua.c

@@ -0,0 +1,523 @@
+#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"
+
+static const char *insecure_methods[] = {
+  " __id__",
+  "__send__",
+  "class",
+  "extend",
+  "freeze",
+  "id",
+  "instance_eval",
+  "instance_variable_defined?",
+  "instance_variable_get",
+  "instance_variable_set",
+  "instance_variables",
+  "method",
+  "method_missing",
+  "methods",
+  "private_methods",
+  "protected_methods",
+  "public_methods",
+  "respond_to?",
+  "send",
+  "singleton_methods",
+  "taint",
+  "type",
+  "untaint",
+  "to_ary",
+  "to_hash",
+  "to_int",
+  "to_str"
+};
+
+static const int insecure_method_num = sizeof(insecure_methods) / sizeof(char*);
+
+void Init_rua() {
+  VALUE Rua, RuaFunc, RuaError;
+
+  Rua = rb_define_class("Rua", rb_cObject);
+  RuaFunc = rb_define_class("RuaFunc", rb_cObject);
+  RuaError = rb_define_class("RuaError", rb_eStandardError);
+
+  rb_define_alloc_func(Rua, rua_alloc);
+  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_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);
+}
+
+// ------------------------------------------------------------------
+
+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);
+}
+
+static VALUE rua_initialize(int argc, VALUE *argv, VALUE self) {
+  struct rua *p;
+  VALUE error_handler, klass, klassname;
+
+  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)) {
+    klass = rb_obj_class(error_handler);
+    klassname = rb_class_name(klass);
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected Proc or Method)", StringValuePtr(klassname));
+  }
+
+  p->L = lua_open();
+  p->secure = 1;
+  p->error_handler = error_handler;
+  return Qnil;
+}
+
+static VALUE rua_openlibs(int argc, VALUE *argv, VALUE self) {
+  struct rua *p;
+  VALUE arg, s_all, s_base, s_package, s_string, s_table, s_math, s_io, s_debug;
+  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);
+
+  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"));
+
+  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 {
+      arg = rb_check_convert_type(arg, T_STRING, "String", "to_s");
+      rb_raise(rb_eArgError, "unknown library '%s' (available: base, package, table, math, io, debug, all)", StringValuePtr(arg));
+    }
+  }
+
+  return Qnil;
+}
+
+static VALUE rua_eval(VALUE self, VALUE str) {
+  struct rua *p;
+  VALUE retval, RuaError;
+  const char *errmsg;
+
+  Data_Get_Struct(self, struct rua, p);
+  Check_Type(str, T_STRING);
+  luaL_loadstring(p->L, StringValuePtr(str));
+
+  if (lua_pcall(p->L, 0, 1, 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);
+  }
+
+  retval = rua_torbval(p->L, -1, p->error_handler, p->secure);
+  lua_pop(p->L, 1);
+  return retval;
+}
+
+static VALUE rua_get(VALUE self, VALUE key) {
+  struct rua *p;
+  VALUE retval;
+
+  Data_Get_Struct(self, struct rua, p);
+  key = rb_check_convert_type(key, T_STRING, "String", "to_s");
+  lua_getglobal(p->L, StringValuePtr(key));
+  retval = rua_torbval(p->L, -1, p->error_handler, p->secure);
+  lua_pop(p->L, 1);
+  return retval;
+}
+
+static VALUE rua_set(VALUE self, VALUE key, VALUE val) {
+  struct rua *p;
+  VALUE RuaError, inspect, klass, klassname;
+
+  Data_Get_Struct(self, struct rua, p);
+
+  if (p->secure && rb_obj_is_kind_of(val, rb_cModule)) {
+    RuaError = rb_const_get(rb_cObject, rb_intern("RuaError"));
+    inspect = rb_check_convert_type(val, T_STRING, "String", "inspect");
+    klass = rb_obj_class(val);
+    klassname = rb_class_name(klass);
+    rb_raise(RuaError, "set insecure value %s (%s)", StringValuePtr(inspect), StringValuePtr(klassname));
+  }
+
+  key = rb_check_convert_type(key, T_STRING, "String", "to_s");
+  rua_pushrbval(p->L, val, p->error_handler, p->secure);
+  lua_setglobal(p->L, StringValuePtr(key));
+  return Qnil;
+}
+
+static VALUE rua_get_secure(VALUE self) {
+  struct rua *p;
+
+  Data_Get_Struct(self, struct rua, p);
+  return p->secure ? Qtrue : Qfalse;
+}
+
+static VALUE rua_set_secure(VALUE self, VALUE secure) {
+  struct rua *p;
+  VALUE klass, klassname;
+
+  Data_Get_Struct(self, struct rua, p);
+
+  switch (TYPE(secure)) {
+  case T_TRUE:  p->secure = 1; break;
+  case T_FALSE: p->secure = 0; break;
+  default:
+    klass = rb_obj_class(secure);
+    klassname = rb_class_name(klass);
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected TrueClass or FalseClass)", StringValuePtr(klassname));
+    break;
+  }
+
+  return Qnil;
+}
+
+// ------------------------------------------------------------------
+
+static VALUE rua_func_alloc(VALUE klass) {
+  struct rua_func *p = ALLOC(struct rua_func);
+
+  return Data_Wrap_Struct(klass, 0, -1, p);
+}
+
+static VALUE rua_func_initialize(VALUE self) {
+  return Qnil;
+}
+
+static VALUE rua_func_call(int argc, VALUE *argv, VALUE self) {
+  struct rua_func *p;
+  VALUE retval, RuaError;
+  int i;
+  const char *errmsg;
+
+  Data_Get_Struct(self, struct rua_func, p);
+  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, 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);
+  }
+
+  retval = rua_torbval(p->L, -1, p->error_handler, p->secure);
+  lua_pop(p->L, 1);
+  return retval;
+}
+
+// ------------------------------------------------------------------
+
+static VALUE rua_torbval(lua_State *L, int idx, VALUE error_handler, int secure) {
+  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:
+    rbval = rua_tohash(L, idx, error_handler, secure);
+    break;
+
+  case LUA_TFUNCTION:
+    rbval = rua_toruafunc(L, idx, error_handler, secure);
+    break;
+
+  case LUA_TLIGHTUSERDATA:
+    rbval = (VALUE) lua_touserdata(L, idx);
+    break;
+  }
+
+  return rbval;
+}
+
+static VALUE rua_tohash(lua_State *L, int idx, VALUE error_handler, int secure) {
+  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, error_handler, secure);
+    val = rua_torbval(L, -1, error_handler, secure);
+    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, VALUE error_handler, int secure) {
+  struct rua_func *p;
+  VALUE RuaFunc, inspect, klass, klassname;
+
+  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, error_handler, secure);
+    break;
+
+  case T_HASH:
+    rua_newtable_from_hash(L, rbval, error_handler, secure);
+    break;
+
+  default:
+    RuaFunc = rb_const_get(rb_cObject, rb_intern("RuaFunc"));
+
+    if (secure && rb_obj_is_kind_of(rbval, rb_cModule)) {
+      inspect = rb_check_convert_type(rbval, T_STRING, "String", "inspect");
+      klass = rb_obj_class(rbval);
+      klassname = rb_class_name(klass);
+      rb_fatal("convert insecure value %s (%s)", StringValuePtr(inspect), StringValuePtr(klassname));
+    } else if (rb_obj_is_kind_of(rbval, RuaFunc)) {
+      Data_Get_Struct(rbval, struct rua_func, 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_pushcclosure(L, rua_proc_call, 3);
+    } else {
+      rua_newtable_from_obj(L, rbval, error_handler, secure);
+    }
+
+    break;
+  }
+}
+
+static void rua_newtable_from_ary(lua_State *L, VALUE ary, VALUE error_handler, int secure) {
+  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, error_handler, secure);
+    lua_settable(L, tblidx);
+  }
+}
+
+static void rua_newtable_from_hash(lua_State *L, VALUE hash, VALUE error_handler, int secure) {
+  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, error_handler, secure);
+    rua_pushrbval(L, val, error_handler, secure);
+    lua_settable(L, tblidx);
+  }
+}
+
+static void rua_newtable_from_obj(lua_State *L, VALUE obj, VALUE error_handler, int secure) {
+  VALUE methods, name, method;
+  int i, tblidx;
+
+  lua_newtable(L);
+  tblidx = lua_gettop(L);
+  methods = rb_check_convert_type(obj, T_ARRAY, "Array", "methods");
+
+  for (i = 0; i < RARRAY(methods)->len; i++) {
+    name = rb_ary_entry(methods, i);
+    method = rb_funcall(obj, rb_intern("method"), 1, name);
+
+    if (secure && rua_name_is_insecure_method(StringValuePtr(name))) {
+      continue;
+    }
+
+    rua_pushrbval(L, name, error_handler, secure);
+    rua_pushrbval(L, method, error_handler, secure);
+    lua_settable(L, tblidx);
+  }
+}
+
+static int rua_proc_call(lua_State *L) {
+  VALUE proc, args, retval, error_handler, errargs, errmsg;
+  int i, n, status, secure;
+
+  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));
+  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, proc);
+  retval = rb_protect(_rua_proc_call, args, &status);
+
+  if (status != 0) {
+    if (rua_obj_is_executable(error_handler)) {
+      errargs = rb_ary_new();
+      rb_ary_push(errargs, ruby_errinfo);
+      rb_ary_push(errargs, error_handler);
+      retval = rb_protect(_rua_proc_call, errargs, &status);
+
+      if (status != 0) {
+        errmsg = rb_check_convert_type(ruby_errinfo, T_STRING, "String", "to_s");
+        fprintf(stderr, "warning: %s\n", StringValuePtr(errmsg));
+      }
+    } else {
+      retval = Qnil;
+    }
+  }
+  
+  rua_pushrbval(L, retval, error_handler, secure);
+  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_toruafunc(lua_State *L, int idx, VALUE error_handler, int secure) {
+  struct rua_func *p;
+  VALUE RuaFunc, f;
+
+  RuaFunc = rb_const_get(rb_cObject, rb_intern("RuaFunc"));
+  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);
+  lua_pop(L, 1);
+  return f;
+}
+
+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;
+}

data/ext/rua.h

@@ -0,0 +1,44 @@
+#ifndef __RUA_H__
+#define __RUA_H__
+
+struct rua {
+  lua_State *L;
+  VALUE error_handler;
+  int secure;
+};
+
+struct rua_func {
+  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);
+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_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_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);
+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 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_obj_is_executable(VALUE obj);
+static int rua_name_is_insecure_method(const char *name);
+
+#endif

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: rua
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-11-13 00:00:00 +09:00
+summary: rua is a library for using Lua under Ruby.
+require_paths: 
+- lib
+email: sgwr_dts@yahoo.co.jp
+homepage: http://rua.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- winebarrel
+files: 
+- ext/rua.c
+- ext/rua.h
+- ext/extconf.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- ext/extconf.rb
+requirements: []
+
+dependencies: []
+