fiddle 1.0.0 → 1.0.1

data/ext/fiddle/closure.c

@@ -13,11 +13,12 @@ typedef struct {
     ffi_type **argv;
 } fiddle_closure;
 
-#if defined(USE_FFI_CLOSURE_ALLOC)
-#elif defined(__OpenBSD__) || defined(__APPLE__) || defined(__linux__)
+#if defined(__OpenBSD__)
 # define USE_FFI_CLOSURE_ALLOC 0
-#elif defined(RUBY_LIBFFI_MODVERSION) && RUBY_LIBFFI_MODVERSION < 3000005 && \
-	(defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_AMD64))
+#endif
+
+#if defined(USE_FFI_CLOSURE_ALLOC)
+#elif !defined(HAVE_FFI_CLOSURE_ALLOC)
 # define USE_FFI_CLOSURE_ALLOC 0
 #else
 # define USE_FFI_CLOSURE_ALLOC 1

data/ext/fiddle/conversions.c

@@ -1,7 +1,115 @@
 #include <fiddle.h>
 
+VALUE
+rb_fiddle_type_ensure(VALUE type)
+{
+    VALUE original_type = type;
+
+    if (!RB_SYMBOL_P(type)) {
+        VALUE type_string = rb_check_string_type(type);
+        if (!NIL_P(type_string)) {
+            type = rb_to_symbol(type_string);
+        }
+    }
+
+    if (RB_SYMBOL_P(type)) {
+        ID type_id = rb_sym2id(type);
+        ID void_id;
+        ID voidp_id;
+        ID char_id;
+        ID short_id;
+        ID int_id;
+        ID long_id;
+#ifdef TYPE_LONG_LONG
+        ID long_long_id;
+#endif
+        ID float_id;
+        ID double_id;
+        ID variadic_id;
+        ID const_string_id;
+        ID size_t_id;
+        ID ssize_t_id;
+        ID ptrdiff_t_id;
+        ID intptr_t_id;
+        ID uintptr_t_id;
+        RUBY_CONST_ID(void_id, "void");
+        RUBY_CONST_ID(voidp_id, "voidp");
+        RUBY_CONST_ID(char_id, "char");
+        RUBY_CONST_ID(short_id, "short");
+        RUBY_CONST_ID(int_id, "int");
+        RUBY_CONST_ID(long_id, "long");
+#ifdef TYPE_LONG_LONG
+        RUBY_CONST_ID(long_long_id, "long_long");
+#endif
+        RUBY_CONST_ID(float_id, "float");
+        RUBY_CONST_ID(double_id, "double");
+        RUBY_CONST_ID(variadic_id, "variadic");
+        RUBY_CONST_ID(const_string_id, "const_string");
+        RUBY_CONST_ID(size_t_id, "size_t");
+        RUBY_CONST_ID(ssize_t_id, "ssize_t");
+        RUBY_CONST_ID(ptrdiff_t_id, "ptrdiff_t");
+        RUBY_CONST_ID(intptr_t_id, "intptr_t");
+        RUBY_CONST_ID(uintptr_t_id, "uintptr_t");
+        if (type_id == void_id) {
+            return INT2NUM(TYPE_VOID);
+        }
+        else if (type_id == voidp_id) {
+            return INT2NUM(TYPE_VOIDP);
+        }
+        else if (type_id == char_id) {
+            return INT2NUM(TYPE_CHAR);
+        }
+        else if (type_id == short_id) {
+            return INT2NUM(TYPE_SHORT);
+        }
+        else if (type_id == int_id) {
+            return INT2NUM(TYPE_INT);
+        }
+        else if (type_id == long_id) {
+            return INT2NUM(TYPE_LONG);
+        }
+#ifdef TYPE_LONG_LONG
+        else if (type_id == long_long_id) {
+            return INT2NUM(TYPE_LONG_LONG);
+        }
+#endif
+        else if (type_id == float_id) {
+            return INT2NUM(TYPE_FLOAT);
+        }
+        else if (type_id == double_id) {
+            return INT2NUM(TYPE_DOUBLE);
+        }
+        else if (type_id == variadic_id) {
+            return INT2NUM(TYPE_VARIADIC);
+        }
+        else if (type_id == const_string_id) {
+            return INT2NUM(TYPE_CONST_STRING);
+        }
+        else if (type_id == size_t_id) {
+            return INT2NUM(TYPE_SIZE_T);
+        }
+        else if (type_id == ssize_t_id) {
+            return INT2NUM(TYPE_SSIZE_T);
+        }
+        else if (type_id == ptrdiff_t_id) {
+            return INT2NUM(TYPE_PTRDIFF_T);
+        }
+        else if (type_id == intptr_t_id) {
+            return INT2NUM(TYPE_INTPTR_T);
+        }
+        else if (type_id == uintptr_t_id) {
+            return INT2NUM(TYPE_UINTPTR_T);
+        }
+        else {
+            type = original_type;
+        }
+    }
+
+    return rb_to_int(type);
+}
+
 ffi_type *
-int_to_ffi_type(int type)
+rb_fiddle_int_to_ffi_type(int type)
 {
     int signed_p = 1;
 
@@ -33,66 +141,90 @@ int_to_ffi_type(int type)
 	return &ffi_type_float;
       case TYPE_DOUBLE:
 	return &ffi_type_double;
+      case TYPE_CONST_STRING:
+	return &ffi_type_pointer;
       default:
 	rb_raise(rb_eRuntimeError, "unknown type %d", type);
     }
     return &ffi_type_pointer;
 }
 
+ffi_type *
+int_to_ffi_type(int type)
+{
+    return rb_fiddle_int_to_ffi_type(type);
+}
+
 void
-value_to_generic(int type, VALUE src, fiddle_generic * dst)
+rb_fiddle_value_to_generic(int type, VALUE *src, fiddle_generic *dst)
 {
     switch (type) {
       case TYPE_VOID:
 	break;
       case TYPE_VOIDP:
-	dst->pointer = NUM2PTR(rb_Integer(src));
+	dst->pointer = NUM2PTR(rb_Integer(*src));
 	break;
       case TYPE_CHAR:
-	dst->schar = (signed char)NUM2INT(src);
+	dst->schar = (signed char)NUM2INT(*src);
 	break;
       case -TYPE_CHAR:
-	dst->uchar = (unsigned char)NUM2UINT(src);
+	dst->uchar = (unsigned char)NUM2UINT(*src);
 	break;
       case TYPE_SHORT:
-	dst->sshort = (unsigned short)NUM2INT(src);
+	dst->sshort = (unsigned short)NUM2INT(*src);
 	break;
       case -TYPE_SHORT:
-	dst->sshort = (signed short)NUM2UINT(src);
+	dst->sshort = (signed short)NUM2UINT(*src);
 	break;
       case TYPE_INT:
-	dst->sint = NUM2INT(src);
+	dst->sint = NUM2INT(*src);
 	break;
       case -TYPE_INT:
-	dst->uint = NUM2UINT(src);
+	dst->uint = NUM2UINT(*src);
 	break;
       case TYPE_LONG:
-	dst->slong = NUM2LONG(src);
+	dst->slong = NUM2LONG(*src);
 	break;
       case -TYPE_LONG:
-	dst->ulong = NUM2ULONG(src);
+	dst->ulong = NUM2ULONG(*src);
 	break;
 #if HAVE_LONG_LONG
       case TYPE_LONG_LONG:
-	dst->slong_long = NUM2LL(src);
+	dst->slong_long = NUM2LL(*src);
 	break;
       case -TYPE_LONG_LONG:
-	dst->ulong_long = NUM2ULL(src);
+	dst->ulong_long = NUM2ULL(*src);
 	break;
 #endif
       case TYPE_FLOAT:
-	dst->ffloat = (float)NUM2DBL(src);
+	dst->ffloat = (float)NUM2DBL(*src);
 	break;
       case TYPE_DOUBLE:
-	dst->ddouble = NUM2DBL(src);
+	dst->ddouble = NUM2DBL(*src);
+	break;
+      case TYPE_CONST_STRING:
+        if (NIL_P(*src)) {
+            dst->pointer = NULL;
+        }
+        else {
+            dst->pointer = rb_string_value_cstr(src);
+        }
 	break;
       default:
 	rb_raise(rb_eRuntimeError, "unknown type %d", type);
     }
 }
 
+void
+value_to_generic(int type, VALUE src, fiddle_generic *dst)
+{
+    /* src isn't safe from GC when type is TYPE_CONST_STRING and src
+     * isn't String. */
+    return rb_fiddle_value_to_generic(type, &src, dst);
+}
+
 VALUE
-generic_to_value(VALUE rettype, fiddle_generic retval)
+rb_fiddle_generic_to_value(VALUE rettype, fiddle_generic retval)
 {
     int type = NUM2INT(rettype);
     VALUE cPointer;
@@ -131,6 +263,13 @@ generic_to_value(VALUE rettype, fiddle_generic retval)
 	return rb_float_new(retval.ffloat);
       case TYPE_DOUBLE:
 	return rb_float_new(retval.ddouble);
+      case TYPE_CONST_STRING:
+        if (retval.pointer) {
+            return rb_str_new_cstr(retval.pointer);
+        }
+        else {
+            return Qnil;
+        }
       default:
 	rb_raise(rb_eRuntimeError, "unknown type %d", type);
     }
@@ -138,4 +277,10 @@ generic_to_value(VALUE rettype, fiddle_generic retval)
     UNREACHABLE;
 }
 
+VALUE
+generic_to_value(VALUE rettype, fiddle_generic retval)
+{
+    return rb_fiddle_generic_to_value(rettype, retval);
+}
+
 /* vim: set noet sw=4 sts=4 */

data/ext/fiddle/conversions.h

@@ -24,13 +24,23 @@ typedef union
     void * pointer;        /* ffi_type_pointer */
 } fiddle_generic;
 
+/* Deprecated. Use rb_fiddle_*() version. */
+VALUE rb_fiddle_type_ensure(VALUE type);
+ffi_type * rb_fiddle_int_to_ffi_type(int type);
+void rb_fiddle_value_to_generic(int type, VALUE *src, fiddle_generic *dst);
+VALUE rb_fiddle_generic_to_value(VALUE rettype, fiddle_generic retval);
+
+/* Deprecated. Use rb_fiddle_*() version. */
 ffi_type * int_to_ffi_type(int type);
-void value_to_generic(int type, VALUE src, fiddle_generic * dst);
+void value_to_generic(int type, VALUE src, fiddle_generic *dst);
 VALUE generic_to_value(VALUE rettype, fiddle_generic retval);
 
-#define VALUE2GENERIC(_type, _src, _dst) value_to_generic((_type), (_src), (_dst))
-#define INT2FFI_TYPE(_type) int_to_ffi_type(_type)
-#define GENERIC2VALUE(_type, _retval) generic_to_value((_type), (_retval))
+#define VALUE2GENERIC(_type, _src, _dst)        \
+    rb_fiddle_value_to_generic((_type), &(_src), (_dst))
+#define INT2FFI_TYPE(_type)                     \
+    rb_fiddle_int_to_ffi_type(_type)
+#define GENERIC2VALUE(_type, _retval)           \
+    rb_fiddle_generic_to_value((_type), (_retval))
 
 #if SIZEOF_VOIDP == SIZEOF_LONG
 # define PTR2NUM(x)   (LONG2NUM((long)(x)))

data/ext/fiddle/depend

@@ -0,0 +1,83 @@
+PWD =
+
+CONFIGURE_LIBFFI = \
+	$(LIBFFI_CONFIGURE) --disable-shared \
+		--host=$(LIBFFI_ARCH) --enable-builddir=$(arch) \
+		CC="$(CC)" CFLAGS="$(LIBFFI_CFLAGS)" \
+		LD="$(LD)" LDFLAGS="$(LIBFFI_LDFLAGS)"
+
+$(STATIC_LIB) $(RUBYARCHDIR)/$(DLLIB) $(DLLIB): $(LIBFFI_A)
+
+$(OBJS): $(FFI_H)
+
+.PHONY: .FORCE hdr
+
+.FORCE:
+
+hdr: $(FFI_H)
+
+configure-libffi build-libffi: .FORCE
+configure-libffi \
+$(LIBFFI_DIR)/include/ffi.h \
+$(LIBFFI_DIR)/include/ffitarget.h \
+$(LIBFFI_DIR)/fficonfig.h \
+$(LIBFFI_DIR)/Makefile:
+	$(Q) $(MAKEDIRS) $(LIBFFI_DIR)
+	$(Q) $(CONFIGURE_LIBFFI)
+
+build-libffi $(LIBFFI_A):
+	$(Q) $(SUBMAKE_PRE) $(MAKE) $(SUBMAKE_ARG)
+
+clean-none:
+clean-libffi:
+	$(Q) $(SUBMAKE_PRE) $(MAKE) $(SUBMAKE_ARG) clean
+
+distclean-none:
+distclean-libffi:
+	$(Q) $(SUBMAKE_PRE) $(MAKE) $(SUBMAKE_ARG) distclean
+	$(Q) $(RM) $(LIBFFI_DIR)/local.exp
+	$(Q) $(RUBY) -rfileutils -e "FileUtils.rmdir(Dir.glob(ARGV[0]+'/**/{,.*/}'), :parents=>true)" $(LIBFFI_DIR)
+
+realclean-none:
+realclean-libffi:
+	$(Q) $(RMALL) $(LIBFFI_DIR)
+
+.PHONY: clean-libffi distclean-libffi realclean-libffi
+.PHONY: clean-none distclean-none realclean-none
+
+clean: clean-$(LIBFFI_CLEAN)
+distclean: distclean-$(LIBFFI_CLEAN)
+realclean: realclean-$(LIBFFI_CLEAN)
+
+.PHONY: configure configure-libffi
+
+closure.o: closure.c
+closure.o: closure.h
+closure.o: conversions.h
+closure.o: fiddle.h
+closure.o: function.h
+conversions.o: closure.h
+conversions.o: conversions.c
+conversions.o: conversions.h
+conversions.o: fiddle.h
+conversions.o: function.h
+fiddle.o: closure.h
+fiddle.o: conversions.h
+fiddle.o: fiddle.c
+fiddle.o: fiddle.h
+fiddle.o: function.h
+function.o: closure.h
+function.o: conversions.h
+function.o: fiddle.h
+function.o: function.c
+function.o: function.h
+handle.o: closure.h
+handle.o: conversions.h
+handle.o: fiddle.h
+handle.o: function.h
+handle.o: handle.c
+pointer.o: closure.h
+pointer.o: conversions.h
+pointer.o: fiddle.h
+pointer.o: function.h
+pointer.o: pointer.c

data/ext/fiddle/extconf.rb

@@ -3,22 +3,32 @@ require 'mkmf'
 
 # :stopdoc:
 
+libffi_version = nil
+have_libffi = false
 bundle = enable_config('bundled-libffi')
-if ! bundle
+unless bundle
   dir_config 'libffi'
 
-  pkg_config("libffi") and
-    ver = pkg_config("libffi", "modversion")
+  if pkg_config("libffi")
+    libffi_version = pkg_config("libffi", "modversion")
+  end
 
+  have_ffi_header = false
   if have_header(ffi_header = 'ffi.h')
-    true
+    have_ffi_header = true
   elsif have_header(ffi_header = 'ffi/ffi.h')
-    $defs.push(format('-DUSE_HEADER_HACKS'))
-    true
-  end and (have_library('ffi') || have_library('libffi'))
-end or
-begin
-  if bundle
+    $defs.push('-DUSE_HEADER_HACKS')
+    have_ffi_header = true
+  end
+  if have_ffi_header && (have_library('ffi') || have_library('libffi'))
+    have_libffi = true
+  end
+end
+
+unless have_libffi
+  # for https://github.com/ruby/fiddle
+  extlibs_rb = File.expand_path("../../bin/extlibs.rb", $srcdir)
+  if bundle && File.exist?(extlibs_rb)
     require "fileutils"
     require_relative "../../bin/extlibs"
     extlibs = ExtLibs.new
@@ -27,31 +37,32 @@ begin
     Dir.glob("#{$srcdir}/libffi-*/").each{|dir| FileUtils.rm_rf(dir)}
     extlibs.run(["--cache=#{cache_dir}", ext_dir])
   end
-  ver = bundle != false &&
-        Dir.glob("#{$srcdir}/libffi-*/")
-        .map {|n| File.basename(n)}
-        .max_by {|n| n.scan(/\d+/).map(&:to_i)}
-  unless ver
+  if bundle != false
+    libffi_package_name = Dir.glob("#{$srcdir}/libffi-*/")
+                            .map {|n| File.basename(n)}
+                            .max_by {|n| n.scan(/\d+/).map(&:to_i)}
+  end
+  unless libffi_package_name
     raise "missing libffi. Please install libffi."
   end
 
-  srcdir = "#{$srcdir}/#{ver}"
+  libffi_srcdir = "#{$srcdir}/#{libffi_package_name}"
   ffi_header = 'ffi.h'
   libffi = Struct.new(*%I[dir srcdir builddir include lib a cflags ldflags opt arch]).new
-  libffi.dir = ver
+  libffi.dir = libffi_package_name
   if $srcdir == "."
-    libffi.builddir = "#{ver}/#{RUBY_PLATFORM}"
+    libffi.builddir = libffi_package_name
     libffi.srcdir = "."
   else
     libffi.builddir = libffi.dir
-    libffi.srcdir = relative_from(srcdir, "..")
+    libffi.srcdir = relative_from(libffi_srcdir, "..")
   end
   libffi.include = "#{libffi.builddir}/include"
   libffi.lib = "#{libffi.builddir}/.libs"
   libffi.a = "#{libffi.lib}/libffi_convenience.#{$LIBEXT}"
   nowarn = CONFIG.merge("warnflags"=>"")
   libffi.cflags = RbConfig.expand("$(CFLAGS)".dup, nowarn)
-  ver = ver[/libffi-(.*)/, 1]
+  libffi_version = libffi_package_name[/libffi-(.*)/, 1]
 
   FileUtils.mkdir_p(libffi.dir)
   libffi.opt = CONFIG['configure_args'][/'(-C)'/, 1]
@@ -80,7 +91,6 @@ begin
   args.concat %W[
     --srcdir=#{libffi.srcdir}
     --host=#{libffi.arch}
-    --enable-builddir=#{RUBY_PLATFORM}
   ]
   args << ($enable_shared || !$static ? '--enable-shared' : '--enable-static')
   args << libffi.opt if libffi.opt
@@ -97,7 +107,7 @@ begin
       begin
         IO.copy_stream(libffi.dir + "/config.log", Logging.instance_variable_get(:@logfile))
       rescue SystemCallError => e
-        Logfile.message("%s\n", e.message)
+        Logging.message("%s\n", e.message)
       end
       raise "failed to configure libffi. Please install libffi."
     end
@@ -106,15 +116,31 @@ begin
     FileUtils.rm_f("#{libffi.include}/ffitarget.h")
   end
   unless File.file?("#{libffi.include}/ffitarget.h")
-    FileUtils.cp("#{srcdir}/src/x86/ffitarget.h", libffi.include, preserve: true)
+    FileUtils.cp("#{libffi_srcdir}/src/x86/ffitarget.h", libffi.include, preserve: true)
   end
   $INCFLAGS << " -I" << libffi.include
 end
 
-if ver
-  ver = ver.gsub(/-rc\d+/, '') # If ver contains rc version, just ignored.
-  ver = (ver.split('.') + [0,0])[0,3]
-  $defs.push(%{-DRUBY_LIBFFI_MODVERSION=#{ '%d%03d%03d' % ver }})
+if libffi_version
+  # If libffi_version contains rc version, just ignored.
+  libffi_version = libffi_version.gsub(/-rc\d+/, '')
+  libffi_version = (libffi_version.split('.').map(&:to_i) + [0,0])[0,3]
+  $defs.push(%{-DRUBY_LIBFFI_MODVERSION=#{ '%d%03d%03d' % libffi_version }})
+  warn "libffi_version: #{libffi_version.join('.')}"
+end
+
+case
+when $mswin, $mingw, (libffi_version && (libffi_version <=> [3, 2]) >= 0)
+  $defs << "-DUSE_FFI_CLOSURE_ALLOC=1"
+when (libffi_version && (libffi_version <=> [3, 2]) < 0)
+else
+  have_func('ffi_closure_alloc', ffi_header)
+end
+
+if libffi
+  $defs << "-DHAVE_FFI_PREP_CIF_VAR"
+else
+  have_func('ffi_prep_cif_var', ffi_header)
 end
 
 have_header 'sys/mman.h'
@@ -141,7 +167,7 @@ types.each do |type, signed|
   if /^\#define\s+SIZEOF_#{type}\s+(SIZEOF_(.+)|\d+)/ =~ config
     if size = $2 and size != 'VOIDP'
       size = types.fetch(size) {size}
-      $defs << format("-DTYPE_%s=TYPE_%s", signed||type, size)
+      $defs << "-DTYPE_#{signed||type}=TYPE_#{size}"
     end
     if signed
       check_signedness(type.downcase, "stddef.h")