ffi 0.3.1 → 0.4.0

data/ext/ffi_c/extconf.rb

@@ -16,15 +16,16 @@ $defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
 create_makefile("ffi_c")
 create_header("extconf.h")
 File.open("Makefile", "a") do |mf|
-  mf.puts "CPPFLAGS += -Werror -Wunused -Wformat"
+  mf.puts "CPPFLAGS += -Werror -Wunused -Wformat -Wimplicit -Wreturn-type"
   unless libffi_ok 
-    mf.puts "include $(srcdir)/ffi.mk"
     mf.puts "LIBFFI_HOST=--host=#{Config::CONFIG['host_alias']}" if Config::CONFIG.has_key?("host_alias")
     mf.puts "FFI_MMAP_EXEC=-DFFI_MMAP_EXEC_WRIT=#{Config::CONFIG['host_os'] =~ /win/ ? 0 : 1}"
-    if Config::CONFIG['host_os'] =~ /darwin/
-      mf.puts "include $(srcdir)/libffi.darwin.mk"
+    if Config::CONFIG['host_os'].downcase =~ /darwin/
+      mf.puts "include ${srcdir}/libffi.darwin.mk"
+    elsif Config::CONFIG['host_os'].downcase =~ /bsd/
+      mf.puts '.include "${srcdir}/libffi.bsd.mk"'
     else
-      mf.puts "include $(srcdir)/libffi.mk"
+      mf.puts "include ${srcdir}/libffi.mk"
     end
   end
 end

data/ext/ffi_c/ffi.c

@@ -10,20 +10,21 @@
 #include "MemoryPointer.h"
 #include "AutoPointer.h"
 #include "Struct.h"
-#include "NativeLibrary.h"
+#include "Callback.h"
+#include "DynamicLibrary.h"
 #include "Platform.h"
 #include "Types.h"
+#include "LastError.h"
 
 
 void Init_ffi_c();
 
 static VALUE moduleFFI = Qnil;
-static VALUE moduleNativeType = Qnil;
 static VALUE typeMap = Qnil, sizeMap = Qnil;
 static ID type_size_id = 0, size_id;
 
 int
-rb_FFI_type_size(VALUE type)
+rbffi_type_size(VALUE type)
 {
     int t = TYPE(type);
     if (t == T_FIXNUM || t == T_BIGNUM) {
@@ -40,9 +41,9 @@ rb_FFI_type_size(VALUE type)
             }
         }
         // Not found - call up to the ruby version to resolve
-        return rb_funcall(moduleFFI, rb_intern("type_size"), 1, &type);
+        return NUM2INT(rb_funcall2(moduleFFI, type_size_id, 1, &type));
     } else {
-        return rb_funcall(type, size_id, 0, NULL);
+        return NUM2INT(rb_funcall2(type, size_id, 0, NULL));
     }
 }
 
@@ -50,50 +51,26 @@ void
 Init_ffi_c() {
     moduleFFI = rb_define_module("FFI");
     rb_global_variable(&moduleFFI);
-    moduleNativeType = rb_define_module_under(moduleFFI, "NativeType");
     rb_define_const(moduleFFI, "TypeDefs", typeMap = rb_hash_new());
     rb_define_const(moduleFFI, "SizeTypes", sizeMap = rb_hash_new());
     rb_global_variable(&typeMap);
     rb_global_variable(&sizeMap);
     type_size_id = rb_intern("type_size");
     size_id = rb_intern("size");
-    
-    rb_define_const(moduleNativeType, "VOID", INT2FIX(NATIVE_VOID));
-    rb_define_const(moduleNativeType, "INT8", INT2FIX(NATIVE_INT8));
-    rb_define_const(moduleNativeType, "UINT8", INT2FIX(NATIVE_UINT8));
-    rb_define_const(moduleNativeType, "INT16", INT2FIX(NATIVE_INT16));
-    rb_define_const(moduleNativeType, "UINT16", INT2FIX(NATIVE_UINT16));
-    rb_define_const(moduleNativeType, "INT32", INT2FIX(NATIVE_INT32));
-    rb_define_const(moduleNativeType, "UINT32", INT2FIX(NATIVE_UINT32));
-    rb_define_const(moduleNativeType, "INT64", INT2FIX(NATIVE_INT64));
-    rb_define_const(moduleNativeType, "UINT64", INT2FIX(NATIVE_UINT64));
-    rb_define_const(moduleNativeType, "FLOAT32", INT2FIX(NATIVE_FLOAT32));
-    rb_define_const(moduleNativeType, "FLOAT64", INT2FIX(NATIVE_FLOAT64));
-    rb_define_const(moduleNativeType, "POINTER", INT2FIX(NATIVE_POINTER));
-    rb_define_const(moduleNativeType, "STRING", INT2FIX(NATIVE_STRING));
-    rb_define_const(moduleNativeType, "RBXSTRING", INT2FIX(NATIVE_RBXSTRING));
-    rb_define_const(moduleNativeType, "CHAR_ARRAY", INT2FIX(NATIVE_CHAR_ARRAY));
-    rb_define_const(moduleNativeType, "BUFFER_IN", INT2FIX(NATIVE_BUFFER_IN));
-    rb_define_const(moduleNativeType, "BUFFER_OUT", INT2FIX(NATIVE_BUFFER_OUT));
-    rb_define_const(moduleNativeType, "BUFFER_INOUT", INT2FIX(NATIVE_BUFFER_INOUT));
-    rb_define_const(moduleNativeType, "VARARGS", INT2FIX(NATIVE_VARARGS));
-    if (sizeof(long) == 4) {
-        rb_define_const(moduleNativeType, "LONG", INT2FIX(NATIVE_INT32));
-        rb_define_const(moduleNativeType, "ULONG", INT2FIX(NATIVE_UINT32));
-    } else {
-        rb_define_const(moduleNativeType, "LONG", INT2FIX(NATIVE_INT64));
-        rb_define_const(moduleNativeType, "ULONG", INT2FIX(NATIVE_UINT64));
-    }
-    rb_FFI_Platform_Init();
-    rb_FFI_AbstractMemory_Init();
-    rb_FFI_Pointer_Init();
-    rb_FFI_AutoPointer_Init();
-    rb_FFI_NullPointer_Init();
-    rb_FFI_MemoryPointer_Init();
-    rb_FFI_Buffer_Init();
-    rb_FFI_Callback_Init();
-    rb_FFI_Struct_Init(0);
-    rb_FFI_NativeLibrary_Init();
-    rb_FFI_Invoker_Init();
+
+    rbffi_Type_Init(moduleFFI);
+    rbffi_LastError_Init(moduleFFI);
+    rbffi_Platform_Init(moduleFFI);
+    rbffi_AbstractMemory_Init(moduleFFI);
+    rbffi_Pointer_Init(moduleFFI);
+    rbffi_AutoPointer_Init(moduleFFI);
+    rbffi_NullPointer_Init(moduleFFI);
+    rbffi_MemoryPointer_Init(moduleFFI);
+    rbffi_Buffer_Init(moduleFFI);
+    rbffi_Callback_Init(moduleFFI);
+    rbffi_Struct_Init(moduleFFI);
+    rbffi_DynamicLibrary_Init(moduleFFI);
+    rbffi_Invoker_Init(moduleFFI);
+    rbffi_Types_Init(moduleFFI);
 }
 

data/ext/ffi_c/libffi.bsd.mk

@@ -0,0 +1,34 @@
+# -*- makefile -*-
+#
+# Makefile for BSD systems
+#
+
+INCFLAGS += -I${LIBFFI_BUILD_DIR}/include
+LOCAL_LIBS += ${LIBFFI} -lpthread
+
+LIBFFI_CFLAGS = ${FFI_MMAP_EXEC} -pthread
+LIBFFI_BUILD_DIR = ${.CURDIR}/libffi
+
+.if "${srcdir}" == "."
+  LIBFFI_SRC_DIR := ${.CURDIR}/libffi
+.else
+  LIBFFI_SRC_DIR := ${srcdir}/libffi
+.endif
+
+
+LIBFFI = ${LIBFFI_BUILD_DIR}/.libs/libffi_convenience.a
+LIBFFI_CONFIGURE = ${LIBFFI_SRC_DIR}/configure --disable-static \
+	--with-pic=yes --disable-dependency-tracking
+
+$(OBJS):	${LIBFFI}
+
+$(LIBFFI):		
+	@mkdir -p ${LIBFFI_BUILD_DIR}
+	@if [ ! -f ${LIBFFI_BUILD_DIR}/Makefile ]; then \
+	    echo "Configuring libffi"; \
+	    cd ${LIBFFI_BUILD_DIR} && \
+		/usr/bin/env CC="${CC}" LD="${LD}" CFLAGS="${LIBFFI_CFLAGS}" \
+		/bin/sh ${LIBFFI_CONFIGURE} ${LIBFFI_HOST} > /dev/null; \
+	fi
+	@cd ${LIBFFI_BUILD_DIR} && ${MAKE}
+

data/ext/ffi_c/libffi.darwin.mk

@@ -1,32 +1,52 @@
 # -*- makefile -*-
-ARCHES := 
+
+include ${srcdir}/libffi.gnu.mk
+
 CCACHE := $(shell type -p ccache)
+BUILD_DIR := $(shell pwd)
+
+INCFLAGS += -I${BUILD_DIR}
+
+# Work out which arches we need to compile the lib for
+ARCHES := 
 ifneq ($(findstring -arch ppc,$(CFLAGS)),)
   ARCHES += ppc
 endif
+
 ifneq ($(findstring -arch i386,$(CFLAGS)),)
   ARCHES += i386
 endif
+
 ifneq ($(findstring -arch x86_64,$(CFLAGS)),)
   ARCHES += x86_64
 endif
-ifeq ($(ARCHES),)
-  ARCHES = $(shell arch)
-endif
 
+ifeq ($(strip $(ARCHES)),)
+# Just build the one (default) architecture
+$(LIBFFI):		
+	@mkdir -p $(LIBFFI_BUILD_DIR)
+	@if [ ! -f $(LIBFFI_BUILD_DIR)/Makefile ]; then \
+	    echo "Configuring libffi"; \
+	    cd $(LIBFFI_BUILD_DIR) && \
+		/usr/bin/env CC="$(CC)" LD="$(LD)" CFLAGS="$(LIBFFI_CFLAGS)" \
+		/bin/sh $(LIBFFI_CONFIGURE) $(LIBFFI_HOST) > /dev/null; \
+	fi
+	cd $(LIBFFI_BUILD_DIR) && $(MAKE)
+
+else
+# Build a fat binary and assemble
 build_ffi = \
 	mkdir -p $(BUILD_DIR)/libffi-$(1); \
 	(if [ ! -f $(BUILD_DIR)/libffi-$(1)/Makefile ]; then \
 	    echo "Configuring libffi for $(1)"; \
 	    cd $(BUILD_DIR)/libffi-$(1) && \
-	      env CC="$(CCACHE) $(CC)" CFLAGS="-arch $(1) $(FFI_CFLAGS)" LDFLAGS="-arch $(1)" \
-		$(FFI_CONFIGURE) --host=$(1)-apple-darwin > /dev/null; \
+	      env CC="$(CCACHE) $(CC)" CFLAGS="-arch $(1) $(LIBFFI_CFLAGS)" LDFLAGS="-arch $(1)" \
+		$(LIBFFI_CONFIGURE) --host=$(1)-apple-darwin > /dev/null; \
 	fi); \
 	env MACOSX_DEPLOYMENT_TARGET=10.4 $(MAKE) -C $(BUILD_DIR)/libffi-$(1)
-	
+
 $(LIBFFI):
-	@for arch in $(ARCHES); do $(call build_ffi,$$arch);done
-	
+	@for arch in $(ARCHES); do $(call build_ffi,$$arch);done	
 	# Assemble into a FAT (i386, ppc) library
 	@mkdir -p $(BUILD_DIR)/libffi/.libs
 	env MACOSX_DEPLOYMENT_TARGET=10.4 /usr/bin/libtool -static -o $@ \
@@ -51,5 +71,5 @@ $(LIBFFI):
 		printf "#include \"libffi-ppc/include/ffitarget.h\"\n";\
 		printf "#endif\n";\
 	) > $(LIBFFI_BUILD_DIR)/include/ffitarget.h
-	
 
+endif

data/ext/ffi_c/libffi.gnu.mk

@@ -0,0 +1,29 @@
+# -*- makefile -*-
+#
+#  Common definitions for all systems that use GNU make
+#
+
+
+# Tack the extra deps onto the autogenerated variables
+INCFLAGS += -I$(LIBFFI_BUILD_DIR)/include
+LOCAL_LIBS += $(LIBFFI)
+BUILD_DIR = $(shell pwd)
+LIBFFI_CFLAGS = $(FFI_MMAP_EXEC)
+LIBFFI_BUILD_DIR = $(BUILD_DIR)/libffi
+
+ifeq ($(srcdir),.)
+  LIBFFI_SRC_DIR := $(shell pwd)/libffi
+else
+  LIBFFI_SRC_DIR := $(srcdir)/libffi
+endif
+
+LIBFFI = $(LIBFFI_BUILD_DIR)/.libs/libffi_convenience.a
+LIBFFI_CONFIGURE = $(LIBFFI_SRC_DIR)/configure --disable-static \
+	--with-pic=yes --disable-dependency-tracking
+
+$(OBJS):	$(LIBFFI)
+
+#
+# libffi.mk or libffi.darwin.mk contains rules for building the actual library
+#
+

data/ext/ffi_c/libffi.mk

@@ -1,11 +1,13 @@
 # -*- makefile -*-
 
+include ${srcdir}/libffi.gnu.mk
+
 $(LIBFFI):		
 	@mkdir -p $(LIBFFI_BUILD_DIR)
 	@if [ ! -f $(LIBFFI_BUILD_DIR)/Makefile ]; then \
 	    echo "Configuring libffi"; \
 	    cd $(LIBFFI_BUILD_DIR) && \
-		/usr/bin/env CC="$(CC)" LD="$(LD)" CFLAGS="$(FFI_CFLAGS)" \
-		/bin/sh $(FFI_CONFIGURE) $(LIBFFI_HOST) > /dev/null; \
+		/usr/bin/env CC="$(CC)" LD="$(LD)" CFLAGS="$(LIBFFI_CFLAGS)" \
+		/bin/sh $(LIBFFI_CONFIGURE) $(LIBFFI_HOST) > /dev/null; \
 	fi
 	cd $(LIBFFI_BUILD_DIR) && $(MAKE)

data/ext/ffi_c/rbffi.h

@@ -8,14 +8,12 @@ extern "C" {
 #endif
 
 #define MAX_PARAMETERS (32)
-    
-extern void rb_FFI_AbstractMemory_Init();
-extern void rb_FFI_MemoryPointer_Init();
-extern void rb_FFI_Buffer_Init();
-extern void rb_FFI_Callback_Init();
-extern void rb_FFI_Invoker_Init();
-extern VALUE rb_FFI_AbstractMemory_class;
-extern int rb_FFI_type_size(VALUE type);
+
+extern void rbffi_Type_Init(VALUE ffiModule);
+extern void rbffi_Buffer_Init(VALUE ffiModule);
+extern void rbffi_Invoker_Init(VALUE ffiModule);
+extern VALUE rbffi_AbstractMemoryClass, rbffi_InvokerClass;
+extern int rbffi_type_size(VALUE type);
 
 #ifdef	__cplusplus
 }

data/gen/Rakefile

@@ -0,0 +1,12 @@
+require 'fileutils'
+require "#{File.join(ENV['RUBYLIBDIR'], 'ffi', 'tools', 'types_generator.rb')}"
+types_conf = File.join(ENV['RUBYLIBDIR'], 'ffi', 'types.conf') 
+file types_conf do |task|
+  options = {}
+  FileUtils.mkdir_p(File.dirname(task.name), { :mode => 0755 })
+  File.open(task.name, File::CREAT|File::TRUNC|File::RDWR, 0644) do |f|
+    f.puts FFI::TypesGenerator.generate(options)
+  end
+end
+task :default => types_conf do
+end

data/lib/ffi/autopointer.rb

@@ -28,7 +28,7 @@ module FFI
     # release(), which by default does nothing.
     #
     def initialize(ptr, proc=nil, &block)
-      raise ArgumentError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) \
+      raise TypeError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) \
         || ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
       free_lambda = if proc and proc.is_a? Method
                       AutoPointer.finalize(ptr, AutoPointer.method_to_proc(proc))

data/lib/ffi/enum.rb

@@ -0,0 +1,78 @@
+module FFI
+
+  class Enums
+
+    def initialize
+      @all_enums = Array.new
+      @tagged_enums = Hash.new
+      @symbol_map = Hash.new
+    end
+
+    def <<(enum)
+      @all_enums << enum
+      @tagged_enums[enum.tag] = enum unless enum.tag.nil?
+      @symbol_map.merge!(enum.symbol_map)
+    end
+
+    def find(query)
+      if @tagged_enums.has_key?(query)
+        @tagged_enums[query]
+      else
+        @all_enums.detect { |enum| enum.symbols.include?(query) }
+      end
+    end
+
+    def __map_symbol(symbol)
+      @symbol_map[symbol]
+    end
+
+  end
+
+  class Enum
+    attr_reader :tag
+
+    def initialize(info, tag=nil)
+      @tag = tag
+      @kv_map = Hash.new
+      @vk_map = Hash.new
+      unless info.nil?
+        last_cst = nil
+        value = 0
+        info.each do |i|
+          case i
+          when Symbol
+            @kv_map[i] = value
+            @vk_map[value] = i
+            last_cst = i
+            value += 1
+          when Integer
+            @kv_map[last_cst] = i
+            @vk_map[i] = last_cst
+            value = i+1
+          end
+        end
+      end
+    end
+
+    def symbols
+      @kv_map.keys
+    end
+
+    def [](query)
+      case query
+      when Symbol
+        @kv_map[query]
+      when Integer
+        @vk_map[query]
+      end
+    end
+    alias find []
+
+    def symbol_map
+      @kv_map
+    end
+    alias to_h symbol_map
+
+  end
+
+end

data/lib/ffi/ffi.rb

@@ -30,8 +30,6 @@ module FFI
   #  Specialised error classes
   class NativeError < LoadError; end
   
-  class TypeError < NativeError; end
-  
   class SignatureError < NativeError; end
   
   class NotFoundError < NativeError
@@ -54,6 +52,7 @@ require 'ffi/callback'
 require 'ffi/io'
 require 'ffi/autopointer'
 require 'ffi/variadic'
+require 'ffi/enum'
 
 module FFI
   
@@ -67,7 +66,7 @@ module FFI
     end
     lib
   end
-  def self.create_invoker(lib, name, args, ret, options = { :convention => :default })
+  def self.create_invoker(lib, name, args, ret_type, native_ret_type, options = { :convention => :default })
     # Current artificial limitation based on JRuby::FFI limit
     raise SignatureError, 'FFI functions may take max 32 arguments!' if args.size > 32
 
@@ -82,14 +81,14 @@ module FFI
     else
       raise LoadError, "Invalid library '#{lib}'"
     end
-    function = library.find_symbol(name)
+    function = library.find_function(name)
     raise NotFoundError.new(name, library.name) unless function
 
     args = args.map {|e| find_type(e) }
     if args.length > 0 && args[args.length - 1] == FFI::NativeType::VARARGS
-      invoker = FFI::VariadicInvoker.new(library, function, args, find_type(ret), options)
+      invoker = FFI::VariadicInvoker.new(function, args, ret_type, find_type(native_ret_type), options)
     else
-      invoker = FFI::Invoker.new(library, function, args, find_type(ret), options[:convention].to_s)
+      invoker = FFI::Invoker.new(function, args, ret_type, find_type(native_ret_type), options[:convention].to_s, options[:enums])
     end
     raise NotFoundError.new(name, library.name) unless invoker
     return invoker

data/lib/ffi/io.rb

@@ -3,5 +3,19 @@ module FFI
     def self.for_fd(fd, mode = "r")
       ::IO.for_fd(fd, mode)
     end
+
+    #
+    # A version of IO#read that reads into a native buffer
+    # 
+    # This will be optimized at some future time to eliminate the double copy
+    #
+    def self.native_read(io, buf, len)
+      tmp = io.read(len)
+      return -1 unless tmp
+      buf.put_bytes(0, tmp)
+      tmp.length
+    end
+
   end
-end
+end
+

data/lib/ffi/library.rb

@@ -3,19 +3,26 @@ module FFI::Library
  
   def ffi_lib(*names)
     ffi_libs = []
+    errors = {}
     names.each do |name|
       [ name, FFI.map_library_name(name) ].each do |libname|
         begin
-          lib = FFI::DynamicLibrary.open(libname, FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_LOCAL)
+          lib = FFI::DynamicLibrary.open(libname, FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL)
           if lib
             ffi_libs << lib
             break
           end
-        rescue LoadError => ex
+        rescue Exception => ex
+          errors[name] = ex
         end
       end
     end
-    raise LoadError, "Could not open any of [#{names.join(", ")}]" if ffi_libs.empty?
+    if ffi_libs.empty?
+      msgs = []
+      errors.each {|name, ex| msgs << "Failed to load library '#{name}': #{ex.message}" }
+      raise LoadError.new(msgs.join('\n'))
+    end
+
     @ffi_libs = ffi_libs
   end
   def ffi_convention(convention)
@@ -33,20 +40,21 @@ module FFI::Library
 
   def attach_function(mname, a3, a4, a5=nil)
     cname, arg_types, ret_type = a5 ? [ a3, a4, a5 ] : [ mname.to_s, a3, a4 ]
-    libraries = defined?(@ffi_libs) ? @ffi_libs : [ DEFAULT ]
-    convention = defined?(@ffi_convention) ? @ffi_convention : :default
 
     # Convert :foo to the native type
     arg_types.map! { |e| find_type(e) }
     has_callback = arg_types.any? {|t| t.kind_of?(FFI::CallbackInfo)}
     options = Hash.new
-    options[:convention] = convention
+    options[:convention] = defined?(@ffi_convention) ? @ffi_convention : :default
     options[:type_map] = @ffi_typedefs if defined?(@ffi_typedefs)
+    options[:enums] = @ffi_enums if defined?(@ffi_enums)
+
     # Try to locate the function in any of the libraries
     invokers = []
+    libraries = defined?(@ffi_libs) ? @ffi_libs : [ DEFAULT ]
     libraries.each do |lib|
       begin
-        invokers << FFI.create_invoker(lib, cname.to_s, arg_types, find_type(ret_type), options)
+        invokers << FFI.create_invoker(lib, cname.to_s, arg_types, ret_type, find_type(ret_type), options)
       rescue LoadError => ex
       end if invokers.empty?
     end
@@ -87,7 +95,7 @@ module FFI::Library
     address = nil
     libraries.each do |lib|
       begin
-        address = lib.find_symbol(cname.to_s)
+        address = lib.find_variable(cname.to_s)
         break unless address.nil?
       rescue LoadError
       end
@@ -120,7 +128,7 @@ module FFI::Library
       if ffi_type.is_a?(FFI::CallbackInfo)
         op = :callback
       else
-        raise FFI::TypeError, "Cannot access library variable of type #{type}"
+        raise TypeError, "Cannot access library variable of type #{type}"
       end
     end
     #
@@ -150,20 +158,72 @@ module FFI::Library
     end
     address
   end
-  def callback(name, args, ret)
-    @ffi_callbacks = Hash.new unless defined?(@ffi_callbacks)
-    @ffi_callbacks[name] = FFI::CallbackInfo.new(find_type(ret), args.map { |e| find_type(e) })
+
+  def callback(*args)
+    raise ArgError, "wrong number of arguments" if args.length < 2 || args.length > 3
+    name, params, ret = if args.length == 3
+      args
+    else
+      [ nil, args[0], args[1] ]
+    end
+    cb = FFI::CallbackInfo.new(find_type(ret), params.map { |e| find_type(e) })
+
+    # Add to the symbol -> type map (unless there was no name)
+    unless name.nil?
+      @ffi_callbacks = Hash.new unless defined?(@ffi_callbacks)
+      @ffi_callbacks[name] = cb
+    end
+
+    cb
   end
-  def typedef(current, add)
+  
+  def typedef(current, add, info=nil)
     @ffi_typedefs = Hash.new unless defined?(@ffi_typedefs)
-    if current.kind_of? Integer
-      code = current
+    code = if current.kind_of?(FFI::Type)
+      current
+    elsif current == :enum
+      if add.kind_of?(Array)
+        self.enum(add)
+      else
+        self.enum(info, add)
+      end
     else
-      code = @ffi_typedefs[current] || FFI.find_type(current)
+      @ffi_typedefs[current] || FFI.find_type(current)
     end
 
     @ffi_typedefs[add] = code
   end
+
+  def enum(*args)
+    #
+    # enum can be called as:
+    # enum :zero, :one, :two  # unnamed enum
+    # enum [ :zero, :one, :two ] # equivalent to above
+    # enum :foo, [ :zero, :one, :two ] create an enum named :foo
+    #
+    name, values = if args[0].kind_of?(Symbol) && args[1].kind_of?(Array)
+      [ args[0], args[1] ]
+    elsif args[0].kind_of?(Array)
+      [ nil, args[0] ]
+    else
+      [ nil, args ]
+    end
+    @ffi_enums = FFI::Enums.new unless defined?(@ffi_enums)
+    @ffi_enums << (e = FFI::Enum.new(values, name))
+
+    # If called as enum :foo, [ :zero, :one, :two ], add a typedef alias
+    typedef(e, name) if name
+    e
+  end
+
+  def enum_type(name)
+    @ffi_enums.find(name) if defined?(@ffi_enums)
+  end
+
+  def enum_value(symbol)
+    @ffi_enums.__map_symbol(symbol)
+  end
+
   def find_type(name)
     code = if defined?(@ffi_typedefs) && @ffi_typedefs.has_key?(name)
       @ffi_typedefs[name]
@@ -171,12 +231,13 @@ module FFI::Library
       @ffi_callbacks[name]
     elsif name.is_a?(Class) && name < FFI::Struct
       FFI::NativeType::POINTER
+    elsif name.kind_of?(FFI::Type)
+      name
     end
-    code = name if !code && name.kind_of?(FFI::CallbackInfo)
     if code.nil? || code.kind_of?(Symbol)
       FFI.find_type(name)
     else
       code
     end
   end
-end
+end

data/lib/ffi/pointer.rb

@@ -52,13 +52,13 @@ module FFI
 
     def read_string(len=nil)
       if len
-        get_string(0, len)
+        get_bytes(0, len)
       else
         get_string(0)
       end
     end
     def read_string_length(len)
-      get_string(0, len)
+      get_bytes(0, len)
     end
     def read_string_to_null
       get_string(0)