ffi 0.6.4 → 1.0.0

data/lib/ffi/pointer.rb

@@ -3,28 +3,20 @@
 # Copyright (c) 2007, 2008 Evan Phoenix
 # All rights reserved.
 #
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
+# This file is part of ruby-ffi.
 #
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the Evan Phoenix nor the names of its contributors
-#   may be used to endorse or promote products derived from this software
-#   without specific prior written permission.
+# 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/>.
 #
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 require 'ffi/platform'
 module FFI
@@ -95,10 +87,11 @@ module FFI
       put_bytes(0, str, 0, len)
     end
     def write_string(str, len=nil)
-      len = str.size unless len
+      len = str.bytesize unless len
       # Write the string data without NUL termination
       put_bytes(0, str, 0, len)
     end
+
     def read_array_of_type(type, reader, length)
       ary = []
       size = FFI.type_size(type)

data/lib/ffi/struct.rb

@@ -1,34 +1,28 @@
 #
-# Copyright (C) 2008, 2009 Wayne Meissner
+# Copyright (C) 2008-2010 Wayne Meissner
 # Copyright (C) 2008, 2009 Andrea Fazzi
 # Copyright (C) 2008, 2009 Luc Heinrich
 #
 # All rights reserved.
 #
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
+# This file is part of ruby-ffi.
 #
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the Evan Phoenix nor the names of its contributors
-#   may be used to endorse or promote products derived from this software
-#   without specific prior written permission.
+# 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/>.
 #
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 require 'ffi/platform'
+require 'ffi/struct_layout_builder'
+
 module FFI
 
   class StructLayout
@@ -53,7 +47,7 @@ module FFI
 
     end
 
-    class InlineStruct < Field
+    class InnerStruct < Field
       def get(ptr)
         type.struct_class.new(ptr.slice(self.offset, self.size))
       end
@@ -62,6 +56,21 @@ module FFI
 #        raise TypeError, "wrong value type (expected #{type.struct_class}" unless value.is_a(type.struct_class)
 #      end
     end
+
+    class Mapped < Field
+      def initialize(name, offset, type, orig_field)
+        super(name, offset, type)
+        @orig_field = orig_field
+      end
+
+      def get(ptr)
+        type.from_native(@orig_field.get(ptr), nil)
+      end
+
+      def put(ptr, value)
+        @orig_field.put(ptr, type.to_native(value, nil))
+      end
+    end
   end
 
   
@@ -131,27 +140,60 @@ module FFI
     end
 
     def self.in
-      :buffer_in
+      ptr(:in)
     end
 
     def self.out
-      :buffer_out
+      ptr(:out)
+    end
+
+    def self.ptr(flags = :inout)
+      @ref_data_type ||= Type::Mapped.new(StructByReference.new(self))
+    end
+
+    def self.val
+      @val_data_type ||= StructByValue.new(self)
     end
 
     def self.by_value
-      ::FFI::StructByValue.new(self)
+      self.val
+    end
+
+    def self.by_ref(flags = :inout)
+      self.ptr(flags)
+    end
+
+    class ManagedStructConverter < StructByReference
+
+      def initialize(struct_class)
+        super(struct_class)
+
+        raise NoMethodError, "release() not implemented for class #{struct_class}" unless struct_class.respond_to? :release
+        @method = struct_class.method(:release)
+      end
+
+      def from_native(ptr, ctx)
+        struct_class.new(AutoPointer.new(ptr, @method))
+      end
     end
 
+    def self.auto_ptr
+      @managed_type ||= Type::Mapped.new(ManagedStructConverter.new(self))
+    end
 
 
     class << self
       public
 
       def layout(*spec)
+#        raise RuntimeError, "struct layout already defined for #{self.inspect}" if defined?(@layout)
         return @layout if spec.size == 0
 
-        builder = FFI::StructLayoutBuilder.new
+        builder = StructLayoutBuilder.new
         builder.union = self < Union
+        builder.packed = @packed if defined?(@packed)
+        builder.alignment = @min_alignment if defined?(@min_alignment)
+
         if spec[0].kind_of?(Hash)
           hash_layout(builder, spec)
         else
@@ -159,7 +201,7 @@ module FFI
         end
         builder.size = @size if defined?(@size) && @size > builder.size
         cspec = builder.build
-        @layout = cspec unless self == FFI::Struct
+        @layout = cspec unless self == Struct
         @size = cspec.size
         return cspec
       end
@@ -172,6 +214,15 @@ module FFI
         FFI::CallbackInfo.new(find_type(ret, mod), params.map { |e| find_type(e, mod) })
       end
 
+      def packed(packed = 1)
+        @packed = packed
+      end
+      alias :pack :packed
+      
+      def aligned(alignment = 1)
+        @min_alignment = alignment
+      end
+      alias :align :aligned
 
       def enclosing_module
         begin
@@ -182,35 +233,38 @@ module FFI
         end
       end
 
-      def find_type(type, mod = nil)
-        if type.kind_of?(Class) && type < FFI::Struct
+
+      def find_field_type(type, mod = enclosing_module)
+        if type.kind_of?(Class) && type < Struct
           FFI::Type::Struct.new(type)
-        elsif type.is_a?(::Array)
+
+        elsif type.kind_of?(Class) && type < FFI::StructLayout::Field
           type
-        elsif mod
+
+        elsif type.kind_of?(::Array)
+          FFI::Type::Array.new(find_field_type(type[0]), type[1])
+
+        else
+          find_type(type, mod)
+        end
+      end
+
+      def find_type(type, mod = enclosing_module)
+        if mod
           mod.find_type(type)
         end || FFI.find_type(type)
       end
 
-
       private
 
       def hash_layout(builder, spec)
         raise "Ruby version not supported" if RUBY_VERSION =~ /1.8.*/
-        mod = enclosing_module
-        spec[0].each do |name,type|
-          if type.kind_of?(Class) && type < Struct
-            builder.add_struct(name, type)
-          elsif type.kind_of?(::Array)
-            builder.add_array(name, find_type(type[0], mod), type[1])
-          else
-            builder.add_field(name, find_type(type, mod))
-          end
+        spec[0].each do |name, type|
+          builder.add name, find_field_type(type), nil
         end
       end
 
       def array_layout(builder, spec)
-        mod = enclosing_module
         i = 0
         while i < spec.size
           name, type = spec[i, 2]
@@ -223,13 +277,8 @@ module FFI
           else
             offset = nil
           end
-          if type.kind_of?(Class) && type < Struct
-            builder.add_struct(name, type, offset)
-          elsif type.kind_of?(::Array)
-            builder.add_array(name, find_type(type[0], mod), type[1], offset)
-          else
-            builder.add_field(name, find_type(type, mod), offset)
-          end
+
+          builder.add name, find_field_type(type), offset
         end
       end
     end

data/lib/ffi/struct_layout_builder.rb

@@ -0,0 +1,158 @@
+#
+# Copyright (C) 2008-2010 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/>.
+#
+
+module FFI
+  class StructLayoutBuilder
+    attr_reader :size, :alignment
+    
+    def initialize
+      @size = 0
+      @alignment = 1
+      @min_alignment = 1
+      @packed = false
+      @union = false
+      @fields = Array.new
+    end
+
+    def size=(size)
+      @size = size if size > @size
+    end
+
+    def alignment=(align)
+      @alignment = align if align > @alignment
+      @min_alignment = align
+    end
+
+    def union=(is_union)
+      @union = is_union
+    end
+
+    def union?
+      @union
+    end
+
+    def packed=(packed)
+      if packed.is_a?(Fixnum)
+        @alignment = packed
+        @packed = packed
+      else
+        @packed = packed ? 1 : 0
+      end
+    end
+
+
+    NUMBER_TYPES = [
+      Type::INT8,
+      Type::UINT8,
+      Type::INT16,
+      Type::UINT16,
+      Type::INT32,
+      Type::UINT32,
+      Type::LONG,
+      Type::ULONG,
+      Type::INT64,
+      Type::UINT64,
+      Type::FLOAT32,
+      Type::FLOAT64,
+    ]
+
+    def add(name, type, offset = nil)
+
+      if offset.nil? || offset == -1
+        offset = @union ? 0 : align(@size, @packed ? [ @packed, type.alignment ].min : [ @min_alignment, type.alignment ].max)
+      end
+
+      #
+      # If a FFI::Type type was passed in as the field arg, try and convert to a StructLayout::Field instance
+      #
+      field = type.is_a?(StructLayout::Field) ? type : field_for_type(name, offset, type)
+      @fields << field
+      @alignment = [ @alignment, field.alignment ].max unless @packed
+      @size = [ @size, field.size + (@union ? 0 : field.offset) ].max
+
+      return self
+    end
+
+    def add_field(name, type, offset = nil)
+      add(name, type, offset)
+    end
+    
+    def add_struct(name, type, offset = nil)
+      add(name, Type::Struct.new(type), offset)
+    end
+
+    def add_array(name, type, count, offset = nil)
+      add(name, Type::Array.new(type, count), offset)
+    end
+
+    def build
+      # Add tail padding if the struct is not packed
+      size = @packed ? @size : align(@size, @alignment)
+      
+      StructLayout.new(@fields, size, @alignment)
+    end
+
+    private
+    
+    def align(offset, align)
+      align + ((offset - 1) & ~(align - 1));
+    end
+
+    def field_for_type(name, offset, type)
+      field_class = case
+      when type.is_a?(Type::Function)
+        StructLayout::Function
+
+      when type.is_a?(Type::Struct)
+        StructLayout::InnerStruct
+
+      when type.is_a?(Type::Array)
+        StructLayout::Array
+
+      when type.is_a?(FFI::Enum)
+        StructLayout::Enum
+
+      when NUMBER_TYPES.include?(type)
+        StructLayout::Number
+
+      when type == Type::POINTER
+        StructLayout::Pointer
+
+      when type == Type::STRING
+        StructLayout::String
+
+      when type.is_a?(Class) && type < StructLayout::Field
+        type
+
+      when type.is_a?(DataConverter)
+        return StructLayout::Mapped.new(name, offset, Type::Mapped.new(type), field_for_type(name, offset, type.native_type))
+
+      when type.is_a?(Type::Mapped)
+        return StructLayout::Mapped.new(name, offset, type, field_for_type(name, offset, type.native_type))
+
+      else
+        raise TypeError, "invalid struct field type #{type.inspect}"
+      end
+
+      field_class.new(name, offset, type)
+    end
+  end
+
+end