mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
* ext/fiddle/fiddle.c: adding alignment constants for compatibility
with DL. * ext/fiddle/fiddle.h: ditto * ext/fiddle/lib/fiddle/cparser.rb: importing the C parser for DL backwards compatibility. * ext/fiddle/lib/fiddle/import.rb: importing the import DSL for DL backwards compatibility. * ext/fiddle/lib/fiddle/pack.rb: importing structure pack for DL backwards compatibility. * ext/fiddle/lib/fiddle/value.rb: ditto * ext/fiddle/lib/fiddle/struct.rb: importing struct DSL for DL backwards compatibility. * test/dl/test_c_struct_entry.rb: importing tests * test/dl/test_c_union_entity.rb: ditto * test/dl/test_cparser.rb: ditto * test/dl/test_import.rb: ditto * test/fiddle/test_c_struct_entry.rb: ditto * test/fiddle/test_c_union_entity.rb: ditto * test/fiddle/test_cparser.rb: ditto * test/fiddle/test_import.rb: ditto git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@37914 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
tenderlove
parent
118d9f43c8
commit
0713f89944
16 changed files with 1316 additions and 61 deletions
23
ChangeLog
23
ChangeLog
|
|
@ -1,3 +1,26 @@
|
|||
Wed Nov 28 09:00:34 2012 Aaron Patterson <aaron@tenderlovemaking.com>
|
||||
|
||||
* ext/fiddle/fiddle.c: adding alignment constants for compatibility
|
||||
with DL.
|
||||
* ext/fiddle/fiddle.h: ditto
|
||||
* ext/fiddle/lib/fiddle/cparser.rb: importing the C parser for DL
|
||||
backwards compatibility.
|
||||
* ext/fiddle/lib/fiddle/import.rb: importing the import DSL for DL
|
||||
backwards compatibility.
|
||||
* ext/fiddle/lib/fiddle/pack.rb: importing structure pack for DL
|
||||
backwards compatibility.
|
||||
* ext/fiddle/lib/fiddle/value.rb: ditto
|
||||
* ext/fiddle/lib/fiddle/struct.rb: importing struct DSL for DL backwards
|
||||
compatibility.
|
||||
* test/dl/test_c_struct_entry.rb: importing tests
|
||||
* test/dl/test_c_union_entity.rb: ditto
|
||||
* test/dl/test_cparser.rb: ditto
|
||||
* test/dl/test_import.rb: ditto
|
||||
* test/fiddle/test_c_struct_entry.rb: ditto
|
||||
* test/fiddle/test_c_union_entity.rb: ditto
|
||||
* test/fiddle/test_cparser.rb: ditto
|
||||
* test/fiddle/test_import.rb: ditto
|
||||
|
||||
Wed Nov 28 08:56:00 2012 Zachary Scott <zachary@zacharyscott.net>
|
||||
|
||||
* doc/globals.rdoc: Add documentation file for magic globals
|
||||
|
|
|
|||
|
|
@ -260,6 +260,86 @@ Init_fiddle(void)
|
|||
*/
|
||||
rb_define_const(mFiddle, "TYPE_UINTPTR_T", INT2NUM(TYPE_UINTPTR_T));
|
||||
|
||||
/* Document-const: ALIGN_VOIDP
|
||||
*
|
||||
* The alignment size of a void*
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_VOIDP", INT2NUM(ALIGN_VOIDP));
|
||||
|
||||
/* Document-const: ALIGN_CHAR
|
||||
*
|
||||
* The alignment size of a char
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_CHAR", INT2NUM(ALIGN_CHAR));
|
||||
|
||||
/* Document-const: ALIGN_SHORT
|
||||
*
|
||||
* The alignment size of a short
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_SHORT", INT2NUM(ALIGN_SHORT));
|
||||
|
||||
/* Document-const: ALIGN_INT
|
||||
*
|
||||
* The alignment size of an int
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_INT", INT2NUM(ALIGN_INT));
|
||||
|
||||
/* Document-const: ALIGN_LONG
|
||||
*
|
||||
* The alignment size of a long
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_LONG", INT2NUM(ALIGN_LONG));
|
||||
|
||||
#if HAVE_LONG_LONG
|
||||
/* Document-const: ALIGN_LONG_LONG
|
||||
*
|
||||
* The alignment size of a long long
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_LONG_LONG", INT2NUM(ALIGN_LONG_LONG));
|
||||
#endif
|
||||
|
||||
/* Document-const: ALIGN_FLOAT
|
||||
*
|
||||
* The alignment size of a float
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_FLOAT", INT2NUM(ALIGN_FLOAT));
|
||||
|
||||
/* Document-const: ALIGN_DOUBLE
|
||||
*
|
||||
* The alignment size of a double
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_DOUBLE",INT2NUM(ALIGN_DOUBLE));
|
||||
|
||||
/* Document-const: ALIGN_SIZE_T
|
||||
*
|
||||
* The alignment size of a size_t
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_SIZE_T", INT2NUM(ALIGN_OF(size_t)));
|
||||
|
||||
/* Document-const: ALIGN_SSIZE_T
|
||||
*
|
||||
* The alignment size of a ssize_t
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_SSIZE_T", INT2NUM(ALIGN_OF(size_t))); /* same as size_t */
|
||||
|
||||
/* Document-const: ALIGN_PTRDIFF_T
|
||||
*
|
||||
* The alignment size of a ptrdiff_t
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_PTRDIFF_T", INT2NUM(ALIGN_OF(ptrdiff_t)));
|
||||
|
||||
/* Document-const: ALIGN_INTPTR_T
|
||||
*
|
||||
* The alignment size of a intptr_t
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_INTPTR_T", INT2NUM(ALIGN_OF(intptr_t)));
|
||||
|
||||
/* Document-const: ALIGN_UINTPTR_T
|
||||
*
|
||||
* The alignment size of a uintptr_t
|
||||
*/
|
||||
rb_define_const(mFiddle, "ALIGN_UINTPTR_T", INT2NUM(ALIGN_OF(uintptr_t)));
|
||||
|
||||
/* Document-const: WINDOWS
|
||||
*
|
||||
* Returns a boolean regarding whether the host is WIN32
|
||||
|
|
@ -356,6 +436,14 @@ Init_fiddle(void)
|
|||
*/
|
||||
rb_define_const(mFiddle, "RUBY_FREE", PTR2NUM(ruby_xfree));
|
||||
|
||||
/* Document-const: BUILD_RUBY_PLATFORM
|
||||
*
|
||||
* Platform built against (i.e. "x86_64-linux", etc.)
|
||||
*
|
||||
* See also RUBY_PLATFORM
|
||||
*/
|
||||
rb_define_const(mFiddle, "BUILD_RUBY_PLATFORM", rb_str_new2(RUBY_PLATFORM));
|
||||
|
||||
rb_define_module_function(mFiddle, "dlwrap", rb_fiddle_value2ptr, 1);
|
||||
rb_define_module_function(mFiddle, "dlunwrap", rb_fiddle_ptr2value, 1);
|
||||
rb_define_module_function(mFiddle, "malloc", rb_fiddle_malloc, 1);
|
||||
|
|
|
|||
|
|
@ -121,6 +121,19 @@
|
|||
#define TYPE_FLOAT 7
|
||||
#define TYPE_DOUBLE 8
|
||||
|
||||
#define ALIGN_OF(type) offsetof(struct {char align_c; type align_x;}, align_x)
|
||||
|
||||
#define ALIGN_VOIDP ALIGN_OF(void*)
|
||||
#define ALIGN_SHORT ALIGN_OF(short)
|
||||
#define ALIGN_CHAR ALIGN_OF(char)
|
||||
#define ALIGN_INT ALIGN_OF(int)
|
||||
#define ALIGN_LONG ALIGN_OF(long)
|
||||
#if HAVE_LONG_LONG
|
||||
#define ALIGN_LONG_LONG ALIGN_OF(LONG_LONG)
|
||||
#endif
|
||||
#define ALIGN_FLOAT ALIGN_OF(float)
|
||||
#define ALIGN_DOUBLE ALIGN_OF(double)
|
||||
|
||||
extern VALUE mFiddle;
|
||||
extern VALUE rb_eFiddleError;
|
||||
|
||||
|
|
|
|||
156
ext/fiddle/lib/fiddle/cparser.rb
Normal file
156
ext/fiddle/lib/fiddle/cparser.rb
Normal file
|
|
@ -0,0 +1,156 @@
|
|||
module Fiddle
|
||||
# Methods for parsing C struct and C prototype signatures.
|
||||
module CParser
|
||||
# Parses a C struct's members
|
||||
#
|
||||
# Example:
|
||||
#
|
||||
# parse_struct_signature(['int i', 'char c'])
|
||||
# => [[Fiddle::TYPE_INT, Fiddle::TYPE_CHAR], ["i", "c"]]
|
||||
#
|
||||
def parse_struct_signature(signature, tymap=nil)
|
||||
if( signature.is_a?(String) )
|
||||
signature = signature.split(/\s*,\s*/)
|
||||
end
|
||||
mems = []
|
||||
tys = []
|
||||
signature.each{|msig|
|
||||
tks = msig.split(/\s+(\*)?/)
|
||||
ty = tks[0..-2].join(" ")
|
||||
member = tks[-1]
|
||||
|
||||
case ty
|
||||
when /\[(\d+)\]/
|
||||
n = $1.to_i
|
||||
ty.gsub!(/\s*\[\d+\]/,"")
|
||||
ty = [ty, n]
|
||||
when /\[\]/
|
||||
ty.gsub!(/\s*\[\]/, "*")
|
||||
end
|
||||
|
||||
case member
|
||||
when /\[(\d+)\]/
|
||||
ty = [ty, $1.to_i]
|
||||
member.gsub!(/\s*\[\d+\]/,"")
|
||||
when /\[\]/
|
||||
ty = ty + "*"
|
||||
member.gsub!(/\s*\[\]/, "")
|
||||
end
|
||||
|
||||
mems.push(member)
|
||||
tys.push(parse_ctype(ty,tymap))
|
||||
}
|
||||
return tys, mems
|
||||
end
|
||||
|
||||
# Parses a C prototype signature
|
||||
#
|
||||
# Example:
|
||||
#
|
||||
# include Fiddle::CParser
|
||||
# => Object
|
||||
#
|
||||
# parse_signature('double sum(double, double)')
|
||||
# => ["sum", Fiddle::TYPE_DOUBLE, [Fiddle::TYPE_DOUBLE, Fiddle::TYPE_DOUBLE]]
|
||||
#
|
||||
def parse_signature(signature, tymap=nil)
|
||||
tymap ||= {}
|
||||
signature = signature.gsub(/\s+/, " ").strip
|
||||
case signature
|
||||
when /^([\w@\*\s]+)\(([\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, parse_ctype(ret, tymap), args.collect{|arg| parse_ctype(arg, tymap)}]
|
||||
else
|
||||
raise(RuntimeError,"can't parse the function prototype: #{signature}")
|
||||
end
|
||||
end
|
||||
|
||||
# Given a String of C type +ty+, return the corresponding DL constant.
|
||||
#
|
||||
# +ty+ can also accept an Array of C type Strings, and will returned in a
|
||||
# corresponding Array.
|
||||
#
|
||||
# If Hash +tymap+ is provided, +ty+ is expected to be the key, and the
|
||||
# value will be the C type to be looked up.
|
||||
#
|
||||
# Example:
|
||||
#
|
||||
# parse_ctype('int')
|
||||
# => Fiddle::TYPE_INT
|
||||
#
|
||||
# parse_ctype('double')
|
||||
# => Fiddle::TYPE_DOUBLE
|
||||
#
|
||||
# parse_ctype('unsigned char')
|
||||
# => -Fiddle::TYPE_CHAR
|
||||
#
|
||||
def parse_ctype(ty, tymap=nil)
|
||||
tymap ||= {}
|
||||
case ty
|
||||
when Array
|
||||
return [parse_ctype(ty[0], tymap), ty[1]]
|
||||
when "void"
|
||||
return TYPE_VOID
|
||||
when "char"
|
||||
return TYPE_CHAR
|
||||
when "unsigned char"
|
||||
return -TYPE_CHAR
|
||||
when "short"
|
||||
return TYPE_SHORT
|
||||
when "unsigned short"
|
||||
return -TYPE_SHORT
|
||||
when "int"
|
||||
return TYPE_INT
|
||||
when "unsigned int", 'uint'
|
||||
return -TYPE_INT
|
||||
when "long"
|
||||
return TYPE_LONG
|
||||
when "unsigned long"
|
||||
return -TYPE_LONG
|
||||
when "long long"
|
||||
if( defined?(TYPE_LONG_LONG) )
|
||||
return TYPE_LONG_LONG
|
||||
else
|
||||
raise(RuntimeError, "unsupported type: #{ty}")
|
||||
end
|
||||
when "unsigned long long"
|
||||
if( defined?(TYPE_LONG_LONG) )
|
||||
return -TYPE_LONG_LONG
|
||||
else
|
||||
raise(RuntimeError, "unsupported type: #{ty}")
|
||||
end
|
||||
when "float"
|
||||
return TYPE_FLOAT
|
||||
when "double"
|
||||
return TYPE_DOUBLE
|
||||
when "size_t"
|
||||
return TYPE_SIZE_T
|
||||
when "ssize_t"
|
||||
return TYPE_SSIZE_T
|
||||
when "ptrdiff_t"
|
||||
return TYPE_PTRDIFF_T
|
||||
when "intptr_t"
|
||||
return TYPE_INTPTR_T
|
||||
when "uintptr_t"
|
||||
return TYPE_UINTPTR_T
|
||||
when /\*/, /\[\s*\]/
|
||||
return TYPE_VOIDP
|
||||
else
|
||||
if( tymap[ty] )
|
||||
return parse_ctype(tymap[ty], tymap)
|
||||
else
|
||||
raise(DLError, "unknown type: #{ty}")
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
241
ext/fiddle/lib/fiddle/import.rb
Normal file
241
ext/fiddle/lib/fiddle/import.rb
Normal file
|
|
@ -0,0 +1,241 @@
|
|||
require 'fiddle'
|
||||
require 'fiddle/struct'
|
||||
require 'fiddle/cparser'
|
||||
|
||||
module Fiddle
|
||||
class CompositeHandler
|
||||
def initialize(handlers)
|
||||
@handlers = handlers
|
||||
end
|
||||
|
||||
def handlers()
|
||||
@handlers
|
||||
end
|
||||
|
||||
def sym(symbol)
|
||||
@handlers.each{|handle|
|
||||
if( handle )
|
||||
begin
|
||||
addr = handle.sym(symbol)
|
||||
return addr
|
||||
rescue DLError
|
||||
end
|
||||
end
|
||||
}
|
||||
return nil
|
||||
end
|
||||
|
||||
def [](symbol)
|
||||
sym(symbol)
|
||||
end
|
||||
end
|
||||
|
||||
# DL::Importer includes the means to dynamically load libraries and build
|
||||
# modules around them including calling extern functions within the C
|
||||
# library that has been loaded.
|
||||
#
|
||||
# == Example
|
||||
#
|
||||
# require 'dl'
|
||||
# require 'dl/import'
|
||||
#
|
||||
# module LibSum
|
||||
# extend DL::Importer
|
||||
# dlload './libsum.so'
|
||||
# extern 'double sum(double*, int)'
|
||||
# extern 'double split(double)'
|
||||
# end
|
||||
#
|
||||
module Importer
|
||||
include Fiddle
|
||||
include CParser
|
||||
extend Importer
|
||||
|
||||
def dlload(*libs)
|
||||
handles = libs.collect{|lib|
|
||||
case lib
|
||||
when nil
|
||||
nil
|
||||
when Handle
|
||||
lib
|
||||
when Importer
|
||||
lib.handlers
|
||||
else
|
||||
begin
|
||||
Fiddle.dlopen(lib)
|
||||
rescue DLError
|
||||
raise(DLError, "can't load #{lib}")
|
||||
end
|
||||
end
|
||||
}.flatten()
|
||||
@handler = CompositeHandler.new(handles)
|
||||
@func_map = {}
|
||||
@type_alias = {}
|
||||
end
|
||||
|
||||
def typealias(alias_type, orig_type)
|
||||
@type_alias[alias_type] = orig_type
|
||||
end
|
||||
|
||||
def sizeof(ty)
|
||||
case ty
|
||||
when String
|
||||
ty = parse_ctype(ty, @type_alias).abs()
|
||||
case ty
|
||||
when TYPE_CHAR
|
||||
return SIZEOF_CHAR
|
||||
when TYPE_SHORT
|
||||
return SIZEOF_SHORT
|
||||
when TYPE_INT
|
||||
return SIZEOF_INT
|
||||
when TYPE_LONG
|
||||
return SIZEOF_LONG
|
||||
when TYPE_LONG_LONG
|
||||
return SIZEOF_LONG_LON
|
||||
when TYPE_FLOAT
|
||||
return SIZEOF_FLOAT
|
||||
when TYPE_DOUBLE
|
||||
return SIZEOF_DOUBLE
|
||||
when TYPE_VOIDP
|
||||
return SIZEOF_VOIDP
|
||||
else
|
||||
raise(DLError, "unknown type: #{ty}")
|
||||
end
|
||||
when Class
|
||||
if( ty.instance_methods().include?(:to_ptr) )
|
||||
return ty.size()
|
||||
end
|
||||
end
|
||||
return CPtr[ty].size()
|
||||
end
|
||||
|
||||
def parse_bind_options(opts)
|
||||
h = {}
|
||||
while( opt = opts.shift() )
|
||||
case opt
|
||||
when :stdcall, :cdecl
|
||||
h[:call_type] = opt
|
||||
when :carried, :temp, :temporal, :bind
|
||||
h[:callback_type] = opt
|
||||
h[:carrier] = opts.shift()
|
||||
else
|
||||
h[opt] = true
|
||||
end
|
||||
end
|
||||
h
|
||||
end
|
||||
private :parse_bind_options
|
||||
|
||||
def extern(signature, *opts)
|
||||
symname, ctype, argtype = parse_signature(signature, @type_alias)
|
||||
opt = parse_bind_options(opts)
|
||||
f = import_function(symname, ctype, argtype, opt[:call_type])
|
||||
name = symname.gsub(/@.+/,'')
|
||||
@func_map[name] = f
|
||||
# define_method(name){|*args,&block| f.call(*args,&block)}
|
||||
begin
|
||||
/^(.+?):(\d+)/ =~ caller.first
|
||||
file, line = $1, $2.to_i
|
||||
rescue
|
||||
file, line = __FILE__, __LINE__+3
|
||||
end
|
||||
module_eval(<<-EOS, file, line)
|
||||
def #{name}(*args, &block)
|
||||
@func_map['#{name}'].call(*args,&block)
|
||||
end
|
||||
EOS
|
||||
module_function(name)
|
||||
f
|
||||
end
|
||||
|
||||
def bind(signature, *opts, &blk)
|
||||
name, ctype, argtype = parse_signature(signature, @type_alias)
|
||||
h = parse_bind_options(opts)
|
||||
case h[:callback_type]
|
||||
when :bind, nil
|
||||
f = bind_function(name, ctype, argtype, h[:call_type], &blk)
|
||||
else
|
||||
raise(RuntimeError, "unknown callback type: #{h[:callback_type]}")
|
||||
end
|
||||
@func_map[name] = f
|
||||
#define_method(name){|*args,&block| f.call(*args,&block)}
|
||||
begin
|
||||
/^(.+?):(\d+)/ =~ caller.first
|
||||
file, line = $1, $2.to_i
|
||||
rescue
|
||||
file, line = __FILE__, __LINE__+3
|
||||
end
|
||||
module_eval(<<-EOS, file, line)
|
||||
def #{name}(*args,&block)
|
||||
@func_map['#{name}'].call(*args,&block)
|
||||
end
|
||||
EOS
|
||||
module_function(name)
|
||||
f
|
||||
end
|
||||
|
||||
# Creates a class to wrap the C struct described by +signature+.
|
||||
#
|
||||
# MyStruct = struct ['int i', 'char c']
|
||||
def struct(signature)
|
||||
tys, mems = parse_struct_signature(signature, @type_alias)
|
||||
Fiddle::CStructBuilder.create(CStruct, tys, mems)
|
||||
end
|
||||
|
||||
# Creates a class to wrap the C union described by +signature+.
|
||||
#
|
||||
# MyUnion = union ['int i', 'char c']
|
||||
def union(signature)
|
||||
tys, mems = parse_struct_signature(signature, @type_alias)
|
||||
Fiddle::CStructBuilder.create(CUnion, tys, mems)
|
||||
end
|
||||
|
||||
def [](name)
|
||||
@func_map[name]
|
||||
end
|
||||
|
||||
def create_value(ty, val=nil)
|
||||
s = struct([ty + " value"])
|
||||
ptr = s.malloc()
|
||||
if( val )
|
||||
ptr.value = val
|
||||
end
|
||||
return ptr
|
||||
end
|
||||
alias value create_value
|
||||
|
||||
def import_value(ty, addr)
|
||||
s = struct([ty + " value"])
|
||||
ptr = s.new(addr)
|
||||
return ptr
|
||||
end
|
||||
|
||||
def handler
|
||||
@handler or raise "call dlload before importing symbols and functions"
|
||||
end
|
||||
|
||||
def import_symbol(name)
|
||||
addr = handler.sym(name)
|
||||
if( !addr )
|
||||
raise(DLError, "cannot find the symbol: #{name}")
|
||||
end
|
||||
Pointer.new(addr)
|
||||
end
|
||||
|
||||
def import_function(name, ctype, argtype, call_type = nil)
|
||||
addr = handler.sym(name)
|
||||
if( !addr )
|
||||
raise(DLError, "cannot find the function: #{name}()")
|
||||
end
|
||||
Function.new(addr, argtype, ctype, call_type)
|
||||
end
|
||||
|
||||
def bind_function(name, ctype, argtype, call_type = nil, &block)
|
||||
closure = Class.new(Fiddle::Closure) {
|
||||
define_method(:call, block)
|
||||
}.new(ctype, argtype)
|
||||
|
||||
Function.new(closure, argtype, ctype)
|
||||
end
|
||||
end
|
||||
end
|
||||
128
ext/fiddle/lib/fiddle/pack.rb
Normal file
128
ext/fiddle/lib/fiddle/pack.rb
Normal file
|
|
@ -0,0 +1,128 @@
|
|||
require 'fiddle'
|
||||
|
||||
module Fiddle
|
||||
module PackInfo
|
||||
ALIGN_MAP = {
|
||||
TYPE_VOIDP => ALIGN_VOIDP,
|
||||
TYPE_CHAR => ALIGN_CHAR,
|
||||
TYPE_SHORT => ALIGN_SHORT,
|
||||
TYPE_INT => ALIGN_INT,
|
||||
TYPE_LONG => ALIGN_LONG,
|
||||
TYPE_FLOAT => ALIGN_FLOAT,
|
||||
TYPE_DOUBLE => ALIGN_DOUBLE,
|
||||
-TYPE_CHAR => ALIGN_CHAR,
|
||||
-TYPE_SHORT => ALIGN_SHORT,
|
||||
-TYPE_INT => ALIGN_INT,
|
||||
-TYPE_LONG => ALIGN_LONG,
|
||||
}
|
||||
|
||||
PACK_MAP = {
|
||||
TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG) ? "q" : "l!"),
|
||||
TYPE_CHAR => "c",
|
||||
TYPE_SHORT => "s!",
|
||||
TYPE_INT => "i!",
|
||||
TYPE_LONG => "l!",
|
||||
TYPE_FLOAT => "f",
|
||||
TYPE_DOUBLE => "d",
|
||||
-TYPE_CHAR => "c",
|
||||
-TYPE_SHORT => "s!",
|
||||
-TYPE_INT => "i!",
|
||||
-TYPE_LONG => "l!",
|
||||
}
|
||||
|
||||
SIZE_MAP = {
|
||||
TYPE_VOIDP => SIZEOF_VOIDP,
|
||||
TYPE_CHAR => SIZEOF_CHAR,
|
||||
TYPE_SHORT => SIZEOF_SHORT,
|
||||
TYPE_INT => SIZEOF_INT,
|
||||
TYPE_LONG => SIZEOF_LONG,
|
||||
TYPE_FLOAT => SIZEOF_FLOAT,
|
||||
TYPE_DOUBLE => SIZEOF_DOUBLE,
|
||||
-TYPE_CHAR => SIZEOF_CHAR,
|
||||
-TYPE_SHORT => SIZEOF_SHORT,
|
||||
-TYPE_INT => SIZEOF_INT,
|
||||
-TYPE_LONG => SIZEOF_LONG,
|
||||
}
|
||||
if defined?(TYPE_LONG_LONG)
|
||||
ALIGN_MAP[TYPE_LONG_LONG] = ALIGN_MAP[-TYPE_LONG_LONG] = ALIGN_LONG_LONG
|
||||
PACK_MAP[TYPE_LONG_LONG] = PACK_MAP[-TYPE_LONG_LONG] = "q"
|
||||
SIZE_MAP[TYPE_LONG_LONG] = SIZE_MAP[-TYPE_LONG_LONG] = SIZEOF_LONG_LONG
|
||||
end
|
||||
|
||||
def align(addr, align)
|
||||
d = addr % align
|
||||
if( d == 0 )
|
||||
addr
|
||||
else
|
||||
addr + (align - d)
|
||||
end
|
||||
end
|
||||
module_function :align
|
||||
end
|
||||
|
||||
class Packer
|
||||
include PackInfo
|
||||
|
||||
def self.[](*types)
|
||||
new(types)
|
||||
end
|
||||
|
||||
def initialize(types)
|
||||
parse_types(types)
|
||||
end
|
||||
|
||||
def size()
|
||||
@size
|
||||
end
|
||||
|
||||
def pack(ary)
|
||||
case SIZEOF_VOIDP
|
||||
when SIZEOF_LONG
|
||||
ary.pack(@template)
|
||||
when SIZEOF_LONG_LONG
|
||||
ary.pack(@template)
|
||||
else
|
||||
raise(RuntimeError, "sizeof(void*)?")
|
||||
end
|
||||
end
|
||||
|
||||
def unpack(ary)
|
||||
case SIZEOF_VOIDP
|
||||
when SIZEOF_LONG
|
||||
ary.join().unpack(@template)
|
||||
when SIZEOF_LONG_LONG
|
||||
ary.join().unpack(@template)
|
||||
else
|
||||
raise(RuntimeError, "sizeof(void*)?")
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def parse_types(types)
|
||||
@template = ""
|
||||
addr = 0
|
||||
types.each{|t|
|
||||
orig_addr = addr
|
||||
if( t.is_a?(Array) )
|
||||
addr = align(orig_addr, ALIGN_MAP[TYPE_VOIDP])
|
||||
else
|
||||
addr = align(orig_addr, ALIGN_MAP[t])
|
||||
end
|
||||
d = addr - orig_addr
|
||||
if( d > 0 )
|
||||
@template << "x#{d}"
|
||||
end
|
||||
if( t.is_a?(Array) )
|
||||
@template << (PACK_MAP[t[0]] * t[1])
|
||||
addr += (SIZE_MAP[t[0]] * t[1])
|
||||
else
|
||||
@template << PACK_MAP[t]
|
||||
addr += SIZE_MAP[t]
|
||||
end
|
||||
}
|
||||
addr = align(addr, ALIGN_MAP[TYPE_VOIDP])
|
||||
@size = addr
|
||||
end
|
||||
end
|
||||
end
|
||||
236
ext/fiddle/lib/fiddle/struct.rb
Normal file
236
ext/fiddle/lib/fiddle/struct.rb
Normal file
|
|
@ -0,0 +1,236 @@
|
|||
require 'fiddle'
|
||||
require 'fiddle/value'
|
||||
require 'fiddle/pack'
|
||||
|
||||
module Fiddle
|
||||
# C struct shell
|
||||
class CStruct
|
||||
# accessor to Fiddle::CStructEntity
|
||||
def CStruct.entity_class
|
||||
CStructEntity
|
||||
end
|
||||
end
|
||||
|
||||
# C union shell
|
||||
class CUnion
|
||||
# accessor to Fiddle::CUnionEntity
|
||||
def CUnion.entity_class
|
||||
CUnionEntity
|
||||
end
|
||||
end
|
||||
|
||||
# Used to construct C classes (CUnion, CStruct, etc)
|
||||
#
|
||||
# Fiddle::Importer#struct and Fiddle::Importer#union wrap this functionality in an
|
||||
# easy-to-use manner.
|
||||
module CStructBuilder
|
||||
# Construct a new class given a C:
|
||||
# * class +klass+ (CUnion, CStruct, or other that provide an
|
||||
# #entity_class)
|
||||
# * +types+ (Fiddle::TYPE_INT, Fiddle::TYPE_SIZE_T, etc., see the C types
|
||||
# constants)
|
||||
# * corresponding +members+
|
||||
#
|
||||
# Fiddle::Importer#struct and Fiddle::Importer#union wrap this functionality in an
|
||||
# easy-to-use manner.
|
||||
#
|
||||
# Example:
|
||||
#
|
||||
# require 'dl/struct'
|
||||
# require 'dl/cparser'
|
||||
#
|
||||
# include Fiddle::CParser
|
||||
#
|
||||
# types, members = parse_struct_signature(['int i','char c'])
|
||||
#
|
||||
# MyStruct = Fiddle::CStructBuilder.create(CUnion, types, members)
|
||||
#
|
||||
# obj = MyStruct.allocate
|
||||
#
|
||||
def create(klass, types, members)
|
||||
new_class = Class.new(klass){
|
||||
define_method(:initialize){|addr|
|
||||
@entity = klass.entity_class.new(addr, types)
|
||||
@entity.assign_names(members)
|
||||
}
|
||||
define_method(:to_ptr){ @entity }
|
||||
define_method(:to_i){ @entity.to_i }
|
||||
members.each{|name|
|
||||
define_method(name){ @entity[name] }
|
||||
define_method(name + "="){|val| @entity[name] = val }
|
||||
}
|
||||
}
|
||||
size = klass.entity_class.size(types)
|
||||
new_class.module_eval(<<-EOS, __FILE__, __LINE__+1)
|
||||
def new_class.size()
|
||||
#{size}
|
||||
end
|
||||
def new_class.malloc()
|
||||
addr = Fiddle.malloc(#{size})
|
||||
new(addr)
|
||||
end
|
||||
EOS
|
||||
return new_class
|
||||
end
|
||||
module_function :create
|
||||
end
|
||||
|
||||
# A C struct wrapper
|
||||
class CStructEntity < Fiddle::Pointer
|
||||
include PackInfo
|
||||
include ValueUtil
|
||||
|
||||
# Allocates a C struct the +types+ provided. The C function +func+ is
|
||||
# called when the instance is garbage collected.
|
||||
def CStructEntity.malloc(types, func = nil)
|
||||
addr = Fiddle.malloc(CStructEntity.size(types))
|
||||
CStructEntity.new(addr, types, func)
|
||||
end
|
||||
|
||||
# Given +types+, returns the offset for the packed sizes of those types
|
||||
#
|
||||
# Fiddle::CStructEntity.size([Fiddle::TYPE_DOUBLE, Fiddle::TYPE_INT, Fiddle::TYPE_CHAR,
|
||||
# Fiddle::TYPE_VOIDP])
|
||||
# => 24
|
||||
def CStructEntity.size(types)
|
||||
offset = 0
|
||||
|
||||
max_align = types.map { |type, count = 1|
|
||||
last_offset = offset
|
||||
|
||||
align = PackInfo::ALIGN_MAP[type]
|
||||
offset = PackInfo.align(last_offset, align) +
|
||||
(PackInfo::SIZE_MAP[type] * count)
|
||||
|
||||
align
|
||||
}.max
|
||||
|
||||
PackInfo.align(offset, max_align)
|
||||
end
|
||||
|
||||
# Wraps the C pointer +addr+ as a C struct with the given +types+. The C
|
||||
# function +func+ is called when the instance is garbage collected.
|
||||
#
|
||||
# See also Fiddle::CPtr.new
|
||||
def initialize(addr, types, func = nil)
|
||||
set_ctypes(types)
|
||||
super(addr, @size, func)
|
||||
end
|
||||
|
||||
# Set the names of the +members+ in this C struct
|
||||
def assign_names(members)
|
||||
@members = members
|
||||
end
|
||||
|
||||
# Given +types+, calculate the offsets and sizes for the types in the
|
||||
# struct.
|
||||
def set_ctypes(types)
|
||||
@ctypes = types
|
||||
@offset = []
|
||||
offset = 0
|
||||
|
||||
max_align = types.map { |type, count = 1|
|
||||
orig_offset = offset
|
||||
align = ALIGN_MAP[type]
|
||||
offset = PackInfo.align(orig_offset, align)
|
||||
|
||||
@offset << offset
|
||||
|
||||
offset += (SIZE_MAP[type] * count)
|
||||
|
||||
align
|
||||
}.max
|
||||
|
||||
@size = PackInfo.align(offset, max_align)
|
||||
end
|
||||
|
||||
# Fetch struct member +name+
|
||||
def [](name)
|
||||
idx = @members.index(name)
|
||||
if( idx.nil? )
|
||||
raise(ArgumentError, "no such member: #{name}")
|
||||
end
|
||||
ty = @ctypes[idx]
|
||||
if( ty.is_a?(Array) )
|
||||
r = super(@offset[idx], SIZE_MAP[ty[0]] * ty[1])
|
||||
else
|
||||
r = super(@offset[idx], SIZE_MAP[ty.abs])
|
||||
end
|
||||
packer = Packer.new([ty])
|
||||
val = packer.unpack([r])
|
||||
case ty
|
||||
when Array
|
||||
case ty[0]
|
||||
when TYPE_VOIDP
|
||||
val = val.collect{|v| CPtr.new(v)}
|
||||
end
|
||||
when TYPE_VOIDP
|
||||
val = CPtr.new(val[0])
|
||||
else
|
||||
val = val[0]
|
||||
end
|
||||
if( ty.is_a?(Integer) && (ty < 0) )
|
||||
return unsigned_value(val, ty)
|
||||
elsif( ty.is_a?(Array) && (ty[0] < 0) )
|
||||
return val.collect{|v| unsigned_value(v,ty[0])}
|
||||
else
|
||||
return val
|
||||
end
|
||||
end
|
||||
|
||||
# Set struct member +name+, to value +val+
|
||||
def []=(name, val)
|
||||
idx = @members.index(name)
|
||||
if( idx.nil? )
|
||||
raise(ArgumentError, "no such member: #{name}")
|
||||
end
|
||||
ty = @ctypes[idx]
|
||||
packer = Packer.new([ty])
|
||||
val = wrap_arg(val, ty, [])
|
||||
buff = packer.pack([val].flatten())
|
||||
super(@offset[idx], buff.size, buff)
|
||||
if( ty.is_a?(Integer) && (ty < 0) )
|
||||
return unsigned_value(val, ty)
|
||||
elsif( ty.is_a?(Array) && (ty[0] < 0) )
|
||||
return val.collect{|v| unsigned_value(v,ty[0])}
|
||||
else
|
||||
return val
|
||||
end
|
||||
end
|
||||
|
||||
def to_s() # :nodoc:
|
||||
super(@size)
|
||||
end
|
||||
end
|
||||
|
||||
# A C union wrapper
|
||||
class CUnionEntity < CStructEntity
|
||||
include PackInfo
|
||||
|
||||
# Allocates a C union the +types+ provided. The C function +func+ is
|
||||
# called when the instance is garbage collected.
|
||||
def CUnionEntity.malloc(types, func=nil)
|
||||
addr = Fiddle.malloc(CUnionEntity.size(types))
|
||||
CUnionEntity.new(addr, types, func)
|
||||
end
|
||||
|
||||
# Given +types+, returns the size needed for the union.
|
||||
#
|
||||
# Fiddle::CUnionEntity.size([Fiddle::TYPE_DOUBLE, Fiddle::TYPE_INT, Fiddle::TYPE_CHAR,
|
||||
# Fiddle::TYPE_VOIDP])
|
||||
# => 8
|
||||
def CUnionEntity.size(types)
|
||||
types.map { |type, count = 1|
|
||||
PackInfo::SIZE_MAP[type] * count
|
||||
}.max
|
||||
end
|
||||
|
||||
# Given +types+, calculate the necessary offset and for each union member
|
||||
def set_ctypes(types)
|
||||
@ctypes = types
|
||||
@offset = Array.new(types.length, 0)
|
||||
@size = self.class.size types
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
114
ext/fiddle/lib/fiddle/value.rb
Normal file
114
ext/fiddle/lib/fiddle/value.rb
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
require 'fiddle'
|
||||
|
||||
module Fiddle
|
||||
module ValueUtil
|
||||
def unsigned_value(val, ty)
|
||||
case ty.abs
|
||||
when TYPE_CHAR
|
||||
[val].pack("c").unpack("C")[0]
|
||||
when TYPE_SHORT
|
||||
[val].pack("s!").unpack("S!")[0]
|
||||
when TYPE_INT
|
||||
[val].pack("i!").unpack("I!")[0]
|
||||
when TYPE_LONG
|
||||
[val].pack("l!").unpack("L!")[0]
|
||||
when TYPE_LONG_LONG
|
||||
[val].pack("q").unpack("Q")[0]
|
||||
else
|
||||
val
|
||||
end
|
||||
end
|
||||
|
||||
def signed_value(val, ty)
|
||||
case ty.abs
|
||||
when TYPE_CHAR
|
||||
[val].pack("C").unpack("c")[0]
|
||||
when TYPE_SHORT
|
||||
[val].pack("S!").unpack("s!")[0]
|
||||
when TYPE_INT
|
||||
[val].pack("I!").unpack("i!")[0]
|
||||
when TYPE_LONG
|
||||
[val].pack("L!").unpack("l!")[0]
|
||||
when TYPE_LONG_LONG
|
||||
[val].pack("Q").unpack("q")[0]
|
||||
else
|
||||
val
|
||||
end
|
||||
end
|
||||
|
||||
def wrap_args(args, tys, funcs, &block)
|
||||
result = []
|
||||
tys ||= []
|
||||
args.each_with_index{|arg, idx|
|
||||
result.push(wrap_arg(arg, tys[idx], funcs, &block))
|
||||
}
|
||||
result
|
||||
end
|
||||
|
||||
def wrap_arg(arg, ty, funcs = [], &block)
|
||||
require 'dl/func'
|
||||
|
||||
funcs ||= []
|
||||
case arg
|
||||
when nil
|
||||
return 0
|
||||
when Pointer
|
||||
return arg.to_i
|
||||
when IO
|
||||
case ty
|
||||
when TYPE_VOIDP
|
||||
return Pointer[arg].to_i
|
||||
else
|
||||
return arg.to_i
|
||||
end
|
||||
when Function
|
||||
if( block )
|
||||
arg.bind_at_call(&block)
|
||||
funcs.push(arg)
|
||||
elsif !arg.bound?
|
||||
raise(RuntimeError, "block must be given.")
|
||||
end
|
||||
return arg.to_i
|
||||
when String
|
||||
if( ty.is_a?(Array) )
|
||||
return arg.unpack('C*')
|
||||
else
|
||||
case SIZEOF_VOIDP
|
||||
when SIZEOF_LONG
|
||||
return [arg].pack("p").unpack("l!")[0]
|
||||
when SIZEOF_LONG_LONG
|
||||
return [arg].pack("p").unpack("q")[0]
|
||||
else
|
||||
raise(RuntimeError, "sizeof(void*)?")
|
||||
end
|
||||
end
|
||||
when Float, Integer
|
||||
return arg
|
||||
when Array
|
||||
if( ty.is_a?(Array) ) # used only by struct
|
||||
case ty[0]
|
||||
when TYPE_VOIDP
|
||||
return arg.collect{|v| Integer(v)}
|
||||
when TYPE_CHAR
|
||||
if( arg.is_a?(String) )
|
||||
return val.unpack('C*')
|
||||
end
|
||||
end
|
||||
return arg
|
||||
else
|
||||
return arg
|
||||
end
|
||||
else
|
||||
if( arg.respond_to?(:to_ptr) )
|
||||
return arg.to_ptr.to_i
|
||||
else
|
||||
begin
|
||||
return Integer(arg)
|
||||
rescue
|
||||
raise(ArgumentError, "unknown argument type: #{arg.class}")
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -2,52 +2,53 @@ require_relative 'test_base'
|
|||
|
||||
require 'dl/struct'
|
||||
|
||||
class DL::TestCStructEntity < DL::TestBase
|
||||
def test_class_size
|
||||
types = [DL::TYPE_DOUBLE, DL::TYPE_CHAR]
|
||||
module DL
|
||||
class TestCStructEntity < TestBase
|
||||
def test_class_size
|
||||
types = [TYPE_DOUBLE, TYPE_CHAR]
|
||||
|
||||
size = DL::CStructEntity.size types
|
||||
size = CStructEntity.size types
|
||||
|
||||
alignments = types.map { |type| DL::PackInfo::ALIGN_MAP[type] }
|
||||
alignments = types.map { |type| PackInfo::ALIGN_MAP[type] }
|
||||
|
||||
expected = DL::PackInfo.align 0, alignments[0]
|
||||
expected += DL::PackInfo::SIZE_MAP[DL::TYPE_DOUBLE]
|
||||
expected = PackInfo.align 0, alignments[0]
|
||||
expected += PackInfo::SIZE_MAP[TYPE_DOUBLE]
|
||||
|
||||
expected = DL::PackInfo.align expected, alignments[1]
|
||||
expected += DL::PackInfo::SIZE_MAP[DL::TYPE_CHAR]
|
||||
expected = PackInfo.align expected, alignments[1]
|
||||
expected += PackInfo::SIZE_MAP[TYPE_CHAR]
|
||||
|
||||
expected = DL::PackInfo.align expected, alignments.max
|
||||
expected = PackInfo.align expected, alignments.max
|
||||
|
||||
assert_equal expected, size
|
||||
end
|
||||
assert_equal expected, size
|
||||
end
|
||||
|
||||
def test_class_size_with_count
|
||||
size = DL::CStructEntity.size([[DL::TYPE_DOUBLE, 2], [DL::TYPE_CHAR, 20]])
|
||||
def test_class_size_with_count
|
||||
size = CStructEntity.size([[TYPE_DOUBLE, 2], [TYPE_CHAR, 20]])
|
||||
|
||||
types = [DL::TYPE_DOUBLE, DL::TYPE_CHAR]
|
||||
alignments = types.map { |type| DL::PackInfo::ALIGN_MAP[type] }
|
||||
types = [TYPE_DOUBLE, TYPE_CHAR]
|
||||
alignments = types.map { |type| PackInfo::ALIGN_MAP[type] }
|
||||
|
||||
expected = DL::PackInfo.align 0, alignments[0]
|
||||
expected += DL::PackInfo::SIZE_MAP[DL::TYPE_DOUBLE] * 2
|
||||
expected = PackInfo.align 0, alignments[0]
|
||||
expected += PackInfo::SIZE_MAP[TYPE_DOUBLE] * 2
|
||||
|
||||
expected = DL::PackInfo.align expected, alignments[1]
|
||||
expected += DL::PackInfo::SIZE_MAP[DL::TYPE_CHAR] * 20
|
||||
expected = PackInfo.align expected, alignments[1]
|
||||
expected += PackInfo::SIZE_MAP[TYPE_CHAR] * 20
|
||||
|
||||
expected = DL::PackInfo.align expected, alignments.max
|
||||
expected = PackInfo.align expected, alignments.max
|
||||
|
||||
assert_equal expected, size
|
||||
end
|
||||
assert_equal expected, size
|
||||
end
|
||||
|
||||
def test_set_ctypes
|
||||
union = DL::CStructEntity.malloc [DL::TYPE_INT, DL::TYPE_LONG]
|
||||
union.assign_names %w[int long]
|
||||
def test_set_ctypes
|
||||
union = CStructEntity.malloc [TYPE_INT, TYPE_LONG]
|
||||
union.assign_names %w[int long]
|
||||
|
||||
# this test is roundabout because the stored ctypes are not accessible
|
||||
union['long'] = 1
|
||||
union['int'] = 2
|
||||
# this test is roundabout because the stored ctypes are not accessible
|
||||
union['long'] = 1
|
||||
union['int'] = 2
|
||||
|
||||
assert_equal 1, union['long']
|
||||
assert_equal 2, union['int']
|
||||
assert_equal 1, union['long']
|
||||
assert_equal 2, union['int']
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
|
|
|||
|
|
@ -2,29 +2,30 @@ require_relative 'test_base'
|
|||
|
||||
require 'dl/struct'
|
||||
|
||||
class DL::TestCUnionEntity < DL::TestBase
|
||||
def test_class_size
|
||||
size = DL::CUnionEntity.size([DL::TYPE_DOUBLE, DL::TYPE_CHAR])
|
||||
module DL
|
||||
class TestCUnionEntity < TestBase
|
||||
def test_class_size
|
||||
size = CUnionEntity.size([TYPE_DOUBLE, TYPE_CHAR])
|
||||
|
||||
assert_equal DL::SIZEOF_DOUBLE, size
|
||||
end
|
||||
assert_equal SIZEOF_DOUBLE, size
|
||||
end
|
||||
|
||||
def test_class_size_with_count
|
||||
size = DL::CUnionEntity.size([[DL::TYPE_DOUBLE, 2], [DL::TYPE_CHAR, 20]])
|
||||
def test_class_size_with_count
|
||||
size = CUnionEntity.size([[TYPE_DOUBLE, 2], [TYPE_CHAR, 20]])
|
||||
|
||||
assert_equal DL::SIZEOF_CHAR * 20, size
|
||||
end
|
||||
assert_equal SIZEOF_CHAR * 20, size
|
||||
end
|
||||
|
||||
def test_set_ctypes
|
||||
union = DL::CUnionEntity.malloc [DL::TYPE_INT, DL::TYPE_LONG]
|
||||
union.assign_names %w[int long]
|
||||
def test_set_ctypes
|
||||
union = CUnionEntity.malloc [TYPE_INT, TYPE_LONG]
|
||||
union.assign_names %w[int long]
|
||||
|
||||
# this test is roundabout because the stored ctypes are not accessible
|
||||
union['long'] = 1
|
||||
assert_equal 1, union['long']
|
||||
# this test is roundabout because the stored ctypes are not accessible
|
||||
union['long'] = 1
|
||||
assert_equal 1, union['long']
|
||||
|
||||
union['int'] = 1
|
||||
assert_equal 1, union['int']
|
||||
union['int'] = 1
|
||||
assert_equal 1, union['int']
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
|
|
|||
|
|
@ -4,30 +4,30 @@ require 'dl/cparser'
|
|||
|
||||
module DL
|
||||
class TestCParser < TestBase
|
||||
include DL::CParser
|
||||
include CParser
|
||||
|
||||
def test_uint_ctype
|
||||
assert_equal(-DL::TYPE_INT, parse_ctype('uint'))
|
||||
assert_equal(-TYPE_INT, parse_ctype('uint'))
|
||||
end
|
||||
|
||||
def test_size_t_ctype
|
||||
assert_equal(DL::TYPE_SIZE_T, parse_ctype("size_t"))
|
||||
assert_equal(TYPE_SIZE_T, parse_ctype("size_t"))
|
||||
end
|
||||
|
||||
def test_ssize_t_ctype
|
||||
assert_equal(DL::TYPE_SSIZE_T, parse_ctype("ssize_t"))
|
||||
assert_equal(TYPE_SSIZE_T, parse_ctype("ssize_t"))
|
||||
end
|
||||
|
||||
def test_ptrdiff_t_ctype
|
||||
assert_equal(DL::TYPE_PTRDIFF_T, parse_ctype("ptrdiff_t"))
|
||||
assert_equal(TYPE_PTRDIFF_T, parse_ctype("ptrdiff_t"))
|
||||
end
|
||||
|
||||
def test_intptr_t_ctype
|
||||
assert_equal(DL::TYPE_INTPTR_T, parse_ctype("intptr_t"))
|
||||
assert_equal(TYPE_INTPTR_T, parse_ctype("intptr_t"))
|
||||
end
|
||||
|
||||
def test_uintptr_t_ctype
|
||||
assert_equal(DL::TYPE_UINTPTR_T, parse_ctype("uintptr_t"))
|
||||
assert_equal(TYPE_UINTPTR_T, parse_ctype("uintptr_t"))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ module DL
|
|||
]
|
||||
|
||||
CallCallback = bind("void call_callback(void*, void*)"){|ptr1, ptr2|
|
||||
f = Function.new(CFunc.new(ptr1.to_i, DL::TYPE_VOID, "<anonymous>"), [TYPE_VOIDP])
|
||||
f = Function.new(CFunc.new(ptr1.to_i, TYPE_VOID, "<anonymous>"), [TYPE_VOIDP])
|
||||
f.call(ptr2)
|
||||
}
|
||||
CarriedFunction = bind("void callback_function(void*)", :carried, 0)
|
||||
|
|
@ -45,7 +45,7 @@ module DL
|
|||
def test_ensure_call_dlload
|
||||
err = assert_raises(RuntimeError) do
|
||||
Class.new do
|
||||
extend DL::Importer
|
||||
extend Importer
|
||||
extern "void *strcpy(char*, char*)"
|
||||
end
|
||||
end
|
||||
|
|
@ -59,7 +59,7 @@ module DL
|
|||
end
|
||||
|
||||
def test_sizeof()
|
||||
assert_equal(DL::SIZEOF_VOIDP, LIBC.sizeof("FILE*"))
|
||||
assert_equal(SIZEOF_VOIDP, LIBC.sizeof("FILE*"))
|
||||
assert_equal(LIBC::MyStruct.size(), LIBC.sizeof(LIBC::MyStruct))
|
||||
end
|
||||
|
||||
|
|
@ -71,7 +71,7 @@ module DL
|
|||
end
|
||||
|
||||
def test_io()
|
||||
if( RUBY_PLATFORM != DL::BUILD_RUBY_PLATFORM )
|
||||
if( RUBY_PLATFORM != BUILD_RUBY_PLATFORM )
|
||||
return
|
||||
end
|
||||
io_in,io_out = IO.pipe()
|
||||
|
|
|
|||
54
test/fiddle/test_c_struct_entry.rb
Normal file
54
test/fiddle/test_c_struct_entry.rb
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
require_relative 'helper'
|
||||
|
||||
require 'fiddle/struct'
|
||||
|
||||
module Fiddle
|
||||
class TestCStructEntity < TestCase
|
||||
def test_class_size
|
||||
types = [TYPE_DOUBLE, TYPE_CHAR]
|
||||
|
||||
size = CStructEntity.size types
|
||||
|
||||
alignments = types.map { |type| PackInfo::ALIGN_MAP[type] }
|
||||
|
||||
expected = PackInfo.align 0, alignments[0]
|
||||
expected += PackInfo::SIZE_MAP[TYPE_DOUBLE]
|
||||
|
||||
expected = PackInfo.align expected, alignments[1]
|
||||
expected += PackInfo::SIZE_MAP[TYPE_CHAR]
|
||||
|
||||
expected = PackInfo.align expected, alignments.max
|
||||
|
||||
assert_equal expected, size
|
||||
end
|
||||
|
||||
def test_class_size_with_count
|
||||
size = CStructEntity.size([[TYPE_DOUBLE, 2], [TYPE_CHAR, 20]])
|
||||
|
||||
types = [TYPE_DOUBLE, TYPE_CHAR]
|
||||
alignments = types.map { |type| PackInfo::ALIGN_MAP[type] }
|
||||
|
||||
expected = PackInfo.align 0, alignments[0]
|
||||
expected += PackInfo::SIZE_MAP[TYPE_DOUBLE] * 2
|
||||
|
||||
expected = PackInfo.align expected, alignments[1]
|
||||
expected += PackInfo::SIZE_MAP[TYPE_CHAR] * 20
|
||||
|
||||
expected = PackInfo.align expected, alignments.max
|
||||
|
||||
assert_equal expected, size
|
||||
end
|
||||
|
||||
def test_set_ctypes
|
||||
union = CStructEntity.malloc [TYPE_INT, TYPE_LONG]
|
||||
union.assign_names %w[int long]
|
||||
|
||||
# this test is roundabout because the stored ctypes are not accessible
|
||||
union['long'] = 1
|
||||
union['int'] = 2
|
||||
|
||||
assert_equal 1, union['long']
|
||||
assert_equal 2, union['int']
|
||||
end
|
||||
end
|
||||
end
|
||||
31
test/fiddle/test_c_union_entity.rb
Normal file
31
test/fiddle/test_c_union_entity.rb
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
require_relative 'helper'
|
||||
|
||||
require 'fiddle/struct'
|
||||
|
||||
module Fiddle
|
||||
class TestCUnionEntity < TestCase
|
||||
def test_class_size
|
||||
size = CUnionEntity.size([TYPE_DOUBLE, TYPE_CHAR])
|
||||
|
||||
assert_equal SIZEOF_DOUBLE, size
|
||||
end
|
||||
|
||||
def test_class_size_with_count
|
||||
size = CUnionEntity.size([[TYPE_DOUBLE, 2], [TYPE_CHAR, 20]])
|
||||
|
||||
assert_equal SIZEOF_CHAR * 20, size
|
||||
end
|
||||
|
||||
def test_set_ctypes
|
||||
union = CUnionEntity.malloc [TYPE_INT, TYPE_LONG]
|
||||
union.assign_names %w[int long]
|
||||
|
||||
# this test is roundabout because the stored ctypes are not accessible
|
||||
union['long'] = 1
|
||||
assert_equal 1, union['long']
|
||||
|
||||
union['int'] = 1
|
||||
assert_equal 1, union['int']
|
||||
end
|
||||
end
|
||||
end
|
||||
33
test/fiddle/test_cparser.rb
Normal file
33
test/fiddle/test_cparser.rb
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
require_relative 'helper'
|
||||
|
||||
require 'fiddle/cparser'
|
||||
|
||||
module Fiddle
|
||||
class TestCParser < TestCase
|
||||
include CParser
|
||||
|
||||
def test_uint_ctype
|
||||
assert_equal(-TYPE_INT, parse_ctype('uint'))
|
||||
end
|
||||
|
||||
def test_size_t_ctype
|
||||
assert_equal(TYPE_SIZE_T, parse_ctype("size_t"))
|
||||
end
|
||||
|
||||
def test_ssize_t_ctype
|
||||
assert_equal(TYPE_SSIZE_T, parse_ctype("ssize_t"))
|
||||
end
|
||||
|
||||
def test_ptrdiff_t_ctype
|
||||
assert_equal(TYPE_PTRDIFF_T, parse_ctype("ptrdiff_t"))
|
||||
end
|
||||
|
||||
def test_intptr_t_ctype
|
||||
assert_equal(TYPE_INTPTR_T, parse_ctype("intptr_t"))
|
||||
end
|
||||
|
||||
def test_uintptr_t_ctype
|
||||
assert_equal(TYPE_UINTPTR_T, parse_ctype("uintptr_t"))
|
||||
end
|
||||
end
|
||||
end
|
||||
136
test/fiddle/test_import.rb
Normal file
136
test/fiddle/test_import.rb
Normal file
|
|
@ -0,0 +1,136 @@
|
|||
# coding: US-ASCII
|
||||
require_relative 'helper'
|
||||
require 'fiddle/import'
|
||||
|
||||
module Fiddle
|
||||
module LIBC
|
||||
extend Importer
|
||||
dlload LIBC_SO, LIBM_SO
|
||||
|
||||
typealias 'string', 'char*'
|
||||
typealias 'FILE*', 'void*'
|
||||
|
||||
extern "void *strcpy(char*, char*)"
|
||||
extern "int isdigit(int)"
|
||||
extern "double atof(string)"
|
||||
extern "unsigned long strtoul(char*, char **, int)"
|
||||
extern "int qsort(void*, unsigned long, unsigned long, void*)"
|
||||
extern "int fprintf(FILE*, char*)"
|
||||
extern "int gettimeofday(timeval*, timezone*)" rescue nil
|
||||
|
||||
BoundQsortCallback = bind("void *bound_qsort_callback(void*, void*)"){|ptr1,ptr2| ptr1[0] <=> ptr2[0]}
|
||||
Timeval = struct [
|
||||
"long tv_sec",
|
||||
"long tv_usec",
|
||||
]
|
||||
Timezone = struct [
|
||||
"int tz_minuteswest",
|
||||
"int tz_dsttime",
|
||||
]
|
||||
MyStruct = struct [
|
||||
"short num[5]",
|
||||
"char c",
|
||||
"unsigned char buff[7]",
|
||||
]
|
||||
|
||||
CallCallback = bind("void call_callback(void*, void*)"){ | ptr1, ptr2|
|
||||
f = Function.new(ptr1.to_i, [TYPE_VOIDP], TYPE_VOID)
|
||||
f.call(ptr2)
|
||||
}
|
||||
end
|
||||
|
||||
class TestImport < TestCase
|
||||
def test_ensure_call_dlload
|
||||
err = assert_raises(RuntimeError) do
|
||||
Class.new do
|
||||
extend Importer
|
||||
extern "void *strcpy(char*, char*)"
|
||||
end
|
||||
end
|
||||
assert_match(/call dlload before/, err.message)
|
||||
end
|
||||
|
||||
def test_malloc()
|
||||
s1 = LIBC::Timeval.malloc()
|
||||
s2 = LIBC::Timeval.malloc()
|
||||
refute_equal(s1.to_ptr.to_i, s2.to_ptr.to_i)
|
||||
end
|
||||
|
||||
def test_sizeof()
|
||||
assert_equal(SIZEOF_VOIDP, LIBC.sizeof("FILE*"))
|
||||
assert_equal(LIBC::MyStruct.size(), LIBC.sizeof(LIBC::MyStruct))
|
||||
end
|
||||
|
||||
def test_unsigned_result()
|
||||
d = (2 ** 31) + 1
|
||||
|
||||
r = LIBC.strtoul(d.to_s, 0, 0)
|
||||
assert_equal(d, r)
|
||||
end
|
||||
|
||||
def test_io()
|
||||
if( RUBY_PLATFORM != BUILD_RUBY_PLATFORM )
|
||||
return
|
||||
end
|
||||
io_in,io_out = IO.pipe()
|
||||
LIBC.fprintf(io_out, "hello")
|
||||
io_out.flush()
|
||||
io_out.close()
|
||||
str = io_in.read()
|
||||
io_in.close()
|
||||
assert_equal("hello", str)
|
||||
end
|
||||
|
||||
def test_value()
|
||||
i = LIBC.value('int', 2)
|
||||
assert_equal(2, i.value)
|
||||
|
||||
d = LIBC.value('double', 2.0)
|
||||
assert_equal(2.0, d.value)
|
||||
|
||||
ary = LIBC.value('int[3]', [0,1,2])
|
||||
assert_equal([0,1,2], ary.value)
|
||||
end
|
||||
|
||||
def test_struct()
|
||||
s = LIBC::MyStruct.malloc()
|
||||
s.num = [0,1,2,3,4]
|
||||
s.c = ?a.ord
|
||||
s.buff = "012345\377"
|
||||
assert_equal([0,1,2,3,4], s.num)
|
||||
assert_equal(?a.ord, s.c)
|
||||
assert_equal([?0.ord,?1.ord,?2.ord,?3.ord,?4.ord,?5.ord,?\377.ord], s.buff)
|
||||
end
|
||||
|
||||
def test_gettimeofday()
|
||||
if( defined?(LIBC.gettimeofday) )
|
||||
timeval = LIBC::Timeval.malloc()
|
||||
timezone = LIBC::Timezone.malloc()
|
||||
LIBC.gettimeofday(timeval, timezone)
|
||||
cur = Time.now()
|
||||
assert(cur.to_i - 2 <= timeval.tv_sec && timeval.tv_sec <= cur.to_i)
|
||||
end
|
||||
end
|
||||
|
||||
def test_strcpy()
|
||||
buff = "000"
|
||||
str = LIBC.strcpy(buff, "123")
|
||||
assert_equal("123", buff)
|
||||
assert_equal("123", str.to_s)
|
||||
end
|
||||
|
||||
def test_isdigit
|
||||
r1 = LIBC.isdigit(?1.ord)
|
||||
r2 = LIBC.isdigit(?2.ord)
|
||||
rr = LIBC.isdigit(?r.ord)
|
||||
assert_operator(r1, :>, 0)
|
||||
assert_operator(r2, :>, 0)
|
||||
assert_equal(0, rr)
|
||||
end
|
||||
|
||||
def test_atof
|
||||
r = LIBC.atof("12.34")
|
||||
assert_includes(12.00..13.00, r)
|
||||
end
|
||||
end
|
||||
end
|
||||
Loading…
Reference in a new issue