ffi_gen 1.0.2 → 1.1.0

data/lib/ffi_gen/clang.rb

@@ -8,6 +8,7 @@ module FFIGen::Clang
   
   # A single translation unit, which resides in an index.
   class TranslationUnitImpl < FFI::Struct
+    layout :dummy, :char
   end
   
   # Provides the contents of a file that has not yet been saved to disk.
@@ -316,7 +317,7 @@ module FFIGen::Clang
   # @method get_presumed_location(location, filename, line, column)
   # @param [SourceLocation] location the location within a source file that will be decomposed
   #   into its parts.
-  # @param [FFI::Pointer(*String)] filename (out) if non-NULL, will be set to the filename of the
+  # @param [String] filename (out) if non-NULL, will be set to the filename of the
   #   source location. Note that filenames returned will be for "virtual" files,
   #   which don't necessarily exist on the machine running clang - e.g. when
   #   parsing preprocessed output obtained from a different environment. If
@@ -329,7 +330,7 @@ module FFIGen::Clang
   #   source location. For an invalid source location, zero is returned.
   # @return [nil] 
   # @scope class
-  attach_function :get_presumed_location, :clang_getPresumedLocation, [SourceLocation.by_value, :pointer, :pointer, :pointer], :void
+  attach_function :get_presumed_location, :clang_getPresumedLocation, [SourceLocation.by_value, String, :pointer, :pointer], :void
   
   # Legacy API to retrieve the file, line, column, and offset represented
   # by the given source location.
@@ -565,12 +566,12 @@ module FFIGen::Clang
   # 
   # @method get_diagnostic_option(diag, disable)
   # @param [FFI::Pointer(Diagnostic)] diag The diagnostic to be queried.
-  # @param [FFI::Pointer(*String)] disable If non-NULL, will be set to the option that disables this
+  # @param [String] disable If non-NULL, will be set to the option that disables this
   #   diagnostic (if any).
   # @return [String] A string that contains the command-line option used to enable this
   #   warning, such as "-Wconversion" or "-pedantic". 
   # @scope class
-  attach_function :get_diagnostic_option, :clang_getDiagnosticOption, [:pointer, :pointer], String.by_value
+  attach_function :get_diagnostic_option, :clang_getDiagnosticOption, [:pointer, String], String.by_value
   
   # Retrieve the category number for this diagnostic.
   # 
@@ -640,14 +641,14 @@ module FFIGen::Clang
   # @method get_diagnostic_fix_it(diagnostic, fix_it, replacement_range)
   # @param [FFI::Pointer(Diagnostic)] diagnostic The diagnostic whose fix-its are being queried.
   # @param [Integer] fix_it The zero-based index of the fix-it.
-  # @param [FFI::Pointer(*SourceRange)] replacement_range The source range whose contents will be
+  # @param [SourceRange] replacement_range The source range whose contents will be
   #   replaced with the returned replacement string. Note that source
   #   ranges are half-open ranges (a, b), so the source code should be
   #   replaced from a and up to (but not including) b.
   # @return [String] A string containing text that should be replace the source
   #   code indicated by the \c ReplacementRange.
   # @scope class
-  attach_function :get_diagnostic_fix_it, :clang_getDiagnosticFixIt, [:pointer, :uint, :pointer], String.by_value
+  attach_function :get_diagnostic_fix_it, :clang_getDiagnosticFixIt, [:pointer, :uint, SourceRange], String.by_value
   
   # Get the original translation unit source file name.
   # 
@@ -1961,6 +1962,7 @@ module FFIGen::Clang
   
   # A fast container representing a set of CXCursors.
   class CursorSetImpl < FFI::Struct
+    layout :dummy, :char
   end
   
   # Creates an empty CXCursorSet.
@@ -2120,10 +2122,10 @@ module FFIGen::Clang
   # clang_getOverriddenCursors().
   # 
   # @method dispose_overridden_cursors(overridden)
-  # @param [FFI::Pointer(*Cursor)] overridden 
+  # @param [Cursor] overridden 
   # @return [nil] 
   # @scope class
-  attach_function :dispose_overridden_cursors, :clang_disposeOverriddenCursors, [:pointer], :void
+  attach_function :dispose_overridden_cursors, :clang_disposeOverriddenCursors, [Cursor], :void
   
   # Retrieve the file that is included by the given inclusion directive
   # cursor.
@@ -3025,23 +3027,23 @@ module FFIGen::Clang
   # 
   # @method annotate_tokens(tu, tokens, num_tokens, cursors)
   # @param [TranslationUnitImpl] tu the translation unit that owns the given tokens.
-  # @param [FFI::Pointer(*Token)] tokens the set of tokens to annotate.
+  # @param [Token] tokens the set of tokens to annotate.
   # @param [Integer] num_tokens the number of tokens in \p Tokens.
-  # @param [FFI::Pointer(*Cursor)] cursors an array of \p NumTokens cursors, whose contents will be
+  # @param [Cursor] cursors an array of \p NumTokens cursors, whose contents will be
   #   replaced with the cursors corresponding to each token.
   # @return [nil] 
   # @scope class
-  attach_function :annotate_tokens, :clang_annotateTokens, [TranslationUnitImpl, :pointer, :uint, :pointer], :void
+  attach_function :annotate_tokens, :clang_annotateTokens, [TranslationUnitImpl, Token, :uint, Cursor], :void
   
   # Free the given set of tokens.
   # 
   # @method dispose_tokens(tu, tokens, num_tokens)
   # @param [TranslationUnitImpl] tu 
-  # @param [FFI::Pointer(*Token)] tokens 
+  # @param [Token] tokens 
   # @param [Integer] num_tokens 
   # @return [nil] 
   # @scope class
-  attach_function :dispose_tokens, :clang_disposeTokens, [TranslationUnitImpl, :pointer, :uint], :void
+  attach_function :dispose_tokens, :clang_disposeTokens, [TranslationUnitImpl, Token, :uint], :void
   
   # for debug/testing
   # 
@@ -3357,12 +3359,12 @@ module FFIGen::Clang
   # 
   # = Fields:
   # :results ::
-  #   (FFI::Pointer(*CompletionResult)) The code-completion results.
+  #   (CompletionResult) The code-completion results.
   # :num_results ::
   #   (Integer) The number of code-completion results stored in the
   #   \c Results array.
   class CodeCompleteResults < FFI::Struct
-    layout :results, :pointer,
+    layout :results, CompletionResult,
            :num_results, :uint
   end
   
@@ -3473,39 +3475,39 @@ module FFIGen::Clang
   #   CXCodeComplete_Flags enumeration. The 
   #   \c clang_defaultCodeCompleteOptions() function returns a default set
   #   of code-completion options.
-  # @return [FFI::Pointer(*CodeCompleteResults)] If successful, a new \c CXCodeCompleteResults structure
+  # @return [CodeCompleteResults] If successful, a new \c CXCodeCompleteResults structure
   #   containing code-completion results, which should eventually be
   #   freed with \c clang_disposeCodeCompleteResults(). If code
   #   completion fails, returns NULL.
   # @scope class
-  attach_function :code_complete_at, :clang_codeCompleteAt, [TranslationUnitImpl, :string, :uint, :uint, UnsavedFile, :uint, :uint], :pointer
+  attach_function :code_complete_at, :clang_codeCompleteAt, [TranslationUnitImpl, :string, :uint, :uint, UnsavedFile, :uint, :uint], CodeCompleteResults
   
   # Sort the code-completion results in case-insensitive alphabetical 
   # order.
   # 
   # @method sort_code_completion_results(results, num_results)
-  # @param [FFI::Pointer(*CompletionResult)] results The set of results to sort.
+  # @param [CompletionResult] results The set of results to sort.
   # @param [Integer] num_results The number of results in \p Results.
   # @return [nil] 
   # @scope class
-  attach_function :sort_code_completion_results, :clang_sortCodeCompletionResults, [:pointer, :uint], :void
+  attach_function :sort_code_completion_results, :clang_sortCodeCompletionResults, [CompletionResult, :uint], :void
   
   # Free the given set of code-completion results.
   # 
   # @method dispose_code_complete_results(results)
-  # @param [FFI::Pointer(*CodeCompleteResults)] results 
+  # @param [CodeCompleteResults] results 
   # @return [nil] 
   # @scope class
-  attach_function :dispose_code_complete_results, :clang_disposeCodeCompleteResults, [:pointer], :void
+  attach_function :dispose_code_complete_results, :clang_disposeCodeCompleteResults, [CodeCompleteResults], :void
   
   # Determine the number of diagnostics produced prior to the
   # location where code completion was performed.
   # 
   # @method code_complete_get_num_diagnostics(results)
-  # @param [FFI::Pointer(*CodeCompleteResults)] results 
+  # @param [CodeCompleteResults] results 
   # @return [Integer] 
   # @scope class
-  attach_function :code_complete_get_num_diagnostics, :clang_codeCompleteGetNumDiagnostics, [:pointer], :uint
+  attach_function :code_complete_get_num_diagnostics, :clang_codeCompleteGetNumDiagnostics, [CodeCompleteResults], :uint
   
   # Retrieve a diagnostic associated with the given code completion.
   # 
@@ -3513,22 +3515,22 @@ module FFIGen::Clang
   # the code completion results to query.
   # 
   # @method code_complete_get_diagnostic(results, index)
-  # @param [FFI::Pointer(*CodeCompleteResults)] results 
+  # @param [CodeCompleteResults] results 
   # @param [Integer] index the zero-based diagnostic number to retrieve.
   # @return [FFI::Pointer(Diagnostic)] the requested diagnostic. This diagnostic must be freed
   #   via a call to \c clang_disposeDiagnostic().
   # @scope class
-  attach_function :code_complete_get_diagnostic, :clang_codeCompleteGetDiagnostic, [:pointer, :uint], :pointer
+  attach_function :code_complete_get_diagnostic, :clang_codeCompleteGetDiagnostic, [CodeCompleteResults, :uint], :pointer
   
   # Determines what compeltions are appropriate for the context
   # the given code completion.
   # 
   # @method code_complete_get_contexts(results)
-  # @param [FFI::Pointer(*CodeCompleteResults)] results the code completion results to query
+  # @param [CodeCompleteResults] results the code completion results to query
   # @return [Integer] the kinds of completions that are appropriate for use
   #   along with the given code completion results.
   # @scope class
-  attach_function :code_complete_get_contexts, :clang_codeCompleteGetContexts, [:pointer], :ulong_long
+  attach_function :code_complete_get_contexts, :clang_codeCompleteGetContexts, [CodeCompleteResults], :ulong_long
   
   # Returns the cursor kind for the container for the current code
   # completion context. The container is only guaranteed to be set for
@@ -3537,24 +3539,24 @@ module FFIGen::Clang
   # CXCursor_InvalidCode.
   # 
   # @method code_complete_get_container_kind(results, is_incomplete)
-  # @param [FFI::Pointer(*CodeCompleteResults)] results the code completion results to query
+  # @param [CodeCompleteResults] results the code completion results to query
   # @param [FFI::Pointer(*UInt)] is_incomplete on return, this value will be false if Clang has complete
   #   information about the container. If Clang does not have complete
   #   information, this value will be true.
   # @return [Symbol from _enum_cursor_kind_] the container kind, or CXCursor_InvalidCode if there is not a
   #   container
   # @scope class
-  attach_function :code_complete_get_container_kind, :clang_codeCompleteGetContainerKind, [:pointer, :pointer], :cursor_kind
+  attach_function :code_complete_get_container_kind, :clang_codeCompleteGetContainerKind, [CodeCompleteResults, :pointer], :cursor_kind
   
   # Returns the USR for the container for the current code completion
   # context. If there is not a container for the current context, this
   # function will return the empty string.
   # 
   # @method code_complete_get_container_usr(results)
-  # @param [FFI::Pointer(*CodeCompleteResults)] results the code completion results to query
+  # @param [CodeCompleteResults] results the code completion results to query
   # @return [String] the USR for the container
   # @scope class
-  attach_function :code_complete_get_container_usr, :clang_codeCompleteGetContainerUSR, [:pointer], String.by_value
+  attach_function :code_complete_get_container_usr, :clang_codeCompleteGetContainerUSR, [CodeCompleteResults], String.by_value
   
   # Returns the currently-entered selector for an Objective-C message
   # send, formatted like "initWithFoo:bar:". Only guaranteed to return a
@@ -3562,11 +3564,11 @@ module FFIGen::Clang
   # CXCompletionContext_ObjCClassMessage.
   # 
   # @method code_complete_get_obj_c_selector(results)
-  # @param [FFI::Pointer(*CodeCompleteResults)] results the code completion results to query
+  # @param [CodeCompleteResults] results the code completion results to query
   # @return [String] the selector (or partial selector) that has been entered thus far
   #   for an Objective-C message send.
   # @scope class
-  attach_function :code_complete_get_obj_c_selector, :clang_codeCompleteGetObjCSelector, [:pointer], String.by_value
+  attach_function :code_complete_get_obj_c_selector, :clang_codeCompleteGetObjCSelector, [CodeCompleteResults], String.by_value
   
   # Return a version string, suitable for showing to a user, but not
   #        intended to be parsed (the format is not guaranteed to be stable).
@@ -3601,12 +3603,12 @@ module FFIGen::Clang
   # <em>This entry is only for documentation and no real method.</em>
   # 
   # @method _callback_inclusion_visitor_(inclusion_stack, include_len, client_data)
-  # @param [FFI::Pointer(*SourceLocation)] inclusion_stack 
+  # @param [SourceLocation] inclusion_stack 
   # @param [Integer] include_len 
   # @param [FFI::Pointer(ClientData)] client_data 
   # @return [FFI::Pointer(File)] 
   # @scope class
-  callback :inclusion_visitor, [:pointer, :uint, :pointer], :pointer
+  callback :inclusion_visitor, [SourceLocation, :uint, :pointer], :pointer
   
   # Visit the set of preprocessor inclusions in a translation unit.
   #   The visitor function is called with the provided data for every included
@@ -3643,12 +3645,12 @@ module FFIGen::Clang
   # @method remap_get_filenames(remapping, index, original, transformed)
   # @param [FFI::Pointer(Remapping)] remapping 
   # @param [Integer] index 
-  # @param [FFI::Pointer(*String)] original If non-NULL, will be set to the original filename.
-  # @param [FFI::Pointer(*String)] transformed If non-NULL, will be set to the filename that the original
+  # @param [String] original If non-NULL, will be set to the original filename.
+  # @param [String] transformed If non-NULL, will be set to the filename that the original
   #   is associated with.
   # @return [nil] 
   # @scope class
-  attach_function :remap_get_filenames, :clang_remap_getFilenames, [:pointer, :uint, :pointer, :pointer], :void
+  attach_function :remap_get_filenames, :clang_remap_getFilenames, [:pointer, :uint, String, String], :void
   
   # Dispose the remapping.
   # 

data/lib/ffi_gen/java_output.rb

@@ -0,0 +1,242 @@
+class FFIGen
+  def generate_java
+    writer = Writer.new "    ", " * ", "/**", " */"
+    writer.puts "// Generated by ffi_gen. Please do not change this file by hand.", "import java.util.*;", "import com.sun.jna.*;", "import java.lang.annotation.*;", "import java.lang.reflect.Method;", "", "public interface #{@module_name} extends Library {"
+    writer.indent do
+      writer.puts "", *IO.readlines(File.join(File.dirname(__FILE__), "java_pre.java")).map(&:rstrip)
+      writer.puts "", "public static #{@module_name} INSTANCE = JnaInstanceCreator.createInstance();", ""
+      writer.puts "static class JnaInstanceCreator {"
+      writer.indent do
+        writer.puts "private static #{@module_name} createInstance() {"
+        writer.indent do
+          writer.puts "DefaultTypeMapper typeMapper = new DefaultTypeMapper();", "typeMapper.addFromNativeConverter(NativeEnum.class, new EnumConverter());", "typeMapper.addToNativeConverter(NativeEnum.class, new EnumConverter());", ""
+          writer.puts "Map<String, Object> options = new HashMap<String, Object>();", "options.put(Library.OPTION_FUNCTION_MAPPER, new NativeNameAnnotationFunctionMapper());", "options.put(Library.OPTION_TYPE_MAPPER, typeMapper);", ""
+          writer.puts "return (#{@module_name}) Native.loadLibrary(\"#{@ffi_lib}\", #{@module_name}.class, options);"
+        end
+        writer.puts "}"
+      end
+      writer.puts "}", ""
+      declarations.values.compact.uniq.each do |declaration|
+        declaration.write_java writer
+      end
+    end
+    writer.puts "}"
+    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}
+    
+    def to_java_downcase
+      format :camelcase, :initial_downcase, JAVA_KEYWORDS
+    end
+    
+    def to_java_classname
+      format :camelcase, JAVA_KEYWORDS
+    end
+    
+    def to_java_constant
+      format :upcase, :underscores, JAVA_KEYWORDS
+    end
+  end
+  
+  class Enum
+    def write_java(writer)
+      shorten_names
+      
+      @constants.each do |constant|
+        constant[:symbol] = ":#{constant[:name].to_ruby_downcase}"
+      end
+      
+      writer.comment do
+        writer.write_description @comment
+        # TODO constant comments
+      end
+      
+      writer.puts "public enum #{java_name} implements NativeEnum {"
+      writer.indent do
+        writer.write_array @constants, "," do |constant|
+          "#{constant[:name].to_java_constant}(#{constant[:value]})"
+        end
+        writer.puts ";"
+        
+        writer.puts "", "private int nativeInt;", "", "private #{java_name}(int nativeInt) {", "    this.nativeInt = nativeInt;", "}", "", "@Override", "public int toNativeInt() {", "    return nativeInt;", "}"
+      end
+      writer.puts "}", ""
+    end
+    
+    def java_name
+      @java_name ||= @name.to_java_classname
+    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
+        unless @fields.empty?
+          writer.puts "", "= Fields:"
+          @fields.each do |field|
+            writer.puts "#{field[:symbol]} ::"
+            writer.write_description field[:comment], false, "  (#{field[:type_data][:description]}) ", "  "
+          end
+        end
+      end
+      
+      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]};"
+        end
+        writer.puts "// hidden structure" if @fields.empty?
+      end
+      writer.puts "}", ""
+      
+      @written = true
+    end
+    
+    def java_name
+      @java_name ||= @name.to_java_classname
+    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.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(', ')})"
+        @parameters.each do |parameter|
+          writer.write_description parameter[:description], false, "@param [#{parameter[:type_data][:description]}] #{parameter[:java_name]} ", "  "
+        end
+        writer.write_description return_value_description, false, "@return [#{return_type_data[:description]}] ", "  "
+        writer.puts "@scope class"
+      end
+      
+      jna_signature = "#{@parameters.map{ |parameter| "#{parameter[:type_data][:jna_type]} #{parameter[:java_name]}" }.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});", ""
+      end
+    end
+    
+    def java_name
+      @java_name ||= @name.to_java_downcase
+    end
+  end
+  
+  class Constant
+    def write_java(writer)
+      writer.puts "public static int #{@name.to_java_constant} = #{@value};", ""
+    end
+  end
+end