rubysl-dl 0.0.1 → 1.0.0

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

@@ -0,0 +1,149 @@
+# -*- ruby -*-
+
+require 'dl'
+require 'dl/import'
+
+module DL
+  module Importable
+    module Internal
+      def define_struct(contents)
+	init_types()
+	Struct.new(@types, contents)
+      end
+      alias struct define_struct
+
+      def define_union(contents)
+	init_types()
+	Union.new(@types, contents)
+      end
+      alias union define_union
+
+      class Memory
+	def initialize(ptr, names, ty, len, enc, dec)
+	  @ptr = ptr
+	  @names = names
+	  @ty    = ty
+	  @len   = len
+	  @enc   = enc
+	  @dec   = dec
+
+	  # define methods
+	  @names.each{|name|
+	    instance_eval [
+	      "def #{name}",
+	      "  v = @ptr[\"#{name}\"]",
+	      "  if( @len[\"#{name}\"] )",
+	      "    v = v.collect{|x| @dec[\"#{name}\"] ? @dec[\"#{name}\"].call(x) : x }",
+              "  else",
+	      "    v = @dec[\"#{name}\"].call(v) if @dec[\"#{name}\"]",
+	      "  end",
+	      "  return v",
+	      "end",
+	      "def #{name}=(v)",
+	      "  if( @len[\"#{name}\"] )",
+	      "    v = v.collect{|x| @enc[\"#{name}\"] ? @enc[\"#{name}\"].call(x) : x }",
+	      "  else",
+	      "    v = @enc[\"#{name}\"].call(v) if @enc[\"#{name}\"]",
+              "  end",
+	      "  @ptr[\"#{name}\"] = v",
+	      "  return v",
+	      "end",
+	    ].join("\n")
+	  }
+	end
+
+	def to_ptr
+	  return @ptr
+	end
+
+	def size
+	  return @ptr.size
+	end
+      end
+
+      class Struct
+	def initialize(types, contents)
+	  @names = []
+	  @ty   = {}
+	  @len  = {}
+	  @enc  = {}
+	  @dec  = {}
+	  @size = 0
+	  @tys  = ""
+	  @types = types
+	  parse(contents)
+	end
+
+	def size
+	  return @size
+	end
+
+	def members
+	  return @names
+	end
+
+	# ptr must be a PtrData object.
+	def new(ptr)
+	  ptr.struct!(@tys, *@names)
+	  mem = Memory.new(ptr, @names, @ty, @len, @enc, @dec)
+	  return mem
+	end
+
+	def malloc(size = nil)
+	  if( !size )
+	    size = @size
+	  end
+	  ptr = DL::malloc(size)
+	  return new(ptr)
+	end
+
+	def parse(contents)
+	  contents.each{|elem|
+	    name,ty,num,enc,dec = parse_elem(elem)
+	    @names.push(name)
+	    @ty[name]  = ty
+	    @len[name] = num
+	    @enc[name] = enc
+	    @dec[name] = dec
+	    if( num )
+	      @tys += "#{ty}#{num}"
+	    else
+	      @tys += ty
+	    end
+	  }
+	  @size = DL.sizeof(@tys)
+	end
+	
+	def parse_elem(elem)
+	  elem.strip!
+	  case elem
+	  when /^([\w\d_\*]+)([\*\s]+)([\w\d_]+)$/
+	    ty = ($1 + $2).strip
+	    name = $3
+	    num = nil;
+	  when /^([\w\d_\*]+)([\*\s]+)([\w\d_]+)\[(\d+)\]$/
+	    ty = ($1 + $2).strip
+	    name = $3
+	    num = $4.to_i
+	  else
+	    raise(RuntimeError, "invalid element: #{elem}")
+	  end
+	  ty,enc,dec = @types.encode_struct_type(ty)
+          if( !ty )
+            raise(TypeError, "unsupported type: #{ty}")
+          end
+	  return [name,ty,num,enc,dec]
+	end
+      end  # class Struct
+      
+      class Union < Struct
+	def new
+	  ptr = DL::malloc(@size)
+	  ptr.union!(@tys, *@names)
+	  mem = Memory.new(ptr, @names, @ty, @len, @enc, @dec)
+	  return mem
+	end
+      end
+    end  # module Internal
+  end  # module Importable
+end  # module DL

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

@@ -0,0 +1,245 @@
+# -*- ruby -*-
+
+require 'dl'
+
+module DL
+  class Types
+    TYPES = [
+      # FORMAT:
+      # ["alias name",
+      #  "type name", encoding_method, decoding_method,   for function prototypes
+      #  "type name", encoding_method, decoding_method]   for structures (not implemented)
+      
+      # for Windows
+      ["DWORD",  "unsigned long", nil, nil,
+                 "unsigned long", nil, nil],
+      ["PDWORD", "unsigned long *", nil, nil,
+                 "unsigned long *", nil, nil],
+      ["WORD",   "unsigned short", nil, nil,
+                 "unsigned short", nil, nil],
+      ["PWORD",  "unsigned int *", nil, nil,
+                 "unsigned int *", nil, nil],
+      ["BYTE",   "unsigned char",   nil, nil,
+                 "unsigned char", nil, nil],
+      ["PBYTE",  "unsigned char *", nil, nil,
+                 "unsigned char *", nil, nil],
+      ["BOOL",   "ibool", nil, nil,
+                 "ibool", nil, nil],
+      ["ATOM",   "int", nil, nil,
+                 "int", nil, nil],
+      ["BYTE",   "unsigned char", nil, nil,
+                 "unsigned char", nil, nil],
+      ["PBYTE",  "unsigned char *", nil, nil,
+                 "unsigned char *", nil, nil],
+      ["UINT",   "unsigned int", nil, nil,
+                 "unsigned int", nil, nil],
+      ["ULONG",  "unsigned long", nil, nil,
+                 "unsigned long", nil, nil],
+      ["UCHAR",  "unsigned char", nil, nil,
+                 "unsigned char", nil, nil],
+      ["HANDLE", "unsigned long", nil, nil,
+                 "unsigned long", nil, nil],
+      ["PHANDLE","void*", nil, nil,
+                 "void*", nil, nil],
+      ["PVOID",  "void*", nil, nil,
+                 "void*", nil, nil],
+      ["LPCSTR", "char*", nil, nil,
+                 "char*", nil, nil],
+      ["HDC",    "unsigned int", nil, nil,
+                 "unsigned int", nil, nil],
+      ["HWND",   "unsigned int", nil, nil,
+                 "unsigned int", nil, nil],
+      
+      # Others
+      ["uint",   "unsigned int", nil, nil,
+                 "unsigned int", nil, nil],
+      ["u_int",  "unsigned int", nil, nil,
+                 "unsigned int", nil, nil],
+      ["ulong",  "unsigned long", nil, nil,
+                 "unsigned long", nil, nil],
+      ["u_long", "unsigned long", nil, nil,
+                 "unsigned long", nil, nil],
+
+      # DL::Importable primitive types
+      ["ibool",
+        "I",
+	proc{|v| v ? 1 : 0},
+	proc{|v| (v != 0) ? true : false},
+        "I",
+	proc{|v| v ? 1 : 0 },
+	proc{|v| (v != 0) ? true : false} ],
+      ["cbool",
+        "C",
+	proc{|v| v ? 1 : 0},
+	proc{|v| (v != 0) ? true : false},
+        "C",
+	proc{|v,len| v ? 1 : 0},
+	proc{|v,len| (v != 0) ? true : false}],
+      ["lbool",
+        "L",
+	proc{|v| v ? 1 : 0},
+	proc{|v| (v != 0) ? true : false},
+        "L",
+	proc{|v,len| v ? 1 : 0},
+	proc{|v,len| (v != 0) ? true : false}],
+      ["unsigned char",
+        "C",
+	proc{|v| [v].pack("C").unpack("c")[0]},
+	proc{|v| [v].pack("c").unpack("C")[0]},
+        "C",
+	proc{|v| [v].pack("C").unpack("c")[0]},
+	proc{|v| [v].pack("c").unpack("C")[0]}],
+      ["unsigned short",
+        "H",
+	proc{|v| [v].pack("S").unpack("s")[0]},
+	proc{|v| [v].pack("s").unpack("S")[0]},
+        "H",
+	proc{|v| [v].pack("S").unpack("s")[0]},
+	proc{|v| [v].pack("s").unpack("S")[0]}],
+      ["unsigned int",
+        "I",
+	proc{|v| [v].pack("I").unpack("i")[0]},
+	proc{|v| [v].pack("i").unpack("I")[0]},
+        "I",
+	proc{|v| [v].pack("I").unpack("i")[0]},
+	proc{|v| [v].pack("i").unpack("I")[0]}],
+      ["unsigned long",
+        "L",
+	proc{|v| [v].pack("L").unpack("l")[0]},
+	proc{|v| [v].pack("l").unpack("L")[0]},
+        "L",
+	proc{|v| [v].pack("L").unpack("l")[0]},
+	proc{|v| [v].pack("l").unpack("L")[0]}],
+      ["unsigned char ref",
+        "c",
+	proc{|v| [v].pack("C").unpack("c")[0]},
+	proc{|v| [v].pack("c").unpack("C")[0]},
+	nil, nil, nil],
+      ["unsigned int ref",
+        "i",
+	proc{|v| [v].pack("I").unpack("i")[0]},
+	proc{|v| [v].pack("i").unpack("I")[0]},
+	nil, nil, nil],
+      ["unsigned long ref",
+        "l",
+	proc{|v| [v].pack("L").unpack("l")[0]},
+	proc{|v| [v].pack("l").unpack("L")[0]},
+	nil, nil, nil],
+      ["char ref",  "c", nil, nil,
+                    nil, nil, nil],
+      ["short ref", "h", nil, nil,
+                    nil, nil, nil],
+      ["int ref",   "i", nil, nil,
+                    nil, nil, nil],
+      ["long ref",  "l", nil, nil,
+                    nil, nil, nil],
+      ["float ref", "f", nil, nil,
+                    nil, nil, nil],
+      ["double ref","d", nil, nil,
+                    nil, nil, nil],
+      ["char",   "C", nil, nil,
+                 "C", nil, nil],
+      ["short",  "H", nil, nil,
+                 "H", nil, nil],
+      ["int",    "I", nil, nil,
+                 "I", nil, nil],
+      ["long",   "L", nil, nil,
+                 "L", nil, nil],
+      ["float",  "F", nil, nil,
+                 "F", nil, nil],
+      ["double", "D", nil, nil,
+                 "D", nil, nil],
+      [/^char\s*\*$/,"s",nil, nil,
+                     "S",nil, nil],
+      [/^const char\s*\*$/,"S",nil, nil,
+                           "S",nil, nil],
+      [/^.+\*$/,   "P", nil, nil,
+                   "P", nil, nil],
+      [/^.+\[\]$/, "a", nil, nil,
+                   "a", nil, nil],
+      ["void",   "0", nil, nil,
+                 nil, nil, nil],
+    ]
+
+    def initialize
+      init_types()
+    end
+
+    def typealias(ty1, ty2, enc=nil, dec=nil, ty3=nil, senc=nil, sdec=nil)
+      @TYDEFS.unshift([ty1, ty2, enc, dec, ty3, senc, sdec])
+    end
+
+    def init_types
+      @TYDEFS = TYPES.dup
+    end
+
+    def encode_argument_type(alias_type)
+      proc_encode = nil
+      proc_decode = nil
+      @TYDEFS.each{|aty,ty,enc,dec,_,_,_|
+	if( (aty.is_a?(Regexp) && (aty =~ alias_type)) || (aty == alias_type) )
+	  alias_type = alias_type.gsub(aty,ty) if ty
+          alias_type.strip! if alias_type
+	  if( proc_encode )
+	    if( enc )
+	      conv1 = proc_encode
+	      proc_encode = proc{|v| enc.call(conv1.call(v))}
+	    end
+	  else
+	    if( enc )
+	      proc_encode = enc
+	    end
+	  end
+	  if( proc_decode )
+	    if( dec )
+	      conv2 = proc_decode
+	      proc_decode = proc{|v| dec.call(conv2.call(v))}
+	    end
+	  else
+	    if( dec )
+	      proc_decode = dec
+	    end
+	  end
+	end
+      }
+      return [alias_type, proc_encode, proc_decode]
+    end
+
+    def encode_return_type(ty)
+      ty, enc, dec = encode_argument_type(ty)
+      return [ty, enc, dec]
+    end
+
+    def encode_struct_type(alias_type)
+      proc_encode = nil
+      proc_decode = nil
+      @TYDEFS.each{|aty,_,_,_,ty,enc,dec|
+	if( (aty.is_a?(Regexp) && (aty =~ alias_type)) || (aty == alias_type) )
+	  alias_type = alias_type.gsub(aty,ty) if ty
+          alias_type.strip! if alias_type
+	  if( proc_encode )
+	    if( enc )
+	      conv1 = proc_encode
+	      proc_encode = proc{|v| enc.call(conv1.call(v))}
+	    end
+	  else
+	    if( enc )
+	      proc_encode = enc
+	    end
+	  end
+	  if( proc_decode )
+	    if( dec )
+	      conv2 = proc_decode
+	      proc_decode = proc{|v| dec.call(conv2.call(v))}
+	    end
+	  else
+	    if( dec )
+	      proc_decode = dec
+	    end
+	  end
+	end
+      }
+      return [alias_type, proc_encode, proc_decode]
+    end
+  end # end of Types
+end

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

@@ -0,0 +1,25 @@
+# -*- ruby -*-
+
+require 'dl'
+
+class Win32API
+  DLL = {}
+
+  def initialize(dllname, func, import, export = "0")
+    prototype = (export + import.to_s).tr("VPpNnLlIi", "0SSI").sub(/^(.)0*$/, '\1')
+    handle = DLL[dllname] ||= DL::Handle.new(dllname)
+    @sym = handle.sym(func, prototype)
+  end
+
+  def call(*args)
+    import = @sym.proto.split("", 2)[1]
+    args.each_with_index do |x, i|
+      args[i] = nil if x == 0 and import[i] == ?S
+      args[i], = [x].pack("I").unpack("i") if import[i] == ?I
+    end
+    ret, = @sym.call(*args)
+    return ret || 0
+  end
+
+  alias Call call
+end

data/ext/rubysl/dl/mkcall.rb

@@ -0,0 +1,69 @@
+# -*- ruby -*-
+
+require 'mkmf'
+$:.unshift File.dirname(__FILE__)
+require 'type'
+require 'dlconfig'
+
+if name = ARGV.shift
+  OUTPUT = File.open name, "wb"
+  at_exit { OUTPUT.close }
+else
+  OUTPUT = STDOUT
+end
+
+def output_arg(x,i)
+  "args[#{i}].#{DLTYPE[x][:stmem]}"
+end
+
+def output_args(types)
+  t = []
+  types[1..-1].each_with_index{|x,i| t.push(output_arg(x,i))}
+  t.join(",")
+end
+
+def output_callfunc(types)
+  t = types[0]
+  stmem = DLTYPE[t][:stmem]
+  ctypes = types2ctypes(types)
+  if( t == VOID )
+    callstm = "(*f)(#{output_args(types)})"
+  else
+    callstm = "ret.#{stmem} = (*f)(#{output_args(types)})"
+  end
+  [ "{",
+    "#{ctypes[0]} (*f)(#{ctypes[1..-1].join(',')}) = func;",
+    "#{callstm};",
+    "}"].join(" ")
+end
+
+def output_case(types)
+  num = types2num(types)
+  callfunc_stm = output_callfunc(types)
+<<EOF
+  case #{num}:
+#ifdef DEBUG
+    OUTPUT.printf("#{callfunc_stm}\\n");
+#endif
+    #{callfunc_stm};
+    break;
+EOF
+end
+
+def rec_output(types = [VOID])
+  OUTPUT.print output_case(types)
+  if( types.length <= MAX_ARG )
+    DLTYPE.keys.sort.each{|t|
+      if( t != VOID && DLTYPE[t][:sym] )
+	rec_output(types + [t])
+      end
+    }
+  end
+end
+
+DLTYPE.keys.sort.each{|t|
+  if( DLTYPE[t][:sym] )
+    $stderr.printf("  #{DLTYPE[t][:ctype]}\n")
+    rec_output([t])
+  end
+}