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

data/History.txt

@@ -1,112 +1 @@
-== 1.0.3 / 2010-12-28
-* Re-add support for ruby 1.8.x
-
-== 1.0.0 / 2010-11-30
-* Major improvements
-  * Better handling of non-ruby thread callbacks
-  * Support for releasing the GIL during C function calls
-* Minor improvements
-  * code cleanups
-
-== 0.5.0 / 2009-10-06
-
-* Major improvements
-  * New Function class
-  * Structs can be passed and returned by value
-  * Implement a custom trampoline for x86_64, resulting in roughly 30% speedup
-  * Improve dispatch of functions which take (0..6) char/short/int/long/pointer arguments by between 50% and 200% on x86_64
-  * Callbacks are now approximately 100% faster on x86_64
-* Minor improvements
-  * Add support for MacOSX Snow Leopard
-  * Improve support for Windows releasing fat binaries on rubyforge
-  * Better introspection in structs:
-    * Add StructLayout::Field#type, size, offset, alignment and name 
-      methods
-    * Add StructLayout#fields which returns an array of 
-      StructLayout::Field objects
-  * Add automagic deducing of library name from module name. 
-    Idea and prototype implementation from Matt Hulse
-  * Callback fields in structs can now be both read and written
-  * Add a bunch of new benchmarks
-  * Lots of refactoring
-* Experimental features
-  * blocking functions (i.e. native code that blocks the thread) support
-* Bug fixes
-  * Fix RUBY-FFI_43 (rake gem dependency)
-
-== 0.4.0 / 2009-08-05
-
-* Major improvements
-  * Add support for boolean types
-  * Add support for methods as callbacks
-  * Add FFI::IO.read as described in JRUBY-3636
-* Minor improvements
-  * Add Pointer::NULL constant
-  * Add AbstractMemory#get_array_of_string()
-  * Implement Pointer.new(address) and Pointer.new(:type, address)
-* Bug fixes
-  * Fix RUBY_FFI-38
-  * Fix issues related to 1.9.1 build
-  * Fix issues related to OSX build
-  * Fix issues related to FreeBSD build
-  * Fix issues related to OpenSolaris build
-
-== 0.3.5 / 2009-05-08
-
-* Bug fixes
-  * Fix RUBY_FFI-17
-  * Fix RUBY_FFI-21
-
-== 0.3.4 / 2009-05-01
-
-* Minor improvements
-  * Add return statements to functions that call rb_raise(), in case
-    rb_raise is not declared noreturn, to avoid gcc warnings.
-
-== 0.3.3 / 2009-04-27
-
-* Minor improvements
-  * Implement RUBY_FFI-16 - Add support for anonymous callbacks
-  * Add support for callback parameters in callbacks
-  * Add support for function pointer return values
-  * Callbacks can now coerce proc objects into function pointers for
-    return values.
-  * Implement FFI::Type and FFI::Type::Builtin
-  * Add support for enumerations
-* Bug fixes
-  * Fix RUBY_FFI-19
-  * Fix RUBY_FFI-15
-
-== 0.3.2 / 2009-05-01
-
-* Bug fixes
-  * Fix JRUBY-3527 by passing RTLD_GLOBAL instead of RTLD_LOCAL
-
-== 0.3.1 / 2009-03-23
-
-* Bug fixes
-  * Correctly save errno/GetLastError after each call.
-
-== 0.3.0 / 2009-03-19
-
-* Switch compilation to rake-compiler
-  * Makes cross-compilation from linux -> win32 super easy
-  * win32 support is available now, but highly experimental
-* Performance improvements
-  * struct field access approx 3x faster than 0.2.0
-  * function invocation approx 20% faster than 0.2.0
-* A bunch of minor improvements
-  * Struct instances can now be passed as :pointer parameters without calling
-    Struct#pointer
-  * Support for array struct members
-  * Structs are now padded correctly to the alignment of the struct's  
-    largest field
-  * Global library variables
-  * Callbacks in global library variables
-  * Strings passed in as :string arguments are scrubbed to avoid 
-    poison-null-byte attacks.
-  * Union support
-  * nil can be passed as a :string argument (passed as NULL)
-  * Structs can now be fields inside another struct
-  * Lots of internal cleanups and refactorings.
- 
+== See git log

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2010 Ruby-FFI contributors
+Copyright (c) 2008-2012 Ruby-FFI contributors
 All rights reserved.
 
 This code is free software: you can redistribute it and/or modify it under

data/README.rdoc

@@ -1,5 +1,4 @@
 ruby-ffi
-    by Wayne Meissner
     http://wiki.github.com/ffi/ffi
 
 == DESCRIPTION:
@@ -28,7 +27,7 @@ using Ruby-FFI here[http://wiki.github.com/ffi/ffi/why-use-ffi].
     attach_function :puts, [ :string ], :int
   end
 
-  MyLib.puts 'Hello boys using libc!'
+  MyLib.puts 'Hello, World using libc!'
 
 For less minimalistic and more sane examples you may look at:
 
@@ -52,19 +51,6 @@ or from the git repository on github:
   cd ffi
   rake gem:install
 
-== CREDITS:
-
-Special thanks to:
-
-* Yehuda Katz
-* Luc Heinrich
-* Andrea Fazzi
-* Mike Dalessio
-* Hongli Lai
-* Evan Phoenix
-* Aman Gupta
-* Beoran
-
 == LICENSE:
 
 See LICENSE file.

data/Rakefile

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

data/ext/ffi_c/AbstractMemory.c

@@ -38,6 +38,7 @@ typedef int bool;
 #include "AbstractMemory.h"
 #include "Pointer.h"
 #include "Function.h"
+#include "LongDouble.h"
 
 
 static inline char* memory_address(VALUE self);
@@ -242,6 +243,7 @@ NUM_OP(long, long, NUM2LONG, LONG2NUM, SWAPSLONG);
 NUM_OP(ulong, unsigned long, NUM2ULONG, ULONG2NUM, SWAPULONG);
 NUM_OP(float32, float, NUM2DBL, rb_float_new, NOSWAP);
 NUM_OP(float64, double, NUM2DBL, rb_float_new, NOSWAP);
+NUM_OP(longdouble, long double, rbffi_num2longdouble, rbffi_longdouble_new, NOSWAP);
 
 static inline void*
 get_pointer_value(VALUE value)
@@ -652,6 +654,7 @@ MemoryOps rbffi_AbstractMemoryOps = {
     &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

data/ext/ffi_c/AbstractMemory.h

@@ -63,6 +63,7 @@ typedef struct {
     MemoryOp* uslong;
     MemoryOp* float32;
     MemoryOp* float64;
+    MemoryOp* longdouble;
     MemoryOp* pointer;
     MemoryOp* strptr;
     MemoryOp* boolOp;
@@ -138,6 +139,8 @@ get_memory_op(Type* type)
             return rbffi_AbstractMemoryOps.float32;
         case NATIVE_FLOAT64:
             return rbffi_AbstractMemoryOps.float64;
+        case NATIVE_LONGDOUBLE:
+            return rbffi_AbstractMemoryOps.longdouble;
         case NATIVE_POINTER:
             return rbffi_AbstractMemoryOps.pointer;
         case NATIVE_STRING:

data/ext/ffi_c/Call.c

@@ -52,6 +52,7 @@ typedef int bool;
 #include "Call.h"
 #include "MappedType.h"
 #include "Thread.h"
+#include "LongDouble.h"
 
 #ifdef USE_RAW
 #  ifndef __i386__
@@ -66,6 +67,7 @@ typedef int bool;
 #define FLOAT32_ADJ (4)
 #define FLOAT64_ADJ (8)
 #define ADDRESS_ADJ (sizeof(void *))
+#define LONGDOUBLE_ADJ (ffi_type_longdouble.alignment)
 
 #endif /* USE_RAW */
 
@@ -211,6 +213,12 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
                 ++argidx;
                 break;
 
+            case NATIVE_LONGDOUBLE:
+                param->ld = rbffi_num2longdouble(argv[argidx]);
+                ADJ(param, LONGDOUBLE);
+                ++argidx;
+                break;
+
 
             case NATIVE_STRING:
                 param->ptr = getString(argv[argidx++], type);

data/ext/ffi_c/Call.h

@@ -57,6 +57,7 @@ typedef union {
     void* ptr;
     float f32;
     double f64;
+    long double ld;
 } FFIStorage;
 
 

data/ext/ffi_c/Function.c

@@ -61,6 +61,7 @@ typedef int bool;
 #include "Function.h"
 #include "MappedType.h"
 #include "Thread.h"
+#include "LongDouble.h"
 
 typedef struct Function_ {
     Pointer base;
@@ -774,6 +775,9 @@ callback_with_gvl(void* data)
             case NATIVE_FLOAT64:
                 param = rb_float_new(*(double *) parameters[i]);
                 break;
+            case NATIVE_LONGDOUBLE:
+	      param = rbffi_longdouble_new(*(long double *) parameters[i]);
+                break;
             case NATIVE_STRING:
                 param = (*(void **) parameters[i] != NULL) ? rb_tainted_str_new2(*(char **) parameters[i]) : Qnil;
                 break;

data/ext/ffi_c/LongDouble.c

@@ -0,0 +1,59 @@
+#include "LongDouble.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <float.h>
+
+static VALUE rb_cBigDecimal = Qnil;
+static VALUE bigdecimal_load(VALUE unused);
+static VALUE bigdecimal_failed(VALUE value);
+
+VALUE 
+rbffi_longdouble_new(long double ld)
+{
+    if (!RTEST(rb_cBigDecimal)) {
+        /* allow fallback if the bigdecimal library is unavailable in future ruby versions */
+        rb_cBigDecimal = rb_rescue(bigdecimal_load, Qnil, bigdecimal_failed, rb_cObject);
+    }
+
+    if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject) {
+        char buf[128];
+        return rb_funcall(rb_cBigDecimal, rb_intern("new"), 1, rb_str_new(buf, sprintf(buf, "%.35Le", ld)));
+    }
+
+    /* Fall through to handling as a float */
+    return rb_float_new(ld);
+}
+
+long double 
+rbffi_num2longdouble(VALUE value)
+{
+    if (TYPE(value) == T_FLOAT) {
+        return rb_num2dbl(value);
+    }
+    
+    if (!RTEST(rb_cBigDecimal) && rb_const_defined(rb_cObject, rb_intern("BigDecimal"))) {
+        rb_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+    }
+
+    if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject && RTEST(rb_obj_is_kind_of(value, rb_cBigDecimal))) {
+        VALUE s = rb_funcall(value, rb_intern("to_s"), 1, rb_str_new2("E"));
+        return strtold(RSTRING_PTR(s), NULL);
+    }
+
+    /* Fall through to handling as a float */
+    return rb_num2dbl(value);
+}
+
+
+static VALUE 
+bigdecimal_load(VALUE unused)
+{
+    rb_require("bigdecimal");
+    return rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+}
+
+static VALUE 
+bigdecimal_failed(VALUE value)
+{
+    return value;
+}

data/ext/ffi_c/LongDouble.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2012, Wayne Meissner
+ *
+ * All rights reserved.
+ *
+ * This file is part of ruby-ffi.
+ *
+ * This code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+ * version 3 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef RBFFI_LONGDOUBLE_H
+#define	RBFFI_LONGDOUBLE_H
+
+#include <ruby.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+extern VALUE rbffi_longdouble_new(long double ld);
+extern long double rbffi_num2longdouble(VALUE value);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_LONGDOUBLE_H */
+

data/ext/ffi_c/Pointer.c

@@ -292,6 +292,10 @@ ptr_equals(VALUE self, VALUE other)
     
     Data_Get_Struct(self, Pointer, ptr);
 
+    if (NIL_P(other)) {
+        return ptr->memory.address == NULL ? Qtrue : Qfalse;
+    }
+
     return ptr->memory.address == POINTER(other)->address ? Qtrue : Qfalse;
 }
 
@@ -382,6 +386,11 @@ ptr_free(VALUE self)
             ptr->storage = NULL;
         }
         ptr->allocated = false;
+
+    } else {
+        VALUE caller = rb_funcall(rb_funcall(Qnil, rb_intern("caller"), 0), rb_intern("first"), 0);
+        
+        rb_warn("calling free on non allocated pointer %s from %s", RSTRING_PTR(ptr_inspect(self)), RSTRING_PTR(rb_str_to_str(caller)));
     }
 
     return self;

data/ext/ffi_c/Struct.c

@@ -146,10 +146,7 @@ struct_initialize_copy(VALUE self, VALUE other)
     // be longer than just this struct.
     //
     if (src->pointer->address != NULL) {
-        memargs[0] = INT2FIX(1);
-        memargs[1] = INT2FIX(src->layout->size);
-        memargs[2] = Qfalse;
-        dst->rbPointer = rb_class_new_instance(2, memargs, rbffi_MemoryPointerClass);
+        dst->rbPointer = rbffi_MemoryPointer_NewInstance(1, src->layout->size, false);
         dst->pointer = MEMORY(dst->rbPointer);
         memcpy(dst->pointer->address, src->pointer->address, src->layout->size);
     } else {

data/ext/ffi_c/Type.c

@@ -373,6 +373,7 @@ rbffi_Type_Init(VALUE moduleFFI)
     A(FLOAT32, FLOAT);
     T(FLOAT64, &ffi_type_double);
     A(FLOAT64, DOUBLE);
+    T(LONGDOUBLE, &ffi_type_longdouble);
     T(POINTER, &ffi_type_pointer);
     T(STRING, &ffi_type_pointer);
     T(BUFFER_IN, &ffi_type_pointer);

data/ext/ffi_c/Types.c

@@ -29,6 +29,7 @@
 #include "Struct.h"
 #include "MappedType.h"
 #include "MemoryPointer.h"
+#include "LongDouble.h"
 
 static ID id_from_native = 0;
 
@@ -65,6 +66,10 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr)
             return rb_float_new(*(float *) ptr);
         case NATIVE_FLOAT64:
             return rb_float_new(*(double *) ptr);
+
+        case NATIVE_LONGDOUBLE:
+	  return rbffi_longdouble_new(*(long double *) ptr);
+
         case NATIVE_STRING:
             return (*(void **) ptr != NULL) ? rb_tainted_str_new2(*(char **) ptr) : Qnil;
         case NATIVE_POINTER:

data/ext/ffi_c/Types.h

@@ -40,6 +40,7 @@ typedef enum {
     NATIVE_ULONG,
     NATIVE_FLOAT32,
     NATIVE_FLOAT64,
+    NATIVE_LONGDOUBLE,
     NATIVE_POINTER,
     NATIVE_CALLBACK,
     NATIVE_FUNCTION,

data/ext/ffi_c/libffi.darwin.mk

@@ -34,6 +34,8 @@ $(LIBFFI):
 	cd "$(LIBFFI_BUILD_DIR)" && $(MAKE)
 
 else
+LIBTARGETS = $(foreach arch,$(ARCHES),"$(BUILD_DIR)"/libffi-$(arch)/.libs/libffi_convenience.a)
+
 # Build a fat binary and assemble
 build_ffi = \
 	mkdir -p "$(BUILD_DIR)"/libffi-$(1); \
@@ -45,8 +47,23 @@ build_ffi = \
 	fi); \
 	env MACOSX_DEPLOYMENT_TARGET=10.4 $(MAKE) -C "$(BUILD_DIR)"/libffi-$(1)
 
-$(LIBFFI):
-	@for arch in $(ARCHES); do $(call build_ffi,$$arch);done	
+target_ffi = "$(BUILD_DIR)"/libffi-$(1)/.libs/libffi_convenience.a:; $(call build_ffi,$(1))
+
+# Work out which arches we need to compile the lib for
+ifneq ($(findstring ppc,$(ARCHES)),)
+  $(call target_ffi,ppc)
+endif
+
+ifneq ($(findstring i386,$(ARCHES)),)
+  $(call target_ffi,i386)
+endif
+
+ifneq ($(findstring x86_64,$(ARCHES)),)
+  $(call target_ffi,x86_64)
+endif
+
+
+$(LIBFFI):	$(LIBTARGETS)
 	# Assemble into a FAT (x86_64, i386, ppc) library
 	@mkdir -p "$(BUILD_DIR)"/libffi/.libs
 	/usr/bin/libtool -static -o $@ \

data/lib/ffi/struct_layout_builder.rb

@@ -71,6 +71,7 @@ module FFI
       Type::UINT64,
       Type::FLOAT32,
       Type::FLOAT64,
+      Type::LONGDOUBLE,
       Type::BOOL,
     ]
 

data/lib/ffi/tools/types_generator.rb

@@ -46,12 +46,15 @@ module FFI
       Tempfile.open 'ffi_types_generator' do |io|
         io.puts <<-C
 #include <sys/types.h>
+#if !(defined(WIN32))
 #include <sys/socket.h>
 #include <sys/resource.h>
+#endif
         C
 
         io.close
-        cmd = "gcc -E -x c #{options[:cppflags]} -D_DARWIN_USE_64_BIT_INODE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -c"
+        cc = ENV['CC'] || 'gcc'
+        cmd = "#{cc} -E -x c #{options[:cppflags]} -D_DARWIN_USE_64_BIT_INODE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -c"
         if options[:input]
           typedefs = File.read(options[:input])
         elsif options[:remote]

data/lib/ffi/types.rb

@@ -102,6 +102,9 @@ module FFI
       # C double precision float
       :double => Type::DOUBLE,
 
+      # C long double
+      :long_double => Type::LONGDOUBLE,
+
       # Native memory address
       :pointer => Type::POINTER,
 

data/spec/ffi/long_double.rb

@@ -0,0 +1,41 @@
+#
+# This file is part of ruby-ffi.
+#
+# This code is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License version 3 only, as
+# published by the Free Software Foundation.
+#
+# This code is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+# version 3 for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'bigdecimal'
+
+describe ":long_double arguments and return values" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :add_f128, [ :long_double, :long_double ], :long_double
+    attach_function :ret_f128, [ :long_double ], :long_double
+  end
+
+  it "returns first parameter" do
+    LibTest.ret_f128(0.1).should be_within(0.01).of(0.1)
+  end
+
+  it "returns first parameter with high precision" do
+    ld =        BigDecimal.new("1.234567890123456789")
+    tolerance = BigDecimal.new("0.0000000000000000001")
+    LibTest.ret_f128(ld).should be_within(tolerance).of(ld)
+  end
+
+  it "add two long double numbers" do
+    LibTest.add_f128(0.1, 0.2).should be_within(0.01).of(0.3)
+  end
+end

data/spec/ffi/pointer_spec.rb

@@ -105,6 +105,9 @@ describe "Pointer" do
       lambda { null_ptr.read_int }.should raise_error(FFI::NullPointerError)
       lambda { null_ptr.write_int(0xff1) }.should raise_error(FFI::NullPointerError)
     end
+    it 'returns true when compared with nil' do
+      (FFI::Pointer::NULL == nil).should be_true
+    end
   end
 
 end

data/spec/ffi/struct_spec.rb

@@ -513,6 +513,8 @@ describe FFI::Struct, ' by value'  do
     attach_function :struct_s8s32_get_s32, [ S8S32.by_value ], :int
     attach_function :struct_s8s32_s32_ret_s32, [ S8S32.by_value, :int ], :int
     attach_function :struct_s8s32_s64_ret_s64, [ S8S32.by_value, :long_long ], :long_long
+    attach_function :struct_s8s32_ret_s8s32, [ S8S32.by_value ], S8S32.by_value
+    attach_function :struct_s32_ptr_s32_s8s32_ret_s32, [ :int, :pointer, :int, S8S32.by_value ], :int
     attach_function :struct_varargs_ret_struct_string, [ :int, :varargs ], StructString.by_value
   end
 
@@ -548,8 +550,34 @@ describe FFI::Struct, ' by value'  do
     s = LibTest::S8S32.new
     s[:s8] = 0x12
     s[:s32] = 0x34567890
+  end
+
+  it 'parameter with preceding s32,ptr,s32' do
+    s = LibTest::S8S32.new
+    s[:s8] = 0x12
+    s[:s32] = 0x34567890
+    out = LibTest::S8S32.new
+    LibTest.struct_s32_ptr_s32_s8s32_ret_s32(0x1000000, out, 0x1eafbeef, s).should eq 0x34567890
+    out[:s8].should eq s[:s8]
+    out[:s32].should eq s[:s32]
+  end
+
+  it 'parameter with preceding s32,string,s32' do
+    s = LibTest::S8S32.new
+    s[:s8] = 0x12
+    s[:s32] = 0x34567890
+    out = 0.chr * 32
+    LibTest.struct_s32_ptr_s32_s8s32_ret_s32(0x1000000, out, 0x1eafbeef, s).should eq 0x34567890
+  end
+
+  it 'parameter, returning struct by value' do
+    s = LibTest::S8S32.new
+    s[:s8] = 0x12
+    s[:s32] = 0x34567890
 
-    LibTest.struct_s8s32_s64_ret_s64(s, 0xdeadcafebabe).should eq 0xdeadcafebabe
+    ret = LibTest.struct_s8s32_ret_s8s32(s)
+    ret[:s8].should eq s[:s8]
+    ret[:s32].should eq s[:s32]
   end
 
   it 'varargs returning a struct' do

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: ffi
 version: !ruby/object:Gem::Version 
-  hash: -913866008
+  hash: 3008988971
   prerelease: 7
   segments: 
   - 1
   - 0
   - 12
-  - pre
-  version: 1.0.12.pre
+  - rc
+  - 2
+  version: 1.0.12.rc2
 platform: x86-mingw32
 authors: 
 - Wayne Meissner
@@ -16,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-16 00:00:00 +10:00
+date: 2012-04-02 00:00:00 +10:00
 default_executable: 
 dependencies: []
 
@@ -337,6 +338,8 @@ files:
 - ext/ffi_c/libffi.mk
 - ext/ffi_c/libffi.vc.mk
 - ext/ffi_c/libffi.vc64.mk
+- ext/ffi_c/LongDouble.c
+- ext/ffi_c/LongDouble.h
 - ext/ffi_c/MappedType.c
 - ext/ffi_c/MappedType.h
 - ext/ffi_c/MemoryPointer.c
@@ -425,6 +428,7 @@ files:
 - spec/ffi/ffi_spec.rb
 - spec/ffi/function_spec.rb
 - spec/ffi/library_spec.rb
+- spec/ffi/long_double.rb
 - spec/ffi/managed_struct_spec.rb
 - spec/ffi/number_spec.rb
 - spec/ffi/pointer_spec.rb