fiddle 1.0.0 → 1.0.1

data/ext/fiddle/extlibs

@@ -1,5 +1,13 @@
-http://sourceware.org/pub/libffi/libffi-3.2.1.tar.gz \
+ver = 3.2.1
+pkg = libffi-$(ver)
+
+https://ftp.osuosl.org/pub/blfs/conglomeration/libffi/$(pkg).tar.gz \
   md5:83b89587607e3eb65c70d361f13bab43 \
   sha512:980ca30a8d76f963fca722432b1fe5af77d7a4e4d2eac5144fbc5374d4c596609a293440573f4294207e1bdd9fda80ad1e1cafb2ffb543df5a275bc3bd546483 \
   #
-	win32/libffi-3.2.1-mswin.patch -p0
+	win32/$(pkg)-mswin.patch -p0
+
+$(pkg)/config.guess -> /tool/config.guess
+$(pkg)/config.sub -> /tool/config.sub
+
+! chdir: $(pkg)| autoconf || exit 0

data/ext/fiddle/fiddle.c

@@ -1,41 +1,11 @@
 #include <fiddle.h>
 
 VALUE mFiddle;
+VALUE rb_eFiddleDLError;
 VALUE rb_eFiddleError;
 
-#ifndef TYPE_SSIZE_T
-# if SIZEOF_SIZE_T == SIZEOF_INT
-#   define TYPE_SSIZE_T TYPE_INT
-# elif SIZEOF_SIZE_T == SIZEOF_LONG
-#   define TYPE_SSIZE_T TYPE_LONG
-# elif defined HAVE_LONG_LONG && SIZEOF_SIZE_T == SIZEOF_LONG_LONG
-#   define TYPE_SSIZE_T TYPE_LONG_LONG
-# endif
-#endif
-#define TYPE_SIZE_T (-1*SIGNEDNESS_OF_SIZE_T*TYPE_SSIZE_T)
-
-#ifndef TYPE_PTRDIFF_T
-# if SIZEOF_PTRDIFF_T == SIZEOF_INT
-#   define TYPE_PTRDIFF_T TYPE_INT
-# elif SIZEOF_PTRDIFF_T == SIZEOF_LONG
-#   define TYPE_PTRDIFF_T TYPE_LONG
-# elif defined HAVE_LONG_LONG && SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG
-#   define TYPE_PTRDIFF_T TYPE_LONG_LONG
-# endif
-#endif
-
-#ifndef TYPE_INTPTR_T
-# if SIZEOF_INTPTR_T == SIZEOF_INT
-#   define TYPE_INTPTR_T TYPE_INT
-# elif SIZEOF_INTPTR_T == SIZEOF_LONG
-#   define TYPE_INTPTR_T TYPE_LONG
-# elif defined HAVE_LONG_LONG && SIZEOF_INTPTR_T == SIZEOF_LONG_LONG
-#   define TYPE_INTPTR_T TYPE_LONG_LONG
-# endif
-#endif
-#define TYPE_UINTPTR_T (-TYPE_INTPTR_T)
-
 void Init_fiddle_pointer(void);
+void Init_fiddle_pinned(void);
 
 /*
  * call-seq: Fiddle.malloc(size)
@@ -47,8 +17,7 @@ static VALUE
 rb_fiddle_malloc(VALUE self, VALUE size)
 {
     void *ptr;
-
-    ptr = (void*)ruby_xmalloc(NUM2SIZET(size));
+    ptr = (void*)ruby_xcalloc(1, NUM2SIZET(size));
     return PTR2NUM(ptr);
 }
 
@@ -163,12 +132,33 @@ Init_fiddle(void)
      */
     mFiddle = rb_define_module("Fiddle");
 
+    /*
+     * Document-class: Fiddle::Error
+     *
+     * Generic error class for Fiddle
+     */
+    rb_eFiddleError = rb_define_class_under(mFiddle, "Error", rb_eStandardError);
+
+    /*
+     * Ruby installed by RubyInstaller for Windows always require
+     * bundled Fiddle because ruby_installer/runtime/dll_directory.rb
+     * requires Fiddle. It's used by
+     * rubygems/defaults/operating_system.rb. It means that the
+     * bundled Fiddle is always required on initialization.
+     *
+     * We just remove existing Fiddle::DLError here to override
+     * the bundled Fiddle.
+     */
+    if (rb_const_defined(mFiddle, rb_intern("DLError"))) {
+        rb_const_remove(mFiddle, rb_intern("DLError"));
+    }
+
     /*
      * Document-class: Fiddle::DLError
      *
      * standard dynamic load exception
      */
-    rb_eFiddleError = rb_define_class_under(mFiddle, "DLError", rb_eStandardError);
+    rb_eFiddleDLError = rb_define_class_under(mFiddle, "DLError", rb_eFiddleError);
 
     /* Document-const: TYPE_VOID
      *
@@ -226,6 +216,20 @@ Init_fiddle(void)
      */
     rb_define_const(mFiddle, "TYPE_DOUBLE",    INT2NUM(TYPE_DOUBLE));
 
+#ifdef HAVE_FFI_PREP_CIF_VAR
+    /* Document-const: TYPE_VARIADIC
+     *
+     * C type - ...
+     */
+    rb_define_const(mFiddle, "TYPE_VARIADIC",  INT2NUM(TYPE_VARIADIC));
+#endif
+
+    /* Document-const: TYPE_CONST_STRING
+     *
+     * C type - const char* ('\0' terminated const char*)
+     */
+    rb_define_const(mFiddle, "TYPE_CONST_STRING",  INT2NUM(TYPE_CONST_STRING));
+
     /* Document-const: TYPE_SIZE_T
      *
      * C type - size_t
@@ -426,6 +430,12 @@ Init_fiddle(void)
      */
     rb_define_const(mFiddle, "SIZEOF_UINTPTR_T",  INT2NUM(sizeof(uintptr_t)));
 
+    /* Document-const: SIZEOF_CONST_STRING
+     *
+     * size of a const char*
+     */
+    rb_define_const(mFiddle, "SIZEOF_CONST_STRING", INT2NUM(sizeof(const char*)));
+
     /* Document-const: RUBY_FREE
      *
      * Address of the ruby_xfree() function
@@ -450,5 +460,6 @@ Init_fiddle(void)
     Init_fiddle_closure();
     Init_fiddle_handle();
     Init_fiddle_pointer();
+    Init_fiddle_pinned();
 }
 /* vim: set noet sws=4 sw=4: */

data/ext/fiddle/fiddle.h

@@ -115,6 +115,40 @@
 #endif
 #define TYPE_FLOAT 7
 #define TYPE_DOUBLE 8
+#define TYPE_VARIADIC 9
+#define TYPE_CONST_STRING 10
+
+#ifndef TYPE_SSIZE_T
+# if SIZEOF_SIZE_T == SIZEOF_INT
+#   define TYPE_SSIZE_T TYPE_INT
+# elif SIZEOF_SIZE_T == SIZEOF_LONG
+#   define TYPE_SSIZE_T TYPE_LONG
+# elif defined HAVE_LONG_LONG && SIZEOF_SIZE_T == SIZEOF_LONG_LONG
+#   define TYPE_SSIZE_T TYPE_LONG_LONG
+# endif
+#endif
+#define TYPE_SIZE_T (-1*SIGNEDNESS_OF_SIZE_T*TYPE_SSIZE_T)
+
+#ifndef TYPE_PTRDIFF_T
+# if SIZEOF_PTRDIFF_T == SIZEOF_INT
+#   define TYPE_PTRDIFF_T TYPE_INT
+# elif SIZEOF_PTRDIFF_T == SIZEOF_LONG
+#   define TYPE_PTRDIFF_T TYPE_LONG
+# elif defined HAVE_LONG_LONG && SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG
+#   define TYPE_PTRDIFF_T TYPE_LONG_LONG
+# endif
+#endif
+
+#ifndef TYPE_INTPTR_T
+# if SIZEOF_INTPTR_T == SIZEOF_INT
+#   define TYPE_INTPTR_T TYPE_INT
+# elif SIZEOF_INTPTR_T == SIZEOF_LONG
+#   define TYPE_INTPTR_T TYPE_LONG
+# elif defined HAVE_LONG_LONG && SIZEOF_INTPTR_T == SIZEOF_LONG_LONG
+#   define TYPE_INTPTR_T TYPE_LONG_LONG
+# endif
+#endif
+#define TYPE_UINTPTR_T (-TYPE_INTPTR_T)
 
 #define ALIGN_OF(type) offsetof(struct {char align_c; type align_x;}, align_x)
 
@@ -130,7 +164,7 @@
 #define ALIGN_DOUBLE ALIGN_OF(double)
 
 extern VALUE mFiddle;
-extern VALUE rb_eFiddleError;
+extern VALUE rb_eFiddleDLError;
 
 VALUE rb_fiddle_new_function(VALUE address, VALUE arg_types, VALUE ret_type);
 

data/ext/fiddle/function.c

@@ -1,6 +1,8 @@
 #include <fiddle.h>
 #include <ruby/thread.h>
 
+#include <stdbool.h>
+
 #ifdef PRIsVALUE
 # define RB_OBJ_CLASSNAME(obj) rb_obj_class(obj)
 # define RB_OBJ_STRING(obj) (obj)
@@ -19,21 +21,21 @@ VALUE cFiddleFunction;
 #define Check_Max_Args_Long(name, len) \
     Check_Max_Args_(name, len, "l")
 #define Check_Max_Args_(name, len, fmt) \
-    if ((size_t)(len) < MAX_ARGS) { \
-	/* OK */ \
-    } \
-    else { \
-	rb_raise(rb_eTypeError, \
-		 name" is so large that it can cause integer overflow (%"fmt"d)", \
-		 (len)); \
-    }
+    do { \
+        if ((size_t)(len) >= MAX_ARGS) { \
+            rb_raise(rb_eTypeError, \
+                     "%s is so large " \
+                     "that it can cause integer overflow (%"fmt"d)", \
+                     (name), (len)); \
+        } \
+    } while (0)
 
 static void
 deallocate(void *p)
 {
-    ffi_cif *ptr = p;
-    if (ptr->arg_types) xfree(ptr->arg_types);
-    xfree(ptr);
+    ffi_cif *cif = p;
+    if (cif->arg_types) xfree(cif->arg_types);
+    xfree(cif);
 }
 
 static size_t
@@ -87,60 +89,91 @@ parse_keyword_arg_i(VALUE key, VALUE value, VALUE self)
     return ST_CONTINUE;
 }
 
+static VALUE
+normalize_argument_types(const char *name,
+                         VALUE arg_types,
+                         bool *is_variadic)
+{
+    VALUE normalized_arg_types;
+    int i;
+    int n_arg_types;
+    *is_variadic = false;
+
+    Check_Type(arg_types, T_ARRAY);
+    n_arg_types = RARRAY_LENINT(arg_types);
+    Check_Max_Args(name, n_arg_types);
+
+    normalized_arg_types = rb_ary_new_capa(n_arg_types);
+    for (i = 0; i < n_arg_types; i++) {
+        VALUE arg_type = RARRAY_AREF(arg_types, i);
+        int c_arg_type;
+        arg_type = rb_fiddle_type_ensure(arg_type);
+        c_arg_type = NUM2INT(arg_type);
+        if (c_arg_type == TYPE_VARIADIC) {
+            if (i != n_arg_types - 1) {
+                rb_raise(rb_eArgError,
+                         "Fiddle::TYPE_VARIADIC must be the last argument type: "
+                         "%"PRIsVALUE,
+                         arg_types);
+            }
+            *is_variadic = true;
+            break;
+        }
+        else {
+            (void)INT2FFI_TYPE(c_arg_type); /* raise */
+        }
+        rb_ary_push(normalized_arg_types, INT2FIX(c_arg_type));
+    }
+
+    /* freeze to prevent inconsistency at calling #to_int later */
+    OBJ_FREEZE(normalized_arg_types);
+    return normalized_arg_types;
+}
+
 static VALUE
 initialize(int argc, VALUE argv[], VALUE self)
 {
     ffi_cif * cif;
-    ffi_type **arg_types, *rtype;
-    ffi_status result;
-    VALUE ptr, args, ret_type, abi, kwds, ary;
-    int i, len;
-    int nabi;
+    VALUE ptr, arg_types, ret_type, abi, kwds;
+    int c_ret_type;
+    bool is_variadic = false;
+    ffi_abi c_ffi_abi;
     void *cfunc;
 
-    rb_scan_args(argc, argv, "31:", &ptr, &args, &ret_type, &abi, &kwds);
+    rb_scan_args(argc, argv, "31:", &ptr, &arg_types, &ret_type, &abi, &kwds);
+    rb_iv_set(self, "@closure", ptr);
+
     ptr = rb_Integer(ptr);
     cfunc = NUM2PTR(ptr);
     PTR2NUM(cfunc);
-    nabi = NIL_P(abi) ? FFI_DEFAULT_ABI : NUM2INT(abi);
-    abi = INT2FIX(nabi);
-    i = NUM2INT(ret_type);
-    rtype = INT2FFI_TYPE(i);
-    ret_type = INT2FIX(i);
-
-    Check_Type(args, T_ARRAY);
-    len = RARRAY_LENINT(args);
-    Check_Max_Args("args", len);
-    ary = rb_ary_subseq(args, 0, len);
-    for (i = 0; i < RARRAY_LEN(args); i++) {
-	VALUE a = RARRAY_PTR(args)[i];
-	int type = NUM2INT(a);
-	(void)INT2FFI_TYPE(type); /* raise */
-	if (INT2FIX(type) != a) rb_ary_store(ary, i, INT2FIX(type));
+    c_ffi_abi = NIL_P(abi) ? FFI_DEFAULT_ABI : NUM2INT(abi);
+    abi = INT2FIX(c_ffi_abi);
+    ret_type = rb_fiddle_type_ensure(ret_type);
+    c_ret_type = NUM2INT(ret_type);
+    (void)INT2FFI_TYPE(c_ret_type); /* raise */
+    ret_type = INT2FIX(c_ret_type);
+
+    arg_types = normalize_argument_types("argument types",
+                                         arg_types,
+                                         &is_variadic);
+#ifndef HAVE_FFI_PREP_CIF_VAR
+    if (is_variadic) {
+        rb_raise(rb_eNotImpError,
+                 "ffi_prep_cif_var() is required in libffi "
+                 "for variadic arguments");
     }
-    OBJ_FREEZE(ary);
+#endif
 
     rb_iv_set(self, "@ptr", ptr);
-    rb_iv_set(self, "@args", args);
+    rb_iv_set(self, "@argument_types", arg_types);
     rb_iv_set(self, "@return_type", ret_type);
     rb_iv_set(self, "@abi", abi);
+    rb_iv_set(self, "@is_variadic", is_variadic ? Qtrue : Qfalse);
 
     if (!NIL_P(kwds)) rb_hash_foreach(kwds, parse_keyword_arg_i, self);
 
     TypedData_Get_Struct(self, ffi_cif, &function_data_type, cif);
-
-    arg_types = xcalloc(len + 1, sizeof(ffi_type *));
-
-    for (i = 0; i < RARRAY_LEN(args); i++) {
-	int type = NUM2INT(RARRAY_AREF(args, i));
-	arg_types[i] = INT2FFI_TYPE(type);
-    }
-    arg_types[len] = NULL;
-
-    result = ffi_prep_cif(cif, nabi, len, rtype, arg_types);
-
-    if (result)
-	rb_raise(rb_eRuntimeError, "error creating CIF %d", result);
+    cif->arg_types = NULL;
 
     return self;
 }
@@ -167,54 +200,160 @@ function_call(int argc, VALUE argv[], VALUE self)
 {
     struct nogvl_ffi_call_args args = { 0 };
     fiddle_generic *generic_args;
-    VALUE cfunc, types, cPointer;
+    VALUE cfunc;
+    VALUE abi;
+    VALUE arg_types;
+    VALUE cPointer;
+    VALUE is_variadic;
+    int n_arg_types;
+    int n_fixed_args = 0;
+    int n_call_args = 0;
     int i;
+    int i_call;
+    VALUE converted_args = Qnil;
     VALUE alloc_buffer = 0;
 
     cfunc    = rb_iv_get(self, "@ptr");
-    types    = rb_iv_get(self, "@args");
+    abi      = rb_iv_get(self, "@abi");
+    arg_types = rb_iv_get(self, "@argument_types");
     cPointer = rb_const_get(mFiddle, rb_intern("Pointer"));
-
-    Check_Max_Args("number of arguments", argc);
-    if (argc != (i = RARRAY_LENINT(types))) {
-	rb_error_arity(argc, i, i);
+    is_variadic = rb_iv_get(self, "@is_variadic");
+
+    n_arg_types = RARRAY_LENINT(arg_types);
+    n_fixed_args = n_arg_types;
+    if (RTEST(is_variadic)) {
+        if (argc < n_arg_types) {
+            rb_error_arity(argc, n_arg_types, UNLIMITED_ARGUMENTS);
+        }
+        if (((argc - n_arg_types) % 2) != 0) {
+            rb_raise(rb_eArgError,
+                     "variadic arguments must be type and value pairs: "
+                     "%"PRIsVALUE,
+                     rb_ary_new_from_values(argc, argv));
+        }
+        n_call_args = n_arg_types + ((argc - n_arg_types) / 2);
     }
+    else {
+        if (argc != n_arg_types) {
+            rb_error_arity(argc, n_arg_types, n_arg_types);
+        }
+        n_call_args = n_arg_types;
+    }
+    Check_Max_Args("the number of arguments", n_call_args);
 
     TypedData_Get_Struct(self, ffi_cif, &function_data_type, args.cif);
 
-    if (rb_safe_level() >= 1) {
-	for (i = 0; i < argc; i++) {
-	    VALUE src = argv[i];
-	    if (OBJ_TAINTED(src)) {
-		rb_raise(rb_eSecurityError, "tainted parameter not allowed");
-	    }
-	}
+    if (is_variadic && args.cif->arg_types) {
+        xfree(args.cif->arg_types);
+        args.cif->arg_types = NULL;
+    }
+
+    if (!args.cif->arg_types) {
+        VALUE fixed_arg_types = arg_types;
+        VALUE return_type;
+        int c_return_type;
+        ffi_type *ffi_return_type;
+        ffi_type **ffi_arg_types;
+        ffi_status result;
+
+        arg_types = rb_ary_dup(fixed_arg_types);
+        for (i = n_fixed_args; i < argc; i += 2) {
+          VALUE arg_type = argv[i];
+          int c_arg_type;
+          arg_type = rb_fiddle_type_ensure(arg_type);
+          c_arg_type = NUM2INT(arg_type);
+          (void)INT2FFI_TYPE(c_arg_type); /* raise */
+          rb_ary_push(arg_types, INT2FIX(c_arg_type));
+        }
+
+        return_type = rb_iv_get(self, "@return_type");
+        c_return_type = FIX2INT(return_type);
+        ffi_return_type = INT2FFI_TYPE(c_return_type);
+
+        ffi_arg_types = xcalloc(n_call_args + 1, sizeof(ffi_type *));
+        for (i_call = 0; i_call < n_call_args; i_call++) {
+            VALUE arg_type;
+            int c_arg_type;
+            arg_type = RARRAY_AREF(arg_types, i_call);
+            c_arg_type = FIX2INT(arg_type);
+            ffi_arg_types[i_call] = INT2FFI_TYPE(c_arg_type);
+        }
+        ffi_arg_types[i_call] = NULL;
+
+        if (is_variadic) {
+#ifdef HAVE_FFI_PREP_CIF_VAR
+            result = ffi_prep_cif_var(args.cif,
+                                      FIX2INT(abi),
+                                      n_fixed_args,
+                                      n_call_args,
+                                      ffi_return_type,
+                                      ffi_arg_types);
+#else
+            /* This code is never used because ffi_prep_cif_var()
+             * availability check is done in #initialize. */
+            result = FFI_BAD_TYPEDEF;
+#endif
+        }
+        else {
+            result = ffi_prep_cif(args.cif,
+                                  FIX2INT(abi),
+                                  n_call_args,
+                                  ffi_return_type,
+                                  ffi_arg_types);
+        }
+        if (result != FFI_OK) {
+            xfree(ffi_arg_types);
+            args.cif->arg_types = NULL;
+            rb_raise(rb_eRuntimeError, "error creating CIF %d", result);
+        }
     }
 
     generic_args = ALLOCV(alloc_buffer,
-	(size_t)(argc + 1) * sizeof(void *) + (size_t)argc * sizeof(fiddle_generic));
+                          sizeof(fiddle_generic) * n_call_args +
+                          sizeof(void *) * (n_call_args + 1));
     args.values = (void **)((char *)generic_args +
-			    (size_t)argc * sizeof(fiddle_generic));
-
-    for (i = 0; i < argc; i++) {
-	VALUE type = RARRAY_AREF(types, i);
-	VALUE src = argv[i];
-	int argtype = FIX2INT(type);
-
-	if (argtype == TYPE_VOIDP) {
-	    if(NIL_P(src)) {
-		src = INT2FIX(0);
-	    } else if(cPointer != CLASS_OF(src)) {
-		src = rb_funcall(cPointer, rb_intern("[]"), 1, src);
-	    }
-	    src = rb_Integer(src);
-	}
-
-	VALUE2GENERIC(argtype, src, &generic_args[i]);
-	args.values[i] = (void *)&generic_args[i];
+                            sizeof(fiddle_generic) * n_call_args);
+
+    for (i = 0, i_call = 0;
+         i < argc && i_call < n_call_args;
+         i++, i_call++) {
+        VALUE arg_type;
+        int c_arg_type;
+        VALUE original_src;
+        VALUE src;
+        arg_type = RARRAY_AREF(arg_types, i_call);
+        c_arg_type = FIX2INT(arg_type);
+        if (i >= n_fixed_args) {
+            i++;
+        }
+        src = argv[i];
+
+        if (c_arg_type == TYPE_VOIDP) {
+            if (NIL_P(src)) {
+                src = INT2FIX(0);
+            }
+            else if (cPointer != CLASS_OF(src)) {
+                src = rb_funcall(cPointer, rb_intern("[]"), 1, src);
+                if (NIL_P(converted_args)) {
+                    converted_args = rb_ary_new();
+                }
+                rb_ary_push(converted_args, src);
+            }
+            src = rb_Integer(src);
+        }
+
+        original_src = src;
+        VALUE2GENERIC(c_arg_type, src, &generic_args[i_call]);
+        if (src != original_src) {
+            if (NIL_P(converted_args)) {
+                converted_args = rb_ary_new();
+            }
+            rb_ary_push(converted_args, src);
+        }
+        args.values[i_call] = (void *)&generic_args[i_call];
     }
-    args.values[argc] = NULL;
-    args.fn = NUM2PTR(cfunc);
+    args.values[i_call] = NULL;
+    args.fn = (void(*)(void))NUM2PTR(cfunc);
 
     (void)rb_thread_call_without_gvl(nogvl_ffi_call, &args, 0, 0);