ffi 0.6.0 → 0.6.4

data/History.txt

@@ -0,0 +1,102 @@
+== 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.
+ 

data/README.md

@@ -0,0 +1,109 @@
+# ruby-ffi http://wiki.github.com/ffi/ffi [![Build Status](https://travis-ci.org/ffi/ffi.png?branch=master)](https://travis-ci.org/ffi/ffi)
+
+## Description
+
+Ruby-FFI is a ruby extension for programmatically loading dynamic
+libraries, binding functions within them, and calling those functions
+from Ruby code. Moreover, a Ruby-FFI extension works without changes
+on Ruby and JRuby. Discover why should you write your next extension
+using Ruby-FFI [here](http://wiki.github.com/ffi/ffi/why-use-ffi).
+
+## Features/problems
+
+* Intuitive DSL
+* Supports all C native types
+* C structs (also nested), enums and global variables
+* Callbacks from C to ruby
+* Automatic garbage collection of native memory
+
+## Synopsis
+
+```ruby
+require 'ffi'
+
+module MyLib
+  extend FFI::Library
+  ffi_lib 'c'
+  attach_function :puts, [ :string ], :int
+end
+
+MyLib.puts 'Hello, World using libc!'
+```
+
+For less minimalistic and more sane examples you may look at:
+
+* the samples/ folder
+* the examples on the [wiki](http://wiki.github.com/ffi/ffi)
+* the projects using FFI listed on this page (http://wiki.github.com/ffi/ffi/projects-using-ffi)
+
+## Requirements
+
+You need a sane building environment in order to compile the extension.
+At a minimum, you will need:
+* A C compiler (e.g. Xcode on OSX, gcc on everything else)
+* libffi development library - this is commonly in the libffi-dev or libffi-devel
+
+## Installation
+
+From rubygems:
+
+    [sudo] gem install ffi
+
+or from the git repository on github:
+
+    git clone git://github.com/ffi/ffi.git
+    cd ffi
+    rake gem:install
+
+## License
+
+The ffi library is covered by the LGPL3 license, also see the LICENSE file.
+The specs are shared with Rubyspec and are licensed by the same license
+as Rubyspec, see the LICENSE.SPECS file.
+
+## Credits
+
+The following people have submitted code, bug reports, or otherwide contributed to the success of this project:
+
+* Alban Peignier <alban.peignier@free.fr>
+* Aman Gupta <aman@tmm1.net>
+* Andrea Fazzi <andrea.fazzi@alcacoop.it>
+* Andreas Niederl <rico32@gmx.net>
+* Andrew Cholakian <andrew@andrewvc.com>
+* Antonio Terceiro <terceiro@softwarelivre.org>
+* Brian Candler <B.Candler@pobox.com>
+* Brian D. Burns <burns180@gmail.com>
+* Bryan Kearney <bkearney@redhat.com>
+* Charlie Savage <cfis@zerista.com>
+* Chikanaga Tomoyuki <nagachika00@gmail.com>
+* Hongli Lai <hongli@phusion.nl>
+* Ian MacLeod <ian@nevir.net>
+* Jake Douglas <jake@shiftedlabs.com>
+* Jean-Dominique Morani <jdmorani@mac.com>
+* Jeremy Hinegardner <jeremy@hinegardner.org>
+* Jesús García Sáez <blaxter@gmail.com>
+* Joe Khoobyar <joe@ankhcraft.com>
+* Jurij Smakov <jurij@wooyd.org>
+* KISHIMOTO, Makoto <ksmakoto@dd.iij4u.or.jp>
+* Kim Burgestrand <kim@burgestrand.se>
+* Lars Kanis <kanis@comcard.de>
+* Luc Heinrich <luc@honk-honk.com>
+* Luis Lavena <luislavena@gmail.com>
+* Matijs van Zuijlen <matijs@matijs.net>
+* Matthew King <automatthew@gmail.com>
+* Mike Dalessio <mike.dalessio@gmail.com>
+* NARUSE, Yui <naruse@airemix.jp>
+* Park Heesob <phasis@gmail.com>
+* Shin Yee <shinyee@speedgocomputing.com>
+* Stephen Bannasch <stephen.bannasch@gmail.com>
+* Suraj N. Kurapati <sunaku@gmail.com>
+* Sylvain Daubert <sylvain.daubert@laposte.net>
+* Victor Costan
+* beoran@gmail.com
+* ctide <christide@christide.com>
+* emboss <Martin.Bosslet@googlemail.com>
+* hobophobe <unusualtears@gmail.com>
+* meh <meh@paranoici.org>
+* postmodern <postmodern.mod3@gmail.com>
+* wycats@gmail.com <wycats@gmail.com>
+* Wayne Meissner <wmeissner@gmail.com>

data/Rakefile

@@ -1,32 +1,31 @@
 require 'rubygems'
+require 'rubygems/package_task'
 require 'rbconfig'
 
 USE_RAKE_COMPILER = (RUBY_PLATFORM =~ /java/) ? false : true
 if USE_RAKE_COMPILER
   gem 'rake-compiler', '>=0.6.0'
   require 'rake/extensiontask'
-  ENV['RUBY_CC_VERSION'] = '1.8.6:1.9.1'
 end
 
 require 'date'
 require 'fileutils'
 require 'rbconfig'
 
-load 'tasks/setup.rb'
 
-LIBEXT = case Config::CONFIG['host_os'].downcase
+LIBEXT = case RbConfig::CONFIG['host_os'].downcase
   when /darwin/
     "dylib"
   when /mswin|mingw/
     "dll"
   else
-    Config::CONFIG['DLEXT']
+    RbConfig::CONFIG['DLEXT']
   end
 
-CPU = case Config::CONFIG['host_cpu'].downcase
+CPU = case RbConfig::CONFIG['host_cpu'].downcase
   when /i[3456]86/
     # Darwin always reports i686, even when running in 64bit mode
-    if Config::CONFIG['host_os'] =~ /darwin/ && 0xfee1deadbeef.is_a?(Fixnum)
+    if RbConfig::CONFIG['host_os'] =~ /darwin/ && 0xfee1deadbeef.is_a?(Fixnum)
       "x86_64"
     else
       "i386"
@@ -41,11 +40,14 @@ CPU = case Config::CONFIG['host_cpu'].downcase
   when /ppc|powerpc/
     "powerpc"
 
+  when /^arm/
+    "arm"
+
   else
-    Config::CONFIG['host_cpu']
+    RbConfig::CONFIG['host_cpu']
   end
 
-OS = case Config::CONFIG['host_os'].downcase
+OS = case RbConfig::CONFIG['host_os'].downcase
   when /linux/
     "linux"
   when /darwin/
@@ -59,78 +61,48 @@ OS = case Config::CONFIG['host_os'].downcase
   when /mswin|mingw/
     "win32"
   else
-    Config::CONFIG['host_os'].downcase
+    RbConfig::CONFIG['host_os'].downcase
   end
 
-CC=ENV['CC'] || Config::CONFIG['CC'] || "gcc"
+CC = ENV['CC'] || RbConfig::CONFIG['CC'] || "gcc"
 
-GMAKE = Config::CONFIG['host_os'].downcase =~ /bsd|solaris/ ? "gmake" : "make"
+GMAKE = system('which gmake >/dev/null') && 'gmake' || 'make'
 
 LIBTEST = "build/libtest.#{LIBEXT}"
 BUILD_DIR = "build"
-BUILD_EXT_DIR = File.join(BUILD_DIR, "#{Config::CONFIG['arch']}", 'ffi_c', RUBY_VERSION)
-
-# Project general information
-PROJ.name = 'ffi'
-PROJ.authors = 'Wayne Meissner'
-PROJ.email = 'wmeissner@gmail.com'
-PROJ.url = 'http://wiki.github.com/ffi/ffi'
-PROJ.version = '0.6.0'
-PROJ.rubyforge.name = 'ffi'
-PROJ.readme_file = 'README.rdoc'
-
-# Annoucement
-PROJ.ann.paragraphs << 'FEATURES' << 'SYNOPSIS' << 'REQUIREMENTS' << 'DOWNLOAD/INSTALL' << 'CREDITS' << 'LICENSE'
-
-PROJ.ann.email[:from] = 'andrea.fazzi@alcacoop.it'
-PROJ.ann.email[:to] = ['ruby-ffi@googlegroups.com']
-PROJ.ann.email[:server] = 'smtp.gmail.com'
-
-# Gem specifications
-PROJ.gem.need_tar = false
-PROJ.gem.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{ext,gen,lib,spec}/**/*")
-PROJ.gem.platform = Gem::Platform::RUBY
-
-# Override Mr. Bones autogenerated extensions and force ours in
-PROJ.gem.extras['extensions'] = %w(ext/ffi_c/extconf.rb gen/Rakefile)
-
-# RDoc
-PROJ.rdoc.exclude << '^ext\/'
-PROJ.rdoc.opts << '-x' << 'ext'
-
-# Ruby
-PROJ.ruby_opts = []
-PROJ.ruby_opts << '-I' << BUILD_EXT_DIR unless RUBY_PLATFORM == "java"
+BUILD_EXT_DIR = File.join(BUILD_DIR, "#{RbConfig::CONFIG['arch']}", 'ffi_c', RUBY_VERSION)
 
-# RSpec
-PROJ.spec.files.exclude /rbx/
-PROJ.spec.opts << '--color' << '-fs'
-
-# Dependencies
+def gem_spec
+  @gem_spec ||= Gem::Specification.load('ffi.gemspec')
+end
 
-depend_on 'rake', '>=0.8.7'
+Gem::PackageTask.new(gem_spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+  pkg.package_dir = 'pkg'
+end
 
 TEST_DEPS = [ LIBTEST ]
 if RUBY_PLATFORM == "java"
   desc "Run all specs"
   task :specs => TEST_DEPS do
-    sh %{#{Gem.ruby} -S spec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -w -S rspec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
   end
   desc "Run rubinius specs"
   task :rbxspecs => TEST_DEPS do
-    sh %{#{Gem.ruby} -S spec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -w -S rspec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
   end
 else
   TEST_DEPS.unshift :compile
   desc "Run all specs"
   task :specs => TEST_DEPS do
     ENV["MRI_FFI"] = "1"
-    sh %{#{Gem.ruby} -Ilib -I#{BUILD_EXT_DIR} -S spec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -w -Ilib -I#{BUILD_EXT_DIR} -S rspec #{Dir["spec/ffi/*_spec.rb"].join(" ")} -fs --color}
   end
   desc "Run rubinius specs"
   task :rbxspecs => TEST_DEPS do
     ENV["MRI_FFI"] = "1"
-    sh %{#{Gem.ruby} -Ilib -I#{BUILD_EXT_DIR} -S spec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
+    sh %{#{Gem.ruby} -w -Ilib -I#{BUILD_EXT_DIR} -S rspec #{Dir["spec/ffi/rbx/*_spec.rb"].join(" ")} -fs --color}
   end
 end
 
@@ -140,20 +112,26 @@ task :package => 'gem:package'
 desc "Install the gem locally"
 task :install => 'gem:install'
 
+namespace :gem do
+  task :install => :gem do
+    ruby %{ -S gem install pkg/ffi-#{gem_spec.version}.gem }
+  end
+end
 
 desc "Clean all built files"
 task :distclean => :clobber do
   FileUtils.rm_rf('build')
-  FileUtils.rm_rf(Dir["lib/**/ffi_c.#{Config::CONFIG['DLEXT']}"])
+  FileUtils.rm_rf(Dir["lib/**/ffi_c.#{RbConfig::CONFIG['DLEXT']}"])
   FileUtils.rm_rf('lib/1.8')
   FileUtils.rm_rf('lib/1.9')
+  FileUtils.rm_rf('lib/ffi/types.conf')
   FileUtils.rm_rf('conftest.dSYM')
   FileUtils.rm_rf('pkg')
 end
 
 
 desc "Build the native test lib"
-task "build/libtest.#{LIBEXT}" do
+file "build/libtest.#{LIBEXT}" => FileList['libtest/**/*.[ch]'] do
   sh %{#{GMAKE} -f libtest/GNUmakefile CPU=#{CPU} OS=#{OS} }
 end
 
@@ -186,3 +164,54 @@ task 'spec:specdoc' => TEST_DEPS
 
 task :default => :specs
 
+task 'gem:win32' do
+  sh("rake cross native gem RUBY_CC_VERSION='1.8.7:1.9.3'") || raise("win32 build failed!")
+end
+
+
+namespace 'java' do
+
+  java_gem_spec = Gem::Specification.new do |s|
+    s.name = gem_spec.name
+    s.version = gem_spec.version
+    s.author = gem_spec.author
+    s.email = gem_spec.email
+    s.homepage = gem_spec.homepage
+    s.summary = gem_spec.summary
+    s.description = gem_spec.description
+    s.files = %w(History.txt LICENSE COPYING COPYING.LESSER README.md Rakefile)
+    s.has_rdoc = false
+    s.license = gem_spec.license
+    s.platform = 'java'
+  end
+
+  Gem::PackageTask.new(java_gem_spec) do |pkg|
+    pkg.need_zip = true
+    pkg.need_tar = true
+    pkg.package_dir = 'pkg'
+  end
+end
+
+task 'gem:java' => 'java:gem'
+
+
+if USE_RAKE_COMPILER
+  Rake::ExtensionTask.new('ffi_c', gem_spec) do |ext|
+    ext.name = 'ffi_c'                                        # indicate the name of the extension.
+    # ext.lib_dir = BUILD_DIR                                 # put binaries into this folder.
+    ext.tmp_dir = BUILD_DIR                                   # temporary folder used during compilation.
+    ext.cross_compile = true                                  # enable cross compilation (requires cross compile toolchain)
+    ext.cross_platform = 'i386-mingw32'                       # forces the Windows platform instead of the default one
+  end
+end
+
+begin
+  require 'yard'
+
+  namespace :doc do
+    YARD::Rake::YardocTask.new do |yard|
+    end
+  end
+rescue LoadError
+  warn "[warn] YARD unavailable"
+end

data/ext/ffi_c/Call.c

@@ -142,10 +142,10 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTy
 
             case NATIVE_BOOL:
                 if (type != T_TRUE && type != T_FALSE) {
-                    rb_raise(rb_eTypeError, "Expected a Boolean parameter");
+                    rb_raise(rb_eTypeError, "wrong argument type  (expected a boolean parameter)");
                 }
-                param->s32 = argv[argidx++] == Qtrue;
-                ADJ(param, INT32);
+                param->s8 = argv[argidx++] == Qtrue;
+                ADJ(param, INT8);
                 break;
 
 

data/ext/ffi_c/Ffi_c.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
+

data/ext/ffi_c/Function.c

@@ -374,7 +374,7 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
                 param = rbffi_Pointer_NewInstance(*(void **) parameters[i]);
                 break;
             case NATIVE_BOOL:
-                param = (*(void **) parameters[i]) ? Qtrue : Qfalse;
+                param = (*(uint8_t *) parameters[i]) ? Qtrue : Qfalse;
                 break;
 
             case NATIVE_FUNCTION:
@@ -428,8 +428,9 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
                 *((void **) retval) = NULL;
             }
             break;
+
         case NATIVE_BOOL:
-            *((ffi_sarg *) retval) = TYPE(rbReturnValue) == T_TRUE ? 1 : 0;
+            *((ffi_arg *) retval) = rbReturnValue == Qtrue;
             break;
 
         case NATIVE_FUNCTION:

data/ext/ffi_c/Struct.c

@@ -71,6 +71,8 @@ typedef struct InlineArray_ {
 static void struct_mark(Struct *);
 static void struct_layout_builder_mark(StructLayoutBuilder *);
 static void struct_layout_builder_free(StructLayoutBuilder *);
+static VALUE struct_class_layout(VALUE klass);
+static void struct_malloc(Struct* s);
 static void inline_array_mark(InlineArray *);
 
 static inline int align(int offset, int align);
@@ -116,10 +118,8 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
     /* Call up into ruby code to adjust the layout */
     if (nargs > 1) {
         s->rbLayout = rb_funcall2(CLASS_OF(self), id_layout, RARRAY_LEN(rest), RARRAY_PTR(rest));
-    } else if (rb_cvar_defined(klass, id_layout_ivar)) {
-        s->rbLayout = rb_cvar_get(klass, id_layout_ivar);
     } else {
-        rb_raise(rb_eRuntimeError, "No Struct layout configured");
+        s->rbLayout = struct_class_layout(klass);
     }
 
     if (!rb_obj_is_kind_of(s->rbLayout, rbffi_StructLayoutClass)) {
@@ -132,13 +132,74 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
         s->pointer = MEMORY(rbPointer);
         s->rbPointer = rbPointer;
     } else {
-        s->rbPointer = rbffi_MemoryPointer_NewInstance(s->layout->size, 1, true);
-        s->pointer = (AbstractMemory *) DATA_PTR(s->rbPointer);
+        struct_malloc(s);
     }
 
     return self;
 }
 
+static VALUE
+struct_class_layout(VALUE klass)
+{
+    VALUE layout;
+    if (!rb_cvar_defined(klass, id_layout_ivar)) {
+        rb_raise(rb_eRuntimeError, "no Struct layout configured for %s", rb_class2name(klass));
+    }
+
+    layout = rb_cvar_get(klass, id_layout_ivar);
+    if (!rb_obj_is_kind_of(layout, rbffi_StructLayoutClass)) {
+        rb_raise(rb_eRuntimeError, "invalid Struct layout for %s", rb_class2name(klass));
+    }
+
+    return layout;
+}
+
+static StructLayout*
+struct_layout(VALUE self)
+{
+    Struct* s = (Struct *) DATA_PTR(self);
+    if (s->layout != NULL) {
+        return s->layout;
+    }
+
+    if (s->layout == NULL) {
+        s->rbLayout = struct_class_layout(CLASS_OF(self));
+        Data_Get_Struct(s->rbLayout, StructLayout, s->layout);
+    }
+
+    return s->layout;
+}
+
+static Struct*
+struct_validate(VALUE self)
+{
+    Struct* s;
+    Data_Get_Struct(self, Struct, s);
+
+    if (struct_layout(self) == NULL) {
+        rb_raise(rb_eRuntimeError, "struct layout == null");
+    }
+
+    if (s->pointer == NULL) {
+        struct_malloc(s);
+    }
+
+    return s;
+}
+
+static void
+struct_malloc(Struct* s)
+{
+    if (s->rbPointer == Qnil) {
+        s->rbPointer = rbffi_MemoryPointer_NewInstance(s->layout->size, 1, true);
+
+    } else if (!rb_obj_is_kind_of(s->rbPointer, rbffi_AbstractMemoryClass)) {
+        rb_raise(rb_eRuntimeError, "invalid pointer in struct");
+    }
+
+    s->pointer = (AbstractMemory *) DATA_PTR(s->rbPointer);
+}
+
 static void
 struct_mark(Struct *s)
 {
@@ -151,9 +212,6 @@ struct_field(Struct* s, VALUE fieldName)
 {
     StructLayout* layout = s->layout;
     VALUE rbField;
-    if (layout == NULL) {
-        rb_raise(rb_eRuntimeError, "layout not set for Struct");
-    }
 
     rbField = rb_hash_aref(layout->rbFieldMap, fieldName);
     if (rbField == Qnil) {
@@ -170,8 +228,9 @@ struct_aref(VALUE self, VALUE fieldName)
     Struct* s;
     VALUE rbField;
     StructField* f;
-    
-    Data_Get_Struct(self, Struct, s);
+
+    s = struct_validate(self);
+
     rbField = struct_field(s, fieldName);
     f = (StructField *) DATA_PTR(rbField);
 
@@ -196,7 +255,8 @@ struct_aset(VALUE self, VALUE fieldName, VALUE value)
     StructField* f;
 
 
-    Data_Get_Struct(self, Struct, s);
+    s = struct_validate(self);
+
     rbField = struct_field(s, fieldName);
     f = (StructField *) DATA_PTR(rbField);
     if (f->put != NULL) {
@@ -221,12 +281,25 @@ static VALUE
 struct_set_pointer(VALUE self, VALUE pointer)
 {
     Struct* s;
+    StructLayout* layout;
+    AbstractMemory* memory;
 
     if (!rb_obj_is_kind_of(pointer, rbffi_AbstractMemoryClass)) {
-        rb_raise(rb_eArgError, "Invalid pointer");
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected Pointer or Buffer)",
+                rb_obj_classname(pointer));
+        return Qnil;
     }
 
+    
     Data_Get_Struct(self, Struct, s);
+    Data_Get_Struct(pointer, AbstractMemory, memory);
+    layout = struct_layout(self);
+
+    if (layout->base.ffiType->size > memory->size) {
+        rb_raise(rb_eArgError, "memory of %d bytes too small for struct %s (expected at least %d)",
+                memory->size, rb_obj_classname(self), layout->base.ffiType->size);
+    }
+    
     s->pointer = MEMORY(pointer);
     s->rbPointer = pointer;
     rb_ivar_set(self, id_pointer_ivar, pointer);
@@ -251,7 +324,9 @@ struct_set_layout(VALUE self, VALUE layout)
     Data_Get_Struct(self, Struct, s);
 
     if (!rb_obj_is_kind_of(layout, rbffi_StructLayoutClass)) {
-        rb_raise(rb_eArgError, "Invalid Struct layout");
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
+                rb_obj_classname(layout), rb_class2name(rbffi_StructLayoutClass));
+        return Qnil;
     }
 
     Data_Get_Struct(layout, StructLayout, s->layout);

data/ext/ffi_c/StructLayout.c

@@ -360,7 +360,8 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
             rb_raise(rb_eTypeError, "wrong type for field %d.", i);
         }
 
-        Data_Get_Struct(rbField, StructField, field = layout->fields[i]);
+        field = layout->fields[i];
+        Data_Get_Struct(rbField, StructField, field);
 
         if (field->type == NULL || field->type->ffiType == NULL) {
             rb_raise(rb_eRuntimeError, "type of field %d not supported", i);

data/ext/ffi_c/Types.c

@@ -76,7 +76,7 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
         case NATIVE_POINTER:
             return rbffi_Pointer_NewInstance(*(void **) ptr);
         case NATIVE_BOOL:
-            return ((int) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
+            return ((unsigned char) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
         case NATIVE_ENUM:
             return rb_funcall(rbType, id_find, 1, INT2NUM((unsigned int) *(ffi_arg *) ptr));
         

data/ext/ffi_c/libffi/configure

@@ -9021,7 +9021,7 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
       old_archive_from_new_cmds='true'
       # FIXME: Should let the user specify the lib program.
       old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
-      fix_srcfile_path='`cygpath -w "$srcfile"`'
+#      fix_srcfile_path='`cygpath -w "$srcfile"`'
       enable_shared_with_static_runtimes=yes
       ;;