ffi_gen 1.1.0 → 1.2.0

data/lib/ffi_gen/java_output.rb

@@ -16,7 +16,7 @@ class FFIGen
         writer.puts "}"
       end
       writer.puts "}", ""
-      declarations.values.compact.uniq.each do |declaration|
+      declarations.each do |declaration|
         declaration.write_java writer
       end
     end
@@ -24,83 +24,6 @@ class FFIGen
     writer.output
   end
   
-  def to_java_type(full_type, is_array = false)
-    canonical_type = Clang.get_canonical_type full_type
-    data_array = case canonical_type[:kind]
-    when :void            then ["void",       "nil"]
-    when :bool            then ["boolean",    "Boolean"]
-    when :u_char          then ["byte",       "Integer"]
-    when :u_short         then ["short",      "Integer"]
-    when :u_int           then ["int",        "Integer"]
-    when :u_long          then ["NativeLong", "Integer"]
-    when :u_long_long     then ["long",       "Integer"]
-    when :char_s, :s_char then ["byte",       "Integer"]
-    when :short           then ["short",      "Integer"]
-    when :int             then ["int",        "Integer"]
-    when :long            then ["NativeLong", "Integer"]
-    when :long_long       then ["long",       "Integer"]
-    when :float           then ["float",      "Float"]
-    when :double          then ["double",     "Float"]
-    when :pointer
-      if is_array
-        element_type = to_java_type Clang.get_pointee_type(canonical_type)
-        return { jna_type: "#{element_type[:jna_type]}[]", description: "Array of #{element_type[:description]}", parameter_name: element_type[:parameter_name] }
-      end
-      
-      pointee_type = Clang.get_pointee_type canonical_type
-      result = nil
-      case pointee_type[:kind]
-      when :char_s
-        result = ["String", "String"]
-      when :record
-        pointee_declaration = @declarations[Clang.get_cursor_type(Clang.get_type_declaration(pointee_type))]
-        result = [pointee_declaration.java_name, pointee_declaration.java_name] if pointee_declaration and pointee_declaration.written
-      when :function_proto
-        declaration = @declarations[full_type]
-        result = [":#{declaration.java_name}", "Proc(_callback_#{declaration.java_name}_)"] if declaration
-      end
-      
-      if result.nil?
-        pointer_depth = 0
-        pointer_target_name = ""
-        current_type = full_type
-        loop do
-          declaration = Clang.get_type_declaration current_type
-          pointer_target_name = Name.new self, Clang.get_cursor_spelling(declaration).to_s_and_dispose
-          break if not pointer_target_name.empty?
-
-          case current_type[:kind]
-          when :pointer
-            pointer_depth += 1
-            current_type = Clang.get_pointee_type current_type
-          when :unexposed
-            break
-          else
-            pointer_target_name = Name.new self, Clang.get_type_kind_spelling(current_type[:kind]).to_s_and_dispose
-            break
-          end
-        end
-        result = ["Pointer", "FFI::Pointer(#{'*' * pointer_depth}#{pointer_target_name.to_java_classname})", pointer_target_name]
-      end
-      
-      result
-    when :record
-      declaration = @declarations[canonical_type]
-      declaration ? ["#{declaration.java_name}.by_value", declaration.java_name] : ["byte", "unknown"] # TODO
-    when :enum
-      declaration = @declarations[canonical_type]
-      declaration ? [declaration.java_name, "Symbol from _enum_#{declaration.java_name}_", declaration.name] : ["byte", "unknown"] # TODO
-    when :constant_array
-      element_type_data = to_java_type Clang.get_array_element_type(canonical_type)
-      size = Clang.get_array_size canonical_type
-      ["[#{element_type_data[:jna_type]}, #{size}]", "Array<#{element_type_data[:description]}>"]
-    else
-      raise NotImplementedError, "No translation for values of type #{canonical_type[:kind]}"
-    end
-    
-    { jna_type: data_array[0], description: data_array[1], parameter_name: (data_array[2] || Name.new(self, data_array[1])).to_java_downcase }
-  end
-  
   class Name
     JAVA_KEYWORDS = %w{abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for goto if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while}
     
@@ -117,17 +40,26 @@ class FFIGen
     end
   end
   
+  class Type
+    def java_description
+      java_name
+    end
+  end
+  
   class Enum
     def write_java(writer)
+      return if @name.nil?
       shorten_names
       
-      @constants.each do |constant|
-        constant[:symbol] = ":#{constant[:name].to_ruby_downcase}"
-      end
-      
       writer.comment do
-        writer.write_description @comment
-        # TODO constant comments
+        writer.write_description @description
+        writer.puts "", "<em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:#{java_name}).</em>"
+        writer.puts "", "=== Options:"
+        @constants.each do |constant|
+          writer.puts "#{constant[:name].to_java_constant} ::"
+          writer.write_description constant[:comment], false, "  ", "  "
+        end
+        writer.puts "", "@method _enum_#{java_name}_", "@return [Symbol]", "@scope class"
       end
       
       writer.puts "public enum #{java_name} implements NativeEnum {"
@@ -145,22 +77,25 @@ class FFIGen
     def java_name
       @java_name ||= @name.to_java_classname
     end
+    
+    def java_jna_type
+      java_name
+    end
+    
+    def java_description
+      "Symbol from _enum_#{java_name}_"
+    end
   end
   
   class StructOrUnion
     def write_java(writer)
-      @fields.each do |field|
-        field[:symbol] = field[:name].to_java_downcase
-        field[:type_data] = @generator.to_java_type field[:type]
-      end
-      
       writer.comment do
-        writer.write_description @comment
+        writer.write_description @description
         unless @fields.empty?
           writer.puts "", "= Fields:"
           @fields.each do |field|
-            writer.puts "#{field[:symbol]} ::"
-            writer.write_description field[:comment], false, "  (#{field[:type_data][:description]}) ", "  "
+            writer.puts ":#{field[:name].to_java_downcase} ::"
+            writer.write_description field[:comment], false, "  (#{field[:type].java_description}) ", "  "
           end
         end
       end
@@ -168,7 +103,7 @@ class FFIGen
       writer.puts "public static class #{java_name} extends #{@is_union ? 'Union' : (@fields.empty? ? 'PointerType' : 'Structure')} {"
       writer.indent do
         @fields.each do |field|
-          writer.puts "public #{field[:type_data][:jna_type]} #{field[:symbol]};"
+          writer.puts "public #{field[:type].java_jna_type} #{field[:symbol]};"
         end
         writer.puts "// hidden structure" if @fields.empty?
       end
@@ -180,63 +115,166 @@ class FFIGen
     def java_name
       @java_name ||= @name.to_java_classname
     end
+    
+    def java_jna_type
+      @written ? java_name : "Pointer"
+    end
+    
+    def java_description
+      @written ? java_name : "FFI::Pointer(*#{java_name})"
+    end
   end
   
   class FunctionOrCallback
     def write_java(writer)
       return if @is_callback # not yet supported
       
-      @parameters.each do |parameter|
-        parameter[:type_data] = @generator.to_java_type parameter[:type], parameter[:is_array]
-        parameter[:java_name] = !parameter[:name].empty? ? parameter[:name].to_java_downcase : parameter[:type_data][:parameter_name]
-        parameter[:description] = []
-      end
-      return_type_data = @generator.to_java_type @return_type
-      
-      function_description = []
-      return_value_description = []
-      current_description = function_description
-      @comment.split("\n").map do |line|
-        line = writer.prepare_comment_line line
-        if line.gsub!(/\\param (.*?) /, '')
-          parameter = @parameters.find { |p| p[:name].raw == $1 }
-          if parameter
-            current_description = parameter[:description]
-          else
-            current_description << "#{$1}: "
-          end
-        end
-        current_description = return_value_description if line.gsub! '\\returns ', ''
-        current_description << line
-      end
-      
       writer.comment do
-        writer.write_description function_description
+        writer.write_description @function_description
         writer.puts "", "<em>This entry is only for documentation and no real method.</em>" if @is_callback
-        writer.puts "", "@method #{@is_callback ? "_callback_#{java_name}_" : java_name}(#{@parameters.map{ |parameter| parameter[:java_name] }.join(', ')})"
+        writer.puts "", "@method #{@is_callback ? "_callback_#{java_name}_" : java_name}(#{@parameters.map{ |parameter| parameter[:name].to_java_downcase }.join(', ')})"
         @parameters.each do |parameter|
-          writer.write_description parameter[:description], false, "@param [#{parameter[:type_data][:description]}] #{parameter[:java_name]} ", "  "
+          writer.write_description parameter[:description], false, "@param [#{parameter[:type].java_description}] #{parameter[:name].to_java_downcase} ", "  "
         end
-        writer.write_description return_value_description, false, "@return [#{return_type_data[:description]}] ", "  "
+        writer.write_description @return_value_description, false, "@return [#{@return_type.java_description}] ", "  "
         writer.puts "@scope class"
       end
       
-      jna_signature = "#{@parameters.map{ |parameter| "#{parameter[:type_data][:jna_type]} #{parameter[:java_name]}" }.join(', ')}"
+      jna_signature = "#{@parameters.map{ |parameter| "#{parameter[:type].java_jna_type} #{parameter[:name].to_java_downcase}" }.join(', ')}"
       if @is_callback
         writer.puts "callback :#{java_name}, #{jna_signature}", ""
       else
-        writer.puts "@NativeName(\"#{@name.raw}\")", "#{return_type_data[:jna_type]} #{java_name}(#{jna_signature});", ""
+        writer.puts "@NativeName(\"#{@name.raw}\")", "#{@return_type.java_jna_type} #{java_name}(#{jna_signature});", ""
       end
     end
     
     def java_name
       @java_name ||= @name.to_java_downcase
     end
+    
+    def java_jna_type
+      java_name
+    end
+    
+    def java_description
+      "Proc(_callback_#{java_name}_)"
+    end
   end
   
-  class Constant
+  class Define
     def write_java(writer)
-      writer.puts "public static int #{@name.to_java_constant} = #{@value};", ""
+      parts = @value.map { |v|
+        if v.is_a? Array
+          case v[0]
+          when :method then v[1].to_java_downcase
+          when :constant then v[1].to_java_constant
+          else raise ArgumentError
+          end
+        else
+          v
+        end
+      }
+      if @parameters
+        # not implemented
+      else
+        writer.puts "public static int #{@name.to_java_constant} = #{parts.join};", ""
+      end
+    end
+  end
+  
+  class PrimitiveType
+    def java_name
+      case @clang_type
+      when :void
+        "nil"
+      when :bool
+        "Boolean"
+      when :u_char, :u_short, :u_int, :u_long, :u_long_long, :char_s, :s_char, :short, :int, :long, :long_long
+        "Integer"
+      when :float, :double
+        "Float"
+      end
+    end
+    
+    def java_jna_type
+      case @clang_type
+      when :void            then "void"
+      when :bool            then "boolean"
+      when :u_char          then "byte"
+      when :u_short         then "short"
+      when :u_int           then "int"
+      when :u_long          then "NativeLong"
+      when :u_long_long     then "long"
+      when :char_s, :s_char then "byte"
+      when :short           then "short"
+      when :int             then "int"
+      when :long            then "NativeLong"
+      when :long_long       then "long"
+      when :float           then "float"
+      when :double          then "double"
+      end
+    end
+  end
+  
+  class StringType
+    def java_name
+      "String"
+    end
+    
+    def java_jna_type
+      "String"
+    end
+  end
+  
+  class ByValueType
+    def java_name
+      @inner_type.java_name
+    end
+    
+    def java_jna_type
+      @inner_type.java_jna_type
+    end
+  end
+  
+  class PointerType
+    def java_name
+      @pointee_name.to_java_downcase
+    end
+    
+    def java_jna_type
+      "Pointer"
+    end
+    
+    def java_description
+      "FFI::Pointer(#{'*' * @depth}#{@pointee_name ? @pointee_name.to_java_classname : ''})"
+    end
+  end
+  
+  class ArrayType
+    def java_name
+      "array"
+    end
+    
+    def java_jna_type
+      if @constant_size
+        raise
+      else
+        "#{@element_type.java_jna_type}[]"
+      end
+    end
+    
+    def java_description
+      "Array of #{@element_type.java_description}"
+    end
+  end
+    
+  class UnknownType
+    def java_name
+      "unknown"
+    end
+
+    def java_jna_type
+      "byte"
     end
   end
 end

data/lib/ffi_gen/ruby_output.rb

@@ -5,116 +5,49 @@ class FFIGen
     writer.indent do
       writer.puts "extend FFI::Library"
       writer.puts "ffi_lib_flags #{@ffi_lib_flags.map(&:inspect).join(', ')}" if @ffi_lib_flags
-      writer.puts "ffi_lib '#{@ffi_lib}'", ""
+      writer.puts "ffi_lib #{@ffi_lib.inspect}", "" if @ffi_lib
       writer.puts "def self.attach_function(name, *_)", "  begin; super; rescue FFI::NotFoundError => e", "    (class << self; self; end).class_eval { define_method(name) { |*_| raise e } }", "  end", "end", ""
-      declarations.values.compact.uniq.each do |declaration|
+      declarations.each do |declaration|
         declaration.write_ruby writer
       end
     end
     writer.puts "end"
     writer.output
   end
-  
-  def to_ruby_type(full_type)
-    canonical_type = Clang.get_canonical_type full_type
-    data_array = case canonical_type[:kind]
-    when :void            then [":void",       "nil"]
-    when :bool            then [":bool",       "Boolean"]
-    when :u_char          then [":uchar",      "Integer"]
-    when :u_short         then [":ushort",     "Integer"]
-    when :u_int           then [":uint",       "Integer"]
-    when :u_long          then [":ulong",      "Integer"]
-    when :u_long_long     then [":ulong_long", "Integer"]
-    when :char_s, :s_char then [":char",       "Integer"]
-    when :short           then [":short",      "Integer"]
-    when :int             then [":int",        "Integer"]
-    when :long            then [":long",       "Integer"]
-    when :long_long       then [":long_long",  "Integer"]
-    when :float           then [":float",      "Float"]
-    when :double          then [":double",     "Float"]
-    when :pointer
-      pointee_type = Clang.get_pointee_type canonical_type
-      result = nil
-      case pointee_type[:kind]
-      when :char_s
-        result = [":string", "String"]
-      when :record
-        pointee_declaration = @declarations[Clang.get_cursor_type(Clang.get_type_declaration(pointee_type))]
-        result = [pointee_declaration.ruby_name, pointee_declaration.ruby_name] if pointee_declaration and pointee_declaration.written
-      when :function_proto
-        declaration = @declarations[full_type]
-        result = [":#{declaration.ruby_name}", "Proc(_callback_#{declaration.ruby_name}_)"] if declaration
-      end
-      
-      if result.nil?
-        pointer_depth = 0
-        pointer_target_name = ""
-        current_type = full_type
-        loop do
-          declaration = Clang.get_type_declaration current_type
-          pointer_target_name = Name.new self, Clang.get_cursor_spelling(declaration).to_s_and_dispose
-          break if not pointer_target_name.empty?
-
-          case current_type[:kind]
-          when :pointer
-            pointer_depth += 1
-            current_type = Clang.get_pointee_type current_type
-          when :unexposed
-            break
-          else
-            pointer_target_name = Name.new self, Clang.get_type_kind_spelling(current_type[:kind]).to_s_and_dispose
-            break
-          end
-        end
-        result = [":pointer", "FFI::Pointer(#{'*' * pointer_depth}#{pointer_target_name.to_ruby_classname})", pointer_target_name]
-      end
-      
-      result
-    when :record
-      declaration = @declarations[canonical_type]
-      declaration ? ["#{declaration.ruby_name}.by_value", declaration.ruby_name] : [":char", "unknown"] # TODO
-    when :enum
-      declaration = @declarations[canonical_type]
-      declaration ? [":#{declaration.ruby_name}", "Symbol from _enum_#{declaration.ruby_name}_", declaration.name] : [":char", "unknown"] # TODO
-    when :constant_array
-      element_type_data = to_ruby_type Clang.get_array_element_type(canonical_type)
-      size = Clang.get_array_size canonical_type
-      ["[#{element_type_data[:ffi_type]}, #{size}]", "Array<#{element_type_data[:description]}>"]
-    when :unexposed
-      [":char", "unexposed"]
-    else
-      raise NotImplementedError, "No translation for values of type #{canonical_type[:kind]}"
-    end
-    
-    { ffi_type: data_array[0], description: data_array[1], parameter_name: (data_array[2] || Name.new(self, data_array[1])).to_ruby_downcase }
-  end
-  
+
   class Name
     RUBY_KEYWORDS = %w{alias and begin break case class def defined do else elsif end ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield BEGIN END}
 
     def to_ruby_downcase
       format :downcase, :underscores, RUBY_KEYWORDS
     end
-    
+
     def to_ruby_classname
       format :camelcase, RUBY_KEYWORDS
     end
-    
+
     def to_ruby_constant
       format :upcase, :underscores, RUBY_KEYWORDS
     end
   end
-  
+
+  class Type
+    def ruby_description
+      ruby_name
+    end
+  end
+
   class Enum
     def write_ruby(writer)
+      return if @name.nil?
       shorten_names
-      
+
       @constants.each do |constant|
         constant[:symbol] = ":#{constant[:name].to_ruby_downcase}"
       end
-      
+
       writer.comment do
-        writer.write_description @comment
+        writer.write_description @description
         writer.puts "", "<em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:#{ruby_name}).</em>"
         writer.puts "", "=== Options:"
         @constants.each do |constant|
@@ -123,7 +56,7 @@ class FFIGen
         end
         writer.puts "", "@method _enum_#{ruby_name}_", "@return [Symbol]", "@scope class"
       end
-      
+
       writer.puts "enum :#{ruby_name}, ["
       writer.indent do
         writer.write_array @constants, "," do |constant|
@@ -132,41 +65,51 @@ class FFIGen
       end
       writer.puts "]", ""
     end
-    
+
     def ruby_name
       @ruby_name ||= @name.to_ruby_downcase
     end
+
+    def ruby_ffi_type
+      ":#{ruby_name}"
+    end
+
+    def ruby_description
+      "Symbol from _enum_#{ruby_name}_"
+    end
   end
-  
+
   class StructOrUnion
     def write_ruby(writer)
-      @fields.each do |field|
-        field[:symbol] = ":#{field[:name].to_ruby_downcase}"
-        field[:type_data] = @generator.to_ruby_type field[:type]
-      end
-      
       writer.comment do
-        writer.write_description @comment
+        writer.write_description @description
         unless @fields.empty?
           writer.puts "", "= Fields:"
           @fields.each do |field|
-            writer.puts "#{field[:symbol]} ::"
-            writer.write_description field[:comment], false, "  (#{field[:type_data][:description]}) ", "  "
+            writer.puts ":#{field[:name].to_ruby_downcase} ::"
+            writer.write_description field[:comment], false, "  (#{field[:type].ruby_description}) ", "  "
           end
         end
       end
-      
-      @fields << { symbol: ":dummy", type_data: { ffi_type: ":char" } } if @fields.empty?
+
+      @fields << { name: Name.new(["dummy"]), type: PrimitiveType.new(:char_s) } if @fields.empty?
 
       unless @oo_functions.empty?
         writer.puts "module #{ruby_name}Wrappers"
         writer.indent do
-          @oo_functions.each_with_index do |(name, function, return_type_declaration), index|
-            parameter_names = function.parameters[1..-1].map { |parameter| !parameter[:name].empty? ? parameter[:name].to_ruby_downcase : "arg#{function.parameters.index(parameter)}" }
+          @oo_functions.each_with_index do |(name, function), index|
+            parameter_names = function.parameters[1..-1].map { |parameter| parameter[:name].to_ruby_downcase }
             writer.puts "" unless index == 0
+            writer.comment do
+              function.parameters[1..-1].each do |parameter|
+                writer.write_description parameter[:description], false, "@param [#{parameter[:type].ruby_description}] #{parameter[:name].to_ruby_downcase} ", "  "
+              end
+              return_type = function.return_type.is_a?(StructOrUnion) ? function.return_type.ruby_name : function.return_type.ruby_description
+              writer.write_description function.return_value_description, false, "@return [#{return_type}] ", "  "
+            end
             writer.puts "def #{name.to_ruby_downcase}(#{parameter_names.join(', ')})"
             writer.indent do
-              cast = return_type_declaration ? "#{return_type_declaration.ruby_name}.new " : ""
+              cast = function.return_type.is_a?(StructOrUnion) ? "#{function.return_type.ruby_name}.new " : ""
               writer.puts "#{cast}#{@generator.module_name}.#{function.ruby_name}(#{(["self"] + parameter_names).join(', ')})"
             end
             writer.puts "end"
@@ -174,78 +117,186 @@ class FFIGen
         end
         writer.puts "end", ""
       end
-            
+
       writer.puts "class #{ruby_name} < #{@is_union ? 'FFI::Union' : 'FFI::Struct'}"
       writer.indent do
         writer.puts "include #{ruby_name}Wrappers" unless @oo_functions.empty?
         writer.write_array @fields, ",", "layout ", "       " do |field|
-          "#{field[:symbol]}, #{field[:type_data][:ffi_type]}"
+          ":#{field[:name].to_ruby_downcase}, #{field[:type].ruby_ffi_type}"
         end
       end
       writer.puts "end", ""
-      
+
       @written = true
     end
-    
+
     def ruby_name
       @ruby_name ||= @name.to_ruby_classname
     end
+
+    def ruby_ffi_type
+      @written ? ruby_name : ":pointer"
+    end
+
+    def ruby_description
+      @written ? ruby_name : "FFI::Pointer(*#{ruby_name})"
+    end
   end
-  
+
   class FunctionOrCallback
     def write_ruby(writer)
-      @parameters.each do |parameter|
-        parameter[:type_data] = @generator.to_ruby_type parameter[:type]
-        parameter[:ruby_name] = !parameter[:name].empty? ? parameter[:name].to_ruby_downcase : parameter[:type_data][:parameter_name]
-        parameter[:description] = []
-      end
-      return_type_data = @generator.to_ruby_type @return_type
-      
-      function_description = []
-      return_value_description = []
-      current_description = function_description
-      @comment.split("\n").map do |line|
-        line = writer.prepare_comment_line line
-        if line.gsub!(/\\param (.*?) /, '')
-          parameter = @parameters.find { |p| p[:name].raw == $1 }
-          if parameter
-            current_description = parameter[:description]
-          else
-            current_description << "#{$1}: "
-          end
-        end
-        current_description = return_value_description if line.gsub! '\\returns ', ''
-        current_description << line
-      end
-      
       writer.puts "@blocking = true" if @blocking
       writer.comment do
-        writer.write_description function_description
+        writer.write_description @function_description
         writer.puts "", "<em>This entry is only for documentation and no real method.</em>" if @is_callback
-        writer.puts "", "@method #{@is_callback ? "_callback_#{ruby_name}_" : ruby_name}(#{@parameters.map{ |parameter| parameter[:ruby_name] }.join(', ')})"
+        writer.puts "", "@method #{@is_callback ? "_callback_#{ruby_name}_" : ruby_name}(#{@parameters.map{ |parameter| parameter[:name].to_ruby_downcase }.join(', ')})"
         @parameters.each do |parameter|
-          writer.write_description parameter[:description], false, "@param [#{parameter[:type_data][:description]}] #{parameter[:ruby_name]} ", "  "
+          writer.write_description parameter[:description], false, "@param [#{parameter[:type].ruby_description}] #{parameter[:name].to_ruby_downcase} ", "  "
         end
-        writer.write_description return_value_description, false, "@return [#{return_type_data[:description]}] ", "  "
+        writer.write_description @return_value_description, false, "@return [#{@return_type.ruby_description}] ", "  "
         writer.puts "@scope class"
       end
-      
-      ffi_signature = "[#{@parameters.map{ |parameter| parameter[:type_data][:ffi_type] }.join(', ')}], #{return_type_data[:ffi_type]}"
+
+      ffi_signature = "[#{@parameters.map{ |parameter| parameter[:type].ruby_ffi_type }.join(', ')}], #{@return_type.ruby_ffi_type}"
       if @is_callback
         writer.puts "callback :#{ruby_name}, #{ffi_signature}", ""
       else
         writer.puts "attach_function :#{ruby_name}, :#{@name.raw}, #{ffi_signature}", ""
       end
     end
-    
+
     def ruby_name
       @ruby_name ||= @name.to_ruby_downcase
     end
+
+    def ruby_ffi_type
+      ":#{ruby_name}"
+    end
+
+    def ruby_description
+      "Proc(_callback_#{ruby_name}_)"
+    end
   end
-  
-  class Constant
+
+  class Define
     def write_ruby(writer)
-      writer.puts "#{@name.to_ruby_constant} = #{@value}", ""
+      parts = @value.map { |v|
+        if v.is_a? Array
+          case v[0]
+          when :method then v[1].to_ruby_downcase
+          when :constant then v[1].to_ruby_constant
+          else raise ArgumentError
+          end
+        else
+          v
+        end
+      }
+      if @parameters
+        writer.puts "def #{@name.to_ruby_downcase}(#{@parameters.join(", ")})"
+        writer.indent do
+          writer.puts parts.join
+        end
+        writer.puts "end", ""
+      else
+        writer.puts "#{@name.to_ruby_constant} = #{parts.join}", ""
+      end
+    end
+  end
+
+  class PrimitiveType
+    def ruby_name
+      case @clang_type
+      when :void
+        "nil"
+      when :bool
+        "Boolean"
+      when :u_char, :u_short, :u_int, :u_long, :u_long_long, :char_s, :s_char, :short, :int, :long, :long_long
+        "Integer"
+      when :float, :double
+        "Float"
+      end
+    end
+
+    def ruby_ffi_type
+      case @clang_type
+      when :void            then ":void"
+      when :bool            then ":bool"
+      when :u_char          then ":uchar"
+      when :u_short         then ":ushort"
+      when :u_int           then ":uint"
+      when :u_long          then ":ulong"
+      when :u_long_long     then ":ulong_long"
+      when :char_s, :s_char then ":char"
+      when :short           then ":short"
+      when :int             then ":int"
+      when :long            then ":long"
+      when :long_long       then ":long_long"
+      when :float           then ":float"
+      when :double          then ":double"
+      end
+    end
+  end
+
+  class StringType
+    def ruby_name
+      "String"
+    end
+
+    def ruby_ffi_type
+      ":string"
+    end
+  end
+
+  class ByValueType
+    def ruby_name
+      @inner_type.ruby_name
+    end
+
+    def ruby_ffi_type
+      "#{@inner_type.ruby_ffi_type}.by_value"
     end
   end
-end
+
+  class PointerType
+    def ruby_name
+      @pointee_name.to_ruby_downcase
+    end
+
+    def ruby_ffi_type
+      ":pointer"
+    end
+
+    def ruby_description
+      "FFI::Pointer(#{'*' * @depth}#{@pointee_name ? @pointee_name.to_ruby_classname : ''})"
+    end
+  end
+
+  class ArrayType
+    def ruby_name
+      "array"
+    end
+
+    def ruby_ffi_type
+      if @constant_size
+        "[#{@element_type.ruby_ffi_type}, #{@constant_size}]"
+      else
+        ":pointer"
+      end
+    end
+
+    def ruby_description
+      "Array<#{@element_type.ruby_description}>"
+    end
+  end
+
+  class UnknownType
+    def ruby_name
+      "unknown"
+    end
+
+    def ruby_ffi_type
+      ":char"
+    end
+  end
+
+end