fiddle 1.0.0.beta1 → 1.0.3

data/ext/fiddle/pointer.c

@@ -2,6 +2,7 @@
  * $Id$
  */
 
+#include <stdbool.h>
 #include <ruby/ruby.h>
 #include <ruby/io.h>
 #include <ctype.h>
@@ -24,6 +25,7 @@ struct ptr_data {
     void *ptr;
     long size;
     freefunc_t free;
+    bool freed;
     VALUE wrap[2];
 };
 
@@ -57,14 +59,19 @@ fiddle_ptr_mark(void *ptr)
 }
 
 static void
-fiddle_ptr_free(void *ptr)
+fiddle_ptr_free_ptr(void *ptr)
 {
     struct ptr_data *data = ptr;
-    if (data->ptr) {
-	if (data->free) {
-	    (*(data->free))(data->ptr);
-	}
+    if (data->ptr && data->free && !data->freed) {
+	data->freed = true;
+	(*(data->free))(data->ptr);
     }
+}
+
+static void
+fiddle_ptr_free(void *ptr)
+{
+    fiddle_ptr_free_ptr(ptr);
     xfree(ptr);
 }
 
@@ -89,8 +96,8 @@ rb_fiddle_ptr_new2(VALUE klass, void *ptr, long size, freefunc_t func)
     val = TypedData_Make_Struct(klass, struct ptr_data, &fiddle_ptr_data_type, data);
     data->ptr = ptr;
     data->free = func;
+    data->freed = false;
     data->size = size;
-    OBJ_TAINT(val);
 
     return val;
 }
@@ -102,13 +109,13 @@ rb_fiddle_ptr_new(void *ptr, long size, freefunc_t func)
 }
 
 static VALUE
-rb_fiddle_ptr_malloc(long size, freefunc_t func)
+rb_fiddle_ptr_malloc(VALUE klass, long size, freefunc_t func)
 {
     void *ptr;
 
     ptr = ruby_xmalloc((size_t)size);
     memset(ptr,0,(size_t)size);
-    return rb_fiddle_ptr_new(ptr, size, func);
+    return rb_fiddle_ptr_new2(klass, ptr, size, func);
 }
 
 static void *
@@ -141,6 +148,7 @@ rb_fiddle_ptr_s_allocate(VALUE klass)
     data->ptr = 0;
     data->size = 0;
     data->free = 0;
+    data->freed = false;
 
     return obj;
 }
@@ -192,16 +200,53 @@ rb_fiddle_ptr_initialize(int argc, VALUE argv[], VALUE self)
     return Qnil;
 }
 
+static VALUE
+rb_fiddle_ptr_call_free(VALUE self);
+
 /*
  * call-seq:
- *
  *    Fiddle::Pointer.malloc(size, freefunc = nil)  => fiddle pointer instance
+ *    Fiddle::Pointer.malloc(size, freefunc) { |pointer| ... } => ...
+ *
+ * == Examples
+ *
+ *    # Automatically freeing the pointer when the block is exited - recommended
+ *    Fiddle::Pointer.malloc(size, Fiddle::RUBY_FREE) do |pointer|
+ *      ...
+ *    end
+ *
+ *    # Manually freeing but relying on the garbage collector otherwise
+ *    pointer = Fiddle::Pointer.malloc(size, Fiddle::RUBY_FREE)
+ *    ...
+ *    pointer.call_free
+ *
+ *    # Relying on the garbage collector - may lead to unlimited memory allocated before freeing any, but safe
+ *    pointer = Fiddle::Pointer.malloc(size, Fiddle::RUBY_FREE)
+ *    ...
+ *
+ *    # Only manually freeing
+ *    pointer = Fiddle::Pointer.malloc(size)
+ *    begin
+ *      ...
+ *    ensure
+ *      Fiddle.free pointer
+ *    end
+ *
+ *    # No free function and no call to free - the native memory will leak if the pointer is garbage collected
+ *    pointer = Fiddle::Pointer.malloc(size)
+ *    ...
  *
  * Allocate +size+ bytes of memory and associate it with an optional
- * +freefunc+ that will be called when the pointer is garbage collected.
+ * +freefunc+.
+ *
+ * If a block is supplied, the pointer will be yielded to the block instead of
+ * being returned, and the return value of the block will be returned. A
+ * +freefunc+ must be supplied if a block is.
  *
- * +freefunc+ must be an address pointing to a function or an instance of
- * Fiddle::Function
+ * If a +freefunc+ is supplied it will be called once, when the pointer is
+ * garbage collected or when the block is left if a block is supplied or
+ * when the user calls +call_free+, whichever happens first. +freefunc+ must be
+ * an address pointing to a function or an instance of +Fiddle::Function+.
  */
 static VALUE
 rb_fiddle_ptr_s_malloc(int argc, VALUE argv[], VALUE klass)
@@ -223,10 +268,17 @@ rb_fiddle_ptr_s_malloc(int argc, VALUE argv[], VALUE klass)
 	rb_bug("rb_fiddle_ptr_s_malloc");
     }
 
-    obj = rb_fiddle_ptr_malloc(s,f);
+    obj = rb_fiddle_ptr_malloc(klass, s,f);
     if (wrap) RPTR_DATA(obj)->wrap[1] = wrap;
 
-    return obj;
+    if (rb_block_given_p()) {
+        if (!f) {
+            rb_raise(rb_eArgError, "a free function must be supplied to Fiddle::Pointer.malloc when it is called with a block");
+        }
+        return rb_ensure(rb_yield, obj, rb_fiddle_ptr_call_free, obj);
+    } else {
+        return obj;
+    }
 }
 
 /*
@@ -351,6 +403,34 @@ rb_fiddle_ptr_free_get(VALUE self)
     return rb_fiddle_new_function(address, arg_types, ret_type);
 }
 
+/*
+ * call-seq: call_free => nil
+ *
+ * Call the free function for this pointer. Calling more than once will do
+ * nothing. Does nothing if there is no free function attached.
+ */
+static VALUE
+rb_fiddle_ptr_call_free(VALUE self)
+{
+    struct ptr_data *pdata;
+    TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, pdata);
+    fiddle_ptr_free_ptr(pdata);
+    return Qnil;
+}
+
+/*
+ * call-seq: freed? => bool
+ *
+ * Returns if the free function for this pointer has been called.
+ */
+static VALUE
+rb_fiddle_ptr_freed_p(VALUE self)
+{
+    struct ptr_data *pdata;
+    TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, pdata);
+    return pdata->freed ? Qtrue : Qfalse;
+}
+
 /*
  * call-seq:
  *
@@ -376,11 +456,11 @@ rb_fiddle_ptr_to_s(int argc, VALUE argv[], VALUE self)
     TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
     switch (rb_scan_args(argc, argv, "01", &arg1)) {
       case 0:
-	val = rb_tainted_str_new2((char*)(data->ptr));
+	val = rb_str_new2((char*)(data->ptr));
 	break;
       case 1:
 	len = NUM2INT(arg1);
-	val = rb_tainted_str_new((char*)(data->ptr), len);
+	val = rb_str_new((char*)(data->ptr), len);
 	break;
       default:
 	rb_bug("rb_fiddle_ptr_to_s");
@@ -414,11 +494,11 @@ rb_fiddle_ptr_to_str(int argc, VALUE argv[], VALUE self)
     TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
     switch (rb_scan_args(argc, argv, "01", &arg1)) {
       case 0:
-	val = rb_tainted_str_new((char*)(data->ptr),data->size);
+	val = rb_str_new((char*)(data->ptr),data->size);
 	break;
       case 1:
 	len = NUM2INT(arg1);
-	val = rb_tainted_str_new((char*)(data->ptr), len);
+	val = rb_str_new((char*)(data->ptr), len);
 	break;
       default:
 	rb_bug("rb_fiddle_ptr_to_str");
@@ -440,7 +520,7 @@ rb_fiddle_ptr_inspect(VALUE self)
 
     TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
     return rb_sprintf("#<%"PRIsVALUE":%p ptr=%p size=%ld free=%p>",
-		      RB_OBJ_CLASSNAME(self), data, data->ptr, data->size, data->free);
+		      RB_OBJ_CLASSNAME(self), (void *)data, data->ptr, data->size, (void *)data->free);
 }
 
 /*
@@ -542,7 +622,7 @@ rb_fiddle_ptr_aref(int argc, VALUE argv[], VALUE self)
     struct ptr_data *data;
 
     TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
-    if (!data->ptr) rb_raise(rb_eFiddleError, "NULL pointer dereference");
+    if (!data->ptr) rb_raise(rb_eFiddleDLError, "NULL pointer dereference");
     switch( rb_scan_args(argc, argv, "11", &arg0, &arg1) ){
       case 1:
 	offset = NUM2ULONG(arg0);
@@ -551,7 +631,7 @@ rb_fiddle_ptr_aref(int argc, VALUE argv[], VALUE self)
       case 2:
 	offset = NUM2ULONG(arg0);
 	len    = NUM2ULONG(arg1);
-	retval = rb_tainted_str_new((char *)data->ptr + offset, len);
+	retval = rb_str_new((char *)data->ptr + offset, len);
 	break;
       default:
 	rb_bug("rb_fiddle_ptr_aref()");
@@ -580,7 +660,7 @@ rb_fiddle_ptr_aset(int argc, VALUE argv[], VALUE self)
     struct ptr_data *data;
 
     TypedData_Get_Struct(self, struct ptr_data, &fiddle_ptr_data_type, data);
-    if (!data->ptr) rb_raise(rb_eFiddleError, "NULL pointer dereference");
+    if (!data->ptr) rb_raise(rb_eFiddleDLError, "NULL pointer dereference");
     switch( rb_scan_args(argc, argv, "21", &arg0, &arg1, &arg2) ){
       case 2:
 	offset = NUM2ULONG(arg0);
@@ -661,7 +741,7 @@ rb_fiddle_ptr_s_to_ptr(VALUE self, VALUE val)
 	    wrap = 0;
 	}
 	else{
-	    rb_raise(rb_eFiddleError, "to_ptr should return a Fiddle::Pointer object");
+	    rb_raise(rb_eFiddleDLError, "to_ptr should return a Fiddle::Pointer object");
 	}
     }
     else{
@@ -669,7 +749,6 @@ rb_fiddle_ptr_s_to_ptr(VALUE self, VALUE val)
 	if (num == val) wrap = 0;
 	ptr = rb_fiddle_ptr_new(NUM2PTR(num), 0, NULL);
     }
-    OBJ_INFECT(ptr, val);
     if (wrap) RPTR_DATA(ptr)->wrap[0] = wrap;
     return ptr;
 }
@@ -677,6 +756,7 @@ rb_fiddle_ptr_s_to_ptr(VALUE self, VALUE val)
 void
 Init_fiddle_pointer(void)
 {
+#undef rb_intern
     id_to_ptr = rb_intern("to_ptr");
 
     /* Document-class: Fiddle::Pointer
@@ -692,6 +772,8 @@ Init_fiddle_pointer(void)
     rb_define_method(rb_cPointer, "initialize", rb_fiddle_ptr_initialize, -1);
     rb_define_method(rb_cPointer, "free=", rb_fiddle_ptr_free_set, 1);
     rb_define_method(rb_cPointer, "free",  rb_fiddle_ptr_free_get, 0);
+    rb_define_method(rb_cPointer, "call_free",  rb_fiddle_ptr_call_free, 0);
+    rb_define_method(rb_cPointer, "freed?",  rb_fiddle_ptr_freed_p, 0);
     rb_define_method(rb_cPointer, "to_i",  rb_fiddle_ptr_to_i, 0);
     rb_define_method(rb_cPointer, "to_int",  rb_fiddle_ptr_to_i, 0);
     rb_define_method(rb_cPointer, "to_value",  rb_fiddle_ptr_to_value, 0);

data/ext/fiddle/win32/libffi-config.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/ruby
-# frozen_string_literal: false
+# frozen_string_literal: true
 require 'fileutils'
 
 basedir = File.dirname(__FILE__)
@@ -32,7 +32,7 @@ IO.foreach("#{srcdir}/configure.ac") do |line|
   end
 end
 
-builddir = srcdir == "." ? enable['builddir'] : "."
+builddir = srcdir == "." ? (enable['builddir'] || ".") : "."
 conf['TARGET'] = /^x64/ =~ host ? "X86_WIN64" : "X86_WIN32"
 
 FileUtils.mkdir_p([builddir, "#{builddir}/include", "#{builddir}/src/x86"])

data/fiddle.gemspec

@@ -1,23 +1,65 @@
+# frozen_string_literal: true
+
+version_module = Module.new do
+  version_rb = File.join(__dir__, "lib/fiddle/version.rb")
+  module_eval(File.read(version_rb), version_rb, __LINE__)
+end
+
 Gem::Specification.new do |spec|
   spec.name          = "fiddle"
-  spec.version       = '1.0.0.beta1'
+  spec.version       = version_module::Fiddle::VERSION
   spec.authors       = ["Aaron Patterson", "SHIBATA Hiroshi"]
   spec.email         = ["aaron@tenderlovemaking.com", "hsbt@ruby-lang.org"]
 
   spec.summary       = %q{A libffi wrapper for Ruby.}
   spec.description   = %q{A libffi wrapper for Ruby.}
   spec.homepage      = "https://github.com/ruby/fiddle"
-  spec.license       = "MIT"
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.files         = [
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "bin/downloader.rb",
+    "bin/extlibs.rb",
+    "ext/fiddle/closure.c",
+    "ext/fiddle/closure.h",
+    "ext/fiddle/conversions.c",
+    "ext/fiddle/conversions.h",
+    "ext/fiddle/depend",
+    "ext/fiddle/extconf.rb",
+    "ext/fiddle/extlibs",
+    "ext/fiddle/fiddle.c",
+    "ext/fiddle/fiddle.h",
+    "ext/fiddle/function.c",
+    "ext/fiddle/function.h",
+    "ext/fiddle/handle.c",
+    "ext/fiddle/pinned.c",
+    "ext/fiddle/pointer.c",
+    "ext/fiddle/win32/fficonfig.h",
+    "ext/fiddle/win32/libffi-3.2.1-mswin.patch",
+    "ext/fiddle/win32/libffi-config.rb",
+    "ext/fiddle/win32/libffi.mk.tmpl",
+    "fiddle.gemspec",
+    "lib/fiddle.rb",
+    "lib/fiddle/closure.rb",
+    "lib/fiddle/cparser.rb",
+    "lib/fiddle/function.rb",
+    "lib/fiddle/import.rb",
+    "lib/fiddle/pack.rb",
+    "lib/fiddle/struct.rb",
+    "lib/fiddle/types.rb",
+    "lib/fiddle/value.rb",
+    "lib/fiddle/version.rb",
+  ]
   spec.require_paths = ["lib"]
+  spec.extensions = ["ext/fiddle/extconf.rb"]
+
+  spec.required_ruby_version = ">= 2.3.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest", "~> 4.0"
   spec.add_development_dependency "rake-compiler"
+
+  spec.metadata["msys2_mingw_dependencies"] = "libffi"
 end

data/lib/fiddle.rb

@@ -1,7 +1,9 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
+
 require 'fiddle.so'
-require 'fiddle/function'
 require 'fiddle/closure'
+require 'fiddle/function'
+require 'fiddle/version'
 
 module Fiddle
   if WINDOWS

data/lib/fiddle/closure.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 module Fiddle
   class Closure
 

data/lib/fiddle/cparser.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 module Fiddle
   # A mixin that provides methods for parsing C struct and prototype signatures.
   #
@@ -21,6 +21,7 @@ module Fiddle
     # Parses a C struct's members
     #
     # Example:
+    #   require 'fiddle/import'
     #
     #   include Fiddle::CParser
     #     #=> Object
@@ -34,12 +35,37 @@ module Fiddle
     def parse_struct_signature(signature, tymap=nil)
       if signature.is_a?(String)
         signature = split_arguments(signature, /[,;]/)
+      elsif signature.is_a?(Hash)
+        signature = [signature]
       end
       mems = []
       tys  = []
       signature.each{|msig|
-        msig = compact(msig)
+        msig = compact(msig) if msig.is_a?(String)
         case msig
+        when Hash
+          msig.each do |struct_name, struct_signature|
+            struct_name = struct_name.to_s if struct_name.is_a?(Symbol)
+            struct_name = compact(struct_name)
+            struct_count = nil
+            if struct_name =~ /^([\w\*\s]+)\[(\d+)\]$/
+              struct_count = $2.to_i
+              struct_name = $1
+            end
+            if struct_signature.respond_to?(:entity_class)
+              struct_type = struct_signature
+            else
+              parsed_struct = parse_struct_signature(struct_signature, tymap)
+              struct_type = CStructBuilder.create(CStruct, *parsed_struct)
+            end
+            if struct_count
+              ty = [struct_type, struct_count]
+            else
+              ty = struct_type
+            end
+            mems.push([struct_name, struct_type.members])
+            tys.push(ty)
+          end
         when /^[\w\*\s]+[\*\s](\w+)$/
           mems.push($1)
           tys.push(parse_ctype(msig, tymap))
@@ -66,6 +92,7 @@ module Fiddle
     # be looked up.
     #
     # Example:
+    #   require 'fiddle/import'
     #
     #   include Fiddle::CParser
     #     #=> Object
@@ -102,6 +129,7 @@ module Fiddle
     # value will be the C type to be looked up.
     #
     # Example:
+    #   require 'fiddle/import'
     #
     #   include Fiddle::CParser
     #     #=> Object
@@ -169,6 +197,8 @@ module Fiddle
         return TYPE_UINTPTR_T
       when /\*/, /\[[\s\d]*\]/
         return TYPE_VOIDP
+      when "..."
+        return TYPE_VARIADIC
       else
         ty = ty.split(' ', 2)[0]
         if( tymap[ty] )
@@ -183,7 +213,7 @@ module Fiddle
 
     def split_arguments(arguments, sep=',')
       return [] if arguments.strip == 'void'
-      arguments.scan(/([\w\*\s]+\(\*\w*\)\(.*?\)|[\w\*\s\[\]]+)(?:#{sep}\s*|$)/).collect {|m| m[0]}
+      arguments.scan(/([\w\*\s]+\(\*\w*\)\(.*?\)|[\w\*\s\[\]]+|\.\.\.)(?:#{sep}\s*|$)/).collect {|m| m[0]}
     end
 
     def compact(signature)