ffi 1.2.0.dev → 1.2.0.dev2

data/Rakefile

@@ -72,7 +72,7 @@ LIBTEST = "build/libtest.#{LIBEXT}"
 BUILD_DIR = "build"
 BUILD_EXT_DIR = File.join(BUILD_DIR, "#{RbConfig::CONFIG['arch']}", 'ffi_c', RUBY_VERSION)
 
-gem_spec = eval(IO.read('ffi.gemspec'))
+gem_spec = Gem::Specification.load('ffi.gemspec')
 
 Gem::PackageTask.new(gem_spec) do |pkg|
   pkg.need_zip = true

data/ext/ffi_c/AbstractMemory.c

@@ -431,11 +431,6 @@ memory_put_string(VALUE self, VALUE offset, VALUE str)
 
     checkWrite(ptr);
     checkBounds(ptr, off, len + 1);
-    
-    if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
-        rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
-        return Qnil;
-    }
 
     memcpy(ptr->address + off, RSTRING_PTR(str), len);
     *((char *) ptr->address + off + len) = '\0';
@@ -651,25 +646,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);
@@ -375,10 +377,7 @@ getPointer(VALUE value, int type)
         return memory != NULL ? memory->address : NULL;
 
     } else if (type == T_STRING) {
-
-        if (rb_safe_level() >= 1 && OBJ_TAINTED(value)) {
-            rb_raise(rb_eSecurityError, "Unsafe string parameter");
-        }
+        
         return StringValuePtr(value);
 
     } else if (type == T_NIL) {
@@ -432,14 +431,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/Types.h

@@ -69,10 +69,6 @@ typedef enum {
 #include <ffi.h>
 #include "Type.h"
 
-#ifndef FFI_STDCALL
-#define FFI_STDCALL FFI_DEFAULT_ABI
-#endif
-
 VALUE rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr);
 void rbffi_Types_Init(VALUE moduleFFI);
 

data/ext/ffi_c/Variadic.c

@@ -219,7 +219,11 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     if (ffiReturnType == NULL) {
         rb_raise(rb_eArgError, "Invalid return type");
     }
+#ifdef HAVE_FFI_PREP_CIF_VAR
+    ffiStatus = ffi_prep_cif_var(&cif, invoker->abi, paramCount, paramCount, ffiReturnType, ffiParamTypes);
+#else
     ffiStatus = ffi_prep_cif(&cif, invoker->abi, paramCount, ffiReturnType, ffiParamTypes);
+#endif
     switch (ffiStatus) {
         case FFI_BAD_ABI:
             rb_raise(rb_eArgError, "Invalid ABI specified");

data/ext/ffi_c/extconf.rb

@@ -21,6 +21,7 @@ if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
   have_func('rb_thread_blocking_region')
   have_func('ruby_native_thread_p')
   have_func('rb_thread_call_with_gvl')
+  have_func('ffi_prep_cif_var')
   
   $defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
   $defs << "-DUSE_INTERNAL_LIBFFI" unless libffi_ok

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/ext/ffi_c/libffi.darwin.mk

@@ -25,7 +25,7 @@ ifeq ($(strip $(ARCHES)),)
 LIBFFI_BUILD_DIR = $(BUILD_DIR)/libffi-$(arch)
 # Just build the one (default) architecture
 $(LIBFFI):		
-	@mkdir -p "$(LIBFFI_BUILD_DIR)"
+	@mkdir -p "$(LIBFFI_BUILD_DIR)" "$(@D)"
 	@if [ ! -f "$(LIBFFI_BUILD_DIR)"/Makefile ]; then \
 	    echo "Configuring libffi"; \
 	    cd "$(LIBFFI_BUILD_DIR)" && \
@@ -66,7 +66,7 @@ endif
 
 $(LIBFFI):	$(LIBTARGETS)
 	# Assemble into a FAT (x86_64, i386, ppc) library
-	@mkdir -p "$(BUILD_DIR)"/libffi/.libs
+	@mkdir -p "$(@D)"
 	/usr/bin/libtool -static -o $@ \
 	    $(foreach arch, $(ARCHES),"$(BUILD_DIR)"/libffi-$(arch)/.libs/libffi_convenience.a)
 	@mkdir -p "$(LIBFFI_BUILD_DIR)"/include

data/ext/ffi_c/libffi.mk

@@ -3,7 +3,7 @@
 include ${srcdir}/libffi.gnu.mk
 
 $(LIBFFI):		
-	@mkdir -p "$(LIBFFI_BUILD_DIR)"
+	@mkdir -p "$(LIBFFI_BUILD_DIR)" "$@(D)"
 	@if [ ! -f "$(LIBFFI_BUILD_DIR)"/Makefile ]; then \
 	    echo "Configuring libffi"; \
 	    cd "$(LIBFFI_BUILD_DIR)" && \

data/gen/log

@@ -0,0 +1 @@
+/Users/wayne/src/ruby-ffi/lib/ffi/platform/x86_64-darwin/types.conf

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,14 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: ffi
 version: !ruby/object:Gem::Version 
-  hash: 286533929
+  hash: -4076106022
   prerelease: 6
   segments: 
   - 1
   - 2
   - 0
   - dev
-  version: 1.2.0.dev
+  - 2
+  version: 1.2.0.dev2
 platform: ruby
 authors: 
 - Wayne Meissner
@@ -16,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-29 00:00:00 +10:00
+date: 2012-08-12 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,6 +50,20 @@ dependencies:
         version: 0.6.0
   type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: Ruby FFI library
 email: wmeissner@gmail.com
 executables: []
@@ -389,6 +404,7 @@ files:
 - ext/ffi_c/Types.h
 - ext/ffi_c/Variadic.c
 - ext/ffi_c/win32/stdint.h
+- gen/log
 - gen/Rakefile
 - lib/ffi/autopointer.rb
 - lib/ffi/buffer.rb