ffi_gen 1.1.0 → 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d8ac88756f647601a2ede8639d9c6534f91d778
+  data.tar.gz: ac9f05381eeef791a9bf41e3aef0c6887165e9ca
+SHA512:
+  metadata.gz: e3fa0b5854c6dbc8fe228a69077af65ea67f88dee3d6a17c995988c46debc140d3d056d9a8c6e698c5183f2c4809ad78d7ca7e7267529b3ae3274d8557674e93
+  data.tar.gz: 2be1889882fd621d0305c6d75bf59e9eac03c95bfd40df5f69c66853ea198fbae298fa1a44a2ddb9955429b76af715182c69ec79738f717d08b8b3515bea7c7e

data/README.md

@@ -1,73 +1,76 @@
-ffi_gen - A generator for Ruby FFI bindings
-===========================================
+# A generator for Ruby FFI bindings
 
-*Author:* Richard Musiol  
-*Contributors:* Jeremy Voorhis (thanks for the initial idea)  
+*Author:* Richard Musiol
+*Contributors:* Jeremy Voorhis (thanks for the initial idea)
 *License:* MIT (see LICENSE)
 
 
-Features
---------
+## Features
+
 * Generation of FFI methods, structures, unions, enumerations and callbacks
 * Generation of YARD documentation comments
 * Tested with headers of the following libraries:
+  * Cairo
+  * CEF (Chromium Embedded Framework)
   * Clang
+  * LibSSH2
   * LLVM
   * OpenGL
   * SQLite3
-  * Cairo
 
 
-Requirements
-------------
+## Requirements
 
 * Ruby 1.9
-* Clang 3.0 ([Download](http://llvm.org/releases/download.html#3.0), use the binaries or configure with ``--enable-shared``)
+* Clang 3.5 or later ([Download](http://llvm.org/releases/download.html#3.5) the binaries or
+  build from source configured with ``--enable-shared``)
 
 *These requirements are only for running the generator. The generated files are Ruby 1.8 compatible and do not need Clang.*
 
 
-Example
--------
+## Example
+
 Use the following interface in a script or Rake task:
 
-    require "ffi_gen"
-    
-    FFIGen.generate(
-      ruby_module: "Clang",
-      ffi_lib:     "clang",
-      headers:     ["clang-c/Index.h"],
-      cflags:      `llvm-config --cflags`.split(" "),
-      prefixes:    ["clang_", "CX"],
-      blacklist:   ["clang_getExpansionLocation"],
-      output:      "Clang/index.rb"
-    )
+```ruby
+require "ffi_gen"
+
+FFIGen.generate(
+  module_name: "Clang",
+  ffi_lib:     "clang",
+  headers:     ["clang-c/Index.h"],
+  cflags:      `llvm-config --cflags`.split(" "),
+  prefixes:    ["clang_", "CX"],
+  output:      "clang-c/index.rb"
+)
+```
 
-Output: [Clang/index.rb](https://github.com/neelance/ffi_gen/blob/master/test/gen/Clang/index.rb)
+Output: [clang-c/index.rb](https://github.com/neelance/ffi_gen/blob/master/test/output/clang-c/Index.rb)
 
-Other generated files can be found in the [test/gen](https://github.com/neelance/ffi_gen/tree/master/test/gen) directory.
+Other generated files can be found in the [test/output](https://github.com/neelance/ffi_gen/tree/master/test/output) directory.
 
 
-Hints
------
+## Hints
 
 You may need to set additional include directories:
 
-    export CPATH=/usr/lib/gcc/x86_64-linux-gnu/4.6.1/include
+```
+export CPATH=/usr/lib/gcc/x86_64-linux-gnu/4.6.1/include
+```
 
 Your GCC include paths can be seen with:
 
-    `gcc -print-prog-name=cc1` -v
+```
+`gcc -print-prog-name=cc1` -v
+```
 
 
-Projects using ffi_gen
-----------------------
+## Projects using ffi_gen
 
 * https://github.com/jvoorhis/ruby-llvm
 
 
-Roadmap
--------
+## Roadmap
 
 * Support for more libraries:
   * (Write me if you have a whish)
@@ -75,6 +78,6 @@ Roadmap
 * Polish YARD documentation comments some more
 
 
-Feedback
---------
-Please use GitHub's issue tracker for problems or suggestions. Pull requests are welcome, too.
+## Feedback
+
+Please use GitHub's issue tracker for problems or suggestions. Pull requests are welcome, too.

data/lib/ffi_gen.rb

@@ -1,18 +1,18 @@
+require 'ffi'
+
 class FFIGen
   require "ffi_gen/clang"
-  require "ffi_gen/ruby_output"
-  require "ffi_gen/java_output"
 
   class << Clang
-    def get_children(declaration)
+    def get_children(cursor)
       children = []
-      visit_children declaration, lambda { |child, child_parent, child_client_data|
+      visit_children cursor, lambda { |visit_result, child, child_parent, child_client_data|
         children << child
         :continue
       }, nil
       children
     end
-    
+
     def get_spelling_location_data(location)
       file_ptr = FFI::MemoryPointer.new :pointer
       line_ptr = FFI::MemoryPointer.new :uint
@@ -28,61 +28,63 @@ class FFIGen
       Clang.tokenize translation_unit, range, tokens_ptr_ptr, num_tokens_ptr
       num_tokens = num_tokens_ptr.read_uint
       tokens_ptr = FFI::Pointer.new Clang::Token, tokens_ptr_ptr.read_pointer
-      num_tokens.times.map { |i| Clang::Token.new tokens_ptr[i] }
+      (num_tokens - 1).times.map { |i| Clang::Token.new tokens_ptr[i] }
     end
   end
-  
+
   class Clang::String
     def to_s
       Clang.get_c_string self
     end
-    
+
     def to_s_and_dispose
       str = to_s
       Clang.dispose_string self
       str
     end
   end
-  
+
   class Clang::Cursor
     def ==(other)
       other.is_a?(Clang::Cursor) && Clang.equal_cursors(self, other) == 1
     end
-    
+
     def eql?(other)
       self == other
     end
-    
+
     def hash
       Clang.hash_cursor self
     end
   end
-  
+
   class Clang::Type
     def ==(other)
       other.is_a?(Clang::Type) && Clang.equal_types(self, other) == 1
     end
-    
+
     def eql?(other)
       self == other
     end
-    
+
     def hash
       0 # no hash available
     end
   end
-  
-  class Enum
+
+  class Type
+  end
+
+  class Enum < Type
     attr_accessor :name
-    attr_reader :constants, :comment
-    
-    def initialize(generator, name, comment)
+
+    def initialize(generator, name, constants, description)
       @generator = generator
       @name = name
-      @comment = comment
-      @constants = []
+      @constants = constants
+      @description = description
     end
-    
+
     def shorten_names
       return if @constants.size < 2
       names = @constants.map { |constant| constant[:name].parts }
@@ -90,47 +92,49 @@ class FFIGen
       names.each(&:pop) while names.map(&:last).uniq.size == 1 and @name.parts.map(&:downcase).include? names.first.last.downcase
     end
   end
-  
-  class StructOrUnion
-    attr_accessor :name, :comment
+
+  class StructOrUnion < Type
+    attr_accessor :name, :description
     attr_reader :fields, :oo_functions, :written
-    
+
     def initialize(generator, name, is_union)
       @generator = generator
       @name = name
       @is_union = is_union
-      @comment = ""
+      @description = []
       @fields = []
       @oo_functions = []
       @written = false
     end
   end
-  
-  class FunctionOrCallback
-    attr_reader :name, :parameters, :comment
-    attr_accessor :return_type
-    
-    def initialize(generator, name, is_callback, blocking, comment)
+
+  class FunctionOrCallback < Type
+    attr_reader :name, :parameters, :return_type, :function_description, :return_value_description
+
+    def initialize(generator, name, parameters, return_type, is_callback, blocking, function_description, return_value_description)
       @generator = generator
       @name = name
-      @parameters = []
+      @parameters = parameters
+      @return_type = return_type
       @is_callback = is_callback
       @blocking = blocking
-      @comment = comment
+      @function_description = function_description
+      @return_value_description = return_value_description
     end
   end
-  
-  class Constant
-    def initialize(generator, name, value)
+
+  class Define
+    def initialize(generator, name, parameters, value)
       @generator = generator
       @name = name
+      @parameters = parameters
       @value = value
     end
   end
-  
+
   class Writer
     attr_reader :output
-    
+
     def initialize(indentation_prefix, comment_prefix, comment_start = nil, comment_end = nil)
       @indentation_prefix = indentation_prefix
       @comment_prefix = comment_prefix
@@ -139,68 +143,53 @@ class FFIGen
       @current_indentation = ""
       @output = ""
     end
-    
+
     def indent(prefix = @indentation_prefix)
       previous_indentation = @current_indentation
       @current_indentation += prefix
       yield
       @current_indentation = previous_indentation
     end
-    
+
     def comment(&block)
       self.puts @comment_start unless @comment_start.nil?
       self.indent @comment_prefix, &block
       self.puts @comment_end unless @comment_end.nil?
     end
-    
+
     def puts(*lines)
       lines.each do |line|
         @output << "#{@current_indentation}#{line}\n"
       end
     end
-    
+
     def write_array(array, separator = "", first_line_prefix = "", other_lines_prefix = "")
       array.each_with_index do |entry, index|
         entry = yield entry if block_given?
         puts "#{index == 0 ? first_line_prefix : other_lines_prefix}#{entry}#{index < array.size - 1 ? separator : ''}"
       end
     end
-    
-    def prepare_comment_line(line)
-      line = line.dup
-      line.sub!(/\ ?\*+\/\s*$/, '')
-      line.sub!(/^\s*\/?\*+ ?/, '')
-      line.gsub!(/\\(brief|determine) /, '')
-      line.gsub!('[', '(')
-      line.gsub!(']', ')')
-      line
-    end
-    
-    def write_description(description, not_documented_message = true, first_line_prefix = "", other_lines_prefix = "")
-      if description.is_a? String
-        description = description.split("\n").map { |line| prepare_comment_line(line) }
-      end
 
+    def write_description(description, not_documented_message = true, first_line_prefix = "", other_lines_prefix = "")
       description.shift while not description.empty? and description.first.strip.empty?
       description.pop while not description.empty? and description.last.strip.empty?
       description.map! { |line| line.gsub "\t", "    " }
       space_prefix_length = description.map{ |line| line.index(/\S/) }.compact.min
       description.map! { |line| line[space_prefix_length..-1] }
       description << (not_documented_message ? "(Not documented)" : "") if description.empty?
-      
+
       write_array description, "", first_line_prefix, other_lines_prefix
     end
   end
-  
+
   class Name
-    attr_reader :raw, :parts
-    
-    def initialize(generator, raw)
-      @generator = generator
+    attr_reader :parts, :raw
+
+    def initialize(parts, raw = nil)
+      @parts = parts
       @raw = raw
-      @parts = @raw.is_a?(Array) ? raw : @raw.sub(/^(#{generator.prefixes.join('|')})/, '').split(/_|(?=[A-Z][a-z])|(?<=[a-z])(?=[A-Z])/).reject(&:empty?)
     end
-    
+
     def format(*modes, keyword_blacklist)
       parts = @parts.dup
       parts.map!(&:downcase) if modes.include? :downcase
@@ -212,28 +201,81 @@ class FFIGen
       str = "#{str}_" if keyword_blacklist.include? str
       str
     end
-    
-    def empty?
-      @parts.empty?
+  end
+
+  class PrimitiveType < Type
+    def initialize(clang_type)
+      @clang_type = clang_type
+    end
+
+    def name
+      Name.new [@clang_type.to_s]
+    end
+  end
+
+  class StringType < Type
+    def name
+      Name.new ["string"]
+    end
+  end
+
+  class ByValueType < Type
+    def initialize(inner_type)
+      @inner_type = inner_type
+    end
+
+    def name
+      @inner_type.name
+    end
+  end
+
+  class PointerType < Type
+    attr_reader :pointee_name, :depth
+
+    def initialize(pointee_name, depth)
+      @pointee_name = pointee_name
+      @depth = depth
+    end
+
+    def name
+      @pointee_name
     end
   end
-  
+
+  class ArrayType < Type
+    def initialize(element_type, constant_size)
+      @element_type = element_type
+      @constant_size = constant_size
+    end
+
+    def name
+      Name.new ["array"]
+    end
+  end
+
+  class UnknownType < Type
+    def name
+      Name.new ["unknown"]
+    end
+  end
+
   attr_reader :module_name, :ffi_lib, :headers, :prefixes, :output, :cflags
 
   def initialize(options = {})
     @module_name   = options[:module_name] or fail "No module name given."
-    @ffi_lib       = options[:ffi_lib] or fail "No FFI library given."
+    @ffi_lib       = options.fetch :ffi_lib, nil
     @headers       = options[:headers] or fail "No headers given."
     @cflags        = options.fetch :cflags, []
     @prefixes      = options.fetch :prefixes, []
+    @suffixes      = options.fetch :suffixes, []
     @blocking      = options.fetch :blocking, []
     @ffi_lib_flags = options.fetch :ffi_lib_flags, nil
     @output        = options.fetch :output, $stdout
-    
+
     @translation_unit = nil
     @declarations = nil
   end
-  
+
   def generate
     code = send "generate_#{File.extname(@output)[1..-1]}"
     if @output.is_a? String
@@ -243,10 +285,10 @@ class FFIGen
       @output.write code
     end
   end
-  
+
   def translation_unit
     return @translation_unit unless @translation_unit.nil?
-    
+
     args = []
     @headers.each do |header|
       args.push "-include", header unless header.is_a? Regexp
@@ -255,233 +297,463 @@ class FFIGen
     args_ptr = FFI::MemoryPointer.new :pointer, args.size
     pointers = args.map { |arg| FFI::MemoryPointer.from_string arg }
     args_ptr.write_array_of_pointer pointers
-    
+
     index = Clang.create_index 0, 0
     @translation_unit = Clang.parse_translation_unit index, File.join(File.dirname(__FILE__), "ffi_gen/empty.h"), args_ptr, args.size, nil, 0, Clang.enum_type(:translation_unit_flags)[:detailed_preprocessing_record]
-    
+
     Clang.get_num_diagnostics(@translation_unit).times do |i|
       diag = Clang.get_diagnostic @translation_unit, i
       $stderr.puts Clang.format_diagnostic(diag, Clang.default_diagnostic_display_options).to_s_and_dispose
     end
-    
+
     @translation_unit
   end
-  
+
   def declarations
     return @declarations unless @declarations.nil?
-    
+
     header_files = []
     Clang.get_inclusions translation_unit, proc { |included_file, inclusion_stack, include_length, client_data|
       filename = Clang.get_file_name(included_file).to_s_and_dispose
       header_files << included_file if @headers.any? { |header| header.is_a?(Regexp) ? header =~ filename : filename.end_with?(header) }
     }, nil
-    
-    @declarations = {}
+
     unit_cursor = Clang.get_translation_unit_cursor translation_unit
+    declaration_cursors = Clang.get_children unit_cursor
+    declaration_cursors.delete_if { |cursor| [:macro_expansion, :inclusion_directive, :var_decl].include? cursor[:kind] }
+    declaration_cursors.delete_if { |cursor| !header_files.include?(Clang.get_spelling_location_data(Clang.get_cursor_location(cursor))[:file]) }
+
+    is_nested_declaration = []
+    min_offset = Clang.get_spelling_location_data(Clang.get_cursor_location(declaration_cursors.last))[:offset]
+    declaration_cursors.reverse_each do |declaration_cursor|
+      offset = Clang.get_spelling_location_data(Clang.get_cursor_location(declaration_cursor))[:offset]
+      is_nested_declaration.unshift(offset > min_offset)
+      min_offset = offset if offset < min_offset
+    end
+
+    @declarations = []
+    @declarations_by_name = {}
+    @declarations_by_type = {}
     previous_declaration_end = Clang.get_cursor_location unit_cursor
-    Clang.get_children(unit_cursor).each do |declaration|
-      file = Clang.get_spelling_location_data(Clang.get_cursor_location(declaration))[:file]
-      
-      extent = Clang.get_cursor_extent declaration
-      comment_range = Clang.get_range previous_declaration_end, Clang.get_range_start(extent)
-      unless [:enum_decl, :struct_decl, :union_decl].include? declaration[:kind] # keep comment for typedef_decl
-        previous_declaration_end = Clang.get_range_end extent
-      end 
-      
-      next if not header_files.include? file
-      
-      comment = extract_comment translation_unit, comment_range
-      
-      read_named_declaration declaration, comment
+    declaration_cursors.each_with_index do |declaration_cursor, index|
+      comment = []
+      unless is_nested_declaration[index]
+        comment_range = Clang.get_range previous_declaration_end, Clang.get_cursor_location(declaration_cursor)
+        comment, _ = extract_comment translation_unit, comment_range
+        previous_declaration_end = Clang.get_range_end Clang.get_cursor_extent(declaration_cursor)
+      end
+
+      read_declaration declaration_cursor, comment
     end
 
     @declarations
   end
-  
-  def read_named_declaration(declaration, comment)
-    name = Name.new self, Clang.get_cursor_spelling(declaration).to_s_and_dispose
 
-    case declaration[:kind]
+  def read_declaration(declaration_cursor, comment)
+    name = read_name declaration_cursor
+
+    declaration = case declaration_cursor[:kind]
     when :enum_decl
-      enum = Enum.new self, name, comment
-      @declarations[Clang.get_cursor_type(declaration)] = enum
-      
-      previous_constant_location = Clang.get_cursor_location declaration
+      enum_description = []
+      constant_descriptions = {}
+      current_description = enum_description
+      comment.each do |line|
+        if line.gsub!(/@(.*?): /, '')
+          current_description = []
+          constant_descriptions[$1] = current_description
+        end
+        current_description = enum_description if line.strip.empty?
+        current_description << line
+      end
+
+      constants = []
+      previous_constant_location = Clang.get_cursor_location declaration_cursor
       next_constant_value = 0
-      Clang.get_children(declaration).each do |enum_constant|
-        constant_name = Name.new self, Clang.get_cursor_spelling(enum_constant).to_s_and_dispose
-        
+      Clang.get_children(declaration_cursor).each do |enum_constant|
+        constant_name = read_name enum_constant
+
         constant_location = Clang.get_cursor_location enum_constant
         constant_comment_range = Clang.get_range previous_constant_location, constant_location
-        constant_comment = extract_comment translation_unit, constant_comment_range
+        constant_description, _ = extract_comment translation_unit, constant_comment_range
+        constant_description.concat(constant_descriptions[constant_name.raw] || [])
         previous_constant_location = constant_location
-        
-        catch :unsupported_value do
+
+        begin
           value_cursor = Clang.get_children(enum_constant).first
           constant_value = if value_cursor
-            read_value value_cursor
+            parts = []
+            Clang.get_tokens(translation_unit, Clang.get_cursor_extent(value_cursor)).each do |token|
+              spelling = Clang.get_token_spelling(translation_unit, token).to_s_and_dispose
+              case Clang.get_token_kind(token)
+              when :literal
+                parts << spelling
+              when :punctuation
+                case spelling
+                when "+", "-", "<<", ">>", "(", ")"
+                  parts << spelling
+                else
+                  raise ArgumentError
+                end
+              else
+                raise ArgumentError
+              end
+            end
+            eval parts.join
           else
             next_constant_value
           end
-          
-          enum.constants << { name: constant_name, value: constant_value, comment: constant_comment }
+
+          constants << { name: constant_name, value: constant_value, comment: constant_description }
           next_constant_value = constant_value + 1
+        rescue ArgumentError
+          puts "Warning: Could not process value of enum constant \"#{constant_name.raw}\""
         end
       end
-      
+
+      Enum.new self, name, constants, enum_description
+
     when :struct_decl, :union_decl
-      struct = @declarations.delete(Clang.get_cursor_type(declaration)) || StructOrUnion.new(self, name, (declaration[:kind] == :union_decl))
+      struct = @declarations_by_type[Clang.get_cursor_type(declaration_cursor)] || StructOrUnion.new(self, name, (declaration_cursor[:kind] == :union_decl))
       raise if not struct.fields.empty?
-      struct.comment << "\n#{comment}"
-      
-      struct_children = Clang.get_children declaration
-      previous_field_end = Clang.get_cursor_location declaration
+      struct.description.concat comment
+
+      struct_children = Clang.get_children declaration_cursor
+      previous_field_end = Clang.get_cursor_location declaration_cursor
+      last_nested_declaration = nil
       until struct_children.empty?
-        nested_declaration = [:struct_decl, :union_decl].include?(struct_children.first[:kind]) ? struct_children.shift : nil
-        field = struct_children.shift
-        raise if field[:kind] != :field_decl
-        
-        field_name = Name.new self, Clang.get_cursor_spelling(field).to_s_and_dispose
-        field_extent = Clang.get_cursor_extent field
-        
-        field_comment_range = Clang.get_range previous_field_end, Clang.get_range_start(field_extent)
-        field_comment = extract_comment translation_unit, field_comment_range
-        
-        # check for comment starting on same line
-        next_field_start = struct_children.first ? Clang.get_cursor_location(struct_children.first) : Clang.get_range_end(Clang.get_cursor_extent(declaration))
-        following_comment_range = Clang.get_range Clang.get_range_end(field_extent), next_field_start
-        following_comment_token = extract_comment translation_unit, following_comment_range, false, false
-        if following_comment_token and Clang.get_spelling_location_data(Clang.get_token_location(translation_unit, following_comment_token))[:line] == Clang.get_spelling_location_data(Clang.get_range_end(field_extent))[:line]
-          field_comment = Clang.get_token_spelling(translation_unit, following_comment_token).to_s_and_dispose
-          previous_field_end = Clang.get_range_end Clang.get_token_extent(translation_unit, following_comment_token)
+        child = struct_children.shift
+        case child[:kind]
+        when :struct_decl, :union_decl
+          last_nested_declaration = read_declaration child, []
+        when :field_decl
+          field_name = read_name child
+          field_extent = Clang.get_cursor_extent child
+
+          field_comment_range = Clang.get_range previous_field_end, Clang.get_range_start(field_extent)
+          field_comment, _ = extract_comment translation_unit, field_comment_range
+
+          # check for comment starting on same line
+          next_field_start = struct_children.first ? Clang.get_cursor_location(struct_children.first) : Clang.get_range_end(Clang.get_cursor_extent(declaration_cursor))
+          following_comment_range = Clang.get_range Clang.get_range_end(field_extent), next_field_start
+          following_comment, following_comment_token = extract_comment translation_unit, following_comment_range, false
+          if following_comment_token and Clang.get_spelling_location_data(Clang.get_token_location(translation_unit, following_comment_token))[:line] == Clang.get_spelling_location_data(Clang.get_range_end(field_extent))[:line]
+            field_comment = following_comment
+            previous_field_end = Clang.get_range_end Clang.get_token_extent(translation_unit, following_comment_token)
+          else
+            previous_field_end = Clang.get_range_end field_extent
+          end
+
+          field_type = resolve_type Clang.get_cursor_type(child)
+          last_nested_declaration.name ||= Name.new(name.parts + field_name.parts) if last_nested_declaration
+          last_nested_declaration = nil
+          struct.fields << { name: field_name, type: field_type, comment: field_comment }
         else
-          previous_field_end = Clang.get_range_end field_extent
-        end
-        
-        if nested_declaration
-          read_named_declaration nested_declaration, ""
-          decl = @declarations[Clang.get_cursor_type(nested_declaration)]
-          decl.name = Name.new(self, name.parts + field_name.parts) if decl and decl.name.empty?
+          raise
         end
-        
-        field_type = Clang.get_cursor_type field
-        struct.fields << { name: field_name, type: field_type, comment: field_comment }
       end
-      
-      @declarations[Clang.get_cursor_type(declaration)] = struct
-    
+
+      struct
+
     when :function_decl
-      function = FunctionOrCallback.new self, name, false, @blocking.include?(name.raw), comment
-      function.return_type = Clang.get_cursor_result_type declaration
-      @declarations[declaration] = function
-      
-      Clang.get_children(declaration).each do |function_child|
+      function_description = []
+      return_value_description = []
+      parameter_descriptions = {}
+      current_description = function_description
+      comment.each do |line|
+        if line.gsub!(/\\param (.*?) /, '')
+          current_description = []
+          parameter_descriptions[$1] = current_description
+        end
+        current_description = return_value_description if line.gsub! '\\returns ', ''
+        current_description << line
+      end
+
+      return_type = resolve_type Clang.get_cursor_result_type(declaration_cursor)
+      parameters = []
+      first_parameter_type = nil
+      Clang.get_children(declaration_cursor).each do |function_child|
         next if function_child[:kind] != :parm_decl
-        param_name = Name.new self, Clang.get_cursor_spelling(function_child).to_s_and_dispose
-        param_type = Clang.get_cursor_type function_child
+        param_name = read_name function_child
         tokens = Clang.get_tokens translation_unit, Clang.get_cursor_extent(function_child)
         is_array = tokens.any? { |t| Clang.get_token_spelling(translation_unit, t).to_s_and_dispose == "[" }
-        function.parameters << { name: param_name, type: param_type, is_array: is_array }
+        param_type = resolve_type Clang.get_cursor_type(function_child), is_array
+        param_name ||= param_type.name
+        param_name ||= Name.new []
+        first_parameter_type ||= Clang.get_cursor_type function_child
+        parameters << { name: param_name, type: param_type }
+      end
+
+      parameters.each_with_index do |parameter, index|
+        parameter[:description] = parameter[:name] && parameter_descriptions[parameter[:name].raw]
+        parameter[:description] ||= parameter_descriptions.values[index] if parameter_descriptions.size == parameters.size # workaround for wrong names
+        parameter[:description] ||= []
       end
-      
-      pointee_declaration = function.parameters.first && get_pointee_declaration(function.parameters.first[:type])
+
+      function = FunctionOrCallback.new self, name, parameters, return_type, false, @blocking.include?(name.raw), function_description, return_value_description
+
+      pointee_declaration = first_parameter_type && get_pointee_declaration(first_parameter_type)
       if pointee_declaration
         type_prefix = pointee_declaration.name.parts.join.downcase
         function_name_parts = name.parts.dup
         while type_prefix.start_with? function_name_parts.first.downcase
           type_prefix = type_prefix[function_name_parts.first.size..-1]
           function_name_parts.shift
+          break if function_name_parts.empty?
         end
         if type_prefix.empty?
-          pointee_declaration.oo_functions << [Name.new(self, function_name_parts), function, get_pointee_declaration(function.return_type)]
+          pointee_declaration.oo_functions << [Name.new(function_name_parts), function]
         end
       end
-    
+
+      function
+
     when :typedef_decl
-      typedef_children = Clang.get_children declaration
+      typedef_children = Clang.get_children declaration_cursor
       if typedef_children.size == 1
-        child_declaration = @declarations[Clang.get_cursor_type(typedef_children.first)]
-        child_declaration.name = name if child_declaration and child_declaration.name.empty?
-        
+        child_declaration = @declarations_by_type[Clang.get_cursor_type(typedef_children.first)]
+        child_declaration.name = name if child_declaration and child_declaration.name.nil?
+        nil
       elsif typedef_children.size > 1
-        callback = FunctionOrCallback.new self, name, true, false, comment
-        callback.return_type = Clang.get_cursor_type typedef_children.first
-        @declarations[Clang.get_cursor_type(declaration)] = callback
-        
-        typedef_children[1..-1].each do |param_decl|
-          param_name = Name.new self, Clang.get_cursor_spelling(param_decl).to_s_and_dispose
-          param_type = Clang.get_cursor_type param_decl
-          callback.parameters << { name:param_name, type: param_type }
+        return_type = resolve_type Clang.get_cursor_type(typedef_children.first)
+        parameters = []
+        typedef_children.each do |param_decl|
+          param_name = read_name param_decl
+          param_type = resolve_type Clang.get_cursor_type(param_decl)
+          param_name ||= param_type.name
+          parameters << { name:param_name, type: param_type, description: [] }
         end
+        FunctionOrCallback.new self, name, parameters, return_type, true, false, comment, []
+      else
+        nil
       end
-        
+
     when :macro_definition
-      tokens = Clang.get_tokens translation_unit, Clang.get_cursor_extent(declaration)
-      if tokens.size == 3
-        if Clang.get_token_kind(tokens[1]) == :literal
-          value = Clang.get_token_spelling(translation_unit, tokens[1]).to_s_and_dispose
-          value.sub!(/[A-Za-z]+$/, '') unless value.start_with? '0x' # remove number suffixes
-          @declarations[name] ||= Constant.new self, name, value
-        end 
+      tokens = Clang.get_tokens(translation_unit, Clang.get_cursor_extent(declaration_cursor)).map { |token|
+        [Clang.get_token_kind(token), Clang.get_token_spelling(translation_unit, token).to_s_and_dispose]
+      }
+      if tokens.size > 1
+        tokens.shift
+        begin
+          parameters = nil
+          if tokens.first[1] == "("
+            tokens_backup = tokens.dup
+            begin
+              parameters = []
+              tokens.shift
+              loop do
+                kind, spelling = tokens.shift
+                case kind
+                when :identifier
+                  parameters << spelling
+                when :punctuation
+                  break if spelling == ")"
+                  raise ArgumentError unless spelling == ","
+                else
+                  raise ArgumentError
+                end
+              end
+            rescue ArgumentError
+              parameters = nil
+              tokens = tokens_backup
+            end
+          end
+          value = []
+          until tokens.empty?
+            kind, spelling = tokens.shift
+            case kind
+            when :literal
+              value << spelling
+            when :punctuation
+              case spelling
+              when "+", "-", "<<", ">>", ")"
+                value << spelling
+              when ","
+                value << ", "
+              when "("
+                if tokens[1][1] == ")"
+                  tokens.delete_at 1
+                else
+                  value << spelling
+                end
+              else
+                raise ArgumentError
+              end
+            when :identifier
+              raise ArgumentError unless parameters
+              if parameters.include? spelling
+                value << spelling
+              elsif spelling == "NULL"
+                value << "nil"
+              else
+                if not tokens.empty? and tokens.first[1] == "("
+                  tokens.shift
+                  if spelling == "strlen"
+                    argument_kind, argument_spelling = tokens.shift
+                    second_token_kind, second_token_spelling = tokens.shift
+                    raise ArgumentError unless argument_kind == :identifier and second_token_spelling == ")"
+                    value << "#{argument_spelling}.length"
+                  else
+                    value << [:method, read_name(spelling)]
+                    value << "("
+                  end
+                else
+                  value << [:constant, read_name(spelling)]
+                end
+              end
+            when :keyword
+              raise ArgumentError unless spelling == "sizeof" and tokens[0][1] == "(" and tokens[1][0] == :literal and tokens[2][1] == ")"
+              tokens.shift
+              argument_kind, argument_spelling = tokens.shift
+              value << "#{argument_spelling}.length"
+              tokens.shift
+            else
+              raise ArgumentError
+            end
+          end
+          Define.new(self, name, parameters, value)
+        rescue ArgumentError
+          puts "Warning: Could not process value of macro \"#{name.raw}\""
+          nil
+        end
+      else
+        nil
       end
-      
+
+    else
+      raise declaration_cursor[:kind].to_s
+
     end
+
+    return nil if declaration.nil?
+    @declarations.delete declaration
+    @declarations << declaration
+    @declarations_by_name[name] = name.raw unless name.nil?
+    type = Clang.get_cursor_type declaration_cursor
+    @declarations_by_type[type] = declaration unless type.nil?
+
+    declaration
   end
-  
-  def read_value(cursor)
-    parts = []
-    tokens = Clang.get_tokens translation_unit, Clang.get_cursor_extent(cursor)
-    tokens.each do |token|
-      spelling = Clang.get_token_spelling(translation_unit, token).to_s_and_dispose
-      case Clang.get_token_kind(token)
-      when :literal
-        parts << spelling
-      when :punctuation
-        case spelling
-        when ",", "}"
-          # ignored
-        when "+", "-", "<<", ">>"
-          parts << spelling
+
+  def resolve_type(full_type, is_array = false)
+    canonical_type = Clang.get_canonical_type full_type
+    data_array = case canonical_type[:kind]
+    when :void, :bool, :u_char, :u_short, :u_int, :u_long, :u_long_long, :char_s, :s_char, :short, :int, :long, :long_long, :float, :double
+      PrimitiveType.new canonical_type[:kind]
+    when :pointer
+      if is_array
+        ArrayType.new resolve_type(Clang.get_pointee_type(canonical_type)), nil
+      else
+        pointee_type = Clang.get_pointee_type canonical_type
+        type = case pointee_type[:kind]
+        when :char_s
+          StringType.new
+        when :record
+          @declarations_by_type[Clang.get_cursor_type(Clang.get_type_declaration(pointee_type))]
+        when :function_proto
+          @declarations_by_type[full_type]
         else
-          throw :unsupported_value
+          nil
         end
-      else
-        throw :unsupported_value
+
+        if type.nil?
+          pointer_depth = 0
+          pointee_name = ""
+          current_type = full_type
+          loop do
+            declaration_cursor = Clang.get_type_declaration current_type
+            pointee_name = read_name declaration_cursor
+            break if pointee_name
+
+            case current_type[:kind]
+            when :pointer
+              pointer_depth += 1
+              current_type = Clang.get_pointee_type current_type
+            when :unexposed
+              break
+            else
+              pointee_name = Name.new Clang.get_type_kind_spelling(current_type[:kind]).to_s_and_dispose.split("_")
+              break
+            end
+          end
+          type = PointerType.new pointee_name, pointer_depth
+        end
+
+        type
       end
+    when :record
+      type = @declarations_by_type[canonical_type]
+      type &&= ByValueType.new(type)
+      type || UnknownType.new # TODO
+    when :enum
+      @declarations_by_type[canonical_type] || UnknownType.new # TODO
+    when :constant_array
+      ArrayType.new resolve_type(Clang.get_array_element_type(canonical_type)), Clang.get_array_size(canonical_type)
+    when :unexposed, :function_proto
+      UnknownType.new
+    when :incomplete_array
+      PointerType.new resolve_type(Clang.get_array_element_type(canonical_type)).name, 1
+    else
+      raise NotImplementedError, "No translation for values of type #{canonical_type[:kind]}"
     end
-    eval parts.join
   end
-  
+
+  def read_name(source)
+    source = Clang.get_cursor_spelling(source).to_s_and_dispose if source.is_a? Clang::Cursor
+    return nil if source.empty?
+    trimmed = source.sub(/^(#{@prefixes.join('|')})/, '')
+    trimmed = trimmed.sub(/(#{@suffixes.join('|')})$/, '')
+    parts = trimmed.split(/_|(?=[A-Z][a-z])|(?<=[a-z])(?=[A-Z])/).reject(&:empty?)
+    Name.new parts, source
+  end
+
   def get_pointee_declaration(type)
     canonical_type = Clang.get_canonical_type type
     return nil if canonical_type[:kind] != :pointer
     pointee_type = Clang.get_pointee_type canonical_type
     return nil if pointee_type[:kind] != :record
-    @declarations[Clang.get_cursor_type(Clang.get_type_declaration(pointee_type))]
+    @declarations_by_type[Clang.get_cursor_type(Clang.get_type_declaration(pointee_type))]
   end
-  
-  def extract_comment(translation_unit, range, search_backwards = true, return_spelling = true)
+
+  def extract_comment(translation_unit, range, search_backwards = true)
     tokens = Clang.get_tokens translation_unit, range
+
     iterator = search_backwards ? tokens.reverse_each : tokens.each
+    comment_lines = []
+    comment_token = nil
+    comment_block = false
     iterator.each do |token|
-      if Clang.get_token_kind(token) == :comment
-        return return_spelling ? Clang.get_token_spelling(translation_unit, token).to_s_and_dispose : token
-      end
+      next if Clang.get_token_kind(token) != :comment
+      comment = Clang.get_token_spelling(translation_unit, token).to_s_and_dispose
+      lines = comment.split("\n").map { |line|
+        line.sub!(/\ ?\*+\/\s*$/, '')
+        line.sub!(/^\s*\/?[*\/]+ ?/, '')
+        line.gsub!(/\\(brief|determine) /, '')
+        line.gsub!('[', '(')
+        line.gsub!(']', ')')
+        line
+      }
+      comment_lines = lines + comment_lines
+      comment_token = token
+      comment_block = !comment_block if comment == "///"
+      break unless comment_block and search_backwards
     end
-    ""
+
+    return comment_lines, comment_token
   end
-  
+
   def self.generate(options = {})
     self.new(options).generate
   end
-  
+
+  require "ffi_gen/ruby_output"
+  require "ffi_gen/java_output"
 end
 
 if __FILE__ == $0
   FFIGen.generate(
     module_name: "FFIGen::Clang",
-    ffi_lib:     "clang",
-    headers:     ["clang-c/Index.h"],
+    ffi_lib:     ["libclang-3.5.so.1", "libclang.so.1", "clang"],
+    headers:     ["clang-c/CXErrorCode.h", "clang-c/CXString.h", "clang-c/Index.h"],
     cflags:      `llvm-config --cflags`.split(" "),
     prefixes:    ["clang_", "CX"],
     output:      File.join(File.dirname(__FILE__), "ffi_gen/clang.rb")