ffi 0.1.1 → 0.2.0

data/lib/ffi/tools/types_generator.rb

@@ -0,0 +1,123 @@
+require 'tempfile'
+
+module FFI
+  class TypesGenerator
+
+    ##
+    # Maps different C types to the C type representations we use
+
+    TYPE_MAP = {
+               "char" => :char,
+        "signed char" => :char,
+      "__signed char" => :char,
+      "unsigned char" => :uchar,
+
+               "short"     => :short,
+        "signed short"     => :short,
+        "signed short int" => :short,
+      "unsigned short"     => :ushort,
+      "unsigned short int" => :ushort,
+
+               "int" => :int,
+        "signed int" => :int,
+      "unsigned int" => :uint,
+
+               "long" => :long,
+               "long int" => :long,
+        "signed long" => :long,
+        "signed long int" => :long,
+      "unsigned long" => :ulong,
+      "unsigned long int" => :ulong,
+      "long unsigned int" => :ulong,
+
+               "long long"     => :long_long,
+               "long long int" => :long_long,
+        "signed long long"     => :long_long,
+        "signed long long int" => :long_long,
+      "unsigned long long"     => :ulong_long,
+      "unsigned long long int" => :ulong_long,
+
+      "char *" => :string,
+      "void *" => :pointer,
+    }
+
+    def self.generate(options = {})
+      typedefs = nil
+      Tempfile.open 'ffi_types_generator' do |io|
+        io.puts <<-C
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/resource.h>
+        C
+
+        io.close
+        typedefs = `gcc -E -x c #{options[:cppflags]} -D_DARWIN_USE_64_BIT_INODE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -c #{io.path}`
+      end
+      
+      code = ""
+
+      typedefs.each_line do |type|
+        # We only care about single line typedef
+        next unless type =~ /typedef/
+        # Ignore unions or structs
+        next if type =~ /union|struct/
+        
+        # strip off the starting typedef and ending ;
+        type.gsub!(/^(.*typedef\s*)/, "")
+        type.gsub!(/\s*;\s*$/, "")
+    
+        parts = type.split(/\s+/)
+        def_type   = parts.join(" ")
+
+        # GCC does mapping with __attribute__ stuf, also see
+        # http://hal.cs.berkeley.edu/cil/cil016.html section 16.2.7.  Problem
+        # with this is that the __attribute__ stuff can either occur before or
+        # after the new type that is defined...
+        if type =~ /__attribute__/
+          if parts.last =~ /__QI__|__HI__|__SI__|__DI__|__word__/
+
+            # In this case, the new type is BEFORE __attribute__ we need to
+            # find the final_type as the type before the part that starts with
+            # __attribute__
+            final_type = ""
+            parts.each do |p|
+              break if p =~ /__attribute__/
+              final_type = p
+            end
+          else
+            final_type = parts.pop
+          end
+          
+          def_type = case type
+                     when /__QI__/   then "char"
+                     when /__HI__/   then "short"
+                     when /__SI__/   then "int"
+                     when /__DI__/   then "long long"
+                     when /__word__/ then "long"
+                     else                 "int"
+                     end
+
+          def_type = "unsigned #{def_type}" if type =~ /unsigned/
+        else
+          final_type = parts.pop
+          def_type   = parts.join(" ")
+        end
+        
+        if type = TYPE_MAP[def_type]
+          code << "rbx.platform.typedef.#{final_type} = #{type}\n"
+          TYPE_MAP[final_type] = TYPE_MAP[def_type]
+        else
+          # Fallback to an ordinary pointer if we don't know the type
+          if def_type =~ /\*/
+            code << "rbx.platform.typedef.#{final_type} = pointer\n"
+            TYPE_MAP[final_type] = :pointer
+          end
+        end
+      end
+
+      code
+    end
+
+  end
+end
+

data/lib/ffi/types.rb

@@ -0,0 +1,150 @@
+module FFI
+  TypeDefs = Hash.new
+  def self.add_typedef(current, add)
+    if current.kind_of? Integer
+      code = current
+    else
+      code = TypeDefs[current]
+      raise TypeError, "Unable to resolve type '#{current}'" unless code
+    end
+
+    TypeDefs[add] = code
+  end
+  def self.find_type(name, type_map = nil)
+    type_map = TypeDefs if type_map.nil?
+    code = type_map[name]
+    code = name if !code && name.kind_of?(Integer)
+    code = name if !code && name.kind_of?(FFI::CallbackInfo)
+    raise TypeError, "Unable to resolve type '#{name}'" unless code
+    return code
+  end
+
+  # Converts a char
+  add_typedef(NativeType::INT8, :char)
+
+  # Converts an unsigned char
+  add_typedef(NativeType::UINT8, :uchar)
+
+  # Converts an 8 bit int
+  add_typedef(NativeType::INT8, :int8)
+
+  # Converts an unsigned char
+  add_typedef(NativeType::UINT8, :uint8)
+
+  # Converts a short
+  add_typedef(NativeType::INT16, :short)
+
+  # Converts an unsigned short
+  add_typedef(NativeType::UINT16, :ushort)
+
+  # Converts a 16bit int
+  add_typedef(NativeType::INT16, :int16)
+
+  # Converts an unsigned 16 bit int
+  add_typedef(NativeType::UINT16, :uint16)
+
+  # Converts an int
+  add_typedef(NativeType::INT32, :int)
+
+  # Converts an unsigned int
+  add_typedef(NativeType::UINT32, :uint)
+
+  # Converts a 32 bit int
+  add_typedef(NativeType::INT32, :int32)
+
+  # Converts an unsigned 16 bit int
+  add_typedef(NativeType::UINT32, :uint32)
+
+  # Converts a long
+  add_typedef(NativeType::LONG, :long)
+
+  # Converts an unsigned long
+  add_typedef(NativeType::ULONG, :ulong)
+
+  # Converts a 64 bit int
+  add_typedef(NativeType::INT64, :int64)
+
+  # Converts an unsigned 64 bit int
+  add_typedef(NativeType::UINT64, :uint64)
+
+  # Converts a long long
+  add_typedef(NativeType::INT64, :long_long)
+
+  # Converts an unsigned long long
+  add_typedef(NativeType::UINT64, :ulong_long)
+
+  # Converts a float
+  add_typedef(NativeType::FLOAT32, :float)
+
+  # Converts a double
+  add_typedef(NativeType::FLOAT64, :double)
+
+  # Converts a pointer to opaque data
+  add_typedef(NativeType::POINTER, :pointer)
+
+  # For when a function has no return value
+  add_typedef(NativeType::VOID, :void)
+
+  # Converts NUL-terminated C strings
+  add_typedef(NativeType::STRING, :string)
+
+  # Converts FFI::Buffer objects
+  add_typedef(NativeType::BUFFER_IN, :buffer_in)
+  add_typedef(NativeType::BUFFER_OUT, :buffer_out)
+  add_typedef(NativeType::BUFFER_INOUT, :buffer_inout)
+  add_typedef(NativeType::VARARGS, :varargs)
+
+  # Use for a C struct with a char [] embedded inside.
+  add_typedef(NativeType::CHAR_ARRAY, :char_array)
+
+  TypeSizes = {
+    1 => :char,
+    2 => :short,
+    4 => :int,
+    8 => :long_long,
+  }
+  SizeTypes = {
+    NativeType::INT8 => 1,
+    NativeType::UINT8 => 1,
+    NativeType::INT16 => 2,
+    NativeType::UINT16 => 2,
+    NativeType::INT32 => 4,
+    NativeType::UINT32 => 4,
+    NativeType::INT64 => 8,
+    NativeType::UINT64 => 8,
+    NativeType::FLOAT32 => 4,
+    NativeType::FLOAT64 => 8,
+    NativeType::LONG => FFI::Platform::LONG_SIZE / 8,
+    NativeType::ULONG => FFI::Platform::LONG_SIZE / 8,
+    NativeType::POINTER => FFI::Platform::ADDRESS_SIZE / 8,
+  }
+
+  def self.size_to_type(size)
+    if sz = TypeSizes[size]
+      return sz
+    end
+
+    # Be like C, use int as the default type size.
+    return :int
+  end
+  def self.type_size(type)
+    if sz = SizeTypes[find_type(type)]
+      return sz
+    end
+    raise ArgumentError, "Unknown native type"
+  end
+
+  # Load all the platform dependent types
+  begin
+    File.open(File.join(FFI::Platform::CONF_DIR, 'types.conf'), "r") do |f|
+      prefix = "rbx.platform.typedef."
+      f.each_line { |line|
+        if line.index(prefix) == 0
+          new_type, orig_type = line.chomp.slice(prefix.length..-1).split(/\s*=\s*/)
+          add_typedef(orig_type.to_sym, new_type.to_sym)
+        end
+      }
+    end
+  rescue Errno::ENOENT
+  end
+end

data/lib/ffi/variadic.rb

@@ -0,0 +1,30 @@
+module FFI
+  class VariadicInvoker
+    def VariadicInvoker.new(library, function, arg_types, ret_type, options)
+      invoker = self.__new(library, function, ret_type, options[:convention].to_s)
+      invoker.init(arg_types, options[:type_map])
+      invoker
+    end
+    def init(arg_types, type_map)
+      @fixed = Array.new
+      @type_map = type_map
+      arg_types.each_with_index do |type, i|
+        @fixed << type unless type == FFI::NativeType::VARARGS
+      end
+    end
+    def call(*args, &block)
+      param_types = Array.new(@fixed)
+      param_values = Array.new
+      @fixed.each_with_index do |t, i|
+        param_values << args[i]
+      end
+      i = @fixed.length
+      while i < args.length
+        param_types << FFI.find_type(args[i], @type_map)
+        param_values << args[i + 1]
+        i += 2
+      end
+      invoke(param_types, param_values, &block)
+    end
+  end
+end

data/nbproject/Makefile-Default.mk

@@ -17,11 +17,14 @@ CCC=g++
 CXX=g++
 FC=
 
+# Macros
+PLATFORM=GNU-MacOSX
+
 # Include project Makefile
 include ruby-ffi-Makefile.mk
 
 # Object Directory
-OBJECTDIR=build/Default/GNU-MacOSX
+OBJECTDIR=build/Default/${PLATFORM}
 
 # Object Files
 OBJECTFILES=
@@ -41,14 +44,14 @@ LDLIBSOPTIONS=
 
 # Build Targets
 .build-conf: ${BUILD_SUBPROJECTS}
-	cd . && make -f Makefile
+	cd . && rake compile
 
 # Subprojects
 .build-subprojects:
 
 # Clean Targets
 .clean-conf:
-	cd . && make -f Makefile clean
+	cd . && rake clean
 
 # Subprojects
 .clean-subprojects:

data/nbproject/Makefile-impl.mk

@@ -35,19 +35,19 @@ ALLCONFS=Default
 
 
 # build
-.build-impl: .validate-impl .depcheck-impl
+.build-impl: .build-pre .validate-impl .depcheck-impl
 	@#echo "=> Running $@... Configuration=$(CONF)"
 	${MAKE} -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .build-conf
 
 
 # clean
-.clean-impl: .validate-impl .depcheck-impl
+.clean-impl: .clean-pre .validate-impl .depcheck-impl
 	@#echo "=> Running $@... Configuration=$(CONF)"
 	${MAKE} -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .clean-conf
 
 
 # clobber 
-.clobber-impl: .depcheck-impl
+.clobber-impl: .clobber-pre .depcheck-impl
 	@#echo "=> Running $@..."
 	for CONF in ${ALLCONFS}; \
 	do \
@@ -55,7 +55,7 @@ ALLCONFS=Default
 	done
 
 # all 
-.all-impl: .depcheck-impl
+.all-impl: .all-pre .depcheck-impl
 	@#echo "=> Running $@..."
 	for CONF in ${ALLCONFS}; \
 	do \
@@ -92,7 +92,7 @@ ALLCONFS=Default
 
 
 # help
-.help-impl:
+.help-impl: .help-pre
 	@echo "This makefile supports the following configurations:"
 	@echo "    ${ALLCONFS}"
 	@echo ""

data/nbproject/Package-Default.bash

@@ -0,0 +1,72 @@
+#!/bin/bash -x
+
+#
+# Generated - do not edit!
+#
+
+# Macros
+TOP=`pwd`
+PLATFORM=GNU-MacOSX
+TMPDIR=build/Default/${PLATFORM}/tmp-packaging
+TMPDIRNAME=tmp-packaging
+OUTPUT_PATH=MissingOutputInProject
+OUTPUT_BASENAME=MissingOutputInProject
+PACKAGE_TOP_DIR=ruby-ffi/
+
+# Functions
+function checkReturnCode
+{
+    rc=$?
+    if [ $rc != 0 ]
+    then
+        exit $rc
+    fi
+}
+function makeDirectory
+# $1 directory path
+# $2 permission (optional)
+{
+    mkdir -p "$1"
+    checkReturnCode
+    if [ "$2" != "" ]
+    then
+      chmod $2 "$1"
+      checkReturnCode
+    fi
+}
+function copyFileToTmpDir
+# $1 from-file path
+# $2 to-file path
+# $3 permission
+{
+    cp "$1" "$2"
+    checkReturnCode
+    if [ "$3" != "" ]
+    then
+        chmod $3 "$2"
+        checkReturnCode
+    fi
+}
+
+# Setup
+cd "${TOP}"
+mkdir -p dist/Default/${PLATFORM}/package
+rm -rf ${TMPDIR}
+mkdir -p ${TMPDIR}
+
+# Copy files and create directories and links
+cd "${TOP}"
+makeDirectory ${TMPDIR}/ruby-ffi/bin
+copyFileToTmpDir "${OUTPUT_PATH}" "${TMPDIR}/${PACKAGE_TOP_DIR}bin/${OUTPUT_BASENAME}" 0755
+
+
+# Generate tar file
+cd "${TOP}"
+rm -f dist/Default/${PLATFORM}/package/ruby-ffi.tar
+cd ${TMPDIR}
+tar -vcf ../../../../dist/Default/${PLATFORM}/package/ruby-ffi.tar *
+checkReturnCode
+
+# Cleanup
+cd "${TOP}"
+rm -rf ${TMPDIR}