summaryrefslogtreecommitdiff
path: root/ext/dl/lib
diff options
context:
space:
mode:
authorttate <ttate@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2005-02-04 13:29:49 +0000
committerttate <ttate@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2005-02-04 13:29:49 +0000
commit4ae9132605dc7b0297bcda408ca7a2ad7de39d2f (patch)
tree6ab98b3252accf7357660e1668bf9e37883340bc /ext/dl/lib
parent889ca023e33ae35c259d02912187ac31be4f5362 (diff)
remove all files to replace ruby-dl with ruby-dl2.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@7882 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
Diffstat (limited to 'ext/dl/lib')
-rw-r--r--ext/dl/lib/dl/import.rb224
-rw-r--r--ext/dl/lib/dl/struct.rb149
-rw-r--r--ext/dl/lib/dl/types.rb245
-rw-r--r--ext/dl/lib/dl/win32.rb25
4 files changed, 0 insertions, 643 deletions
diff --git a/ext/dl/lib/dl/import.rb b/ext/dl/lib/dl/import.rb
deleted file mode 100644
index 2a98ace8ab..0000000000
--- a/ext/dl/lib/dl/import.rb
+++ /dev/null
@@ -1,224 +0,0 @@
-# -*- 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
- 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",
- " @retval",
- "}",
- ].join("\n"))
-
- @SYM[func] = [sym,rdec,enc,dec]
-
- return sym
- end
-
- # example:
- # typealias("uint", "unsigned int")
- #
- def typealias(*args)
- init_types()
- @types.typealias(*args)
- 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 @retval",
- "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
diff --git a/ext/dl/lib/dl/struct.rb b/ext/dl/lib/dl/struct.rb
deleted file mode 100644
index 33f303fe22..0000000000
--- a/ext/dl/lib/dl/struct.rb
+++ /dev/null
@@ -1,149 +0,0 @@
-# -*- 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
diff --git a/ext/dl/lib/dl/types.rb b/ext/dl/lib/dl/types.rb
deleted file mode 100644
index 1144917dae..0000000000
--- a/ext/dl/lib/dl/types.rb
+++ /dev/null
@@ -1,245 +0,0 @@
-# -*- 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
diff --git a/ext/dl/lib/dl/win32.rb b/ext/dl/lib/dl/win32.rb
deleted file mode 100644
index 92f473d392..0000000000
--- a/ext/dl/lib/dl/win32.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# -*- ruby -*-
-
-require 'dl'
-
-class Win32API
- DLL = {}
-
- def initialize(dllname, func, import, export = "0")
- prototype = (export + import.to_s).tr("VPpNnLlIi", "0SSI")
- 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