fiddle 1.0.0.beta1 → 1.0.3

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);
 

data/ext/fiddle/handle.c

@@ -1,8 +1,6 @@
 #include <ruby.h>
 #include <fiddle.h>
 
-#define SafeStringValueCStr(v) (rb_check_safe_obj(rb_string_value(&v)), StringValueCStr(v))
-
 VALUE rb_cHandle;
 
 struct dl_handle {
@@ -76,14 +74,14 @@ rb_fiddle_handle_close(VALUE self)
 	/* Check dlclose for successful return value */
 	if(ret) {
 #if defined(HAVE_DLERROR)
-	    rb_raise(rb_eFiddleError, "%s", dlerror());
+	    rb_raise(rb_eFiddleDLError, "%s", dlerror());
 #else
-	    rb_raise(rb_eFiddleError, "could not close handle");
+	    rb_raise(rb_eFiddleDLError, "could not close handle");
 #endif
 	}
 	return INT2NUM(ret);
     }
-    rb_raise(rb_eFiddleError, "dlclose() called too many times");
+    rb_raise(rb_eFiddleDLError, "dlclose() called too many times");
 
     UNREACHABLE;
 }
@@ -145,11 +143,11 @@ rb_fiddle_handle_initialize(int argc, VALUE argv[], VALUE self)
 	cflag = RTLD_LAZY | RTLD_GLOBAL;
 	break;
       case 1:
-	clib = NIL_P(lib) ? NULL : SafeStringValueCStr(lib);
+	clib = NIL_P(lib) ? NULL : StringValueCStr(lib);
 	cflag = RTLD_LAZY | RTLD_GLOBAL;
 	break;
       case 2:
-	clib = NIL_P(lib) ? NULL : SafeStringValueCStr(lib);
+	clib = NIL_P(lib) ? NULL : StringValueCStr(lib);
 	cflag = NUM2INT(flag);
 	break;
       default:
@@ -179,12 +177,12 @@ rb_fiddle_handle_initialize(int argc, VALUE argv[], VALUE self)
 	ptr = dlopen(clib, cflag);
 #if defined(HAVE_DLERROR)
     if( !ptr && (err = dlerror()) ){
-	rb_raise(rb_eFiddleError, "%s", err);
+	rb_raise(rb_eFiddleDLError, "%s", err);
     }
 #else
     if( !ptr ){
 	err = dlerror();
-	rb_raise(rb_eFiddleError, "%s", err);
+	rb_raise(rb_eFiddleDLError, "%s", err);
     }
 #endif
     TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
@@ -280,7 +278,7 @@ rb_fiddle_handle_sym(VALUE self, VALUE sym)
 
     TypedData_Get_Struct(self, struct dl_handle, &fiddle_handle_data_type, fiddle_handle);
     if( ! fiddle_handle->open ){
-	rb_raise(rb_eFiddleError, "closed handle");
+	rb_raise(rb_eFiddleDLError, "closed handle");
     }
 
     return fiddle_handle_sym(fiddle_handle->ptr, sym);
@@ -319,7 +317,7 @@ fiddle_handle_sym(void *handle, VALUE symbol)
 # define CHECK_DLERROR
 #endif
     void (*func)();
-    const char *name = SafeStringValueCStr(symbol);
+    const char *name = StringValueCStr(symbol);
 
 #ifdef HAVE_DLERROR
     dlerror();
@@ -368,7 +366,7 @@ fiddle_handle_sym(void *handle, VALUE symbol)
     }
 #endif
     if( !func ){
-	rb_raise(rb_eFiddleError, "unknown symbol \"%"PRIsVALUE"\"", symbol);
+	rb_raise(rb_eFiddleDLError, "unknown symbol \"%"PRIsVALUE"\"", symbol);
     }
 
     return PTR2NUM(func);

data/ext/fiddle/pinned.c

@@ -0,0 +1,123 @@
+#include <fiddle.h>
+
+VALUE rb_cPinned;
+VALUE rb_eFiddleClearedReferenceError;
+
+struct pinned_data {
+    VALUE ptr;
+};
+
+static void
+pinned_mark(void *ptr)
+{
+    struct pinned_data *data = (struct pinned_data*)ptr;
+    /* Ensure reference is pinned */
+    if (data->ptr) {
+        rb_gc_mark(data->ptr);
+    }
+}
+
+static size_t
+pinned_memsize(const void *ptr)
+{
+    return sizeof(struct pinned_data);
+}
+
+static const rb_data_type_t pinned_data_type = {
+    "fiddle/pinned",
+    {pinned_mark, xfree, pinned_memsize, },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE
+allocate(VALUE klass)
+{
+    struct pinned_data *data;
+    VALUE obj = TypedData_Make_Struct(klass, struct pinned_data, &pinned_data_type, data);
+    data->ptr = 0;
+    return obj;
+}
+
+/*
+ * call-seq:
+ *    Fiddle::Pinned.new(object)      => pinned_object
+ *
+ * Create a new pinned object reference.  The Fiddle::Pinned instance will
+ * prevent the GC from moving +object+.
+ */
+static VALUE
+initialize(VALUE self, VALUE ref)
+{
+    struct pinned_data *data;
+    TypedData_Get_Struct(self, struct pinned_data, &pinned_data_type, data);
+    RB_OBJ_WRITE(self, &data->ptr, ref);
+    return self;
+}
+
+/*
+ * call-seq: ref
+ *
+ * Return the object that this pinned instance references.
+ */
+static VALUE
+ref(VALUE self)
+{
+    struct pinned_data *data;
+    TypedData_Get_Struct(self, struct pinned_data, &pinned_data_type, data);
+    if (data->ptr) {
+      return data->ptr;
+    } else {
+      rb_raise(rb_eFiddleClearedReferenceError, "`ref` called on a cleared object");
+    }
+}
+
+/*
+ * call-seq: clear
+ *
+ * Clear the reference to the object this is pinning.
+ */
+static VALUE
+clear(VALUE self)
+{
+    struct pinned_data *data;
+    TypedData_Get_Struct(self, struct pinned_data, &pinned_data_type, data);
+    data->ptr = 0;
+    return self;
+}
+
+/*
+ * call-seq: cleared?
+ *
+ * Returns true if the reference has been cleared, otherwise returns false.
+ */
+static VALUE
+cleared_p(VALUE self)
+{
+    struct pinned_data *data;
+    TypedData_Get_Struct(self, struct pinned_data, &pinned_data_type, data);
+    if (data->ptr) {
+        return Qfalse;
+    } else {
+        return Qtrue;
+    }
+}
+
+extern VALUE rb_eFiddleError;
+
+void
+Init_fiddle_pinned(void)
+{
+    rb_cPinned = rb_define_class_under(mFiddle, "Pinned", rb_cObject);
+    rb_define_alloc_func(rb_cPinned, allocate);
+    rb_define_method(rb_cPinned, "initialize", initialize, 1);
+    rb_define_method(rb_cPinned, "ref", ref, 0);
+    rb_define_method(rb_cPinned, "clear", clear, 0);
+    rb_define_method(rb_cPinned, "cleared?", cleared_p, 0);
+
+    /*
+     * Document-class: Fiddle::ClearedReferenceError
+     *
+     * Cleared reference exception
+     */
+    rb_eFiddleClearedReferenceError = rb_define_class_under(mFiddle, "ClearedReferenceError", rb_eFiddleError);
+}