ffi 1.1.3 → 1.1.4

data/Rakefile

@@ -77,7 +77,7 @@ PROJ.name = 'ffi'
 PROJ.authors = 'Wayne Meissner'
 PROJ.email = 'wmeissner@gmail.com'
 PROJ.url = 'http://wiki.github.com/ffi/ffi'
-PROJ.version = '1.1.3'
+PROJ.version = '1.1.4'
 PROJ.rubyforge.name = 'ffi'
 PROJ.readme_file = 'README.rdoc'
 

data/ext/ffi_c/AbstractMemory.c

@@ -651,25 +651,24 @@ memory_op_put_strptr(AbstractMemory* ptr, long offset, VALUE value)
 
 static MemoryOp memory_op_strptr = { memory_op_get_strptr, memory_op_put_strptr };
 
-//static MemoryOp memory_op_pointer = { memory_op_get_pointer, memory_op_put_pointer };
 
 MemoryOps rbffi_AbstractMemoryOps = {
-    &memory_op_int8, //.int8
-    &memory_op_uint8, //.uint8
-    &memory_op_int16, //.int16
-    &memory_op_uint16, //.uint16
-    &memory_op_int32, //.int32
-    &memory_op_uint32, //.uint32
-    &memory_op_int64, //.int64
-    &memory_op_uint64, //.uint64
-    &memory_op_long, //.slong
-    &memory_op_ulong, //.uslong
-    &memory_op_float32, //.float32
-    &memory_op_float64, //.float64
-    &memory_op_longdouble, //.longdouble
-    &memory_op_pointer, //.pointer
-    &memory_op_strptr, //.strptr
-    &memory_op_bool //.boolOp
+    &memory_op_int8, /*.int8 */
+    &memory_op_uint8, /* .uint8 */
+    &memory_op_int16, /* .int16 */
+    &memory_op_uint16, /* .uint16 */
+    &memory_op_int32, /* .int32 */
+    &memory_op_uint32, /* .uint32 */
+    &memory_op_int64, /* .int64 */
+    &memory_op_uint64, /* .uint64 */
+    &memory_op_long, /* .slong */
+    &memory_op_ulong, /* .uslong */
+    &memory_op_float32, /* .float32 */
+    &memory_op_float64, /* .float64 */
+    &memory_op_longdouble, /* .longdouble */
+    &memory_op_pointer, /* .pointer */
+    &memory_op_strptr, /* .strptr */
+    &memory_op_bool /* .boolOp */
 };
 
 void

data/ext/ffi_c/AbstractMemory.h

@@ -70,7 +70,7 @@ typedef struct {
 } MemoryOps;
 
 struct AbstractMemory_ {
-    char* address; // Use char* instead of void* to ensure adding to it works correctly
+    char* address; /* Use char* instead of void* to ensure adding to it works correctly */
     long size;
     int flags;
     int typeSize;

data/ext/ffi_c/Buffer.c

@@ -41,7 +41,7 @@ typedef struct Buffer {
     union {
         VALUE rbParent; /* link to parent buffer */
         char* storage; /* start of malloc area */
-        long embed[BUFFER_EMBED_MAXLEN / sizeof(long)]; // storage for tiny allocations
+        long embed[BUFFER_EMBED_MAXLEN / sizeof(long)]; /* storage for tiny allocations */
     } data;
 } Buffer;
 
@@ -151,7 +151,7 @@ buffer_initialize_copy(VALUE self, VALUE other)
     dst->memory.size = src->size;
     dst->memory.typeSize = src->typeSize;
     
-    // finally, copy the actual buffer contents
+    /* finally, copy the actual buffer contents */
     memcpy(dst->memory.address, src->address, src->size);
 
     return self;

data/ext/ffi_c/Call.c

@@ -314,8 +314,10 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
     if (unlikely(fnInfo->blocking)) {
         BlockingCall* bc;
 
-        // due to the way thread switching works on older ruby variants, we
-        // cannot allocate anything passed to the blocking function on the stack
+        /*
+         * due to the way thread switching works on older ruby variants, we
+         * cannot allocate anything passed to the blocking function on the stack
+         */
         ffiValues = ALLOC_N(void *, fnInfo->parameterCount);
         params = ALLOC_N(FFIStorage, fnInfo->parameterCount);
         bc = ALLOC_N(BlockingCall, 1);
@@ -432,14 +434,13 @@ callback_param(VALUE proc, VALUE cbInfo)
         return NULL ;
     }
 
-    // Handle Function pointers here
+    /* Handle Function pointers here */
     if (rb_obj_is_kind_of(proc, rbffi_FunctionClass)) {
         AbstractMemory* ptr;
         Data_Get_Struct(proc, AbstractMemory, ptr);
         return ptr->address;
     }
 
-    //callback = rbffi_NativeCallback_ForProc(proc, cbInfo);
     callback = rbffi_Function_ForProc(cbInfo, proc);
     RB_GC_GUARD(callback);
 

data/ext/ffi_c/ClosurePool.c

@@ -206,7 +206,7 @@ rbffi_Closure_Free(Closure* closure)
     if (closure != NULL) {
         ClosurePool* pool = closure->pool;
         long refcnt;
-        // Just push it on the front of the free list
+        /* Just push it on the front of the free list */
         closure->next = pool->list;
         pool->list = closure;
         refcnt = --(pool->refcnt);

data/ext/ffi_c/DynamicLibrary.c

@@ -155,7 +155,7 @@ library_dlerror(VALUE self)
 static void
 library_free(Library* library)
 {
-    // dlclose() on MacOS tends to segfault - avoid it
+    /* dlclose() on MacOS tends to segfault - avoid it */
 #ifndef __APPLE__
     if (library->handle != NULL) {
         dl_close(library->handle);
@@ -270,7 +270,7 @@ rbffi_DynamicLibrary_Init(VALUE moduleFFI)
      * Document-const: FFI::NativeLibrary
      * Backward compatibility for FFI::DynamicLibrary
      */
-    rb_define_const(moduleFFI, "NativeLibrary", LibraryClass); // backwards compat library
+    rb_define_const(moduleFFI, "NativeLibrary", LibraryClass); /* backwards compat library */
     rb_define_alloc_func(LibraryClass, library_allocate);
     rb_define_singleton_method(LibraryClass, "open", library_open, 2);
     rb_define_singleton_method(LibraryClass, "last_error", library_dlerror, 0);

data/ext/ffi_c/Function.c

@@ -199,11 +199,11 @@ function_initialize(int argc, VALUE* argv, VALUE self)
 
     nargs = rb_scan_args(argc, argv, "22", &rbReturnType, &rbParamTypes, &rbProc, &rbOptions);
 
-    //
-    // Callback with block,
-    // e.g. Function.new(:int, [ :int ]) { |i| blah }
-    // or   Function.new(:int, [ :int ], { :convention => :stdcall }) { |i| blah }
-    //
+    /*
+     * Callback with block,
+     * e.g. Function.new(:int, [ :int ]) { |i| blah }
+     * or   Function.new(:int, [ :int ], { :convention => :stdcall }) { |i| blah }
+     */
     if (rb_block_given_p()) {
         if (nargs > 3) {
             rb_raise(rb_eArgError, "cannot create function with both proc/address and block");
@@ -211,11 +211,12 @@ function_initialize(int argc, VALUE* argv, VALUE self)
         rbOptions = rbProc;
         rbProc = rb_block_proc();
     } else {
-        // Callback with proc, or Function with address
-        // e.g. Function.new(:int, [ :int ], Proc.new { |i| })
-        //      Function.new(:int, [ :int ], Proc.new { |i| }, { :convention => :stdcall })
-        //      Function.new(:int, [ :int ], addr)
-        //      Function.new(:int, [ :int ], addr, { :convention => :stdcall })
+        /* Callback with proc, or Function with address
+         * e.g. Function.new(:int, [ :int ], Proc.new { |i| })
+         *      Function.new(:int, [ :int ], Proc.new { |i| }, { :convention => :stdcall })
+         *      Function.new(:int, [ :int ], addr)
+         *      Function.new(:int, [ :int ], addr, { :convention => :stdcall })
+         */
     }
     
     infoArgv[0] = rbReturnType;
@@ -381,9 +382,9 @@ function_attach(VALUE self, VALUE module, VALUE name)
         fn->methodHandle = rbffi_MethodHandle_Alloc(fn->info, fn->base.memory.address);
     }
 
-    //
-    // Stash the Function in a module variable so it does not get garbage collected
-    //
+    /*
+     * Stash the Function in a module variable so it does not get garbage collected
+     */
     snprintf(var, sizeof(var), "@@%s", StringValueCStr(name));
     rb_cv_set(module, var, self);
 
@@ -470,7 +471,7 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
         pthread_mutex_init(&cb.async_mutex, NULL);
         pthread_cond_init(&cb.async_cond, NULL);
 
-        // Now signal the async callback thread
+        /* Now signal the async callback thread */
         pthread_mutex_lock(&async_cb_mutex);
         empty = async_cb_list == NULL;
         cb.next = async_cb_list;
@@ -478,7 +479,7 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
         pthread_mutex_unlock(&async_cb_mutex);
 
 #if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
-        // Only signal if the list was empty
+        /* Only signal if the list was empty */
         if (empty) {
             char c;
             write(async_cb_pipe[1], &c, 1);
@@ -487,7 +488,7 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
         pthread_cond_signal(&async_cb_cond);
 #endif
 
-        // Wait for the thread executing the ruby callback to signal it is done
+        /* Wait for the thread executing the ruby callback to signal it is done */
         pthread_mutex_lock(&cb.async_mutex);
         while (!cb.done) {
             pthread_cond_wait(&cb.async_cond, &cb.async_mutex);
@@ -502,7 +503,7 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
 
         cb.async_event = CreateEvent(NULL, FALSE, FALSE, NULL);
 
-        // Now signal the async callback thread
+        /* Now signal the async callback thread */
         EnterCriticalSection(&async_cb_lock);
         empty = async_cb_list == NULL;
         cb.next = async_cb_list;
@@ -510,7 +511,7 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
         LeaveCriticalSection(&async_cb_lock);
 
 #if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
-        // Only signal if the list was empty
+        /* Only signal if the list was empty */
         if (empty) {
             char c;
             write(async_cb_pipe[1], &c, 1);
@@ -519,7 +520,7 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
         SetEvent(async_cb_cond);
 #endif
 
-        // Wait for the thread executing the ruby callback to signal it is done
+        /* Wait for the thread executing the ruby callback to signal it is done */
         WaitForSingleObject(cb.async_event, INFINITE);
         CloseHandle(cb.async_event);
 #endif
@@ -545,7 +546,7 @@ async_cb_event(void* unused)
     while (!w.stop) {
         rb_thread_blocking_region(async_cb_wait, &w, async_cb_stop, &w);
         if (w.cb != NULL) {
-            // Start up a new ruby thread to run the ruby callback
+            /* Start up a new ruby thread to run the ruby callback */
             rb_thread_create(async_cb_call, w.cb);
         }
     }
@@ -574,7 +575,7 @@ async_cb_event(void* unused)
 
         while (cb != NULL) {
             struct gvl_callback* next = cb->next;
-            // Start up a new ruby thread to run the ruby callback
+            /* Start up a new ruby thread to run the ruby callback */
             rb_thread_create(async_cb_call, cb);
             cb = next;
         }
@@ -606,7 +607,7 @@ async_cb_event(void* unused)
 
         while (cb != NULL) {
             struct gvl_callback* next = cb->next;
-            // Start up a new ruby thread to run the ruby callback
+            /* Start up a new ruby thread to run the ruby callback */
             rb_thread_create(async_cb_call, cb);
             cb = next;
         }
@@ -696,7 +697,7 @@ async_cb_call(void *data)
 
     callback_with_gvl(cb);
 
-    // Signal the original native thread that the ruby code has completed
+    /* Signal the original native thread that the ruby code has completed */
 #ifdef _WIN32
     SetEvent(cb->async_event);
 #else
@@ -799,7 +800,7 @@ callback_with_gvl(void* data)
                 break;
         }
 
-        // Convert the native value into a custom ruby value
+        /* Convert the native value into a custom ruby value */
         if (unlikely(cbInfo->parameterTypes[i]->nativeType == NATIVE_MAPPED)) {
             VALUE values[] = { param, Qnil };
             param = rb_funcall2(((MappedType *) cbInfo->parameterTypes[i])->rbConverter, id_from_native, 2, values);
@@ -853,7 +854,7 @@ callback_with_gvl(void* data)
             if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rbffi_PointerClass)) {
                 *((void **) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
             } else {
-                // Default to returning NULL if not a value pointer object.  handles nil case as well
+                /* Default to returning NULL if not a value pointer object.  handles nil case as well */
                 *((void **) retval) = NULL;
             }
             break;

data/ext/ffi_c/Function.h

@@ -41,7 +41,7 @@ typedef struct FunctionType_ FunctionType;
 #include "ClosurePool.h"
 
 struct FunctionType_ {
-    Type type; // The native type of a FunctionInfo object
+    Type type; /* The native type of a FunctionInfo object */
     VALUE rbReturnType;
     VALUE rbParameterTypes;
 

data/ext/ffi_c/MemoryPointer.c

@@ -144,8 +144,9 @@ memptr_mark(Pointer* ptr)
 }
 
 static VALUE
-memptr_s_from_string(VALUE klass, VALUE s)
+memptr_s_from_string(VALUE klass, VALUE to_str)
 {
+    VALUE s = StringValue(to_str);
     VALUE args[] = { INT2FIX(1), LONG2NUM(RSTRING_LEN(s) + 1), Qfalse };
     VALUE obj = rb_class_new_instance(3, args, klass);
     rb_funcall(obj, rb_intern("put_string"), 2, INT2FIX(0), s);

data/ext/ffi_c/MethodHandle.c

@@ -311,7 +311,7 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
     caddr_t ptr = (caddr_t) code;
 
     memcpy(ptr, &ffi_trampoline, trampoline_size());
-    // Patch the context and function addresses into the stub code
+    /* Patch the context and function addresses into the stub code */
     *(intptr_t *)(ptr + trampoline_ctx_offset) = (intptr_t) closure;
     *(intptr_t *)(ptr + trampoline_func_offset) = (intptr_t) custom_trampoline;
 

data/ext/ffi_c/Pointer.c

@@ -181,7 +181,7 @@ ptr_initialize_copy(VALUE self, VALUE other)
     dst->memory.size = src->size;
     dst->memory.typeSize = src->typeSize;
     
-    // finally, copy the actual memory contents
+    /* finally, copy the actual memory contents */
     memcpy(dst->memory.address, src->address, src->size);
 
     return self;

data/ext/ffi_c/Struct.c

@@ -139,11 +139,11 @@ struct_initialize_copy(VALUE self, VALUE other)
     dst->rbLayout = src->rbLayout;
     dst->layout = src->layout;
     
-    //
-    // A new MemoryPointer instance is allocated here instead of just calling 
-    // #dup on rbPointer, since the Pointer may not know its length, or may
-    // be longer than just this struct.
-    //
+    /*
+     * A new MemoryPointer instance is allocated here instead of just calling
+     * #dup on rbPointer, since the Pointer may not know its length, or may
+     * be longer than just this struct.
+     */
     if (src->pointer->address != NULL) {
         dst->rbPointer = rbffi_MemoryPointer_NewInstance(1, src->layout->size, false);
         dst->pointer = MEMORY(dst->rbPointer);

data/ext/ffi_c/StructByValue.c

@@ -87,7 +87,7 @@ sbv_initialize(VALUE self, VALUE rbStructClass)
     sbv->rbStructClass = rbStructClass;
     sbv->rbStructLayout = rbLayout;
 
-    // We can just use everything from the ffi_type directly
+    /* We can just use everything from the ffi_type directly */
     *sbv->base.ffiType = *layout->base.ffiType;
     
     return self;

data/ext/ffi_c/StructLayout.c

@@ -281,7 +281,7 @@ array_field_put(VALUE self, VALUE pointer, VALUE value)
             rb_raise(rb_eIndexError, "array too large");
         }
 
-        // clear the contents in case of a short write
+        /* clear the contents in case of a short write */
         checkWrite(memory);
         checkBounds(memory, f->offset, f->type->ffiType->size);
         if (count < array->length) {
@@ -289,7 +289,7 @@ array_field_put(VALUE self, VALUE pointer, VALUE value)
                     0, (array->length - count) * array->componentType->ffiType->size);
         }
 
-        // now copy each element in
+        /* now copy each element in */
         if ((op = get_memory_op(array->componentType)) != NULL) {
 
             for (i = 0; i < count; ++i) {
@@ -357,7 +357,7 @@ struct_layout_initialize(VALUE self, VALUE fields, VALUE size, VALUE align)
     layout->fieldCount = (int) RARRAY_LEN(fields);
     layout->rbFieldMap = rb_hash_new();
     layout->rbFieldNames = rb_ary_new2(layout->fieldCount);
-    layout->size = FFI_ALIGN(NUM2INT(size),  NUM2INT(align));
+    layout->size = (int) FFI_ALIGN(NUM2INT(size),  NUM2INT(align));
     layout->align = NUM2INT(align);
     layout->fields = xcalloc(layout->fieldCount, sizeof(StructField *));
     layout->ffiTypes = xcalloc(layout->fieldCount + 1, sizeof(ffi_type *));
@@ -423,7 +423,7 @@ struct_layout_union_bang(VALUE self)
 
     for (i = 0; alignment_types[i] != NULL; ++i) {
         if (alignment_types[i]->alignment == layout->align) {
-            t = alignment_types[i];
+            t = (ffi_type *) alignment_types[i];
             break;
         }
     }
@@ -432,7 +432,7 @@ struct_layout_union_bang(VALUE self)
         return Qnil;
     }
 
-    count = layout->size / t->size;
+    count = (int) layout->size / t->size;
     xfree(layout->ffiTypes);
     layout->ffiTypes = xcalloc(count + 1, sizeof(ffi_type *));
     layout->base.ffiType->elements = layout->ffiTypes;

data/ext/ffi_c/Thread.c

@@ -76,7 +76,7 @@ rbffi_thread_has_gvl_p(void)
     return rbffi_active_thread.valid && pthread_equal(rbffi_active_thread.id, pthread_self());
 #endif
 }
-#endif // HAVE_RUBY_THREAD_HAS_GVL_P
+#endif /* HAVE_RUBY_THREAD_HAS_GVL_P */
 
 #ifndef HAVE_RB_THREAD_BLOCKING_REGION
 
@@ -322,5 +322,5 @@ rbffi_thread_blocking_region(VALUE (*func)(void *), void *data1, void (*ubf)(voi
 
 #endif /* !_WIN32 */
 
-#endif // HAVE_RB_THREAD_BLOCKING_REGION
+#endif /* HAVE_RB_THREAD_BLOCKING_REGION */
 

data/ext/ffi_c/Type.c

@@ -193,7 +193,7 @@ rbffi_type_size(VALUE type)
             }
         }
 
-        // Not found - call up to the ruby version to resolve
+        /* Not found - call up to the ruby version to resolve */
         return NUM2INT(rb_funcall2(rbffi_FFIModule, id_type_size, 1, &type));
     
     } else {
@@ -321,14 +321,14 @@ rbffi_Type_Init(VALUE moduleFFI)
     rb_define_method(rbffi_TypeClass, "alignment", type_alignment, 0);
     rb_define_method(rbffi_TypeClass, "inspect", type_inspect, 0);
 
-    // Make Type::Builtin non-allocatable
+    /* Make Type::Builtin non-allocatable */
     rb_undef_method(CLASS_OF(classBuiltinType), "new");
     rb_define_method(classBuiltinType, "inspect", builtin_type_inspect, 0);
     
     rb_global_variable(&rbffi_TypeClass);
     rb_global_variable(&classBuiltinType);
 
-    // Define all the builtin types
+    /* Define all the builtin types */
     #define T(x, ffiType) do { \
         VALUE t = Qnil; \
         rb_define_const(rbffi_TypeClass, #x, t = builtin_type_new(classBuiltinType, NATIVE_##x, ffiType, #x)); \

data/ext/ffi_c/Types.c

@@ -98,8 +98,10 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr)
         }
 
         case NATIVE_MAPPED: {
-            // For mapped types, first convert to the real native type, then upcall to
-            // ruby to convert to the expected return type
+            /*
+             * For mapped types, first convert to the real native type, then upcall to
+             * ruby to convert to the expected return type
+             */
             MappedType* m = (MappedType *) type;
             VALUE values[2], rbReturnValue;
 

data/ext/ffi_c/ffi.c

@@ -59,7 +59,7 @@ Init_ffi_c(void) {
     rb_global_variable(&moduleFFI);
 
 
-    // FFI::Type needs to be initialized before most other classes
+    /* FFI::Type needs to be initialized before most other classes */
     rbffi_Type_Init(moduleFFI);
 
     rbffi_DataConverter_Init(moduleFFI);

data/spec/ffi/rbx/memory_pointer_spec.rb

@@ -16,6 +16,10 @@ describe "MemoryPointer" do
     m.type_size.should eq 1
   end
 
+  it "does not make a pointer from non-strings" do
+    expect { FFI::MemoryPointer.from_string(nil) }.to raise_error(TypeError)
+  end
+
   it "makes a pointer from a string with multibyte characters" do
     m = FFI::MemoryPointer.from_string("ぱんだ")
     m.total.should eq 10

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ffi
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 27
   prerelease: 
   segments: 
   - 1
   - 1
-  - 3
-  version: 1.1.3
+  - 4
+  version: 1.1.4
 platform: ruby
 authors: 
 - Wayne Meissner
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-31 00:00:00 +10:00
+date: 2012-08-04 00:00:00 +10:00
 default_executable: 
 dependencies: []