Index.rb

# Generated by ffi-gen. Please do not change this file by hand.

require 'ffi'

module Clang
  extend FFI::Library
  ffi_lib 'clang'
  
  def self.attach_function(name, *_)
    begin; super; rescue FFI::NotFoundError => e
      (class << self; self; end).class_eval { define_method(name) { |*_| raise e } }
    end
  end
  
  # 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.
  # 
  # Each CXUnsavedFile instance provides the name of a file on the
  # system along with the current contents of that file that have not
  # yet been saved to disk.
  # 
  # = Fields:
  # :filename ::
  #   (String) The file whose contents have not yet been saved.
  #   
  #   This file must already exist in the file system.
  # :contents ::
  #   (String) A buffer containing the unsaved contents of this file.
  # :length ::
  #   (Integer) The length of the unsaved contents of this buffer.
  class UnsavedFile < FFI::Struct
    layout :filename, :string,
           :contents, :string,
           :length, :ulong
  end
  
  # Describes the availability of a particular entity, which indicates
  # whether the use of this entity will result in a warning or error due to
  # it being deprecated or unavailable.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:availability_kind).</em>
  # 
  # === Options:
  # :available ::
  #   The entity is available.
  # :deprecated ::
  #   The entity is available, but has been deprecated (and its use is
  #   not recommended).
  # :not_available ::
  #   The entity is not available; any use of it will be an error.
  # :not_accessible ::
  #   The entity is available, but not accessible; any use of it will be
  #   an error.
  # 
  # @method _enum_availability_kind_
  # @return [Symbol]
  # @scope class
  enum :availability_kind, [
    :available, 0,
    :deprecated, 1,
    :not_available, 2,
    :not_accessible, 3
  ]
  
  # A character string.
  # 
  # The \c CXString type is used to return strings from the interface when
  # the ownership of that string might different from one call to the next.
  # Use \c clang_getCString() to retrieve the string data and, once finished
  # with the string data, call \c clang_disposeString() to free the string.
  # 
  # = Fields:
  # :data ::
  #   (FFI::Pointer(*Void)) 
  # :private_flags ::
  #   (Integer) 
  class String < FFI::Struct
    layout :data, :pointer,
           :private_flags, :uint
  end
  
  # Retrieve the character data associated with the given string.
  # 
  # @method get_c_string(string)
  # @param [String] string 
  # @return [String] 
  # @scope class
  attach_function :get_c_string, :clang_getCString, [String.by_value], :string
  
  # Free the given string,
  # 
  # @method dispose_string(string)
  # @param [String] string 
  # @return [nil] 
  # @scope class
  attach_function :dispose_string, :clang_disposeString, [String.by_value], :void
  
  # clang_createIndex() provides a shared context for creating
  # translation units. It provides two options:
  # 
  # - excludeDeclarationsFromPCH: When non-zero, allows enumeration of "local"
  # declarations (when loading any new translation units). A "local" declaration
  # is one that belongs in the translation unit itself and not in a precompiled
  # header that was used by the translation unit. If zero, all declarations
  # will be enumerated.
  # 
  # Here is an example:
  # 
  #   // excludeDeclsFromPCH = 1, displayDiagnostics=1
  #   Idx = clang_createIndex(1, 1);
  # 
  #   // IndexTest.pch was produced with the following command:
  #   // "clang -x c IndexTest.h -emit-ast -o IndexTest.pch"
  #   TU = clang_createTranslationUnit(Idx, "IndexTest.pch");
  # 
  #   // This will load all the symbols from 'IndexTest.pch'
  #   clang_visitChildren(clang_getTranslationUnitCursor(TU),
  #                       TranslationUnitVisitor, 0);
  #   clang_disposeTranslationUnit(TU);
  # 
  #   // This will load all the symbols from 'IndexTest.c', excluding symbols
  #   // from 'IndexTest.pch'.
  #   char *args() = { "-Xclang", "-include-pch=IndexTest.pch" };
  #   TU = clang_createTranslationUnitFromSourceFile(Idx, "IndexTest.c", 2, args,
  #                                                  0, 0);
  #   clang_visitChildren(clang_getTranslationUnitCursor(TU),
  #                       TranslationUnitVisitor, 0);
  #   clang_disposeTranslationUnit(TU);
  # 
  # This process of creating the 'pch', loading it separately, and using it (via
  # -include-pch) allows 'excludeDeclsFromPCH' to remove redundant callbacks
  # (which gives the indexer the same performance benefit as the compiler).
  # 
  # @method create_index(exclude_declarations_from_pch, display_diagnostics)
  # @param [Integer] exclude_declarations_from_pch 
  # @param [Integer] display_diagnostics 
  # @return [FFI::Pointer(Index)] 
  # @scope class
  attach_function :create_index, :clang_createIndex, [:int, :int], :pointer
  
  # Destroy the given index.
  # 
  # The index must not be destroyed until all of the translation units created
  # within that index have been destroyed.
  # 
  # @method dispose_index(index)
  # @param [FFI::Pointer(Index)] index 
  # @return [nil] 
  # @scope class
  attach_function :dispose_index, :clang_disposeIndex, [:pointer], :void
  
  # Retrieve the complete file and path name of the given file.
  # 
  # @method get_file_name(s_file)
  # @param [FFI::Pointer(File)] s_file 
  # @return [String] 
  # @scope class
  attach_function :get_file_name, :clang_getFileName, [:pointer], String.by_value
  
  # Retrieve the last modification time of the given file.
  # 
  # @method get_file_time(s_file)
  # @param [FFI::Pointer(File)] s_file 
  # @return [Integer] 
  # @scope class
  attach_function :get_file_time, :clang_getFileTime, [:pointer], :long
  
  # Determine whether the given header is guarded against
  # multiple inclusions, either with the conventional
  # #ifndef/#define/#endif macro guards or with #pragma once.
  # 
  # @method is_file_multiple_include_guarded(tu, file)
  # @param [TranslationUnitImpl] tu 
  # @param [FFI::Pointer(File)] file 
  # @return [Integer] 
  # @scope class
  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 [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, [TranslationUnitImpl, :string], :pointer
  
  # Identifies a specific source location within a translation
  # unit.
  # 
  # Use clang_getExpansionLocation() or clang_getSpellingLocation()
  # to map a source location to a particular file, line, and column.
  # 
  # = Fields:
  # :ptr_data ::
  #   (Array<FFI::Pointer(*Void)>) 
  # :int_data ::
  #   (Integer) 
  class SourceLocation < FFI::Struct
    layout :ptr_data, [:pointer, 2],
           :int_data, :uint
  end
  
  # Identifies a half-open character range in the source code.
  # 
  # Use clang_getRangeStart() and clang_getRangeEnd() to retrieve the
  # starting and end locations from a source range, respectively.
  # 
  # = Fields:
  # :ptr_data ::
  #   (Array<FFI::Pointer(*Void)>) 
  # :begin_int_data ::
  #   (Integer) 
  # :end_int_data ::
  #   (Integer) 
  class SourceRange < FFI::Struct
    layout :ptr_data, [:pointer, 2],
           :begin_int_data, :uint,
           :end_int_data, :uint
  end
  
  # Retrieve a NULL (invalid) source location.
  # 
  # @method get_null_location()
  # @return [SourceLocation] 
  # @scope class
  attach_function :get_null_location, :clang_getNullLocation, [], SourceLocation.by_value
  
  # Determine whether two source locations, which must refer into
  # the same translation unit, refer to exactly the same point in the source
  # code.
  # 
  # @method equal_locations(loc1, loc2)
  # @param [SourceLocation] loc1 
  # @param [SourceLocation] loc2 
  # @return [Integer] non-zero if the source locations refer to the same location, zero
  #   if they refer to different locations.
  # @scope class
  attach_function :equal_locations, :clang_equalLocations, [SourceLocation.by_value, SourceLocation.by_value], :uint
  
  # Retrieves the source location associated with a given file/line/column
  # in a particular translation unit.
  # 
  # @method get_location(tu, file, line, column)
  # @param [TranslationUnitImpl] tu 
  # @param [FFI::Pointer(File)] file 
  # @param [Integer] line 
  # @param [Integer] column 
  # @return [SourceLocation] 
  # @scope class
  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 [TranslationUnitImpl] tu 
  # @param [FFI::Pointer(File)] file 
  # @param [Integer] offset 
  # @return [SourceLocation] 
  # @scope class
  attach_function :get_location_for_offset, :clang_getLocationForOffset, [TranslationUnitImpl, :pointer, :uint], SourceLocation.by_value
  
  # Retrieve a NULL (invalid) source range.
  # 
  # @method get_null_range()
  # @return [SourceRange] 
  # @scope class
  attach_function :get_null_range, :clang_getNullRange, [], SourceRange.by_value
  
  # Retrieve a source range given the beginning and ending source
  # locations.
  # 
  # @method get_range(begin_, end_)
  # @param [SourceLocation] begin_ 
  # @param [SourceLocation] end_ 
  # @return [SourceRange] 
  # @scope class
  attach_function :get_range, :clang_getRange, [SourceLocation.by_value, SourceLocation.by_value], SourceRange.by_value
  
  # Determine whether two ranges are equivalent.
  # 
  # @method equal_ranges(range1, range2)
  # @param [SourceRange] range1 
  # @param [SourceRange] range2 
  # @return [Integer] non-zero if the ranges are the same, zero if they differ.
  # @scope class
  attach_function :equal_ranges, :clang_equalRanges, [SourceRange.by_value, SourceRange.by_value], :uint
  
  # Returns non-zero if \arg range is null.
  # 
  # @method range_is_null(range)
  # @param [SourceRange] range 
  # @return [Integer] 
  # @scope class
  attach_function :range_is_null, :clang_Range_isNull, [SourceRange.by_value], :int
  
  # Retrieve the file, line, column, and offset represented by
  # the given source location.
  # 
  # If the location refers into a macro expansion, retrieves the
  # location of the macro expansion.
  # 
  # @method get_expansion_location(location, file, line, column, offset)
  # @param [SourceLocation] location the location within a source file that will be decomposed
  #   into its parts.
  # @param [FFI::Pointer(*File)] file (out) if non-NULL, will be set to the file to which the given
  #   source location points.
  # @param [FFI::Pointer(*UInt)] line (out) if non-NULL, will be set to the line to which the given
  #   source location points.
  # @param [FFI::Pointer(*UInt)] column (out) if non-NULL, will be set to the column to which the given
  #   source location points.
  # @param [FFI::Pointer(*UInt)] offset (out) if non-NULL, will be set to the offset into the
  #   buffer to which the given source location points.
  # @return [nil] 
  # @scope class
  attach_function :get_expansion_location, :clang_getExpansionLocation, [SourceLocation.by_value, :pointer, :pointer, :pointer, :pointer], :void
  
  # Retrieve the file, line, column, and offset represented by
  # the given source location, as specified in a # line directive.
  # 
  # Example: given the following source code in a file somefile.c
  # 
  # #123 "dummy.c" 1
  # 
  # static int func(void)
  # {
  #     return 0;
  # }
  # 
  # the location information returned by this function would be
  # 
  # File: dummy.c Line: 124 Column: 12
  # 
  # whereas clang_getExpansionLocation would have returned
  # 
  # File: somefile.c Line: 3 Column: 12
  # 
  # @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 [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
  #   a non-NULL value is passed in, remember to dispose of the returned value
  #   using \c clang_disposeString() once you've finished with it. For an invalid
  #   source location, an empty string is returned.
  # @param [FFI::Pointer(*UInt)] line (out) if non-NULL, will be set to the line number of the
  #   source location. For an invalid source location, zero is returned.
  # @param [FFI::Pointer(*UInt)] column (out) if non-NULL, will be set to the column number of the
  #   source location. For an invalid source location, zero is returned.
  # @return [nil] 
  # @scope class
  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.
  # 
  # This interface has been replaced by the newer interface
  # \see clang_getExpansionLocation(). See that interface's documentation for
  # details.
  # 
  # @method get_instantiation_location(location, file, line, column, offset)
  # @param [SourceLocation] location 
  # @param [FFI::Pointer(*File)] file 
  # @param [FFI::Pointer(*UInt)] line 
  # @param [FFI::Pointer(*UInt)] column 
  # @param [FFI::Pointer(*UInt)] offset 
  # @return [nil] 
  # @scope class
  attach_function :get_instantiation_location, :clang_getInstantiationLocation, [SourceLocation.by_value, :pointer, :pointer, :pointer, :pointer], :void
  
  # Retrieve the file, line, column, and offset represented by
  # the given source location.
  # 
  # If the location refers into a macro instantiation, return where the
  # location was originally spelled in the source file.
  # 
  # @method get_spelling_location(location, file, line, column, offset)
  # @param [SourceLocation] location the location within a source file that will be decomposed
  #   into its parts.
  # @param [FFI::Pointer(*File)] file (out) if non-NULL, will be set to the file to which the given
  #   source location points.
  # @param [FFI::Pointer(*UInt)] line (out) if non-NULL, will be set to the line to which the given
  #   source location points.
  # @param [FFI::Pointer(*UInt)] column (out) if non-NULL, will be set to the column to which the given
  #   source location points.
  # @param [FFI::Pointer(*UInt)] offset (out) if non-NULL, will be set to the offset into the
  #   buffer to which the given source location points.
  # @return [nil] 
  # @scope class
  attach_function :get_spelling_location, :clang_getSpellingLocation, [SourceLocation.by_value, :pointer, :pointer, :pointer, :pointer], :void
  
  # Retrieve a source location representing the first character within a
  # source range.
  # 
  # @method get_range_start(range)
  # @param [SourceRange] range 
  # @return [SourceLocation] 
  # @scope class
  attach_function :get_range_start, :clang_getRangeStart, [SourceRange.by_value], SourceLocation.by_value
  
  # Retrieve a source location representing the last character within a
  # source range.
  # 
  # @method get_range_end(range)
  # @param [SourceRange] range 
  # @return [SourceLocation] 
  # @scope class
  attach_function :get_range_end, :clang_getRangeEnd, [SourceRange.by_value], SourceLocation.by_value
  
  # Describes the severity of a particular diagnostic.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:diagnostic_severity).</em>
  # 
  # === Options:
  # :ignored ::
  #   A diagnostic that has been suppressed, e.g., by a command-line
  #   option.
  # :note ::
  #   This diagnostic is a note that should be attached to the
  #   previous (non-note) diagnostic.
  # :warning ::
  #   This diagnostic indicates suspicious code that may not be
  #   wrong.
  # :error ::
  #   This diagnostic indicates that the code is ill-formed.
  # :fatal ::
  #   This diagnostic indicates that the code is ill-formed such
  #   that future parser recovery is unlikely to produce useful
  #   results.
  # 
  # @method _enum_diagnostic_severity_
  # @return [Symbol]
  # @scope class
  enum :diagnostic_severity, [
    :ignored, 0,
    :note, 1,
    :warning, 2,
    :error, 3,
    :fatal, 4
  ]
  
  # Determine the number of diagnostics produced for the given
  # translation unit.
  # 
  # @method get_num_diagnostics(unit)
  # @param [TranslationUnitImpl] unit 
  # @return [Integer] 
  # @scope class
  attach_function :get_num_diagnostics, :clang_getNumDiagnostics, [TranslationUnitImpl], :uint
  
  # Retrieve a diagnostic associated with the given translation unit.
  # 
  # @method get_diagnostic(unit, index)
  # @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, [TranslationUnitImpl, :uint], :pointer
  
  # Destroy a diagnostic.
  # 
  # @method dispose_diagnostic(diagnostic)
  # @param [FFI::Pointer(Diagnostic)] diagnostic 
  # @return [nil] 
  # @scope class
  attach_function :dispose_diagnostic, :clang_disposeDiagnostic, [:pointer], :void
  
  # Options to control the display of diagnostics.
  # 
  # The values in this enum are meant to be combined to customize the
  # behavior of \c clang_displayDiagnostic().
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:diagnostic_display_options).</em>
  # 
  # === Options:
  # :source_location ::
  #   Display the source-location information where the
  #   diagnostic was located.
  #   
  #   When set, diagnostics will be prefixed by the file, line, and
  #   (optionally) column to which the diagnostic refers. For example,
  #   
  #   \code
  #   test.c:28: warning: extra tokens at end of #endif directive
  #   \endcode
  #   
  #   This option corresponds to the clang flag \c -fshow-source-location.
  # :column ::
  #   If displaying the source-location information of the
  #   diagnostic, also include the column number.
  #   
  #   This option corresponds to the clang flag \c -fshow-column.
  # :source_ranges ::
  #   If displaying the source-location information of the
  #   diagnostic, also include information about source ranges in a
  #   machine-parsable format.
  #   
  #   This option corresponds to the clang flag
  #   \c -fdiagnostics-print-source-range-info.
  # :option ::
  #   Display the option name associated with this diagnostic, if any.
  #   
  #   The option name displayed (e.g., -Wconversion) will be placed in brackets
  #   after the diagnostic text. This option corresponds to the clang flag
  #   \c -fdiagnostics-show-option.
  # :category_id ::
  #   Display the category number associated with this diagnostic, if any.
  #   
  #   The category number is displayed within brackets after the diagnostic text.
  #   This option corresponds to the clang flag 
  #   \c -fdiagnostics-show-category=id.
  # :category_name ::
  #   Display the category name associated with this diagnostic, if any.
  #   
  #   The category name is displayed within brackets after the diagnostic text.
  #   This option corresponds to the clang flag 
  #   \c -fdiagnostics-show-category=name.
  # 
  # @method _enum_diagnostic_display_options_
  # @return [Symbol]
  # @scope class
  enum :diagnostic_display_options, [
    :source_location, 1,
    :column, 2,
    :source_ranges, 4,
    :option, 8,
    :category_id, 16,
    :category_name, 32
  ]
  
  # Format the given diagnostic in a manner that is suitable for display.
  # 
  # This routine will format the given diagnostic to a string, rendering
  # the diagnostic according to the various options given. The
  # \c clang_defaultDiagnosticDisplayOptions() function returns the set of
  # options that most closely mimics the behavior of the clang compiler.
  # 
  # @method format_diagnostic(diagnostic, options)
  # @param [FFI::Pointer(Diagnostic)] diagnostic The diagnostic to print.
  # @param [Integer] options A set of options that control the diagnostic display,
  #   created by combining \c CXDiagnosticDisplayOptions values.
  # @return [String] A new string containing for formatted diagnostic.
  # @scope class
  attach_function :format_diagnostic, :clang_formatDiagnostic, [:pointer, :uint], String.by_value
  
  # Retrieve the set of display options most similar to the
  # default behavior of the clang compiler.
  # 
  # @method default_diagnostic_display_options()
  # @return [Integer] A set of display options suitable for use with \c
  #   clang_displayDiagnostic().
  # @scope class
  attach_function :default_diagnostic_display_options, :clang_defaultDiagnosticDisplayOptions, [], :uint
  
  # Determine the severity of the given diagnostic.
  # 
  # @method get_diagnostic_severity(diagnostic)
  # @param [FFI::Pointer(Diagnostic)] diagnostic 
  # @return [Symbol from _enum_diagnostic_severity_] 
  # @scope class
  attach_function :get_diagnostic_severity, :clang_getDiagnosticSeverity, [:pointer], :diagnostic_severity
  
  # Retrieve the source location of the given diagnostic.
  # 
  # This location is where Clang would print the caret ('^') when
  # displaying the diagnostic on the command line.
  # 
  # @method get_diagnostic_location(diagnostic)
  # @param [FFI::Pointer(Diagnostic)] diagnostic 
  # @return [SourceLocation] 
  # @scope class
  attach_function :get_diagnostic_location, :clang_getDiagnosticLocation, [:pointer], SourceLocation.by_value
  
  # Retrieve the text of the given diagnostic.
  # 
  # @method get_diagnostic_spelling(diagnostic)
  # @param [FFI::Pointer(Diagnostic)] diagnostic 
  # @return [String] 
  # @scope class
  attach_function :get_diagnostic_spelling, :clang_getDiagnosticSpelling, [:pointer], String.by_value
  
  # Retrieve the name of the command-line option that enabled this
  # diagnostic.
  # 
  # @method get_diagnostic_option(diag, disable)
  # @param [FFI::Pointer(Diagnostic)] diag The diagnostic to be queried.
  # @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, String], String.by_value
  
  # Retrieve the category number for this diagnostic.
  # 
  # Diagnostics can be categorized into groups along with other, related
  # diagnostics (e.g., diagnostics under the same warning flag). This routine 
  # retrieves the category number for the given diagnostic.
  # 
  # @method get_diagnostic_category(diagnostic)
  # @param [FFI::Pointer(Diagnostic)] diagnostic 
  # @return [Integer] The number of the category that contains this diagnostic, or zero
  #   if this diagnostic is uncategorized.
  # @scope class
  attach_function :get_diagnostic_category, :clang_getDiagnosticCategory, [:pointer], :uint
  
  # Retrieve the name of a particular diagnostic category.
  # 
  # @method get_diagnostic_category_name(category)
  # @param [Integer] category A diagnostic category number, as returned by 
  #   \c clang_getDiagnosticCategory().
  # @return [String] The name of the given diagnostic category.
  # @scope class
  attach_function :get_diagnostic_category_name, :clang_getDiagnosticCategoryName, [:uint], String.by_value
  
  # Determine the number of source ranges associated with the given
  # diagnostic.
  # 
  # @method get_diagnostic_num_ranges(diagnostic)
  # @param [FFI::Pointer(Diagnostic)] diagnostic 
  # @return [Integer] 
  # @scope class
  attach_function :get_diagnostic_num_ranges, :clang_getDiagnosticNumRanges, [:pointer], :uint
  
  # Retrieve a source range associated with the diagnostic.
  # 
  # A diagnostic's source ranges highlight important elements in the source
  # code. On the command line, Clang displays source ranges by
  # underlining them with '~' characters.
  # 
  # @method get_diagnostic_range(diagnostic, range)
  # @param [FFI::Pointer(Diagnostic)] diagnostic the diagnostic whose range is being extracted.
  # @param [Integer] range the zero-based index specifying which range to
  # @return [SourceRange] the requested source range.
  # @scope class
  attach_function :get_diagnostic_range, :clang_getDiagnosticRange, [:pointer, :uint], SourceRange.by_value
  
  # Determine the number of fix-it hints associated with the
  # given diagnostic.
  # 
  # @method get_diagnostic_num_fix_its(diagnostic)
  # @param [FFI::Pointer(Diagnostic)] diagnostic 
  # @return [Integer] 
  # @scope class
  attach_function :get_diagnostic_num_fix_its, :clang_getDiagnosticNumFixIts, [:pointer], :uint
  
  # Retrieve the replacement information for a given fix-it.
  # 
  # Fix-its are described in terms of a source range whose contents
  # should be replaced by a string. This approach generalizes over
  # three kinds of operations: removal of source code (the range covers
  # the code to be removed and the replacement string is empty),
  # replacement of source code (the range covers the code to be
  # replaced and the replacement string provides the new code), and
  # insertion (both the start and end of the range point at the
  # insertion location, and the replacement string provides the text to
  # insert).
  # 
  # @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 [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, SourceRange], String.by_value
  
  # Get the original translation unit source file name.
  # 
  # @method get_translation_unit_spelling(ct_unit)
  # @param [TranslationUnitImpl] ct_unit 
  # @return [String] 
  # @scope class
  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.
  # 
  # Note: The 'source_filename' argument is optional.  If the caller provides a
  # NULL pointer, the name of the source file is expected to reside in the
  # specified command line arguments.
  # 
  # Note: When encountered in 'clang_command_line_args', the following options
  # are ignored:
  # 
  #   '-c'
  #   '-emit-ast'
  #   '-fsyntax-only'
  #   '-o <output file>'  (both '-o' and '<output file>' are ignored)
  # 
  # @method create_translation_unit_from_source_file(c_idx, source_filename, num_clang_command_line_args, command_line_args, num_unsaved_files, unsaved_files)
  # @param [FFI::Pointer(Index)] c_idx The index object with which the translation unit will be
  #   associated.
  # @param [String] source_filename - The name of the source file to load, or NULL if the
  #   source file is included in \p clang_command_line_args.
  # @param [Integer] num_clang_command_line_args The number of command-line arguments in
  #   \p clang_command_line_args.
  # @param [FFI::Pointer(**CharS)] command_line_args The command-line arguments that would be
  #   passed to the \c clang executable if it were being invoked out-of-process.
  #   These command-line options will be parsed and will affect how the translation
  #   unit is parsed. Note that the following options are ignored: '-c',
  #   '-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 [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 [TranslationUnitImpl] 
  # @scope class
  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 [TranslationUnitImpl] 
  # @scope class
  attach_function :create_translation_unit, :clang_createTranslationUnit, [:pointer, :string], TranslationUnitImpl
  
  # Flags that control the creation of translation units.
  # 
  # The enumerators in this enumeration type are meant to be bitwise
  # ORed together to specify which options should be used when
  # constructing the translation unit.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:translation_unit_flags).</em>
  # 
  # === Options:
  # :none ::
  #   Used to indicate that no special translation-unit options are
  #   needed.
  # :detailed_preprocessing_record ::
  #   Used to indicate that the parser should construct a "detailed"
  #   preprocessing record, including all macro definitions and instantiations.
  #   
  #   Constructing a detailed preprocessing record requires more memory
  #   and time to parse, since the information contained in the record
  #   is usually not retained. However, it can be useful for
  #   applications that require more detailed information about the
  #   behavior of the preprocessor.
  # :incomplete ::
  #   Used to indicate that the translation unit is incomplete.
  #   
  #   When a translation unit is considered "incomplete", semantic
  #   analysis that is typically performed at the end of the
  #   translation unit will be suppressed. For example, this suppresses
  #   the completion of tentative declarations in C and of
  #   instantiation of implicitly-instantiation function templates in
  #   C++. This option is typically used when parsing a header with the
  #   intent of producing a precompiled header.
  # :precompiled_preamble ::
  #   Used to indicate that the translation unit should be built with an 
  #   implicit precompiled header for the preamble.
  #   
  #   An implicit precompiled header is used as an optimization when a
  #   particular translation unit is likely to be reparsed many times
  #   when the sources aren't changing that often. In this case, an
  #   implicit precompiled header will be built containing all of the
  #   initial includes at the top of the main file (what we refer to as
  #   the "preamble" of the file). In subsequent parses, if the
  #   preamble or the files in it have not changed, \c
  #   clang_reparseTranslationUnit() will re-use the implicit
  #   precompiled header to improve parsing performance.
  # :cache_completion_results ::
  #   Used to indicate that the translation unit should cache some
  #   code-completion results with each reparse of the source file.
  #   
  #   Caching of code-completion results is a performance optimization that
  #   introduces some overhead to reparsing but improves the performance of
  #   code-completion operations.
  # :cxx_precompiled_preamble ::
  #   DEPRECATED: Enable precompiled preambles in C++.
  #   
  #   Note: this is a *temporary* option that is available only while
  #   we are testing C++ precompiled preamble support. It is deprecated.
  # :cxx_chained_pch ::
  #   DEPRECATED: Enabled chained precompiled preambles in C++.
  #   
  #   Note: this is a *temporary* option that is available only while
  #   we are testing C++ precompiled preamble support. It is deprecated.
  # :nested_macro_expansions ::
  #   Used to indicate that the "detailed" preprocessing record,
  #   if requested, should also contain nested macro expansions.
  #   
  #   Nested macro expansions (i.e., macro expansions that occur
  #   inside another macro expansion) can, in some code bases, require
  #   a large amount of storage to due preprocessor metaprogramming. Moreover,
  #   its fairly rare that this information is useful for libclang clients.
  # 
  # @method _enum_translation_unit_flags_
  # @return [Symbol]
  # @scope class
  enum :translation_unit_flags, [
    :none, 0,
    :detailed_preprocessing_record, 1,
    :incomplete, 2,
    :precompiled_preamble, 4,
    :cache_completion_results, 8,
    :cxx_precompiled_preamble, 16,
    :cxx_chained_pch, 32,
    :nested_macro_expansions, 64
  ]
  
  # Returns the set of flags that is suitable for parsing a translation
  # unit that is being edited.
  # 
  # The set of flags returned provide options for \c clang_parseTranslationUnit()
  # to indicate that the translation unit is likely to be reparsed many times,
  # either explicitly (via \c clang_reparseTranslationUnit()) or implicitly
  # (e.g., by code completion (\c clang_codeCompletionAt())). The returned flag
  # set contains an unspecified set of optimizations (e.g., the precompiled 
  # preamble) geared toward improving the performance of these routines. The
  # set of optimizations enabled may change from one version to the next.
  # 
  # @method default_editing_translation_unit_options()
  # @return [Integer] 
  # @scope class
  attach_function :default_editing_translation_unit_options, :clang_defaultEditingTranslationUnitOptions, [], :uint
  
  # Parse the given source file and the translation unit corresponding
  # to that file.
  # 
  # This routine is the main entry point for the Clang C API, providing the
  # ability to parse a source file into a translation unit that can then be
  # queried by other functions in the API. This routine accepts a set of
  # command-line arguments so that the compilation can be configured in the same
  # way that the compiler is configured on the command line.
  # 
  # @method parse_translation_unit(c_idx, source_filename, command_line_args, num_command_line_args, unsaved_files, num_unsaved_files, options)
  # @param [FFI::Pointer(Index)] c_idx The index object with which the translation unit will be 
  #   associated.
  # @param [String] source_filename The name of the source file to load, or NULL if the
  #   source file is included in \p command_line_args.
  # @param [FFI::Pointer(**CharS)] command_line_args The command-line arguments that would be
  #   passed to the \c clang executable if it were being invoked out-of-process.
  #   These command-line options will be parsed and will affect how the translation
  #   unit is parsed. Note that the following options are ignored: '-c', 
  #   '-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 [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
  #   guarantee their validity until the call to this function returns.
  # @param [Integer] num_unsaved_files the number of unsaved file entries in \p
  #   unsaved_files.
  # @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 [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, UnsavedFile, :uint, :uint], TranslationUnitImpl
  
  # Flags that control how translation units are saved.
  # 
  # The enumerators in this enumeration type are meant to be bitwise
  # ORed together to specify which options should be used when
  # saving the translation unit.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:save_translation_unit_flags).</em>
  # 
  # === Options:
  # :save_translation_unit_none ::
  #   Used to indicate that no special saving options are needed.
  # 
  # @method _enum_save_translation_unit_flags_
  # @return [Symbol]
  # @scope class
  enum :save_translation_unit_flags, [
    :save_translation_unit_none, 0
  ]
  
  # Returns the set of flags that is suitable for saving a translation
  # unit.
  # 
  # The set of flags returned provide options for
  # \c clang_saveTranslationUnit() by default. The returned flag
  # set contains an unspecified set of options that save translation units with
  # the most commonly-requested data.
  # 
  # @method default_save_options(tu)
  # @param [TranslationUnitImpl] tu 
  # @return [Integer] 
  # @scope class
  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().
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:save_error).</em>
  # 
  # === Options:
  # :none ::
  #   Indicates that no error occurred while saving a translation unit.
  # :unknown ::
  #   Indicates that an unknown error occurred while attempting to save
  #   the file.
  #   
  #   This error typically indicates that file I/O failed when attempting to 
  #   write the file.
  # :translation_errors ::
  #   Indicates that errors during translation prevented this attempt
  #   to save the translation unit.
  #   
  #   Errors that prevent the translation unit from being saved can be
  #   extracted using \c clang_getNumDiagnostics() and \c clang_getDiagnostic().
  # :invalid_tu ::
  #   Indicates that the translation unit to be saved was somehow
  #   invalid (e.g., NULL).
  # 
  # @method _enum_save_error_
  # @return [Symbol]
  # @scope class
  enum :save_error, [
    :none, 0,
    :unknown, 1,
    :translation_errors, 2,
    :invalid_tu, 3
  ]
  
  # Saves a translation unit into a serialized representation of
  # that translation unit on disk.
  # 
  # Any translation unit that was parsed without error can be saved
  # into a file. The translation unit can then be deserialized into a
  # new \c CXTranslationUnit with \c clang_createTranslationUnit() or,
  # if it is an incomplete translation unit that corresponds to a
  # header, used as a precompiled header when parsing other translation
  # units.
  # 
  # @method save_translation_unit(tu, file_name, options)
  # @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
  #   CXSaveTranslationUnit_XXX flags.
  # @return [Integer] A value that will match one of the enumerators of the CXSaveError
  #   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, [TranslationUnitImpl, :string, :uint], :int
  
  # Destroy the specified CXTranslationUnit object.
  # 
  # @method dispose_translation_unit(translation_unit_impl)
  # @param [TranslationUnitImpl] translation_unit_impl 
  # @return [nil] 
  # @scope class
  attach_function :dispose_translation_unit, :clang_disposeTranslationUnit, [TranslationUnitImpl], :void
  
  # Flags that control the reparsing of translation units.
  # 
  # The enumerators in this enumeration type are meant to be bitwise
  # ORed together to specify which options should be used when
  # reparsing the translation unit.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:reparse_flags).</em>
  # 
  # === Options:
  # :reparse_none ::
  #   Used to indicate that no special reparsing options are needed.
  # 
  # @method _enum_reparse_flags_
  # @return [Symbol]
  # @scope class
  enum :reparse_flags, [
    :reparse_none, 0
  ]
  
  # Returns the set of flags that is suitable for reparsing a translation
  # unit.
  # 
  # The set of flags returned provide options for
  # \c clang_reparseTranslationUnit() by default. The returned flag
  # set contains an unspecified set of optimizations geared toward common uses
  # of reparsing. The set of optimizations enabled may change from one version 
  # to the next.
  # 
  # @method default_reparse_options(tu)
  # @param [TranslationUnitImpl] tu 
  # @return [Integer] 
  # @scope class
  attach_function :default_reparse_options, :clang_defaultReparseOptions, [TranslationUnitImpl], :uint
  
  # Reparse the source files that produced this translation unit.
  # 
  # This routine can be used to re-parse the source files that originally
  # created the given translation unit, for example because those source files
  # have changed (either on disk or as passed via \p unsaved_files). The
  # source code will be reparsed with the same command-line options as it
  # was originally parsed. 
  # 
  # Reparsing a translation unit invalidates all cursors and source locations
  # that refer into that translation unit. This makes reparsing a translation
  # unit semantically equivalent to destroying the translation unit and then
  # creating a new translation unit with the same command-line arguments.
  # However, it may be more efficient to reparse a translation 
  # unit using this routine.
  # 
  # @method reparse_translation_unit(tu, num_unsaved_files, unsaved_files, options)
  # @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 [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
  #   guarantee their validity until the call to this function returns.
  # @param [Integer] options A bitset of options composed of the flags in CXReparse_Flags.
  #   The function \c clang_defaultReparseOptions() produces a default set of
  #   options recommended for most uses, based on the translation unit.
  # @return [Integer] 0 if the sources could be reparsed. A non-zero value will be
  #   returned if reparsing was impossible, such that the translation unit is
  #   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, [TranslationUnitImpl, :uint, UnsavedFile, :uint], :int
  
  # Categorizes how memory is being used by a translation unit.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:tu_resource_usage_kind).</em>
  # 
  # === Options:
  # :ast ::
  #   
  # :identifiers ::
  #   
  # :selectors ::
  #   
  # :global_completion_results ::
  #   
  # :source_manager_content_cache ::
  #   
  # :ast_side_tables ::
  #   
  # :source_manager_membuffer_malloc ::
  #   
  # :source_manager_membuffer_m_map ::
  #   
  # :external_ast_source_membuffer_malloc ::
  #   
  # :external_ast_source_membuffer_m_map ::
  #   
  # :preprocessor ::
  #   
  # :preprocessing_record ::
  #   
  # :source_manager_data_structures ::
  #   
  # :preprocessor_header_search ::
  #   
  # 
  # @method _enum_tu_resource_usage_kind_
  # @return [Symbol]
  # @scope class
  enum :tu_resource_usage_kind, [
    :ast, 1,
    :identifiers, 2,
    :selectors, 3,
    :global_completion_results, 4,
    :source_manager_content_cache, 5,
    :ast_side_tables, 6,
    :source_manager_membuffer_malloc, 7,
    :source_manager_membuffer_m_map, 8,
    :external_ast_source_membuffer_malloc, 9,
    :external_ast_source_membuffer_m_map, 10,
    :preprocessor, 11,
    :preprocessing_record, 12,
    :source_manager_data_structures, 13,
    :preprocessor_header_search, 14
  ]
  
  # Returns the human-readable null-terminated C string that represents
  #  the name of the memory category.  This string should never be freed.
  # 
  # @method get_tu_resource_usage_name(kind)
  # @param [Symbol from _enum_tu_resource_usage_kind_] kind 
  # @return [String] 
  # @scope class
  attach_function :get_tu_resource_usage_name, :clang_getTUResourceUsageName, [:tu_resource_usage_kind], :string
  
  # (Not documented)
  # 
  # = Fields:
  # :kind ::
  #   (Symbol from _enum_tu_resource_usage_kind_) The memory usage category.
  # :amount ::
  #   (Integer) Amount of resources used. 
  #         The units will depend on the resource kind.
  class TUResourceUsageEntry < FFI::Struct
    layout :kind, :tu_resource_usage_kind,
           :amount, :ulong
  end
  
  # The memory usage of a CXTranslationUnit, broken into categories.
  # 
  # = Fields:
  # :data ::
  #   (FFI::Pointer(*Void)) Private data member, used for queries.
  # :num_entries ::
  #   (Integer) The number of entries in the 'entries' array.
  # :entries ::
  #   (TUResourceUsageEntry) An array of key-value pairs, representing the breakdown of memory
  #               usage.
  class TUResourceUsage < FFI::Struct
    layout :data, :pointer,
           :num_entries, :uint,
           :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 [TranslationUnitImpl] tu 
  # @return [TUResourceUsage] 
  # @scope class
  attach_function :get_cxtu_resource_usage, :clang_getCXTUResourceUsage, [TranslationUnitImpl], TUResourceUsage.by_value
  
  # (Not documented)
  # 
  # @method dispose_cxtu_resource_usage(usage)
  # @param [TUResourceUsage] usage 
  # @return [nil] 
  # @scope class
  attach_function :dispose_cxtu_resource_usage, :clang_disposeCXTUResourceUsage, [TUResourceUsage.by_value], :void
  
  # Describes the kind of entity that a cursor refers to.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:cursor_kind).</em>
  # 
  # === Options:
  # :unexposed_decl ::
  #   A declaration whose specific kind is not exposed via this
  #   interface.
  #   
  #   Unexposed declarations have the same operations as any other kind
  #   of declaration; one can extract their location information,
  #   spelling, find their definitions, etc. However, the specific kind
  #   of the declaration is not reported.
  # :struct_decl ::
  #   A C or C++ struct.
  # :union_decl ::
  #   A C or C++ union.
  # :class_decl ::
  #   A C++ class.
  # :enum_decl ::
  #   An enumeration.
  # :field_decl ::
  #   A field (in C) or non-static data member (in C++) in a
  #   struct, union, or C++ class.
  # :enum_constant_decl ::
  #   An enumerator constant.
  # :function_decl ::
  #   A function.
  # :var_decl ::
  #   A variable.
  # :parm_decl ::
  #   A function or method parameter.
  # :obj_c_interface_decl ::
  #   An Objective-C @interface.
  # :obj_c_category_decl ::
  #   An Objective-C @interface for a category.
  # :obj_c_protocol_decl ::
  #   An Objective-C @protocol declaration.
  # :obj_c_property_decl ::
  #   An Objective-C @property declaration.
  # :obj_c_ivar_decl ::
  #   An Objective-C instance variable.
  # :obj_c_instance_method_decl ::
  #   An Objective-C instance method.
  # :obj_c_class_method_decl ::
  #   An Objective-C class method.
  # :obj_c_implementation_decl ::
  #   An Objective-C @implementation.
  # :obj_c_category_impl_decl ::
  #   An Objective-C @implementation for a category.
  # :typedef_decl ::
  #   A typedef
  # :cxx_method ::
  #   A C++ class method.
  # :namespace ::
  #   A C++ namespace.
  # :linkage_spec ::
  #   A linkage specification, e.g. 'extern "C"'.
  # :constructor ::
  #   A C++ constructor.
  # :destructor ::
  #   A C++ destructor.
  # :conversion_function ::
  #   A C++ conversion function.
  # :template_type_parameter ::
  #   A C++ template type parameter.
  # :non_type_template_parameter ::
  #   A C++ non-type template parameter.
  # :template_template_parameter ::
  #   A C++ template template parameter.
  # :function_template ::
  #   A C++ function template.
  # :class_template ::
  #   A C++ class template.
  # :class_template_partial_specialization ::
  #   A C++ class template partial specialization.
  # :namespace_alias ::
  #   A C++ namespace alias declaration.
  # :using_directive ::
  #   A C++ using directive.
  # :using_declaration ::
  #   A C++ using declaration.
  # :type_alias_decl ::
  #   A C++ alias declaration
  # :obj_c_synthesize_decl ::
  #   An Objective-C @synthesize definition.
  # :obj_c_dynamic_decl ::
  #   An Objective-C @dynamic definition.
  # :cxx_access_specifier ::
  #   An access specifier.
  # :first_ref ::
  #   References
  # :obj_c_super_class_ref ::
  #   Decl references
  # :obj_c_protocol_ref ::
  #   
  # :obj_c_class_ref ::
  #   
  # :type_ref ::
  #   A reference to a type declaration.
  #   
  #   A type reference occurs anywhere where a type is named but not
  #   declared. For example, given:
  #   
  #   \code
  #   typedef unsigned size_type;
  #   size_type size;
  #   \endcode
  #   
  #   The typedef is a declaration of size_type (CXCursor_TypedefDecl),
  #   while the type of the variable "size" is referenced. The cursor
  #   referenced by the type of size is the typedef for size_type.
  # :cxx_base_specifier ::
  #   
  # :template_ref ::
  #   A reference to a class template, function template, template
  #   template parameter, or class template partial specialization.
  # :namespace_ref ::
  #   A reference to a namespace or namespace alias.
  # :member_ref ::
  #   A reference to a member of a struct, union, or class that occurs in 
  #   some non-expression context, e.g., a designated initializer.
  # :label_ref ::
  #   A reference to a labeled statement.
  #   
  #   This cursor kind is used to describe the jump to "start_over" in the 
  #   goto statement in the following example:
  #   
  #   \code
  #     start_over:
  #       ++counter;
  #   
  #       goto start_over;
  #   \endcode
  #   
  #   A label reference cursor refers to a label statement.
  # :overloaded_decl_ref ::
  #   A reference to a set of overloaded functions or function templates
  #   that has not yet been resolved to a specific function or function template.
  #   
  #   An overloaded declaration reference cursor occurs in C++ templates where
  #   a dependent name refers to a function. For example:
  #   
  #   \code
  #   template<typename T> void swap(T&, T&);
  #   
  #   struct X { ... };
  #   void swap(X&, X&);
  #   
  #   template<typename T>
  #   void reverse(T* first, T* last) {
  #     while (first < last - 1) {
  #       swap(*first, *--last);
  #       ++first;
  #     }
  #   }
  #   
  #   struct Y { };
  #   void swap(Y&, Y&);
  #   \endcode
  #   
  #   Here, the identifier "swap" is associated with an overloaded declaration
  #   reference. In the template definition, "swap" refers to either of the two
  #   "swap" functions declared above, so both results will be available. At
  #   instantiation time, "swap" may also refer to other functions found via
  #   argument-dependent lookup (e.g., the "swap" function at the end of the
  #   example).
  #   
  #   The functions \c clang_getNumOverloadedDecls() and 
  #   \c clang_getOverloadedDecl() can be used to retrieve the definitions
  #   referenced by this cursor.
  # :first_invalid ::
  #   Error conditions
  # :invalid_file ::
  #   
  # :no_decl_found ::
  #   
  # :not_implemented ::
  #   
  # :invalid_code ::
  #   
  # :first_expr ::
  #   Expressions
  # :unexposed_expr ::
  #   An expression whose specific kind is not exposed via this
  #   interface.
  #   
  #   Unexposed expressions have the same operations as any other kind
  #   of expression; one can extract their location information,
  #   spelling, children, etc. However, the specific kind of the
  #   expression is not reported.
  # :decl_ref_expr ::
  #   An expression that refers to some value declaration, such
  #   as a function, varible, or enumerator.
  # :member_ref_expr ::
  #   An expression that refers to a member of a struct, union,
  #   class, Objective-C class, etc.
  # :call_expr ::
  #   An expression that calls a function.
  # :obj_c_message_expr ::
  #   An expression that sends a message to an Objective-C
  #      object or class.
  # :block_expr ::
  #   An expression that represents a block literal.
  # :integer_literal ::
  #   An integer literal.
  # :floating_literal ::
  #   A floating point number literal.
  # :imaginary_literal ::
  #   An imaginary number literal.
  # :string_literal ::
  #   A string literal.
  # :character_literal ::
  #   A character literal.
  # :paren_expr ::
  #   A parenthesized expression, e.g. "(1)".
  #   
  #   This AST node is only formed if full location information is requested.
  # :unary_operator ::
  #   This represents the unary-expression's (except sizeof and
  #   alignof).
  # :array_subscript_expr ::
  #   (C99 6.5.2.1) Array Subscripting.
  # :binary_operator ::
  #   A builtin binary operation expression such as "x + y" or
  #   "x <= y".
  # :compound_assign_operator ::
  #   Compound assignment such as "+=".
  # :conditional_operator ::
  #   The ?: ternary operator.
  # :c_style_cast_expr ::
  #   An explicit cast in C (C99 6.5.4) or a C-style cast in C++
  #   (C++ (expr.cast)), which uses the syntax (Type)expr.
  #   
  #   For example: (int)f.
  # :compound_literal_expr ::
  #   (C99 6.5.2.5)
  # :init_list_expr ::
  #   Describes an C or C++ initializer list.
  # :addr_label_expr ::
  #   The GNU address of label extension, representing &&label.
  # :stmt_expr ::
  #   This is the GNU Statement Expression extension: ({int X=4; X;})
  # :generic_selection_expr ::
  #   Represents a C1X generic selection.
  # :gnu_null_expr ::
  #   Implements the GNU __null extension, which is a name for a null
  #   pointer constant that has integral type (e.g., int or long) and is the same
  #   size and alignment as a pointer.
  #   
  #   The __null extension is typically only used by system headers, which define
  #   NULL as __null in C++ rather than using 0 (which is an integer that may not
  #   match the size of a pointer).
  # :cxx_static_cast_expr ::
  #   C++'s static_cast<> expression.
  # :cxx_dynamic_cast_expr ::
  #   C++'s dynamic_cast<> expression.
  # :cxx_reinterpret_cast_expr ::
  #   C++'s reinterpret_cast<> expression.
  # :cxx_const_cast_expr ::
  #   C++'s const_cast<> expression.
  # :cxx_functional_cast_expr ::
  #   Represents an explicit C++ type conversion that uses "functional"
  #   notion (C++ (expr.type.conv)).
  #   
  #   Example:
  #   \code
  #     x = int(0.5);
  #   \endcode
  # :cxx_typeid_expr ::
  #   A C++ typeid expression (C++ (expr.typeid)).
  # :cxx_bool_literal_expr ::
  #   (C++ 2.13.5) C++ Boolean Literal.
  # :cxx_null_ptr_literal_expr ::
  #   (C++0x 2.14.7) C++ Pointer Literal.
  # :cxx_this_expr ::
  #   Represents the "this" expression in C++
  # :cxx_throw_expr ::
  #   (C++ 15) C++ Throw Expression.
  #   
  #   This handles 'throw' and 'throw' assignment-expression. When
  #   assignment-expression isn't present, Op will be null.
  # :cxx_new_expr ::
  #   A new expression for memory allocation and constructor calls, e.g:
  #   "new CXXNewExpr(foo)".
  # :cxx_delete_expr ::
  #   A delete expression for memory deallocation and destructor calls,
  #   e.g. "delete() pArray".
  # :unary_expr ::
  #   A unary expression.
  # :obj_c_string_literal ::
  #   ObjCStringLiteral, used for Objective-C string literals i.e. "foo".
  # :obj_c_encode_expr ::
  #   ObjCEncodeExpr, used for in Objective-C.
  # :obj_c_selector_expr ::
  #   ObjCSelectorExpr used for in Objective-C.
  # :obj_c_protocol_expr ::
  #   Objective-C's protocol expression.
  # :obj_c_bridged_cast_expr ::
  #   An Objective-C "bridged" cast expression, which casts between
  #   Objective-C pointers and C pointers, transferring ownership in the process.
  #   
  #   \code
  #     NSString *str = (__bridge_transfer NSString *)CFCreateString();
  #   \endcode
  # :pack_expansion_expr ::
  #   Represents a C++0x pack expansion that produces a sequence of
  #   expressions.
  #   
  #   A pack expansion expression contains a pattern (which itself is an
  #   expression) followed by an ellipsis. For example:
  #   
  #   \code
  #   template<typename F, typename ...Types>
  #   void forward(F f, Types &&...args) {
  #    f(static_cast<Types&&>(args)...);
  #   }
  #   \endcode
  # :size_of_pack_expr ::
  #   Represents an expression that computes the length of a parameter
  #   pack.
  #   
  #   \code
  #   template<typename ...Types>
  #   struct count {
  #     static const unsigned value = sizeof...(Types);
  #   };
  #   \endcode
  # :first_stmt ::
  #   Statements
  # :unexposed_stmt ::
  #   A statement whose specific kind is not exposed via this
  #   interface.
  #   
  #   Unexposed statements have the same operations as any other kind of
  #   statement; one can extract their location information, spelling,
  #   children, etc. However, the specific kind of the statement is not
  #   reported.
  # :label_stmt ::
  #   A labelled statement in a function. 
  #   
  #   This cursor kind is used to describe the "start_over:" label statement in 
  #   the following example:
  #   
  #   \code
  #     start_over:
  #       ++counter;
  #   \endcode
  # :compound_stmt ::
  #   A group of statements like { stmt stmt }.
  #   
  #   This cursor kind is used to describe compound statements, e.g. function
  #   bodies.
  # :case_stmt ::
  #   A case statment.
  # :default_stmt ::
  #   A default statement.
  # :if_stmt ::
  #   An if statement
  # :switch_stmt ::
  #   A switch statement.
  # :while_stmt ::
  #   A while statement.
  # :do_stmt ::
  #   A do statement.
  # :for_stmt ::
  #   A for statement.
  # :goto_stmt ::
  #   A goto statement.
  # :indirect_goto_stmt ::
  #   An indirect goto statement.
  # :continue_stmt ::
  #   A continue statement.
  # :break_stmt ::
  #   A break statement.
  # :return_stmt ::
  #   A return statement.
  # :asm_stmt ::
  #   A GNU inline assembly statement extension.
  # :obj_c_at_try_stmt ::
  #   Objective-C's overall @try-@catc-@finall statement.
  # :obj_c_at_catch_stmt ::
  #   Objective-C's @catch statement.
  # :obj_c_at_finally_stmt ::
  #   Objective-C's @finally statement.
  # :obj_c_at_throw_stmt ::
  #   Objective-C's @throw statement.
  # :obj_c_at_synchronized_stmt ::
  #   Objective-C's @synchronized statement.
  # :obj_c_autorelease_pool_stmt ::
  #   Objective-C's autorelease pool statement.
  # :obj_c_for_collection_stmt ::
  #   Objective-C's collection statement.
  # :cxx_catch_stmt ::
  #   C++'s catch statement.
  # :cxx_try_stmt ::
  #   C++'s try statement.
  # :cxx_for_range_stmt ::
  #   C++'s for (* : *) statement.
  # :seh_try_stmt ::
  #   Windows Structured Exception Handling's try statement.
  # :seh_except_stmt ::
  #   Windows Structured Exception Handling's except statement.
  # :seh_finally_stmt ::
  #   Windows Structured Exception Handling's finally statement.
  # :null_stmt ::
  #   The null satement ";": C99 6.8.3p3.
  #   
  #   This cursor kind is used to describe the null statement.
  # :decl_stmt ::
  #   Adaptor class for mixing declarations with statements and
  #   expressions.
  # :translation_unit ::
  #   Cursor that represents the translation unit itself.
  #   
  #   The translation unit cursor exists primarily to act as the root
  #   cursor for traversing the contents of a translation unit.
  # :first_attr ::
  #   Attributes
  # :unexposed_attr ::
  #   An attribute whose specific kind is not exposed via this
  #   interface.
  # :ib_action_attr ::
  #   
  # :ib_outlet_attr ::
  #   
  # :ib_outlet_collection_attr ::
  #   
  # :cxx_final_attr ::
  #   
  # :cxx_override_attr ::
  #   
  # :annotate_attr ::
  #   
  # :preprocessing_directive ::
  #   Preprocessing
  # :macro_definition ::
  #   
  # :macro_expansion ::
  #   
  # :inclusion_directive ::
  #   
  # 
  # @method _enum_cursor_kind_
  # @return [Symbol]
  # @scope class
  enum :cursor_kind, [
    :unexposed_decl, 1,
    :struct_decl, 2,
    :union_decl, 3,
    :class_decl, 4,
    :enum_decl, 5,
    :field_decl, 6,
    :enum_constant_decl, 7,
    :function_decl, 8,
    :var_decl, 9,
    :parm_decl, 10,
    :obj_c_interface_decl, 11,
    :obj_c_category_decl, 12,
    :obj_c_protocol_decl, 13,
    :obj_c_property_decl, 14,
    :obj_c_ivar_decl, 15,
    :obj_c_instance_method_decl, 16,
    :obj_c_class_method_decl, 17,
    :obj_c_implementation_decl, 18,
    :obj_c_category_impl_decl, 19,
    :typedef_decl, 20,
    :cxx_method, 21,
    :namespace, 22,
    :linkage_spec, 23,
    :constructor, 24,
    :destructor, 25,
    :conversion_function, 26,
    :template_type_parameter, 27,
    :non_type_template_parameter, 28,
    :template_template_parameter, 29,
    :function_template, 30,
    :class_template, 31,
    :class_template_partial_specialization, 32,
    :namespace_alias, 33,
    :using_directive, 34,
    :using_declaration, 35,
    :type_alias_decl, 36,
    :obj_c_synthesize_decl, 37,
    :obj_c_dynamic_decl, 38,
    :cxx_access_specifier, 39,
    :first_ref, 40,
    :obj_c_super_class_ref, 40,
    :obj_c_protocol_ref, 41,
    :obj_c_class_ref, 42,
    :type_ref, 43,
    :cxx_base_specifier, 44,
    :template_ref, 45,
    :namespace_ref, 46,
    :member_ref, 47,
    :label_ref, 48,
    :overloaded_decl_ref, 49,
    :first_invalid, 70,
    :invalid_file, 70,
    :no_decl_found, 71,
    :not_implemented, 72,
    :invalid_code, 73,
    :first_expr, 100,
    :unexposed_expr, 100,
    :decl_ref_expr, 101,
    :member_ref_expr, 102,
    :call_expr, 103,
    :obj_c_message_expr, 104,
    :block_expr, 105,
    :integer_literal, 106,
    :floating_literal, 107,
    :imaginary_literal, 108,
    :string_literal, 109,
    :character_literal, 110,
    :paren_expr, 111,
    :unary_operator, 112,
    :array_subscript_expr, 113,
    :binary_operator, 114,
    :compound_assign_operator, 115,
    :conditional_operator, 116,
    :c_style_cast_expr, 117,
    :compound_literal_expr, 118,
    :init_list_expr, 119,
    :addr_label_expr, 120,
    :stmt_expr, 121,
    :generic_selection_expr, 122,
    :gnu_null_expr, 123,
    :cxx_static_cast_expr, 124,
    :cxx_dynamic_cast_expr, 125,
    :cxx_reinterpret_cast_expr, 126,
    :cxx_const_cast_expr, 127,
    :cxx_functional_cast_expr, 128,
    :cxx_typeid_expr, 129,
    :cxx_bool_literal_expr, 130,
    :cxx_null_ptr_literal_expr, 131,
    :cxx_this_expr, 132,
    :cxx_throw_expr, 133,
    :cxx_new_expr, 134,
    :cxx_delete_expr, 135,
    :unary_expr, 136,
    :obj_c_string_literal, 137,
    :obj_c_encode_expr, 138,
    :obj_c_selector_expr, 139,
    :obj_c_protocol_expr, 140,
    :obj_c_bridged_cast_expr, 141,
    :pack_expansion_expr, 142,
    :size_of_pack_expr, 143,
    :first_stmt, 200,
    :unexposed_stmt, 200,
    :label_stmt, 201,
    :compound_stmt, 202,
    :case_stmt, 203,
    :default_stmt, 204,
    :if_stmt, 205,
    :switch_stmt, 206,
    :while_stmt, 207,
    :do_stmt, 208,
    :for_stmt, 209,
    :goto_stmt, 210,
    :indirect_goto_stmt, 211,
    :continue_stmt, 212,
    :break_stmt, 213,
    :return_stmt, 214,
    :asm_stmt, 215,
    :obj_c_at_try_stmt, 216,
    :obj_c_at_catch_stmt, 217,
    :obj_c_at_finally_stmt, 218,
    :obj_c_at_throw_stmt, 219,
    :obj_c_at_synchronized_stmt, 220,
    :obj_c_autorelease_pool_stmt, 221,
    :obj_c_for_collection_stmt, 222,
    :cxx_catch_stmt, 223,
    :cxx_try_stmt, 224,
    :cxx_for_range_stmt, 225,
    :seh_try_stmt, 226,
    :seh_except_stmt, 227,
    :seh_finally_stmt, 228,
    :null_stmt, 230,
    :decl_stmt, 231,
    :translation_unit, 300,
    :first_attr, 400,
    :unexposed_attr, 400,
    :ib_action_attr, 401,
    :ib_outlet_attr, 402,
    :ib_outlet_collection_attr, 403,
    :cxx_final_attr, 404,
    :cxx_override_attr, 405,
    :annotate_attr, 406,
    :preprocessing_directive, 500,
    :macro_definition, 501,
    :macro_expansion, 502,
    :inclusion_directive, 503
  ]
  
  # A cursor representing some element in the abstract syntax tree for
  # a translation unit.
  # 
  # The cursor abstraction unifies the different kinds of entities in a
  # program--declaration, statements, expressions, references to declarations,
  # etc.--under a single "cursor" abstraction with a common set of operations.
  # Common operation for a cursor include: getting the physical location in
  # a source file where the cursor points, getting the name associated with a
  # cursor, and retrieving cursors for any child nodes of a particular cursor.
  # 
  # Cursors can be produced in two specific ways.
  # clang_getTranslationUnitCursor() produces a cursor for a translation unit,
  # from which one can use clang_visitChildren() to explore the rest of the
  # translation unit. clang_getCursor() maps from a physical source location
  # to the entity that resides at that location, allowing one to map from the
  # source code into the AST.
  # 
  # = Fields:
  # :kind ::
  #   (Symbol from _enum_cursor_kind_) 
  # :xdata ::
  #   (Integer) 
  # :data ::
  #   (Array<FFI::Pointer(*Void)>) 
  class Cursor < FFI::Struct
    layout :kind, :cursor_kind,
           :xdata, :int,
           :data, [:pointer, 3]
  end
  
  # Retrieve the NULL cursor, which represents no entity.
  # 
  # @method get_null_cursor()
  # @return [Cursor] 
  # @scope class
  attach_function :get_null_cursor, :clang_getNullCursor, [], Cursor.by_value
  
  # Retrieve the cursor that represents the given translation unit.
  # 
  # 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_impl)
  # @param [TranslationUnitImpl] translation_unit_impl 
  # @return [Cursor] 
  # @scope class
  attach_function :get_translation_unit_cursor, :clang_getTranslationUnitCursor, [TranslationUnitImpl], Cursor.by_value
  
  # Determine whether two cursors are equivalent.
  # 
  # @method equal_cursors(cursor, cursor)
  # @param [Cursor] cursor 
  # @param [Cursor] cursor 
  # @return [Integer] 
  # @scope class
  attach_function :equal_cursors, :clang_equalCursors, [Cursor.by_value, Cursor.by_value], :uint
  
  # Returns non-zero if \arg cursor is null.
  # 
  # @method cursor_is_null(cursor)
  # @param [Cursor] cursor 
  # @return [Integer] 
  # @scope class
  attach_function :cursor_is_null, :clang_Cursor_isNull, [Cursor.by_value], :int
  
  # Compute a hash value for the given cursor.
  # 
  # @method hash_cursor(cursor)
  # @param [Cursor] cursor 
  # @return [Integer] 
  # @scope class
  attach_function :hash_cursor, :clang_hashCursor, [Cursor.by_value], :uint
  
  # Retrieve the kind of the given cursor.
  # 
  # @method get_cursor_kind(cursor)
  # @param [Cursor] cursor 
  # @return [Symbol from _enum_cursor_kind_] 
  # @scope class
  attach_function :get_cursor_kind, :clang_getCursorKind, [Cursor.by_value], :cursor_kind
  
  # Determine whether the given cursor kind represents a declaration.
  # 
  # @method is_declaration(cursor_kind)
  # @param [Symbol from _enum_cursor_kind_] cursor_kind 
  # @return [Integer] 
  # @scope class
  attach_function :is_declaration, :clang_isDeclaration, [:cursor_kind], :uint
  
  # Determine whether the given cursor kind represents a simple
  # reference.
  # 
  # Note that other kinds of cursors (such as expressions) can also refer to
  # other cursors. Use clang_getCursorReferenced() to determine whether a
  # particular cursor refers to another entity.
  # 
  # @method is_reference(cursor_kind)
  # @param [Symbol from _enum_cursor_kind_] cursor_kind 
  # @return [Integer] 
  # @scope class
  attach_function :is_reference, :clang_isReference, [:cursor_kind], :uint
  
  # Determine whether the given cursor kind represents an expression.
  # 
  # @method is_expression(cursor_kind)
  # @param [Symbol from _enum_cursor_kind_] cursor_kind 
  # @return [Integer] 
  # @scope class
  attach_function :is_expression, :clang_isExpression, [:cursor_kind], :uint
  
  # Determine whether the given cursor kind represents a statement.
  # 
  # @method is_statement(cursor_kind)
  # @param [Symbol from _enum_cursor_kind_] cursor_kind 
  # @return [Integer] 
  # @scope class
  attach_function :is_statement, :clang_isStatement, [:cursor_kind], :uint
  
  # Determine whether the given cursor kind represents an attribute.
  # 
  # @method is_attribute(cursor_kind)
  # @param [Symbol from _enum_cursor_kind_] cursor_kind 
  # @return [Integer] 
  # @scope class
  attach_function :is_attribute, :clang_isAttribute, [:cursor_kind], :uint
  
  # Determine whether the given cursor kind represents an invalid
  # cursor.
  # 
  # @method is_invalid(cursor_kind)
  # @param [Symbol from _enum_cursor_kind_] cursor_kind 
  # @return [Integer] 
  # @scope class
  attach_function :is_invalid, :clang_isInvalid, [:cursor_kind], :uint
  
  # Determine whether the given cursor kind represents a translation
  # unit.
  # 
  # @method is_translation_unit(cursor_kind)
  # @param [Symbol from _enum_cursor_kind_] cursor_kind 
  # @return [Integer] 
  # @scope class
  attach_function :is_translation_unit, :clang_isTranslationUnit, [:cursor_kind], :uint
  
  # Determine whether the given cursor represents a preprocessing
  # element, such as a preprocessor directive or macro instantiation.
  # 
  # @method is_preprocessing(cursor_kind)
  # @param [Symbol from _enum_cursor_kind_] cursor_kind 
  # @return [Integer] 
  # @scope class
  attach_function :is_preprocessing, :clang_isPreprocessing, [:cursor_kind], :uint
  
  # Determine whether the given cursor represents a currently
  #  unexposed piece of the AST (e.g., CXCursor_UnexposedStmt).
  # 
  # @method is_unexposed(cursor_kind)
  # @param [Symbol from _enum_cursor_kind_] cursor_kind 
  # @return [Integer] 
  # @scope class
  attach_function :is_unexposed, :clang_isUnexposed, [:cursor_kind], :uint
  
  # Describe the linkage of the entity referred to by a cursor.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:linkage_kind).</em>
  # 
  # === Options:
  # :invalid ::
  #   This value indicates that no linkage information is available
  #   for a provided CXCursor.
  # :no_linkage ::
  #   This is the linkage for variables, parameters, and so on that
  #    have automatic storage.  This covers normal (non-extern) local variables.
  # :internal ::
  #   This is the linkage for static variables and static functions.
  # :unique_external ::
  #   This is the linkage for entities with external linkage that live
  #   in C++ anonymous namespaces.
  # :external ::
  #   This is the linkage for entities with true, external linkage.
  # 
  # @method _enum_linkage_kind_
  # @return [Symbol]
  # @scope class
  enum :linkage_kind, [
    :invalid, 0,
    :no_linkage, 1,
    :internal, 2,
    :unique_external, 3,
    :external, 4
  ]
  
  # Determine the linkage of the entity referred to by a given cursor.
  # 
  # @method get_cursor_linkage(cursor)
  # @param [Cursor] cursor 
  # @return [Symbol from _enum_linkage_kind_] 
  # @scope class
  attach_function :get_cursor_linkage, :clang_getCursorLinkage, [Cursor.by_value], :linkage_kind
  
  # Determine the availability of the entity that this cursor refers to.
  # 
  # @method get_cursor_availability(cursor)
  # @param [Cursor] cursor The cursor to query.
  # @return [Symbol from _enum_availability_kind_] The availability of the cursor.
  # @scope class
  attach_function :get_cursor_availability, :clang_getCursorAvailability, [Cursor.by_value], :availability_kind
  
  # Describe the "language" of the entity referred to by a cursor.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:language_kind).</em>
  # 
  # === Options:
  # :invalid ::
  #   
  # :c ::
  #   
  # :obj_c ::
  #   
  # :c_plus_plus ::
  #   
  # 
  # @method _enum_language_kind_
  # @return [Symbol]
  # @scope class
  enum :language_kind, [
    :invalid, 0,
    :c, 1,
    :obj_c, 2,
    :c_plus_plus, 3
  ]
  
  # Determine the "language" of the entity referred to by a given cursor.
  # 
  # @method get_cursor_language(cursor)
  # @param [Cursor] cursor 
  # @return [Symbol from _enum_language_kind_] 
  # @scope class
  attach_function :get_cursor_language, :clang_getCursorLanguage, [Cursor.by_value], :language_kind
  
  # Returns the translation unit that a cursor originated from.
  # 
  # @method cursor_get_translation_unit(cursor)
  # @param [Cursor] cursor 
  # @return [TranslationUnitImpl] 
  # @scope class
  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
    layout :dummy, :char
  end
  
  # Creates an empty CXCursorSet.
  # 
  # @method create_cx_cursor_set()
  # @return [CursorSetImpl] 
  # @scope class
  attach_function :create_cx_cursor_set, :clang_createCXCursorSet, [], CursorSetImpl
  
  # Disposes a CXCursorSet and releases its associated memory.
  # 
  # @method dispose_cx_cursor_set(cset)
  # @param [CursorSetImpl] cset 
  # @return [nil] 
  # @scope class
  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 [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, [CursorSetImpl, Cursor.by_value], :uint
  
  # Inserts a CXCursor into a CXCursorSet.
  # 
  # @method cx_cursor_set_insert(cset, cursor)
  # @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, [CursorSetImpl, Cursor.by_value], :uint
  
  # Determine the semantic parent of the given cursor.
  # 
  # The semantic parent of a cursor is the cursor that semantically contains
  # the given \p cursor. For many declarations, the lexical and semantic parents
  # are equivalent (the lexical parent is returned by 
  # \c clang_getCursorLexicalParent()). They diverge when declarations or
  # definitions are provided out-of-line. For example:
  # 
  # \code
  # class C {
  #  void f();
  # };
  # 
  # void C::f() { }
  # \endcode
  # 
  # In the out-of-line definition of \c C::f, the semantic parent is the 
  # the class \c C, of which this function is a member. The lexical parent is
  # the place where the declaration actually occurs in the source code; in this
  # case, the definition occurs in the translation unit. In general, the 
  # lexical parent for a given entity can change without affecting the semantics
  # of the program, and the lexical parent of different declarations of the
  # same entity may be different. Changing the semantic parent of a declaration,
  # on the other hand, can have a major impact on semantics, and redeclarations
  # of a particular entity should all have the same semantic context.
  # 
  # In the example above, both declarations of \c C::f have \c C as their
  # semantic context, while the lexical context of the first \c C::f is \c C
  # and the lexical context of the second \c C::f is the translation unit.
  # 
  # For global declarations, the semantic parent is the translation unit.
  # 
  # @method get_cursor_semantic_parent(cursor)
  # @param [Cursor] cursor 
  # @return [Cursor] 
  # @scope class
  attach_function :get_cursor_semantic_parent, :clang_getCursorSemanticParent, [Cursor.by_value], Cursor.by_value
  
  # Determine the lexical parent of the given cursor.
  # 
  # The lexical parent of a cursor is the cursor in which the given \p cursor
  # was actually written. For many declarations, the lexical and semantic parents
  # are equivalent (the semantic parent is returned by 
  # \c clang_getCursorSemanticParent()). They diverge when declarations or
  # definitions are provided out-of-line. For example:
  # 
  # \code
  # class C {
  #  void f();
  # };
  # 
  # void C::f() { }
  # \endcode
  # 
  # In the out-of-line definition of \c C::f, the semantic parent is the 
  # the class \c C, of which this function is a member. The lexical parent is
  # the place where the declaration actually occurs in the source code; in this
  # case, the definition occurs in the translation unit. In general, the 
  # lexical parent for a given entity can change without affecting the semantics
  # of the program, and the lexical parent of different declarations of the
  # same entity may be different. Changing the semantic parent of a declaration,
  # on the other hand, can have a major impact on semantics, and redeclarations
  # of a particular entity should all have the same semantic context.
  # 
  # In the example above, both declarations of \c C::f have \c C as their
  # semantic context, while the lexical context of the first \c C::f is \c C
  # and the lexical context of the second \c C::f is the translation unit.
  # 
  # For declarations written in the global scope, the lexical parent is
  # the translation unit.
  # 
  # @method get_cursor_lexical_parent(cursor)
  # @param [Cursor] cursor 
  # @return [Cursor] 
  # @scope class
  attach_function :get_cursor_lexical_parent, :clang_getCursorLexicalParent, [Cursor.by_value], Cursor.by_value
  
  # Determine the set of methods that are overridden by the given
  # method.
  # 
  # In both Objective-C and C++, a method (aka virtual member function,
  # in C++) can override a virtual method in a base class. For
  # Objective-C, a method is said to override any method in the class's
  # interface (if we're coming from an implementation), its protocols,
  # or its categories, that has the same selector and is of the same
  # kind (class or instance). If no such method exists, the search
  # continues to the class's superclass, its protocols, and its
  # categories, and so on.
  # 
  # For C++, a virtual member function overrides any virtual member
  # function with the same signature that occurs in its base
  # classes. With multiple inheritance, a virtual member function can
  # override several virtual member functions coming from different
  # base classes.
  # 
  # In all cases, this function determines the immediate overridden
  # method, rather than all of the overridden methods. For example, if
  # a method is originally declared in a class A, then overridden in B
  # (which in inherits from A) and also in C (which inherited from B),
  # then the only overridden method returned from this function when
  # invoked on C's method will be B's method. The client may then
  # invoke this function again, given the previously-found overridden
  # methods, to map out the complete method-override set.
  # 
  # @method get_overridden_cursors(cursor, overridden, num_overridden)
  # @param [Cursor] cursor A cursor representing an Objective-C or C++
  #   method. This routine will compute the set of methods that this
  #   method overrides.
  # @param [FFI::Pointer(**Cursor)] overridden A pointer whose pointee will be replaced with a
  #   pointer to an array of cursors, representing the set of overridden
  #   methods. If there are no overridden methods, the pointee will be
  #   set to NULL. The pointee must be freed via a call to 
  #   \c clang_disposeOverriddenCursors().
  # @param [FFI::Pointer(*UInt)] num_overridden A pointer to the number of overridden
  #   functions, will be set to the number of overridden functions in the
  #   array pointed to by \p overridden.
  # @return [nil] 
  # @scope class
  attach_function :get_overridden_cursors, :clang_getOverriddenCursors, [Cursor.by_value, :pointer, :pointer], :void
  
  # Free the set of overridden cursors returned by \c
  # clang_getOverriddenCursors().
  # 
  # @method dispose_overridden_cursors(overridden)
  # @param [Cursor] overridden 
  # @return [nil] 
  # @scope class
  attach_function :dispose_overridden_cursors, :clang_disposeOverriddenCursors, [Cursor], :void
  
  # Retrieve the file that is included by the given inclusion directive
  # cursor.
  # 
  # @method get_included_file(cursor)
  # @param [Cursor] cursor 
  # @return [FFI::Pointer(File)] 
  # @scope class
  attach_function :get_included_file, :clang_getIncludedFile, [Cursor.by_value], :pointer
  
  # Map a source location to the cursor that describes the entity at that
  # location in the source code.
  # 
  # clang_getCursor() maps an arbitrary source location within a translation
  # unit down to the most specific cursor that describes the entity at that
  # location. For example, given an expression \c x + y, invoking
  # clang_getCursor() with a source location pointing to "x" will return the
  # cursor for "x"; similarly for "y". If the cursor points anywhere between
  # "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_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, [TranslationUnitImpl, SourceLocation.by_value], Cursor.by_value
  
  # Retrieve the physical location of the source constructor referenced
  # by the given cursor.
  # 
  # The location of a declaration is typically the location of the name of that
  # declaration, where the name of that declaration would occur if it is
  # unnamed, or some keyword that introduces that particular declaration.
  # The location of a reference is where that reference occurs within the
  # source code.
  # 
  # @method get_cursor_location(cursor)
  # @param [Cursor] cursor 
  # @return [SourceLocation] 
  # @scope class
  attach_function :get_cursor_location, :clang_getCursorLocation, [Cursor.by_value], SourceLocation.by_value
  
  # Retrieve the physical extent of the source construct referenced by
  # the given cursor.
  # 
  # The extent of a cursor starts with the file/line/column pointing at the
  # first character within the source construct that the cursor refers to and
  # ends with the last character withinin that source construct. For a
  # declaration, the extent covers the declaration itself. For a reference,
  # the extent covers the location of the reference (e.g., where the referenced
  # entity was actually used).
  # 
  # @method get_cursor_extent(cursor)
  # @param [Cursor] cursor 
  # @return [SourceRange] 
  # @scope class
  attach_function :get_cursor_extent, :clang_getCursorExtent, [Cursor.by_value], SourceRange.by_value
  
  # Describes the kind of type
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:type_kind).</em>
  # 
  # === Options:
  # :invalid ::
  #   Reprents an invalid type (e.g., where no type is available).
  # :unexposed ::
  #   A type whose specific kind is not exposed via this
  #   interface.
  # :void ::
  #   Builtin types
  # :bool ::
  #   
  # :char_u ::
  #   
  # :u_char ::
  #   
  # :char16 ::
  #   
  # :char32 ::
  #   
  # :u_short ::
  #   
  # :u_int ::
  #   
  # :u_long ::
  #   
  # :u_long_long ::
  #   
  # :u_int128 ::
  #   
  # :char_s ::
  #   
  # :s_char ::
  #   
  # :w_char ::
  #   
  # :short ::
  #   
  # :int ::
  #   
  # :long ::
  #   
  # :long_long ::
  #   
  # :int128 ::
  #   
  # :float ::
  #   
  # :double ::
  #   
  # :long_double ::
  #   
  # :null_ptr ::
  #   
  # :overload ::
  #   
  # :dependent ::
  #   
  # :obj_c_id ::
  #   
  # :obj_c_class ::
  #   
  # :obj_c_sel ::
  #   
  # :complex ::
  #   
  # :pointer ::
  #   
  # :block_pointer ::
  #   
  # :l_value_reference ::
  #   
  # :r_value_reference ::
  #   
  # :record ::
  #   
  # :enum ::
  #   
  # :typedef ::
  #   
  # :obj_c_interface ::
  #   
  # :obj_c_object_pointer ::
  #   
  # :function_no_proto ::
  #   
  # :function_proto ::
  #   
  # :constant_array ::
  #   
  # 
  # @method _enum_type_kind_
  # @return [Symbol]
  # @scope class
  enum :type_kind, [
    :invalid, 0,
    :unexposed, 1,
    :void, 2,
    :bool, 3,
    :char_u, 4,
    :u_char, 5,
    :char16, 6,
    :char32, 7,
    :u_short, 8,
    :u_int, 9,
    :u_long, 10,
    :u_long_long, 11,
    :u_int128, 12,
    :char_s, 13,
    :s_char, 14,
    :w_char, 15,
    :short, 16,
    :int, 17,
    :long, 18,
    :long_long, 19,
    :int128, 20,
    :float, 21,
    :double, 22,
    :long_double, 23,
    :null_ptr, 24,
    :overload, 25,
    :dependent, 26,
    :obj_c_id, 27,
    :obj_c_class, 28,
    :obj_c_sel, 29,
    :complex, 100,
    :pointer, 101,
    :block_pointer, 102,
    :l_value_reference, 103,
    :r_value_reference, 104,
    :record, 105,
    :enum, 106,
    :typedef, 107,
    :obj_c_interface, 108,
    :obj_c_object_pointer, 109,
    :function_no_proto, 110,
    :function_proto, 111,
    :constant_array, 112
  ]
  
  # The type of an element in the abstract syntax tree.
  # 
  # = Fields:
  # :kind ::
  #   (Symbol from _enum_type_kind_) 
  # :data ::
  #   (Array<FFI::Pointer(*Void)>) 
  class Type < FFI::Struct
    layout :kind, :type_kind,
           :data, [:pointer, 2]
  end
  
  # Retrieve the type of a CXCursor (if any).
  # 
  # @method get_cursor_type(c)
  # @param [Cursor] c 
  # @return [Type] 
  # @scope class
  attach_function :get_cursor_type, :clang_getCursorType, [Cursor.by_value], Type.by_value
  
  # Determine whether two CXTypes represent the same type.
  # 
  # @method equal_types(a, b)
  # @param [Type] a 
  # @param [Type] b 
  # @return [Integer] non-zero if the CXTypes represent the same type and 
  #               zero otherwise.
  # @scope class
  attach_function :equal_types, :clang_equalTypes, [Type.by_value, Type.by_value], :uint
  
  # Return the canonical type for a CXType.
  # 
  # Clang's type system explicitly models typedefs and all the ways
  # a specific type can be represented.  The canonical type is the underlying
  # type with all the "sugar" removed.  For example, if 'T' is a typedef
  # for 'int', the canonical type for 'T' would be 'int'.
  # 
  # @method get_canonical_type(t)
  # @param [Type] t 
  # @return [Type] 
  # @scope class
  attach_function :get_canonical_type, :clang_getCanonicalType, [Type.by_value], Type.by_value
  
  # Determine whether a CXType has the "const" qualifier set, 
  # without looking through typedefs that may have added "const" at a different level.
  # 
  # @method is_const_qualified_type(t)
  # @param [Type] t 
  # @return [Integer] 
  # @scope class
  attach_function :is_const_qualified_type, :clang_isConstQualifiedType, [Type.by_value], :uint
  
  # Determine whether a CXType has the "volatile" qualifier set,
  # without looking through typedefs that may have added "volatile" at a different level.
  # 
  # @method is_volatile_qualified_type(t)
  # @param [Type] t 
  # @return [Integer] 
  # @scope class
  attach_function :is_volatile_qualified_type, :clang_isVolatileQualifiedType, [Type.by_value], :uint
  
  # Determine whether a CXType has the "restrict" qualifier set,
  # without looking through typedefs that may have added "restrict" at a different level.
  # 
  # @method is_restrict_qualified_type(t)
  # @param [Type] t 
  # @return [Integer] 
  # @scope class
  attach_function :is_restrict_qualified_type, :clang_isRestrictQualifiedType, [Type.by_value], :uint
  
  # For pointer types, returns the type of the pointee.
  # 
  # @method get_pointee_type(t)
  # @param [Type] t 
  # @return [Type] 
  # @scope class
  attach_function :get_pointee_type, :clang_getPointeeType, [Type.by_value], Type.by_value
  
  # Return the cursor for the declaration of the given type.
  # 
  # @method get_type_declaration(t)
  # @param [Type] t 
  # @return [Cursor] 
  # @scope class
  attach_function :get_type_declaration, :clang_getTypeDeclaration, [Type.by_value], Cursor.by_value
  
  # Returns the Objective-C type encoding for the specified declaration.
  # 
  # @method get_decl_obj_c_type_encoding(c)
  # @param [Cursor] c 
  # @return [String] 
  # @scope class
  attach_function :get_decl_obj_c_type_encoding, :clang_getDeclObjCTypeEncoding, [Cursor.by_value], String.by_value
  
  # Retrieve the spelling of a given CXTypeKind.
  # 
  # @method get_type_kind_spelling(k)
  # @param [Symbol from _enum_type_kind_] k 
  # @return [String] 
  # @scope class
  attach_function :get_type_kind_spelling, :clang_getTypeKindSpelling, [:type_kind], String.by_value
  
  # Retrieve the result type associated with a function type.
  # 
  # @method get_result_type(t)
  # @param [Type] t 
  # @return [Type] 
  # @scope class
  attach_function :get_result_type, :clang_getResultType, [Type.by_value], Type.by_value
  
  # Retrieve the result type associated with a given cursor.  This only
  #  returns a valid type of the cursor refers to a function or method.
  # 
  # @method get_cursor_result_type(c)
  # @param [Cursor] c 
  # @return [Type] 
  # @scope class
  attach_function :get_cursor_result_type, :clang_getCursorResultType, [Cursor.by_value], Type.by_value
  
  # Return 1 if the CXType is a POD (plain old data) type, and 0
  #  otherwise.
  # 
  # @method is_pod_type(t)
  # @param [Type] t 
  # @return [Integer] 
  # @scope class
  attach_function :is_pod_type, :clang_isPODType, [Type.by_value], :uint
  
  # Return the element type of an array type.
  # 
  # If a non-array type is passed in, an invalid type is returned.
  # 
  # @method get_array_element_type(t)
  # @param [Type] t 
  # @return [Type] 
  # @scope class
  attach_function :get_array_element_type, :clang_getArrayElementType, [Type.by_value], Type.by_value
  
  # Return the the array size of a constant array.
  # 
  # If a non-array type is passed in, -1 is returned.
  # 
  # @method get_array_size(t)
  # @param [Type] t 
  # @return [Integer] 
  # @scope class
  attach_function :get_array_size, :clang_getArraySize, [Type.by_value], :long_long
  
  # Returns 1 if the base class specified by the cursor with kind
  #   CX_CXXBaseSpecifier is virtual.
  # 
  # @method is_virtual_base(cursor)
  # @param [Cursor] cursor 
  # @return [Integer] 
  # @scope class
  attach_function :is_virtual_base, :clang_isVirtualBase, [Cursor.by_value], :uint
  
  # Represents the C++ access control level to a base class for a
  # cursor with kind CX_CXXBaseSpecifier.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:cxx_access_specifier).</em>
  # 
  # === Options:
  # :invalid_access_specifier ::
  #   
  # :public ::
  #   
  # :protected ::
  #   
  # :private ::
  #   
  # 
  # @method _enum_cxx_access_specifier_
  # @return [Symbol]
  # @scope class
  enum :cxx_access_specifier, [
    :invalid_access_specifier, 0,
    :public, 1,
    :protected, 2,
    :private, 3
  ]
  
  # Returns the access control level for the C++ base specifier
  # represented by a cursor with kind CXCursor_CXXBaseSpecifier or
  # CXCursor_AccessSpecifier.
  # 
  # @method get_cxx_access_specifier(cursor)
  # @param [Cursor] cursor 
  # @return [Symbol from _enum_cxx_access_specifier_] 
  # @scope class
  attach_function :get_cxx_access_specifier, :clang_getCXXAccessSpecifier, [Cursor.by_value], :cxx_access_specifier
  
  # Determine the number of overloaded declarations referenced by a 
  # \c CXCursor_OverloadedDeclRef cursor.
  # 
  # @method get_num_overloaded_decls(cursor)
  # @param [Cursor] cursor The cursor whose overloaded declarations are being queried.
  # @return [Integer] The number of overloaded declarations referenced by \c cursor. If it
  #   is not a \c CXCursor_OverloadedDeclRef cursor, returns 0.
  # @scope class
  attach_function :get_num_overloaded_decls, :clang_getNumOverloadedDecls, [Cursor.by_value], :uint
  
  # Retrieve a cursor for one of the overloaded declarations referenced
  # by a \c CXCursor_OverloadedDeclRef cursor.
  # 
  # @method get_overloaded_decl(cursor, index)
  # @param [Cursor] cursor The cursor whose overloaded declarations are being queried.
  # @param [Integer] index The zero-based index into the set of overloaded declarations in
  #   the cursor.
  # @return [Cursor] A cursor representing the declaration referenced by the given 
  #   \c cursor at the specified \c index. If the cursor does not have an 
  #   associated set of overloaded declarations, or if the index is out of bounds,
  #   returns \c clang_getNullCursor();
  # @scope class
  attach_function :get_overloaded_decl, :clang_getOverloadedDecl, [Cursor.by_value, :uint], Cursor.by_value
  
  # For cursors representing an iboutletcollection attribute,
  #  this function returns the collection element type.
  # 
  # @method get_ib_outlet_collection_type(cursor)
  # @param [Cursor] cursor 
  # @return [Type] 
  # @scope class
  attach_function :get_ib_outlet_collection_type, :clang_getIBOutletCollectionType, [Cursor.by_value], Type.by_value
  
  # Describes how the traversal of the children of a particular
  # cursor should proceed after visiting a particular child cursor.
  # 
  # A value of this enumeration type should be returned by each
  # \c CXCursorVisitor to indicate how clang_visitChildren() proceed.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:child_visit_result).</em>
  # 
  # === Options:
  # :break_ ::
  #   Terminates the cursor traversal.
  # :continue ::
  #   Continues the cursor traversal with the next sibling of
  #   the cursor just visited, without visiting its children.
  # :recurse ::
  #   Recursively traverse the children of this cursor, using
  #   the same visitor and client data.
  # 
  # @method _enum_child_visit_result_
  # @return [Symbol]
  # @scope class
  enum :child_visit_result, [
    :break_, 0,
    :continue, 1,
    :recurse, 2
  ]
  
  # Visitor invoked for each cursor found by a traversal.
  # 
  # This visitor function will be invoked for each cursor found by
  # clang_visitCursorChildren(). Its first argument is the cursor being
  # visited, its second argument is the parent visitor for that cursor,
  # and its third argument is the client data provided to
  # clang_visitCursorChildren().
  # 
  # The visitor should return one of the \c CXChildVisitResult values
  # to direct clang_visitCursorChildren().
  # 
  # <em>This entry is only for documentation and no real method.</em>
  # 
  # @method _callback_cursor_visitor_(cursor, parent, client_data)
  # @param [Cursor] cursor 
  # @param [Cursor] parent 
  # @param [FFI::Pointer(ClientData)] client_data 
  # @return [Symbol from _enum_child_visit_result_] 
  # @scope class
  callback :cursor_visitor, [Cursor.by_value, Cursor.by_value, :pointer], :child_visit_result
  
  # Visit the children of a particular cursor.
  # 
  # This function visits all the direct children of the given cursor,
  # invoking the given \p visitor function with the cursors of each
  # visited child. The traversal may be recursive, if the visitor returns
  # \c CXChildVisit_Recurse. The traversal may also be ended prematurely, if
  # the visitor returns \c CXChildVisit_Break.
  # 
  # @method visit_children(parent, visitor, client_data)
  # @param [Cursor] parent the cursor whose child may be visited. All kinds of
  #   cursors can be visited, including invalid cursors (which, by
  #   definition, have no children).
  # @param [Proc(_callback_cursor_visitor_)] visitor the visitor function that will be invoked for each
  #   child of \p parent.
  # @param [FFI::Pointer(ClientData)] client_data pointer data supplied by the client, which will
  #   be passed to the visitor each time it is invoked.
  # @return [Integer] a non-zero value if the traversal was terminated
  #   prematurely by the visitor returning \c CXChildVisit_Break.
  # @scope class
  attach_function :visit_children, :clang_visitChildren, [Cursor.by_value, :cursor_visitor, :pointer], :uint
  
  # Retrieve a Unified Symbol Resolution (USR) for the entity referenced
  # by the given cursor.
  # 
  # A Unified Symbol Resolution (USR) is a string that identifies a particular
  # entity (function, class, variable, etc.) within a program. USRs can be
  # compared across translation units to determine, e.g., when references in
  # one translation refer to an entity defined in another translation unit.
  # 
  # @method get_cursor_usr(cursor)
  # @param [Cursor] cursor 
  # @return [String] 
  # @scope class
  attach_function :get_cursor_usr, :clang_getCursorUSR, [Cursor.by_value], String.by_value
  
  # Construct a USR for a specified Objective-C class.
  # 
  # @method construct_usr_obj_c_class(class_name)
  # @param [String] class_name 
  # @return [String] 
  # @scope class
  attach_function :construct_usr_obj_c_class, :clang_constructUSR_ObjCClass, [:string], String.by_value
  
  # Construct a USR for a specified Objective-C category.
  # 
  # @method construct_usr_obj_c_category(class_name, category_name)
  # @param [String] class_name 
  # @param [String] category_name 
  # @return [String] 
  # @scope class
  attach_function :construct_usr_obj_c_category, :clang_constructUSR_ObjCCategory, [:string, :string], String.by_value
  
  # Construct a USR for a specified Objective-C protocol.
  # 
  # @method construct_usr_obj_c_protocol(protocol_name)
  # @param [String] protocol_name 
  # @return [String] 
  # @scope class
  attach_function :construct_usr_obj_c_protocol, :clang_constructUSR_ObjCProtocol, [:string], String.by_value
  
  # Construct a USR for a specified Objective-C instance variable and
  #   the USR for its containing class.
  # 
  # @method construct_usr_obj_c_ivar(name, class_usr)
  # @param [String] name 
  # @param [String] class_usr 
  # @return [String] 
  # @scope class
  attach_function :construct_usr_obj_c_ivar, :clang_constructUSR_ObjCIvar, [:string, String.by_value], String.by_value
  
  # Construct a USR for a specified Objective-C method and
  #   the USR for its containing class.
  # 
  # @method construct_usr_obj_c_method(name, is_instance_method, class_usr)
  # @param [String] name 
  # @param [Integer] is_instance_method 
  # @param [String] class_usr 
  # @return [String] 
  # @scope class
  attach_function :construct_usr_obj_c_method, :clang_constructUSR_ObjCMethod, [:string, :uint, String.by_value], String.by_value
  
  # Construct a USR for a specified Objective-C property and the USR
  #  for its containing class.
  # 
  # @method construct_usr_obj_c_property(property, class_usr)
  # @param [String] property 
  # @param [String] class_usr 
  # @return [String] 
  # @scope class
  attach_function :construct_usr_obj_c_property, :clang_constructUSR_ObjCProperty, [:string, String.by_value], String.by_value
  
  # Retrieve a name for the entity referenced by this cursor.
  # 
  # @method get_cursor_spelling(cursor)
  # @param [Cursor] cursor 
  # @return [String] 
  # @scope class
  attach_function :get_cursor_spelling, :clang_getCursorSpelling, [Cursor.by_value], String.by_value
  
  # Retrieve the display name for the entity referenced by this cursor.
  # 
  # The display name contains extra information that helps identify the cursor,
  # such as the parameters of a function or template or the arguments of a 
  # class template specialization.
  # 
  # @method get_cursor_display_name(cursor)
  # @param [Cursor] cursor 
  # @return [String] 
  # @scope class
  attach_function :get_cursor_display_name, :clang_getCursorDisplayName, [Cursor.by_value], String.by_value
  
  # For a cursor that is a reference, retrieve a cursor representing the
  # entity that it references.
  # 
  # Reference cursors refer to other entities in the AST. For example, an
  # Objective-C superclass reference cursor refers to an Objective-C class.
  # This function produces the cursor for the Objective-C class from the
  # cursor for the superclass reference. If the input cursor is a declaration or
  # definition, it returns that declaration or definition unchanged.
  # Otherwise, returns the NULL cursor.
  # 
  # @method get_cursor_referenced(cursor)
  # @param [Cursor] cursor 
  # @return [Cursor] 
  # @scope class
  attach_function :get_cursor_referenced, :clang_getCursorReferenced, [Cursor.by_value], Cursor.by_value
  
  # For a cursor that is either a reference to or a declaration
  # of some entity, retrieve a cursor that describes the definition of
  # that entity.
  # 
  # Some entities can be declared multiple times within a translation
  # unit, but only one of those declarations can also be a
  # definition. For example, given:
  # 
  # \code
  # int f(int, int);
  # int g(int x, int y) { return f(x, y); }
  # int f(int a, int b) { return a + b; }
  # int f(int, int);
  # \endcode
  # 
  # there are three declarations of the function "f", but only the
  # second one is a definition. The clang_getCursorDefinition()
  # function will take any cursor pointing to a declaration of "f"
  # (the first or fourth lines of the example) or a cursor referenced
  # that uses "f" (the call to "f' inside "g") and will return a
  # declaration cursor pointing to the definition (the second "f"
  # declaration).
  # 
  # If given a cursor for which there is no corresponding definition,
  # e.g., because there is no definition of that entity within this
  # translation unit, returns a NULL cursor.
  # 
  # @method get_cursor_definition(cursor)
  # @param [Cursor] cursor 
  # @return [Cursor] 
  # @scope class
  attach_function :get_cursor_definition, :clang_getCursorDefinition, [Cursor.by_value], Cursor.by_value
  
  # Determine whether the declaration pointed to by this cursor
  # is also a definition of that entity.
  # 
  # @method is_cursor_definition(cursor)
  # @param [Cursor] cursor 
  # @return [Integer] 
  # @scope class
  attach_function :is_cursor_definition, :clang_isCursorDefinition, [Cursor.by_value], :uint
  
  # Retrieve the canonical cursor corresponding to the given cursor.
  # 
  # In the C family of languages, many kinds of entities can be declared several
  # times within a single translation unit. For example, a structure type can
  # be forward-declared (possibly multiple times) and later defined:
  # 
  # \code
  # struct X;
  # struct X;
  # struct X {
  #   int member;
  # };
  # \endcode
  # 
  # The declarations and the definition of \c X are represented by three 
  # different cursors, all of which are declarations of the same underlying 
  # entity. One of these cursor is considered the "canonical" cursor, which
  # is effectively the representative for the underlying entity. One can 
  # determine if two cursors are declarations of the same underlying entity by
  # comparing their canonical cursors.
  # 
  # @method get_canonical_cursor(cursor)
  # @param [Cursor] cursor 
  # @return [Cursor] The canonical cursor for the entity referred to by the given cursor.
  # @scope class
  attach_function :get_canonical_cursor, :clang_getCanonicalCursor, [Cursor.by_value], Cursor.by_value
  
  # Determine if a C++ member function or member function template is 
  # declared 'static'.
  # 
  # @method cxx_method_is_static(c)
  # @param [Cursor] c 
  # @return [Integer] 
  # @scope class
  attach_function :cxx_method_is_static, :clang_CXXMethod_isStatic, [Cursor.by_value], :uint
  
  # Determine if a C++ member function or member function template is
  # explicitly declared 'virtual' or if it overrides a virtual method from
  # one of the base classes.
  # 
  # @method cxx_method_is_virtual(c)
  # @param [Cursor] c 
  # @return [Integer] 
  # @scope class
  attach_function :cxx_method_is_virtual, :clang_CXXMethod_isVirtual, [Cursor.by_value], :uint
  
  # Given a cursor that represents a template, determine
  # the cursor kind of the specializations would be generated by instantiating
  # the template.
  # 
  # This routine can be used to determine what flavor of function template,
  # class template, or class template partial specialization is stored in the
  # cursor. For example, it can describe whether a class template cursor is
  # declared with "struct", "class" or "union".
  # 
  # @method get_template_cursor_kind(c)
  # @param [Cursor] c The cursor to query. This cursor should represent a template
  #   declaration.
  # @return [Symbol from _enum_cursor_kind_] The cursor kind of the specializations that would be generated
  #   by instantiating the template \p C. If \p C is not a template, returns
  #   \c CXCursor_NoDeclFound.
  # @scope class
  attach_function :get_template_cursor_kind, :clang_getTemplateCursorKind, [Cursor.by_value], :cursor_kind
  
  # Given a cursor that may represent a specialization or instantiation
  # of a template, retrieve the cursor that represents the template that it
  # specializes or from which it was instantiated.
  # 
  # This routine determines the template involved both for explicit 
  # specializations of templates and for implicit instantiations of the template,
  # both of which are referred to as "specializations". For a class template
  # specialization (e.g., \c std::vector<bool>), this routine will return 
  # either the primary template (\c std::vector) or, if the specialization was
  # instantiated from a class template partial specialization, the class template
  # partial specialization. For a class template partial specialization and a
  # function template specialization (including instantiations), this
  # this routine will return the specialized template.
  # 
  # For members of a class template (e.g., member functions, member classes, or
  # static data members), returns the specialized or instantiated member. 
  # Although not strictly "templates" in the C++ language, members of class
  # templates have the same notions of specializations and instantiations that
  # templates do, so this routine treats them similarly.
  # 
  # @method get_specialized_cursor_template(c)
  # @param [Cursor] c A cursor that may be a specialization of a template or a member
  #   of a template.
  # @return [Cursor] If the given cursor is a specialization or instantiation of a 
  #   template or a member thereof, the template or member that it specializes or
  #   from which it was instantiated. Otherwise, returns a NULL cursor.
  # @scope class
  attach_function :get_specialized_cursor_template, :clang_getSpecializedCursorTemplate, [Cursor.by_value], Cursor.by_value
  
  # Given a cursor that references something else, return the source range
  # covering that reference.
  # 
  # @method get_cursor_reference_name_range(c, name_flags, piece_index)
  # @param [Cursor] c A cursor pointing to a member reference, a declaration reference, or
  #   an operator call.
  # @param [Integer] name_flags A bitset with three independent flags: 
  #   CXNameRange_WantQualifier, CXNameRange_WantTemplateArgs, and
  #   CXNameRange_WantSinglePiece.
  # @param [Integer] piece_index For contiguous names or when passing the flag 
  #   CXNameRange_WantSinglePiece, only one piece with index 0 is 
  #   available. When the CXNameRange_WantSinglePiece flag is not passed for a
  #   non-contiguous names, this index can be used to retreive the individual
  #   pieces of the name. See also CXNameRange_WantSinglePiece.
  # @return [SourceRange] The piece of the name pointed to by the given cursor. If there is no
  #   name, or if the PieceIndex is out-of-range, a null-cursor will be returned.
  # @scope class
  attach_function :get_cursor_reference_name_range, :clang_getCursorReferenceNameRange, [Cursor.by_value, :uint, :uint], SourceRange.by_value
  
  # (Not documented)
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:name_ref_flags).</em>
  # 
  # === Options:
  # :range_want_qualifier ::
  #   Include the nested-name-specifier, e.g. Foo:: in x.Foo::y, in the
  #   range.
  # :range_want_template_args ::
  #   Include the explicit template arguments, e.g. <int> in x.f<int>, in 
  #   the range.
  # :range_want_single_piece ::
  #   If the name is non-contiguous, return the full spanning range.
  #   
  #   Non-contiguous names occur in Objective-C when a selector with two or more
  #   parameters is used, or in C++ when using an operator:
  #   \code
  #   (object doSomething:here withValue:there); // ObjC
  #   return some_vector(1); // C++
  #   \endcode
  # 
  # @method _enum_name_ref_flags_
  # @return [Symbol]
  # @scope class
  enum :name_ref_flags, [
    :range_want_qualifier, 1,
    :range_want_template_args, 2,
    :range_want_single_piece, 4
  ]
  
  # Describes a kind of token.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:token_kind).</em>
  # 
  # === Options:
  # :punctuation ::
  #   A token that contains some kind of punctuation.
  # :keyword ::
  #   A language keyword.
  # :identifier ::
  #   An identifier (that is not a keyword).
  # :literal ::
  #   A numeric, string, or character literal.
  # :comment ::
  #   A comment.
  # 
  # @method _enum_token_kind_
  # @return [Symbol]
  # @scope class
  enum :token_kind, [
    :punctuation, 0,
    :keyword, 1,
    :identifier, 2,
    :literal, 3,
    :comment, 4
  ]
  
  # Describes a single preprocessing token.
  # 
  # = Fields:
  # :int_data ::
  #   (Array<Integer>) 
  # :ptr_data ::
  #   (FFI::Pointer(*Void)) 
  class Token < FFI::Struct
    layout :int_data, [:uint, 4],
           :ptr_data, :pointer
  end
  
  # Determine the kind of the given token.
  # 
  # @method get_token_kind(token)
  # @param [Token] token 
  # @return [Symbol from _enum_token_kind_] 
  # @scope class
  attach_function :get_token_kind, :clang_getTokenKind, [Token.by_value], :token_kind
  
  # Determine the spelling of the given token.
  # 
  # 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_impl, token)
  # @param [TranslationUnitImpl] translation_unit_impl 
  # @param [Token] token 
  # @return [String] 
  # @scope class
  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_impl, token)
  # @param [TranslationUnitImpl] translation_unit_impl 
  # @param [Token] token 
  # @return [SourceLocation] 
  # @scope class
  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_impl, token)
  # @param [TranslationUnitImpl] translation_unit_impl 
  # @param [Token] token 
  # @return [SourceRange] 
  # @scope class
  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 [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
  #   that occur within the given source range. The returned pointer must be
  #   freed with clang_disposeTokens() before the translation unit is destroyed.
  # @param [FFI::Pointer(*UInt)] num_tokens will be set to the number of tokens in the \c *Tokens
  #   array.
  # @return [nil] 
  # @scope class
  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.
  # 
  # This token-annotation routine is equivalent to invoking
  # clang_getCursor() for the source locations of each of the
  # tokens. The cursors provided are filtered, so that only those
  # cursors that have a direct correspondence to the token are
  # accepted. For example, given a function call \c f(x),
  # clang_getCursor() would provide the following cursors:
  # 
  #   * when the cursor is over the 'f', a DeclRefExpr cursor referring to 'f'.
  #   * when the cursor is over the '(' or the ')', a CallExpr referring to 'f'.
  #   * when the cursor is over the 'x', a DeclRefExpr cursor referring to 'x'.
  # 
  # Only the first and last of these cursors will occur within the
  # annotate, since the tokens "f" and "x' directly refer to a function
  # and a variable, respectively, but the parentheses are just a small
  # part of the full syntax of the function call expression, which is
  # not provided as an annotation.
  # 
  # @method annotate_tokens(tu, tokens, num_tokens, cursors)
  # @param [TranslationUnitImpl] tu the translation unit that owns the given tokens.
  # @param [Token] tokens the set of tokens to annotate.
  # @param [Integer] num_tokens the number of tokens in \p Tokens.
  # @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, Token, :uint, Cursor], :void
  
  # Free the given set of tokens.
  # 
  # @method dispose_tokens(tu, tokens, num_tokens)
  # @param [TranslationUnitImpl] tu 
  # @param [Token] tokens 
  # @param [Integer] num_tokens 
  # @return [nil] 
  # @scope class
  attach_function :dispose_tokens, :clang_disposeTokens, [TranslationUnitImpl, Token, :uint], :void
  
  # for debug/testing
  # 
  # @method get_cursor_kind_spelling(kind)
  # @param [Symbol from _enum_cursor_kind_] kind 
  # @return [String] 
  # @scope class
  attach_function :get_cursor_kind_spelling, :clang_getCursorKindSpelling, [:cursor_kind], String.by_value
  
  # (Not documented)
  # 
  # @method get_definition_spelling_and_extent(cursor, start_buf, end_buf, start_line, start_column, end_line, end_column)
  # @param [Cursor] cursor 
  # @param [FFI::Pointer(**CharS)] start_buf 
  # @param [FFI::Pointer(**CharS)] end_buf 
  # @param [FFI::Pointer(*UInt)] start_line 
  # @param [FFI::Pointer(*UInt)] start_column 
  # @param [FFI::Pointer(*UInt)] end_line 
  # @param [FFI::Pointer(*UInt)] end_column 
  # @return [nil] 
  # @scope class
  attach_function :get_definition_spelling_and_extent, :clang_getDefinitionSpellingAndExtent, [Cursor.by_value, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :void
  
  # (Not documented)
  # 
  # @method enable_stack_traces()
  # @return [nil] 
  # @scope class
  attach_function :enable_stack_traces, :clang_enableStackTraces, [], :void
  
  # (Not documented)
  # 
  # @method execute_on_thread(fn, user_data, stack_size)
  # @param [FFI::Pointer(*)] fn 
  # @param [FFI::Pointer(*Void)] user_data 
  # @param [Integer] stack_size 
  # @return [nil] 
  # @scope class
  attach_function :execute_on_thread, :clang_executeOnThread, [:pointer, :pointer, :uint], :void
  
  # A single result of code completion.
  # 
  # = Fields:
  # :cursor_kind ::
  #   (Symbol from _enum_cursor_kind_) The kind of entity that this completion refers to.
  #   
  #   The cursor kind will be a macro, keyword, or a declaration (one of the
  #   *Decl cursor kinds), describing the entity that the completion is
  #   referring to.
  #   
  #   \todo In the future, we would like to provide a full cursor, to allow
  #   the client to extract additional information from declaration.
  # :completion_string ::
  #   (FFI::Pointer(CompletionString)) The code-completion string that describes how to insert this
  #   code-completion result into the editing buffer.
  class CompletionResult < FFI::Struct
    layout :cursor_kind, :cursor_kind,
           :completion_string, :pointer
  end
  
  # Describes a single piece of text within a code-completion string.
  # 
  # Each "chunk" within a code-completion string (\c CXCompletionString) is
  # either a piece of text with a specific "kind" that describes how that text
  # should be interpreted by the client or is another completion string.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:completion_chunk_kind).</em>
  # 
  # === Options:
  # :optional ::
  #   A code-completion string that describes "optional" text that
  #   could be a part of the template (but is not required).
  #   
  #   The Optional chunk is the only kind of chunk that has a code-completion
  #   string for its representation, which is accessible via
  #   \c clang_getCompletionChunkCompletionString(). The code-completion string
  #   describes an additional part of the template that is completely optional.
  #   For example, optional chunks can be used to describe the placeholders for
  #   arguments that match up with defaulted function parameters, e.g. given:
  #   
  #   \code
  #   void f(int x, float y = 3.14, double z = 2.71828);
  #   \endcode
  #   
  #   The code-completion string for this function would contain:
  #     - a TypedText chunk for "f".
  #     - a LeftParen chunk for "(".
  #     - a Placeholder chunk for "int x"
  #     - an Optional chunk containing the remaining defaulted arguments, e.g.,
  #         - a Comma chunk for ","
  #         - a Placeholder chunk for "float y"
  #         - an Optional chunk containing the last defaulted argument:
  #             - a Comma chunk for ","
  #             - a Placeholder chunk for "double z"
  #     - a RightParen chunk for ")"
  #   
  #   There are many ways to handle Optional chunks. Two simple approaches are:
  #     - Completely ignore optional chunks, in which case the template for the
  #       function "f" would only include the first parameter ("int x").
  #     - Fully expand all optional chunks, in which case the template for the
  #       function "f" would have all of the parameters.
  # :typed_text ::
  #   Text that a user would be expected to type to get this
  #   code-completion result.
  #   
  #   There will be exactly one "typed text" chunk in a semantic string, which
  #   will typically provide the spelling of a keyword or the name of a
  #   declaration that could be used at the current code point. Clients are
  #   expected to filter the code-completion results based on the text in this
  #   chunk.
  # :text ::
  #   Text that should be inserted as part of a code-completion result.
  #   
  #   A "text" chunk represents text that is part of the template to be
  #   inserted into user code should this particular code-completion result
  #   be selected.
  # :placeholder ::
  #   Placeholder text that should be replaced by the user.
  #   
  #   A "placeholder" chunk marks a place where the user should insert text
  #   into the code-completion template. For example, placeholders might mark
  #   the function parameters for a function declaration, to indicate that the
  #   user should provide arguments for each of those parameters. The actual
  #   text in a placeholder is a suggestion for the text to display before
  #   the user replaces the placeholder with real code.
  # :informative ::
  #   Informative text that should be displayed but never inserted as
  #   part of the template.
  #   
  #   An "informative" chunk contains annotations that can be displayed to
  #   help the user decide whether a particular code-completion result is the
  #   right option, but which is not part of the actual template to be inserted
  #   by code completion.
  # :current_parameter ::
  #   Text that describes the current parameter when code-completion is
  #   referring to function call, message send, or template specialization.
  #   
  #   A "current parameter" chunk occurs when code-completion is providing
  #   information about a parameter corresponding to the argument at the
  #   code-completion point. For example, given a function
  #   
  #   \code
  #   int add(int x, int y);
  #   \endcode
  #   
  #   and the source code \c add(, where the code-completion point is after the
  #   "(", the code-completion string will contain a "current parameter" chunk
  #   for "int x", indicating that the current argument will initialize that
  #   parameter. After typing further, to \c add(17, (where the code-completion
  #   point is after the ","), the code-completion string will contain a
  #   "current paremeter" chunk to "int y".
  # :left_paren ::
  #   A left parenthesis ('('), used to initiate a function call or
  #   signal the beginning of a function parameter list.
  # :right_paren ::
  #   A right parenthesis (')'), used to finish a function call or
  #   signal the end of a function parameter list.
  # :left_bracket ::
  #   A left bracket ('(').
  # :right_bracket ::
  #   A right bracket (')').
  # :left_brace ::
  #   A left brace ('{').
  # :right_brace ::
  #   A right brace ('}').
  # :left_angle ::
  #   A left angle bracket ('<').
  # :right_angle ::
  #   A right angle bracket ('>').
  # :comma ::
  #   A comma separator (',').
  # :result_type ::
  #   Text that specifies the result type of a given result.
  #   
  #   This special kind of informative chunk is not meant to be inserted into
  #   the text buffer. Rather, it is meant to illustrate the type that an
  #   expression using the given completion string would have.
  # :colon ::
  #   A colon (':').
  # :semi_colon ::
  #   A semicolon (';').
  # :equal ::
  #   An '=' sign.
  # :horizontal_space ::
  #   Horizontal space (' ').
  # :vertical_space ::
  #   Vertical space ('\n'), after which it is generally a good idea to
  #   perform indentation.
  # 
  # @method _enum_completion_chunk_kind_
  # @return [Symbol]
  # @scope class
  enum :completion_chunk_kind, [
    :optional, 0,
    :typed_text, 1,
    :text, 2,
    :placeholder, 3,
    :informative, 4,
    :current_parameter, 5,
    :left_paren, 6,
    :right_paren, 7,
    :left_bracket, 8,
    :right_bracket, 9,
    :left_brace, 10,
    :right_brace, 11,
    :left_angle, 12,
    :right_angle, 13,
    :comma, 14,
    :result_type, 15,
    :colon, 16,
    :semi_colon, 17,
    :equal, 18,
    :horizontal_space, 19,
    :vertical_space, 20
  ]
  
  # Determine the kind of a particular chunk within a completion string.
  # 
  # @method get_completion_chunk_kind(completion_string, chunk_number)
  # @param [FFI::Pointer(CompletionString)] completion_string the completion string to query.
  # @param [Integer] chunk_number the 0-based index of the chunk in the completion string.
  # @return [Symbol from _enum_completion_chunk_kind_] the kind of the chunk at the index \c chunk_number.
  # @scope class
  attach_function :get_completion_chunk_kind, :clang_getCompletionChunkKind, [:pointer, :uint], :completion_chunk_kind
  
  # Retrieve the text associated with a particular chunk within a
  # completion string.
  # 
  # @method get_completion_chunk_text(completion_string, chunk_number)
  # @param [FFI::Pointer(CompletionString)] completion_string the completion string to query.
  # @param [Integer] chunk_number the 0-based index of the chunk in the completion string.
  # @return [String] the text associated with the chunk at index \c chunk_number.
  # @scope class
  attach_function :get_completion_chunk_text, :clang_getCompletionChunkText, [:pointer, :uint], String.by_value
  
  # Retrieve the completion string associated with a particular chunk
  # within a completion string.
  # 
  # @method get_completion_chunk_completion_string(completion_string, chunk_number)
  # @param [FFI::Pointer(CompletionString)] completion_string the completion string to query.
  # @param [Integer] chunk_number the 0-based index of the chunk in the completion string.
  # @return [FFI::Pointer(CompletionString)] the completion string associated with the chunk at index
  #   \c chunk_number.
  # @scope class
  attach_function :get_completion_chunk_completion_string, :clang_getCompletionChunkCompletionString, [:pointer, :uint], :pointer
  
  # Retrieve the number of chunks in the given code-completion string.
  # 
  # @method get_num_completion_chunks(completion_string)
  # @param [FFI::Pointer(CompletionString)] completion_string 
  # @return [Integer] 
  # @scope class
  attach_function :get_num_completion_chunks, :clang_getNumCompletionChunks, [:pointer], :uint
  
  # Determine the priority of this code completion.
  # 
  # The priority of a code completion indicates how likely it is that this 
  # particular completion is the completion that the user will select. The
  # priority is selected by various internal heuristics.
  # 
  # @method get_completion_priority(completion_string)
  # @param [FFI::Pointer(CompletionString)] completion_string The completion string to query.
  # @return [Integer] The priority of this completion string. Smaller values indicate
  #   higher-priority (more likely) completions.
  # @scope class
  attach_function :get_completion_priority, :clang_getCompletionPriority, [:pointer], :uint
  
  # Determine the availability of the entity that this code-completion
  # string refers to.
  # 
  # @method get_completion_availability(completion_string)
  # @param [FFI::Pointer(CompletionString)] completion_string The completion string to query.
  # @return [Symbol from _enum_availability_kind_] The availability of the completion string.
  # @scope class
  attach_function :get_completion_availability, :clang_getCompletionAvailability, [:pointer], :availability_kind
  
  # Retrieve the number of annotations associated with the given
  # completion string.
  # 
  # @method get_completion_num_annotations(completion_string)
  # @param [FFI::Pointer(CompletionString)] completion_string the completion string to query.
  # @return [Integer] the number of annotations associated with the given completion
  #   string.
  # @scope class
  attach_function :get_completion_num_annotations, :clang_getCompletionNumAnnotations, [:pointer], :uint
  
  # Retrieve the annotation associated with the given completion string.
  # 
  # @method get_completion_annotation(completion_string, annotation_number)
  # @param [FFI::Pointer(CompletionString)] completion_string the completion string to query.
  # @param [Integer] annotation_number the 0-based index of the annotation of the
  #   completion string.
  # @return [String] annotation string associated with the completion at index
  #   \c annotation_number, or a NULL string if that annotation is not available.
  # @scope class
  attach_function :get_completion_annotation, :clang_getCompletionAnnotation, [:pointer, :uint], String.by_value
  
  # Retrieve a completion string for an arbitrary declaration or macro
  # definition cursor.
  # 
  # @method get_cursor_completion_string(cursor)
  # @param [Cursor] cursor The cursor to query.
  # @return [FFI::Pointer(CompletionString)] A non-context-sensitive completion string for declaration and macro
  #   definition cursors, or NULL for other kinds of cursors.
  # @scope class
  attach_function :get_cursor_completion_string, :clang_getCursorCompletionString, [Cursor.by_value], :pointer
  
  # Contains the results of code-completion.
  # 
  # This data structure contains the results of code completion, as
  # produced by \c clang_codeCompleteAt(). Its contents must be freed by
  # \c clang_disposeCodeCompleteResults.
  # 
  # = Fields:
  # :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, CompletionResult,
           :num_results, :uint
  end
  
  # Flags that can be passed to \c clang_codeCompleteAt() to
  # modify its behavior.
  # 
  # The enumerators in this enumeration can be bitwise-OR'd together to
  # provide multiple options to \c clang_codeCompleteAt().
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:code_complete_flags).</em>
  # 
  # === Options:
  # :include_macros ::
  #   Whether to include macros within the set of code
  #   completions returned.
  # :include_code_patterns ::
  #   Whether to include code patterns for language constructs
  #   within the set of code completions, e.g., for loops.
  # 
  # @method _enum_code_complete_flags_
  # @return [Symbol]
  # @scope class
  enum :code_complete_flags, [
    :include_macros, 1,
    :include_code_patterns, 2
  ]
  
  # Bits that represent the context under which completion is occurring.
  # 
  # The enumerators in this enumeration may be bitwise-OR'd together if multiple
  # contexts are occurring simultaneously.
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:completion_context).</em>
  # 
  # === Options:
  # :unexposed ::
  #   The context for completions is unexposed, as only Clang results
  #   should be included. (This is equivalent to having no context bits set.)
  # :any_type ::
  #   Completions for any possible type should be included in the results.
  # :any_value ::
  #   Completions for any possible value (variables, function calls, etc.)
  #   should be included in the results.
  # :obj_c_object_value ::
  #   Completions for values that resolve to an Objective-C object should
  #   be included in the results.
  # :obj_c_selector_value ::
  #   Completions for values that resolve to an Objective-C selector
  #   should be included in the results.
  # :cxx_class_type_value ::
  #   Completions for values that resolve to a C++ class type should be
  #   included in the results.
  # :dot_member_access ::
  #   Completions for fields of the member being accessed using the dot
  #   operator should be included in the results.
  # :arrow_member_access ::
  #   Completions for fields of the member being accessed using the arrow
  #   operator should be included in the results.
  # :obj_c_property_access ::
  #   Completions for properties of the Objective-C object being accessed
  #   using the dot operator should be included in the results.
  # :enum_tag ::
  #   Completions for enum tags should be included in the results.
  # :union_tag ::
  #   Completions for union tags should be included in the results.
  # :struct_tag ::
  #   Completions for struct tags should be included in the results.
  # :class_tag ::
  #   Completions for C++ class names should be included in the results.
  # :namespace ::
  #   Completions for C++ namespaces and namespace aliases should be
  #   included in the results.
  # :nested_name_specifier ::
  #   Completions for C++ nested name specifiers should be included in
  #   the results.
  # :obj_c_interface ::
  #   Completions for Objective-C interfaces (classes) should be included
  #   in the results.
  # :obj_c_protocol ::
  #   Completions for Objective-C protocols should be included in
  #   the results.
  # :obj_c_category ::
  #   Completions for Objective-C categories should be included in
  #   the results.
  # :obj_c_instance_message ::
  #   Completions for Objective-C instance messages should be included
  #   in the results.
  # :obj_c_class_message ::
  #   Completions for Objective-C class messages should be included in
  #   the results.
  # :obj_c_selector_name ::
  #   Completions for Objective-C selector names should be included in
  #   the results.
  # :macro_name ::
  #   Completions for preprocessor macro names should be included in
  #   the results.
  # :natural_language ::
  #   Natural language completions should be included in the results.
  # :unknown ::
  #   The current context is unknown, so set all contexts.
  # 
  # @method _enum_completion_context_
  # @return [Symbol]
  # @scope class
  enum :completion_context, [
    :unexposed, 0,
    :any_type, 1,
    :any_value, 2,
    :obj_c_object_value, 4,
    :obj_c_selector_value, 8,
    :cxx_class_type_value, 16,
    :dot_member_access, 32,
    :arrow_member_access, 64,
    :obj_c_property_access, 128,
    :enum_tag, 256,
    :union_tag, 512,
    :struct_tag, 1024,
    :class_tag, 2048,
    :namespace, 4096,
    :nested_name_specifier, 8192,
    :obj_c_interface, 16384,
    :obj_c_protocol, 32768,
    :obj_c_category, 65536,
    :obj_c_instance_message, 131072,
    :obj_c_class_message, 262144,
    :obj_c_selector_name, 524288,
    :macro_name, 1048576,
    :natural_language, 2097152,
    :unknown, 4194303
  ]
  
  # Returns a default set of code-completion options that can be
  # passed to\c clang_codeCompleteAt(). 
  # 
  # @method default_code_complete_options()
  # @return [Integer] 
  # @scope class
  attach_function :default_code_complete_options, :clang_defaultCodeCompleteOptions, [], :uint
  
  # Perform code completion at a given location in a translation unit.
  # 
  # This function performs code completion at a particular file, line, and
  # column within source code, providing results that suggest potential
  # code snippets based on the context of the completion. The basic model
  # for code completion is that Clang will parse a complete source file,
  # performing syntax checking up to the location where code-completion has
  # been requested. At that point, a special code-completion token is passed
  # to the parser, which recognizes this token and determines, based on the
  # current location in the C/Objective-C/C++ grammar and the state of
  # semantic analysis, what completions to provide. These completions are
  # returned via a new \c CXCodeCompleteResults structure.
  # 
  # Code completion itself is meant to be triggered by the client when the
  # user types punctuation characters or whitespace, at which point the
  # code-completion location will coincide with the cursor. For example, if \c p
  # is a pointer, code-completion might be triggered after the "-" and then
  # after the ">" in \c p->. When the code-completion location is afer the ">",
  # the completion results will provide, e.g., the members of the struct that
  # "p" points to. The client is responsible for placing the cursor at the
  # beginning of the token currently being typed, then filtering the results
  # based on the contents of the token. For example, when code-completing for
  # the expression \c p->get, the client should provide the location just after
  # the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the
  # client can filter the results based on the current token text ("get"), only
  # showing those results that start with "get". The intent of this interface
  # is to separate the relatively high-latency acquisition of code-completion
  # results from the filtering of results on a per-character basis, which must
  # have a lower latency.
  # 
  # @method code_complete_at(tu, complete_filename, complete_line, complete_column, unsaved_files, num_unsaved_files, options)
  # @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
  #   translation unit may be invalidated by this invocation.
  # @param [String] complete_filename The name of the source file where code
  #   completion should be performed. This filename may be any file
  #   included in the translation unit.
  # @param [Integer] complete_line The line at which code-completion should occur.
  # @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 [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
  #   client only needs to guarantee their validity until the call to
  #   this function returns.
  # @param [Integer] num_unsaved_files The number of unsaved file entries in \p
  #   unsaved_files.
  # @param [Integer] options Extra options that control the behavior of code
  #   completion, expressed as a bitwise OR of the enumerators of the
  #   CXCodeComplete_Flags enumeration. The 
  #   \c clang_defaultCodeCompleteOptions() function returns a default set
  #   of code-completion options.
  # @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], CodeCompleteResults
  
  # Sort the code-completion results in case-insensitive alphabetical 
  # order.
  # 
  # @method sort_code_completion_results(results, num_results)
  # @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, [CompletionResult, :uint], :void
  
  # Free the given set of code-completion results.
  # 
  # @method dispose_code_complete_results(results)
  # @param [CodeCompleteResults] results 
  # @return [nil] 
  # @scope class
  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 [CodeCompleteResults] results 
  # @return [Integer] 
  # @scope class
  attach_function :code_complete_get_num_diagnostics, :clang_codeCompleteGetNumDiagnostics, [CodeCompleteResults], :uint
  
  # Retrieve a diagnostic associated with the given code completion.
  # 
  # @method code_complete_get_diagnostic(results, index)
  # @param [CodeCompleteResults] results the code completion results 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 :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 [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, [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
  # contexts where a container exists (i.e. member accesses or Objective-C
  # message sends); if there is not a container, this function will return
  # CXCursor_InvalidCode.
  # 
  # @method code_complete_get_container_kind(results, is_incomplete)
  # @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, [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 [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, [CodeCompleteResults], String.by_value
  
  # Returns the currently-entered selector for an Objective-C message
  # send, formatted like "initWithFoo:bar:". Only guaranteed to return a
  # non-empty string for CXCompletionContext_ObjCInstanceMessage and
  # CXCompletionContext_ObjCClassMessage.
  # 
  # @method code_complete_get_obj_c_selector(results)
  # @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, [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).
  # 
  # @method get_clang_version()
  # @return [String] 
  # @scope class
  attach_function :get_clang_version, :clang_getClangVersion, [], String.by_value
  
  # Enable/disable crash recovery.
  # 
  # @method toggle_crash_recovery(is_enabled)
  # @param [Integer] is_enabled to indicate if crash recovery is enabled.  A non-zero value
  #          enables crash recovery, while 0 disables it.
  # @return [nil] 
  # @scope class
  attach_function :toggle_crash_recovery, :clang_toggleCrashRecovery, [:uint], :void
  
  # Visitor invoked for each file in a translation unit
  #        (used with clang_getInclusions()).
  # 
  # This visitor function will be invoked by clang_getInclusions() for each
  # file included (either at the top-level or by #include directives) within
  # a translation unit.  The first argument is the file being included, and
  # the second and third arguments provide the inclusion stack.  The
  # array is sorted in order of immediate inclusion.  For example,
  # the first element refers to the location that included 'included_file'.
  # 
  # <em>This entry is only for documentation and no real method.</em>
  # 
  # @method _callback_inclusion_visitor_(inclusion_stack, include_len, client_data)
  # @param [SourceLocation] inclusion_stack 
  # @param [Integer] include_len 
  # @param [FFI::Pointer(ClientData)] client_data 
  # @return [FFI::Pointer(File)] 
  # @scope class
  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
  #   file.  This does not include headers included by the PCH file (unless one
  #   is inspecting the inclusions in the PCH file itself).
  # 
  # @method get_inclusions(tu, visitor, client_data)
  # @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, [TranslationUnitImpl, :inclusion_visitor, :pointer], :void
  
  # Retrieve a remapping.
  # 
  # @method get_remappings(path)
  # @param [String] path the path that contains metadata about remappings.
  # @return [FFI::Pointer(Remapping)] the requested remapping. This remapping must be freed
  #   via a call to \c clang_remap_dispose(). Can return NULL if an error occurred.
  # @scope class
  attach_function :get_remappings, :clang_getRemappings, [:string], :pointer
  
  # Determine the number of remappings.
  # 
  # @method remap_get_num_files(remapping)
  # @param [FFI::Pointer(Remapping)] remapping 
  # @return [Integer] 
  # @scope class
  attach_function :remap_get_num_files, :clang_remap_getNumFiles, [:pointer], :uint
  
  # Get the original and the associated filename from the remapping.
  # 
  # @method remap_get_filenames(remapping, index, original, transformed)
  # @param [FFI::Pointer(Remapping)] remapping 
  # @param [Integer] index 
  # @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, String, String], :void
  
  # Dispose the remapping.
  # 
  # @method remap_dispose(remapping)
  # @param [FFI::Pointer(Remapping)] remapping 
  # @return [nil] 
  # @scope class
  attach_function :remap_dispose, :clang_remap_dispose, [:pointer], :void
  
  # \defgroup CINDEX_HIGH Higher level API functions
  # 
  # @{
  # 
  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:visitor_result).</em>
  # 
  # === Options:
  # :visit_break ::
  #   
  # :visit_continue ::
  #   
  # 
  # @method _enum_visitor_result_
  # @return [Symbol]
  # @scope class
  enum :visitor_result, [
    :visit_break, 0,
    :visit_continue, 1
  ]
  
  # (Not documented)
  # 
  # = Fields:
  # :context ::
  #   (FFI::Pointer(*Void)) 
  # :visit ::
  #   (FFI::Pointer(*)) 
  class CursorAndRangeVisitor < FFI::Struct
    layout :context, :pointer,
           :visit, :pointer
  end
  
  # Find references of a declaration in a specific file.
  # 
  # @method find_references_in_file(cursor, file, visitor)
  # @param [Cursor] cursor pointing to a declaration or a reference of one.
  # @param [FFI::Pointer(File)] file to search for references.
  # @param [CursorAndRangeVisitor] visitor callback that will receive pairs of CXCursor/CXSourceRange for
  #   each reference found.
  #   The CXSourceRange will point inside the file; if the reference is inside
  #   a macro (and not a macro argument) the CXSourceRange will be invalid.
  # @return [nil] 
  # @scope class
  attach_function :find_references_in_file, :clang_findReferencesInFile, [Cursor.by_value, :pointer, CursorAndRangeVisitor.by_value], :void
  
end