fiddle 1.0.0 → 1.0.1

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

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