fiddle 1.0.0.beta2 → 1.0.4

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/memory_view.c

@@ -0,0 +1,254 @@
+#include <stdbool.h>
+#include <ruby/ruby.h>
+
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+# include <ruby/memory_view.h>
+#endif
+
+#if SIZEOF_INTPTR_T == SIZEOF_LONG_LONG
+#   define INTPTR2NUM LL2NUM
+#   define UINTPTR2NUM ULL2NUM
+#elif SIZEOF_INTPTR_T == SIZEOF_LONG
+#   define INTPTR2NUM LONG2NUM
+#   define UINTPTR2NUM ULONG2NUM
+#else
+#   define INTPTR2NUM INT2NUM
+#   define UINTPTR2NUM UINT2NUM
+#endif
+
+#include <fiddle.h>
+
+#ifdef FIDDLE_MEMORY_VIEW
+VALUE rb_cMemoryView = Qnil;
+
+struct memview_data {
+    rb_memory_view_t view;
+    rb_memory_view_item_component_t *members;
+    size_t n_members;
+};
+
+static void
+fiddle_memview_mark(void *ptr)
+{
+    const struct memview_data *data = ptr;
+    rb_gc_mark(data->view.obj);
+}
+
+static void
+fiddle_memview_free(void *ptr)
+{
+    struct memview_data *data = ptr;
+    rb_memory_view_release(&data->view);
+    if (data->members)
+        xfree(data->members);
+    xfree(ptr);
+}
+
+static size_t
+fiddle_memview_memsize(const void *ptr)
+{
+    const struct memview_data *data = ptr;
+    return sizeof(*data) + sizeof(rb_memory_view_item_component_t)*data->n_members + (size_t)data->view.len;
+}
+
+static const rb_data_type_t fiddle_memview_data_type = {
+    "fiddle/memory_view",
+    {fiddle_memview_mark, fiddle_memview_free, fiddle_memview_memsize,},
+};
+
+static VALUE
+rb_fiddle_memview_s_allocate(VALUE klass)
+{
+    struct memview_data *data;
+    VALUE obj = TypedData_Make_Struct(klass, struct memview_data, &fiddle_memview_data_type, data);
+    data->view.obj = Qnil;
+    data->members = NULL;
+    data->n_members = 0;
+    return obj;
+}
+
+static VALUE
+rb_fiddle_memview_initialize(VALUE obj, VALUE target)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (!rb_memory_view_get(target, &data->view, 0)) {
+        rb_raise(rb_eArgError, "Unable to get a memory view from %+"PRIsVALUE, target);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rb_fiddle_memview_get_obj(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    return data->view.obj;
+}
+
+static VALUE
+rb_fiddle_memview_get_length(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    return SSIZET2NUM(data->view.len);
+}
+
+static VALUE
+rb_fiddle_memview_get_readonly(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    return data->view.readonly ? Qtrue : Qfalse;
+}
+
+static VALUE
+rb_fiddle_memview_get_format(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    return data->view.format == NULL ? Qnil : rb_str_new_cstr(data->view.format);
+}
+
+static VALUE
+rb_fiddle_memview_get_item_size(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    return SSIZET2NUM(data->view.item_size);
+}
+
+static VALUE
+rb_fiddle_memview_get_ndim(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    return SSIZET2NUM(data->view.ndim);
+}
+
+static VALUE
+rb_fiddle_memview_get_shape(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    if (data->view.shape == NULL) return Qnil;
+
+    const ssize_t ndim = data->view.ndim;
+    VALUE shape = rb_ary_new_capa(ndim);
+    ssize_t i;
+    for (i = 0; i < ndim; ++i) {
+        rb_ary_push(shape, SSIZET2NUM(data->view.shape[i]));
+    }
+    return shape;
+}
+
+static VALUE
+rb_fiddle_memview_get_strides(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    if (data->view.strides == NULL) return Qnil;
+
+    const ssize_t ndim = data->view.ndim;
+    VALUE strides = rb_ary_new_capa(ndim);
+    ssize_t i;
+    for (i = 0; i < ndim; ++i) {
+        rb_ary_push(strides, SSIZET2NUM(data->view.strides[i]));
+    }
+    return strides;
+}
+
+static VALUE
+rb_fiddle_memview_get_sub_offsets(VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+    if (data->view.sub_offsets == NULL) return Qnil;
+
+    const ssize_t ndim = data->view.ndim;
+    VALUE sub_offsets = rb_ary_new_capa(ndim);
+    ssize_t i;
+    for (i = 0; i < ndim; ++i) {
+        rb_ary_push(sub_offsets, SSIZET2NUM(data->view.sub_offsets[i]));
+    }
+    return sub_offsets;
+}
+
+static VALUE
+rb_fiddle_memview_aref(int argc, VALUE *argv, VALUE obj)
+{
+    struct memview_data *data;
+    TypedData_Get_Struct(obj, struct memview_data, &fiddle_memview_data_type, data);
+
+    if (NIL_P(data->view.obj)) return Qnil;
+
+    const ssize_t ndim = data->view.ndim;
+    if (argc != ndim) {
+        rb_raise(rb_eIndexError, "wrong number of index (%d for %"PRIdSIZE")", argc, ndim);
+    }
+
+    VALUE indices_v = 0;
+    ssize_t *indices = ALLOCV_N(ssize_t, indices_v, ndim);
+
+    ssize_t i;
+    for (i = 0; i < ndim; ++i) {
+        ssize_t x = NUM2SSIZET(argv[i]);
+        indices[i] = x;
+    }
+
+    uint8_t *ptr = rb_memory_view_get_item_pointer(&data->view, indices);
+    ALLOCV_END(indices_v);
+
+    if (data->view.format == NULL) {
+        return INT2FIX(*ptr);
+    }
+
+    if (!data->members) {
+        const char *err;
+        if (rb_memory_view_parse_item_format(data->view.format, &data->members, &data->n_members, &err) < 0) {
+            rb_raise(rb_eRuntimeError, "Unable to recognize item format at %"PRIdSIZE" in \"%s\"",
+                     err - data->view.format, data->view.format);
+        }
+    }
+
+    return rb_memory_view_extract_item_members(ptr, data->members, data->n_members);
+}
+
+void
+Init_fiddle_memory_view(void)
+{
+    rb_cMemoryView = rb_define_class_under(mFiddle, "MemoryView", rb_cObject);
+    rb_define_alloc_func(rb_cMemoryView, rb_fiddle_memview_s_allocate);
+    rb_define_method(rb_cMemoryView, "initialize", rb_fiddle_memview_initialize, 1);
+    rb_define_method(rb_cMemoryView, "obj", rb_fiddle_memview_get_obj, 0);
+    rb_define_method(rb_cMemoryView, "length", rb_fiddle_memview_get_length, 0);
+    rb_define_method(rb_cMemoryView, "readonly?", rb_fiddle_memview_get_readonly, 0);
+    rb_define_method(rb_cMemoryView, "format", rb_fiddle_memview_get_format, 0);
+    rb_define_method(rb_cMemoryView, "item_size", rb_fiddle_memview_get_item_size, 0);
+    rb_define_method(rb_cMemoryView, "ndim", rb_fiddle_memview_get_ndim, 0);
+    rb_define_method(rb_cMemoryView, "shape", rb_fiddle_memview_get_shape, 0);
+    rb_define_method(rb_cMemoryView, "strides", rb_fiddle_memview_get_strides, 0);
+    rb_define_method(rb_cMemoryView, "sub_offsets", rb_fiddle_memview_get_sub_offsets, 0);
+    rb_define_method(rb_cMemoryView, "[]", rb_fiddle_memview_aref, -1);
+}
+
+#endif /* FIDDLE_MEMORY_VIEW */

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