ffi2-generators 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8f4b27c539662e9b2d469ed8e8345bb8ed5f0244
+  data.tar.gz: 3a6992fb5b224faf1ec1f85aacaa4b6bbbab7a4c
+SHA512:
+  metadata.gz: b31668fd36d8fdeb444659bc7a78d7682c648a8b98e99b37f86c23eb199939944c0d6a93ee57b447b92e370dff6241bd1daa860bd5e820c86f5d066c7378dd93
+  data.tar.gz: 611e20ede0e0de89462f2142923154c637f0d9574550ac348220a7d82ddffc3b5a618f360c18324affe164ceb911fba2723c635cfeecbc9c489b057485497465

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ffi2-generators.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2013, Brian Shirai
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the library nor the names of its contributors may be
+   used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+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 <COPYRIGHT HOLDER> 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.

data/README.md

@@ -0,0 +1,29 @@
+# Ffi2::Generators
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ffi2-generators'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ffi2-generators
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/ffi2-generators.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+require './lib/ffi2/generators/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ffi2-generators"
+  spec.version       = FFI::Generators::VERSION
+  spec.authors       = ["Brian Shirai"]
+  spec.email         = ["brixen@gmail.com"]
+  spec.description   = %q{Utilities for generating constants, types, and structs for FFI.}
+  spec.summary       = %q{Utilities for generating constants, types, and structs for FFI.}
+  spec.homepage      = "https://github.com/rubinius/ffi2-generators"
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/ffi2/generators.rb

@@ -0,0 +1,164 @@
+require "ffi2/generators/version"
+require "ffi2/generators/constants"
+require "ffi2/generators/structures"
+require "ffi2/generators/types"
+require "ffi2/generators/file_processor"
+
+require "rbconfig"
+
+module FFI
+  module Generators
+
+    ##
+    # BodyGuard does your file system dirty work and cleans up after any
+    # fallout.
+
+    class BodyGuardError < Exception; end
+
+    class BodyGuard
+      def initialize(subject, label, platform)
+        @subject = subject
+        @label = label.gsub(/\W/, '-')
+        @platform = platform
+      end
+
+      ##
+      # Orchestrates a workflow by querying the subject at each stage and cleans
+      # up if problems arise before raising an exception.
+      #
+      # Expects the subject to respond to the following methods:
+      #
+      #   #source io
+      #     Where io is an IO instance used to create the source for later
+      #     stages.
+      #
+      #   #prepare name, target
+      #     Where name is the source file name and target is the file that would
+      #     be created by the prepare process. The method should return the
+      #     command to run.
+      #
+      #   #prepare_failed
+      #     The method should return the error message for #raise to which will
+      #     be appended the output of running the command returned by #prepare.
+      #
+      #   #process target
+      #     Where target is the same as passed to #prepare. The method should
+      #     return the command to run. If no further options or changes are
+      #     needed, #process should just return target.
+      #
+      #   #process_failed
+      #     The method should return the error message for #raise to which will
+      #     be appended the output of running the command returned by #process.
+      #
+      # The #perform method returns the result of running the command returned
+      # by the #process method.
+
+      def perform
+        begin
+          name = "rbx-ffi-generators-#{@label}"
+          source = File.expand_path name + @platform.source_ext
+          target = File.expand_path name + @platform.executable_ext
+
+          File.open source, "wb" do |f|
+            @subject.source f
+          end
+
+          if preparer = @subject.prepare(source, target)
+            handle preparer, :prepare_failed
+          else
+            target = source
+          end
+
+          processor = @subject.process target
+          return handle(processor, :process_failed)
+        ensure
+          remove source, target
+        end
+      end
+
+      def handle(command, failure)
+        result = `#{command}`
+        Process.waitpid $?.pid rescue nil
+
+        unless $?.success?
+          result = result.split("\n").map { |l| "\t#{l}" }.join "\n"
+          msg = "#{@subject.send failure}:\n#{result}"
+          raise BodyGuardError, msg
+        end
+
+        result
+      end
+
+      def remove(*names)
+        names.each do |name|
+          File.delete name if File.exists? name
+        end
+      end
+    end
+
+    class Platform
+      # TODO: Make these configurable to enable cross-compiling
+
+      def initialize(kind=:c)
+        @kind = kind
+      end
+
+      def source_ext
+        case @kind
+        when :c
+          ".c"
+        when :cpp
+          ".cpp"
+        end
+      end
+
+      def executable_ext
+        windows? ? ".exe" : ""
+      end
+
+      def defines
+        case @kind
+        when :c
+          RbConfig::CONFIG["CFLAGS"]
+        when :cpp, :cxx
+          RbConfig::CONFIG["CPPFLAGS"] || RbConfig["CXXFLAGS"]
+        else
+          RbConfig::CONFIG["CFLAGS"]
+        end
+      end
+
+      def windows?
+        RUBY_PLATFORM =~ /mswin|mingw/
+      end
+
+      def compiler
+        case @kind
+        when :c
+          RbConfig::CONFIG["CC"]
+        when :cpp, :cxx
+          RbConfig::CONFIG["CXX"] || RbConfig::CONFIG["CC"]
+        else
+          RbConfig::CONFIG["CC"]
+        end
+      end
+
+      def language
+        case @kind
+        when :c
+          "c"
+        when :cpp, :cxx
+          "c++"
+        else
+          "c"
+        end
+      end
+
+      def compile(include_dirs, source, target)
+        includes = include_dirs.map { |i| "-I#{i}" }.join(" ")
+        compile_options = "#{defines} -x #{language} #{includes} -Wall -Werror"
+
+        "#{compiler} #{compile_options} #{source} -o #{target} 2>&1"
+      end
+    end
+  end
+end

data/lib/ffi2/generators/constants.rb

@@ -0,0 +1,178 @@
+module FFI
+  module Generators
+    ##
+    # Constants turns C constants into ruby values.
+
+    class Constants
+
+      class Constant
+        attr_reader :name, :format, :cast
+        attr_accessor :value
+
+        def initialize(name, format, cast, ruby_name=nil, converter=nil)
+          @name = name
+          @format = format
+          @cast = cast
+          @ruby_name = ruby_name
+          @converter = converter
+          @value = nil
+        end
+
+        def value?
+          @value != nil
+        end
+
+        def converted_value
+          @converter ? @converter.call(@value) : @value
+        end
+
+        def ruby_name
+          @ruby_name || @name
+        end
+
+        def to_ruby
+          "#{ruby_name} = #{converted_value}"
+        end
+      end
+
+
+      attr_reader :constants
+
+      ##
+      # Creates a new constant generator that uses +prefix+ as a name, and an
+      # options hash.
+      #
+      # The only option is :required, which if set to true raises an error if a
+      # constant you have requested was not found.
+      #
+      # When passed a block, #calculate is automatically called at the end of
+      # the block, otherwise you must call it yourself.
+
+      def initialize(prefix=nil, options={})
+        @includes = []
+        @include_dirs = []
+        @constants = {}
+        @prefix = prefix
+        @platform = Platform.new
+
+        @required = options[:required]
+
+        if block_given?
+          yield self
+          calculate
+        end
+      end
+
+      def [](name)
+        @constants[name].value
+      end
+
+      ##
+      # Request the value for C constant +name+.  +format+ is a printf format
+      # string to print the value out, and +cast+ is a C cast for the value.
+      # +ruby_name+ allows you to give the constant an alternate ruby name for
+      # #to_ruby.  +converter+ or +converter_proc+ allow you to convert the
+      # value from a string to the appropriate type for #to_ruby.
+
+      def const(name, format=nil, cast=nil, ruby_name=nil, converter=nil, &block)
+        format ||= '%ld'
+        cast ||= '(long)'
+
+        if block and converter
+          raise ArgumentError, "Supply only converter or converter block"
+        end
+
+        converter = block if converter.nil?
+
+        const = Constant.new name, format, cast, ruby_name, converter
+        @constants[name.to_s] = const
+        return const
+      end
+
+      def source(io)
+        io.puts "#include <stdio.h>"
+
+        @includes.each do |inc|
+          io.puts "#include <#{inc}>"
+        end
+
+        io.puts "#include <stddef.h>\n\n"
+        io.puts "int main(int argc, char **argv)\n{"
+
+        @constants.each_value do |const|
+          io.puts <<-EOF
+  #ifdef #{const.name}
+  printf("#{const.name} #{const.format}\\n", #{const.cast}#{const.name});
+  #endif
+          EOF
+        end
+
+        io.puts "\n\treturn 0;\n}"
+      end
+
+      def prepare(name, target)
+        @platform.compile(@include_dirs, name, target)
+      end
+
+      def prepare_failed
+        "Compilation error generating constants #{@prefix}"
+      end
+
+      def process(target)
+        target
+      end
+
+      def process_failed
+        "Error generating constants #{@prefix}"
+      end
+
+      def calculate
+        output = BodyGuard.new(self, @prefix, @platform).perform
+
+        output.each_line do |line|
+          line =~ /^(\S+)\s(.*)$/
+          const = @constants[$1]
+          const.value = $2
+        end
+
+        missing_constants = @constants.reject { |_, c| c.value? }.keys
+
+        if @required and not missing_constants.empty?
+          raise "Missing required constants for #{@prefix}: #{missing_constants.join ', '}"
+        end
+      end
+
+      def write_constants(io)
+        @constants.each do |name, constant|
+          io.print @prefix, "."
+          io.puts constant.to_ruby
+        end
+      end
+
+      ##
+      # Outputs values for discovered constants.  If the constant's value was
+      # not discovered it is not omitted.
+
+      def to_ruby
+        @constants.sort_by { |name,| name }.map do |name, constant|
+          if constant.value?
+            constant.to_ruby
+          else
+            "# #{name} not defined"
+          end
+        end.join "\n"
+      end
+
+      def include(i)
+        @includes << i
+      end
+
+      def include_dir(i)
+        @include_dirs << i
+      end
+    end
+
+  end
+
+  ConstGenerator = Generators::Constants
+end

data/lib/ffi2/generators/file_processor.rb

@@ -0,0 +1,85 @@
+module FFI
+
+  # Processes a file containing Ruby code with blocks of FFI definitions
+  # delimited by @@@. The blocks are replaced with Ruby code produced by
+  # running the FFI generators contained in the blocks. For example:
+  #
+  #   module Something
+  #     @@@
+  #     constants do |c|
+  #       c.include 'somefile.h'
+  #
+  #       c.const 'MAX'
+  #       c.const 'MIN'
+  #     end
+  #     @@@
+  #   end
+  #
+  # would be converted to:
+  #
+  #   module Something
+  #     MAX = 1
+  #     MIN = 2
+  #   end
+  #
+  # assuming that
+  # 
+  #   #define MAX 1
+  #   #define MIN 2
+  #
+  # was contained in the file 'something.h'.
+
+  class FileProcessor
+
+    def initialize(ffi_name, rb_name)
+      @name = File.basename rb_name, '.rb'
+
+      definitions = File.read ffi_name
+
+      replacement = definitions.gsub(/^( *)@@@(.*?)@@@/m) do
+        @constants = []
+        @structs = []
+
+        indent = $1
+        line_count = $2.count("\n") + 1
+
+        instance_eval $2
+
+        lines = []
+        @constants.each { |c| lines << c.to_ruby }
+        @structs.each { |s| lines << s.generate_layout }
+
+        # expand multiline blocks
+        lines = lines.join("\n").split "\n"
+        lines = lines.map { |line| indent + line }
+
+        # preserve source line numbers in output
+        padding = line_count - lines.length
+        lines += [nil] * padding if padding >= 0
+
+        lines.join "\n"
+      end
+
+      File.open rb_name, 'wb' do |f|
+        f.puts "# This file is generated #{self.class} from #{ffi_name}."
+        f.puts
+        f.puts replacement
+      end
+    end
+
+    def constants(options={}, &block)
+      @constants << FFI::ConstGenerator.new(@name, options, &block)
+    end
+
+    def struct(&block)
+      @structs << FFI::StructGenerator.new(@name, &block)
+    end
+
+    ##
+    # Utility converter for constants
+
+    def to_s
+      proc { |obj| obj.to_s.inspect }
+    end
+  end
+end

data/lib/ffi2/generators/structures.rb

@@ -0,0 +1,198 @@
+module FFI
+  module Generators
+    ##
+    # Generates an FFI Struct layout.
+    #
+    # Given the @@@ portion in:
+    #
+    #   module Zlib::ZStream < FFI::Struct
+    #     @@@
+    #     name "struct z_stream_s"
+    #     include "zlib.h"
+    #   
+    #     field :next_in,   :pointer
+    #     field :avail_in,  :uint
+    #     field :total_in,  :ulong
+    #   
+    #     # ...
+    #     @@@
+    #   end
+    #
+    # Structures will create the layout:
+    #
+    #   layout :next_in, :pointer, 0,
+    #          :avail_in, :uint, 4,
+    #          :total_in, :ulong, 8,
+    #          # ...
+    #
+    # StructGenerator does its best to pad the layout it produces to preserve
+    # line numbers.  Place the struct definition as close to the top of the file
+    # for best results.
+
+    class Structures
+
+      ##
+      # A field in a Struct.
+
+      class Field
+
+        attr_reader :name
+        attr_reader :type
+        attr_reader :offset
+        attr_accessor :size
+
+        def initialize(name, type)
+          @name = name
+          @type = type
+          @offset = nil
+          @size = nil
+        end
+
+        def offset=(o)
+          @offset = o
+        end
+
+        def to_config(name)
+          buf = []
+          buf << "rbx.platform.#{name}.#{@name}.offset = #{@offset}"
+          buf << "rbx.platform.#{name}.#{@name}.size = #{@size}"
+          buf << "rbx.platform.#{name}.#{@name}.type = #{@type}" if @type
+          buf
+        end
+      end
+
+
+      attr_accessor :size
+      attr_reader   :fields
+
+      def initialize(name)
+        @name = name
+        @struct_name = nil
+        @includes = []
+        @include_dirs = []
+        @fields = []
+        @found = false
+        @size = nil
+        @platform = Platform.new
+
+        if block_given? then
+          yield self
+          calculate
+        end
+      end
+
+      def source(io)
+        io.puts "#include <stdio.h>"
+
+        @includes.each do |inc|
+          io.puts "#include <#{inc}>"
+        end
+
+        io.puts "#include <stddef.h>\n\n"
+        io.puts "int main(int argc, char **argv)\n{"
+        io.puts "  #{@struct_name} s;"
+        io.puts %[  printf("sizeof(#{@struct_name}) %u\\n", (unsigned int) sizeof(#{@struct_name}));]
+
+        @fields.each do |field|
+          io.puts <<-EOF
+    printf("#{field.name} %u %u\\n", (unsigned int) offsetof(#{@struct_name}, #{field.name}),
+           (unsigned int) sizeof(s.#{field.name}));
+  EOF
+        end
+
+        io.puts "\n  return 0;\n}"
+      end
+
+      def prepare(name, target)
+        @platform.compile(@include_dirs, name, target)
+      end
+
+      def prepare_failed
+        "Compilation error generating struct #{@name} (#{@struct_name})"
+      end
+
+      def process(target)
+        target
+      end
+
+      def process_failed
+        "Error generating struct #{@name} (#{@struct_name})"
+      end
+
+      def calculate
+        raise "struct name not set" if @struct_name.nil?
+
+        output = BodyGuard.new(self, @struct_name, @platform).perform.split "\n"
+
+        sizeof = output.shift
+        unless @size
+          m = /\s*sizeof\([^)]+\) (\d+)/.match sizeof
+          @size = m[1]
+        end
+
+        line_no = 0
+        output.each do |line|
+          md = line.match(/.+ (\d+) (\d+)/)
+          @fields[line_no].offset = md[1].to_i
+          @fields[line_no].size   = md[2].to_i
+
+          line_no += 1
+        end
+
+        @found = true
+      end
+
+      def field(name, type=nil)
+        field = Field.new(name, type)
+        @fields << field
+        return field
+      end
+
+      def found?
+        @found
+      end
+
+      def write_config(io)
+        io.puts "rbx.platform.#{@name}.sizeof = #{@size}"
+
+        @fields.each { |field| io.puts field.to_config(@name) }
+      end
+
+      def generate_layout
+        buf = ""
+
+        @fields.each_with_index do |field, i|
+          if buf.empty?
+            buf << "layout :#{field.name}, :#{field.type}, #{field.offset}"
+          else
+            buf << "       :#{field.name}, :#{field.type}, #{field.offset}"
+          end
+
+          if i < @fields.length - 1
+            buf << ",\n"
+          end
+        end
+
+        buf
+      end
+
+      def get_field(name)
+        @fields.find { |f| name == f.name }
+      end
+
+      def include(i)
+        @includes << i
+      end
+
+      def include_dir(i)
+        @include_dirs << i
+      end
+
+      def name(n)
+        @struct_name = n
+      end
+    end
+  end
+
+  StructGenerator = Generators::Structures
+end

data/lib/ffi2/generators/types.rb

@@ -0,0 +1,142 @@
+module FFI
+  module Generators
+    class Types
+
+      ##
+      # 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
+        new.generate
+      end
+
+      def initialize
+        @platform = Platform.new
+      end
+
+      def source(io)
+        io.puts "#include <stdint.h>"
+        io.puts "#include <sys/types.h>"
+        unless @platform.windows?
+          io.puts "#include <sys/socket.h>"
+          io.puts "#include <sys/resource.h>"
+        end
+      end
+
+      def prepare(name, target)
+        # we have nothing to do in this stage
+      end
+
+      def process(target)
+        "#{@platform.compiler} -E #{@platform.defines} #{target}"
+      end
+
+      def process_failed
+        "Error generating C types"
+      end
+
+      def generate
+        typedefs = BodyGuard.new(self, "ffi_types_generator", @platform).perform
+
+        code = ""
+
+        typedefs.split(/\n/).each 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
+
+  TypesGenerator = Generators::Types
+end

data/lib/ffi2/generators/version.rb

@@ -0,0 +1,5 @@
+module FFI
+  module Generators
+    VERSION = "0.1.1"
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: ffi2-generators
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Brian Shirai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Utilities for generating constants, types, and structs for FFI.
+email:
+- brixen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ffi2-generators.gemspec
+- lib/ffi2/generators.rb
+- lib/ffi2/generators/constants.rb
+- lib/ffi2/generators/file_processor.rb
+- lib/ffi2/generators/structures.rb
+- lib/ffi2/generators/types.rb
+- lib/ffi2/generators/version.rb
+homepage: https://github.com/rubinius/ffi2-generators
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: Utilities for generating constants, types, and structs for FFI.
+test_files: []