rubysl-dl 0.0.1 → 1.0.0

data/ext/rubysl/dl/handle.c

@@ -0,0 +1,215 @@
+/* -*- C -*-
+ * $Id: handle.c 11708 2007-02-12 23:01:19Z shyouhei $
+ */
+
+#include <ruby.h>
+#include "dl.h"
+
+VALUE rb_cDLHandle;
+
+void
+dlhandle_free(struct dl_handle *dlhandle)
+{
+  if (dlhandle->ptr && dlhandle->open && dlhandle->enable_close) {
+    dlclose(dlhandle->ptr);
+  }
+}
+
+VALUE
+rb_dlhandle_close(VALUE self)
+{
+  struct dl_handle *dlhandle;
+
+  Data_Get_Struct(self, struct dl_handle, dlhandle);
+  dlhandle->open = 0;
+  return INT2NUM(dlclose(dlhandle->ptr));
+}
+
+VALUE
+rb_dlhandle_s_allocate(VALUE klass)
+{
+  VALUE obj;
+  struct dl_handle *dlhandle;
+
+  obj = Data_Make_Struct(rb_cDLHandle, struct dl_handle, 0,
+			 dlhandle_free, dlhandle);
+  dlhandle->ptr  = 0;
+  dlhandle->open = 0;
+  dlhandle->enable_close = 0;
+
+  return obj;
+}
+
+VALUE
+rb_dlhandle_initialize(int argc, VALUE argv[], VALUE self)
+{
+  void *ptr;
+  struct dl_handle *dlhandle;
+  VALUE lib, flag;
+  char  *clib = 0;
+  int   cflag = 0;
+  const char *err;
+
+  switch (rb_scan_args(argc, argv, "11", &lib, &flag)) {
+  case 1:
+    clib = NIL_P(lib) ? NULL : StringValuePtr(lib);
+    cflag = RTLD_LAZY | RTLD_GLOBAL;
+    break;
+  case 2:
+    clib = NIL_P(lib) ? NULL : StringValuePtr(lib);
+    cflag = NUM2INT(flag);
+    break;
+  default:
+    rb_bug("rb_dlhandle_new");
+  }
+
+  ptr = dlopen(clib, cflag);
+#if defined(HAVE_DLERROR)
+  if (!ptr && (err = dlerror())) {
+    rb_raise(rb_eRuntimeError, "%s", err);
+  }
+#else
+  if (!ptr) {
+    err = dlerror();
+    rb_raise(rb_eRuntimeError, "%s", err);
+  }
+#endif
+  Data_Get_Struct(self, struct dl_handle, dlhandle);
+  if (dlhandle->ptr && dlhandle->open && dlhandle->enable_close) {
+    dlclose(dlhandle->ptr);
+  }
+  dlhandle->ptr = ptr;
+  dlhandle->open = 1;
+  dlhandle->enable_close = 0;
+
+  if (rb_block_given_p()) {
+    rb_ensure(rb_yield, self, rb_dlhandle_close, self);
+  }
+
+  return Qnil;
+}
+
+VALUE
+rb_dlhandle_enable_close(VALUE self)
+{
+  struct dl_handle *dlhandle;
+
+  Data_Get_Struct(self, struct dl_handle, dlhandle);
+  dlhandle->enable_close = 1;
+  return Qnil;
+}
+
+VALUE
+rb_dlhandle_disable_close(VALUE self)
+{
+  struct dl_handle *dlhandle;
+
+  Data_Get_Struct(self, struct dl_handle, dlhandle);
+  dlhandle->enable_close = 0;
+  return Qnil;
+}
+
+VALUE
+rb_dlhandle_to_i(VALUE self)
+{
+  struct dl_handle *dlhandle;
+
+  Data_Get_Struct(self, struct dl_handle, dlhandle);
+  return DLLONG2NUM(dlhandle);
+}
+
+VALUE
+rb_dlhandle_to_ptr(VALUE self)
+{
+  struct dl_handle *dlhandle;
+
+  Data_Get_Struct(self, struct dl_handle, dlhandle);
+  return rb_dlptr_new(dlhandle, sizeof(dlhandle), 0);
+}
+
+VALUE
+rb_dlhandle_sym(int argc, VALUE argv[], VALUE self)
+{
+  VALUE sym, type;
+  void (*func)();
+  VALUE val;
+  struct dl_handle *dlhandle;
+  void *handle;
+  const char *name, *stype;
+  const char *err;
+
+  rb_secure(2);
+  if (rb_scan_args(argc, argv, "11", &sym, &type) == 2) {
+    SafeStringValue(type);
+    stype = StringValuePtr(type);
+  }
+  else{
+    stype = NULL;
+  }
+
+  if (sym == Qnil) {
+#if defined(RTLD_NEXT)
+    name = RTLD_NEXT;
+#else
+    name = NULL;
+#endif
+  }
+  else{
+    SafeStringValue(sym);
+    name = StringValuePtr(sym);
+  }
+
+  Data_Get_Struct(self, struct dl_handle, dlhandle);
+  if (!dlhandle->open) {
+    rb_raise(rb_eRuntimeError, "closed handle");
+  }
+  handle = dlhandle->ptr;
+
+  func = dlsym(handle, name);
+#if defined(HAVE_DLERROR)
+  if (!func && (err = dlerror()))
+#else
+  if (!func)
+#endif
+  {
+#if defined(__CYGWIN__) || defined(WIN32) || defined(__MINGW32__)
+    {
+      int  len = strlen(name);
+      char *name_a = (char*)dlmalloc(len+2);
+      strcpy(name_a, name);
+      name_a[len]   = 'A';
+      name_a[len+1] = '\0';
+      func = dlsym(handle, name_a);
+      dlfree(name_a);
+#if defined(HAVE_DLERROR)
+      if (!func && (err = dlerror()))
+#else
+      if (!func)
+#endif
+      {
+	rb_raise(rb_eRuntimeError, "unknown symbol \"%sA\"", name);
+      }
+    }
+#else
+    rb_raise(rb_eRuntimeError, "unknown symbol \"%s\"", name);
+#endif
+  }
+  val = rb_dlsym_new(func, name, stype);
+
+  return val;
+}
+
+void
+Init_dlhandle()
+{
+  rb_cDLHandle = rb_define_class_under(rb_mDL, "Handle", rb_cObject);
+  rb_define_alloc_func(rb_cDLHandle, rb_dlhandle_s_allocate);
+  rb_define_method(rb_cDLHandle, "initialize", rb_dlhandle_initialize, -1);
+  rb_define_method(rb_cDLHandle, "to_i", rb_dlhandle_to_i, 0);
+  rb_define_method(rb_cDLHandle, "to_ptr", rb_dlhandle_to_ptr, 0);
+  rb_define_method(rb_cDLHandle, "close", rb_dlhandle_close, 0);
+  rb_define_method(rb_cDLHandle, "sym",  rb_dlhandle_sym, -1);
+  rb_define_method(rb_cDLHandle, "[]",  rb_dlhandle_sym, -1);
+  rb_define_method(rb_cDLHandle, "disable_close", rb_dlhandle_disable_close, 0);
+  rb_define_method(rb_cDLHandle, "enable_close", rb_dlhandle_enable_close, 0);
+}

data/ext/rubysl/dl/install.rb

@@ -0,0 +1,49 @@
+require 'mkmf'
+require 'ftools'
+
+SO_LIBS = ["dl.so"]
+
+$ruby_version = CONFIG['MAJOR'] + "." + CONFIG['MINOR']
+$prefix = CONFIG['prefix']
+$libdir = File.join($prefix,'lib')
+$rubylibdir = File.join($libdir, 'ruby', $ruby_version)
+$arch = CONFIG['arch']
+$archdir = File.join($rubylibdir, $arch)
+
+def find(dir, match = /./)
+  Dir.chdir(dir)
+  files = []
+  Dir.new(".").each{|file|
+    if( file != "." && file != ".." )
+      case File.ftype(file)
+      when "file"
+	if( file =~ match )
+	  files.push(File.join(dir,file))
+	end
+      when "directory"
+	files += find(file, match).collect{|f| File.join(dir,f)}
+      end
+    end
+  }
+  Dir.chdir("..")
+  return files
+end
+
+def install()
+  rb_files = find(File.join(".","lib"), /.rb$/)
+
+  SO_LIBS.each{|f|
+    File.makedirs($rubylibdir, "#{$archdir}")
+    File.install(f, File.join($archdir,f), 0555, true)
+  }
+
+  rb_files.each{|f|
+    origfile = f
+    instfile = File.join($rubylibdir, origfile.sub("./lib/",""))
+    instdir  = File.dirname(instfile)
+    File.makedirs(instdir)
+    File.install(origfile, instfile, 0644, true)
+  }
+end
+
+install()

data/ext/rubysl/dl/lib/dl/import.rb

@@ -0,0 +1,225 @@
+# -*- ruby -*-
+
+require 'dl'
+require 'dl/types'
+
+module DL
+  module Importable
+    LIB_MAP = {}
+
+    module Internal
+      def init_types()
+	@types ||= ::DL::Types.new
+      end
+
+      def init_sym()
+	@SYM ||= {}
+      end
+
+      def [](name)
+	return @SYM[name.to_s][0]
+      end
+
+      def dlload(*libnames)
+	if( !defined?(@LIBS) )
+	  @LIBS = []
+	end
+	libnames.each{|libname|
+	  if( !LIB_MAP[libname] )
+	    LIB_MAP[libname] = DL.dlopen(libname)
+	  end
+	  @LIBS.push(LIB_MAP[libname])
+	}
+      end
+      alias dllink :dlload
+
+      def parse_cproto(proto)
+	proto = proto.gsub(/\s+/, " ").strip
+	case proto
+	when /^([\d\w\*_\s]+)\(([\d\w\*_\s\,\[\]]*)\)$/
+	  ret = $1
+	  args = $2.strip()
+	  ret = ret.split(/\s+/)
+	  args = args.split(/\s*,\s*/)
+	  func = ret.pop()
+	  if( func =~ /^\*/ )
+	    func.gsub!(/^\*+/,"")
+	    ret.push("*")
+	  end
+	  ret  = ret.join(" ")
+	  return [func, ret, args]
+	else
+	  raise(RuntimeError,"can't parse the function prototype: #{proto}")
+	end
+      end
+
+      # example:
+      #   extern "int strlen(char*)"
+      #
+      def extern(proto)
+	func,ret,args = parse_cproto(proto)
+	return import(func, ret, args)
+      end
+
+      # example:
+      #   callback "int method_name(int, char*)"
+      #
+      def callback(proto)
+	func,ret,args = parse_cproto(proto)
+
+	init_types()
+	init_sym()
+
+	rty,renc,rdec = @types.encode_return_type(ret)
+        if( !rty )
+          raise(TypeError, "unsupported type: #{ret}")
+        end
+	ty,enc,dec = encode_argument_types(args)
+	symty = rty + ty
+
+	module_eval("module_function :#{func}")
+	sym = module_eval([
+	  "DL::callback(\"#{symty}\"){|*args|",
+	  "  sym,rdec,enc,dec  = @SYM['#{func}']",
+	  "  args = enc.call(args) if enc",
+	  "  r,rs = #{func}(*args)",
+	  "  r  = renc.call(r) if rdec",
+	  "  rs = dec.call(rs) if (dec && rs)",
+	  "  @retval = r",
+	  "  @args   = rs",
+	  "  r",
+	  "}",
+	].join("\n"))
+
+	@SYM[func] = [sym,rdec,enc,dec]
+
+	return sym
+      end
+
+      # example:
+      #  typealias("uint", "unsigned int")
+      #
+      def typealias(alias_type, ty1, enc1=nil, dec1=nil, ty2=nil, enc2=nil, dec2=nil)
+	init_types()
+	@types.typealias(alias_type, ty1, enc1, dec1,
+                                     ty2||ty1, enc2, dec2)
+      end
+
+      # example:
+      #  symbol "foo_value"
+      #  symbol "foo_func", "IIP"
+      #
+      def symbol(name, ty = nil)
+	sym = nil
+	@LIBS.each{|lib|
+	  begin
+	    if( ty )
+	      sym = lib[name, ty]
+	    else
+	      sym = lib[name]
+	    end
+	  rescue
+	    next
+	  end
+	}
+	if( !sym )
+	  raise(RuntimeError, "can't find the symbol `#{name}'")
+	end
+	return sym
+      end
+
+      # example:
+      #   import("get_length", "int", ["void*", "int"])
+      #
+      def import(name, rettype, argtypes = nil)
+	init_types()
+	init_sym()
+
+	rty,_,rdec = @types.encode_return_type(rettype)
+        if( !rty )
+          raise(TypeError, "unsupported type: #{rettype}")
+        end
+	ty,enc,dec = encode_argument_types(argtypes)
+	symty = rty + ty
+
+	sym = symbol(name, symty)
+
+	mname = name.dup
+	if( ?A <= mname[0] && mname[0] <= ?Z )
+	  mname[0,1] = mname[0,1].downcase
+	end
+	@SYM[mname] = [sym,rdec,enc,dec]
+	
+	module_eval [
+	  "def #{mname}(*args)",
+	  "  sym,rdec,enc,dec  = @SYM['#{mname}']",
+	  "  args = enc.call(args) if enc",
+	  if( $DEBUG )
+	    "  p \"[DL] call #{mname} with \#{args.inspect}\""
+	  else
+	    ""
+	  end,
+	  "  r,rs = sym.call(*args)",
+	  if( $DEBUG )
+	    "  p \"[DL] retval=\#{r.inspect} args=\#{rs.inspect}\""
+	  else
+	    ""
+	  end,
+	  "  r  = rdec.call(r) if rdec",
+	  "  rs = dec.call(rs) if dec",
+	  "  @retval = r",
+	  "  @args   = rs",
+	  "  return r",
+	  "end",
+	  "module_function :#{mname}",
+	].join("\n")
+
+	return sym
+      end
+
+      def _args_
+	return @args
+      end
+
+      def _retval_
+	return @retval
+      end
+
+      def encode_argument_types(tys)
+	init_types()
+	encty = []
+	enc = nil
+	dec = nil
+	tys.each_with_index{|ty,idx|
+	  ty,c1,c2 = @types.encode_argument_type(ty)
+          if( !ty )
+            raise(TypeError, "unsupported type: #{ty}")
+          end
+	  encty.push(ty)
+	  if( enc )
+	    if( c1 )
+	      conv1 = enc
+	      enc = proc{|v| v = conv1.call(v); v[idx] = c1.call(v[idx]); v}
+	    end
+	  else
+	    if( c1 )
+	      enc = proc{|v| v[idx] = c1.call(v[idx]); v}
+	    end
+	  end
+	  if( dec )
+	    if( c2 )
+	      conv2 = dec
+	      dec = proc{|v| v = conv2.call(v); v[idx] = c2.call(v[idx]); v}
+	    end
+	  else
+	    if( c2 )
+	      dec = proc{|v| v[idx] = c2.call(v[idx]); v}
+	    end
+	  end
+	}
+	return [encty.join, enc, dec]
+      end
+    end # end of Internal
+    include Internal
+  end # end of Importable
+end