ffi 1.0.9-x86-mingw32 → 1.0.12.pre-x86-mingw32

data/ext/ffi_c/Function.h

@@ -25,7 +25,13 @@
 extern "C" {
 #endif
 
+#ifndef _MSC_VER
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #include <ffi.h>
 
 typedef struct FunctionType_ FunctionType;

data/ext/ffi_c/FunctionInfo.c

@@ -17,11 +17,19 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef _MSC_VER
 #include <sys/param.h>
+#endif
 #include <sys/types.h>
 #include <stdio.h>
+#ifndef _MSC_VER
 #include <stdint.h>
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #include <errno.h>
 #include <ruby.h>
 
@@ -105,7 +113,7 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
     Check_Type(rbParamTypes, T_ARRAY);
 
     Data_Get_Struct(self, FunctionType, fnInfo);
-    fnInfo->parameterCount = RARRAY_LEN(rbParamTypes);
+    fnInfo->parameterCount = (int) RARRAY_LEN(rbParamTypes);
     fnInfo->parameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->parameterTypes));
     fnInfo->ffiParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(ffi_type *));
     fnInfo->nativeParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->nativeParameterTypes));
@@ -201,10 +209,22 @@ fntype_param_types(VALUE self)
 void
 rbffi_FunctionInfo_Init(VALUE moduleFFI)
 {
+    /*
+     * Document-class: FFI::FunctionType < FFI::Type
+     */
     rbffi_FunctionTypeClass = rb_define_class_under(moduleFFI, "FunctionType", rbffi_TypeClass);
     rb_global_variable(&rbffi_FunctionTypeClass);
+    /*
+     * Document-const: FFI::CallbackInfo = FFI::FunctionType
+     */
     rb_define_const(moduleFFI, "CallbackInfo", rbffi_FunctionTypeClass);
+    /*
+     * Document-const: FFI::FunctionInfo = FFI::FunctionType
+     */
     rb_define_const(moduleFFI, "FunctionInfo", rbffi_FunctionTypeClass);
+    /*
+     * Document-const: FFI::Type::Function = FFI::FunctionType
+     */
     rb_define_const(rbffi_TypeClass, "Function", rbffi_FunctionTypeClass);
 
     rb_define_alloc_func(rbffi_FunctionTypeClass, fntype_allocate);

data/ext/ffi_c/LastError.c

@@ -18,11 +18,19 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef _MSC_VER
 #include <sys/param.h>
+#endif
 #include <sys/types.h>
 #include <stdio.h>
+#ifndef _MSC_VER
 #include <stdint.h>
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #include <errno.h>
 #include <ruby.h>
 
@@ -99,6 +107,11 @@ thread_data_get()
 #endif
 
 
+/*
+ * call-seq: error
+ * @return [Numeric]
+ * Get +errno+ value.
+ */
 static VALUE
 get_last_error(VALUE self)
 {
@@ -106,6 +119,12 @@ get_last_error(VALUE self)
 }
 
 
+/*
+ * call-seq: error(error)
+ * @param [Numeric] error
+ * @return [nil]
+ * Set +errno+ value.
+ */
 static VALUE
 set_last_error(VALUE self, VALUE error)
 {
@@ -138,6 +157,11 @@ rbffi_save_errno(void)
 void
 rbffi_LastError_Init(VALUE moduleFFI)
 {
+    /*
+     * Document-module: FFI::LastError
+     * This module defines a couple of method to set and get +errno+
+     * for current thread.
+     */
     VALUE moduleError = rb_define_module_under(moduleFFI, "LastError");
 
     rb_define_module_function(moduleError, "error", get_last_error, 0);

data/ext/ffi_c/MappedType.c

@@ -50,6 +50,12 @@ mapped_allocate(VALUE klass)
     return obj;
 }
 
+/*
+ * call-seq: initialize(converter)
+ * @param [#native_type, #to_native, #from_native] converter +converter+ must respond to
+ *  all these methods
+ * @return [self]
+ */
 static VALUE
 mapped_initialize(VALUE self, VALUE rbConverter)
 {
@@ -88,6 +94,11 @@ mapped_mark(MappedType* m)
     rb_gc_mark(m->rbConverter);
 }
 
+/*
+ * call-seq: mapped_type.native_type
+ * @return [Type]
+ * Get native type of mapped type.
+ */
 static VALUE
 mapped_native_type(VALUE self)
 {
@@ -97,6 +108,10 @@ mapped_native_type(VALUE self)
     return m->rbType;
 }
 
+/*
+ * call-seq: mapped_type.to_native(*args)
+ * @param args depends on {FFI::DataConverter} used to initialize +self+
+ */
 static VALUE
 mapped_to_native(int argc, VALUE* argv, VALUE self)
 {
@@ -107,6 +122,10 @@ mapped_to_native(int argc, VALUE* argv, VALUE self)
     return rb_funcall2(m->rbConverter, id_to_native, argc, argv);
 }
 
+/*
+ * call-seq: mapped_type.from_native(*args)
+ * @param args depends on {FFI::DataConverter} used to initialize +self+
+ */
 static VALUE
 mapped_from_native(int argc, VALUE* argv, VALUE self)
 {
@@ -121,6 +140,9 @@ void
 rbffi_MappedType_Init(VALUE moduleFFI)
 {
     
+    /* 
+     * Document-class: FFI::Type::Mapped
+     */
     rbffi_MappedTypeClass = rb_define_class_under(rbffi_TypeClass, "Mapped", rbffi_TypeClass);
     
     rb_global_variable(&rbffi_MappedTypeClass);

data/ext/ffi_c/MemoryPointer.c

@@ -19,8 +19,16 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef _MSC_VER
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
+#ifndef _MSC_VER
 #include <stdint.h>
+#endif
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
@@ -88,7 +96,7 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
         return Qnil;
     }
     p->autorelease = true;
-    p->memory.typeSize = size;
+    p->memory.typeSize = (int) size;
     p->memory.size = msize;
     /* ensure the memory is aligned on at least a 8 byte boundary */
     p->memory.address = (char *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7UL);;
@@ -135,6 +143,15 @@ memptr_mark(Pointer* ptr)
     rb_gc_mark(ptr->rbParent);
 }
 
+static VALUE
+memptr_s_from_string(VALUE klass, VALUE s)
+{
+    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);
+    
+    return obj;
+}
 
 void
 rbffi_MemoryPointer_Init(VALUE moduleFFI)
@@ -144,5 +161,6 @@ rbffi_MemoryPointer_Init(VALUE moduleFFI)
 
     rb_define_alloc_func(rbffi_MemoryPointerClass, memptr_allocate);
     rb_define_method(rbffi_MemoryPointerClass, "initialize", memptr_initialize, -1);
+    rb_define_singleton_method(rbffi_MemoryPointerClass, "from_string", memptr_s_from_string, 1);
 }
 

data/ext/ffi_c/MemoryPointer.h

@@ -22,7 +22,13 @@
 #ifndef RBFFI_MEMORYPOINTER_H
 #define	RBFFI_MEMORYPOINTER_H
 
+#ifndef _MSC_VER
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #include <ruby.h>
 
 #ifdef	__cplusplus

data/ext/ffi_c/MethodHandle.c

@@ -17,14 +17,22 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef _MSC_VER
 #include <sys/param.h>
+#endif
 #include <sys/types.h>
 #ifndef _WIN32
 #  include <sys/mman.h>
 #endif
 #include <stdio.h>
+#ifndef _MSC_VER
 #include <stdint.h>
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #ifndef _WIN32
 #  include <unistd.h>
 #endif
@@ -67,7 +75,7 @@
 
 
 static bool prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize);
-static int trampoline_size(void);
+static long trampoline_size(void);
 
 #if defined(__x86_64__) && defined(__GNUC__)
 # define CUSTOM_TRAMPOLINE 1
@@ -143,14 +151,14 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
 }
 
 
-static int
+static long
 trampoline_size(void)
 {
     return sizeof(METHOD_CLOSURE);
 }
 
 /*
- * attached_method_vinvoke is used functions with more than 6 parameters, or
+ * attached_method_invoke is used functions with more than 6 parameters, or
  * with struct param or return values
  */
 static void
@@ -211,7 +219,13 @@ static VALUE
 custom_trampoline(int argc, VALUE* argv, VALUE self, Closure* handle)
 {
     FunctionType* fnInfo = (FunctionType *) handle->info;
-    return (*fnInfo->invoke)(argc, argv, handle->function, fnInfo);
+    VALUE rbReturnValue;
+    
+    RB_GC_GUARD(rbReturnValue) = (*fnInfo->invoke)(argc, argv, handle->function, fnInfo);
+    RB_GC_GUARD_PTR(argv);
+    RB_GC_GUARD(self);
+
+    return rbReturnValue;
 }
 
 #elif defined(__i386__) && 0
@@ -258,11 +272,11 @@ custom_trampoline(caddr_t args, Closure* handle)
 
 extern void ffi_trampoline(int argc, VALUE* argv, VALUE self);
 extern void ffi_trampoline_end(void);
-static int trampoline_offsets(int *, int *);
+static int trampoline_offsets(long *, long *);
 
-static int trampoline_ctx_offset, trampoline_func_offset;
+static long trampoline_ctx_offset, trampoline_func_offset;
 
-static int
+static long
 trampoline_offset(int off, const long value)
 {
     caddr_t ptr;
@@ -276,7 +290,7 @@ trampoline_offset(int off, const long value)
 }
 
 static int
-trampoline_offsets(int* ctxOffset, int* fnOffset)
+trampoline_offsets(long* ctxOffset, long* fnOffset)
 {
     *ctxOffset = trampoline_offset(0, TRAMPOLINE_CTX_MAGIC);
     if (*ctxOffset == -1) {
@@ -304,7 +318,7 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
     return true;
 }
 
-static int
+static long
 trampoline_size(void)
 {
     return (caddr_t) &ffi_trampoline_end - (caddr_t) &ffi_trampoline;
@@ -316,14 +330,15 @@ trampoline_size(void)
 void
 rbffi_MethodHandle_Init(VALUE module)
 {
-    defaultClosurePool = rbffi_ClosurePool_New(trampoline_size(), prep_trampoline, NULL);
+    ffi_status ffiStatus;
+    defaultClosurePool = rbffi_ClosurePool_New((int) trampoline_size(), prep_trampoline, NULL);
 
 #if defined(CUSTOM_TRAMPOLINE)
     if (trampoline_offsets(&trampoline_ctx_offset, &trampoline_func_offset) != 0) {
         rb_raise(rb_eFatal, "Could not locate offsets in trampoline code");
     }
 #else
-    ffi_status ffiStatus = ffi_prep_cif(&mh_cif, FFI_DEFAULT_ABI, 3, &ffi_type_ulong,
+    ffiStatus = ffi_prep_cif(&mh_cif, FFI_DEFAULT_ABI, 3, &ffi_type_ulong,
             methodHandleParamTypes);
     if (ffiStatus != FFI_OK) {
         rb_raise(rb_eFatal, "ffi_prep_cif failed.  status=%#x", ffiStatus);

data/ext/ffi_c/Platform.c

@@ -18,14 +18,25 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef _MSC_VER
 #include <sys/param.h>
+#endif
 #include <sys/types.h>
+#ifndef _MSC_VER
 #include <stdint.h>
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #include <ruby.h>
 #include <ctype.h>
 #include "endian.h"
 #include "Platform.h"
+#if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
+  #include <gnu/lib-names.h>
+#endif
 
 static VALUE PlatformModule = Qnil;
 
@@ -34,13 +45,13 @@ static VALUE PlatformModule = Qnil;
  * system installed ruby incorrectly reports 'host_cpu' as 'powerpc' when running
  * on intel.
  */
-#if defined(__x86_64__) || defined(__x86_64) || defined(__amd64)
+#if defined(__x86_64__) || defined(__x86_64) || defined(__amd64) || defined(_M_X64) || defined(_M_AMD64)
 # define CPU "x86_64"
 
-#elif defined(__i386__) || defined(__i386)
+#elif defined(__i386__) || defined(__i386) || defined(_M_IX86)
 # define CPU "i386"
 
-#elif defined(__ppc64__) || defined(__powerpc64__)
+#elif defined(__ppc64__) || defined(__powerpc64__) || defined(_M_PPC)
 # define CPU "ppc64"
 
 #elif defined(__ppc__) || defined(__powerpc__) || defined(__powerpc)
@@ -93,6 +104,9 @@ rbffi_Platform_Init(VALUE moduleFFI)
     rb_define_const(PlatformModule, "LITTLE_ENDIAN", INT2FIX(LITTLE_ENDIAN));
     rb_define_const(PlatformModule, "BIG_ENDIAN", INT2FIX(BIG_ENDIAN));
     rb_define_const(PlatformModule, "CPU", rb_str_new2(CPU));
+#if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
+    rb_define_const(PlatformModule, "GNU_LIBC", rb_str_new2(LIBC_SO));
+#endif
     export_primitive_types(PlatformModule);
 }
 

data/ext/ffi_c/Pointer.c

@@ -18,8 +18,16 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef _MSC_VER
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
+#ifndef _MSC_VER
 #include <stdint.h>
+#endif
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
@@ -68,6 +76,17 @@ ptr_allocate(VALUE klass)
     return obj;
 }
 
+/*
+ * @overload initialize(pointer)
+ *  @param [Pointer] pointer another pointer to initialize from
+ *  Create a new pointer from another {Pointer}.
+ * @overload initialize(type, address)
+ *  @param [Type] type type for pointer
+ *  @param [Integer] address base address for pointer
+ *  Create a new pointer from a {Type} and a base adresse
+ * @return [self]
+ * A new instance of Pointer.
+ */
 static VALUE
 ptr_initialize(int argc, VALUE* argv, VALUE self)
 {
@@ -117,6 +136,16 @@ ptr_initialize(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
+/*
+ * call-seq: ptr.initialize_copy(other)
+ * @param [Pointer] other source for cloning or dupping
+ * @return [self]
+ * @raise {RuntimeError} if +other+ is an unbounded memory area, or is unreable/unwritable
+ * @raise {NoMemError} if failed to allocate memory for new object
+ * DO NOT CALL THIS METHOD.
+ *
+ * This method is internally used by #dup and #clone. Memory contents is copied from +other+.
+ */
 static VALUE
 ptr_initialize_copy(VALUE self, VALUE other)
 {
@@ -179,6 +208,13 @@ slice(VALUE self, long offset, long size)
     return retval;
 }
 
+/* 
+ * Document-method: +
+ * call-seq: ptr + offset
+ * @param [Numeric] offset
+ * @return [Pointer]
+ * Return a new {Pointer} from an existing pointer and an +offset+.
+ */
 static VALUE
 ptr_plus(VALUE self, VALUE offset)
 {
@@ -190,12 +226,25 @@ ptr_plus(VALUE self, VALUE offset)
     return slice(self, off, ptr->size == LONG_MAX ? LONG_MAX : ptr->size - off);
 }
 
+/*
+ * call-seq: ptr.slice(offset, length)
+ * @param [Numeric] offset
+ * @param [Numeric] length
+ * @return [Pointer]
+ * Return a new {Pointer} from an existing one. This pointer points on same contents 
+ * from +offset+ for a length +length+.
+ */
 static VALUE
 ptr_slice(VALUE self, VALUE rbOffset, VALUE rbLength)
 {
     return slice(self, NUM2LONG(rbOffset), NUM2LONG(rbLength));
 }
 
+/*
+ * call-seq: ptr.inspect
+ * @return [String]
+ * Inspect pointer object.
+ */
 static VALUE
 ptr_inspect(VALUE self)
 {
@@ -214,6 +263,12 @@ ptr_inspect(VALUE self)
     return rb_str_new2(buf);
 }
 
+/*
+ * Document-method: null?
+ * call-seq: ptr.null?
+ * @return [Boolean]
+ * Return +true+ if +self+ is a {NULL} pointer.
+ */
 static VALUE
 ptr_null_p(VALUE self)
 {
@@ -224,6 +279,12 @@ ptr_null_p(VALUE self)
     return ptr->memory.address == NULL ? Qtrue : Qfalse;
 }
 
+/*
+ * Document-method: ==
+ * call-seq: ptr == other
+ * @param [Pointer] other
+ * Check equality between +self+ and +other+. Equality is tested on {#address}.
+ */
 static VALUE
 ptr_equals(VALUE self, VALUE other)
 {
@@ -234,6 +295,11 @@ ptr_equals(VALUE self, VALUE other)
     return ptr->memory.address == POINTER(other)->address ? Qtrue : Qfalse;
 }
 
+/*
+ * call-seq: ptr.address
+ * @return [Numeric] pointer's base address
+ * Return +self+'s base address (alias: #to_i).
+ */
 static VALUE
 ptr_address(VALUE self)
 {
@@ -250,6 +316,15 @@ ptr_address(VALUE self)
 # define SWAPPED_ORDER LITTLE_ENDIAN
 #endif
 
+/*
+ * Get or set +self+'s endianness
+ * @overload ptr.order
+ *  @return [:big, :little] endianness of +self+
+ * @overload ptr.order(order)
+ *  @param  [Symbol] order endianness to set (+:little+, +:big+ or +:network+). +:big+ and +:network+ 
+ *   are synonymous.
+ *  @return [self]
+ */
 static VALUE
 ptr_order(int argc, VALUE* argv, VALUE self)
 {
@@ -289,6 +364,11 @@ ptr_order(int argc, VALUE* argv, VALUE self)
 }
 
 
+/*
+ * call-seq: ptr.free
+ * @return [self]
+ * Free memory pointed by +self+.
+ */
 static VALUE
 ptr_free(VALUE self)
 {
@@ -307,6 +387,12 @@ ptr_free(VALUE self)
     return self;
 }
 
+/*
+ * call-seq: ptr.autorelease = autorelease
+ * @param [Boolean] autorelease
+ * @return [Boolean] +autorelease+
+ * Set +autorelease+ attribute. See also Autorelease section.
+ */
 static VALUE
 ptr_autorelease(VALUE self, VALUE autorelease)
 {
@@ -318,6 +404,11 @@ ptr_autorelease(VALUE self, VALUE autorelease)
     return autorelease;
 }
 
+/*
+ * call-seq: ptr.autorelease?
+ * @return [Boolean]
+ * Get +autorelease+ attribute. See also Autorelease section.
+ */
 static VALUE
 ptr_autorelease_p(VALUE self)
 {
@@ -350,7 +441,19 @@ rbffi_Pointer_Init(VALUE moduleFFI)
 {
     VALUE rbNullAddress = ULL2NUM(0);
 
+    /* 
+     * Document-class: FFI::Pointer < FFI::AbstractMemory
+     * Pointer class is used to manage C pointers with ease. A {Pointer} object is defined by his
+     * {#address} (as a C pointer). It permits additions with an integer for pointer arithmetic.
+     *
+     * ==Autorelease
+     * A pointer object may autorelease his contents when freed (by default). This behaviour may be
+     * changed with {#autorelease=} method.
+     */
     rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", rbffi_AbstractMemoryClass);
+    /*
+     * Document-variable: Pointer
+     */
     rb_global_variable(&rbffi_PointerClass);
 
     rb_define_alloc_func(rbffi_PointerClass, ptr_allocate);
@@ -370,6 +473,9 @@ rbffi_Pointer_Init(VALUE moduleFFI)
     rb_define_method(rbffi_PointerClass, "free", ptr_free, 0);
 
     rbffi_NullPointerSingleton = rb_class_new_instance(1, &rbNullAddress, rbffi_PointerClass);
+    /*
+     * NULL pointer
+     */
     rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton);
 }