ffi_gen 1.0.1 → 1.0.2

data/README.md

@@ -14,6 +14,7 @@ Features
   * Clang
   * LLVM
   * OpenGL
+  * SQLite3
 
 
 Requirements

data/lib/ffi_gen/clang.rb

@@ -2,7 +2,7 @@
 
 require 'ffi'
 
-module Clang
+module FFIGen::Clang
   extend FFI::Library
   ffi_lib 'clang'
   
@@ -167,21 +167,21 @@ module Clang
   # #ifndef/#define/#endif macro guards or with #pragma once.
   # 
   # @method is_file_multiple_include_guarded(tu, file)
-  # @param [FFI::Pointer(TranslationUnit)] tu 
+  # @param [TranslationUnitImpl] tu 
   # @param [FFI::Pointer(File)] file 
   # @return [Integer] 
   # @scope class
-  attach_function :is_file_multiple_include_guarded, :clang_isFileMultipleIncludeGuarded, [:pointer, :pointer], :uint
+  attach_function :is_file_multiple_include_guarded, :clang_isFileMultipleIncludeGuarded, [TranslationUnitImpl, :pointer], :uint
   
   # Retrieve a file handle within the given translation unit.
   # 
   # @method get_file(tu, file_name)
-  # @param [FFI::Pointer(TranslationUnit)] tu the translation unit
+  # @param [TranslationUnitImpl] tu the translation unit
   # @param [String] file_name the name of the file.
   # @return [FFI::Pointer(File)] the file handle for the named file in the translation unit \p tu,
   #   or a NULL file handle if the file was not a part of this translation unit.
   # @scope class
-  attach_function :get_file, :clang_getFile, [:pointer, :string], :pointer
+  attach_function :get_file, :clang_getFile, [TranslationUnitImpl, :string], :pointer
   
   # Identifies a specific source location within a translation
   # unit.
@@ -240,24 +240,24 @@ module Clang
   # in a particular translation unit.
   # 
   # @method get_location(tu, file, line, column)
-  # @param [FFI::Pointer(TranslationUnit)] tu 
+  # @param [TranslationUnitImpl] tu 
   # @param [FFI::Pointer(File)] file 
   # @param [Integer] line 
   # @param [Integer] column 
   # @return [SourceLocation] 
   # @scope class
-  attach_function :get_location, :clang_getLocation, [:pointer, :pointer, :uint, :uint], SourceLocation.by_value
+  attach_function :get_location, :clang_getLocation, [TranslationUnitImpl, :pointer, :uint, :uint], SourceLocation.by_value
   
   # Retrieves the source location associated with a given character offset
   # in a particular translation unit.
   # 
   # @method get_location_for_offset(tu, file, offset)
-  # @param [FFI::Pointer(TranslationUnit)] tu 
+  # @param [TranslationUnitImpl] tu 
   # @param [FFI::Pointer(File)] file 
   # @param [Integer] offset 
   # @return [SourceLocation] 
   # @scope class
-  attach_function :get_location_for_offset, :clang_getLocationForOffset, [:pointer, :pointer, :uint], SourceLocation.by_value
+  attach_function :get_location_for_offset, :clang_getLocationForOffset, [TranslationUnitImpl, :pointer, :uint], SourceLocation.by_value
   
   # Retrieve a NULL (invalid) source range.
   # 
@@ -423,20 +423,20 @@ module Clang
   # translation unit.
   # 
   # @method get_num_diagnostics(unit)
-  # @param [FFI::Pointer(TranslationUnit)] unit 
+  # @param [TranslationUnitImpl] unit 
   # @return [Integer] 
   # @scope class
-  attach_function :get_num_diagnostics, :clang_getNumDiagnostics, [:pointer], :uint
+  attach_function :get_num_diagnostics, :clang_getNumDiagnostics, [TranslationUnitImpl], :uint
   
   # Retrieve a diagnostic associated with the given translation unit.
   # 
   # @method get_diagnostic(unit, index)
-  # @param [FFI::Pointer(TranslationUnit)] unit the translation unit to query.
+  # @param [TranslationUnitImpl] unit the translation unit to query.
   # @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 :get_diagnostic, :clang_getDiagnostic, [:pointer, :uint], :pointer
+  attach_function :get_diagnostic, :clang_getDiagnostic, [TranslationUnitImpl, :uint], :pointer
   
   # Destroy a diagnostic.
   # 
@@ -652,10 +652,10 @@ module Clang
   # Get the original translation unit source file name.
   # 
   # @method get_translation_unit_spelling(ct_unit)
-  # @param [FFI::Pointer(TranslationUnit)] ct_unit 
+  # @param [TranslationUnitImpl] ct_unit 
   # @return [String] 
   # @scope class
-  attach_function :get_translation_unit_spelling, :clang_getTranslationUnitSpelling, [:pointer], String.by_value
+  attach_function :get_translation_unit_spelling, :clang_getTranslationUnitSpelling, [TranslationUnitImpl], String.by_value
   
   # Return the CXTranslationUnit for a given source file and the provided
   # command line arguments one would pass to the compiler.
@@ -686,23 +686,23 @@ module Clang
   #   '-emit-ast', '-fsyntex-only' (which is the default), and '-o <output file>'.
   # @param [Integer] num_unsaved_files the number of unsaved file entries in \p
   #   unsaved_files.
-  # @param [FFI::Pointer(*UnsavedFile)] unsaved_files the files that have not yet been saved to disk
+  # @param [UnsavedFile] unsaved_files the files that have not yet been saved to disk
   #   but may be required for code completion, including the contents of
   #   those files.  The contents and name of these files (as specified by
   #   CXUnsavedFile) are copied when necessary, so the client only needs to
   #   guarantee their validity until the call to this function returns.
-  # @return [FFI::Pointer(TranslationUnit)] 
+  # @return [TranslationUnitImpl] 
   # @scope class
-  attach_function :create_translation_unit_from_source_file, :clang_createTranslationUnitFromSourceFile, [:pointer, :string, :int, :pointer, :uint, :pointer], :pointer
+  attach_function :create_translation_unit_from_source_file, :clang_createTranslationUnitFromSourceFile, [:pointer, :string, :int, :pointer, :uint, UnsavedFile], TranslationUnitImpl
   
   # Create a translation unit from an AST file (-emit-ast).
   # 
   # @method create_translation_unit(index, ast_filename)
   # @param [FFI::Pointer(Index)] index 
   # @param [String] ast_filename 
-  # @return [FFI::Pointer(TranslationUnit)] 
+  # @return [TranslationUnitImpl] 
   # @scope class
-  attach_function :create_translation_unit, :clang_createTranslationUnit, [:pointer, :string], :pointer
+  attach_function :create_translation_unit, :clang_createTranslationUnit, [:pointer, :string], TranslationUnitImpl
   
   # Flags that control the creation of translation units.
   # 
@@ -825,7 +825,7 @@ module Clang
   #   '-emit-ast', '-fsyntex-only' (which is the default), and '-o <output file>'.
   # @param [Integer] num_command_line_args The number of command-line arguments in
   #   \p command_line_args.
-  # @param [FFI::Pointer(*UnsavedFile)] unsaved_files the files that have not yet been saved to disk
+  # @param [UnsavedFile] unsaved_files the files that have not yet been saved to disk
   #   but may be required for parsing, including the contents of
   #   those files.  The contents and name of these files (as specified by
   #   CXUnsavedFile) are copied when necessary, so the client only needs to
@@ -835,11 +835,11 @@ module Clang
   # @param [Integer] options A bitmask of options that affects how the translation unit
   #   is managed but not its compilation. This should be a bitwise OR of the
   #   CXTranslationUnit_XXX flags.
-  # @return [FFI::Pointer(TranslationUnit)] A new translation unit describing the parsed code and containing
+  # @return [TranslationUnitImpl] A new translation unit describing the parsed code and containing
   #   any diagnostics produced by the compiler. If there is a failure from which
   #   the compiler cannot recover, returns NULL.
   # @scope class
-  attach_function :parse_translation_unit, :clang_parseTranslationUnit, [:pointer, :string, :pointer, :int, :pointer, :uint, :uint], :pointer
+  attach_function :parse_translation_unit, :clang_parseTranslationUnit, [:pointer, :string, :pointer, :int, UnsavedFile, :uint, :uint], TranslationUnitImpl
   
   # Flags that control how translation units are saved.
   # 
@@ -869,10 +869,10 @@ module Clang
   # the most commonly-requested data.
   # 
   # @method default_save_options(tu)
-  # @param [FFI::Pointer(TranslationUnit)] tu 
+  # @param [TranslationUnitImpl] tu 
   # @return [Integer] 
   # @scope class
-  attach_function :default_save_options, :clang_defaultSaveOptions, [:pointer], :uint
+  attach_function :default_save_options, :clang_defaultSaveOptions, [TranslationUnitImpl], :uint
   
   # Describes the kind of error that occurred (if any) in a call to
   # \c clang_saveTranslationUnit().
@@ -919,7 +919,7 @@ module Clang
   # units.
   # 
   # @method save_translation_unit(tu, file_name, options)
-  # @param [FFI::Pointer(TranslationUnit)] tu The translation unit to save.
+  # @param [TranslationUnitImpl] tu The translation unit to save.
   # @param [String] file_name The file to which the translation unit will be saved.
   # @param [Integer] options A bitmask of options that affects how the translation unit
   #   is saved. This should be a bitwise OR of the
@@ -928,15 +928,15 @@ module Clang
   #   enumeration. Zero (CXSaveError_None) indicates that the translation unit was 
   #   saved successfully, while a non-zero value indicates that a problem occurred.
   # @scope class
-  attach_function :save_translation_unit, :clang_saveTranslationUnit, [:pointer, :string, :uint], :int
+  attach_function :save_translation_unit, :clang_saveTranslationUnit, [TranslationUnitImpl, :string, :uint], :int
   
   # Destroy the specified CXTranslationUnit object.
   # 
-  # @method dispose_translation_unit(translation_unit)
-  # @param [FFI::Pointer(TranslationUnit)] translation_unit 
+  # @method dispose_translation_unit(translation_unit_impl)
+  # @param [TranslationUnitImpl] translation_unit_impl 
   # @return [nil] 
   # @scope class
-  attach_function :dispose_translation_unit, :clang_disposeTranslationUnit, [:pointer], :void
+  attach_function :dispose_translation_unit, :clang_disposeTranslationUnit, [TranslationUnitImpl], :void
   
   # Flags that control the reparsing of translation units.
   # 
@@ -967,10 +967,10 @@ module Clang
   # to the next.
   # 
   # @method default_reparse_options(tu)
-  # @param [FFI::Pointer(TranslationUnit)] tu 
+  # @param [TranslationUnitImpl] tu 
   # @return [Integer] 
   # @scope class
-  attach_function :default_reparse_options, :clang_defaultReparseOptions, [:pointer], :uint
+  attach_function :default_reparse_options, :clang_defaultReparseOptions, [TranslationUnitImpl], :uint
   
   # Reparse the source files that produced this translation unit.
   # 
@@ -988,12 +988,12 @@ module Clang
   # unit using this routine.
   # 
   # @method reparse_translation_unit(tu, num_unsaved_files, unsaved_files, options)
-  # @param [FFI::Pointer(TranslationUnit)] tu The translation unit whose contents will be re-parsed. The
+  # @param [TranslationUnitImpl] tu The translation unit whose contents will be re-parsed. The
   #   translation unit must originally have been built with 
   #   \c clang_createTranslationUnitFromSourceFile().
   # @param [Integer] num_unsaved_files The number of unsaved file entries in \p
   #   unsaved_files.
-  # @param [FFI::Pointer(*UnsavedFile)] unsaved_files The files that have not yet been saved to disk
+  # @param [UnsavedFile] unsaved_files The files that have not yet been saved to disk
   #   but may be required for parsing, including the contents of
   #   those files.  The contents and name of these files (as specified by
   #   CXUnsavedFile) are copied when necessary, so the client only needs to
@@ -1006,7 +1006,7 @@ module Clang
   #   invalid. In such cases, the only valid call for \p TU is 
   #   \c clang_disposeTranslationUnit(TU).
   # @scope class
-  attach_function :reparse_translation_unit, :clang_reparseTranslationUnit, [:pointer, :uint, :pointer, :uint], :int
+  attach_function :reparse_translation_unit, :clang_reparseTranslationUnit, [TranslationUnitImpl, :uint, UnsavedFile, :uint], :int
   
   # Categorizes how memory is being used by a translation unit.
   # 
@@ -1092,22 +1092,22 @@ module Clang
   # :num_entries ::
   #   (Integer) The number of entries in the 'entries' array.
   # :entries ::
-  #   (FFI::Pointer(*TUResourceUsageEntry)) An array of key-value pairs, representing the breakdown of memory
+  #   (TUResourceUsageEntry) An array of key-value pairs, representing the breakdown of memory
   #               usage.
   class TUResourceUsage < FFI::Struct
     layout :data, :pointer,
            :num_entries, :uint,
-           :entries, :pointer
+           :entries, TUResourceUsageEntry
   end
   
   # Return the memory usage of a translation unit.  This object
   #  should be released with clang_disposeCXTUResourceUsage().
   # 
   # @method get_cxtu_resource_usage(tu)
-  # @param [FFI::Pointer(TranslationUnit)] tu 
+  # @param [TranslationUnitImpl] tu 
   # @return [TUResourceUsage] 
   # @scope class
-  attach_function :get_cxtu_resource_usage, :clang_getCXTUResourceUsage, [:pointer], TUResourceUsage.by_value
+  attach_function :get_cxtu_resource_usage, :clang_getCXTUResourceUsage, [TranslationUnitImpl], TUResourceUsage.by_value
   
   # (Not documented)
   # 
@@ -1753,11 +1753,11 @@ module Clang
   # The translation unit cursor can be used to start traversing the
   # various declarations within the given translation unit.
   # 
-  # @method get_translation_unit_cursor(translation_unit)
-  # @param [FFI::Pointer(TranslationUnit)] translation_unit 
+  # @method get_translation_unit_cursor(translation_unit_impl)
+  # @param [TranslationUnitImpl] translation_unit_impl 
   # @return [Cursor] 
   # @scope class
-  attach_function :get_translation_unit_cursor, :clang_getTranslationUnitCursor, [:pointer], Cursor.by_value
+  attach_function :get_translation_unit_cursor, :clang_getTranslationUnitCursor, [TranslationUnitImpl], Cursor.by_value
   
   # Determine whether two cursors are equivalent.
   # 
@@ -1955,9 +1955,9 @@ module Clang
   # 
   # @method cursor_get_translation_unit(cursor)
   # @param [Cursor] cursor 
-  # @return [FFI::Pointer(TranslationUnit)] 
+  # @return [TranslationUnitImpl] 
   # @scope class
-  attach_function :cursor_get_translation_unit, :clang_Cursor_getTranslationUnit, [Cursor.by_value], :pointer
+  attach_function :cursor_get_translation_unit, :clang_Cursor_getTranslationUnit, [Cursor.by_value], TranslationUnitImpl
   
   # A fast container representing a set of CXCursors.
   class CursorSetImpl < FFI::Struct
@@ -1966,35 +1966,35 @@ module Clang
   # Creates an empty CXCursorSet.
   # 
   # @method create_cx_cursor_set()
-  # @return [FFI::Pointer(CursorSet)] 
+  # @return [CursorSetImpl] 
   # @scope class
-  attach_function :create_cx_cursor_set, :clang_createCXCursorSet, [], :pointer
+  attach_function :create_cx_cursor_set, :clang_createCXCursorSet, [], CursorSetImpl
   
   # Disposes a CXCursorSet and releases its associated memory.
   # 
   # @method dispose_cx_cursor_set(cset)
-  # @param [FFI::Pointer(CursorSet)] cset 
+  # @param [CursorSetImpl] cset 
   # @return [nil] 
   # @scope class
-  attach_function :dispose_cx_cursor_set, :clang_disposeCXCursorSet, [:pointer], :void
+  attach_function :dispose_cx_cursor_set, :clang_disposeCXCursorSet, [CursorSetImpl], :void
   
   # Queries a CXCursorSet to see if it contains a specific CXCursor.
   # 
   # @method cx_cursor_set_contains(cset, cursor)
-  # @param [FFI::Pointer(CursorSet)] cset 
+  # @param [CursorSetImpl] cset 
   # @param [Cursor] cursor 
   # @return [Integer] non-zero if the set contains the specified cursor.
   # @scope class
-  attach_function :cx_cursor_set_contains, :clang_CXCursorSet_contains, [:pointer, Cursor.by_value], :uint
+  attach_function :cx_cursor_set_contains, :clang_CXCursorSet_contains, [CursorSetImpl, Cursor.by_value], :uint
   
   # Inserts a CXCursor into a CXCursorSet.
   # 
   # @method cx_cursor_set_insert(cset, cursor)
-  # @param [FFI::Pointer(CursorSet)] cset 
+  # @param [CursorSetImpl] cset 
   # @param [Cursor] cursor 
   # @return [Integer] zero if the CXCursor was already in the set, and non-zero otherwise.
   # @scope class
-  attach_function :cx_cursor_set_insert, :clang_CXCursorSet_insert, [:pointer, Cursor.by_value], :uint
+  attach_function :cx_cursor_set_insert, :clang_CXCursorSet_insert, [CursorSetImpl, Cursor.by_value], :uint
   
   # Determine the semantic parent of the given cursor.
   # 
@@ -2145,13 +2145,13 @@ module Clang
   # "x" or "y" (e.g., on the + or the whitespace around it), clang_getCursor()
   # will return a cursor referring to the "+" expression.
   # 
-  # @method get_cursor(translation_unit, source_location)
-  # @param [FFI::Pointer(TranslationUnit)] translation_unit 
+  # @method get_cursor(translation_unit_impl, source_location)
+  # @param [TranslationUnitImpl] translation_unit_impl 
   # @param [SourceLocation] source_location 
   # @return [Cursor] a cursor representing the entity at the given source location, or
   #   a NULL cursor if no such entity can be found.
   # @scope class
-  attach_function :get_cursor, :clang_getCursor, [:pointer, SourceLocation.by_value], Cursor.by_value
+  attach_function :get_cursor, :clang_getCursor, [TranslationUnitImpl, SourceLocation.by_value], Cursor.by_value
   
   # Retrieve the physical location of the source constructor referenced
   # by the given cursor.
@@ -2962,36 +2962,36 @@ module Clang
   # The spelling of a token is the textual representation of that token, e.g.,
   # the text of an identifier or keyword.
   # 
-  # @method get_token_spelling(translation_unit, token)
-  # @param [FFI::Pointer(TranslationUnit)] translation_unit 
+  # @method get_token_spelling(translation_unit_impl, token)
+  # @param [TranslationUnitImpl] translation_unit_impl 
   # @param [Token] token 
   # @return [String] 
   # @scope class
-  attach_function :get_token_spelling, :clang_getTokenSpelling, [:pointer, Token.by_value], String.by_value
+  attach_function :get_token_spelling, :clang_getTokenSpelling, [TranslationUnitImpl, Token.by_value], String.by_value
   
   # Retrieve the source location of the given token.
   # 
-  # @method get_token_location(translation_unit, token)
-  # @param [FFI::Pointer(TranslationUnit)] translation_unit 
+  # @method get_token_location(translation_unit_impl, token)
+  # @param [TranslationUnitImpl] translation_unit_impl 
   # @param [Token] token 
   # @return [SourceLocation] 
   # @scope class
-  attach_function :get_token_location, :clang_getTokenLocation, [:pointer, Token.by_value], SourceLocation.by_value
+  attach_function :get_token_location, :clang_getTokenLocation, [TranslationUnitImpl, Token.by_value], SourceLocation.by_value
   
   # Retrieve a source range that covers the given token.
   # 
-  # @method get_token_extent(translation_unit, token)
-  # @param [FFI::Pointer(TranslationUnit)] translation_unit 
+  # @method get_token_extent(translation_unit_impl, token)
+  # @param [TranslationUnitImpl] translation_unit_impl 
   # @param [Token] token 
   # @return [SourceRange] 
   # @scope class
-  attach_function :get_token_extent, :clang_getTokenExtent, [:pointer, Token.by_value], SourceRange.by_value
+  attach_function :get_token_extent, :clang_getTokenExtent, [TranslationUnitImpl, Token.by_value], SourceRange.by_value
   
   # Tokenize the source code described by the given range into raw
   # lexical tokens.
   # 
   # @method tokenize(tu, range, tokens, num_tokens)
-  # @param [FFI::Pointer(TranslationUnit)] tu the translation unit whose text is being tokenized.
+  # @param [TranslationUnitImpl] tu the translation unit whose text is being tokenized.
   # @param [SourceRange] range the source range in which text should be tokenized. All of the
   #   tokens produced by tokenization will fall within this source range,
   # @param [FFI::Pointer(**Token)] tokens this pointer will be set to point to the array of tokens
@@ -3001,7 +3001,7 @@ module Clang
   #   array.
   # @return [nil] 
   # @scope class
-  attach_function :tokenize, :clang_tokenize, [:pointer, SourceRange.by_value, :pointer, :pointer], :void
+  attach_function :tokenize, :clang_tokenize, [TranslationUnitImpl, SourceRange.by_value, :pointer, :pointer], :void
   
   # Annotate the given set of tokens by providing cursors for each token
   # that can be mapped to a specific entity within the abstract syntax tree.
@@ -3024,24 +3024,24 @@ module Clang
   # not provided as an annotation.
   # 
   # @method annotate_tokens(tu, tokens, num_tokens, cursors)
-  # @param [FFI::Pointer(TranslationUnit)] tu the translation unit that owns the given tokens.
+  # @param [TranslationUnitImpl] tu the translation unit that owns the given tokens.
   # @param [FFI::Pointer(*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
   #   replaced with the cursors corresponding to each token.
   # @return [nil] 
   # @scope class
-  attach_function :annotate_tokens, :clang_annotateTokens, [:pointer, :pointer, :uint, :pointer], :void
+  attach_function :annotate_tokens, :clang_annotateTokens, [TranslationUnitImpl, :pointer, :uint, :pointer], :void
   
   # Free the given set of tokens.
   # 
   # @method dispose_tokens(tu, tokens, num_tokens)
-  # @param [FFI::Pointer(TranslationUnit)] tu 
+  # @param [TranslationUnitImpl] tu 
   # @param [FFI::Pointer(*Token)] tokens 
   # @param [Integer] num_tokens 
   # @return [nil] 
   # @scope class
-  attach_function :dispose_tokens, :clang_disposeTokens, [:pointer, :pointer, :uint], :void
+  attach_function :dispose_tokens, :clang_disposeTokens, [TranslationUnitImpl, :pointer, :uint], :void
   
   # for debug/testing
   # 
@@ -3448,7 +3448,7 @@ module Clang
   # have a lower latency.
   # 
   # @method code_complete_at(tu, complete_filename, complete_line, complete_column, unsaved_files, num_unsaved_files, options)
-  # @param [FFI::Pointer(TranslationUnit)] tu The translation unit in which code-completion should
+  # @param [TranslationUnitImpl] tu The translation unit in which code-completion should
   #   occur. The source files for this translation unit need not be
   #   completely up-to-date (and the contents of those source files may
   #   be overridden via \p unsaved_files). Cursors referring into the
@@ -3460,7 +3460,7 @@ module Clang
   # @param [Integer] complete_column The column at which code-completion should occur.
   #   Note that the column should point just after the syntactic construct that
   #   initiated code completion, and not in the middle of a lexical token.
-  # @param [FFI::Pointer(*UnsavedFile)] unsaved_files the Tiles that have not yet been saved to disk
+  # @param [UnsavedFile] unsaved_files the Tiles that have not yet been saved to disk
   #   but may be required for parsing or code completion, including the
   #   contents of those files.  The contents and name of these files (as
   #   specified by CXUnsavedFile) are copied when necessary, so the
@@ -3478,7 +3478,7 @@ module Clang
   #   freed with \c clang_disposeCodeCompleteResults(). If code
   #   completion fails, returns NULL.
   # @scope class
-  attach_function :code_complete_at, :clang_codeCompleteAt, [:pointer, :string, :uint, :uint, :pointer, :uint, :uint], :pointer
+  attach_function :code_complete_at, :clang_codeCompleteAt, [TranslationUnitImpl, :string, :uint, :uint, UnsavedFile, :uint, :uint], :pointer
   
   # Sort the code-completion results in case-insensitive alphabetical 
   # order.
@@ -3614,12 +3614,12 @@ module Clang
   #   is inspecting the inclusions in the PCH file itself).
   # 
   # @method get_inclusions(tu, visitor, client_data)
-  # @param [FFI::Pointer(TranslationUnit)] tu 
+  # @param [TranslationUnitImpl] tu 
   # @param [Proc(_callback_inclusion_visitor_)] visitor 
   # @param [FFI::Pointer(ClientData)] client_data 
   # @return [nil] 
   # @scope class
-  attach_function :get_inclusions, :clang_getInclusions, [:pointer, :inclusion_visitor, :pointer], :void
+  attach_function :get_inclusions, :clang_getInclusions, [TranslationUnitImpl, :inclusion_visitor, :pointer], :void
   
   # Retrieve a remapping.
   # 

data/lib/ffi_gen.rb

@@ -1,33 +1,42 @@
-require "ffi_gen/clang"
-
-class << Clang
-  def get_children(declaration)
-    children = []
-    visit_children declaration, lambda { |child, child_parent, child_client_data|
-      children << child
-      :continue
-    }, nil
-    children
-  end
-end
-
-class Clang::String
-  def to_s
-    Clang.get_c_string self
+class FFIGen
+  RUBY_KEYWORDS = %w{alias allocate and begin break case class def defined do else elsif end ensure false for if in initialize module next nil not or redo rescue retry return self super then true undef unless until when while yield}
+  
+  require "ffi_gen/clang"
+  
+  class << Clang
+    def get_children(declaration)
+      children = []
+      visit_children declaration, lambda { |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
+      column_ptr = FFI::MemoryPointer.new :uint
+      offset_ptr = FFI::MemoryPointer.new :uint
+      get_spelling_location location, file_ptr, line_ptr, column_ptr, offset_ptr
+      { file: file_ptr.read_pointer, line: line_ptr.read_uint, column: column_ptr.read_uint, offset: offset_ptr.read_uint }
+    end
   end
   
-  def to_s_and_dispose
-    str = to_s
-    Clang.dispose_string self
-    str
+  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
-end
-
-class FFIGen
-  RUBY_KEYWORDS = %w{alias allocate and begin break case class def defined do else elsif end ensure false for if in initialize module next nil not or redo rescue retry return self super then true undef unless until when while yield}
-
+  
   class Enum
-    attr_reader :constants
+    attr_reader :constants, :comment
     
     def initialize(generator, name, comment)
       @generator = generator
@@ -86,29 +95,23 @@ class FFIGen
     def ruby_name
       @ruby_name ||= @generator.to_ruby_lowercase @name
     end
-    
-    def type_name(short)
-      short ? @name : "Symbol from _enum_#{ruby_name}_"
-    end
-    
-    def reference
-      ":#{ruby_name}"
-    end
   end
   
   class Struct
-    attr_reader :fields
+    attr_reader :fields, :comment, :written
     
     def initialize(generator, name, comment)
       @generator = generator
       @name = name
       @comment = comment
       @fields = []
+      @written = false
     end
     
     def write(writer)
       @fields.each do |field|
         field[:symbol] = ":#{@generator.to_ruby_lowercase field[:name]}"
+        field[:type_data] = @generator.map_type field[:type]
       end
       
       writer.comment do
@@ -117,7 +120,7 @@ class FFIGen
           writer.puts "", "= Fields:"
           @fields.each do |field|
             writer.puts "#{field[:symbol]} ::"
-            writer.write_description field[:comment], false, "  (#{@generator.to_type_name field[:type]}) ", "  "
+            writer.write_description field[:comment], false, "  (#{field[:type_data][:description]}) ", "  "
           end
         end
       end
@@ -125,27 +128,21 @@ class FFIGen
       writer.puts "class #{ruby_name} < FFI::Struct"
       writer.indent do
         writer.write_array @fields, ",", "layout ", "       " do |field|
-          "#{field[:symbol]}, #{@generator.to_ffi_type field[:type]}"
+          "#{field[:symbol]}, #{field[:type_data][:ffi_type]}"
         end
       end
       writer.puts "end", ""
+      
+      @written = true
     end
     
     def ruby_name
       @ruby_name ||= @generator.to_ruby_camelcase @name
     end
-    
-    def type_name(short)
-      ruby_name
-    end
-    
-    def reference
-      "#{ruby_name}.by_value"
-    end
   end
   
   class Function
-    attr_reader :name, :parameters
+    attr_reader :name, :parameters, :comment
     attr_accessor :return_type
     
     def initialize(generator, name, is_callback, comment)
@@ -158,10 +155,11 @@ class FFIGen
     
     def write(writer)
       @parameters.each do |parameter|
-        parameter[:ruby_type] = @generator.to_type_name parameter[:type]
-        parameter[:ruby_name] = @generator.to_ruby_lowercase(parameter[:name].empty? ? @generator.to_type_name(parameter[:type], true) : parameter[:name])
+        parameter[:type_data] = @generator.map_type parameter[:type]
+        parameter[:ruby_name] = !parameter[:name].empty? ? @generator.to_ruby_lowercase(parameter[:name]) : parameter[:type_data][:parameter_name]
         parameter[:description] = []
       end
+      return_type_data = @generator.map_type @return_type
       
       function_description = []
       return_value_description = []
@@ -185,13 +183,13 @@ class FFIGen
         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(', ')})"
         @parameters.each do |parameter|
-          writer.write_description parameter[:description], false, "@param [#{parameter[:ruby_type]}] #{parameter[:ruby_name]} ", "  "
+          writer.write_description parameter[:description], false, "@param [#{parameter[:type_data][:description]}] #{parameter[:ruby_name]} ", "  "
         end
-        writer.write_description return_value_description, false, "@return [#{@generator.to_type_name @return_type}] ", "  "
+        writer.write_description return_value_description, false, "@return [#{return_type_data[:description]}] ", "  "
         writer.puts "@scope class"
       end
       
-      ffi_signature = "[#{@parameters.map{ |parameter| @generator.to_ffi_type parameter[:type] }.join(', ')}], #{@generator.to_ffi_type @return_type}"
+      ffi_signature = "[#{@parameters.map{ |parameter| parameter[:type_data][:ffi_type] }.join(', ')}], #{return_type_data[:ffi_type]}"
       if @is_callback
         writer.puts "callback :#{ruby_name}, #{ffi_signature}", ""
       else
@@ -202,14 +200,6 @@ class FFIGen
     def ruby_name
       @ruby_name ||= @generator.to_ruby_lowercase @name, true
     end
-    
-    def type_name(short)
-      "Proc(_callback_#{ruby_name}_)"
-    end
-    
-    def reference
-      ":#{ruby_name}"
-    end
   end
   
   class Constant
@@ -297,6 +287,24 @@ class FFIGen
     @declarations = nil
   end
   
+  def generate
+    writer = Writer.new
+    writer.puts "# Generated by ffi_gen. Please do not change this file by hand.", "", "require 'ffi'", "", "module #{@ruby_module}"
+    writer.indent do
+      writer.puts "extend FFI::Library", "ffi_lib '#{@ffi_lib}'", ""
+      declarations.each do |name, declaration|
+        declaration.write writer
+      end
+    end
+    writer.puts "end"
+    if @output.is_a? String
+      File.open(@output, "w") { |file| file.write writer.output }
+      puts "ffi_gen: #{@output}"
+    else
+      @output.write writer.output
+    end
+  end
+  
   def translation_unit
     return @translation_unit unless @translation_unit.nil?
     
@@ -333,9 +341,7 @@ class FFIGen
     unit_cursor = Clang.get_translation_unit_cursor translation_unit
     previous_declaration_end = Clang.get_cursor_location unit_cursor
     Clang.get_children(unit_cursor).each do |declaration|
-      file_ptr = FFI::MemoryPointer.new :pointer
-      Clang.get_spelling_location Clang.get_cursor_location(declaration), file_ptr, nil, nil, nil
-      file = file_ptr.read_pointer
+      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)
@@ -397,32 +403,17 @@ class FFIGen
             @declarations[name] = Constant.new self, name, value
           end 
         end
-            
+        
       end
     end
 
     @declarations
   end
   
-  def generate
-    writer = Writer.new
-    writer.puts "# Generated by ffi_gen. Please do not change this file by hand.", "", "require 'ffi'", "", "module #{@ruby_module}"
-    writer.indent do
-      writer.puts "extend FFI::Library", "ffi_lib '#{@ffi_lib}'", ""
-      declarations.each do |name, declaration|
-        declaration.write writer
-      end
-    end
-    writer.puts "end"
-    if @output.is_a? String
-      File.open(@output, "w") { |file| file.write writer.output }
-      puts "ffi_gen: #{@output}"
-    else
-      @output.write writer.output
-    end
-  end
-  
   def read_named_declaration(declaration, name, comment)
+    old_declaration = @declarations.delete name
+    comment = "#{old_declaration.comment}\n#{comment}" if old_declaration
+
     case declaration[:kind]
     when :enum_decl
       enum = Enum.new self, name, comment
@@ -457,85 +448,93 @@ class FFIGen
       
     when :struct_decl
       struct = Struct.new self, name, comment
-      @declarations[name] = struct
       
-      previous_field_location = Clang.get_cursor_location declaration
-      Clang.get_children(declaration).each do |field_decl|
-        field_name = Clang.get_cursor_spelling(field_decl).to_s_and_dispose
-        field_type = Clang.get_cursor_type field_decl
+      struct_children = Clang.get_children declaration
+      previous_child_end = Clang.get_cursor_location declaration
+      struct_children.each_with_index do |struct_child, index|
+        child_name = Clang.get_cursor_spelling(struct_child).to_s_and_dispose
+        child_extent = Clang.get_cursor_extent struct_child
         
-        field_location = Clang.get_cursor_location field_decl
-        field_comment_range = Clang.get_range previous_field_location, field_location
-        field_comment = extract_comment translation_unit, field_comment_range
-        previous_field_location = field_location
+        child_comment_range = Clang.get_range previous_child_end, Clang.get_range_start(child_extent)
+        child_comment = extract_comment translation_unit, child_comment_range
         
-        struct.fields << { name: field_name, type: field_type, comment: field_comment }
+        # check for comment starting on same line
+        next_child_start = index < struct_children.size - 1 ? Clang.get_cursor_location(struct_children[index + 1]) : Clang.get_range_end(Clang.get_cursor_extent(declaration))
+        following_comment_range = Clang.get_range Clang.get_range_end(child_extent), next_child_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(child_extent))[:line]
+          child_comment = Clang.get_token_spelling(translation_unit, following_comment_token).to_s_and_dispose
+          previous_child_end = Clang.get_range_end Clang.get_token_extent(translation_unit, following_comment_token)
+        else
+          previous_child_end = Clang.get_range_end child_extent
+        end
+        
+        case struct_child[:kind]
+        when :field_decl
+          field_type = Clang.get_cursor_type struct_child
+  
+          struct.fields << { name: child_name, type: field_type, comment: child_comment }
+        when :struct_decl
+          read_named_declaration struct_child, child_name, child_comment
+        end
       end
+      
+      @declarations[name] = struct
+      
     end
   end
   
-  def extract_comment(translation_unit, range)
+  def extract_comment(translation_unit, range, search_backwards = true, return_spelling = true)
     tokens_ptr_ptr = FFI::MemoryPointer.new :pointer
     num_tokens_ptr = FFI::MemoryPointer.new :uint
     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 - 1).downto(0) do |i|
+    indices = search_backwards ? (num_tokens - 1).downto(0) : 0.upto(num_tokens - 1)
+    indices.each do |i|
       token = Clang::Token.new tokens_ptr[i]
-      return Clang.get_token_spelling(translation_unit, token).to_s_and_dispose if Clang.get_token_kind(token) == :comment
+      if Clang.get_token_kind(token) == :comment
+        return return_spelling ? Clang.get_token_spelling(translation_unit, token).to_s_and_dispose : token
+      end
     end
     ""
   end
   
-  def to_ffi_type(full_type)
-    declaration = Clang.get_type_declaration full_type
-    name = Clang.get_cursor_spelling(declaration).to_s_and_dispose
-    return @declarations[name].reference if @declarations.has_key? name
+  def map_type(full_type)
+    name = Clang.get_cursor_spelling(Clang.get_type_declaration(full_type)).to_s_and_dispose
+    declaration = !name.empty? && @declarations[name]
     
     canonical_type = Clang.get_canonical_type full_type
-    case canonical_type[:kind]
-    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"
+    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
-      pointee_type[:kind] == :char_s ? ":string" : ":pointer"
-    when :constant_array
-      element_type = Clang.get_array_element_type canonical_type
-      size = Clang.get_array_size canonical_type
-      "[#{to_ffi_type element_type}, #{size}]"
-    else
-      raise NotImplementedError, "No translation for values of type #{canonical_type[:kind]}"
-    end
-  end
-  
-  def to_type_name(full_type, short = false)
-    declaration = Clang.get_type_declaration full_type
-    name = Clang.get_cursor_spelling(declaration).to_s_and_dispose
-    return @declarations[name].type_name(short) if @declarations.has_key? name
-    
-    canonical_type = Clang.get_canonical_type full_type
-    case canonical_type[:kind]
-    when :void then "nil"
-    when :bool then "Boolean"
-    when :u_char, :u_short, :u_int, :u_long, :u_long_long, :char_s, :s_char, :short, :int, :long, :long_long then "Integer"
-    when :float, :double then "Float"
-    when :pointer
-      pointee_type = Clang.get_pointee_type canonical_type
-      if pointee_type[:kind] == :char_s
-        "String"
-      else
+      result = nil
+      case pointee_type[:kind]
+      when :char_s
+        result = [":string", "String"]
+      when :record
+        pointee_name = Clang.get_cursor_spelling(Clang.get_type_declaration(pointee_type)).to_s_and_dispose
+        pointee_declaration = !pointee_name.empty? && @declarations[pointee_name]
+        result = [pointee_declaration.ruby_name, pointee_declaration.ruby_name] if pointee_declaration and pointee_declaration.written
+      when :function_proto
+        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
@@ -555,14 +554,23 @@ class FFIGen
             break
           end
         end
-        short ? pointer_target_name : "FFI::Pointer(#{'*' * pointer_depth}#{pointer_target_name})"
+        result = [":pointer", "FFI::Pointer(#{'*' * pointer_depth}#{pointer_target_name})", pointer_target_name]
       end
+      
+      result
+    when :record
+      ["#{declaration.ruby_name}.by_value", declaration.ruby_name]
+    when :enum
+      [":#{declaration.ruby_name}", "Symbol from _enum_#{declaration.ruby_name}_", declaration.ruby_name]
     when :constant_array
-      element_type = Clang.get_array_element_type canonical_type
-      "Array<#{to_type_name element_type}>"
+      element_type_data = map_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]}>"]
     else
-      raise NotImplementedError, "No type name for type #{canonical_type[:kind]}"
+      raise NotImplementedError, "No translation for values of type #{canonical_type[:kind]}"
     end
+    
+    { ffi_type: data_array[0], description: data_array[1], parameter_name: to_ruby_lowercase(data_array[2] || data_array[1]) }
   end
   
   def to_ruby_lowercase(str, avoid_keywords = false)
@@ -594,7 +602,7 @@ end
 
 if __FILE__ == $0
   FFIGen.generate(
-    ruby_module: "Clang",
+    ruby_module: "FFIGen::Clang",
     ffi_lib:     "clang",
     headers:     ["clang-c/Index.h"],
     cflags:      `llvm-config --cflags`.split(" "),

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffi_gen
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-04 00:00:00.000000000 Z
+date: 2012-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
-  requirement: &17288240 !ruby/object:Gem::Requirement
+  requirement: &18320080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *17288240
+  version_requirements: *18320080
 description: A generator for Ruby FFI bindings, directly from header files via LLVM's
   Clang compiler
 email: mail@richard-musiol.de