kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* ext/fiddle/fiddle.c: adding alignment constants for compatibility

Browse source 
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 2012-11-28 00:02:49 +00:00
parent 118d9f43c8
commit 0713f89944
16 changed files with 1316 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

23
ChangeLog
View file

@ -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> Wed Nov 28 08:56:00 2012 Zachary Scott <zachary@zacharyscott.net>
* doc/globals.rdoc: Add documentation file for magic globals * doc/globals.rdoc: Add documentation file for magic globals

88
ext/fiddle/fiddle.c
View file

@ -260,6 +260,86 @@ Init_fiddle(void)
*/ */
rb_define_const(mFiddle, "TYPE_UINTPTR_T", INT2NUM(TYPE_UINTPTR_T)); 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 /* Document-const: WINDOWS
* *
* Returns a boolean regarding whether the host is WIN32 * 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)); 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, "dlwrap", rb_fiddle_value2ptr, 1);
rb_define_module_function(mFiddle, "dlunwrap", rb_fiddle_ptr2value, 1); rb_define_module_function(mFiddle, "dlunwrap", rb_fiddle_ptr2value, 1);
rb_define_module_function(mFiddle, "malloc", rb_fiddle_malloc, 1); rb_define_module_function(mFiddle, "malloc", rb_fiddle_malloc, 1);

13
ext/fiddle/fiddle.h
View file

@ -121,6 +121,19 @@
#define TYPE_FLOAT 7 #define TYPE_FLOAT 7
#define TYPE_DOUBLE 8 #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 mFiddle;
extern VALUE rb_eFiddleError; extern VALUE rb_eFiddleError;

156
ext/fiddle/lib/fiddle/cparser.rb Normal file
View 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
View 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
View 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
View 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
View 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

65
test/dl/test_c_struct_entry.rb
View file

@ -2,52 +2,53 @@ require_relative 'test_base'
require 'dl/struct' require 'dl/struct'
class DL::TestCStructEntity < DL::TestBase module DL
def test_class_size class TestCStructEntity < TestBase
types = [DL::TYPE_DOUBLE, DL::TYPE_CHAR] 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 = PackInfo.align 0, alignments[0]
expected += DL::PackInfo::SIZE_MAP[DL::TYPE_DOUBLE] expected += PackInfo::SIZE_MAP[TYPE_DOUBLE]
expected = DL::PackInfo.align expected, alignments[1] expected = PackInfo.align expected, alignments[1]
expected += DL::PackInfo::SIZE_MAP[DL::TYPE_CHAR] expected += PackInfo::SIZE_MAP[TYPE_CHAR]
expected = DL::PackInfo.align expected, alignments.max expected = PackInfo.align expected, alignments.max
assert_equal expected, size assert_equal expected, size
end end
def test_class_size_with_count def test_class_size_with_count
size = DL::CStructEntity.size([[DL::TYPE_DOUBLE, 2], [DL::TYPE_CHAR, 20]]) size = CStructEntity.size([[TYPE_DOUBLE, 2], [TYPE_CHAR, 20]])
types = [DL::TYPE_DOUBLE, DL::TYPE_CHAR] types = [TYPE_DOUBLE, TYPE_CHAR]
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 = PackInfo.align 0, alignments[0]
expected += DL::PackInfo::SIZE_MAP[DL::TYPE_DOUBLE] * 2 expected += PackInfo::SIZE_MAP[TYPE_DOUBLE] * 2
expected = DL::PackInfo.align expected, alignments[1] expected = PackInfo.align expected, alignments[1]
expected += DL::PackInfo::SIZE_MAP[DL::TYPE_CHAR] * 20 expected += PackInfo::SIZE_MAP[TYPE_CHAR] * 20
expected = DL::PackInfo.align expected, alignments.max expected = PackInfo.align expected, alignments.max
assert_equal expected, size assert_equal expected, size
end end
def test_set_ctypes def test_set_ctypes
union = DL::CStructEntity.malloc [DL::TYPE_INT, DL::TYPE_LONG] union = CStructEntity.malloc [TYPE_INT, TYPE_LONG]
union.assign_names %w[int long] union.assign_names %w[int long]
# this test is roundabout because the stored ctypes are not accessible # this test is roundabout because the stored ctypes are not accessible
union['long'] = 1 union['long'] = 1
union['int'] = 2 union['int'] = 2
assert_equal 1, union['long'] assert_equal 1, union['long']
assert_equal 2, union['int'] assert_equal 2, union['int']
end
end end
end end

37
test/dl/test_c_union_entity.rb
View file

@ -2,29 +2,30 @@ require_relative 'test_base'
require 'dl/struct' require 'dl/struct'
class DL::TestCUnionEntity < DL::TestBase module DL
def test_class_size class TestCUnionEntity < TestBase
size = DL::CUnionEntity.size([DL::TYPE_DOUBLE, DL::TYPE_CHAR]) def test_class_size
size = CUnionEntity.size([TYPE_DOUBLE, TYPE_CHAR])
assert_equal DL::SIZEOF_DOUBLE, size assert_equal SIZEOF_DOUBLE, size
end end
def test_class_size_with_count def test_class_size_with_count
size = DL::CUnionEntity.size([[DL::TYPE_DOUBLE, 2], [DL::TYPE_CHAR, 20]]) size = CUnionEntity.size([[TYPE_DOUBLE, 2], [TYPE_CHAR, 20]])
assert_equal DL::SIZEOF_CHAR * 20, size assert_equal SIZEOF_CHAR * 20, size
end end
def test_set_ctypes def test_set_ctypes
union = DL::CUnionEntity.malloc [DL::TYPE_INT, DL::TYPE_LONG] union = CUnionEntity.malloc [TYPE_INT, TYPE_LONG]
union.assign_names %w[int long] union.assign_names %w[int long]
# this test is roundabout because the stored ctypes are not accessible # this test is roundabout because the stored ctypes are not accessible
union['long'] = 1 union['long'] = 1
assert_equal 1, union['long'] assert_equal 1, union['long']
union['int'] = 1 union['int'] = 1
assert_equal 1, union['int'] assert_equal 1, union['int']
end
end end
end end

14
test/dl/test_cparser.rb
View file

@ -4,30 +4,30 @@ require 'dl/cparser'
module DL module DL
class TestCParser < TestBase class TestCParser < TestBase
include DL::CParser include CParser
def test_uint_ctype def test_uint_ctype
assert_equal(-DL::TYPE_INT, parse_ctype('uint')) assert_equal(-TYPE_INT, parse_ctype('uint'))
end end
def test_size_t_ctype 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 end
def test_ssize_t_ctype 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 end
def test_ptrdiff_t_ctype 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 end
def test_intptr_t_ctype 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 end
def test_uintptr_t_ctype 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 end
end end

8
test/dl/test_import.rb
View file

@ -35,7 +35,7 @@ module DL
] ]
CallCallback = bind("void call_callback(void*, void*)"){|ptr1, ptr2| 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) f.call(ptr2)
} }
CarriedFunction = bind("void callback_function(void*)", :carried, 0) CarriedFunction = bind("void callback_function(void*)", :carried, 0)
@ -45,7 +45,7 @@ module DL
def test_ensure_call_dlload def test_ensure_call_dlload
err = assert_raises(RuntimeError) do err = assert_raises(RuntimeError) do
Class.new do Class.new do
extend DL::Importer extend Importer
extern "void *strcpy(char*, char*)" extern "void *strcpy(char*, char*)"
end end
end end
@ -59,7 +59,7 @@ module DL
end end
def test_sizeof() 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)) assert_equal(LIBC::MyStruct.size(), LIBC.sizeof(LIBC::MyStruct))
end end
@ -71,7 +71,7 @@ module DL
end end
def test_io() def test_io()
if( RUBY_PLATFORM != DL::BUILD_RUBY_PLATFORM ) if( RUBY_PLATFORM != BUILD_RUBY_PLATFORM )
return return
end end
io_in,io_out = IO.pipe() io_in,io_out = IO.pipe()

54
test/fiddle/test_c_struct_entry.rb Normal file
View 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
View 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
View 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
View 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