0001 // this file is generated by `create_swift_from_generated_interface.py` 0002 #if SWIFT_PACKAGE 0003 import Clang_C 0004 #endif 0005 private let library= toolchainLoader.load("libclang.dylib") 0006 // swiftlint:disable file_length 0007 // swiftlint:disable force_unwrapping 0008 // swiftlint:disable function_parameter_count 0009 // swiftlint:disable missing_docs 0010 // swiftlint:disable trailing_newline 0011 // swiftlint:disable variable_name 0012 // swiftlint:disable valid_docs 0013 // import Darwin 0014 // import Foundation 0015 // import SWXMLHash 0016 // import SourceKittenFramework 0017 0018 /*===-- clang-c/Index.h - Indexing Public C Interface -------------*- C -*-===*\ 0019 |* *| 0020 |* The LLVM Compiler Infrastructure *| 0021 |* *| 0022 |* This file is distributed under the University of Illinois Open Source *| 0023 |* License. See LICENSE.TXT for details. *| 0024 |* *| 0025 |*===----------------------------------------------------------------------===*| 0026 |* *| 0027 |* This header provides a public inferface to a Clang library for extracting *| 0028 |* high-level symbol information from source files without exposing the full *| 0029 |* Clang C++ API. *| 0030 |* *| 0031 \*===----------------------------------------------------------------------===*/ 0032 0033 /** 0034 * \brief The version constants for the libclang API. 0035 * CINDEX_VERSION_MINOR should increase when there are API additions. 0036 * CINDEX_VERSION_MAJOR is intended for "major" source/ABI breaking changes. 0037 * 0038 * The policy about the libclang API was always to keep it source and ABI 0039 * compatible, thus CINDEX_VERSION_MAJOR is expected to remain stable. 0040 */ 0041 // public var CINDEX_VERSION_MAJOR: Int32 { get } 0042 // public var CINDEX_VERSION_MINOR: Int32 { get } 0043 0044 /** \defgroup CINDEX libclang: C Interface to Clang 0045 * 0046 * The C Interface to Clang provides a relatively small API that exposes 0047 * facilities for parsing source code into an abstract syntax tree (AST), 0048 * loading already-parsed ASTs, traversing the AST, associating 0049 * physical source locations with elements within the AST, and other 0050 * facilities that support Clang-based development tools. 0051 * 0052 * This C interface to Clang will never provide all of the information 0053 * representation stored in Clang's C++ AST, nor should it: the intent is to 0054 * maintain an API that is relatively stable from one release to the next, 0055 * providing only the basic functionality needed to support development tools. 0056 * 0057 * To avoid namespace pollution, data types are prefixed with "CX" and 0058 * functions are prefixed with "clang_". 0059 * 0060 * @{ 0061 */ 0062 0063 /** 0064 * \brief An "index" that consists of a set of translation units that would 0065 * typically be linked together into an executable or library. 0066 */ 0067 // public typealias CXIndex = UnsafeMutablePointer<Void> 0068 0069 /** 0070 * \brief A single translation unit, which resides in an index. 0071 */ 0072 // public typealias CXTranslationUnit = COpaquePointer 0073 0074 /** 0075 * \brief Opaque pointer representing client data that will be passed through 0076 * to various callbacks and visitors. 0077 */ 0078 // public typealias CXClientData = UnsafeMutablePointer<Void> 0079 0080 /** 0081 * \brief Provides the contents of a file that has not yet been saved to disk. 0082 * 0083 * Each CXUnsavedFile instance provides the name of a file on the 0084 * system along with the current contents of that file that have not 0085 * yet been saved to disk. 0086 */ 0087 /* 0088 public struct CXUnsavedFile { 0089 /** 0090 * \brief The file whose contents have not yet been saved. 0091 * 0092 * This file must already exist in the file system. 0093 */ 0094 // public var Filename: UnsafePointer<Int8> 0095 0096 /** 0097 * \brief A buffer containing the unsaved contents of this file. 0098 */ 0099 // public var Contents: UnsafePointer<Int8> 0100 0101 /** 0102 * \brief The length of the unsaved contents of this buffer. 0103 */ 0104 // public var Length: UInt 0105 public init() 0106 public init(Filename: UnsafePointer<Int8>, Contents: UnsafePointer<Int8>, Length: UInt) 0107 } 0108 */ 0109 0110 /** 0111 * \brief Describes the availability of a particular entity, which indicates 0112 * whether the use of this entity will result in a warning or error due to 0113 * it being deprecated or unavailable. 0114 */ 0115 /* 0116 public struct CXAvailabilityKind : RawRepresentable, Equatable { 0117 public init(_ rawValue: UInt32) 0118 public init(rawValue: UInt32) 0119 // public var rawValue: UInt32 0120 } 0121 */ 0122 0123 /** 0124 * \brief The entity is available. 0125 */ 0126 // public var CXAvailability_Available: CXAvailabilityKind { get } 0127 /** 0128 * \brief The entity is available, but has been deprecated (and its use is 0129 * not recommended). 0130 */ 0131 // public var CXAvailability_Deprecated: CXAvailabilityKind { get } 0132 /** 0133 * \brief The entity is not available; any use of it will be an error. 0134 */ 0135 // public var CXAvailability_NotAvailable: CXAvailabilityKind { get } 0136 /** 0137 * \brief The entity is available, but not accessible; any use of it will be 0138 * an error. 0139 */ 0140 // public var CXAvailability_NotAccessible: CXAvailabilityKind { get } 0141 0142 /** 0143 * \brief Describes a version number of the form major.minor.subminor. 0144 */ 0145 /* 0146 public struct CXVersion { 0147 /** 0148 * \brief The major version number, e.g., the '10' in '10.7.3'. A negative 0149 * value indicates that there is no version number at all. 0150 */ 0151 // public var Major: Int32 0152 /** 0153 * \brief The minor version number, e.g., the '7' in '10.7.3'. This value 0154 * will be negative if no minor version number was provided, e.g., for 0155 * version '10'. 0156 */ 0157 // public var Minor: Int32 0158 /** 0159 * \brief The subminor version number, e.g., the '3' in '10.7.3'. This value 0160 * will be negative if no minor or subminor version number was provided, 0161 * e.g., in version '10' or '10.7'. 0162 */ 0163 // public var Subminor: Int32 0164 public init() 0165 public init(Major: Int32, Minor: Int32, Subminor: Int32) 0166 } 0167 */ 0168 0169 /** 0170 * \brief Provides a shared context for creating translation units. 0171 * 0172 * It provides two options: 0173 * 0174 * - excludeDeclarationsFromPCH: When non-zero, allows enumeration of "local" 0175 * declarations (when loading any new translation units). A "local" declaration 0176 * is one that belongs in the translation unit itself and not in a precompiled 0177 * header that was used by the translation unit. If zero, all declarations 0178 * will be enumerated. 0179 * 0180 * Here is an example: 0181 * 0182 * \code 0183 * // excludeDeclsFromPCH = 1, displayDiagnostics=1 0184 * Idx = clang_createIndex(1, 1); 0185 * 0186 * // IndexTest.pch was produced with the following command: 0187 * // "clang -x c IndexTest.h -emit-ast -o IndexTest.pch" 0188 * TU = clang_createTranslationUnit(Idx, "IndexTest.pch"); 0189 * 0190 * // This will load all the symbols from 'IndexTest.pch' 0191 * clang_visitChildren(clang_getTranslationUnitCursor(TU), 0192 * TranslationUnitVisitor, 0); 0193 * clang_disposeTranslationUnit(TU); 0194 * 0195 * // This will load all the symbols from 'IndexTest.c', excluding symbols 0196 * // from 'IndexTest.pch'. 0197 * char *args[] = { "-Xclang", "-include-pch=IndexTest.pch" }; 0198 * TU = clang_createTranslationUnitFromSourceFile(Idx, "IndexTest.c", 2, args, 0199 * 0, 0); 0200 * clang_visitChildren(clang_getTranslationUnitCursor(TU), 0201 * TranslationUnitVisitor, 0); 0202 * clang_disposeTranslationUnit(TU); 0203 * \endcode 0204 * 0205 * This process of creating the 'pch', loading it separately, and using it (via 0206 * -include-pch) allows 'excludeDeclsFromPCH' to remove redundant callbacks 0207 * (which gives the indexer the same performance benefit as the compiler). 0208 */ 0209 public func clang_createIndex
created_Index.swift:212 private let _clang_createIndex: @convention(c) (excludeDeclarationsFromPCH: Int32, displayDiagnostics: Int32) -> CXIndex = library.loadSymbol("clang_createIndex")created_Index.swift:224 private let _clang_disposeIndex: @convention(c) (index: CXIndex) -> () = library.loadSymbol("clang_disposeIndex")created_Index.swift:280 private let _clang_CXIndex_setGlobalOptions: @convention(c) (_: CXIndex, options: UInt32) -> () = library.loadSymbol("clang_CXIndex_setGlobalOptions")created_Index.swift:292 private let _clang_CXIndex_getGlobalOptions: @convention(c) (_: CXIndex) -> UInt32 = library.loadSymbol("clang_CXIndex_getGlobalOptions")created_Index.swift:312 private let _clang_getFileName: @convention(c) (SFile: CXFile) -> CXString = library.loadSymbol("clang_getFileName")created_Index.swift:321 private let _clang_getFileTime: @convention(c) (SFile: CXFile) -> time_t = library.loadSymbol("clang_getFileTime")created_Index.swift:347 private let _clang_getFileUniqueID: @convention(c) (file: CXFile, outID: UnsafeMutablePointer<CXFileUniqueID>) -> Int32 = library.loadSymbol("clang_getFileUniqueID")created_Index.swift:358 private let _clang_isFileMultipleIncludeGuarded: @convention(c) (tu: CXTranslationUnit, file: CXFile) -> UInt32 = library.loadSymbol("clang_isFileMultipleIncludeGuarded")created_Index.swift:374 private let _clang_getFile: @convention(c) (tu: CXTranslationUnit, file_name: UnsafePointer<Int8>) -> CXFile = library.loadSymbol("clang_getFile")created_Index.swift:384 private let _clang_File_isEqual: @convention(c) (file1: CXFile, file2: CXFile) -> Int32 = library.loadSymbol("clang_File_isEqual")created_Index.swift:442 private let _clang_getNullLocation: @convention(c) () -> CXSourceLocation = library.loadSymbol("clang_getNullLocation")created_Index.swift:456 private let _clang_equalLocations: @convention(c) (loc1: CXSourceLocation, loc2: CXSourceLocation) -> UInt32 = library.loadSymbol("clang_equalLocations")created_Index.swift:466 private let _clang_getLocation: @convention(c) (tu: CXTranslationUnit, file: CXFile, line: UInt32, column: UInt32) -> CXSourceLocation = library.loadSymbol("clang_getLocation")created_Index.swift:475 private let _clang_getLocationForOffset: @convention(c) (tu: CXTranslationUnit, file: CXFile, offset: UInt32) -> CXSourceLocation = library.loadSymbol("clang_getLocationForOffset")created_Index.swift:484 private let _clang_Location_isInSystemHeader: @convention(c) (location: CXSourceLocation) -> Int32 = library.loadSymbol("clang_Location_isInSystemHeader")created_Index.swift:494 private let _clang_Location_isFromMainFile: @convention(c) (location: CXSourceLocation) -> Int32 = library.loadSymbol("clang_Location_isFromMainFile")created_Index.swift:503 private let _clang_getNullRange: @convention(c) () -> CXSourceRange = library.loadSymbol("clang_getNullRange")created_Index.swift:513 private let _clang_getRange: @convention(c) (begin: CXSourceLocation, end: CXSourceLocation) -> CXSourceRange = library.loadSymbol("clang_getRange")created_Index.swift:524 private let _clang_equalRanges: @convention(c) (range1: CXSourceRange, range2: CXSourceRange) -> UInt32 = library.loadSymbol("clang_equalRanges")created_Index.swift:533 private let _clang_Range_isNull: @convention(c) (range: CXSourceRange) -> Int32 = library.loadSymbol("clang_Range_isNull")created_Index.swift:561 private let _clang_getExpansionLocation: @convention(c) (location: CXSourceLocation, file: UnsafeMutablePointer<CXFile>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>, offset: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getExpansionLocation")created_Index.swift:607 private let _clang_getPresumedLocation: @convention(c) (location: CXSourceLocation, filename: UnsafeMutablePointer<CXString>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getPresumedLocation")created_Index.swift:621 private let _clang_getInstantiationLocation: @convention(c) (location: CXSourceLocation, file: UnsafeMutablePointer<CXFile>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>, offset: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getInstantiationLocation")created_Index.swift:649 private let _clang_getSpellingLocation: @convention(c) (location: CXSourceLocation, file: UnsafeMutablePointer<CXFile>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>, offset: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getSpellingLocation")created_Index.swift:678 private let _clang_getFileLocation: @convention(c) (location: CXSourceLocation, file: UnsafeMutablePointer<CXFile>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>, offset: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getFileLocation")created_Index.swift:688 private let _clang_getRangeStart: @convention(c) (range: CXSourceRange) -> CXSourceLocation = library.loadSymbol("clang_getRangeStart")created_Index.swift:698 private let _clang_getRangeEnd: @convention(c) (range: CXSourceRange) -> CXSourceLocation = library.loadSymbol("clang_getRangeEnd")created_Index.swift:726 private let _clang_getSkippedRanges: @convention(c) (tu: CXTranslationUnit, file: CXFile) -> UnsafeMutablePointer<CXSourceRangeList> = library.loadSymbol("clang_getSkippedRanges")created_Index.swift:735 private let _clang_disposeSourceRangeList: @convention(c) (ranges: UnsafeMutablePointer<CXSourceRangeList>) -> () = library.loadSymbol("clang_disposeSourceRangeList")created_Index.swift:806 private let _clang_getNumDiagnosticsInSet: @convention(c) (Diags: CXDiagnosticSet) -> UInt32 = library.loadSymbol("clang_getNumDiagnosticsInSet")created_Index.swift:821 private let _clang_getDiagnosticInSet: @convention(c) (Diags: CXDiagnosticSet, Index: UInt32) -> CXDiagnostic = library.loadSymbol("clang_getDiagnosticInSet")created_Index.swift:875 private let _clang_loadDiagnostics: @convention(c) (file: UnsafePointer<Int8>, error: UnsafeMutablePointer<CXLoadDiag_Error>, errorString: UnsafeMutablePointer<CXString>) -> CXDiagnosticSet = library.loadSymbol("clang_loadDiagnostics")created_Index.swift:884 private let _clang_disposeDiagnosticSet: @convention(c) (Diags: CXDiagnosticSet) -> () = library.loadSymbol("clang_disposeDiagnosticSet")created_Index.swift:896 private let _clang_getChildDiagnostics: @convention(c) (D: CXDiagnostic) -> CXDiagnosticSet = library.loadSymbol("clang_getChildDiagnostics")created_Index.swift:906 private let _clang_getNumDiagnostics: @convention(c) (Unit: CXTranslationUnit) -> UInt32 = library.loadSymbol("clang_getNumDiagnostics")created_Index.swift:921 private let _clang_getDiagnostic: @convention(c) (Unit: CXTranslationUnit, Index: UInt32) -> CXDiagnostic = library.loadSymbol("clang_getDiagnostic")created_Index.swift:933 private let _clang_getDiagnosticSetFromTU: @convention(c) (Unit: CXTranslationUnit) -> CXDiagnosticSet = library.loadSymbol("clang_getDiagnosticSetFromTU")created_Index.swift:942 private let _clang_disposeDiagnostic: @convention(c) (Diagnostic: CXDiagnostic) -> () = library.loadSymbol("clang_disposeDiagnostic")created_Index.swift:1037 private let _clang_formatDiagnostic: @convention(c) (Diagnostic: CXDiagnostic, Options: UInt32) -> CXString = library.loadSymbol("clang_formatDiagnostic")created_Index.swift:1050 private let _clang_defaultDiagnosticDisplayOptions: @convention(c) () -> UInt32 = library.loadSymbol("clang_defaultDiagnosticDisplayOptions")created_Index.swift:1059 private let _clang_getDiagnosticSeverity: @convention(c) (_: CXDiagnostic) -> CXDiagnosticSeverity = library.loadSymbol("clang_getDiagnosticSeverity")created_Index.swift:1071 private let _clang_getDiagnosticLocation: @convention(c) (_: CXDiagnostic) -> CXSourceLocation = library.loadSymbol("clang_getDiagnosticLocation")created_Index.swift:1080 private let _clang_getDiagnosticSpelling: @convention(c) (_: CXDiagnostic) -> CXString = library.loadSymbol("clang_getDiagnosticSpelling")created_Index.swift:1098 private let _clang_getDiagnosticOption: @convention(c) (Diag: CXDiagnostic, Disable: UnsafeMutablePointer<CXString>) -> CXString = library.loadSymbol("clang_getDiagnosticOption")created_Index.swift:1114 private let _clang_getDiagnosticCategory: @convention(c) (_: CXDiagnostic) -> UInt32 = library.loadSymbol("clang_getDiagnosticCategory")created_Index.swift:1131 private let _clang_getDiagnosticCategoryName: @convention(c) (Category: UInt32) -> CXString = library.loadSymbol("clang_getDiagnosticCategoryName")created_Index.swift:1142 private let _clang_getDiagnosticCategoryText: @convention(c) (_: CXDiagnostic) -> CXString = library.loadSymbol("clang_getDiagnosticCategoryText")created_Index.swift:1152 private let _clang_getDiagnosticNumRanges: @convention(c) (_: CXDiagnostic) -> UInt32 = library.loadSymbol("clang_getDiagnosticNumRanges")created_Index.swift:1171 private let _clang_getDiagnosticRange: @convention(c) (Diagnostic: CXDiagnostic, Range: UInt32) -> CXSourceRange = library.loadSymbol("clang_getDiagnosticRange")created_Index.swift:1181 private let _clang_getDiagnosticNumFixIts: @convention(c) (Diagnostic: CXDiagnostic) -> UInt32 = library.loadSymbol("clang_getDiagnosticNumFixIts")created_Index.swift:1212 private let _clang_getDiagnosticFixIt: @convention(c) (Diagnostic: CXDiagnostic, FixIt: UInt32, ReplacementRange: UnsafeMutablePointer<CXSourceRange>) -> CXString = library.loadSymbol("clang_getDiagnosticFixIt")created_Index.swift:1235 private let _clang_getTranslationUnitSpelling: @convention(c) (CTUnit: CXTranslationUnit) -> CXString = library.loadSymbol("clang_getTranslationUnitSpelling")created_Index.swift:1281 private let _clang_createTranslationUnitFromSourceFile: @convention(c) (CIdx: CXIndex, source_filename: UnsafePointer<Int8>, num_clang_command_line_args: Int32, clang_command_line_args: UnsafePointer<UnsafePointer<Int8>>, num_unsaved_files: UInt32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>) -> CXTranslationUnit = library.loadSymbol("clang_createTranslationUnitFromSourceFile")created_Index.swift:1293 private let _clang_createTranslationUnit: @convention(c) (CIdx: CXIndex, ast_filename: UnsafePointer<Int8>) -> CXTranslationUnit = library.loadSymbol("clang_createTranslationUnit")created_Index.swift:1307 private let _clang_createTranslationUnit2: @convention(c) (CIdx: CXIndex, ast_filename: UnsafePointer<Int8>, out_TU: UnsafeMutablePointer<CXTranslationUnit>) -> CXErrorCode = library.loadSymbol("clang_createTranslationUnit2")created_Index.swift:1430 private let _clang_defaultEditingTranslationUnitOptions: @convention(c) () -> UInt32 = library.loadSymbol("clang_defaultEditingTranslationUnitOptions")created_Index.swift:1442 private let _clang_parseTranslationUnit: @convention(c) (CIdx: CXIndex, source_filename: UnsafePointer<Int8>, command_line_args: UnsafePointer<UnsafePointer<Int8>>, num_command_line_args: Int32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, num_unsaved_files: UInt32, options: UInt32) -> CXTranslationUnit = library.loadSymbol("clang_parseTranslationUnit")created_Index.swift:1492 private let _clang_parseTranslationUnit2: @convention(c) (CIdx: CXIndex, source_filename: UnsafePointer<Int8>, command_line_args: UnsafePointer<UnsafePointer<Int8>>, num_command_line_args: Int32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, num_unsaved_files: UInt32, options: UInt32, out_TU: UnsafeMutablePointer<CXTranslationUnit>) -> CXErrorCode = library.loadSymbol("clang_parseTranslationUnit2")created_Index.swift:1527 private let _clang_defaultSaveOptions: @convention(c) (TU: CXTranslationUnit) -> UInt32 = library.loadSymbol("clang_defaultSaveOptions")created_Index.swift:1597 private let _clang_saveTranslationUnit: @convention(c) (TU: CXTranslationUnit, FileName: UnsafePointer<Int8>, options: UInt32) -> Int32 = library.loadSymbol("clang_saveTranslationUnit")created_Index.swift:1606 private let _clang_disposeTranslationUnit: @convention(c) (_: CXTranslationUnit) -> () = library.loadSymbol("clang_disposeTranslationUnit")created_Index.swift:1642 private let _clang_defaultReparseOptions: @convention(c) (TU: CXTranslationUnit) -> UInt32 = library.loadSymbol("clang_defaultReparseOptions")created_Index.swift:1687 private let _clang_reparseTranslationUnit: @convention(c) (TU: CXTranslationUnit, num_unsaved_files: UInt32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, options: UInt32) -> Int32 = library.loadSymbol("clang_reparseTranslationUnit")created_Index.swift:1727 private let _clang_getTUResourceUsageName: @convention(c) (kind: CXTUResourceUsageKind) -> UnsafePointer<Int8> = library.loadSymbol("clang_getTUResourceUsageName")created_Index.swift:1768 private let _clang_getCXTUResourceUsage: @convention(c) (TU: CXTranslationUnit) -> CXTUResourceUsage = library.loadSymbol("clang_getCXTUResourceUsage")created_Index.swift:1774 private let _clang_disposeCXTUResourceUsage: @convention(c) (usage: CXTUResourceUsage) -> () = library.loadSymbol("clang_disposeCXTUResourceUsage")created_Index.swift:2788 private let _clang_getNullCursor: @convention(c) () -> CXCursor = library.loadSymbol("clang_getNullCursor")created_Index.swift:2800 private let _clang_getTranslationUnitCursor: @convention(c) (_: CXTranslationUnit) -> CXCursor = library.loadSymbol("clang_getTranslationUnitCursor")created_Index.swift:2809 private let _clang_equalCursors: @convention(c) (_: CXCursor, _: CXCursor) -> UInt32 = library.loadSymbol("clang_equalCursors")created_Index.swift:2818 private let _clang_Cursor_isNull: @convention(c) (cursor: CXCursor) -> Int32 = library.loadSymbol("clang_Cursor_isNull")created_Index.swift:2827 private let _clang_hashCursor: @convention(c) (_: CXCursor) -> UInt32 = library.loadSymbol("clang_hashCursor")created_Index.swift:2836 private let _clang_getCursorKind: @convention(c) (_: CXCursor) -> CXCursorKind = library.loadSymbol("clang_getCursorKind")created_Index.swift:2845 private let _clang_isDeclaration: @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isDeclaration")created_Index.swift:2859 private let _clang_isReference: @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isReference")created_Index.swift:2868 private let _clang_isExpression: @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isExpression")created_Index.swift:2877 private let _clang_isStatement: @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isStatement")created_Index.swift:2886 private let _clang_isAttribute: @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isAttribute")created_Index.swift:2896 private let _clang_isInvalid: @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isInvalid")created_Index.swift:2906 private let _clang_isTranslationUnit: @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isTranslationUnit")created_Index.swift:2916 private let _clang_isPreprocessing: @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isPreprocessing")created_Index.swift:2926 private let _clang_isUnexposed: @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isUnexposed")created_Index.swift:2962 private let _clang_getCursorLinkage: @convention(c) (cursor: CXCursor) -> CXLinkageKind = library.loadSymbol("clang_getCursorLinkage")created_Index.swift:2976 private let _clang_getCursorAvailability: @convention(c) (cursor: CXCursor) -> CXAvailabilityKind = library.loadSymbol("clang_getCursorAvailability")created_Index.swift:3059 private let _clang_getCursorPlatformAvailability: @convention(c) (cursor: CXCursor, always_deprecated: UnsafeMutablePointer<Int32>, deprecated_message: UnsafeMutablePointer<CXString>, always_unavailable: UnsafeMutablePointer<Int32>, unavailable_message: UnsafeMutablePointer<CXString>, availability: UnsafeMutablePointer<CXPlatformAvailability>, availability_size: Int32) -> Int32 = library.loadSymbol("clang_getCursorPlatformAvailability")created_Index.swift:3068 private let _clang_disposeCXPlatformAvailability: @convention(c) (availability: UnsafeMutablePointer<CXPlatformAvailability>) -> () = library.loadSymbol("clang_disposeCXPlatformAvailability")created_Index.swift:3092 private let _clang_getCursorLanguage: @convention(c) (cursor: CXCursor) -> CXLanguageKind = library.loadSymbol("clang_getCursorLanguage")created_Index.swift:3101 private let _clang_Cursor_getTranslationUnit: @convention(c) (_: CXCursor) -> CXTranslationUnit = library.loadSymbol("clang_Cursor_getTranslationUnit")created_Index.swift:3115 private let _clang_createCXCursorSet: @convention(c) () -> CXCursorSet = library.loadSymbol("clang_createCXCursorSet")created_Index.swift:3124 private let _clang_disposeCXCursorSet: @convention(c) (cset: CXCursorSet) -> () = library.loadSymbol("clang_disposeCXCursorSet")created_Index.swift:3135 private let _clang_CXCursorSet_contains: @convention(c) (cset: CXCursorSet, cursor: CXCursor) -> UInt32 = library.loadSymbol("clang_CXCursorSet_contains")created_Index.swift:3146 private let _clang_CXCursorSet_insert: @convention(c) (cset: CXCursorSet, cursor: CXCursor) -> UInt32 = library.loadSymbol("clang_CXCursorSet_insert")created_Index.swift:3185 private let _clang_getCursorSemanticParent: @convention(c) (cursor: CXCursor) -> CXCursor = library.loadSymbol("clang_getCursorSemanticParent")created_Index.swift:3225 private let _clang_getCursorLexicalParent: @convention(c) (cursor: CXCursor) -> CXCursor = library.loadSymbol("clang_getCursorLexicalParent")created_Index.swift:3274 private let _clang_getOverriddenCursors: @convention(c) (cursor: CXCursor, overridden: UnsafeMutablePointer<UnsafeMutablePointer<CXCursor>>, num_overridden: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getOverriddenCursors")created_Index.swift:3284 private let _clang_disposeOverriddenCursors: @convention(c) (overridden: UnsafeMutablePointer<CXCursor>) -> () = library.loadSymbol("clang_disposeOverriddenCursors")created_Index.swift:3294 private let _clang_getIncludedFile: @convention(c) (cursor: CXCursor) -> CXFile = library.loadSymbol("clang_getIncludedFile")created_Index.swift:3330 private let _clang_getCursor: @convention(c) (_: CXTranslationUnit, _: CXSourceLocation) -> CXCursor = library.loadSymbol("clang_getCursor")created_Index.swift:3346 private let _clang_getCursorLocation: @convention(c) (_: CXCursor) -> CXSourceLocation = library.loadSymbol("clang_getCursorLocation")created_Index.swift:3363 private let _clang_getCursorExtent: @convention(c) (_: CXCursor) -> CXSourceRange = library.loadSymbol("clang_getCursorExtent")created_Index.swift:3688 private let _clang_getCursorType: @convention(c) (C: CXCursor) -> CXType = library.loadSymbol("clang_getCursorType")created_Index.swift:3700 private let _clang_getTypeSpelling: @convention(c) (CT: CXType) -> CXString = library.loadSymbol("clang_getTypeSpelling")created_Index.swift:3712 private let _clang_getTypedefDeclUnderlyingType: @convention(c) (C: CXCursor) -> CXType = library.loadSymbol("clang_getTypedefDeclUnderlyingType")created_Index.swift:3724 private let _clang_getEnumDeclIntegerType: @convention(c) (C: CXCursor) -> CXType = library.loadSymbol("clang_getEnumDeclIntegerType")created_Index.swift:3738 private let _clang_getEnumConstantDeclValue: @convention(c) (C: CXCursor) -> Int64 = library.loadSymbol("clang_getEnumConstantDeclValue")created_Index.swift:3752 private let _clang_getEnumConstantDeclUnsignedValue: @convention(c) (C: CXCursor) -> UInt64 = library.loadSymbol("clang_getEnumConstantDeclUnsignedValue")created_Index.swift:3763 private let _clang_getFieldDeclBitWidth: @convention(c) (C: CXCursor) -> Int32 = library.loadSymbol("clang_getFieldDeclBitWidth")created_Index.swift:3776 private let _clang_Cursor_getNumArguments: @convention(c) (C: CXCursor) -> Int32 = library.loadSymbol("clang_Cursor_getNumArguments")created_Index.swift:3789 private let _clang_Cursor_getArgument: @convention(c) (C: CXCursor, i: UInt32) -> CXCursor = library.loadSymbol("clang_Cursor_getArgument")created_Index.swift:3837 private let _clang_Cursor_getNumTemplateArguments: @convention(c) (C: CXCursor) -> Int32 = library.loadSymbol("clang_Cursor_getNumTemplateArguments")created_Index.swift:3859 private let _clang_Cursor_getTemplateArgumentKind: @convention(c) (C: CXCursor, I: UInt32) -> CXTemplateArgumentKind = library.loadSymbol("clang_Cursor_getTemplateArgumentKind")created_Index.swift:3883 private let _clang_Cursor_getTemplateArgumentType: @convention(c) (C: CXCursor, I: UInt32) -> CXType = library.loadSymbol("clang_Cursor_getTemplateArgumentType")created_Index.swift:3906 private let _clang_Cursor_getTemplateArgumentValue: @convention(c) (C: CXCursor, I: UInt32) -> Int64 = library.loadSymbol("clang_Cursor_getTemplateArgumentValue")created_Index.swift:3929 private let _clang_Cursor_getTemplateArgumentUnsignedValue: @convention(c) (C: CXCursor, I: UInt32) -> UInt64 = library.loadSymbol("clang_Cursor_getTemplateArgumentUnsignedValue")created_Index.swift:3941 private let _clang_equalTypes: @convention(c) (A: CXType, B: CXType) -> UInt32 = library.loadSymbol("clang_equalTypes")created_Index.swift:3955 private let _clang_getCanonicalType: @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_getCanonicalType")created_Index.swift:3966 private let _clang_isConstQualifiedType: @convention(c) (T: CXType) -> UInt32 = library.loadSymbol("clang_isConstQualifiedType")created_Index.swift:3977 private let _clang_isVolatileQualifiedType: @convention(c) (T: CXType) -> UInt32 = library.loadSymbol("clang_isVolatileQualifiedType")created_Index.swift:3988 private let _clang_isRestrictQualifiedType: @convention(c) (T: CXType) -> UInt32 = library.loadSymbol("clang_isRestrictQualifiedType")created_Index.swift:3997 private let _clang_getPointeeType: @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_getPointeeType")created_Index.swift:4006 private let _clang_getTypeDeclaration: @convention(c) (T: CXType) -> CXCursor = library.loadSymbol("clang_getTypeDeclaration")created_Index.swift:4015 private let _clang_getDeclObjCTypeEncoding: @convention(c) (C: CXCursor) -> CXString = library.loadSymbol("clang_getDeclObjCTypeEncoding")created_Index.swift:4024 private let _clang_getTypeKindSpelling: @convention(c) (K: CXTypeKind) -> CXString = library.loadSymbol("clang_getTypeKindSpelling")created_Index.swift:4035 private let _clang_getFunctionTypeCallingConv: @convention(c) (T: CXType) -> CXCallingConv = library.loadSymbol("clang_getFunctionTypeCallingConv")created_Index.swift:4046 private let _clang_getResultType: @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_getResultType")created_Index.swift:4058 private let _clang_getNumArgTypes: @convention(c) (T: CXType) -> Int32 = library.loadSymbol("clang_getNumArgTypes")created_Index.swift:4070 private let _clang_getArgType: @convention(c) (T: CXType, i: UInt32) -> CXType = library.loadSymbol("clang_getArgType")created_Index.swift:4079 private let _clang_isFunctionTypeVariadic: @convention(c) (T: CXType) -> UInt32 = library.loadSymbol("clang_isFunctionTypeVariadic")created_Index.swift:4090 private let _clang_getCursorResultType: @convention(c) (C: CXCursor) -> CXType = library.loadSymbol("clang_getCursorResultType")created_Index.swift:4100 private let _clang_isPODType: @convention(c) (T: CXType) -> UInt32 = library.loadSymbol("clang_isPODType")created_Index.swift:4112 private let _clang_getElementType: @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_getElementType")created_Index.swift:4124 private let _clang_getNumElements: @convention(c) (T: CXType) -> Int64 = library.loadSymbol("clang_getNumElements")created_Index.swift:4135 private let _clang_getArrayElementType: @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_getArrayElementType")created_Index.swift:4146 private let _clang_getArraySize: @convention(c) (T: CXType) -> Int64 = library.loadSymbol("clang_getArraySize")created_Index.swift:4201 private let _clang_Type_getAlignOf: @convention(c) (T: CXType) -> Int64 = library.loadSymbol("clang_Type_getAlignOf")created_Index.swift:4212 private let _clang_Type_getClassType: @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_Type_getClassType")created_Index.swift:4227 private let _clang_Type_getSizeOf: @convention(c) (T: CXType) -> Int64 = library.loadSymbol("clang_Type_getSizeOf")created_Index.swift:4246 private let _clang_Type_getOffsetOf: @convention(c) (T: CXType, S: UnsafePointer<Int8>) -> Int64 = library.loadSymbol("clang_Type_getOffsetOf")created_Index.swift:4265 private let _clang_Cursor_getOffsetOfField: @convention(c) (C: CXCursor) -> Int64 = library.loadSymbol("clang_Cursor_getOffsetOfField")created_Index.swift:4275 private let _clang_Cursor_isAnonymous: @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_Cursor_isAnonymous")created_Index.swift:4303 private let _clang_Type_getNumTemplateArguments: @convention(c) (T: CXType) -> Int32 = library.loadSymbol("clang_Type_getNumTemplateArguments")created_Index.swift:4316 private let _clang_Type_getTemplateArgumentAsType: @convention(c) (T: CXType, i: UInt32) -> CXType = library.loadSymbol("clang_Type_getTemplateArgumentAsType")created_Index.swift:4328 private let _clang_Type_getCXXRefQualifier: @convention(c) (T: CXType) -> CXRefQualifierKind = library.loadSymbol("clang_Type_getCXXRefQualifier")created_Index.swift:4338 private let _clang_Cursor_isBitField: @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_Cursor_isBitField")created_Index.swift:4348 private let _clang_isVirtualBase: @convention(c) (_: CXCursor) -> UInt32 = library.loadSymbol("clang_isVirtualBase")created_Index.swift:4377 private let _clang_getCXXAccessSpecifier: @convention(c) (_: CXCursor) -> CX_CXXAccessSpecifier = library.loadSymbol("clang_getCXXAccessSpecifier")created_Index.swift:4409 private let _clang_Cursor_getStorageClass: @convention(c) (_: CXCursor) -> CX_StorageClass = library.loadSymbol("clang_Cursor_getStorageClass")created_Index.swift:4424 private let _clang_getNumOverloadedDecls: @convention(c) (cursor: CXCursor) -> UInt32 = library.loadSymbol("clang_getNumOverloadedDecls")created_Index.swift:4444 private let _clang_getOverloadedDecl: @convention(c) (cursor: CXCursor, index: UInt32) -> CXCursor = library.loadSymbol("clang_getOverloadedDecl")created_Index.swift:4465 private let _clang_getIBOutletCollectionType: @convention(c) (_: CXCursor) -> CXType = library.loadSymbol("clang_getIBOutletCollectionType")created_Index.swift:4550 private let _clang_visitChildren: @convention(c) (parent: CXCursor, visitor: CXCursorVisitor!, client_data: CXClientData) -> UInt32 = library.loadSymbol("clang_visitChildren")created_Index.swift:4572 private let _clang_visitChildrenWithBlock: @convention(c) (parent: CXCursor, block: CXCursorVisitorBlock!) -> UInt32 = library.loadSymbol("clang_visitChildrenWithBlock")created_Index.swift:4602 private let _clang_getCursorUSR: @convention(c) (_: CXCursor) -> CXString = library.loadSymbol("clang_getCursorUSR")created_Index.swift:4611 private let _clang_constructUSR_ObjCClass: @convention(c) (class_name: UnsafePointer<Int8>) -> CXString = library.loadSymbol("clang_constructUSR_ObjCClass")created_Index.swift:4620 private let _clang_constructUSR_ObjCCategory: @convention(c) (class_name: UnsafePointer<Int8>, category_name: UnsafePointer<Int8>) -> CXString = library.loadSymbol("clang_constructUSR_ObjCCategory")created_Index.swift:4629 private let _clang_constructUSR_ObjCProtocol: @convention(c) (protocol_name: UnsafePointer<Int8>) -> CXString = library.loadSymbol("clang_constructUSR_ObjCProtocol")created_Index.swift:4639 private let _clang_constructUSR_ObjCIvar: @convention(c) (name: UnsafePointer<Int8>, classUSR: CXString) -> CXString = library.loadSymbol("clang_constructUSR_ObjCIvar")created_Index.swift:4649 private let _clang_constructUSR_ObjCMethod: @convention(c) (name: UnsafePointer<Int8>, isInstanceMethod: UInt32, classUSR: CXString) -> CXString = library.loadSymbol("clang_constructUSR_ObjCMethod")created_Index.swift:4659 private let _clang_constructUSR_ObjCProperty: @convention(c) (property: UnsafePointer<Int8>, classUSR: CXString) -> CXString = library.loadSymbol("clang_constructUSR_ObjCProperty")created_Index.swift:4668 private let _clang_getCursorSpelling: @convention(c) (_: CXCursor) -> CXString = library.loadSymbol("clang_getCursorSpelling")created_Index.swift:4685 private let _clang_Cursor_getSpellingNameRange: @convention(c) (_: CXCursor, pieceIndex: UInt32, options: UInt32) -> CXSourceRange = library.loadSymbol("clang_Cursor_getSpellingNameRange")created_Index.swift:4698 private let _clang_getCursorDisplayName: @convention(c) (_: CXCursor) -> CXString = library.loadSymbol("clang_getCursorDisplayName")created_Index.swift:4714 private let _clang_getCursorReferenced: @convention(c) (_: CXCursor) -> CXCursor = library.loadSymbol("clang_getCursorReferenced")created_Index.swift:4748 private let _clang_getCursorDefinition: @convention(c) (_: CXCursor) -> CXCursor = library.loadSymbol("clang_getCursorDefinition")created_Index.swift:4758 private let _clang_isCursorDefinition: @convention(c) (_: CXCursor) -> UInt32 = library.loadSymbol("clang_isCursorDefinition")created_Index.swift:4788 private let _clang_getCanonicalCursor: @convention(c) (_: CXCursor) -> CXCursor = library.loadSymbol("clang_getCanonicalCursor")created_Index.swift:4805 private let _clang_Cursor_getObjCSelectorIndex: @convention(c) (_: CXCursor) -> Int32 = library.loadSymbol("clang_Cursor_getObjCSelectorIndex")created_Index.swift:4822 private let _clang_Cursor_isDynamicCall: @convention(c) (C: CXCursor) -> Int32 = library.loadSymbol("clang_Cursor_isDynamicCall")created_Index.swift:4832 private let _clang_Cursor_getReceiverType: @convention(c) (C: CXCursor) -> CXType = library.loadSymbol("clang_Cursor_getReceiverType")created_Index.swift:4869 private let _clang_Cursor_getObjCPropertyAttributes: @convention(c) (C: CXCursor, reserved: UInt32) -> UInt32 = library.loadSymbol("clang_Cursor_getObjCPropertyAttributes")created_Index.swift:4900 private let _clang_Cursor_getObjCDeclQualifiers: @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_Cursor_getObjCDeclQualifiers")created_Index.swift:4911 private let _clang_Cursor_isObjCOptional: @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_Cursor_isObjCOptional")created_Index.swift:4920 private let _clang_Cursor_isVariadic: @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_Cursor_isVariadic")created_Index.swift:4931 private let _clang_Cursor_getCommentRange: @convention(c) (C: CXCursor) -> CXSourceRange = library.loadSymbol("clang_Cursor_getCommentRange")created_Index.swift:4941 private let _clang_Cursor_getRawCommentText: @convention(c) (C: CXCursor) -> CXString = library.loadSymbol("clang_Cursor_getRawCommentText")created_Index.swift:4952 private let _clang_Cursor_getBriefCommentText: @convention(c) (C: CXCursor) -> CXString = library.loadSymbol("clang_Cursor_getBriefCommentText")created_Index.swift:4970 private let _clang_Cursor_getMangling: @convention(c) (_: CXCursor) -> CXString = library.loadSymbol("clang_Cursor_getMangling")created_Index.swift:4993 private let _clang_Cursor_getModule: @convention(c) (C: CXCursor) -> CXModule = library.loadSymbol("clang_Cursor_getModule")created_Index.swift:5003 private let _clang_getModuleForFile: @convention(c) (_: CXTranslationUnit, _: CXFile) -> CXModule = library.loadSymbol("clang_getModuleForFile")created_Index.swift:5014 private let _clang_Module_getASTFile: @convention(c) (Module: CXModule) -> CXFile = library.loadSymbol("clang_Module_getASTFile")created_Index.swift:5026 private let _clang_Module_getParent: @convention(c) (Module: CXModule) -> CXModule = library.loadSymbol("clang_Module_getParent")created_Index.swift:5038 private let _clang_Module_getName: @convention(c) (Module: CXModule) -> CXString = library.loadSymbol("clang_Module_getName")created_Index.swift:5049 private let _clang_Module_getFullName: @convention(c) (Module: CXModule) -> CXString = library.loadSymbol("clang_Module_getFullName")created_Index.swift:5060 private let _clang_Module_isSystem: @convention(c) (Module: CXModule) -> Int32 = library.loadSymbol("clang_Module_isSystem")created_Index.swift:5071 private let _clang_Module_getNumTopLevelHeaders: @convention(c) (_: CXTranslationUnit, Module: CXModule) -> UInt32 = library.loadSymbol("clang_Module_getNumTopLevelHeaders")created_Index.swift:5085 private let _clang_Module_getTopLevelHeader: @convention(c) (_: CXTranslationUnit, Module: CXModule, Index: UInt32) -> CXFile = library.loadSymbol("clang_Module_getTopLevelHeader")created_Index.swift:5107 private let _clang_CXXField_isMutable: @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_CXXField_isMutable")created_Index.swift:5117 private let _clang_CXXMethod_isPureVirtual: @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_CXXMethod_isPureVirtual")created_Index.swift:5127 private let _clang_CXXMethod_isStatic: @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_CXXMethod_isStatic")created_Index.swift:5138 private let _clang_CXXMethod_isVirtual: @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_CXXMethod_isVirtual")created_Index.swift:5148 private let _clang_CXXMethod_isConst: @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_CXXMethod_isConst")created_Index.swift:5171 private let _clang_getTemplateCursorKind: @convention(c) (C: CXCursor) -> CXCursorKind = library.loadSymbol("clang_getTemplateCursorKind")created_Index.swift:5205 private let _clang_getSpecializedCursorTemplate: @convention(c) (C: CXCursor) -> CXCursor = library.loadSymbol("clang_getSpecializedCursorTemplate")created_Index.swift:5229 private let _clang_getCursorReferenceNameRange: @convention(c) (C: CXCursor, NameFlags: UInt32, PieceIndex: UInt32) -> CXSourceRange = library.loadSymbol("clang_getCursorReferenceNameRange")created_Index.swift:5332 private let _clang_getTokenKind: @convention(c) (_: CXToken) -> CXTokenKind = library.loadSymbol("clang_getTokenKind")created_Index.swift:5344 private let _clang_getTokenSpelling: @convention(c) (_: CXTranslationUnit, _: CXToken) -> CXString = library.loadSymbol("clang_getTokenSpelling")created_Index.swift:5353 private let _clang_getTokenLocation: @convention(c) (_: CXTranslationUnit, _: CXToken) -> CXSourceLocation = library.loadSymbol("clang_getTokenLocation")created_Index.swift:5362 private let _clang_getTokenExtent: @convention(c) (_: CXTranslationUnit, _: CXToken) -> CXSourceRange = library.loadSymbol("clang_getTokenExtent")created_Index.swift:5385 private let _clang_tokenize: @convention(c) (TU: CXTranslationUnit, Range: CXSourceRange, Tokens: UnsafeMutablePointer<UnsafeMutablePointer<CXToken>>, NumTokens: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_tokenize")created_Index.swift:5421 private let _clang_annotateTokens: @convention(c) (TU: CXTranslationUnit, Tokens: UnsafeMutablePointer<CXToken>, NumTokens: UInt32, Cursors: UnsafeMutablePointer<CXCursor>) -> () = library.loadSymbol("clang_annotateTokens")created_Index.swift:5430 private let _clang_disposeTokens: @convention(c) (TU: CXTranslationUnit, Tokens: UnsafeMutablePointer<CXToken>, NumTokens: UInt32) -> () = library.loadSymbol("clang_disposeTokens")created_Index.swift:5450 private let _clang_getCursorKindSpelling: @convention(c) (Kind: CXCursorKind) -> CXString = library.loadSymbol("clang_getCursorKindSpelling")created_Index.swift:5455 private let _clang_getDefinitionSpellingAndExtent: @convention(c) (_: CXCursor, startBuf: UnsafeMutablePointer<UnsafePointer<Int8>>, endBuf: UnsafeMutablePointer<UnsafePointer<Int8>>, startLine: UnsafeMutablePointer<UInt32>, startColumn: UnsafeMutablePointer<UInt32>, endLine: UnsafeMutablePointer<UInt32>, endColumn: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getDefinitionSpellingAndExtent")created_Index.swift:5460 private let _clang_enableStackTraces: @convention(c) () -> () = library.loadSymbol("clang_enableStackTraces")created_Index.swift:5465 private let _clang_executeOnThread: @convention(c) (fn: (@convention(c) (UnsafeMutablePointer<Void>) -> Void)!, user_data: UnsafeMutablePointer<Void>, stack_size: UInt32) -> () = library.loadSymbol("clang_executeOnThread")created_Index.swift:5715 private let _clang_getCompletionChunkKind: @convention(c) (completion_string: CXCompletionString, chunk_number: UInt32) -> CXCompletionChunkKind = library.loadSymbol("clang_getCompletionChunkKind")created_Index.swift:5731 private let _clang_getCompletionChunkText: @convention(c) (completion_string: CXCompletionString, chunk_number: UInt32) -> CXString = library.loadSymbol("clang_getCompletionChunkText")created_Index.swift:5748 private let _clang_getCompletionChunkCompletionString: @convention(c) (completion_string: CXCompletionString, chunk_number: UInt32) -> CXCompletionString = library.loadSymbol("clang_getCompletionChunkCompletionString")created_Index.swift:5757 private let _clang_getNumCompletionChunks: @convention(c) (completion_string: CXCompletionString) -> UInt32 = library.loadSymbol("clang_getNumCompletionChunks")created_Index.swift:5775 private let _clang_getCompletionPriority: @convention(c) (completion_string: CXCompletionString) -> UInt32 = library.loadSymbol("clang_getCompletionPriority")created_Index.swift:5789 private let _clang_getCompletionAvailability: @convention(c) (completion_string: CXCompletionString) -> CXAvailabilityKind = library.loadSymbol("clang_getCompletionAvailability")created_Index.swift:5804 private let _clang_getCompletionNumAnnotations: @convention(c) (completion_string: CXCompletionString) -> UInt32 = library.loadSymbol("clang_getCompletionNumAnnotations")created_Index.swift:5821 private let _clang_getCompletionAnnotation: @convention(c) (completion_string: CXCompletionString, annotation_number: UInt32) -> CXString = library.loadSymbol("clang_getCompletionAnnotation")created_Index.swift:5843 private let _clang_getCompletionParent: @convention(c) (completion_string: CXCompletionString, kind: UnsafeMutablePointer<CXCursorKind>) -> CXString = library.loadSymbol("clang_getCompletionParent")created_Index.swift:5853 private let _clang_getCompletionBriefComment: @convention(c) (completion_string: CXCompletionString) -> CXString = library.loadSymbol("clang_getCompletionBriefComment")created_Index.swift:5868 private let _clang_getCursorCompletionString: @convention(c) (cursor: CXCursor) -> CXCompletionString = library.loadSymbol("clang_getCursorCompletionString")created_Index.swift:6072 private let _clang_defaultCodeCompleteOptions: @convention(c) () -> UInt32 = library.loadSymbol("clang_defaultCodeCompleteOptions")created_Index.swift:6147 private let _clang_codeCompleteAt: @convention(c) (TU: CXTranslationUnit, complete_filename: UnsafePointer<Int8>, complete_line: UInt32, complete_column: UInt32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, num_unsaved_files: UInt32, options: UInt32) -> UnsafeMutablePointer<CXCodeCompleteResults> = library.loadSymbol("clang_codeCompleteAt")created_Index.swift:6161 private let _clang_sortCodeCompletionResults: @convention(c) (Results: UnsafeMutablePointer<CXCompletionResult>, NumResults: UInt32) -> () = library.loadSymbol("clang_sortCodeCompletionResults")created_Index.swift:6171 private let _clang_disposeCodeCompleteResults: @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> () = library.loadSymbol("clang_disposeCodeCompleteResults")created_Index.swift:6182 private let _clang_codeCompleteGetNumDiagnostics: @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> UInt32 = library.loadSymbol("clang_codeCompleteGetNumDiagnostics")created_Index.swift:6198 private let _clang_codeCompleteGetDiagnostic: @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>, Index: UInt32) -> CXDiagnostic = library.loadSymbol("clang_codeCompleteGetDiagnostic")created_Index.swift:6214 private let _clang_codeCompleteGetContexts: @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> UInt64 = library.loadSymbol("clang_codeCompleteGetContexts")created_Index.swift:6237 private let _clang_codeCompleteGetContainerKind: @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>, IsIncomplete: UnsafeMutablePointer<UInt32>) -> CXCursorKind = library.loadSymbol("clang_codeCompleteGetContainerKind")created_Index.swift:6253 private let _clang_codeCompleteGetContainerUSR: @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> CXString = library.loadSymbol("clang_codeCompleteGetContainerUSR")created_Index.swift:6271 private let _clang_codeCompleteGetObjCSelector: @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> CXString = library.loadSymbol("clang_codeCompleteGetObjCSelector")created_Index.swift:6291 private let _clang_getClangVersion: @convention(c) () -> CXString = library.loadSymbol("clang_getClangVersion")created_Index.swift:6303 private let _clang_toggleCrashRecovery: @convention(c) (isEnabled: UInt32) -> () = library.loadSymbol("clang_toggleCrashRecovery")created_Index.swift:6328 private let _clang_getInclusions: @convention(c) (tu: CXTranslationUnit, visitor: CXInclusionVisitor!, client_data: CXClientData) -> () = library.loadSymbol("clang_getInclusions")created_Index.swift:6356 private let _clang_getRemappings: @convention(c) (path: UnsafePointer<Int8>) -> CXRemapping = library.loadSymbol("clang_getRemappings")created_Index.swift:6373 private let _clang_getRemappingsFromFileList: @convention(c) (filePaths: UnsafeMutablePointer<UnsafePointer<Int8>>, numFiles: UInt32) -> CXRemapping = library.loadSymbol("clang_getRemappingsFromFileList")created_Index.swift:6382 private let _clang_remap_getNumFiles: @convention(c) (_: CXRemapping) -> UInt32 = library.loadSymbol("clang_remap_getNumFiles")created_Index.swift:6396 private let _clang_remap_getFilenames: @convention(c) (_: CXRemapping, index: UInt32, original: UnsafeMutablePointer<CXString>, transformed: UnsafeMutablePointer<CXString>) -> () = library.loadSymbol("clang_remap_getFilenames")created_Index.swift:6405 private let _clang_remap_dispose: @convention(c) (_: CXRemapping) -> () = library.loadSymbol("clang_remap_dispose")created_Index.swift:6475 private let _clang_findReferencesInFile: @convention(c) (cursor: CXCursor, file: CXFile, visitor: CXCursorAndRangeVisitor) -> CXResult = library.loadSymbol("clang_findReferencesInFile")created_Index.swift:6493 private let _clang_findIncludesInFile: @convention(c) (TU: CXTranslationUnit, file: CXFile, visitor: CXCursorAndRangeVisitor) -> CXResult = library.loadSymbol("clang_findIncludesInFile")created_Index.swift:6501 private let _clang_findReferencesInFileWithBlock: @convention(c) (_: CXCursor, _: CXFile, _: CXCursorAndRangeVisitorBlock!) -> CXResult = library.loadSymbol("clang_findReferencesInFileWithBlock")created_Index.swift:6507 private let _clang_findIncludesInFileWithBlock: @convention(c) (_: CXTranslationUnit, _: CXFile, _: CXCursorAndRangeVisitorBlock!) -> CXResult = library.loadSymbol("clang_findIncludesInFileWithBlock")created_Index.swift:6964 private let _clang_index_isEntityObjCContainerKind: @convention(c) (_: CXIdxEntityKind) -> Int32 = library.loadSymbol("clang_index_isEntityObjCContainerKind")created_Index.swift:6969 private let _clang_index_getObjCContainerDeclInfo: @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCContainerDeclInfo> = library.loadSymbol("clang_index_getObjCContainerDeclInfo")created_Index.swift:6975 private let _clang_index_getObjCInterfaceDeclInfo: @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCInterfaceDeclInfo> = library.loadSymbol("clang_index_getObjCInterfaceDeclInfo")created_Index.swift:6981 private let _clang_index_getObjCCategoryDeclInfo: @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCCategoryDeclInfo> = library.loadSymbol("clang_index_getObjCCategoryDeclInfo")created_Index.swift:6987 private let _clang_index_getObjCProtocolRefListInfo: @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCProtocolRefListInfo> = library.loadSymbol("clang_index_getObjCProtocolRefListInfo")created_Index.swift:6993 private let _clang_index_getObjCPropertyDeclInfo: @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCPropertyDeclInfo> = library.loadSymbol("clang_index_getObjCPropertyDeclInfo")created_Index.swift:6999 private let _clang_index_getIBOutletCollectionAttrInfo: @convention(c) (_: UnsafePointer<CXIdxAttrInfo>) -> UnsafePointer<CXIdxIBOutletCollectionAttrInfo> = library.loadSymbol("clang_index_getIBOutletCollectionAttrInfo")created_Index.swift:7005 private let _clang_index_getCXXClassDeclInfo: @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxCXXClassDeclInfo> = library.loadSymbol("clang_index_getCXXClassDeclInfo")created_Index.swift:7015 private let _clang_index_getClientContainer: @convention(c) (_: UnsafePointer<CXIdxContainerInfo>) -> CXIdxClientContainer = library.loadSymbol("clang_index_getClientContainer")created_Index.swift:7025 private let _clang_index_setClientContainer: @convention(c) (_: UnsafePointer<CXIdxContainerInfo>, _: CXIdxClientContainer) -> () = library.loadSymbol("clang_index_setClientContainer")created_Index.swift:7034 private let _clang_index_getClientEntity: @convention(c) (_: UnsafePointer<CXIdxEntityInfo>) -> CXIdxClientEntity = library.loadSymbol("clang_index_getClientEntity")created_Index.swift:7043 private let _clang_index_setClientEntity: @convention(c) (_: UnsafePointer<CXIdxEntityInfo>, _: CXIdxClientEntity) -> () = library.loadSymbol("clang_index_setClientEntity")created_Index.swift:7061 private let _clang_IndexAction_create: @convention(c) (CIdx: CXIndex) -> CXIndexAction = library.loadSymbol("clang_IndexAction_create")created_Index.swift:7073 private let _clang_IndexAction_dispose: @convention(c) (_: CXIndexAction) -> () = library.loadSymbol("clang_IndexAction_dispose")created_Index.swift:7148 private let _clang_indexSourceFile: @convention(c) (_: CXIndexAction, client_data: CXClientData, index_callbacks: UnsafeMutablePointer<IndexerCallbacks>, index_callbacks_size: UInt32, index_options: UInt32, source_filename: UnsafePointer<Int8>, command_line_args: UnsafePointer<UnsafePointer<Int8>>, num_command_line_args: Int32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, num_unsaved_files: UInt32, out_TU: UnsafeMutablePointer<CXTranslationUnit>, TU_options: UInt32) -> Int32 = library.loadSymbol("clang_indexSourceFile")created_Index.swift:7170 private let _clang_indexTranslationUnit: @convention(c) (_: CXIndexAction, client_data: CXClientData, index_callbacks: UnsafeMutablePointer<IndexerCallbacks>, index_callbacks_size: UInt32, index_options: UInt32, _: CXTranslationUnit) -> Int32 = library.loadSymbol("clang_indexTranslationUnit")created_Index.swift:7184 private let _clang_indexLoc_getFileLocation: @convention(c) (loc: CXIdxLoc, indexFile: UnsafeMutablePointer<CXIdxClientFile>, file: UnsafeMutablePointer<CXFile>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>, offset: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_indexLoc_getFileLocation")created_Index.swift:7194 private let _clang_indexLoc_getCXSourceLocation: @convention(c) (loc: CXIdxLoc) -> CXSourceLocation = library.loadSymbol("clang_indexLoc_getCXSourceLocation")created_Index.swift:7232 private let _clang_Type_visitFields: @convention(c) (T: CXType, visitor: CXFieldVisitor!, client_data: CXClientData) -> UInt32 = library.loadSymbol("clang_Type_visitFields")(excludeDeclarationsFromPCH: Int32, _ displayDiagnostics: Int32) -> CXIndex { 0210 return _clang_createIndex(excludeDeclarationsFromPCH: excludeDeclarationsFromPCH, displayDiagnostics: displayDiagnostics) 0211 } 0212 private let _clang_createIndex
Clang+SourceKitten.swift:16 : @convention(c) (excludeDeclarationsFromPCH: Int32, displayDiagnostics: Int32) -> CXIndex = library.loadSymbol("clang_createIndex") 0213 0214 0215 /** 0216 * \brief Destroy the given index. 0217 * 0218 * The index must not be destroyed until all of the translation units created 0219 * within that index have been destroyed. 0220 */ 0221 public func clang_disposeIndex(index: CXIndex) { 0222 return _clang_disposeIndex(index: index) 0223 } 0224 private let _clang_disposeIndex
created_Index.swift:210 : @convention(c) (index: CXIndex) -> () = library.loadSymbol("clang_disposeIndex") 0225 0226 0227 /* 0228 public struct CXGlobalOptFlags : RawRepresentable, Equatable { 0229 public init(_ rawValue: UInt32) 0230 public init(rawValue: UInt32) 0231 // public var rawValue: UInt32 0232 } 0233 */ 0234 0235 /** 0236 * \brief Used to indicate that no special CXIndex options are needed. 0237 */ 0238 // public var CXGlobalOpt_None: CXGlobalOptFlags { get } 0239 0240 /** 0241 * \brief Used to indicate that threads that libclang creates for indexing 0242 * purposes should use background priority. 0243 * 0244 * Affects #clang_indexSourceFile, #clang_indexTranslationUnit, 0245 * #clang_parseTranslationUnit, #clang_saveTranslationUnit. 0246 */ 0247 // public var CXGlobalOpt_ThreadBackgroundPriorityForIndexing: CXGlobalOptFlags { get } 0248 0249 /** 0250 * \brief Used to indicate that threads that libclang creates for editing 0251 * purposes should use background priority. 0252 * 0253 * Affects #clang_reparseTranslationUnit, #clang_codeCompleteAt, 0254 * #clang_annotateTokens 0255 */ 0256 // public var CXGlobalOpt_ThreadBackgroundPriorityForEditing: CXGlobalOptFlags { get } 0257 0258 /** 0259 * \brief Used to indicate that all threads that libclang creates should use 0260 * background priority. 0261 */ 0262 // public var CXGlobalOpt_ThreadBackgroundPriorityForAll: CXGlobalOptFlags { get } 0263 0264 /** 0265 * \brief Sets general options associated with a CXIndex. 0266 * 0267 * For example: 0268 * \code 0269 * CXIndex idx = ...; 0270 * clang_CXIndex_setGlobalOptions(idx, 0271 * clang_CXIndex_getGlobalOptions(idx) | 0272 * CXGlobalOpt_ThreadBackgroundPriorityForIndexing); 0273 * \endcode 0274 * 0275 * \param options A bitmask of options, a bitwise OR of CXGlobalOpt_XXX flags. 0276 */ 0277 public func clang_CXIndex_setGlobalOptions(unnamed1: CXIndex, _ options: UInt32) { 0278 return _clang_CXIndex_setGlobalOptions(unnamed1, options: options) 0279 } 0280 private let _clang_CXIndex_setGlobalOptions
created_Index.swift:222 : @convention(c) (_: CXIndex, options: UInt32) -> () = library.loadSymbol("clang_CXIndex_setGlobalOptions") 0281 0282 0283 /** 0284 * \brief Gets the general options associated with a CXIndex. 0285 * 0286 * \returns A bitmask of options, a bitwise OR of CXGlobalOpt_XXX flags that 0287 * are associated with the given CXIndex object. 0288 */ 0289 public func clang_CXIndex_getGlobalOptions(unnamed1: CXIndex) -> UInt32 { 0290 return _clang_CXIndex_getGlobalOptions(unnamed1) 0291 } 0292 private let _clang_CXIndex_getGlobalOptions
created_Index.swift:278 : @convention(c) (_: CXIndex) -> UInt32 = library.loadSymbol("clang_CXIndex_getGlobalOptions") 0293 0294 0295 /** 0296 * \defgroup CINDEX_FILES File manipulation routines 0297 * 0298 * @{ 0299 */ 0300 0301 /** 0302 * \brief A particular source file that is part of a translation unit. 0303 */ 0304 // public typealias CXFile = UnsafeMutablePointer<Void> 0305 0306 /** 0307 * \brief Retrieve the complete file and path name of the given file. 0308 */ 0309 public func clang_getFileName
created_Index.swift:290 (SFile: CXFile) -> CXString { 0310 return _clang_getFileName(SFile: SFile) 0311 } 0312 private let _clang_getFileName
SourceLocation.swift:32 : @convention(c) (SFile: CXFile) -> CXString = library.loadSymbol("clang_getFileName") 0313 0314 0315 /** 0316 * \brief Retrieve the last modification time of the given file. 0317 */ 0318 public func clang_getFileTime(SFile: CXFile) -> time_t { 0319 return _clang_getFileTime(SFile: SFile) 0320 } 0321 private let _clang_getFileTime
created_Index.swift:310 : @convention(c) (SFile: CXFile) -> time_t = library.loadSymbol("clang_getFileTime") 0322 0323 0324 /** 0325 * \brief Uniquely identifies a CXFile, that refers to the same underlying file, 0326 * across an indexing session. 0327 */ 0328 /* 0329 public struct CXFileUniqueID { 0330 // public var data: (UInt64, UInt64, UInt64) 0331 public init() 0332 public init(data: (UInt64, UInt64, UInt64)) 0333 } 0334 */ 0335 0336 /** 0337 * \brief Retrieve the unique ID for the given \c file. 0338 * 0339 * \param file the file to get the ID for. 0340 * \param outID stores the returned CXFileUniqueID. 0341 * \returns If there was a failure getting the unique ID, returns non-zero, 0342 * otherwise returns 0. 0343 */ 0344 public func clang_getFileUniqueID(file: CXFile, _ outID: UnsafeMutablePointer<CXFileUniqueID>) -> Int32 { 0345 return _clang_getFileUniqueID(file: file, outID: outID) 0346 } 0347 private let _clang_getFileUniqueID
created_Index.swift:319 : @convention(c) (file: CXFile, outID: UnsafeMutablePointer<CXFileUniqueID>) -> Int32 = library.loadSymbol("clang_getFileUniqueID") 0348 0349 0350 /** 0351 * \brief Determine whether the given header is guarded against 0352 * multiple inclusions, either with the conventional 0353 * \#ifndef/\#define/\#endif macro guards or with \#pragma once. 0354 */ 0355 public func clang_isFileMultipleIncludeGuarded(tu: CXTranslationUnit, _ file: CXFile) -> UInt32 { 0356 return _clang_isFileMultipleIncludeGuarded(tu: tu, file: file) 0357 } 0358 private let _clang_isFileMultipleIncludeGuarded
created_Index.swift:345 : @convention(c) (tu: CXTranslationUnit, file: CXFile) -> UInt32 = library.loadSymbol("clang_isFileMultipleIncludeGuarded") 0359 0360 0361 /** 0362 * \brief Retrieve a file handle within the given translation unit. 0363 * 0364 * \param tu the translation unit 0365 * 0366 * \param file_name the name of the file. 0367 * 0368 * \returns the file handle for the named file in the translation unit \p tu, 0369 * or a NULL file handle if the file was not a part of this translation unit. 0370 */ 0371 public func clang_getFile(tu: CXTranslationUnit, _ file_name: UnsafePointer<Int8>) -> CXFile { 0372 return _clang_getFile(tu: tu, file_name: file_name) 0373 } 0374 private let _clang_getFile
created_Index.swift:356 : @convention(c) (tu: CXTranslationUnit, file_name: UnsafePointer<Int8>) -> CXFile = library.loadSymbol("clang_getFile") 0375 0376 0377 /** 0378 * \brief Returns non-zero if the \c file1 and \c file2 point to the same file, 0379 * or they are both NULL. 0380 */ 0381 public func clang_File_isEqual(file1: CXFile, _ file2: CXFile) -> Int32 { 0382 return _clang_File_isEqual(file1: file1, file2: file2) 0383 } 0384 private let _clang_File_isEqual
created_Index.swift:372 : @convention(c) (file1: CXFile, file2: CXFile) -> Int32 = library.loadSymbol("clang_File_isEqual") 0385 0386 0387 /** 0388 * @} 0389 */ 0390 0391 /** 0392 * \defgroup CINDEX_LOCATIONS Physical source locations 0393 * 0394 * Clang represents physical source locations in its abstract syntax tree in 0395 * great detail, with file, line, and column information for the majority of 0396 * the tokens parsed in the source code. These data types and functions are 0397 * used to represent source location information, either for a particular 0398 * point in the program or for a range of points in the program, and extract 0399 * specific location information from those data types. 0400 * 0401 * @{ 0402 */ 0403 0404 /** 0405 * \brief Identifies a specific source location within a translation 0406 * unit. 0407 * 0408 * Use clang_getExpansionLocation() or clang_getSpellingLocation() 0409 * to map a source location to a particular file, line, and column. 0410 */ 0411 /* 0412 public struct CXSourceLocation { 0413 // public var ptr_data: (UnsafePointer<Void>, UnsafePointer<Void>) 0414 // public var int_data: UInt32 0415 public init() 0416 public init(ptr_data: (UnsafePointer<Void>, UnsafePointer<Void>), int_data: UInt32) 0417 } 0418 */ 0419 0420 /** 0421 * \brief Identifies a half-open character range in the source code. 0422 * 0423 * Use clang_getRangeStart() and clang_getRangeEnd() to retrieve the 0424 * starting and end locations from a source range, respectively. 0425 */ 0426 /* 0427 public struct CXSourceRange { 0428 // public var ptr_data: (UnsafePointer<Void>, UnsafePointer<Void>) 0429 // public var begin_int_data: UInt32 0430 // public var end_int_data: UInt32 0431 public init() 0432 public init(ptr_data: (UnsafePointer<Void>, UnsafePointer<Void>), begin_int_data: UInt32, end_int_data: UInt32) 0433 } 0434 */ 0435 0436 /** 0437 * \brief Retrieve a NULL (invalid) source location. 0438 */ 0439 public func clang_getNullLocation() -> CXSourceLocation { 0440 return _clang_getNullLocation() 0441 } 0442 private let _clang_getNullLocation
created_Index.swift:382 : @convention(c) () -> CXSourceLocation = library.loadSymbol("clang_getNullLocation") 0443 0444 0445 /** 0446 * \brief Determine whether two source locations, which must refer into 0447 * the same translation unit, refer to exactly the same point in the source 0448 * code. 0449 * 0450 * \returns non-zero if the source locations refer to the same location, zero 0451 * if they refer to different locations. 0452 */ 0453 public func clang_equalLocations(loc1: CXSourceLocation, _ loc2: CXSourceLocation) -> UInt32 { 0454 return _clang_equalLocations(loc1: loc1, loc2: loc2) 0455 } 0456 private let _clang_equalLocations
created_Index.swift:440 : @convention(c) (loc1: CXSourceLocation, loc2: CXSourceLocation) -> UInt32 = library.loadSymbol("clang_equalLocations") 0457 0458 0459 /** 0460 * \brief Retrieves the source location associated with a given file/line/column 0461 * in a particular translation unit. 0462 */ 0463 public func clang_getLocation(tu: CXTranslationUnit, _ file: CXFile, _ line: UInt32, _ column: UInt32) -> CXSourceLocation { 0464 return _clang_getLocation(tu: tu, file: file, line: line, column: column) 0465 } 0466 private let _clang_getLocation
created_Index.swift:454 : @convention(c) (tu: CXTranslationUnit, file: CXFile, line: UInt32, column: UInt32) -> CXSourceLocation = library.loadSymbol("clang_getLocation") 0467 0468 /** 0469 * \brief Retrieves the source location associated with a given character offset 0470 * in a particular translation unit. 0471 */ 0472 public func clang_getLocationForOffset(tu: CXTranslationUnit, _ file: CXFile, _ offset: UInt32) -> CXSourceLocation { 0473 return _clang_getLocationForOffset(tu: tu, file: file, offset: offset) 0474 } 0475 private let _clang_getLocationForOffset
created_Index.swift:464 : @convention(c) (tu: CXTranslationUnit, file: CXFile, offset: UInt32) -> CXSourceLocation = library.loadSymbol("clang_getLocationForOffset") 0476 0477 0478 /** 0479 * \brief Returns non-zero if the given source location is in a system header. 0480 */ 0481 public func clang_Location_isInSystemHeader
created_Index.swift:473 (location: CXSourceLocation) -> Int32 { 0482 return _clang_Location_isInSystemHeader(location: location) 0483 } 0484 private let _clang_Location_isInSystemHeader
Clang+SourceKitten.swift:60 : @convention(c) (location: CXSourceLocation) -> Int32 = library.loadSymbol("clang_Location_isInSystemHeader") 0485 0486 0487 /** 0488 * \brief Returns non-zero if the given source location is in the main file of 0489 * the corresponding translation unit. 0490 */ 0491 public func clang_Location_isFromMainFile(location: CXSourceLocation) -> Int32 { 0492 return _clang_Location_isFromMainFile(location: location) 0493 } 0494 private let _clang_Location_isFromMainFile
created_Index.swift:482 : @convention(c) (location: CXSourceLocation) -> Int32 = library.loadSymbol("clang_Location_isFromMainFile") 0495 0496 0497 /** 0498 * \brief Retrieve a NULL (invalid) source range. 0499 */ 0500 public func clang_getNullRange() -> CXSourceRange { 0501 return _clang_getNullRange() 0502 } 0503 private let _clang_getNullRange
created_Index.swift:492 : @convention(c) () -> CXSourceRange = library.loadSymbol("clang_getNullRange") 0504 0505 0506 /** 0507 * \brief Retrieve a source range given the beginning and ending source 0508 * locations. 0509 */ 0510 public func clang_getRange(begin: CXSourceLocation, _ end: CXSourceLocation) -> CXSourceRange { 0511 return _clang_getRange(begin: begin, end: end) 0512 } 0513 private let _clang_getRange
created_Index.swift:501 : @convention(c) (begin: CXSourceLocation, end: CXSourceLocation) -> CXSourceRange = library.loadSymbol("clang_getRange") 0514 0515 0516 /** 0517 * \brief Determine whether two ranges are equivalent. 0518 * 0519 * \returns non-zero if the ranges are the same, zero if they differ. 0520 */ 0521 public func clang_equalRanges(range1: CXSourceRange, _ range2: CXSourceRange) -> UInt32 { 0522 return _clang_equalRanges(range1: range1, range2: range2) 0523 } 0524 private let _clang_equalRanges
created_Index.swift:511 : @convention(c) (range1: CXSourceRange, range2: CXSourceRange) -> UInt32 = library.loadSymbol("clang_equalRanges") 0525 0526 0527 /** 0528 * \brief Returns non-zero if \p range is null. 0529 */ 0530 public func clang_Range_isNull(range: CXSourceRange) -> Int32 { 0531 return _clang_Range_isNull(range: range) 0532 } 0533 private let _clang_Range_isNull
created_Index.swift:522 : @convention(c) (range: CXSourceRange) -> Int32 = library.loadSymbol("clang_Range_isNull") 0534 0535 0536 /** 0537 * \brief Retrieve the file, line, column, and offset represented by 0538 * the given source location. 0539 * 0540 * If the location refers into a macro expansion, retrieves the 0541 * location of the macro expansion. 0542 * 0543 * \param location the location within a source file that will be decomposed 0544 * into its parts. 0545 * 0546 * \param file [out] if non-NULL, will be set to the file to which the given 0547 * source location points. 0548 * 0549 * \param line [out] if non-NULL, will be set to the line to which the given 0550 * source location points. 0551 * 0552 * \param column [out] if non-NULL, will be set to the column to which the given 0553 * source location points. 0554 * 0555 * \param offset [out] if non-NULL, will be set to the offset into the 0556 * buffer to which the given source location points. 0557 */ 0558 public func clang_getExpansionLocation(location: CXSourceLocation, _ file: UnsafeMutablePointer<CXFile>, _ line: UnsafeMutablePointer<UInt32>, _ column: UnsafeMutablePointer<UInt32>, _ offset: UnsafeMutablePointer<UInt32>) { 0559 return _clang_getExpansionLocation(location: location, file: file, line: line, column: column, offset: offset) 0560 } 0561 private let _clang_getExpansionLocation
created_Index.swift:531 : @convention(c) (location: CXSourceLocation, file: UnsafeMutablePointer<CXFile>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>, offset: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getExpansionLocation") 0562 0563 0564 /** 0565 * \brief Retrieve the file, line, column, and offset represented by 0566 * the given source location, as specified in a # line directive. 0567 * 0568 * Example: given the following source code in a file somefile.c 0569 * 0570 * \code 0571 * #123 "dummy.c" 1 0572 * 0573 * static int func(void) 0574 * { 0575 * return 0; 0576 * } 0577 * \endcode 0578 * 0579 * the location information returned by this function would be 0580 * 0581 * File: dummy.c Line: 124 Column: 12 0582 * 0583 * whereas clang_getExpansionLocation would have returned 0584 * 0585 * File: somefile.c Line: 3 Column: 12 0586 * 0587 * \param location the location within a source file that will be decomposed 0588 * into its parts. 0589 * 0590 * \param filename [out] if non-NULL, will be set to the filename of the 0591 * source location. Note that filenames returned will be for "virtual" files, 0592 * which don't necessarily exist on the machine running clang - e.g. when 0593 * parsing preprocessed output obtained from a different environment. If 0594 * a non-NULL value is passed in, remember to dispose of the returned value 0595 * using \c clang_disposeString() once you've finished with it. For an invalid 0596 * source location, an empty string is returned. 0597 * 0598 * \param line [out] if non-NULL, will be set to the line number of the 0599 * source location. For an invalid source location, zero is returned. 0600 * 0601 * \param column [out] if non-NULL, will be set to the column number of the 0602 * source location. For an invalid source location, zero is returned. 0603 */ 0604 public func clang_getPresumedLocation(location: CXSourceLocation, _ filename: UnsafeMutablePointer<CXString>, _ line: UnsafeMutablePointer<UInt32>, _ column: UnsafeMutablePointer<UInt32>) { 0605 return _clang_getPresumedLocation(location: location, filename: filename, line: line, column: column) 0606 } 0607 private let _clang_getPresumedLocation
created_Index.swift:559 : @convention(c) (location: CXSourceLocation, filename: UnsafeMutablePointer<CXString>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getPresumedLocation") 0608 0609 0610 /** 0611 * \brief Legacy API to retrieve the file, line, column, and offset represented 0612 * by the given source location. 0613 * 0614 * This interface has been replaced by the newer interface 0615 * #clang_getExpansionLocation(). See that interface's documentation for 0616 * details. 0617 */ 0618 public func clang_getInstantiationLocation(location: CXSourceLocation, _ file: UnsafeMutablePointer<CXFile>, _ line: UnsafeMutablePointer<UInt32>, _ column: UnsafeMutablePointer<UInt32>, _ offset: UnsafeMutablePointer<UInt32>) { 0619 return _clang_getInstantiationLocation(location: location, file: file, line: line, column: column, offset: offset) 0620 } 0621 private let _clang_getInstantiationLocation
created_Index.swift:605 : @convention(c) (location: CXSourceLocation, file: UnsafeMutablePointer<CXFile>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>, offset: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getInstantiationLocation") 0622 0623 0624 /** 0625 * \brief Retrieve the file, line, column, and offset represented by 0626 * the given source location. 0627 * 0628 * If the location refers into a macro instantiation, return where the 0629 * location was originally spelled in the source file. 0630 * 0631 * \param location the location within a source file that will be decomposed 0632 * into its parts. 0633 * 0634 * \param file [out] if non-NULL, will be set to the file to which the given 0635 * source location points. 0636 * 0637 * \param line [out] if non-NULL, will be set to the line to which the given 0638 * source location points. 0639 * 0640 * \param column [out] if non-NULL, will be set to the column to which the given 0641 * source location points. 0642 * 0643 * \param offset [out] if non-NULL, will be set to the offset into the 0644 * buffer to which the given source location points. 0645 */ 0646 public func clang_getSpellingLocation
created_Index.swift:619 (location: CXSourceLocation, _ file: UnsafeMutablePointer<CXFile>, _ line: UnsafeMutablePointer<UInt32>, _ column: UnsafeMutablePointer<UInt32>, _ offset: UnsafeMutablePointer<UInt32>) { 0647 return _clang_getSpellingLocation(location: location, file: file, line: line, column: column, offset: offset) 0648 } 0649 private let _clang_getSpellingLocation
SourceLocation.swift:31 : @convention(c) (location: CXSourceLocation, file: UnsafeMutablePointer<CXFile>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>, offset: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getSpellingLocation") 0650 0651 0652 /** 0653 * \brief Retrieve the file, line, column, and offset represented by 0654 * the given source location. 0655 * 0656 * If the location refers into a macro expansion, return where the macro was 0657 * expanded or where the macro argument was written, if the location points at 0658 * a macro argument. 0659 * 0660 * \param location the location within a source file that will be decomposed 0661 * into its parts. 0662 * 0663 * \param file [out] if non-NULL, will be set to the file to which the given 0664 * source location points. 0665 * 0666 * \param line [out] if non-NULL, will be set to the line to which the given 0667 * source location points. 0668 * 0669 * \param column [out] if non-NULL, will be set to the column to which the given 0670 * source location points. 0671 * 0672 * \param offset [out] if non-NULL, will be set to the offset into the 0673 * buffer to which the given source location points. 0674 */ 0675 public func clang_getFileLocation(location: CXSourceLocation, _ file: UnsafeMutablePointer<CXFile>, _ line: UnsafeMutablePointer<UInt32>, _ column: UnsafeMutablePointer<UInt32>, _ offset: UnsafeMutablePointer<UInt32>) { 0676 return _clang_getFileLocation(location: location, file: file, line: line, column: column, offset: offset) 0677 } 0678 private let _clang_getFileLocation
created_Index.swift:647 : @convention(c) (location: CXSourceLocation, file: UnsafeMutablePointer<CXFile>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>, offset: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getFileLocation") 0679 0680 0681 /** 0682 * \brief Retrieve a source location representing the first character within a 0683 * source range. 0684 */ 0685 public func clang_getRangeStart
created_Index.swift:676 (range: CXSourceRange) -> CXSourceLocation { 0686 return _clang_getRangeStart(range: range) 0687 } 0688 private let _clang_getRangeStart
Clang+SourceKitten.swift:51 : @convention(c) (range: CXSourceRange) -> CXSourceLocation = library.loadSymbol("clang_getRangeStart") 0689 0690 0691 /** 0692 * \brief Retrieve a source location representing the last character within a 0693 * source range. 0694 */ 0695 public func clang_getRangeEnd
created_Index.swift:686 (range: CXSourceRange) -> CXSourceLocation { 0696 return _clang_getRangeEnd(range: range) 0697 } 0698 private let _clang_getRangeEnd
Clang+SourceKitten.swift:52 : @convention(c) (range: CXSourceRange) -> CXSourceLocation = library.loadSymbol("clang_getRangeEnd") 0699 0700 0701 /** 0702 * \brief Identifies an array of ranges. 0703 */ 0704 /* 0705 public struct CXSourceRangeList { 0706 /** \brief The number of ranges in the \c ranges array. */ 0707 // public var count: UInt32 0708 /** 0709 * \brief An array of \c CXSourceRanges. 0710 */ 0711 // public var ranges: UnsafeMutablePointer<CXSourceRange> 0712 public init() 0713 public init(count: UInt32, ranges: UnsafeMutablePointer<CXSourceRange>) 0714 } 0715 */ 0716 0717 /** 0718 * \brief Retrieve all ranges that were skipped by the preprocessor. 0719 * 0720 * The preprocessor will skip lines when they are surrounded by an 0721 * if/ifdef/ifndef directive whose condition does not evaluate to true. 0722 */ 0723 public func clang_getSkippedRanges(tu: CXTranslationUnit, _ file: CXFile) -> UnsafeMutablePointer<CXSourceRangeList> { 0724 return _clang_getSkippedRanges(tu: tu, file: file) 0725 } 0726 private let _clang_getSkippedRanges
created_Index.swift:696 : @convention(c) (tu: CXTranslationUnit, file: CXFile) -> UnsafeMutablePointer<CXSourceRangeList> = library.loadSymbol("clang_getSkippedRanges") 0727 0728 0729 /** 0730 * \brief Destroy the given \c CXSourceRangeList. 0731 */ 0732 public func clang_disposeSourceRangeList(ranges: UnsafeMutablePointer<CXSourceRangeList>) { 0733 return _clang_disposeSourceRangeList(ranges: ranges) 0734 } 0735 private let _clang_disposeSourceRangeList
created_Index.swift:724 : @convention(c) (ranges: UnsafeMutablePointer<CXSourceRangeList>) -> () = library.loadSymbol("clang_disposeSourceRangeList") 0736 0737 0738 /** 0739 * @} 0740 */ 0741 0742 /** 0743 * \defgroup CINDEX_DIAG Diagnostic reporting 0744 * 0745 * @{ 0746 */ 0747 0748 /** 0749 * \brief Describes the severity of a particular diagnostic. 0750 */ 0751 /* 0752 public struct CXDiagnosticSeverity : RawRepresentable, Equatable { 0753 public init(_ rawValue: UInt32) 0754 public init(rawValue: UInt32) 0755 // public var rawValue: UInt32 0756 } 0757 */ 0758 0759 /** 0760 * \brief A diagnostic that has been suppressed, e.g., by a command-line 0761 * option. 0762 */ 0763 // public var CXDiagnostic_Ignored: CXDiagnosticSeverity { get } 0764 0765 /** 0766 * \brief This diagnostic is a note that should be attached to the 0767 * previous (non-note) diagnostic. 0768 */ 0769 // public var CXDiagnostic_Note: CXDiagnosticSeverity { get } 0770 0771 /** 0772 * \brief This diagnostic indicates suspicious code that may not be 0773 * wrong. 0774 */ 0775 // public var CXDiagnostic_Warning: CXDiagnosticSeverity { get } 0776 0777 /** 0778 * \brief This diagnostic indicates that the code is ill-formed. 0779 */ 0780 // public var CXDiagnostic_Error: CXDiagnosticSeverity { get } 0781 0782 /** 0783 * \brief This diagnostic indicates that the code is ill-formed such 0784 * that future parser recovery is unlikely to produce useful 0785 * results. 0786 */ 0787 // public var CXDiagnostic_Fatal: CXDiagnosticSeverity { get } 0788 0789 /** 0790 * \brief A single diagnostic, containing the diagnostic's severity, 0791 * location, text, source ranges, and fix-it hints. 0792 */ 0793 // public typealias CXDiagnostic = UnsafeMutablePointer<Void> 0794 0795 /** 0796 * \brief A group of CXDiagnostics. 0797 */ 0798 // public typealias CXDiagnosticSet = UnsafeMutablePointer<Void> 0799 0800 /** 0801 * \brief Determine the number of diagnostics in a CXDiagnosticSet. 0802 */ 0803 public func clang_getNumDiagnosticsInSet(Diags: CXDiagnosticSet) -> UInt32 { 0804 return _clang_getNumDiagnosticsInSet(Diags: Diags) 0805 } 0806 private let _clang_getNumDiagnosticsInSet
created_Index.swift:733 : @convention(c) (Diags: CXDiagnosticSet) -> UInt32 = library.loadSymbol("clang_getNumDiagnosticsInSet") 0807 0808 0809 /** 0810 * \brief Retrieve a diagnostic associated with the given CXDiagnosticSet. 0811 * 0812 * \param Diags the CXDiagnosticSet to query. 0813 * \param Index the zero-based diagnostic number to retrieve. 0814 * 0815 * \returns the requested diagnostic. This diagnostic must be freed 0816 * via a call to \c clang_disposeDiagnostic(). 0817 */ 0818 public func clang_getDiagnosticInSet(Diags: CXDiagnosticSet, _ Index: UInt32) -> CXDiagnostic { 0819 return _clang_getDiagnosticInSet(Diags: Diags, Index: Index) 0820 } 0821 private let _clang_getDiagnosticInSet
created_Index.swift:804 : @convention(c) (Diags: CXDiagnosticSet, Index: UInt32) -> CXDiagnostic = library.loadSymbol("clang_getDiagnosticInSet") 0822 0823 0824 /** 0825 * \brief Describes the kind of error that occurred (if any) in a call to 0826 * \c clang_loadDiagnostics. 0827 */ 0828 /* 0829 public struct CXLoadDiag_Error : RawRepresentable, Equatable { 0830 public init(_ rawValue: UInt32) 0831 public init(rawValue: UInt32) 0832 // public var rawValue: UInt32 0833 } 0834 */ 0835 0836 /** 0837 * \brief Indicates that no error occurred. 0838 */ 0839 // public var CXLoadDiag_None: CXLoadDiag_Error { get } 0840 0841 /** 0842 * \brief Indicates that an unknown error occurred while attempting to 0843 * deserialize diagnostics. 0844 */ 0845 // public var CXLoadDiag_Unknown: CXLoadDiag_Error { get } 0846 0847 /** 0848 * \brief Indicates that the file containing the serialized diagnostics 0849 * could not be opened. 0850 */ 0851 // public var CXLoadDiag_CannotLoad: CXLoadDiag_Error { get } 0852 0853 /** 0854 * \brief Indicates that the serialized diagnostics file is invalid or 0855 * corrupt. 0856 */ 0857 // public var CXLoadDiag_InvalidFile: CXLoadDiag_Error { get } 0858 0859 /** 0860 * \brief Deserialize a set of diagnostics from a Clang diagnostics bitcode 0861 * file. 0862 * 0863 * \param file The name of the file to deserialize. 0864 * \param error A pointer to a enum value recording if there was a problem 0865 * deserializing the diagnostics. 0866 * \param errorString A pointer to a CXString for recording the error string 0867 * if the file was not successfully loaded. 0868 * 0869 * \returns A loaded CXDiagnosticSet if successful, and NULL otherwise. These 0870 * diagnostics should be released using clang_disposeDiagnosticSet(). 0871 */ 0872 public func clang_loadDiagnostics(file: UnsafePointer<Int8>, _ error: UnsafeMutablePointer<CXLoadDiag_Error>, _ errorString: UnsafeMutablePointer<CXString>) -> CXDiagnosticSet { 0873 return _clang_loadDiagnostics(file: file, error: error, errorString: errorString) 0874 } 0875 private let _clang_loadDiagnostics
created_Index.swift:819 : @convention(c) (file: UnsafePointer<Int8>, error: UnsafeMutablePointer<CXLoadDiag_Error>, errorString: UnsafeMutablePointer<CXString>) -> CXDiagnosticSet = library.loadSymbol("clang_loadDiagnostics") 0876 0877 0878 /** 0879 * \brief Release a CXDiagnosticSet and all of its contained diagnostics. 0880 */ 0881 public func clang_disposeDiagnosticSet(Diags: CXDiagnosticSet) { 0882 return _clang_disposeDiagnosticSet(Diags: Diags) 0883 } 0884 private let _clang_disposeDiagnosticSet
created_Index.swift:873 : @convention(c) (Diags: CXDiagnosticSet) -> () = library.loadSymbol("clang_disposeDiagnosticSet") 0885 0886 0887 /** 0888 * \brief Retrieve the child diagnostics of a CXDiagnostic. 0889 * 0890 * This CXDiagnosticSet does not need to be released by 0891 * clang_disposeDiagnosticSet. 0892 */ 0893 public func clang_getChildDiagnostics(D: CXDiagnostic) -> CXDiagnosticSet { 0894 return _clang_getChildDiagnostics(D: D) 0895 } 0896 private let _clang_getChildDiagnostics
created_Index.swift:882 : @convention(c) (D: CXDiagnostic) -> CXDiagnosticSet = library.loadSymbol("clang_getChildDiagnostics") 0897 0898 0899 /** 0900 * \brief Determine the number of diagnostics produced for the given 0901 * translation unit. 0902 */ 0903 public func clang_getNumDiagnostics(Unit: CXTranslationUnit) -> UInt32 { 0904 return _clang_getNumDiagnostics(Unit: Unit) 0905 } 0906 private let _clang_getNumDiagnostics
created_Index.swift:894 : @convention(c) (Unit: CXTranslationUnit) -> UInt32 = library.loadSymbol("clang_getNumDiagnostics") 0907 0908 0909 /** 0910 * \brief Retrieve a diagnostic associated with the given translation unit. 0911 * 0912 * \param Unit the translation unit to query. 0913 * \param Index the zero-based diagnostic number to retrieve. 0914 * 0915 * \returns the requested diagnostic. This diagnostic must be freed 0916 * via a call to \c clang_disposeDiagnostic(). 0917 */ 0918 public func clang_getDiagnostic(Unit: CXTranslationUnit, _ Index: UInt32) -> CXDiagnostic { 0919 return _clang_getDiagnostic(Unit: Unit, Index: Index) 0920 } 0921 private let _clang_getDiagnostic
created_Index.swift:904 : @convention(c) (Unit: CXTranslationUnit, Index: UInt32) -> CXDiagnostic = library.loadSymbol("clang_getDiagnostic") 0922 0923 0924 /** 0925 * \brief Retrieve the complete set of diagnostics associated with a 0926 * translation unit. 0927 * 0928 * \param Unit the translation unit to query. 0929 */ 0930 public func clang_getDiagnosticSetFromTU(Unit: CXTranslationUnit) -> CXDiagnosticSet { 0931 return _clang_getDiagnosticSetFromTU(Unit: Unit) 0932 } 0933 private let _clang_getDiagnosticSetFromTU
created_Index.swift:919 : @convention(c) (Unit: CXTranslationUnit) -> CXDiagnosticSet = library.loadSymbol("clang_getDiagnosticSetFromTU") 0934 0935 0936 /** 0937 * \brief Destroy a diagnostic. 0938 */ 0939 public func clang_disposeDiagnostic(Diagnostic: CXDiagnostic) { 0940 return _clang_disposeDiagnostic(Diagnostic: Diagnostic) 0941 } 0942 private let _clang_disposeDiagnostic
created_Index.swift:931 : @convention(c) (Diagnostic: CXDiagnostic) -> () = library.loadSymbol("clang_disposeDiagnostic") 0943 0944 0945 /** 0946 * \brief Options to control the display of diagnostics. 0947 * 0948 * The values in this enum are meant to be combined to customize the 0949 * behavior of \c clang_formatDiagnostic(). 0950 */ 0951 /* 0952 public struct CXDiagnosticDisplayOptions : RawRepresentable, Equatable { 0953 public init(_ rawValue: UInt32) 0954 public init(rawValue: UInt32) 0955 // public var rawValue: UInt32 0956 } 0957 */ 0958 0959 /** 0960 * \brief Display the source-location information where the 0961 * diagnostic was located. 0962 * 0963 * When set, diagnostics will be prefixed by the file, line, and 0964 * (optionally) column to which the diagnostic refers. For example, 0965 * 0966 * \code 0967 * test.c:28: warning: extra tokens at end of #endif directive 0968 * \endcode 0969 * 0970 * This option corresponds to the clang flag \c -fshow-source-location. 0971 */ 0972 // public var CXDiagnostic_DisplaySourceLocation: CXDiagnosticDisplayOptions { get } 0973 0974 /** 0975 * \brief If displaying the source-location information of the 0976 * diagnostic, also include the column number. 0977 * 0978 * This option corresponds to the clang flag \c -fshow-column. 0979 */ 0980 // public var CXDiagnostic_DisplayColumn: CXDiagnosticDisplayOptions { get } 0981 0982 /** 0983 * \brief If displaying the source-location information of the 0984 * diagnostic, also include information about source ranges in a 0985 * machine-parsable format. 0986 * 0987 * This option corresponds to the clang flag 0988 * \c -fdiagnostics-print-source-range-info. 0989 */ 0990 // public var CXDiagnostic_DisplaySourceRanges: CXDiagnosticDisplayOptions { get } 0991 0992 /** 0993 * \brief Display the option name associated with this diagnostic, if any. 0994 * 0995 * The option name displayed (e.g., -Wconversion) will be placed in brackets 0996 * after the diagnostic text. This option corresponds to the clang flag 0997 * \c -fdiagnostics-show-option. 0998 */ 0999 // public var CXDiagnostic_DisplayOption: CXDiagnosticDisplayOptions { get } 1000 1001 /** 1002 * \brief Display the category number associated with this diagnostic, if any. 1003 * 1004 * The category number is displayed within brackets after the diagnostic text. 1005 * This option corresponds to the clang flag 1006 * \c -fdiagnostics-show-category=id. 1007 */ 1008 // public var CXDiagnostic_DisplayCategoryId: CXDiagnosticDisplayOptions { get } 1009 1010 /** 1011 * \brief Display the category name associated with this diagnostic, if any. 1012 * 1013 * The category name is displayed within brackets after the diagnostic text. 1014 * This option corresponds to the clang flag 1015 * \c -fdiagnostics-show-category=name. 1016 */ 1017 // public var CXDiagnostic_DisplayCategoryName: CXDiagnosticDisplayOptions { get } 1018 1019 /** 1020 * \brief Format the given diagnostic in a manner that is suitable for display. 1021 * 1022 * This routine will format the given diagnostic to a string, rendering 1023 * the diagnostic according to the various options given. The 1024 * \c clang_defaultDiagnosticDisplayOptions() function returns the set of 1025 * options that most closely mimics the behavior of the clang compiler. 1026 * 1027 * \param Diagnostic The diagnostic to print. 1028 * 1029 * \param Options A set of options that control the diagnostic display, 1030 * created by combining \c CXDiagnosticDisplayOptions values. 1031 * 1032 * \returns A new string containing for formatted diagnostic. 1033 */ 1034 public func clang_formatDiagnostic(Diagnostic: CXDiagnostic, _ Options: UInt32) -> CXString { 1035 return _clang_formatDiagnostic(Diagnostic: Diagnostic, Options: Options) 1036 } 1037 private let _clang_formatDiagnostic
created_Index.swift:940 : @convention(c) (Diagnostic: CXDiagnostic, Options: UInt32) -> CXString = library.loadSymbol("clang_formatDiagnostic") 1038 1039 1040 /** 1041 * \brief Retrieve the set of display options most similar to the 1042 * default behavior of the clang compiler. 1043 * 1044 * \returns A set of display options suitable for use with \c 1045 * clang_formatDiagnostic(). 1046 */ 1047 public func clang_defaultDiagnosticDisplayOptions() -> UInt32 { 1048 return _clang_defaultDiagnosticDisplayOptions() 1049 } 1050 private let _clang_defaultDiagnosticDisplayOptions
created_Index.swift:1035 : @convention(c) () -> UInt32 = library.loadSymbol("clang_defaultDiagnosticDisplayOptions") 1051 1052 1053 /** 1054 * \brief Determine the severity of the given diagnostic. 1055 */ 1056 public func clang_getDiagnosticSeverity(unnamed1: CXDiagnostic) -> CXDiagnosticSeverity { 1057 return _clang_getDiagnosticSeverity(unnamed1) 1058 } 1059 private let _clang_getDiagnosticSeverity
created_Index.swift:1048 : @convention(c) (_: CXDiagnostic) -> CXDiagnosticSeverity = library.loadSymbol("clang_getDiagnosticSeverity") 1060 1061 1062 /** 1063 * \brief Retrieve the source location of the given diagnostic. 1064 * 1065 * This location is where Clang would print the caret ('^') when 1066 * displaying the diagnostic on the command line. 1067 */ 1068 public func clang_getDiagnosticLocation(unnamed1: CXDiagnostic) -> CXSourceLocation { 1069 return _clang_getDiagnosticLocation(unnamed1) 1070 } 1071 private let _clang_getDiagnosticLocation
created_Index.swift:1057 : @convention(c) (_: CXDiagnostic) -> CXSourceLocation = library.loadSymbol("clang_getDiagnosticLocation") 1072 1073 1074 /** 1075 * \brief Retrieve the text of the given diagnostic. 1076 */ 1077 public func clang_getDiagnosticSpelling(unnamed1: CXDiagnostic) -> CXString { 1078 return _clang_getDiagnosticSpelling(unnamed1) 1079 } 1080 private let _clang_getDiagnosticSpelling
created_Index.swift:1069 : @convention(c) (_: CXDiagnostic) -> CXString = library.loadSymbol("clang_getDiagnosticSpelling") 1081 1082 1083 /** 1084 * \brief Retrieve the name of the command-line option that enabled this 1085 * diagnostic. 1086 * 1087 * \param Diag The diagnostic to be queried. 1088 * 1089 * \param Disable If non-NULL, will be set to the option that disables this 1090 * diagnostic (if any). 1091 * 1092 * \returns A string that contains the command-line option used to enable this 1093 * warning, such as "-Wconversion" or "-pedantic". 1094 */ 1095 public func clang_getDiagnosticOption(Diag: CXDiagnostic, _ Disable: UnsafeMutablePointer<CXString>) -> CXString { 1096 return _clang_getDiagnosticOption(Diag: Diag, Disable: Disable) 1097 } 1098 private let _clang_getDiagnosticOption
created_Index.swift:1078 : @convention(c) (Diag: CXDiagnostic, Disable: UnsafeMutablePointer<CXString>) -> CXString = library.loadSymbol("clang_getDiagnosticOption") 1099 1100 1101 /** 1102 * \brief Retrieve the category number for this diagnostic. 1103 * 1104 * Diagnostics can be categorized into groups along with other, related 1105 * diagnostics (e.g., diagnostics under the same warning flag). This routine 1106 * retrieves the category number for the given diagnostic. 1107 * 1108 * \returns The number of the category that contains this diagnostic, or zero 1109 * if this diagnostic is uncategorized. 1110 */ 1111 public func clang_getDiagnosticCategory(unnamed1: CXDiagnostic) -> UInt32 { 1112 return _clang_getDiagnosticCategory(unnamed1) 1113 } 1114 private let _clang_getDiagnosticCategory
created_Index.swift:1096 : @convention(c) (_: CXDiagnostic) -> UInt32 = library.loadSymbol("clang_getDiagnosticCategory") 1115 1116 1117 /** 1118 * \brief Retrieve the name of a particular diagnostic category. This 1119 * is now deprecated. Use clang_getDiagnosticCategoryText() 1120 * instead. 1121 * 1122 * \param Category A diagnostic category number, as returned by 1123 * \c clang_getDiagnosticCategory(). 1124 * 1125 * \returns The name of the given diagnostic category. 1126 */ 1127 @available(*, deprecated) 1128 public func clang_getDiagnosticCategoryName(Category: UInt32) -> CXString { 1129 return _clang_getDiagnosticCategoryName(Category: Category) 1130 } 1131 private let _clang_getDiagnosticCategoryName
created_Index.swift:1112 : @convention(c) (Category: UInt32) -> CXString = library.loadSymbol("clang_getDiagnosticCategoryName") 1132 1133 1134 /** 1135 * \brief Retrieve the diagnostic category text for a given diagnostic. 1136 * 1137 * \returns The text of the given diagnostic category. 1138 */ 1139 public func clang_getDiagnosticCategoryText(unnamed1: CXDiagnostic) -> CXString { 1140 return _clang_getDiagnosticCategoryText(unnamed1) 1141 } 1142 private let _clang_getDiagnosticCategoryText
created_Index.swift:1129 : @convention(c) (_: CXDiagnostic) -> CXString = library.loadSymbol("clang_getDiagnosticCategoryText") 1143 1144 1145 /** 1146 * \brief Determine the number of source ranges associated with the given 1147 * diagnostic. 1148 */ 1149 public func clang_getDiagnosticNumRanges(unnamed1: CXDiagnostic) -> UInt32 { 1150 return _clang_getDiagnosticNumRanges(unnamed1) 1151 } 1152 private let _clang_getDiagnosticNumRanges
created_Index.swift:1140 : @convention(c) (_: CXDiagnostic) -> UInt32 = library.loadSymbol("clang_getDiagnosticNumRanges") 1153 1154 1155 /** 1156 * \brief Retrieve a source range associated with the diagnostic. 1157 * 1158 * A diagnostic's source ranges highlight important elements in the source 1159 * code. On the command line, Clang displays source ranges by 1160 * underlining them with '~' characters. 1161 * 1162 * \param Diagnostic the diagnostic whose range is being extracted. 1163 * 1164 * \param Range the zero-based index specifying which range to 1165 * 1166 * \returns the requested source range. 1167 */ 1168 public func clang_getDiagnosticRange(Diagnostic: CXDiagnostic, _ Range: UInt32) -> CXSourceRange { 1169 return _clang_getDiagnosticRange(Diagnostic: Diagnostic, Range: Range) 1170 } 1171 private let _clang_getDiagnosticRange
created_Index.swift:1150 : @convention(c) (Diagnostic: CXDiagnostic, Range: UInt32) -> CXSourceRange = library.loadSymbol("clang_getDiagnosticRange") 1172 1173 1174 /** 1175 * \brief Determine the number of fix-it hints associated with the 1176 * given diagnostic. 1177 */ 1178 public func clang_getDiagnosticNumFixIts(Diagnostic: CXDiagnostic) -> UInt32 { 1179 return _clang_getDiagnosticNumFixIts(Diagnostic: Diagnostic) 1180 } 1181 private let _clang_getDiagnosticNumFixIts
created_Index.swift:1169 : @convention(c) (Diagnostic: CXDiagnostic) -> UInt32 = library.loadSymbol("clang_getDiagnosticNumFixIts") 1182 1183 1184 /** 1185 * \brief Retrieve the replacement information for a given fix-it. 1186 * 1187 * Fix-its are described in terms of a source range whose contents 1188 * should be replaced by a string. This approach generalizes over 1189 * three kinds of operations: removal of source code (the range covers 1190 * the code to be removed and the replacement string is empty), 1191 * replacement of source code (the range covers the code to be 1192 * replaced and the replacement string provides the new code), and 1193 * insertion (both the start and end of the range point at the 1194 * insertion location, and the replacement string provides the text to 1195 * insert). 1196 * 1197 * \param Diagnostic The diagnostic whose fix-its are being queried. 1198 * 1199 * \param FixIt The zero-based index of the fix-it. 1200 * 1201 * \param ReplacementRange The source range whose contents will be 1202 * replaced with the returned replacement string. Note that source 1203 * ranges are half-open ranges [a, b), so the source code should be 1204 * replaced from a and up to (but not including) b. 1205 * 1206 * \returns A string containing text that should be replace the source 1207 * code indicated by the \c ReplacementRange. 1208 */ 1209 public func clang_getDiagnosticFixIt(Diagnostic: CXDiagnostic, _ FixIt: UInt32, _ ReplacementRange: UnsafeMutablePointer<CXSourceRange>) -> CXString { 1210 return _clang_getDiagnosticFixIt(Diagnostic: Diagnostic, FixIt: FixIt, ReplacementRange: ReplacementRange) 1211 } 1212 private let _clang_getDiagnosticFixIt
created_Index.swift:1179 : @convention(c) (Diagnostic: CXDiagnostic, FixIt: UInt32, ReplacementRange: UnsafeMutablePointer<CXSourceRange>) -> CXString = library.loadSymbol("clang_getDiagnosticFixIt") 1213 1214 1215 /** 1216 * @} 1217 */ 1218 1219 /** 1220 * \defgroup CINDEX_TRANSLATION_UNIT Translation unit manipulation 1221 * 1222 * The routines in this group provide the ability to create and destroy 1223 * translation units from files, either by parsing the contents of the files or 1224 * by reading in a serialized representation of a translation unit. 1225 * 1226 * @{ 1227 */ 1228 1229 /** 1230 * \brief Get the original translation unit source file name. 1231 */ 1232 public func clang_getTranslationUnitSpelling(CTUnit: CXTranslationUnit) -> CXString { 1233 return _clang_getTranslationUnitSpelling(CTUnit: CTUnit) 1234 } 1235 private let _clang_getTranslationUnitSpelling
created_Index.swift:1210 : @convention(c) (CTUnit: CXTranslationUnit) -> CXString = library.loadSymbol("clang_getTranslationUnitSpelling") 1236 1237 1238 /** 1239 * \brief Return the CXTranslationUnit for a given source file and the provided 1240 * command line arguments one would pass to the compiler. 1241 * 1242 * Note: The 'source_filename' argument is optional. If the caller provides a 1243 * NULL pointer, the name of the source file is expected to reside in the 1244 * specified command line arguments. 1245 * 1246 * Note: When encountered in 'clang_command_line_args', the following options 1247 * are ignored: 1248 * 1249 * '-c' 1250 * '-emit-ast' 1251 * '-fsyntax-only' 1252 * '-o \<output file>' (both '-o' and '\<output file>' are ignored) 1253 * 1254 * \param CIdx The index object with which the translation unit will be 1255 * associated. 1256 * 1257 * \param source_filename The name of the source file to load, or NULL if the 1258 * source file is included in \p clang_command_line_args. 1259 * 1260 * \param num_clang_command_line_args The number of command-line arguments in 1261 * \p clang_command_line_args. 1262 * 1263 * \param clang_command_line_args The command-line arguments that would be 1264 * passed to the \c clang executable if it were being invoked out-of-process. 1265 * These command-line options will be parsed and will affect how the translation 1266 * unit is parsed. Note that the following options are ignored: '-c', 1267 * '-emit-ast', '-fsyntax-only' (which is the default), and '-o \<output file>'. 1268 * 1269 * \param num_unsaved_files the number of unsaved file entries in \p 1270 * unsaved_files. 1271 * 1272 * \param unsaved_files the files that have not yet been saved to disk 1273 * but may be required for code completion, including the contents of 1274 * those files. The contents and name of these files (as specified by 1275 * CXUnsavedFile) are copied when necessary, so the client only needs to 1276 * guarantee their validity until the call to this function returns. 1277 */ 1278 public func clang_createTranslationUnitFromSourceFile
created_Index.swift:1233 (CIdx: CXIndex, _ source_filename: UnsafePointer<Int8>, _ num_clang_command_line_args: Int32, _ clang_command_line_args: UnsafePointer<UnsafePointer<Int8>>, _ num_unsaved_files: UInt32, _ unsaved_files: UnsafeMutablePointer<CXUnsavedFile>) -> CXTranslationUnit { 1279 return _clang_createTranslationUnitFromSourceFile(CIdx: CIdx, source_filename: source_filename, num_clang_command_line_args: num_clang_command_line_args, clang_command_line_args: clang_command_line_args, num_unsaved_files: num_unsaved_files, unsaved_files: unsaved_files) 1280 } 1281 private let _clang_createTranslationUnitFromSourceFile
Clang+SourceKitten.swift:19 : @convention(c) (CIdx: CXIndex, source_filename: UnsafePointer<Int8>, num_clang_command_line_args: Int32, clang_command_line_args: UnsafePointer<UnsafePointer<Int8>>, num_unsaved_files: UInt32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>) -> CXTranslationUnit = library.loadSymbol("clang_createTranslationUnitFromSourceFile") 1282 1283 1284 /** 1285 * \brief Same as \c clang_createTranslationUnit2, but returns 1286 * the \c CXTranslationUnit instead of an error code. In case of an error this 1287 * routine returns a \c NULL \c CXTranslationUnit, without further detailed 1288 * error codes. 1289 */ 1290 public func clang_createTranslationUnit(CIdx: CXIndex, _ ast_filename: UnsafePointer<Int8>) -> CXTranslationUnit { 1291 return _clang_createTranslationUnit(CIdx: CIdx, ast_filename: ast_filename) 1292 } 1293 private let _clang_createTranslationUnit
created_Index.swift:1279 : @convention(c) (CIdx: CXIndex, ast_filename: UnsafePointer<Int8>) -> CXTranslationUnit = library.loadSymbol("clang_createTranslationUnit") 1294 1295 1296 /** 1297 * \brief Create a translation unit from an AST file (\c -emit-ast). 1298 * 1299 * \param[out] out_TU A non-NULL pointer to store the created 1300 * \c CXTranslationUnit. 1301 * 1302 * \returns Zero on success, otherwise returns an error code. 1303 */ 1304 public func clang_createTranslationUnit2(CIdx: CXIndex, _ ast_filename: UnsafePointer<Int8>, _ out_TU: UnsafeMutablePointer<CXTranslationUnit>) -> CXErrorCode { 1305 return _clang_createTranslationUnit2(CIdx: CIdx, ast_filename: ast_filename, out_TU: out_TU) 1306 } 1307 private let _clang_createTranslationUnit2
created_Index.swift:1291 : @convention(c) (CIdx: CXIndex, ast_filename: UnsafePointer<Int8>, out_TU: UnsafeMutablePointer<CXTranslationUnit>) -> CXErrorCode = library.loadSymbol("clang_createTranslationUnit2") 1308 1309 1310 /** 1311 * \brief Flags that control the creation of translation units. 1312 * 1313 * The enumerators in this enumeration type are meant to be bitwise 1314 * ORed together to specify which options should be used when 1315 * constructing the translation unit. 1316 */ 1317 /* 1318 public struct CXTranslationUnit_Flags : RawRepresentable, Equatable { 1319 public init(_ rawValue: UInt32) 1320 public init(rawValue: UInt32) 1321 // public var rawValue: UInt32 1322 } 1323 */ 1324 1325 /** 1326 * \brief Used to indicate that no special translation-unit options are 1327 * needed. 1328 */ 1329 // public var CXTranslationUnit_None: CXTranslationUnit_Flags { get } 1330 1331 /** 1332 * \brief Used to indicate that the parser should construct a "detailed" 1333 * preprocessing record, including all macro definitions and instantiations. 1334 * 1335 * Constructing a detailed preprocessing record requires more memory 1336 * and time to parse, since the information contained in the record 1337 * is usually not retained. However, it can be useful for 1338 * applications that require more detailed information about the 1339 * behavior of the preprocessor. 1340 */ 1341 // public var CXTranslationUnit_DetailedPreprocessingRecord: CXTranslationUnit_Flags { get } 1342 1343 /** 1344 * \brief Used to indicate that the translation unit is incomplete. 1345 * 1346 * When a translation unit is considered "incomplete", semantic 1347 * analysis that is typically performed at the end of the 1348 * translation unit will be suppressed. For example, this suppresses 1349 * the completion of tentative declarations in C and of 1350 * instantiation of implicitly-instantiation function templates in 1351 * C++. This option is typically used when parsing a header with the 1352 * intent of producing a precompiled header. 1353 */ 1354 // public var CXTranslationUnit_Incomplete: CXTranslationUnit_Flags { get } 1355 1356 /** 1357 * \brief Used to indicate that the translation unit should be built with an 1358 * implicit precompiled header for the preamble. 1359 * 1360 * An implicit precompiled header is used as an optimization when a 1361 * particular translation unit is likely to be reparsed many times 1362 * when the sources aren't changing that often. In this case, an 1363 * implicit precompiled header will be built containing all of the 1364 * initial includes at the top of the main file (what we refer to as 1365 * the "preamble" of the file). In subsequent parses, if the 1366 * preamble or the files in it have not changed, \c 1367 * clang_reparseTranslationUnit() will re-use the implicit 1368 * precompiled header to improve parsing performance. 1369 */ 1370 // public var CXTranslationUnit_PrecompiledPreamble: CXTranslationUnit_Flags { get } 1371 1372 /** 1373 * \brief Used to indicate that the translation unit should cache some 1374 * code-completion results with each reparse of the source file. 1375 * 1376 * Caching of code-completion results is a performance optimization that 1377 * introduces some overhead to reparsing but improves the performance of 1378 * code-completion operations. 1379 */ 1380 // public var CXTranslationUnit_CacheCompletionResults: CXTranslationUnit_Flags { get } 1381 1382 /** 1383 * \brief Used to indicate that the translation unit will be serialized with 1384 * \c clang_saveTranslationUnit. 1385 * 1386 * This option is typically used when parsing a header with the intent of 1387 * producing a precompiled header. 1388 */ 1389 // public var CXTranslationUnit_ForSerialization: CXTranslationUnit_Flags { get } 1390 1391 /** 1392 * \brief DEPRECATED: Enabled chained precompiled preambles in C++. 1393 * 1394 * Note: this is a *temporary* option that is available only while 1395 * we are testing C++ precompiled preamble support. It is deprecated. 1396 */ 1397 // public var CXTranslationUnit_CXXChainedPCH: CXTranslationUnit_Flags { get } 1398 1399 /** 1400 * \brief Used to indicate that function/method bodies should be skipped while 1401 * parsing. 1402 * 1403 * This option can be used to search for declarations/definitions while 1404 * ignoring the usages. 1405 */ 1406 // public var CXTranslationUnit_SkipFunctionBodies: CXTranslationUnit_Flags { get } 1407 1408 /** 1409 * \brief Used to indicate that brief documentation comments should be 1410 * included into the set of code completions returned from this translation 1411 * unit. 1412 */ 1413 // public var CXTranslationUnit_IncludeBriefCommentsInCodeCompletion: CXTranslationUnit_Flags { get } 1414 1415 /** 1416 * \brief Returns the set of flags that is suitable for parsing a translation 1417 * unit that is being edited. 1418 * 1419 * The set of flags returned provide options for \c clang_parseTranslationUnit() 1420 * to indicate that the translation unit is likely to be reparsed many times, 1421 * either explicitly (via \c clang_reparseTranslationUnit()) or implicitly 1422 * (e.g., by code completion (\c clang_codeCompletionAt())). The returned flag 1423 * set contains an unspecified set of optimizations (e.g., the precompiled 1424 * preamble) geared toward improving the performance of these routines. The 1425 * set of optimizations enabled may change from one version to the next. 1426 */ 1427 public func clang_defaultEditingTranslationUnitOptions() -> UInt32 { 1428 return _clang_defaultEditingTranslationUnitOptions() 1429 } 1430 private let _clang_defaultEditingTranslationUnitOptions
created_Index.swift:1305 : @convention(c) () -> UInt32 = library.loadSymbol("clang_defaultEditingTranslationUnitOptions") 1431 1432 1433 /** 1434 * \brief Same as \c clang_parseTranslationUnit2, but returns 1435 * the \c CXTranslationUnit instead of an error code. In case of an error this 1436 * routine returns a \c NULL \c CXTranslationUnit, without further detailed 1437 * error codes. 1438 */ 1439 public func clang_parseTranslationUnit(CIdx: CXIndex, _ source_filename: UnsafePointer<Int8>, _ command_line_args: UnsafePointer<UnsafePointer<Int8>>, _ num_command_line_args: Int32, _ unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, _ num_unsaved_files: UInt32, _ options: UInt32) -> CXTranslationUnit { 1440 return _clang_parseTranslationUnit(CIdx: CIdx, source_filename: source_filename, command_line_args: command_line_args, num_command_line_args: num_command_line_args, unsaved_files: unsaved_files, num_unsaved_files: num_unsaved_files, options: options) 1441 } 1442 private let _clang_parseTranslationUnit
created_Index.swift:1428 : @convention(c) (CIdx: CXIndex, source_filename: UnsafePointer<Int8>, command_line_args: UnsafePointer<UnsafePointer<Int8>>, num_command_line_args: Int32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, num_unsaved_files: UInt32, options: UInt32) -> CXTranslationUnit = library.loadSymbol("clang_parseTranslationUnit") 1443 1444 1445 /** 1446 * \brief Parse the given source file and the translation unit corresponding 1447 * to that file. 1448 * 1449 * This routine is the main entry point for the Clang C API, providing the 1450 * ability to parse a source file into a translation unit that can then be 1451 * queried by other functions in the API. This routine accepts a set of 1452 * command-line arguments so that the compilation can be configured in the same 1453 * way that the compiler is configured on the command line. 1454 * 1455 * \param CIdx The index object with which the translation unit will be 1456 * associated. 1457 * 1458 * \param source_filename The name of the source file to load, or NULL if the 1459 * source file is included in \c command_line_args. 1460 * 1461 * \param command_line_args The command-line arguments that would be 1462 * passed to the \c clang executable if it were being invoked out-of-process. 1463 * These command-line options will be parsed and will affect how the translation 1464 * unit is parsed. Note that the following options are ignored: '-c', 1465 * '-emit-ast', '-fsyntax-only' (which is the default), and '-o \<output file>'. 1466 * 1467 * \param num_command_line_args The number of command-line arguments in 1468 * \c command_line_args. 1469 * 1470 * \param unsaved_files the files that have not yet been saved to disk 1471 * but may be required for parsing, including the contents of 1472 * those files. The contents and name of these files (as specified by 1473 * CXUnsavedFile) are copied when necessary, so the client only needs to 1474 * guarantee their validity until the call to this function returns. 1475 * 1476 * \param num_unsaved_files the number of unsaved file entries in \p 1477 * unsaved_files. 1478 * 1479 * \param options A bitmask of options that affects how the translation unit 1480 * is managed but not its compilation. This should be a bitwise OR of the 1481 * CXTranslationUnit_XXX flags. 1482 * 1483 * \param[out] out_TU A non-NULL pointer to store the created 1484 * \c CXTranslationUnit, describing the parsed code and containing any 1485 * diagnostics produced by the compiler. 1486 * 1487 * \returns Zero on success, otherwise returns an error code. 1488 */ 1489 public func clang_parseTranslationUnit2(CIdx: CXIndex, _ source_filename: UnsafePointer<Int8>, _ command_line_args: UnsafePointer<UnsafePointer<Int8>>, _ num_command_line_args: Int32, _ unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, _ num_unsaved_files: UInt32, _ options: UInt32, _ out_TU: UnsafeMutablePointer<CXTranslationUnit>) -> CXErrorCode { 1490 return _clang_parseTranslationUnit2(CIdx: CIdx, source_filename: source_filename, command_line_args: command_line_args, num_command_line_args: num_command_line_args, unsaved_files: unsaved_files, num_unsaved_files: num_unsaved_files, options: options, out_TU: out_TU) 1491 } 1492 private let _clang_parseTranslationUnit2
created_Index.swift:1440 : @convention(c) (CIdx: CXIndex, source_filename: UnsafePointer<Int8>, command_line_args: UnsafePointer<UnsafePointer<Int8>>, num_command_line_args: Int32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, num_unsaved_files: UInt32, options: UInt32, out_TU: UnsafeMutablePointer<CXTranslationUnit>) -> CXErrorCode = library.loadSymbol("clang_parseTranslationUnit2") 1493 1494 1495 /** 1496 * \brief Flags that control how translation units are saved. 1497 * 1498 * The enumerators in this enumeration type are meant to be bitwise 1499 * ORed together to specify which options should be used when 1500 * saving the translation unit. 1501 */ 1502 /* 1503 public struct CXSaveTranslationUnit_Flags : RawRepresentable, Equatable { 1504 public init(_ rawValue: UInt32) 1505 public init(rawValue: UInt32) 1506 // public var rawValue: UInt32 1507 } 1508 */ 1509 1510 /** 1511 * \brief Used to indicate that no special saving options are needed. 1512 */ 1513 // public var CXSaveTranslationUnit_None: CXSaveTranslationUnit_Flags { get } 1514 1515 /** 1516 * \brief Returns the set of flags that is suitable for saving a translation 1517 * unit. 1518 * 1519 * The set of flags returned provide options for 1520 * \c clang_saveTranslationUnit() by default. The returned flag 1521 * set contains an unspecified set of options that save translation units with 1522 * the most commonly-requested data. 1523 */ 1524 public func clang_defaultSaveOptions(TU: CXTranslationUnit) -> UInt32 { 1525 return _clang_defaultSaveOptions(TU: TU) 1526 } 1527 private let _clang_defaultSaveOptions
created_Index.swift:1490 : @convention(c) (TU: CXTranslationUnit) -> UInt32 = library.loadSymbol("clang_defaultSaveOptions") 1528 1529 1530 /** 1531 * \brief Describes the kind of error that occurred (if any) in a call to 1532 * \c clang_saveTranslationUnit(). 1533 */ 1534 /* 1535 public struct CXSaveError : RawRepresentable, Equatable { 1536 public init(_ rawValue: UInt32) 1537 public init(rawValue: UInt32) 1538 // public var rawValue: UInt32 1539 } 1540 */ 1541 1542 /** 1543 * \brief Indicates that no error occurred while saving a translation unit. 1544 */ 1545 // public var CXSaveError_None: CXSaveError { get } 1546 1547 /** 1548 * \brief Indicates that an unknown error occurred while attempting to save 1549 * the file. 1550 * 1551 * This error typically indicates that file I/O failed when attempting to 1552 * write the file. 1553 */ 1554 // public var CXSaveError_Unknown: CXSaveError { get } 1555 1556 /** 1557 * \brief Indicates that errors during translation prevented this attempt 1558 * to save the translation unit. 1559 * 1560 * Errors that prevent the translation unit from being saved can be 1561 * extracted using \c clang_getNumDiagnostics() and \c clang_getDiagnostic(). 1562 */ 1563 // public var CXSaveError_TranslationErrors: CXSaveError { get } 1564 1565 /** 1566 * \brief Indicates that the translation unit to be saved was somehow 1567 * invalid (e.g., NULL). 1568 */ 1569 // public var CXSaveError_InvalidTU: CXSaveError { get } 1570 1571 /** 1572 * \brief Saves a translation unit into a serialized representation of 1573 * that translation unit on disk. 1574 * 1575 * Any translation unit that was parsed without error can be saved 1576 * into a file. The translation unit can then be deserialized into a 1577 * new \c CXTranslationUnit with \c clang_createTranslationUnit() or, 1578 * if it is an incomplete translation unit that corresponds to a 1579 * header, used as a precompiled header when parsing other translation 1580 * units. 1581 * 1582 * \param TU The translation unit to save. 1583 * 1584 * \param FileName The file to which the translation unit will be saved. 1585 * 1586 * \param options A bitmask of options that affects how the translation unit 1587 * is saved. This should be a bitwise OR of the 1588 * CXSaveTranslationUnit_XXX flags. 1589 * 1590 * \returns A value that will match one of the enumerators of the CXSaveError 1591 * enumeration. Zero (CXSaveError_None) indicates that the translation unit was 1592 * saved successfully, while a non-zero value indicates that a problem occurred. 1593 */ 1594 public func clang_saveTranslationUnit(TU: CXTranslationUnit, _ FileName: UnsafePointer<Int8>, _ options: UInt32) -> Int32 { 1595 return _clang_saveTranslationUnit(TU: TU, FileName: FileName, options: options) 1596 } 1597 private let _clang_saveTranslationUnit
created_Index.swift:1525 : @convention(c) (TU: CXTranslationUnit, FileName: UnsafePointer<Int8>, options: UInt32) -> Int32 = library.loadSymbol("clang_saveTranslationUnit") 1598 1599 1600 /** 1601 * \brief Destroy the specified CXTranslationUnit object. 1602 */ 1603 public func clang_disposeTranslationUnit(unnamed1: CXTranslationUnit) { 1604 return _clang_disposeTranslationUnit(unnamed1) 1605 } 1606 private let _clang_disposeTranslationUnit
created_Index.swift:1595 : @convention(c) (_: CXTranslationUnit) -> () = library.loadSymbol("clang_disposeTranslationUnit") 1607 1608 1609 /** 1610 * \brief Flags that control the reparsing of translation units. 1611 * 1612 * The enumerators in this enumeration type are meant to be bitwise 1613 * ORed together to specify which options should be used when 1614 * reparsing the translation unit. 1615 */ 1616 /* 1617 public struct CXReparse_Flags : RawRepresentable, Equatable { 1618 public init(_ rawValue: UInt32) 1619 public init(rawValue: UInt32) 1620 // public var rawValue: UInt32 1621 } 1622 */ 1623 1624 /** 1625 * \brief Used to indicate that no special reparsing options are needed. 1626 */ 1627 // public var CXReparse_None: CXReparse_Flags { get } 1628 1629 /** 1630 * \brief Returns the set of flags that is suitable for reparsing a translation 1631 * unit. 1632 * 1633 * The set of flags returned provide options for 1634 * \c clang_reparseTranslationUnit() by default. The returned flag 1635 * set contains an unspecified set of optimizations geared toward common uses 1636 * of reparsing. The set of optimizations enabled may change from one version 1637 * to the next. 1638 */ 1639 public func clang_defaultReparseOptions(TU: CXTranslationUnit) -> UInt32 { 1640 return _clang_defaultReparseOptions(TU: TU) 1641 } 1642 private let _clang_defaultReparseOptions
created_Index.swift:1604 : @convention(c) (TU: CXTranslationUnit) -> UInt32 = library.loadSymbol("clang_defaultReparseOptions") 1643 1644 1645 /** 1646 * \brief Reparse the source files that produced this translation unit. 1647 * 1648 * This routine can be used to re-parse the source files that originally 1649 * created the given translation unit, for example because those source files 1650 * have changed (either on disk or as passed via \p unsaved_files). The 1651 * source code will be reparsed with the same command-line options as it 1652 * was originally parsed. 1653 * 1654 * Reparsing a translation unit invalidates all cursors and source locations 1655 * that refer into that translation unit. This makes reparsing a translation 1656 * unit semantically equivalent to destroying the translation unit and then 1657 * creating a new translation unit with the same command-line arguments. 1658 * However, it may be more efficient to reparse a translation 1659 * unit using this routine. 1660 * 1661 * \param TU The translation unit whose contents will be re-parsed. The 1662 * translation unit must originally have been built with 1663 * \c clang_createTranslationUnitFromSourceFile(). 1664 * 1665 * \param num_unsaved_files The number of unsaved file entries in \p 1666 * unsaved_files. 1667 * 1668 * \param unsaved_files The files that have not yet been saved to disk 1669 * but may be required for parsing, including the contents of 1670 * those files. The contents and name of these files (as specified by 1671 * CXUnsavedFile) are copied when necessary, so the client only needs to 1672 * guarantee their validity until the call to this function returns. 1673 * 1674 * \param options A bitset of options composed of the flags in CXReparse_Flags. 1675 * The function \c clang_defaultReparseOptions() produces a default set of 1676 * options recommended for most uses, based on the translation unit. 1677 * 1678 * \returns 0 if the sources could be reparsed. A non-zero error code will be 1679 * returned if reparsing was impossible, such that the translation unit is 1680 * invalid. In such cases, the only valid call for \c TU is 1681 * \c clang_disposeTranslationUnit(TU). The error codes returned by this 1682 * routine are described by the \c CXErrorCode enum. 1683 */ 1684 public func clang_reparseTranslationUnit(TU: CXTranslationUnit, _ num_unsaved_files: UInt32, _ unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, _ options: UInt32) -> Int32 { 1685 return _clang_reparseTranslationUnit(TU: TU, num_unsaved_files: num_unsaved_files, unsaved_files: unsaved_files, options: options) 1686 } 1687 private let _clang_reparseTranslationUnit
created_Index.swift:1640 : @convention(c) (TU: CXTranslationUnit, num_unsaved_files: UInt32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, options: UInt32) -> Int32 = library.loadSymbol("clang_reparseTranslationUnit") 1688 1689 1690 /** 1691 * \brief Categorizes how memory is being used by a translation unit. 1692 */ 1693 /* 1694 public struct CXTUResourceUsageKind : RawRepresentable, Equatable { 1695 public init(_ rawValue: UInt32) 1696 public init(rawValue: UInt32) 1697 // public var rawValue: UInt32 1698 } 1699 */ 1700 // public var CXTUResourceUsage_AST: CXTUResourceUsageKind { get } 1701 // public var CXTUResourceUsage_Identifiers: CXTUResourceUsageKind { get } 1702 // public var CXTUResourceUsage_Selectors: CXTUResourceUsageKind { get } 1703 // public var CXTUResourceUsage_GlobalCompletionResults: CXTUResourceUsageKind { get } 1704 // public var CXTUResourceUsage_SourceManagerContentCache: CXTUResourceUsageKind { get } 1705 // public var CXTUResourceUsage_AST_SideTables: CXTUResourceUsageKind { get } 1706 // public var CXTUResourceUsage_SourceManager_Membuffer_Malloc: CXTUResourceUsageKind { get } 1707 // public var CXTUResourceUsage_SourceManager_Membuffer_MMap: CXTUResourceUsageKind { get } 1708 // public var CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc: CXTUResourceUsageKind { get } 1709 // public var CXTUResourceUsage_ExternalASTSource_Membuffer_MMap: CXTUResourceUsageKind { get } 1710 // public var CXTUResourceUsage_Preprocessor: CXTUResourceUsageKind { get } 1711 // public var CXTUResourceUsage_PreprocessingRecord: CXTUResourceUsageKind { get } 1712 // public var CXTUResourceUsage_SourceManager_DataStructures: CXTUResourceUsageKind { get } 1713 // public var CXTUResourceUsage_Preprocessor_HeaderSearch: CXTUResourceUsageKind { get } 1714 // public var CXTUResourceUsage_MEMORY_IN_BYTES_BEGIN: CXTUResourceUsageKind { get } 1715 // public var CXTUResourceUsage_MEMORY_IN_BYTES_END: CXTUResourceUsageKind { get } 1716 // public var CXTUResourceUsage_First: CXTUResourceUsageKind { get } 1717 // public var CXTUResourceUsage_Last: CXTUResourceUsageKind { get } 1718 1719 1720 /** 1721 * \brief Returns the human-readable null-terminated C string that represents 1722 * the name of the memory category. This string should never be freed. 1723 */ 1724 public func clang_getTUResourceUsageName(kind: CXTUResourceUsageKind) -> UnsafePointer<Int8> { 1725 return _clang_getTUResourceUsageName(kind: kind) 1726 } 1727 private let _clang_getTUResourceUsageName
created_Index.swift:1685 : @convention(c) (kind: CXTUResourceUsageKind) -> UnsafePointer<Int8> = library.loadSymbol("clang_getTUResourceUsageName") 1728 1729 1730 /* 1731 public struct CXTUResourceUsageEntry { 1732 /* \brief The memory usage category. */ 1733 // public var kind: CXTUResourceUsageKind 1734 /* \brief Amount of resources used. 1735 The units will depend on the resource kind. */ 1736 // public var amount: UInt 1737 public init() 1738 public init(kind: CXTUResourceUsageKind, amount: UInt) 1739 } 1740 */ 1741 1742 /** 1743 * \brief The memory usage of a CXTranslationUnit, broken into categories. 1744 */ 1745 /* 1746 public struct CXTUResourceUsage { 1747 /* \brief Private data member, used for queries. */ 1748 // public var data: UnsafeMutablePointer<Void> 1749 1750 /* \brief The number of entries in the 'entries' array. */ 1751 // public var numEntries: UInt32 1752 1753 /* \brief An array of key-value pairs, representing the breakdown of memory 1754 usage. */ 1755 // public var entries: UnsafeMutablePointer<CXTUResourceUsageEntry> 1756 public init() 1757 public init(data: UnsafeMutablePointer<Void>, numEntries: UInt32, entries: UnsafeMutablePointer<CXTUResourceUsageEntry>) 1758 } 1759 */ 1760 1761 /** 1762 * \brief Return the memory usage of a translation unit. This object 1763 * should be released with clang_disposeCXTUResourceUsage(). 1764 */ 1765 public func clang_getCXTUResourceUsage(TU: CXTranslationUnit) -> CXTUResourceUsage { 1766 return _clang_getCXTUResourceUsage(TU: TU) 1767 } 1768 private let _clang_getCXTUResourceUsage
created_Index.swift:1725 : @convention(c) (TU: CXTranslationUnit) -> CXTUResourceUsage = library.loadSymbol("clang_getCXTUResourceUsage") 1769 1770 1771 public func clang_disposeCXTUResourceUsage(usage: CXTUResourceUsage) { 1772 return _clang_disposeCXTUResourceUsage(usage: usage) 1773 } 1774 private let _clang_disposeCXTUResourceUsage
created_Index.swift:1766 : @convention(c) (usage: CXTUResourceUsage) -> () = library.loadSymbol("clang_disposeCXTUResourceUsage") 1775 1776 1777 /** 1778 * @} 1779 */ 1780 1781 /** 1782 * \brief Describes the kind of entity that a cursor refers to. 1783 */ 1784 /* 1785 public struct CXCursorKind : RawRepresentable, Equatable { 1786 public init(_ rawValue: UInt32) 1787 public init(rawValue: UInt32) 1788 // public var rawValue: UInt32 1789 } 1790 */ 1791 1792 /* Declarations */ 1793 /** 1794 * \brief A declaration whose specific kind is not exposed via this 1795 * interface. 1796 * 1797 * Unexposed declarations have the same operations as any other kind 1798 * of declaration; one can extract their location information, 1799 * spelling, find their definitions, etc. However, the specific kind 1800 * of the declaration is not reported. 1801 */ 1802 // public var CXCursor_UnexposedDecl: CXCursorKind { get } 1803 /** \brief A C or C++ struct. */ 1804 // public var CXCursor_StructDecl: CXCursorKind { get } 1805 /** \brief A C or C++ union. */ 1806 // public var CXCursor_UnionDecl: CXCursorKind { get } 1807 /** \brief A C++ class. */ 1808 // public var CXCursor_ClassDecl: CXCursorKind { get } 1809 /** \brief An enumeration. */ 1810 // public var CXCursor_EnumDecl: CXCursorKind { get } 1811 /** 1812 * \brief A field (in C) or non-static data member (in C++) in a 1813 * struct, union, or C++ class. 1814 */ 1815 // public var CXCursor_FieldDecl: CXCursorKind { get } 1816 /** \brief An enumerator constant. */ 1817 // public var CXCursor_EnumConstantDecl: CXCursorKind { get } 1818 /** \brief A function. */ 1819 // public var CXCursor_FunctionDecl: CXCursorKind { get } 1820 /** \brief A variable. */ 1821 // public var CXCursor_VarDecl: CXCursorKind { get } 1822 /** \brief A function or method parameter. */ 1823 // public var CXCursor_ParmDecl: CXCursorKind { get } 1824 /** \brief An Objective-C \@interface. */ 1825 // public var CXCursor_ObjCInterfaceDecl: CXCursorKind { get } 1826 /** \brief An Objective-C \@interface for a category. */ 1827 // public var CXCursor_ObjCCategoryDecl: CXCursorKind { get } 1828 /** \brief An Objective-C \@protocol declaration. */ 1829 // public var CXCursor_ObjCProtocolDecl: CXCursorKind { get } 1830 /** \brief An Objective-C \@property declaration. */ 1831 // public var CXCursor_ObjCPropertyDecl: CXCursorKind { get } 1832 /** \brief An Objective-C instance variable. */ 1833 // public var CXCursor_ObjCIvarDecl: CXCursorKind { get } 1834 /** \brief An Objective-C instance method. */ 1835 // public var CXCursor_ObjCInstanceMethodDecl: CXCursorKind { get } 1836 /** \brief An Objective-C class method. */ 1837 // public var CXCursor_ObjCClassMethodDecl: CXCursorKind { get } 1838 /** \brief An Objective-C \@implementation. */ 1839 // public var CXCursor_ObjCImplementationDecl: CXCursorKind { get } 1840 /** \brief An Objective-C \@implementation for a category. */ 1841 // public var CXCursor_ObjCCategoryImplDecl: CXCursorKind { get } 1842 /** \brief A typedef. */ 1843 // public var CXCursor_TypedefDecl: CXCursorKind { get } 1844 /** \brief A C++ class method. */ 1845 // public var CXCursor_CXXMethod: CXCursorKind { get } 1846 /** \brief A C++ namespace. */ 1847 // public var CXCursor_Namespace: CXCursorKind { get } 1848 /** \brief A linkage specification, e.g. 'extern "C"'. */ 1849 // public var CXCursor_LinkageSpec: CXCursorKind { get } 1850 /** \brief A C++ constructor. */ 1851 // public var CXCursor_Constructor: CXCursorKind { get } 1852 /** \brief A C++ destructor. */ 1853 // public var CXCursor_Destructor: CXCursorKind { get } 1854 /** \brief A C++ conversion function. */ 1855 // public var CXCursor_ConversionFunction: CXCursorKind { get } 1856 /** \brief A C++ template type parameter. */ 1857 // public var CXCursor_TemplateTypeParameter: CXCursorKind { get } 1858 /** \brief A C++ non-type template parameter. */ 1859 // public var CXCursor_NonTypeTemplateParameter: CXCursorKind { get } 1860 /** \brief A C++ template template parameter. */ 1861 // public var CXCursor_TemplateTemplateParameter: CXCursorKind { get } 1862 /** \brief A C++ function template. */ 1863 // public var CXCursor_FunctionTemplate: CXCursorKind { get } 1864 /** \brief A C++ class template. */ 1865 // public var CXCursor_ClassTemplate: CXCursorKind { get } 1866 /** \brief A C++ class template partial specialization. */ 1867 // public var CXCursor_ClassTemplatePartialSpecialization: CXCursorKind { get } 1868 /** \brief A C++ namespace alias declaration. */ 1869 // public var CXCursor_NamespaceAlias: CXCursorKind { get } 1870 /** \brief A C++ using directive. */ 1871 // public var CXCursor_UsingDirective: CXCursorKind { get } 1872 /** \brief A C++ using declaration. */ 1873 // public var CXCursor_UsingDeclaration: CXCursorKind { get } 1874 /** \brief A C++ alias declaration */ 1875 // public var CXCursor_TypeAliasDecl: CXCursorKind { get } 1876 /** \brief An Objective-C \@synthesize definition. */ 1877 // public var CXCursor_ObjCSynthesizeDecl: CXCursorKind { get } 1878 /** \brief An Objective-C \@dynamic definition. */ 1879 // public var CXCursor_ObjCDynamicDecl: CXCursorKind { get } 1880 /** \brief An access specifier. */ 1881 // public var CXCursor_CXXAccessSpecifier: CXCursorKind { get } 1882 1883 /** \brief An access specifier. */ 1884 // public var CXCursor_FirstDecl: CXCursorKind { get } 1885 /** \brief An access specifier. */ 1886 // public var CXCursor_LastDecl: CXCursorKind { get } 1887 1888 /* References */ 1889 /** \brief An access specifier. */ 1890 // public var CXCursor_FirstRef: CXCursorKind { get } /* Decl references */ 1891 /** \brief An access specifier. */ 1892 // public var CXCursor_ObjCSuperClassRef: CXCursorKind { get } 1893 /** \brief An access specifier. */ 1894 // public var CXCursor_ObjCProtocolRef: CXCursorKind { get } 1895 /** \brief An access specifier. */ 1896 // public var CXCursor_ObjCClassRef: CXCursorKind { get } 1897 /** 1898 * \brief A reference to a type declaration. 1899 * 1900 * A type reference occurs anywhere where a type is named but not 1901 * declared. For example, given: 1902 * 1903 * \code 1904 * typedef unsigned size_type; 1905 * size_type size; 1906 * \endcode 1907 * 1908 * The typedef is a declaration of size_type (CXCursor_TypedefDecl), 1909 * while the type of the variable "size" is referenced. The cursor 1910 * referenced by the type of size is the typedef for size_type. 1911 */ 1912 // public var CXCursor_TypeRef: CXCursorKind { get } 1913 /** 1914 * \brief A reference to a type declaration. 1915 * 1916 * A type reference occurs anywhere where a type is named but not 1917 * declared. For example, given: 1918 * 1919 * \code 1920 * typedef unsigned size_type; 1921 * size_type size; 1922 * \endcode 1923 * 1924 * The typedef is a declaration of size_type (CXCursor_TypedefDecl), 1925 * while the type of the variable "size" is referenced. The cursor 1926 * referenced by the type of size is the typedef for size_type. 1927 */ 1928 // public var CXCursor_CXXBaseSpecifier: CXCursorKind { get } 1929 /** 1930 * \brief A reference to a class template, function template, template 1931 * template parameter, or class template partial specialization. 1932 */ 1933 // public var CXCursor_TemplateRef: CXCursorKind { get } 1934 /** 1935 * \brief A reference to a namespace or namespace alias. 1936 */ 1937 // public var CXCursor_NamespaceRef: CXCursorKind { get } 1938 /** 1939 * \brief A reference to a member of a struct, union, or class that occurs in 1940 * some non-expression context, e.g., a designated initializer. 1941 */ 1942 // public var CXCursor_MemberRef: CXCursorKind { get } 1943 /** 1944 * \brief A reference to a labeled statement. 1945 * 1946 * This cursor kind is used to describe the jump to "start_over" in the 1947 * goto statement in the following example: 1948 * 1949 * \code 1950 * start_over: 1951 * ++counter; 1952 * 1953 * goto start_over; 1954 * \endcode 1955 * 1956 * A label reference cursor refers to a label statement. 1957 */ 1958 // public var CXCursor_LabelRef: CXCursorKind { get } 1959 1960 /** 1961 * \brief A reference to a set of overloaded functions or function templates 1962 * that has not yet been resolved to a specific function or function template. 1963 * 1964 * An overloaded declaration reference cursor occurs in C++ templates where 1965 * a dependent name refers to a function. For example: 1966 * 1967 * \code 1968 * template<typename T> void swap(T&, T&); 1969 * 1970 * struct X { ... }; 1971 * void swap(X&, X&); 1972 * 1973 * template<typename T> 1974 * void reverse(T* first, T* last) { 1975 * while (first < last - 1) { 1976 * swap(*first, *--last); 1977 * ++first; 1978 * } 1979 * } 1980 * 1981 * struct Y { }; 1982 * void swap(Y&, Y&); 1983 * \endcode 1984 * 1985 * Here, the identifier "swap" is associated with an overloaded declaration 1986 * reference. In the template definition, "swap" refers to either of the two 1987 * "swap" functions declared above, so both results will be available. At 1988 * instantiation time, "swap" may also refer to other functions found via 1989 * argument-dependent lookup (e.g., the "swap" function at the end of the 1990 * example). 1991 * 1992 * The functions \c clang_getNumOverloadedDecls() and 1993 * \c clang_getOverloadedDecl() can be used to retrieve the definitions 1994 * referenced by this cursor. 1995 */ 1996 // public var CXCursor_OverloadedDeclRef: CXCursorKind { get } 1997 1998 /** 1999 * \brief A reference to a variable that occurs in some non-expression 2000 * context, e.g., a C++ lambda capture list. 2001 */ 2002 // public var CXCursor_VariableRef: CXCursorKind { get } 2003 2004 /** 2005 * \brief A reference to a variable that occurs in some non-expression 2006 * context, e.g., a C++ lambda capture list. 2007 */ 2008 // public var CXCursor_LastRef: CXCursorKind { get } 2009 2010 /* Error conditions */ 2011 /** 2012 * \brief A reference to a variable that occurs in some non-expression 2013 * context, e.g., a C++ lambda capture list. 2014 */ 2015 // public var CXCursor_FirstInvalid: CXCursorKind { get } 2016 /** 2017 * \brief A reference to a variable that occurs in some non-expression 2018 * context, e.g., a C++ lambda capture list. 2019 */ 2020 // public var CXCursor_InvalidFile: CXCursorKind { get } 2021 /** 2022 * \brief A reference to a variable that occurs in some non-expression 2023 * context, e.g., a C++ lambda capture list. 2024 */ 2025 // public var CXCursor_NoDeclFound: CXCursorKind { get } 2026 /** 2027 * \brief A reference to a variable that occurs in some non-expression 2028 * context, e.g., a C++ lambda capture list. 2029 */ 2030 // public var CXCursor_NotImplemented: CXCursorKind { get } 2031 /** 2032 * \brief A reference to a variable that occurs in some non-expression 2033 * context, e.g., a C++ lambda capture list. 2034 */ 2035 // public var CXCursor_InvalidCode: CXCursorKind { get } 2036 /** 2037 * \brief A reference to a variable that occurs in some non-expression 2038 * context, e.g., a C++ lambda capture list. 2039 */ 2040 // public var CXCursor_LastInvalid: CXCursorKind { get } 2041 2042 /* Expressions */ 2043 /** 2044 * \brief A reference to a variable that occurs in some non-expression 2045 * context, e.g., a C++ lambda capture list. 2046 */ 2047 // public var CXCursor_FirstExpr: CXCursorKind { get } 2048 2049 /** 2050 * \brief An expression whose specific kind is not exposed via this 2051 * interface. 2052 * 2053 * Unexposed expressions have the same operations as any other kind 2054 * of expression; one can extract their location information, 2055 * spelling, children, etc. However, the specific kind of the 2056 * expression is not reported. 2057 */ 2058 // public var CXCursor_UnexposedExpr: CXCursorKind { get } 2059 2060 /** 2061 * \brief An expression that refers to some value declaration, such 2062 * as a function, variable, or enumerator. 2063 */ 2064 // public var CXCursor_DeclRefExpr: CXCursorKind { get } 2065 2066 /** 2067 * \brief An expression that refers to a member of a struct, union, 2068 * class, Objective-C class, etc. 2069 */ 2070 // public var CXCursor_MemberRefExpr: CXCursorKind { get } 2071 2072 /** \brief An expression that calls a function. */ 2073 // public var CXCursor_CallExpr: CXCursorKind { get } 2074 2075 /** \brief An expression that sends a message to an Objective-C 2076 object or class. */ 2077 // public var CXCursor_ObjCMessageExpr: CXCursorKind { get } 2078 2079 /** \brief An expression that represents a block literal. */ 2080 // public var CXCursor_BlockExpr: CXCursorKind { get } 2081 2082 /** \brief An integer literal. 2083 */ 2084 // public var CXCursor_IntegerLiteral: CXCursorKind { get } 2085 2086 /** \brief A floating point number literal. 2087 */ 2088 // public var CXCursor_FloatingLiteral: CXCursorKind { get } 2089 2090 /** \brief An imaginary number literal. 2091 */ 2092 // public var CXCursor_ImaginaryLiteral: CXCursorKind { get } 2093 2094 /** \brief A string literal. 2095 */ 2096 // public var CXCursor_StringLiteral: CXCursorKind { get } 2097 2098 /** \brief A character literal. 2099 */ 2100 // public var CXCursor_CharacterLiteral: CXCursorKind { get } 2101 2102 /** \brief A parenthesized expression, e.g. "(1)". 2103 * 2104 * This AST node is only formed if full location information is requested. 2105 */ 2106 // public var CXCursor_ParenExpr: CXCursorKind { get } 2107 2108 /** \brief This represents the unary-expression's (except sizeof and 2109 * alignof). 2110 */ 2111 // public var CXCursor_UnaryOperator: CXCursorKind { get } 2112 2113 /** \brief [C99 6.5.2.1] Array Subscripting. 2114 */ 2115 // public var CXCursor_ArraySubscriptExpr: CXCursorKind { get } 2116 2117 /** \brief A builtin binary operation expression such as "x + y" or 2118 * "x <= y". 2119 */ 2120 // public var CXCursor_BinaryOperator: CXCursorKind { get } 2121 2122 /** \brief Compound assignment such as "+=". 2123 */ 2124 // public var CXCursor_CompoundAssignOperator: CXCursorKind { get } 2125 2126 /** \brief The ?: ternary operator. 2127 */ 2128 // public var CXCursor_ConditionalOperator: CXCursorKind { get } 2129 2130 /** \brief An explicit cast in C (C99 6.5.4) or a C-style cast in C++ 2131 * (C++ [expr.cast]), which uses the syntax (Type)expr. 2132 * 2133 * For example: (int)f. 2134 */ 2135 // public var CXCursor_CStyleCastExpr: CXCursorKind { get } 2136 2137 /** \brief [C99 6.5.2.5] 2138 */ 2139 // public var CXCursor_CompoundLiteralExpr: CXCursorKind { get } 2140 2141 /** \brief Describes an C or C++ initializer list. 2142 */ 2143 // public var CXCursor_InitListExpr: CXCursorKind { get } 2144 2145 /** \brief The GNU address of label extension, representing &&label. 2146 */ 2147 // public var CXCursor_AddrLabelExpr: CXCursorKind { get } 2148 2149 /** \brief This is the GNU Statement Expression extension: ({int X=4; X;}) 2150 */ 2151 // public var CXCursor_StmtExpr: CXCursorKind { get } 2152 2153 /** \brief Represents a C11 generic selection. 2154 */ 2155 // public var CXCursor_GenericSelectionExpr: CXCursorKind { get } 2156 2157 /** \brief Implements the GNU __null extension, which is a name for a null 2158 * pointer constant that has integral type (e.g., int or long) and is the same 2159 * size and alignment as a pointer. 2160 * 2161 * The __null extension is typically only used by system headers, which define 2162 * NULL as __null in C++ rather than using 0 (which is an integer that may not 2163 * match the size of a pointer). 2164 */ 2165 // public var CXCursor_GNUNullExpr: CXCursorKind { get } 2166 2167 /** \brief C++'s static_cast<> expression. 2168 */ 2169 // public var CXCursor_CXXStaticCastExpr: CXCursorKind { get } 2170 2171 /** \brief C++'s dynamic_cast<> expression. 2172 */ 2173 // public var CXCursor_CXXDynamicCastExpr: CXCursorKind { get } 2174 2175 /** \brief C++'s reinterpret_cast<> expression. 2176 */ 2177 // public var CXCursor_CXXReinterpretCastExpr: CXCursorKind { get } 2178 2179 /** \brief C++'s const_cast<> expression. 2180 */ 2181 // public var CXCursor_CXXConstCastExpr: CXCursorKind { get } 2182 2183 /** \brief Represents an explicit C++ type conversion that uses "functional" 2184 * notion (C++ [expr.type.conv]). 2185 * 2186 * Example: 2187 * \code 2188 * x = int(0.5); 2189 * \endcode 2190 */ 2191 // public var CXCursor_CXXFunctionalCastExpr: CXCursorKind { get } 2192 2193 /** \brief A C++ typeid expression (C++ [expr.typeid]). 2194 */ 2195 // public var CXCursor_CXXTypeidExpr: CXCursorKind { get } 2196 2197 /** \brief [C++ 2.13.5] C++ Boolean Literal. 2198 */ 2199 // public var CXCursor_CXXBoolLiteralExpr: CXCursorKind { get } 2200 2201 /** \brief [C++0x 2.14.7] C++ Pointer Literal. 2202 */ 2203 // public var CXCursor_CXXNullPtrLiteralExpr: CXCursorKind { get } 2204 2205 /** \brief Represents the "this" expression in C++ 2206 */ 2207 // public var CXCursor_CXXThisExpr: CXCursorKind { get } 2208 2209 /** \brief [C++ 15] C++ Throw Expression. 2210 * 2211 * This handles 'throw' and 'throw' assignment-expression. When 2212 * assignment-expression isn't present, Op will be null. 2213 */ 2214 // public var CXCursor_CXXThrowExpr: CXCursorKind { get } 2215 2216 /** \brief A new expression for memory allocation and constructor calls, e.g: 2217 * "new CXXNewExpr(foo)". 2218 */ 2219 // public var CXCursor_CXXNewExpr: CXCursorKind { get } 2220 2221 /** \brief A delete expression for memory deallocation and destructor calls, 2222 * e.g. "delete[] pArray". 2223 */ 2224 // public var CXCursor_CXXDeleteExpr: CXCursorKind { get } 2225 2226 /** \brief A unary expression. 2227 */ 2228 // public var CXCursor_UnaryExpr: CXCursorKind { get } 2229 2230 /** \brief An Objective-C string literal i.e. @"foo". 2231 */ 2232 // public var CXCursor_ObjCStringLiteral: CXCursorKind { get } 2233 2234 /** \brief An Objective-C \@encode expression. 2235 */ 2236 // public var CXCursor_ObjCEncodeExpr: CXCursorKind { get } 2237 2238 /** \brief An Objective-C \@selector expression. 2239 */ 2240 // public var CXCursor_ObjCSelectorExpr: CXCursorKind { get } 2241 2242 /** \brief An Objective-C \@protocol expression. 2243 */ 2244 // public var CXCursor_ObjCProtocolExpr: CXCursorKind { get } 2245 2246 /** \brief An Objective-C "bridged" cast expression, which casts between 2247 * Objective-C pointers and C pointers, transferring ownership in the process. 2248 * 2249 * \code 2250 * NSString *str = (__bridge_transfer NSString *)CFCreateString(); 2251 * \endcode 2252 */ 2253 // public var CXCursor_ObjCBridgedCastExpr: CXCursorKind { get } 2254 2255 /** \brief Represents a C++0x pack expansion that produces a sequence of 2256 * expressions. 2257 * 2258 * A pack expansion expression contains a pattern (which itself is an 2259 * expression) followed by an ellipsis. For example: 2260 * 2261 * \code 2262 * template<typename F, typename ...Types> 2263 * void forward(F f, Types &&...args) { 2264 * f(static_cast<Types&&>(args)...); 2265 * } 2266 * \endcode 2267 */ 2268 // public var CXCursor_PackExpansionExpr: CXCursorKind { get } 2269 2270 /** \brief Represents an expression that computes the length of a parameter 2271 * pack. 2272 * 2273 * \code 2274 * template<typename ...Types> 2275 * struct count { 2276 * static const unsigned value = sizeof...(Types); 2277 * }; 2278 * \endcode 2279 */ 2280 // public var CXCursor_SizeOfPackExpr: CXCursorKind { get } 2281 2282 /* \brief Represents a C++ lambda expression that produces a local function 2283 * object. 2284 * 2285 * \code 2286 * void abssort(float *x, unsigned N) { 2287 * std::sort(x, x + N, 2288 * [](float a, float b) { 2289 * return std::abs(a) < std::abs(b); 2290 * }); 2291 * } 2292 * \endcode 2293 */ 2294 // public var CXCursor_LambdaExpr: CXCursorKind { get } 2295 2296 /** \brief Objective-c Boolean Literal. 2297 */ 2298 // public var CXCursor_ObjCBoolLiteralExpr: CXCursorKind { get } 2299 2300 /** \brief Represents the "self" expression in an Objective-C method. 2301 */ 2302 // public var CXCursor_ObjCSelfExpr: CXCursorKind { get } 2303 2304 /** \brief OpenMP 4.0 [2.4, Array Section]. 2305 */ 2306 // public var CXCursor_OMPArraySectionExpr: CXCursorKind { get } 2307 2308 /** \brief OpenMP 4.0 [2.4, Array Section]. 2309 */ 2310 // public var CXCursor_LastExpr: CXCursorKind { get } 2311 2312 /* Statements */ 2313 /** \brief OpenMP 4.0 [2.4, Array Section]. 2314 */ 2315 // public var CXCursor_FirstStmt: CXCursorKind { get } 2316 /** 2317 * \brief A statement whose specific kind is not exposed via this 2318 * interface. 2319 * 2320 * Unexposed statements have the same operations as any other kind of 2321 * statement; one can extract their location information, spelling, 2322 * children, etc. However, the specific kind of the statement is not 2323 * reported. 2324 */ 2325 // public var CXCursor_UnexposedStmt: CXCursorKind { get } 2326 2327 /** \brief A labelled statement in a function. 2328 * 2329 * This cursor kind is used to describe the "start_over:" label statement in 2330 * the following example: 2331 * 2332 * \code 2333 * start_over: 2334 * ++counter; 2335 * \endcode 2336 * 2337 */ 2338 // public var CXCursor_LabelStmt: CXCursorKind { get } 2339 2340 /** \brief A group of statements like { stmt stmt }. 2341 * 2342 * This cursor kind is used to describe compound statements, e.g. function 2343 * bodies. 2344 */ 2345 // public var CXCursor_CompoundStmt: CXCursorKind { get } 2346 2347 /** \brief A case statement. 2348 */ 2349 // public var CXCursor_CaseStmt: CXCursorKind { get } 2350 2351 /** \brief A default statement. 2352 */ 2353 // public var CXCursor_DefaultStmt: CXCursorKind { get } 2354 2355 /** \brief An if statement 2356 */ 2357 // public var CXCursor_IfStmt: CXCursorKind { get } 2358 2359 /** \brief A switch statement. 2360 */ 2361 // public var CXCursor_SwitchStmt: CXCursorKind { get } 2362 2363 /** \brief A while statement. 2364 */ 2365 // public var CXCursor_WhileStmt: CXCursorKind { get } 2366 2367 /** \brief A do statement. 2368 */ 2369 // public var CXCursor_DoStmt: CXCursorKind { get } 2370 2371 /** \brief A for statement. 2372 */ 2373 // public var CXCursor_ForStmt: CXCursorKind { get } 2374 2375 /** \brief A goto statement. 2376 */ 2377 // public var CXCursor_GotoStmt: CXCursorKind { get } 2378 2379 /** \brief An indirect goto statement. 2380 */ 2381 // public var CXCursor_IndirectGotoStmt: CXCursorKind { get } 2382 2383 /** \brief A continue statement. 2384 */ 2385 // public var CXCursor_ContinueStmt: CXCursorKind { get } 2386 2387 /** \brief A break statement. 2388 */ 2389 // public var CXCursor_BreakStmt: CXCursorKind { get } 2390 2391 /** \brief A return statement. 2392 */ 2393 // public var CXCursor_ReturnStmt: CXCursorKind { get } 2394 2395 /** \brief A GCC inline assembly statement extension. 2396 */ 2397 // public var CXCursor_GCCAsmStmt: CXCursorKind { get } 2398 /** \brief A GCC inline assembly statement extension. 2399 */ 2400 // public var CXCursor_AsmStmt: CXCursorKind { get } 2401 2402 /** \brief Objective-C's overall \@try-\@catch-\@finally statement. 2403 */ 2404 // public var CXCursor_ObjCAtTryStmt: CXCursorKind { get } 2405 2406 /** \brief Objective-C's \@catch statement. 2407 */ 2408 // public var CXCursor_ObjCAtCatchStmt: CXCursorKind { get } 2409 2410 /** \brief Objective-C's \@finally statement. 2411 */ 2412 // public var CXCursor_ObjCAtFinallyStmt: CXCursorKind { get } 2413 2414 /** \brief Objective-C's \@throw statement. 2415 */ 2416 // public var CXCursor_ObjCAtThrowStmt: CXCursorKind { get } 2417 2418 /** \brief Objective-C's \@synchronized statement. 2419 */ 2420 // public var CXCursor_ObjCAtSynchronizedStmt: CXCursorKind { get } 2421 2422 /** \brief Objective-C's autorelease pool statement. 2423 */ 2424 // public var CXCursor_ObjCAutoreleasePoolStmt: CXCursorKind { get } 2425 2426 /** \brief Objective-C's collection statement. 2427 */ 2428 // public var CXCursor_ObjCForCollectionStmt: CXCursorKind { get } 2429 2430 /** \brief C++'s catch statement. 2431 */ 2432 // public var CXCursor_CXXCatchStmt: CXCursorKind { get } 2433 2434 /** \brief C++'s try statement. 2435 */ 2436 // public var CXCursor_CXXTryStmt: CXCursorKind { get } 2437 2438 /** \brief C++'s for (* : *) statement. 2439 */ 2440 // public var CXCursor_CXXForRangeStmt: CXCursorKind { get } 2441 2442 /** \brief Windows Structured Exception Handling's try statement. 2443 */ 2444 // public var CXCursor_SEHTryStmt: CXCursorKind { get } 2445 2446 /** \brief Windows Structured Exception Handling's except statement. 2447 */ 2448 // public var CXCursor_SEHExceptStmt: CXCursorKind { get } 2449 2450 /** \brief Windows Structured Exception Handling's finally statement. 2451 */ 2452 // public var CXCursor_SEHFinallyStmt: CXCursorKind { get } 2453 2454 /** \brief A MS inline assembly statement extension. 2455 */ 2456 // public var CXCursor_MSAsmStmt: CXCursorKind { get } 2457 2458 /** \brief The null statement ";": C99 6.8.3p3. 2459 * 2460 * This cursor kind is used to describe the null statement. 2461 */ 2462 // public var CXCursor_NullStmt: CXCursorKind { get } 2463 2464 /** \brief Adaptor class for mixing declarations with statements and 2465 * expressions. 2466 */ 2467 // public var CXCursor_DeclStmt: CXCursorKind { get } 2468 2469 /** \brief OpenMP parallel directive. 2470 */ 2471 // public var CXCursor_OMPParallelDirective: CXCursorKind { get } 2472 2473 /** \brief OpenMP SIMD directive. 2474 */ 2475 // public var CXCursor_OMPSimdDirective: CXCursorKind { get } 2476 2477 /** \brief OpenMP for directive. 2478 */ 2479 // public var CXCursor_OMPForDirective: CXCursorKind { get } 2480 2481 /** \brief OpenMP sections directive. 2482 */ 2483 // public var CXCursor_OMPSectionsDirective: CXCursorKind { get } 2484 2485 /** \brief OpenMP section directive. 2486 */ 2487 // public var CXCursor_OMPSectionDirective: CXCursorKind { get } 2488 2489 /** \brief OpenMP single directive. 2490 */ 2491 // public var CXCursor_OMPSingleDirective: CXCursorKind { get } 2492 2493 /** \brief OpenMP parallel for directive. 2494 */ 2495 // public var CXCursor_OMPParallelForDirective: CXCursorKind { get } 2496 2497 /** \brief OpenMP parallel sections directive. 2498 */ 2499 // public var CXCursor_OMPParallelSectionsDirective: CXCursorKind { get } 2500 2501 /** \brief OpenMP task directive. 2502 */ 2503 // public var CXCursor_OMPTaskDirective: CXCursorKind { get } 2504 2505 /** \brief OpenMP master directive. 2506 */ 2507 // public var CXCursor_OMPMasterDirective: CXCursorKind { get } 2508 2509 /** \brief OpenMP critical directive. 2510 */ 2511 // public var CXCursor_OMPCriticalDirective: CXCursorKind { get } 2512 2513 /** \brief OpenMP taskyield directive. 2514 */ 2515 // public var CXCursor_OMPTaskyieldDirective: CXCursorKind { get } 2516 2517 /** \brief OpenMP barrier directive. 2518 */ 2519 // public var CXCursor_OMPBarrierDirective: CXCursorKind { get } 2520 2521 /** \brief OpenMP taskwait directive. 2522 */ 2523 // public var CXCursor_OMPTaskwaitDirective: CXCursorKind { get } 2524 2525 /** \brief OpenMP flush directive. 2526 */ 2527 // public var CXCursor_OMPFlushDirective: CXCursorKind { get } 2528 2529 /** \brief Windows Structured Exception Handling's leave statement. 2530 */ 2531 // public var CXCursor_SEHLeaveStmt: CXCursorKind { get } 2532 2533 /** \brief OpenMP ordered directive. 2534 */ 2535 // public var CXCursor_OMPOrderedDirective: CXCursorKind { get } 2536 2537 /** \brief OpenMP atomic directive. 2538 */ 2539 // public var CXCursor_OMPAtomicDirective: CXCursorKind { get } 2540 2541 /** \brief OpenMP for SIMD directive. 2542 */ 2543 // public var CXCursor_OMPForSimdDirective: CXCursorKind { get } 2544 2545 /** \brief OpenMP parallel for SIMD directive. 2546 */ 2547 // public var CXCursor_OMPParallelForSimdDirective: CXCursorKind { get } 2548 2549 /** \brief OpenMP target directive. 2550 */ 2551 // public var CXCursor_OMPTargetDirective: CXCursorKind { get } 2552 2553 /** \brief OpenMP teams directive. 2554 */ 2555 // public var CXCursor_OMPTeamsDirective: CXCursorKind { get } 2556 2557 /** \brief OpenMP taskgroup directive. 2558 */ 2559 // public var CXCursor_OMPTaskgroupDirective: CXCursorKind { get } 2560 2561 /** \brief OpenMP cancellation point directive. 2562 */ 2563 // public var CXCursor_OMPCancellationPointDirective: CXCursorKind { get } 2564 2565 /** \brief OpenMP cancel directive. 2566 */ 2567 // public var CXCursor_OMPCancelDirective: CXCursorKind { get } 2568 2569 /** \brief OpenMP target data directive. 2570 */ 2571 // public var CXCursor_OMPTargetDataDirective: CXCursorKind { get } 2572 2573 /** \brief OpenMP target data directive. 2574 */ 2575 // public var CXCursor_LastStmt: CXCursorKind { get } 2576 2577 /** 2578 * \brief Cursor that represents the translation unit itself. 2579 * 2580 * The translation unit cursor exists primarily to act as the root 2581 * cursor for traversing the contents of a translation unit. 2582 */ 2583 // public var CXCursor_TranslationUnit: CXCursorKind { get } 2584 2585 /* Attributes */ 2586 /** 2587 * \brief Cursor that represents the translation unit itself. 2588 * 2589 * The translation unit cursor exists primarily to act as the root 2590 * cursor for traversing the contents of a translation unit. 2591 */ 2592 // public var CXCursor_FirstAttr: CXCursorKind { get } 2593 /** 2594 * \brief An attribute whose specific kind is not exposed via this 2595 * interface. 2596 */ 2597 // public var CXCursor_UnexposedAttr: CXCursorKind { get } 2598 2599 /** 2600 * \brief An attribute whose specific kind is not exposed via this 2601 * interface. 2602 */ 2603 // public var CXCursor_IBActionAttr: CXCursorKind { get } 2604 /** 2605 * \brief An attribute whose specific kind is not exposed via this 2606 * interface. 2607 */ 2608 // public var CXCursor_IBOutletAttr: CXCursorKind { get } 2609 /** 2610 * \brief An attribute whose specific kind is not exposed via this 2611 * interface. 2612 */ 2613 // public var CXCursor_IBOutletCollectionAttr: CXCursorKind { get } 2614 /** 2615 * \brief An attribute whose specific kind is not exposed via this 2616 * interface. 2617 */ 2618 // public var CXCursor_CXXFinalAttr: CXCursorKind { get } 2619 /** 2620 * \brief An attribute whose specific kind is not exposed via this 2621 * interface. 2622 */ 2623 // public var CXCursor_CXXOverrideAttr: CXCursorKind { get } 2624 /** 2625 * \brief An attribute whose specific kind is not exposed via this 2626 * interface. 2627 */ 2628 // public var CXCursor_AnnotateAttr: CXCursorKind { get } 2629 /** 2630 * \brief An attribute whose specific kind is not exposed via this 2631 * interface. 2632 */ 2633 // public var CXCursor_AsmLabelAttr: CXCursorKind { get } 2634 /** 2635 * \brief An attribute whose specific kind is not exposed via this 2636 * interface. 2637 */ 2638 // public var CXCursor_PackedAttr: CXCursorKind { get } 2639 /** 2640 * \brief An attribute whose specific kind is not exposed via this 2641 * interface. 2642 */ 2643 // public var CXCursor_PureAttr: CXCursorKind { get } 2644 /** 2645 * \brief An attribute whose specific kind is not exposed via this 2646 * interface. 2647 */ 2648 // public var CXCursor_ConstAttr: CXCursorKind { get } 2649 /** 2650 * \brief An attribute whose specific kind is not exposed via this 2651 * interface. 2652 */ 2653 // public var CXCursor_NoDuplicateAttr: CXCursorKind { get } 2654 /** 2655 * \brief An attribute whose specific kind is not exposed via this 2656 * interface. 2657 */ 2658 // public var CXCursor_CUDAConstantAttr: CXCursorKind { get } 2659 /** 2660 * \brief An attribute whose specific kind is not exposed via this 2661 * interface. 2662 */ 2663 // public var CXCursor_CUDADeviceAttr: CXCursorKind { get } 2664 /** 2665 * \brief An attribute whose specific kind is not exposed via this 2666 * interface. 2667 */ 2668 // public var CXCursor_CUDAGlobalAttr: CXCursorKind { get } 2669 /** 2670 * \brief An attribute whose specific kind is not exposed via this 2671 * interface. 2672 */ 2673 // public var CXCursor_CUDAHostAttr: CXCursorKind { get } 2674 /** 2675 * \brief An attribute whose specific kind is not exposed via this 2676 * interface. 2677 */ 2678 // public var CXCursor_CUDASharedAttr: CXCursorKind { get } 2679 /** 2680 * \brief An attribute whose specific kind is not exposed via this 2681 * interface. 2682 */ 2683 // public var CXCursor_VisibilityAttr: CXCursorKind { get } 2684 /** 2685 * \brief An attribute whose specific kind is not exposed via this 2686 * interface. 2687 */ 2688 // public var CXCursor_LastAttr: CXCursorKind { get } 2689 2690 /* Preprocessing */ 2691 /** 2692 * \brief An attribute whose specific kind is not exposed via this 2693 * interface. 2694 */ 2695 // public var CXCursor_PreprocessingDirective: CXCursorKind { get } 2696 /** 2697 * \brief An attribute whose specific kind is not exposed via this 2698 * interface. 2699 */ 2700 // public var CXCursor_MacroDefinition: CXCursorKind { get } 2701 /** 2702 * \brief An attribute whose specific kind is not exposed via this 2703 * interface. 2704 */ 2705 // public var CXCursor_MacroExpansion: CXCursorKind { get } 2706 /** 2707 * \brief An attribute whose specific kind is not exposed via this 2708 * interface. 2709 */ 2710 // public var CXCursor_MacroInstantiation: CXCursorKind { get } 2711 /** 2712 * \brief An attribute whose specific kind is not exposed via this 2713 * interface. 2714 */ 2715 // public var CXCursor_InclusionDirective: CXCursorKind { get } 2716 /** 2717 * \brief An attribute whose specific kind is not exposed via this 2718 * interface. 2719 */ 2720 // public var CXCursor_FirstPreprocessing: CXCursorKind { get } 2721 /** 2722 * \brief An attribute whose specific kind is not exposed via this 2723 * interface. 2724 */ 2725 // public var CXCursor_LastPreprocessing: CXCursorKind { get } 2726 2727 /* Extra Declarations */ 2728 /** 2729 * \brief A module import declaration. 2730 */ 2731 // public var CXCursor_ModuleImportDecl: CXCursorKind { get } 2732 /** 2733 * \brief A module import declaration. 2734 */ 2735 // public var CXCursor_FirstExtraDecl: CXCursorKind { get } 2736 /** 2737 * \brief A module import declaration. 2738 */ 2739 // public var CXCursor_LastExtraDecl: CXCursorKind { get } 2740 2741 /** 2742 * \brief A code completion overload candidate. 2743 */ 2744 // public var CXCursor_OverloadCandidate: CXCursorKind { get } 2745 2746 /** 2747 * \brief A cursor representing some element in the abstract syntax tree for 2748 * a translation unit. 2749 * 2750 * The cursor abstraction unifies the different kinds of entities in a 2751 * program--declaration, statements, expressions, references to declarations, 2752 * etc.--under a single "cursor" abstraction with a common set of operations. 2753 * Common operation for a cursor include: getting the physical location in 2754 * a source file where the cursor points, getting the name associated with a 2755 * cursor, and retrieving cursors for any child nodes of a particular cursor. 2756 * 2757 * Cursors can be produced in two specific ways. 2758 * clang_getTranslationUnitCursor() produces a cursor for a translation unit, 2759 * from which one can use clang_visitChildren() to explore the rest of the 2760 * translation unit. clang_getCursor() maps from a physical source location 2761 * to the entity that resides at that location, allowing one to map from the 2762 * source code into the AST. 2763 */ 2764 /* 2765 public struct CXCursor { 2766 // public var kind: CXCursorKind 2767 // public var xdata: Int32 2768 // public var data: (UnsafePointer<Void>, UnsafePointer<Void>, UnsafePointer<Void>) 2769 public init() 2770 public init(kind: CXCursorKind, xdata: Int32, data: (UnsafePointer<Void>, UnsafePointer<Void>, UnsafePointer<Void>)) 2771 } 2772 */ 2773 2774 2775 2776 /** 2777 * \defgroup CINDEX_CURSOR_MANIP Cursor manipulations 2778 * 2779 * @{ 2780 */ 2781 2782 /** 2783 * \brief Retrieve the NULL cursor, which represents no entity. 2784 */ 2785 public func clang_getNullCursor() -> CXCursor { 2786 return _clang_getNullCursor() 2787 } 2788 private let _clang_getNullCursor
created_Index.swift:1772 : @convention(c) () -> CXCursor = library.loadSymbol("clang_getNullCursor") 2789 2790 2791 /** 2792 * \brief Retrieve the cursor that represents the given translation unit. 2793 * 2794 * The translation unit cursor can be used to start traversing the 2795 * various declarations within the given translation unit. 2796 */ 2797 public func clang_getTranslationUnitCursor
created_Index.swift:2786 (unnamed1: CXTranslationUnit) -> CXCursor { 2798 return _clang_getTranslationUnitCursor(unnamed1) 2799 } 2800 private let _clang_getTranslationUnitCursor
Clang+SourceKitten.swift:40 : @convention(c) (_: CXTranslationUnit) -> CXCursor = library.loadSymbol("clang_getTranslationUnitCursor") 2801 2802 2803 /** 2804 * \brief Determine whether two cursors are equivalent. 2805 */ 2806 public func clang_equalCursors(unnamed1: CXCursor, _ unnamed2: CXCursor) -> UInt32 { 2807 return _clang_equalCursors(unnamed1, unnamed2) 2808 } 2809 private let _clang_equalCursors
created_Index.swift:2798 : @convention(c) (_: CXCursor, _: CXCursor) -> UInt32 = library.loadSymbol("clang_equalCursors") 2810 2811 2812 /** 2813 * \brief Returns non-zero if \p cursor is null. 2814 */ 2815 public func clang_Cursor_isNull(cursor: CXCursor) -> Int32 { 2816 return _clang_Cursor_isNull(cursor: cursor) 2817 } 2818 private let _clang_Cursor_isNull
created_Index.swift:2807 : @convention(c) (cursor: CXCursor) -> Int32 = library.loadSymbol("clang_Cursor_isNull") 2819 2820 2821 /** 2822 * \brief Compute a hash value for the given cursor. 2823 */ 2824 public func clang_hashCursor(unnamed1: CXCursor) -> UInt32 { 2825 return _clang_hashCursor(unnamed1) 2826 } 2827 private let _clang_hashCursor
created_Index.swift:2816 : @convention(c) (_: CXCursor) -> UInt32 = library.loadSymbol("clang_hashCursor") 2828 2829 2830 /** 2831 * \brief Retrieve the kind of the given cursor. 2832 */ 2833 public func clang_getCursorKind(unnamed1: CXCursor) -> CXCursorKind { 2834 return _clang_getCursorKind(unnamed1) 2835 } 2836 private let _clang_getCursorKind
created_Index.swift:2825 : @convention(c) (_: CXCursor) -> CXCursorKind = library.loadSymbol("clang_getCursorKind") 2837 2838 2839 /** 2840 * \brief Determine whether the given cursor kind represents a declaration. 2841 */ 2842 public func clang_isDeclaration
created_Index.swift:2834 (unnamed1: CXCursorKind) -> UInt32 { 2843 return _clang_isDeclaration(unnamed1) 2844 } 2845 private let _clang_isDeclaration
Clang+SourceKitten.swift:57 : @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isDeclaration") 2846 2847 2848 /** 2849 * \brief Determine whether the given cursor kind represents a simple 2850 * reference. 2851 * 2852 * Note that other kinds of cursors (such as expressions) can also refer to 2853 * other cursors. Use clang_getCursorReferenced() to determine whether a 2854 * particular cursor refers to another entity. 2855 */ 2856 public func clang_isReference(unnamed1: CXCursorKind) -> UInt32 { 2857 return _clang_isReference(unnamed1) 2858 } 2859 private let _clang_isReference
created_Index.swift:2843 : @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isReference") 2860 2861 2862 /** 2863 * \brief Determine whether the given cursor kind represents an expression. 2864 */ 2865 public func clang_isExpression(unnamed1: CXCursorKind) -> UInt32 { 2866 return _clang_isExpression(unnamed1) 2867 } 2868 private let _clang_isExpression
created_Index.swift:2857 : @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isExpression") 2869 2870 2871 /** 2872 * \brief Determine whether the given cursor kind represents a statement. 2873 */ 2874 public func clang_isStatement(unnamed1: CXCursorKind) -> UInt32 { 2875 return _clang_isStatement(unnamed1) 2876 } 2877 private let _clang_isStatement
created_Index.swift:2866 : @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isStatement") 2878 2879 2880 /** 2881 * \brief Determine whether the given cursor kind represents an attribute. 2882 */ 2883 public func clang_isAttribute(unnamed1: CXCursorKind) -> UInt32 { 2884 return _clang_isAttribute(unnamed1) 2885 } 2886 private let _clang_isAttribute
created_Index.swift:2875 : @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isAttribute") 2887 2888 2889 /** 2890 * \brief Determine whether the given cursor kind represents an invalid 2891 * cursor. 2892 */ 2893 public func clang_isInvalid(unnamed1: CXCursorKind) -> UInt32 { 2894 return _clang_isInvalid(unnamed1) 2895 } 2896 private let _clang_isInvalid
created_Index.swift:2884 : @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isInvalid") 2897 2898 2899 /** 2900 * \brief Determine whether the given cursor kind represents a translation 2901 * unit. 2902 */ 2903 public func clang_isTranslationUnit(unnamed1: CXCursorKind) -> UInt32 { 2904 return _clang_isTranslationUnit(unnamed1) 2905 } 2906 private let _clang_isTranslationUnit
created_Index.swift:2894 : @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isTranslationUnit") 2907 2908 2909 /*** 2910 * \brief Determine whether the given cursor represents a preprocessing 2911 * element, such as a preprocessor directive or macro instantiation. 2912 */ 2913 public func clang_isPreprocessing(unnamed1: CXCursorKind) -> UInt32 { 2914 return _clang_isPreprocessing(unnamed1) 2915 } 2916 private let _clang_isPreprocessing
created_Index.swift:2904 : @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isPreprocessing") 2917 2918 2919 /*** 2920 * \brief Determine whether the given cursor represents a currently 2921 * unexposed piece of the AST (e.g., CXCursor_UnexposedStmt). 2922 */ 2923 public func clang_isUnexposed(unnamed1: CXCursorKind) -> UInt32 { 2924 return _clang_isUnexposed(unnamed1) 2925 } 2926 private let _clang_isUnexposed
created_Index.swift:2914 : @convention(c) (_: CXCursorKind) -> UInt32 = library.loadSymbol("clang_isUnexposed") 2927 2928 2929 /** 2930 * \brief Describe the linkage of the entity referred to by a cursor. 2931 */ 2932 /* 2933 public struct CXLinkageKind : RawRepresentable, Equatable { 2934 public init(_ rawValue: UInt32) 2935 public init(rawValue: UInt32) 2936 // public var rawValue: UInt32 2937 } 2938 */ 2939 2940 /** \brief This value indicates that no linkage information is available 2941 * for a provided CXCursor. */ 2942 // public var CXLinkage_Invalid: CXLinkageKind { get } 2943 /** 2944 * \brief This is the linkage for variables, parameters, and so on that 2945 * have automatic storage. This covers normal (non-extern) local variables. 2946 */ 2947 // public var CXLinkage_NoLinkage: CXLinkageKind { get } 2948 /** \brief This is the linkage for static variables and static functions. */ 2949 // public var CXLinkage_Internal: CXLinkageKind { get } 2950 /** \brief This is the linkage for entities with external linkage that live 2951 * in C++ anonymous namespaces.*/ 2952 // public var CXLinkage_UniqueExternal: CXLinkageKind { get } 2953 /** \brief This is the linkage for entities with true, external linkage. */ 2954 // public var CXLinkage_External: CXLinkageKind { get } 2955 2956 /** 2957 * \brief Determine the linkage of the entity referred to by a given cursor. 2958 */ 2959 public func clang_getCursorLinkage(cursor: CXCursor) -> CXLinkageKind { 2960 return _clang_getCursorLinkage(cursor: cursor) 2961 } 2962 private let _clang_getCursorLinkage
created_Index.swift:2924 : @convention(c) (cursor: CXCursor) -> CXLinkageKind = library.loadSymbol("clang_getCursorLinkage") 2963 2964 2965 /** 2966 * \brief Determine the availability of the entity that this cursor refers to, 2967 * taking the current target platform into account. 2968 * 2969 * \param cursor The cursor to query. 2970 * 2971 * \returns The availability of the cursor. 2972 */ 2973 public func clang_getCursorAvailability(cursor: CXCursor) -> CXAvailabilityKind { 2974 return _clang_getCursorAvailability(cursor: cursor) 2975 } 2976 private let _clang_getCursorAvailability
created_Index.swift:2960 : @convention(c) (cursor: CXCursor) -> CXAvailabilityKind = library.loadSymbol("clang_getCursorAvailability") 2977 2978 2979 /** 2980 * Describes the availability of a given entity on a particular platform, e.g., 2981 * a particular class might only be available on Mac OS 10.7 or newer. 2982 */ 2983 /* 2984 public struct CXPlatformAvailability { 2985 /** 2986 * \brief A string that describes the platform for which this structure 2987 * provides availability information. 2988 * 2989 * Possible values are "ios" or "macosx". 2990 */ 2991 // public var Platform: CXString 2992 /** 2993 * \brief The version number in which this entity was introduced. 2994 */ 2995 // public var Introduced: CXVersion 2996 /** 2997 * \brief The version number in which this entity was deprecated (but is 2998 * still available). 2999 */ 3000 // public var Deprecated: CXVersion 3001 /** 3002 * \brief The version number in which this entity was obsoleted, and therefore 3003 * is no longer available. 3004 */ 3005 // public var Obsoleted: CXVersion 3006 /** 3007 * \brief Whether the entity is unconditionally unavailable on this platform. 3008 */ 3009 // public var Unavailable: Int32 3010 /** 3011 * \brief An optional message to provide to a user of this API, e.g., to 3012 * suggest replacement APIs. 3013 */ 3014 // public var Message: CXString 3015 public init() 3016 public init(Platform: CXString, Introduced: CXVersion, Deprecated: CXVersion, Obsoleted: CXVersion, Unavailable: Int32, Message: CXString) 3017 } 3018 */ 3019 3020 /** 3021 * \brief Determine the availability of the entity that this cursor refers to 3022 * on any platforms for which availability information is known. 3023 * 3024 * \param cursor The cursor to query. 3025 * 3026 * \param always_deprecated If non-NULL, will be set to indicate whether the 3027 * entity is deprecated on all platforms. 3028 * 3029 * \param deprecated_message If non-NULL, will be set to the message text 3030 * provided along with the unconditional deprecation of this entity. The client 3031 * is responsible for deallocating this string. 3032 * 3033 * \param always_unavailable If non-NULL, will be set to indicate whether the 3034 * entity is unavailable on all platforms. 3035 * 3036 * \param unavailable_message If non-NULL, will be set to the message text 3037 * provided along with the unconditional unavailability of this entity. The 3038 * client is responsible for deallocating this string. 3039 * 3040 * \param availability If non-NULL, an array of CXPlatformAvailability instances 3041 * that will be populated with platform availability information, up to either 3042 * the number of platforms for which availability information is available (as 3043 * returned by this function) or \c availability_size, whichever is smaller. 3044 * 3045 * \param availability_size The number of elements available in the 3046 * \c availability array. 3047 * 3048 * \returns The number of platforms (N) for which availability information is 3049 * available (which is unrelated to \c availability_size). 3050 * 3051 * Note that the client is responsible for calling 3052 * \c clang_disposeCXPlatformAvailability to free each of the 3053 * platform-availability structures returned. There are 3054 * \c min(N, availability_size) such structures. 3055 */ 3056 public func clang_getCursorPlatformAvailability(cursor: CXCursor, _ always_deprecated: UnsafeMutablePointer<Int32>, _ deprecated_message: UnsafeMutablePointer<CXString>, _ always_unavailable: UnsafeMutablePointer<Int32>, _ unavailable_message: UnsafeMutablePointer<CXString>, _ availability: UnsafeMutablePointer<CXPlatformAvailability>, _ availability_size: Int32) -> Int32 { 3057 return _clang_getCursorPlatformAvailability(cursor: cursor, always_deprecated: always_deprecated, deprecated_message: deprecated_message, always_unavailable: always_unavailable, unavailable_message: unavailable_message, availability: availability, availability_size: availability_size) 3058 } 3059 private let _clang_getCursorPlatformAvailability
created_Index.swift:2974 : @convention(c) (cursor: CXCursor, always_deprecated: UnsafeMutablePointer<Int32>, deprecated_message: UnsafeMutablePointer<CXString>, always_unavailable: UnsafeMutablePointer<Int32>, unavailable_message: UnsafeMutablePointer<CXString>, availability: UnsafeMutablePointer<CXPlatformAvailability>, availability_size: Int32) -> Int32 = library.loadSymbol("clang_getCursorPlatformAvailability") 3060 3061 3062 /** 3063 * \brief Free the memory associated with a \c CXPlatformAvailability structure. 3064 */ 3065 public func clang_disposeCXPlatformAvailability(availability: UnsafeMutablePointer<CXPlatformAvailability>) { 3066 return _clang_disposeCXPlatformAvailability(availability: availability) 3067 } 3068 private let _clang_disposeCXPlatformAvailability
created_Index.swift:3057 : @convention(c) (availability: UnsafeMutablePointer<CXPlatformAvailability>) -> () = library.loadSymbol("clang_disposeCXPlatformAvailability") 3069 3070 3071 /** 3072 * \brief Describe the "language" of the entity referred to by a cursor. 3073 */ 3074 /* 3075 public struct CXLanguageKind : RawRepresentable, Equatable { 3076 public init(_ rawValue: UInt32) 3077 public init(rawValue: UInt32) 3078 // public var rawValue: UInt32 3079 } 3080 */ 3081 // public var CXLanguage_Invalid: CXLanguageKind { get } 3082 // public var CXLanguage_C: CXLanguageKind { get } 3083 // public var CXLanguage_ObjC: CXLanguageKind { get } 3084 // public var CXLanguage_CPlusPlus: CXLanguageKind { get } 3085 3086 /** 3087 * \brief Determine the "language" of the entity referred to by a given cursor. 3088 */ 3089 public func clang_getCursorLanguage(cursor: CXCursor) -> CXLanguageKind { 3090 return _clang_getCursorLanguage(cursor: cursor) 3091 } 3092 private let _clang_getCursorLanguage
created_Index.swift:3066 : @convention(c) (cursor: CXCursor) -> CXLanguageKind = library.loadSymbol("clang_getCursorLanguage") 3093 3094 3095 /** 3096 * \brief Returns the translation unit that a cursor originated from. 3097 */ 3098 public func clang_Cursor_getTranslationUnit(unnamed1: CXCursor) -> CXTranslationUnit { 3099 return _clang_Cursor_getTranslationUnit(unnamed1) 3100 } 3101 private let _clang_Cursor_getTranslationUnit
created_Index.swift:3090 : @convention(c) (_: CXCursor) -> CXTranslationUnit = library.loadSymbol("clang_Cursor_getTranslationUnit") 3102 3103 3104 /** 3105 * \brief A fast container representing a set of CXCursors. 3106 */ 3107 // public typealias CXCursorSet = COpaquePointer 3108 3109 /** 3110 * \brief Creates an empty CXCursorSet. 3111 */ 3112 public func clang_createCXCursorSet() -> CXCursorSet { 3113 return _clang_createCXCursorSet() 3114 } 3115 private let _clang_createCXCursorSet
created_Index.swift:3099 : @convention(c) () -> CXCursorSet = library.loadSymbol("clang_createCXCursorSet") 3116 3117 3118 /** 3119 * \brief Disposes a CXCursorSet and releases its associated memory. 3120 */ 3121 public func clang_disposeCXCursorSet(cset: CXCursorSet) { 3122 return _clang_disposeCXCursorSet(cset: cset) 3123 } 3124 private let _clang_disposeCXCursorSet
created_Index.swift:3113 : @convention(c) (cset: CXCursorSet) -> () = library.loadSymbol("clang_disposeCXCursorSet") 3125 3126 3127 /** 3128 * \brief Queries a CXCursorSet to see if it contains a specific CXCursor. 3129 * 3130 * \returns non-zero if the set contains the specified cursor. 3131 */ 3132 public func clang_CXCursorSet_contains(cset: CXCursorSet, _ cursor: CXCursor) -> UInt32 { 3133 return _clang_CXCursorSet_contains(cset: cset, cursor: cursor) 3134 } 3135 private let _clang_CXCursorSet_contains
created_Index.swift:3122 : @convention(c) (cset: CXCursorSet, cursor: CXCursor) -> UInt32 = library.loadSymbol("clang_CXCursorSet_contains") 3136 3137 3138 /** 3139 * \brief Inserts a CXCursor into a CXCursorSet. 3140 * 3141 * \returns zero if the CXCursor was already in the set, and non-zero otherwise. 3142 */ 3143 public func clang_CXCursorSet_insert(cset: CXCursorSet, _ cursor: CXCursor) -> UInt32 { 3144 return _clang_CXCursorSet_insert(cset: cset, cursor: cursor) 3145 } 3146 private let _clang_CXCursorSet_insert
created_Index.swift:3133 : @convention(c) (cset: CXCursorSet, cursor: CXCursor) -> UInt32 = library.loadSymbol("clang_CXCursorSet_insert") 3147 3148 3149 /** 3150 * \brief Determine the semantic parent of the given cursor. 3151 * 3152 * The semantic parent of a cursor is the cursor that semantically contains 3153 * the given \p cursor. For many declarations, the lexical and semantic parents 3154 * are equivalent (the lexical parent is returned by 3155 * \c clang_getCursorLexicalParent()). They diverge when declarations or 3156 * definitions are provided out-of-line. For example: 3157 * 3158 * \code 3159 * class C { 3160 * void f(); 3161 * }; 3162 * 3163 * void C::f() { } 3164 * \endcode 3165 * 3166 * In the out-of-line definition of \c C::f, the semantic parent is 3167 * the class \c C, of which this function is a member. The lexical parent is 3168 * the place where the declaration actually occurs in the source code; in this 3169 * case, the definition occurs in the translation unit. In general, the 3170 * lexical parent for a given entity can change without affecting the semantics 3171 * of the program, and the lexical parent of different declarations of the 3172 * same entity may be different. Changing the semantic parent of a declaration, 3173 * on the other hand, can have a major impact on semantics, and redeclarations 3174 * of a particular entity should all have the same semantic context. 3175 * 3176 * In the example above, both declarations of \c C::f have \c C as their 3177 * semantic context, while the lexical context of the first \c C::f is \c C 3178 * and the lexical context of the second \c C::f is the translation unit. 3179 * 3180 * For global declarations, the semantic parent is the translation unit. 3181 */ 3182 public func clang_getCursorSemanticParent(cursor: CXCursor) -> CXCursor { 3183 return _clang_getCursorSemanticParent(cursor: cursor) 3184 } 3185 private let _clang_getCursorSemanticParent
created_Index.swift:3144 : @convention(c) (cursor: CXCursor) -> CXCursor = library.loadSymbol("clang_getCursorSemanticParent") 3186 3187 3188 /** 3189 * \brief Determine the lexical parent of the given cursor. 3190 * 3191 * The lexical parent of a cursor is the cursor in which the given \p cursor 3192 * was actually written. For many declarations, the lexical and semantic parents 3193 * are equivalent (the semantic parent is returned by 3194 * \c clang_getCursorSemanticParent()). They diverge when declarations or 3195 * definitions are provided out-of-line. For example: 3196 * 3197 * \code 3198 * class C { 3199 * void f(); 3200 * }; 3201 * 3202 * void C::f() { } 3203 * \endcode 3204 * 3205 * In the out-of-line definition of \c C::f, the semantic parent is 3206 * the class \c C, of which this function is a member. The lexical parent is 3207 * the place where the declaration actually occurs in the source code; in this 3208 * case, the definition occurs in the translation unit. In general, the 3209 * lexical parent for a given entity can change without affecting the semantics 3210 * of the program, and the lexical parent of different declarations of the 3211 * same entity may be different. Changing the semantic parent of a declaration, 3212 * on the other hand, can have a major impact on semantics, and redeclarations 3213 * of a particular entity should all have the same semantic context. 3214 * 3215 * In the example above, both declarations of \c C::f have \c C as their 3216 * semantic context, while the lexical context of the first \c C::f is \c C 3217 * and the lexical context of the second \c C::f is the translation unit. 3218 * 3219 * For declarations written in the global scope, the lexical parent is 3220 * the translation unit. 3221 */ 3222 public func clang_getCursorLexicalParent(cursor: CXCursor) -> CXCursor { 3223 return _clang_getCursorLexicalParent(cursor: cursor) 3224 } 3225 private let _clang_getCursorLexicalParent
created_Index.swift:3183 : @convention(c) (cursor: CXCursor) -> CXCursor = library.loadSymbol("clang_getCursorLexicalParent") 3226 3227 3228 /** 3229 * \brief Determine the set of methods that are overridden by the given 3230 * method. 3231 * 3232 * In both Objective-C and C++, a method (aka virtual member function, 3233 * in C++) can override a virtual method in a base class. For 3234 * Objective-C, a method is said to override any method in the class's 3235 * base class, its protocols, or its categories' protocols, that has the same 3236 * selector and is of the same kind (class or instance). 3237 * If no such method exists, the search continues to the class's superclass, 3238 * its protocols, and its categories, and so on. A method from an Objective-C 3239 * implementation is considered to override the same methods as its 3240 * corresponding method in the interface. 3241 * 3242 * For C++, a virtual member function overrides any virtual member 3243 * function with the same signature that occurs in its base 3244 * classes. With multiple inheritance, a virtual member function can 3245 * override several virtual member functions coming from different 3246 * base classes. 3247 * 3248 * In all cases, this function determines the immediate overridden 3249 * method, rather than all of the overridden methods. For example, if 3250 * a method is originally declared in a class A, then overridden in B 3251 * (which in inherits from A) and also in C (which inherited from B), 3252 * then the only overridden method returned from this function when 3253 * invoked on C's method will be B's method. The client may then 3254 * invoke this function again, given the previously-found overridden 3255 * methods, to map out the complete method-override set. 3256 * 3257 * \param cursor A cursor representing an Objective-C or C++ 3258 * method. This routine will compute the set of methods that this 3259 * method overrides. 3260 * 3261 * \param overridden A pointer whose pointee will be replaced with a 3262 * pointer to an array of cursors, representing the set of overridden 3263 * methods. If there are no overridden methods, the pointee will be 3264 * set to NULL. The pointee must be freed via a call to 3265 * \c clang_disposeOverriddenCursors(). 3266 * 3267 * \param num_overridden A pointer to the number of overridden 3268 * functions, will be set to the number of overridden functions in the 3269 * array pointed to by \p overridden. 3270 */ 3271 public func clang_getOverriddenCursors(cursor: CXCursor, _ overridden: UnsafeMutablePointer<UnsafeMutablePointer<CXCursor>>, _ num_overridden: UnsafeMutablePointer<UInt32>) { 3272 return _clang_getOverriddenCursors(cursor: cursor, overridden: overridden, num_overridden: num_overridden) 3273 } 3274 private let _clang_getOverriddenCursors
created_Index.swift:3223 : @convention(c) (cursor: CXCursor, overridden: UnsafeMutablePointer<UnsafeMutablePointer<CXCursor>>, num_overridden: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getOverriddenCursors") 3275 3276 3277 /** 3278 * \brief Free the set of overridden cursors returned by \c 3279 * clang_getOverriddenCursors(). 3280 */ 3281 public func clang_disposeOverriddenCursors(overridden: UnsafeMutablePointer<CXCursor>) { 3282 return _clang_disposeOverriddenCursors(overridden: overridden) 3283 } 3284 private let _clang_disposeOverriddenCursors
created_Index.swift:3272 : @convention(c) (overridden: UnsafeMutablePointer<CXCursor>) -> () = library.loadSymbol("clang_disposeOverriddenCursors") 3285 3286 3287 /** 3288 * \brief Retrieve the file that is included by the given inclusion directive 3289 * cursor. 3290 */ 3291 public func clang_getIncludedFile(cursor: CXCursor) -> CXFile { 3292 return _clang_getIncludedFile(cursor: cursor) 3293 } 3294 private let _clang_getIncludedFile
created_Index.swift:3282 : @convention(c) (cursor: CXCursor) -> CXFile = library.loadSymbol("clang_getIncludedFile") 3295 3296 3297 /** 3298 * @} 3299 */ 3300 3301 /** 3302 * \defgroup CINDEX_CURSOR_SOURCE Mapping between cursors and source code 3303 * 3304 * Cursors represent a location within the Abstract Syntax Tree (AST). These 3305 * routines help map between cursors and the physical locations where the 3306 * described entities occur in the source code. The mapping is provided in 3307 * both directions, so one can map from source code to the AST and back. 3308 * 3309 * @{ 3310 */ 3311 3312 /** 3313 * \brief Map a source location to the cursor that describes the entity at that 3314 * location in the source code. 3315 * 3316 * clang_getCursor() maps an arbitrary source location within a translation 3317 * unit down to the most specific cursor that describes the entity at that 3318 * location. For example, given an expression \c x + y, invoking 3319 * clang_getCursor() with a source location pointing to "x" will return the 3320 * cursor for "x"; similarly for "y". If the cursor points anywhere between 3321 * "x" or "y" (e.g., on the + or the whitespace around it), clang_getCursor() 3322 * will return a cursor referring to the "+" expression. 3323 * 3324 * \returns a cursor representing the entity at the given source location, or 3325 * a NULL cursor if no such entity can be found. 3326 */ 3327 public func clang_getCursor(unnamed1: CXTranslationUnit, _ unnamed2: CXSourceLocation) -> CXCursor { 3328 return _clang_getCursor(unnamed1, unnamed2) 3329 } 3330 private let _clang_getCursor
created_Index.swift:3292 : @convention(c) (_: CXTranslationUnit, _: CXSourceLocation) -> CXCursor = library.loadSymbol("clang_getCursor") 3331 3332 3333 /** 3334 * \brief Retrieve the physical location of the source constructor referenced 3335 * by the given cursor. 3336 * 3337 * The location of a declaration is typically the location of the name of that 3338 * declaration, where the name of that declaration would occur if it is 3339 * unnamed, or some keyword that introduces that particular declaration. 3340 * The location of a reference is where that reference occurs within the 3341 * source code. 3342 */ 3343 public func clang_getCursorLocation
created_Index.swift:3328 (unnamed1: CXCursor) -> CXSourceLocation { 3344 return _clang_getCursorLocation(unnamed1) 3345 } 3346 private let _clang_getCursorLocation
Clang+SourceKitten.swift:46 Clang+SourceKitten.swift:60 : @convention(c) (_: CXCursor) -> CXSourceLocation = library.loadSymbol("clang_getCursorLocation") 3347 3348 3349 /** 3350 * \brief Retrieve the physical extent of the source construct referenced by 3351 * the given cursor. 3352 * 3353 * The extent of a cursor starts with the file/line/column pointing at the 3354 * first character within the source construct that the cursor refers to and 3355 * ends with the last character within that source construct. For a 3356 * declaration, the extent covers the declaration itself. For a reference, 3357 * the extent covers the location of the reference (e.g., where the referenced 3358 * entity was actually used). 3359 */ 3360 public func clang_getCursorExtent
created_Index.swift:3344 (unnamed1: CXCursor) -> CXSourceRange { 3361 return _clang_getCursorExtent(unnamed1) 3362 } 3363 private let _clang_getCursorExtent
Clang+SourceKitten.swift:50 : @convention(c) (_: CXCursor) -> CXSourceRange = library.loadSymbol("clang_getCursorExtent") 3364 3365 3366 /** 3367 * @} 3368 */ 3369 3370 /** 3371 * \defgroup CINDEX_TYPES Type information for CXCursors 3372 * 3373 * @{ 3374 */ 3375 3376 /** 3377 * \brief Describes the kind of type 3378 */ 3379 /* 3380 public struct CXTypeKind : RawRepresentable, Equatable { 3381 public init(_ rawValue: UInt32) 3382 public init(rawValue: UInt32) 3383 // public var rawValue: UInt32 3384 } 3385 */ 3386 3387 /** 3388 * \brief Represents an invalid type (e.g., where no type is available). 3389 */ 3390 // public var CXType_Invalid: CXTypeKind { get } 3391 3392 /** 3393 * \brief A type whose specific kind is not exposed via this 3394 * interface. 3395 */ 3396 // public var CXType_Unexposed: CXTypeKind { get } 3397 3398 /* Builtin types */ 3399 /** 3400 * \brief A type whose specific kind is not exposed via this 3401 * interface. 3402 */ 3403 // public var CXType_Void: CXTypeKind { get } 3404 /** 3405 * \brief A type whose specific kind is not exposed via this 3406 * interface. 3407 */ 3408 // public var CXType_Bool: CXTypeKind { get } 3409 /** 3410 * \brief A type whose specific kind is not exposed via this 3411 * interface. 3412 */ 3413 // public var CXType_Char_U: CXTypeKind { get } 3414 /** 3415 * \brief A type whose specific kind is not exposed via this 3416 * interface. 3417 */ 3418 // public var CXType_UChar: CXTypeKind { get } 3419 /** 3420 * \brief A type whose specific kind is not exposed via this 3421 * interface. 3422 */ 3423 // public var CXType_Char16: CXTypeKind { get } 3424 /** 3425 * \brief A type whose specific kind is not exposed via this 3426 * interface. 3427 */ 3428 // public var CXType_Char32: CXTypeKind { get } 3429 /** 3430 * \brief A type whose specific kind is not exposed via this 3431 * interface. 3432 */ 3433 // public var CXType_UShort: CXTypeKind { get } 3434 /** 3435 * \brief A type whose specific kind is not exposed via this 3436 * interface. 3437 */ 3438 // public var CXType_UInt: CXTypeKind { get } 3439 /** 3440 * \brief A type whose specific kind is not exposed via this 3441 * interface. 3442 */ 3443 // public var CXType_ULong: CXTypeKind { get } 3444 /** 3445 * \brief A type whose specific kind is not exposed via this 3446 * interface. 3447 */ 3448 // public var CXType_ULongLong: CXTypeKind { get } 3449 /** 3450 * \brief A type whose specific kind is not exposed via this 3451 * interface. 3452 */ 3453 // public var CXType_UInt128: CXTypeKind { get } 3454 /** 3455 * \brief A type whose specific kind is not exposed via this 3456 * interface. 3457 */ 3458 // public var CXType_Char_S: CXTypeKind { get } 3459 /** 3460 * \brief A type whose specific kind is not exposed via this 3461 * interface. 3462 */ 3463 // public var CXType_SChar: CXTypeKind { get } 3464 /** 3465 * \brief A type whose specific kind is not exposed via this 3466 * interface. 3467 */ 3468 // public var CXType_WChar: CXTypeKind { get } 3469 /** 3470 * \brief A type whose specific kind is not exposed via this 3471 * interface. 3472 */ 3473 // public var CXType_Short: CXTypeKind { get } 3474 /** 3475 * \brief A type whose specific kind is not exposed via this 3476 * interface. 3477 */ 3478 // public var CXType_Int: CXTypeKind { get } 3479 /** 3480 * \brief A type whose specific kind is not exposed via this 3481 * interface. 3482 */ 3483 // public var CXType_Long: CXTypeKind { get } 3484 /** 3485 * \brief A type whose specific kind is not exposed via this 3486 * interface. 3487 */ 3488 // public var CXType_LongLong: CXTypeKind { get } 3489 /** 3490 * \brief A type whose specific kind is not exposed via this 3491 * interface. 3492 */ 3493 // public var CXType_Int128: CXTypeKind { get } 3494 /** 3495 * \brief A type whose specific kind is not exposed via this 3496 * interface. 3497 */ 3498 // public var CXType_Float: CXTypeKind { get } 3499 /** 3500 * \brief A type whose specific kind is not exposed via this 3501 * interface. 3502 */ 3503 // public var CXType_Double: CXTypeKind { get } 3504 /** 3505 * \brief A type whose specific kind is not exposed via this 3506 * interface. 3507 */ 3508 // public var CXType_LongDouble: CXTypeKind { get } 3509 /** 3510 * \brief A type whose specific kind is not exposed via this 3511 * interface. 3512 */ 3513 // public var CXType_NullPtr: CXTypeKind { get } 3514 /** 3515 * \brief A type whose specific kind is not exposed via this 3516 * interface. 3517 */ 3518 // public var CXType_Overload: CXTypeKind { get } 3519 /** 3520 * \brief A type whose specific kind is not exposed via this 3521 * interface. 3522 */ 3523 // public var CXType_Dependent: CXTypeKind { get } 3524 /** 3525 * \brief A type whose specific kind is not exposed via this 3526 * interface. 3527 */ 3528 // public var CXType_ObjCId: CXTypeKind { get } 3529 /** 3530 * \brief A type whose specific kind is not exposed via this 3531 * interface. 3532 */ 3533 // public var CXType_ObjCClass: CXTypeKind { get } 3534 /** 3535 * \brief A type whose specific kind is not exposed via this 3536 * interface. 3537 */ 3538 // public var CXType_ObjCSel: CXTypeKind { get } 3539 /** 3540 * \brief A type whose specific kind is not exposed via this 3541 * interface. 3542 */ 3543 // public var CXType_FirstBuiltin: CXTypeKind { get } 3544 /** 3545 * \brief A type whose specific kind is not exposed via this 3546 * interface. 3547 */ 3548 // public var CXType_LastBuiltin: CXTypeKind { get } 3549 3550 /** 3551 * \brief A type whose specific kind is not exposed via this 3552 * interface. 3553 */ 3554 // public var CXType_Complex: CXTypeKind { get } 3555 /** 3556 * \brief A type whose specific kind is not exposed via this 3557 * interface. 3558 */ 3559 // public var CXType_Pointer: CXTypeKind { get } 3560 /** 3561 * \brief A type whose specific kind is not exposed via this 3562 * interface. 3563 */ 3564 // public var CXType_BlockPointer: CXTypeKind { get } 3565 /** 3566 * \brief A type whose specific kind is not exposed via this 3567 * interface. 3568 */ 3569 // public var CXType_LValueReference: CXTypeKind { get } 3570 /** 3571 * \brief A type whose specific kind is not exposed via this 3572 * interface. 3573 */ 3574 // public var CXType_RValueReference: CXTypeKind { get } 3575 /** 3576 * \brief A type whose specific kind is not exposed via this 3577 * interface. 3578 */ 3579 // public var CXType_Record: CXTypeKind { get } 3580 /** 3581 * \brief A type whose specific kind is not exposed via this 3582 * interface. 3583 */ 3584 // public var CXType_Enum: CXTypeKind { get } 3585 /** 3586 * \brief A type whose specific kind is not exposed via this 3587 * interface. 3588 */ 3589 // public var CXType_Typedef: CXTypeKind { get } 3590 /** 3591 * \brief A type whose specific kind is not exposed via this 3592 * interface. 3593 */ 3594 // public var CXType_ObjCInterface: CXTypeKind { get } 3595 /** 3596 * \brief A type whose specific kind is not exposed via this 3597 * interface. 3598 */ 3599 // public var CXType_ObjCObjectPointer: CXTypeKind { get } 3600 /** 3601 * \brief A type whose specific kind is not exposed via this 3602 * interface. 3603 */ 3604 // public var CXType_FunctionNoProto: CXTypeKind { get } 3605 /** 3606 * \brief A type whose specific kind is not exposed via this 3607 * interface. 3608 */ 3609 // public var CXType_FunctionProto: CXTypeKind { get } 3610 /** 3611 * \brief A type whose specific kind is not exposed via this 3612 * interface. 3613 */ 3614 // public var CXType_ConstantArray: CXTypeKind { get } 3615 /** 3616 * \brief A type whose specific kind is not exposed via this 3617 * interface. 3618 */ 3619 // public var CXType_Vector: CXTypeKind { get } 3620 /** 3621 * \brief A type whose specific kind is not exposed via this 3622 * interface. 3623 */ 3624 // public var CXType_IncompleteArray: CXTypeKind { get } 3625 /** 3626 * \brief A type whose specific kind is not exposed via this 3627 * interface. 3628 */ 3629 // public var CXType_VariableArray: CXTypeKind { get } 3630 /** 3631 * \brief A type whose specific kind is not exposed via this 3632 * interface. 3633 */ 3634 // public var CXType_DependentSizedArray: CXTypeKind { get } 3635 /** 3636 * \brief A type whose specific kind is not exposed via this 3637 * interface. 3638 */ 3639 // public var CXType_MemberPointer: CXTypeKind { get } 3640 3641 /** 3642 * \brief Describes the calling convention of a function type 3643 */ 3644 /* 3645 public struct CXCallingConv : RawRepresentable, Equatable { 3646 public init(_ rawValue: UInt32) 3647 public init(rawValue: UInt32) 3648 // public var rawValue: UInt32 3649 } 3650 */ 3651 // public var CXCallingConv_Default: CXCallingConv { get } 3652 // public var CXCallingConv_C: CXCallingConv { get } 3653 // public var CXCallingConv_X86StdCall: CXCallingConv { get } 3654 // public var CXCallingConv_X86FastCall: CXCallingConv { get } 3655 // public var CXCallingConv_X86ThisCall: CXCallingConv { get } 3656 // public var CXCallingConv_X86Pascal: CXCallingConv { get } 3657 // public var CXCallingConv_AAPCS: CXCallingConv { get } 3658 // public var CXCallingConv_AAPCS_VFP: CXCallingConv { get } 3659 3660 /* Value 8 was PnaclCall, but it was never used, so it could safely be re-used. */ 3661 // public var CXCallingConv_IntelOclBicc: CXCallingConv { get } 3662 // public var CXCallingConv_X86_64Win64: CXCallingConv { get } 3663 // public var CXCallingConv_X86_64SysV: CXCallingConv { get } 3664 // public var CXCallingConv_X86VectorCall: CXCallingConv { get } 3665 3666 // public var CXCallingConv_Invalid: CXCallingConv { get } 3667 // public var CXCallingConv_Unexposed: CXCallingConv { get } 3668 3669 /** 3670 * \brief The type of an element in the abstract syntax tree. 3671 * 3672 */ 3673 /* 3674 public struct CXType { 3675 // public var kind: CXTypeKind 3676 // public var data: (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>) 3677 public init() 3678 public init(kind: CXTypeKind, data: (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>)) 3679 } 3680 */ 3681 3682 /** 3683 * \brief Retrieve the type of a CXCursor (if any). 3684 */ 3685 public func clang_getCursorType(C: CXCursor) -> CXType { 3686 return _clang_getCursorType(C: C) 3687 } 3688 private let _clang_getCursorType
created_Index.swift:3361 : @convention(c) (C: CXCursor) -> CXType = library.loadSymbol("clang_getCursorType") 3689 3690 3691 /** 3692 * \brief Pretty-print the underlying type using the rules of the 3693 * language of the translation unit from which it came. 3694 * 3695 * If the type is invalid, an empty string is returned. 3696 */ 3697 public func clang_getTypeSpelling(CT: CXType) -> CXString { 3698 return _clang_getTypeSpelling(CT: CT) 3699 } 3700 private let _clang_getTypeSpelling
created_Index.swift:3686 : @convention(c) (CT: CXType) -> CXString = library.loadSymbol("clang_getTypeSpelling") 3701 3702 3703 /** 3704 * \brief Retrieve the underlying type of a typedef declaration. 3705 * 3706 * If the cursor does not reference a typedef declaration, an invalid type is 3707 * returned. 3708 */ 3709 public func clang_getTypedefDeclUnderlyingType(C: CXCursor) -> CXType { 3710 return _clang_getTypedefDeclUnderlyingType(C: C) 3711 } 3712 private let _clang_getTypedefDeclUnderlyingType
created_Index.swift:3698 : @convention(c) (C: CXCursor) -> CXType = library.loadSymbol("clang_getTypedefDeclUnderlyingType") 3713 3714 3715 /** 3716 * \brief Retrieve the integer type of an enum declaration. 3717 * 3718 * If the cursor does not reference an enum declaration, an invalid type is 3719 * returned. 3720 */ 3721 public func clang_getEnumDeclIntegerType(C: CXCursor) -> CXType { 3722 return _clang_getEnumDeclIntegerType(C: C) 3723 } 3724 private let _clang_getEnumDeclIntegerType
created_Index.swift:3710 : @convention(c) (C: CXCursor) -> CXType = library.loadSymbol("clang_getEnumDeclIntegerType") 3725 3726 3727 /** 3728 * \brief Retrieve the integer value of an enum constant declaration as a signed 3729 * long long. 3730 * 3731 * If the cursor does not reference an enum constant declaration, LLONG_MIN is returned. 3732 * Since this is also potentially a valid constant value, the kind of the cursor 3733 * must be verified before calling this function. 3734 */ 3735 public func clang_getEnumConstantDeclValue(C: CXCursor) -> Int64 { 3736 return _clang_getEnumConstantDeclValue(C: C) 3737 } 3738 private let _clang_getEnumConstantDeclValue
created_Index.swift:3722 : @convention(c) (C: CXCursor) -> Int64 = library.loadSymbol("clang_getEnumConstantDeclValue") 3739 3740 3741 /** 3742 * \brief Retrieve the integer value of an enum constant declaration as an unsigned 3743 * long long. 3744 * 3745 * If the cursor does not reference an enum constant declaration, ULLONG_MAX is returned. 3746 * Since this is also potentially a valid constant value, the kind of the cursor 3747 * must be verified before calling this function. 3748 */ 3749 public func clang_getEnumConstantDeclUnsignedValue(C: CXCursor) -> UInt64 { 3750 return _clang_getEnumConstantDeclUnsignedValue(C: C) 3751 } 3752 private let _clang_getEnumConstantDeclUnsignedValue
created_Index.swift:3736 : @convention(c) (C: CXCursor) -> UInt64 = library.loadSymbol("clang_getEnumConstantDeclUnsignedValue") 3753 3754 3755 /** 3756 * \brief Retrieve the bit width of a bit field declaration as an integer. 3757 * 3758 * If a cursor that is not a bit field declaration is passed in, -1 is returned. 3759 */ 3760 public func clang_getFieldDeclBitWidth(C: CXCursor) -> Int32 { 3761 return _clang_getFieldDeclBitWidth(C: C) 3762 } 3763 private let _clang_getFieldDeclBitWidth
created_Index.swift:3750 : @convention(c) (C: CXCursor) -> Int32 = library.loadSymbol("clang_getFieldDeclBitWidth") 3764 3765 3766 /** 3767 * \brief Retrieve the number of non-variadic arguments associated with a given 3768 * cursor. 3769 * 3770 * The number of arguments can be determined for calls as well as for 3771 * declarations of functions or methods. For other cursors -1 is returned. 3772 */ 3773 public func clang_Cursor_getNumArguments(C: CXCursor) -> Int32 { 3774 return _clang_Cursor_getNumArguments(C: C) 3775 } 3776 private let _clang_Cursor_getNumArguments
created_Index.swift:3761 : @convention(c) (C: CXCursor) -> Int32 = library.loadSymbol("clang_Cursor_getNumArguments") 3777 3778 3779 /** 3780 * \brief Retrieve the argument cursor of a function or method. 3781 * 3782 * The argument cursor can be determined for calls as well as for declarations 3783 * of functions or methods. For other cursors and for invalid indices, an 3784 * invalid cursor is returned. 3785 */ 3786 public func clang_Cursor_getArgument(C: CXCursor, _ i: UInt32) -> CXCursor { 3787 return _clang_Cursor_getArgument(C: C, i: i) 3788 } 3789 private let _clang_Cursor_getArgument
created_Index.swift:3774 : @convention(c) (C: CXCursor, i: UInt32) -> CXCursor = library.loadSymbol("clang_Cursor_getArgument") 3790 3791 3792 /** 3793 * \brief Describes the kind of a template argument. 3794 * 3795 * See the definition of llvm::clang::TemplateArgument::ArgKind for full 3796 * element descriptions. 3797 */ 3798 /* 3799 public struct CXTemplateArgumentKind : RawRepresentable, Equatable { 3800 public init(_ rawValue: UInt32) 3801 public init(rawValue: UInt32) 3802 // public var rawValue: UInt32 3803 } 3804 */ 3805 // public var CXTemplateArgumentKind_Null: CXTemplateArgumentKind { get } 3806 // public var CXTemplateArgumentKind_Type: CXTemplateArgumentKind { get } 3807 // public var CXTemplateArgumentKind_Declaration: CXTemplateArgumentKind { get } 3808 // public var CXTemplateArgumentKind_NullPtr: CXTemplateArgumentKind { get } 3809 // public var CXTemplateArgumentKind_Integral: CXTemplateArgumentKind { get } 3810 // public var CXTemplateArgumentKind_Template: CXTemplateArgumentKind { get } 3811 // public var CXTemplateArgumentKind_TemplateExpansion: CXTemplateArgumentKind { get } 3812 // public var CXTemplateArgumentKind_Expression: CXTemplateArgumentKind { get } 3813 // public var CXTemplateArgumentKind_Pack: CXTemplateArgumentKind { get } 3814 3815 /* Indicates an error case, preventing the kind from being deduced. */ 3816 // public var CXTemplateArgumentKind_Invalid: CXTemplateArgumentKind { get } 3817 3818 /** 3819 *\brief Returns the number of template args of a function decl representing a 3820 * template specialization. 3821 * 3822 * If the argument cursor cannot be converted into a template function 3823 * declaration, -1 is returned. 3824 * 3825 * For example, for the following declaration and specialization: 3826 * template <typename T, int kInt, bool kBool> 3827 * void foo() { ... } 3828 * 3829 * template <> 3830 * void foo<float, -7, true>(); 3831 * 3832 * The value 3 would be returned from this call. 3833 */ 3834 public func clang_Cursor_getNumTemplateArguments(C: CXCursor) -> Int32 { 3835 return _clang_Cursor_getNumTemplateArguments(C: C) 3836 } 3837 private let _clang_Cursor_getNumTemplateArguments
created_Index.swift:3787 : @convention(c) (C: CXCursor) -> Int32 = library.loadSymbol("clang_Cursor_getNumTemplateArguments") 3838 3839 3840 /** 3841 * \brief Retrieve the kind of the I'th template argument of the CXCursor C. 3842 * 3843 * If the argument CXCursor does not represent a FunctionDecl, an invalid 3844 * template argument kind is returned. 3845 * 3846 * For example, for the following declaration and specialization: 3847 * template <typename T, int kInt, bool kBool> 3848 * void foo() { ... } 3849 * 3850 * template <> 3851 * void foo<float, -7, true>(); 3852 * 3853 * For I = 0, 1, and 2, Type, Integral, and Integral will be returned, 3854 * respectively. 3855 */ 3856 public func clang_Cursor_getTemplateArgumentKind(C: CXCursor, _ I: UInt32) -> CXTemplateArgumentKind { 3857 return _clang_Cursor_getTemplateArgumentKind(C: C, I: I) 3858 } 3859 private let _clang_Cursor_getTemplateArgumentKind
created_Index.swift:3835 : @convention(c) (C: CXCursor, I: UInt32) -> CXTemplateArgumentKind = library.loadSymbol("clang_Cursor_getTemplateArgumentKind") 3860 3861 3862 /** 3863 * \brief Retrieve a CXType representing the type of a TemplateArgument of a 3864 * function decl representing a template specialization. 3865 * 3866 * If the argument CXCursor does not represent a FunctionDecl whose I'th 3867 * template argument has a kind of CXTemplateArgKind_Integral, an invalid type 3868 * is returned. 3869 * 3870 * For example, for the following declaration and specialization: 3871 * template <typename T, int kInt, bool kBool> 3872 * void foo() { ... } 3873 * 3874 * template <> 3875 * void foo<float, -7, true>(); 3876 * 3877 * If called with I = 0, "float", will be returned. 3878 * Invalid types will be returned for I == 1 or 2. 3879 */ 3880 public func clang_Cursor_getTemplateArgumentType(C: CXCursor, _ I: UInt32) -> CXType { 3881 return _clang_Cursor_getTemplateArgumentType(C: C, I: I) 3882 } 3883 private let _clang_Cursor_getTemplateArgumentType
created_Index.swift:3857 : @convention(c) (C: CXCursor, I: UInt32) -> CXType = library.loadSymbol("clang_Cursor_getTemplateArgumentType") 3884 3885 3886 /** 3887 * \brief Retrieve the value of an Integral TemplateArgument (of a function 3888 * decl representing a template specialization) as a signed long long. 3889 * 3890 * It is undefined to call this function on a CXCursor that does not represent a 3891 * FunctionDecl or whose I'th template argument is not an integral value. 3892 * 3893 * For example, for the following declaration and specialization: 3894 * template <typename T, int kInt, bool kBool> 3895 * void foo() { ... } 3896 * 3897 * template <> 3898 * void foo<float, -7, true>(); 3899 * 3900 * If called with I = 1 or 2, -7 or true will be returned, respectively. 3901 * For I == 0, this function's behavior is undefined. 3902 */ 3903 public func clang_Cursor_getTemplateArgumentValue(C: CXCursor, _ I: UInt32) -> Int64 { 3904 return _clang_Cursor_getTemplateArgumentValue(C: C, I: I) 3905 } 3906 private let _clang_Cursor_getTemplateArgumentValue
created_Index.swift:3881 : @convention(c) (C: CXCursor, I: UInt32) -> Int64 = library.loadSymbol("clang_Cursor_getTemplateArgumentValue") 3907 3908 3909 /** 3910 * \brief Retrieve the value of an Integral TemplateArgument (of a function 3911 * decl representing a template specialization) as an unsigned long long. 3912 * 3913 * It is undefined to call this function on a CXCursor that does not represent a 3914 * FunctionDecl or whose I'th template argument is not an integral value. 3915 * 3916 * For example, for the following declaration and specialization: 3917 * template <typename T, int kInt, bool kBool> 3918 * void foo() { ... } 3919 * 3920 * template <> 3921 * void foo<float, 2147483649, true>(); 3922 * 3923 * If called with I = 1 or 2, 2147483649 or true will be returned, respectively. 3924 * For I == 0, this function's behavior is undefined. 3925 */ 3926 public func clang_Cursor_getTemplateArgumentUnsignedValue(C: CXCursor, _ I: UInt32) -> UInt64 { 3927 return _clang_Cursor_getTemplateArgumentUnsignedValue(C: C, I: I) 3928 } 3929 private let _clang_Cursor_getTemplateArgumentUnsignedValue
created_Index.swift:3904 : @convention(c) (C: CXCursor, I: UInt32) -> UInt64 = library.loadSymbol("clang_Cursor_getTemplateArgumentUnsignedValue") 3930 3931 3932 /** 3933 * \brief Determine whether two CXTypes represent the same type. 3934 * 3935 * \returns non-zero if the CXTypes represent the same type and 3936 * zero otherwise. 3937 */ 3938 public func clang_equalTypes(A: CXType, _ B: CXType) -> UInt32 { 3939 return _clang_equalTypes(A: A, B: B) 3940 } 3941 private let _clang_equalTypes
created_Index.swift:3927 : @convention(c) (A: CXType, B: CXType) -> UInt32 = library.loadSymbol("clang_equalTypes") 3942 3943 3944 /** 3945 * \brief Return the canonical type for a CXType. 3946 * 3947 * Clang's type system explicitly models typedefs and all the ways 3948 * a specific type can be represented. The canonical type is the underlying 3949 * type with all the "sugar" removed. For example, if 'T' is a typedef 3950 * for 'int', the canonical type for 'T' would be 'int'. 3951 */ 3952 public func clang_getCanonicalType(T: CXType) -> CXType { 3953 return _clang_getCanonicalType(T: T) 3954 } 3955 private let _clang_getCanonicalType
created_Index.swift:3939 : @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_getCanonicalType") 3956 3957 3958 /** 3959 * \brief Determine whether a CXType has the "const" qualifier set, 3960 * without looking through typedefs that may have added "const" at a 3961 * different level. 3962 */ 3963 public func clang_isConstQualifiedType(T: CXType) -> UInt32 { 3964 return _clang_isConstQualifiedType(T: T) 3965 } 3966 private let _clang_isConstQualifiedType
created_Index.swift:3953 : @convention(c) (T: CXType) -> UInt32 = library.loadSymbol("clang_isConstQualifiedType") 3967 3968 3969 /** 3970 * \brief Determine whether a CXType has the "volatile" qualifier set, 3971 * without looking through typedefs that may have added "volatile" at 3972 * a different level. 3973 */ 3974 public func clang_isVolatileQualifiedType(T: CXType) -> UInt32 { 3975 return _clang_isVolatileQualifiedType(T: T) 3976 } 3977 private let _clang_isVolatileQualifiedType
created_Index.swift:3964 : @convention(c) (T: CXType) -> UInt32 = library.loadSymbol("clang_isVolatileQualifiedType") 3978 3979 3980 /** 3981 * \brief Determine whether a CXType has the "restrict" qualifier set, 3982 * without looking through typedefs that may have added "restrict" at a 3983 * different level. 3984 */ 3985 public func clang_isRestrictQualifiedType(T: CXType) -> UInt32 { 3986 return _clang_isRestrictQualifiedType(T: T) 3987 } 3988 private let _clang_isRestrictQualifiedType
created_Index.swift:3975 : @convention(c) (T: CXType) -> UInt32 = library.loadSymbol("clang_isRestrictQualifiedType") 3989 3990 3991 /** 3992 * \brief For pointer types, returns the type of the pointee. 3993 */ 3994 public func clang_getPointeeType(T: CXType) -> CXType { 3995 return _clang_getPointeeType(T: T) 3996 } 3997 private let _clang_getPointeeType
created_Index.swift:3986 : @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_getPointeeType") 3998 3999 4000 /** 4001 * \brief Return the cursor for the declaration of the given type. 4002 */ 4003 public func clang_getTypeDeclaration(T: CXType) -> CXCursor { 4004 return _clang_getTypeDeclaration(T: T) 4005 } 4006 private let _clang_getTypeDeclaration
created_Index.swift:3995 : @convention(c) (T: CXType) -> CXCursor = library.loadSymbol("clang_getTypeDeclaration") 4007 4008 4009 /** 4010 * Returns the Objective-C type encoding for the specified declaration. 4011 */ 4012 public func clang_getDeclObjCTypeEncoding(C: CXCursor) -> CXString { 4013 return _clang_getDeclObjCTypeEncoding(C: C) 4014 } 4015 private let _clang_getDeclObjCTypeEncoding
created_Index.swift:4004 : @convention(c) (C: CXCursor) -> CXString = library.loadSymbol("clang_getDeclObjCTypeEncoding") 4016 4017 4018 /** 4019 * \brief Retrieve the spelling of a given CXTypeKind. 4020 */ 4021 public func clang_getTypeKindSpelling(K: CXTypeKind) -> CXString { 4022 return _clang_getTypeKindSpelling(K: K) 4023 } 4024 private let _clang_getTypeKindSpelling
created_Index.swift:4013 : @convention(c) (K: CXTypeKind) -> CXString = library.loadSymbol("clang_getTypeKindSpelling") 4025 4026 4027 /** 4028 * \brief Retrieve the calling convention associated with a function type. 4029 * 4030 * If a non-function type is passed in, CXCallingConv_Invalid is returned. 4031 */ 4032 public func clang_getFunctionTypeCallingConv(T: CXType) -> CXCallingConv { 4033 return _clang_getFunctionTypeCallingConv(T: T) 4034 } 4035 private let _clang_getFunctionTypeCallingConv
created_Index.swift:4022 : @convention(c) (T: CXType) -> CXCallingConv = library.loadSymbol("clang_getFunctionTypeCallingConv") 4036 4037 4038 /** 4039 * \brief Retrieve the return type associated with a function type. 4040 * 4041 * If a non-function type is passed in, an invalid type is returned. 4042 */ 4043 public func clang_getResultType(T: CXType) -> CXType { 4044 return _clang_getResultType(T: T) 4045 } 4046 private let _clang_getResultType
created_Index.swift:4033 : @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_getResultType") 4047 4048 4049 /** 4050 * \brief Retrieve the number of non-variadic parameters associated with a 4051 * function type. 4052 * 4053 * If a non-function type is passed in, -1 is returned. 4054 */ 4055 public func clang_getNumArgTypes(T: CXType) -> Int32 { 4056 return _clang_getNumArgTypes(T: T) 4057 } 4058 private let _clang_getNumArgTypes
created_Index.swift:4044 : @convention(c) (T: CXType) -> Int32 = library.loadSymbol("clang_getNumArgTypes") 4059 4060 4061 /** 4062 * \brief Retrieve the type of a parameter of a function type. 4063 * 4064 * If a non-function type is passed in or the function does not have enough 4065 * parameters, an invalid type is returned. 4066 */ 4067 public func clang_getArgType(T: CXType, _ i: UInt32) -> CXType { 4068 return _clang_getArgType(T: T, i: i) 4069 } 4070 private let _clang_getArgType
created_Index.swift:4056 : @convention(c) (T: CXType, i: UInt32) -> CXType = library.loadSymbol("clang_getArgType") 4071 4072 4073 /** 4074 * \brief Return 1 if the CXType is a variadic function type, and 0 otherwise. 4075 */ 4076 public func clang_isFunctionTypeVariadic(T: CXType) -> UInt32 { 4077 return _clang_isFunctionTypeVariadic(T: T) 4078 } 4079 private let _clang_isFunctionTypeVariadic
created_Index.swift:4068 : @convention(c) (T: CXType) -> UInt32 = library.loadSymbol("clang_isFunctionTypeVariadic") 4080 4081 4082 /** 4083 * \brief Retrieve the return type associated with a given cursor. 4084 * 4085 * This only returns a valid type if the cursor refers to a function or method. 4086 */ 4087 public func clang_getCursorResultType(C: CXCursor) -> CXType { 4088 return _clang_getCursorResultType(C: C) 4089 } 4090 private let _clang_getCursorResultType
created_Index.swift:4077 : @convention(c) (C: CXCursor) -> CXType = library.loadSymbol("clang_getCursorResultType") 4091 4092 4093 /** 4094 * \brief Return 1 if the CXType is a POD (plain old data) type, and 0 4095 * otherwise. 4096 */ 4097 public func clang_isPODType(T: CXType) -> UInt32 { 4098 return _clang_isPODType(T: T) 4099 } 4100 private let _clang_isPODType
created_Index.swift:4088 : @convention(c) (T: CXType) -> UInt32 = library.loadSymbol("clang_isPODType") 4101 4102 4103 /** 4104 * \brief Return the element type of an array, complex, or vector type. 4105 * 4106 * If a type is passed in that is not an array, complex, or vector type, 4107 * an invalid type is returned. 4108 */ 4109 public func clang_getElementType(T: CXType) -> CXType { 4110 return _clang_getElementType(T: T) 4111 } 4112 private let _clang_getElementType
created_Index.swift:4098 : @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_getElementType") 4113 4114 4115 /** 4116 * \brief Return the number of elements of an array or vector type. 4117 * 4118 * If a type is passed in that is not an array or vector type, 4119 * -1 is returned. 4120 */ 4121 public func clang_getNumElements(T: CXType) -> Int64 { 4122 return _clang_getNumElements(T: T) 4123 } 4124 private let _clang_getNumElements
created_Index.swift:4110 : @convention(c) (T: CXType) -> Int64 = library.loadSymbol("clang_getNumElements") 4125 4126 4127 /** 4128 * \brief Return the element type of an array type. 4129 * 4130 * If a non-array type is passed in, an invalid type is returned. 4131 */ 4132 public func clang_getArrayElementType(T: CXType) -> CXType { 4133 return _clang_getArrayElementType(T: T) 4134 } 4135 private let _clang_getArrayElementType
created_Index.swift:4122 : @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_getArrayElementType") 4136 4137 4138 /** 4139 * \brief Return the array size of a constant array. 4140 * 4141 * If a non-array type is passed in, -1 is returned. 4142 */ 4143 public func clang_getArraySize(T: CXType) -> Int64 { 4144 return _clang_getArraySize(T: T) 4145 } 4146 private let _clang_getArraySize
created_Index.swift:4133 : @convention(c) (T: CXType) -> Int64 = library.loadSymbol("clang_getArraySize") 4147 4148 4149 /** 4150 * \brief List the possible error codes for \c clang_Type_getSizeOf, 4151 * \c clang_Type_getAlignOf, \c clang_Type_getOffsetOf and 4152 * \c clang_Cursor_getOffsetOf. 4153 * 4154 * A value of this enumeration type can be returned if the target type is not 4155 * a valid argument to sizeof, alignof or offsetof. 4156 */ 4157 /* 4158 public struct CXTypeLayoutError : RawRepresentable, Equatable { 4159 public init(_ rawValue: Int32) 4160 public init(rawValue: Int32) 4161 // public var rawValue: Int32 4162 } 4163 */ 4164 4165 /** 4166 * \brief Type is of kind CXType_Invalid. 4167 */ 4168 // public var CXTypeLayoutError_Invalid: CXTypeLayoutError { get } 4169 /** 4170 * \brief The type is an incomplete Type. 4171 */ 4172 // public var CXTypeLayoutError_Incomplete: CXTypeLayoutError { get } 4173 /** 4174 * \brief The type is a dependent Type. 4175 */ 4176 // public var CXTypeLayoutError_Dependent: CXTypeLayoutError { get } 4177 /** 4178 * \brief The type is not a constant size type. 4179 */ 4180 // public var CXTypeLayoutError_NotConstantSize: CXTypeLayoutError { get } 4181 /** 4182 * \brief The Field name is not valid for this record. 4183 */ 4184 // public var CXTypeLayoutError_InvalidFieldName: CXTypeLayoutError { get } 4185 4186 /** 4187 * \brief Return the alignment of a type in bytes as per C++[expr.alignof] 4188 * standard. 4189 * 4190 * If the type declaration is invalid, CXTypeLayoutError_Invalid is returned. 4191 * If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete 4192 * is returned. 4193 * If the type declaration is a dependent type, CXTypeLayoutError_Dependent is 4194 * returned. 4195 * If the type declaration is not a constant size type, 4196 * CXTypeLayoutError_NotConstantSize is returned. 4197 */ 4198 public func clang_Type_getAlignOf(T: CXType) -> Int64 { 4199 return _clang_Type_getAlignOf(T: T) 4200 } 4201 private let _clang_Type_getAlignOf
created_Index.swift:4144 : @convention(c) (T: CXType) -> Int64 = library.loadSymbol("clang_Type_getAlignOf") 4202 4203 4204 /** 4205 * \brief Return the class type of an member pointer type. 4206 * 4207 * If a non-member-pointer type is passed in, an invalid type is returned. 4208 */ 4209 public func clang_Type_getClassType(T: CXType) -> CXType { 4210 return _clang_Type_getClassType(T: T) 4211 } 4212 private let _clang_Type_getClassType
created_Index.swift:4199 : @convention(c) (T: CXType) -> CXType = library.loadSymbol("clang_Type_getClassType") 4213 4214 4215 /** 4216 * \brief Return the size of a type in bytes as per C++[expr.sizeof] standard. 4217 * 4218 * If the type declaration is invalid, CXTypeLayoutError_Invalid is returned. 4219 * If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete 4220 * is returned. 4221 * If the type declaration is a dependent type, CXTypeLayoutError_Dependent is 4222 * returned. 4223 */ 4224 public func clang_Type_getSizeOf(T: CXType) -> Int64 { 4225 return _clang_Type_getSizeOf(T: T) 4226 } 4227 private let _clang_Type_getSizeOf
created_Index.swift:4210 : @convention(c) (T: CXType) -> Int64 = library.loadSymbol("clang_Type_getSizeOf") 4228 4229 4230 /** 4231 * \brief Return the offset of a field named S in a record of type T in bits 4232 * as it would be returned by __offsetof__ as per C++11[18.2p4] 4233 * 4234 * If the cursor is not a record field declaration, CXTypeLayoutError_Invalid 4235 * is returned. 4236 * If the field's type declaration is an incomplete type, 4237 * CXTypeLayoutError_Incomplete is returned. 4238 * If the field's type declaration is a dependent type, 4239 * CXTypeLayoutError_Dependent is returned. 4240 * If the field's name S is not found, 4241 * CXTypeLayoutError_InvalidFieldName is returned. 4242 */ 4243 public func clang_Type_getOffsetOf(T: CXType, _ S: UnsafePointer<Int8>) -> Int64 { 4244 return _clang_Type_getOffsetOf(T: T, S: S) 4245 } 4246 private let _clang_Type_getOffsetOf
created_Index.swift:4225 : @convention(c) (T: CXType, S: UnsafePointer<Int8>) -> Int64 = library.loadSymbol("clang_Type_getOffsetOf") 4247 4248 4249 /** 4250 * \brief Return the offset of the field represented by the Cursor. 4251 * 4252 * If the cursor is not a field declaration, -1 is returned. 4253 * If the cursor semantic parent is not a record field declaration, 4254 * CXTypeLayoutError_Invalid is returned. 4255 * If the field's type declaration is an incomplete type, 4256 * CXTypeLayoutError_Incomplete is returned. 4257 * If the field's type declaration is a dependent type, 4258 * CXTypeLayoutError_Dependent is returned. 4259 * If the field's name S is not found, 4260 * CXTypeLayoutError_InvalidFieldName is returned. 4261 */ 4262 public func clang_Cursor_getOffsetOfField(C: CXCursor) -> Int64 { 4263 return _clang_Cursor_getOffsetOfField(C: C) 4264 } 4265 private let _clang_Cursor_getOffsetOfField
created_Index.swift:4244 : @convention(c) (C: CXCursor) -> Int64 = library.loadSymbol("clang_Cursor_getOffsetOfField") 4266 4267 4268 /** 4269 * \brief Determine whether the given cursor represents an anonymous record 4270 * declaration. 4271 */ 4272 public func clang_Cursor_isAnonymous(C: CXCursor) -> UInt32 { 4273 return _clang_Cursor_isAnonymous(C: C) 4274 } 4275 private let _clang_Cursor_isAnonymous
created_Index.swift:4263 : @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_Cursor_isAnonymous") 4276 4277 4278 /* 4279 public struct CXRefQualifierKind : RawRepresentable, Equatable { 4280 public init(_ rawValue: UInt32) 4281 public init(rawValue: UInt32) 4282 // public var rawValue: UInt32 4283 } 4284 */ 4285 4286 /** \brief No ref-qualifier was provided. */ 4287 // public var CXRefQualifier_None: CXRefQualifierKind { get } 4288 /** \brief An lvalue ref-qualifier was provided (\c &). */ 4289 // public var CXRefQualifier_LValue: CXRefQualifierKind { get } 4290 /** \brief An rvalue ref-qualifier was provided (\c &&). */ 4291 // public var CXRefQualifier_RValue: CXRefQualifierKind { get } 4292 4293 /** 4294 * \brief Returns the number of template arguments for given class template 4295 * specialization, or -1 if type \c T is not a class template specialization. 4296 * 4297 * Variadic argument packs count as only one argument, and can not be inspected 4298 * further. 4299 */ 4300 public func clang_Type_getNumTemplateArguments(T: CXType) -> Int32 { 4301 return _clang_Type_getNumTemplateArguments(T: T) 4302 } 4303 private let _clang_Type_getNumTemplateArguments
created_Index.swift:4273 : @convention(c) (T: CXType) -> Int32 = library.loadSymbol("clang_Type_getNumTemplateArguments") 4304 4305 4306 /** 4307 * \brief Returns the type template argument of a template class specialization 4308 * at given index. 4309 * 4310 * This function only returns template type arguments and does not handle 4311 * template template arguments or variadic packs. 4312 */ 4313 public func clang_Type_getTemplateArgumentAsType(T: CXType, _ i: UInt32) -> CXType { 4314 return _clang_Type_getTemplateArgumentAsType(T: T, i: i) 4315 } 4316 private let _clang_Type_getTemplateArgumentAsType
created_Index.swift:4301 : @convention(c) (T: CXType, i: UInt32) -> CXType = library.loadSymbol("clang_Type_getTemplateArgumentAsType") 4317 4318 4319 /** 4320 * \brief Retrieve the ref-qualifier kind of a function or method. 4321 * 4322 * The ref-qualifier is returned for C++ functions or methods. For other types 4323 * or non-C++ declarations, CXRefQualifier_None is returned. 4324 */ 4325 public func clang_Type_getCXXRefQualifier(T: CXType) -> CXRefQualifierKind { 4326 return _clang_Type_getCXXRefQualifier(T: T) 4327 } 4328 private let _clang_Type_getCXXRefQualifier
created_Index.swift:4314 : @convention(c) (T: CXType) -> CXRefQualifierKind = library.loadSymbol("clang_Type_getCXXRefQualifier") 4329 4330 4331 /** 4332 * \brief Returns non-zero if the cursor specifies a Record member that is a 4333 * bitfield. 4334 */ 4335 public func clang_Cursor_isBitField(C: CXCursor) -> UInt32 { 4336 return _clang_Cursor_isBitField(C: C) 4337 } 4338 private let _clang_Cursor_isBitField
created_Index.swift:4326 : @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_Cursor_isBitField") 4339 4340 4341 /** 4342 * \brief Returns 1 if the base class specified by the cursor with kind 4343 * CX_CXXBaseSpecifier is virtual. 4344 */ 4345 public func clang_isVirtualBase(unnamed1: CXCursor) -> UInt32 { 4346 return _clang_isVirtualBase(unnamed1) 4347 } 4348 private let _clang_isVirtualBase
created_Index.swift:4336 : @convention(c) (_: CXCursor) -> UInt32 = library.loadSymbol("clang_isVirtualBase") 4349 4350 4351 /** 4352 * \brief Represents the C++ access control level to a base class for a 4353 * cursor with kind CX_CXXBaseSpecifier. 4354 */ 4355 /* 4356 public struct CX_CXXAccessSpecifier : RawRepresentable, Equatable { 4357 public init(_ rawValue: UInt32) 4358 public init(rawValue: UInt32) 4359 // public var rawValue: UInt32 4360 } 4361 */ 4362 // public var CX_CXXInvalidAccessSpecifier: CX_CXXAccessSpecifier { get } 4363 // public var CX_CXXPublic: CX_CXXAccessSpecifier { get } 4364 // public var CX_CXXProtected: CX_CXXAccessSpecifier { get } 4365 // public var CX_CXXPrivate: CX_CXXAccessSpecifier { get } 4366 4367 /** 4368 * \brief Returns the access control level for the referenced object. 4369 * 4370 * If the cursor refers to a C++ declaration, its access control level within its 4371 * parent scope is returned. Otherwise, if the cursor refers to a base specifier or 4372 * access specifier, the specifier itself is returned. 4373 */ 4374 public func clang_getCXXAccessSpecifier(unnamed1: CXCursor) -> CX_CXXAccessSpecifier { 4375 return _clang_getCXXAccessSpecifier(unnamed1) 4376 } 4377 private let _clang_getCXXAccessSpecifier
created_Index.swift:4346 : @convention(c) (_: CXCursor) -> CX_CXXAccessSpecifier = library.loadSymbol("clang_getCXXAccessSpecifier") 4378 4379 4380 /** 4381 * \brief Represents the storage classes as declared in the source. CX_SC_Invalid 4382 * was added for the case that the passed cursor in not a declaration. 4383 */ 4384 /* 4385 public struct CX_StorageClass : RawRepresentable, Equatable { 4386 public init(_ rawValue: UInt32) 4387 public init(rawValue: UInt32) 4388 // public var rawValue: UInt32 4389 } 4390 */ 4391 // public var CX_SC_Invalid: CX_StorageClass { get } 4392 // public var CX_SC_None: CX_StorageClass { get } 4393 // public var CX_SC_Extern: CX_StorageClass { get } 4394 // public var CX_SC_Static: CX_StorageClass { get } 4395 // public var CX_SC_PrivateExtern: CX_StorageClass { get } 4396 // public var CX_SC_OpenCLWorkGroupLocal: CX_StorageClass { get } 4397 // public var CX_SC_Auto: CX_StorageClass { get } 4398 // public var CX_SC_Register: CX_StorageClass { get } 4399 4400 /** 4401 * \brief Returns the storage class for a function or variable declaration. 4402 * 4403 * If the passed in Cursor is not a function or variable declaration, 4404 * CX_SC_Invalid is returned else the storage class. 4405 */ 4406 public func clang_Cursor_getStorageClass(unnamed1: CXCursor) -> CX_StorageClass { 4407 return _clang_Cursor_getStorageClass(unnamed1) 4408 } 4409 private let _clang_Cursor_getStorageClass
created_Index.swift:4375 : @convention(c) (_: CXCursor) -> CX_StorageClass = library.loadSymbol("clang_Cursor_getStorageClass") 4410 4411 4412 /** 4413 * \brief Determine the number of overloaded declarations referenced by a 4414 * \c CXCursor_OverloadedDeclRef cursor. 4415 * 4416 * \param cursor The cursor whose overloaded declarations are being queried. 4417 * 4418 * \returns The number of overloaded declarations referenced by \c cursor. If it 4419 * is not a \c CXCursor_OverloadedDeclRef cursor, returns 0. 4420 */ 4421 public func clang_getNumOverloadedDecls(cursor: CXCursor) -> UInt32 { 4422 return _clang_getNumOverloadedDecls(cursor: cursor) 4423 } 4424 private let _clang_getNumOverloadedDecls
created_Index.swift:4407 : @convention(c) (cursor: CXCursor) -> UInt32 = library.loadSymbol("clang_getNumOverloadedDecls") 4425 4426 4427 /** 4428 * \brief Retrieve a cursor for one of the overloaded declarations referenced 4429 * by a \c CXCursor_OverloadedDeclRef cursor. 4430 * 4431 * \param cursor The cursor whose overloaded declarations are being queried. 4432 * 4433 * \param index The zero-based index into the set of overloaded declarations in 4434 * the cursor. 4435 * 4436 * \returns A cursor representing the declaration referenced by the given 4437 * \c cursor at the specified \c index. If the cursor does not have an 4438 * associated set of overloaded declarations, or if the index is out of bounds, 4439 * returns \c clang_getNullCursor(); 4440 */ 4441 public func clang_getOverloadedDecl(cursor: CXCursor, _ index: UInt32) -> CXCursor { 4442 return _clang_getOverloadedDecl(cursor: cursor, index: index) 4443 } 4444 private let _clang_getOverloadedDecl
created_Index.swift:4422 : @convention(c) (cursor: CXCursor, index: UInt32) -> CXCursor = library.loadSymbol("clang_getOverloadedDecl") 4445 4446 4447 /** 4448 * @} 4449 */ 4450 4451 /** 4452 * \defgroup CINDEX_ATTRIBUTES Information for attributes 4453 * 4454 * @{ 4455 */ 4456 4457 /** 4458 * \brief For cursors representing an iboutletcollection attribute, 4459 * this function returns the collection element type. 4460 * 4461 */ 4462 public func clang_getIBOutletCollectionType(unnamed1: CXCursor) -> CXType { 4463 return _clang_getIBOutletCollectionType(unnamed1) 4464 } 4465 private let _clang_getIBOutletCollectionType
created_Index.swift:4442 : @convention(c) (_: CXCursor) -> CXType = library.loadSymbol("clang_getIBOutletCollectionType") 4466 4467 4468 /** 4469 * @} 4470 */ 4471 4472 /** 4473 * \defgroup CINDEX_CURSOR_TRAVERSAL Traversing the AST with cursors 4474 * 4475 * These routines provide the ability to traverse the abstract syntax tree 4476 * using cursors. 4477 * 4478 * @{ 4479 */ 4480 4481 /** 4482 * \brief Describes how the traversal of the children of a particular 4483 * cursor should proceed after visiting a particular child cursor. 4484 * 4485 * A value of this enumeration type should be returned by each 4486 * \c CXCursorVisitor to indicate how clang_visitChildren() proceed. 4487 */ 4488 /* 4489 public struct CXChildVisitResult : RawRepresentable, Equatable { 4490 public init(_ rawValue: UInt32) 4491 public init(rawValue: UInt32) 4492 // public var rawValue: UInt32 4493 } 4494 */ 4495 4496 /** 4497 * \brief Terminates the cursor traversal. 4498 */ 4499 // public var CXChildVisit_Break: CXChildVisitResult { get } 4500 /** 4501 * \brief Continues the cursor traversal with the next sibling of 4502 * the cursor just visited, without visiting its children. 4503 */ 4504 // public var CXChildVisit_Continue: CXChildVisitResult { get } 4505 /** 4506 * \brief Recursively traverse the children of this cursor, using 4507 * the same visitor and client data. 4508 */ 4509 // public var CXChildVisit_Recurse: CXChildVisitResult { get } 4510 4511 /** 4512 * \brief Visitor invoked for each cursor found by a traversal. 4513 * 4514 * This visitor function will be invoked for each cursor found by 4515 * clang_visitCursorChildren(). Its first argument is the cursor being 4516 * visited, its second argument is the parent visitor for that cursor, 4517 * and its third argument is the client data provided to 4518 * clang_visitCursorChildren(). 4519 * 4520 * The visitor should return one of the \c CXChildVisitResult values 4521 * to direct clang_visitCursorChildren(). 4522 */ 4523 // public typealias CXCursorVisitor = @convention(c) (CXCursor, CXCursor, CXClientData) -> CXChildVisitResult 4524 4525 /** 4526 * \brief Visit the children of a particular cursor. 4527 * 4528 * This function visits all the direct children of the given cursor, 4529 * invoking the given \p visitor function with the cursors of each 4530 * visited child. The traversal may be recursive, if the visitor returns 4531 * \c CXChildVisit_Recurse. The traversal may also be ended prematurely, if 4532 * the visitor returns \c CXChildVisit_Break. 4533 * 4534 * \param parent the cursor whose child may be visited. All kinds of 4535 * cursors can be visited, including invalid cursors (which, by 4536 * definition, have no children). 4537 * 4538 * \param visitor the visitor function that will be invoked for each 4539 * child of \p parent. 4540 * 4541 * \param client_data pointer data supplied by the client, which will 4542 * be passed to the visitor each time it is invoked. 4543 * 4544 * \returns a non-zero value if the traversal was terminated 4545 * prematurely by the visitor returning \c CXChildVisit_Break. 4546 */ 4547 public func clang_visitChildren(parent: CXCursor, _ visitor: CXCursorVisitor!, _ client_data: CXClientData) -> UInt32 { 4548 return _clang_visitChildren(parent: parent, visitor: visitor, client_data: client_data) 4549 } 4550 private let _clang_visitChildren
created_Index.swift:4463 : @convention(c) (parent: CXCursor, visitor: CXCursorVisitor!, client_data: CXClientData) -> UInt32 = library.loadSymbol("clang_visitChildren") 4551 4552 4553 /** 4554 * \brief Visitor invoked for each cursor found by a traversal. 4555 * 4556 * This visitor block will be invoked for each cursor found by 4557 * clang_visitChildrenWithBlock(). Its first argument is the cursor being 4558 * visited, its second argument is the parent visitor for that cursor. 4559 * 4560 * The visitor should return one of the \c CXChildVisitResult values 4561 * to direct clang_visitChildrenWithBlock(). 4562 */ 4563 // public typealias CXCursorVisitorBlock = (CXCursor, CXCursor) -> CXChildVisitResult 4564 4565 /** 4566 * Visits the children of a cursor using the specified block. Behaves 4567 * identically to clang_visitChildren() in all other respects. 4568 */ 4569 public func clang_visitChildrenWithBlock
created_Index.swift:4548 (parent: CXCursor, _ block: CXCursorVisitorBlock!) -> UInt32 { 4570 return _clang_visitChildrenWithBlock(parent: parent, block: block) 4571 } 4572 private let _clang_visitChildrenWithBlock
Clang+SourceKitten.swift:122 : @convention(c) (parent: CXCursor, block: CXCursorVisitorBlock!) -> UInt32 = library.loadSymbol("clang_visitChildrenWithBlock") 4573 4574 4575 /** 4576 * @} 4577 */ 4578 4579 /** 4580 * \defgroup CINDEX_CURSOR_XREF Cross-referencing in the AST 4581 * 4582 * These routines provide the ability to determine references within and 4583 * across translation units, by providing the names of the entities referenced 4584 * by cursors, follow reference cursors to the declarations they reference, 4585 * and associate declarations with their definitions. 4586 * 4587 * @{ 4588 */ 4589 4590 /** 4591 * \brief Retrieve a Unified Symbol Resolution (USR) for the entity referenced 4592 * by the given cursor. 4593 * 4594 * A Unified Symbol Resolution (USR) is a string that identifies a particular 4595 * entity (function, class, variable, etc.) within a program. USRs can be 4596 * compared across translation units to determine, e.g., when references in 4597 * one translation refer to an entity defined in another translation unit. 4598 */ 4599 public func clang_getCursorUSR
created_Index.swift:4570 (unnamed1: CXCursor) -> CXString { 4600 return _clang_getCursorUSR(unnamed1) 4601 } 4602 private let _clang_getCursorUSR
Clang+SourceKitten.swift:118 : @convention(c) (_: CXCursor) -> CXString = library.loadSymbol("clang_getCursorUSR") 4603 4604 4605 /** 4606 * \brief Construct a USR for a specified Objective-C class. 4607 */ 4608 public func clang_constructUSR_ObjCClass(class_name: UnsafePointer<Int8>) -> CXString { 4609 return _clang_constructUSR_ObjCClass(class_name: class_name) 4610 } 4611 private let _clang_constructUSR_ObjCClass
created_Index.swift:4600 : @convention(c) (class_name: UnsafePointer<Int8>) -> CXString = library.loadSymbol("clang_constructUSR_ObjCClass") 4612 4613 4614 /** 4615 * \brief Construct a USR for a specified Objective-C category. 4616 */ 4617 public func clang_constructUSR_ObjCCategory(class_name: UnsafePointer<Int8>, _ category_name: UnsafePointer<Int8>) -> CXString { 4618 return _clang_constructUSR_ObjCCategory(class_name: class_name, category_name: category_name) 4619 } 4620 private let _clang_constructUSR_ObjCCategory
created_Index.swift:4609 : @convention(c) (class_name: UnsafePointer<Int8>, category_name: UnsafePointer<Int8>) -> CXString = library.loadSymbol("clang_constructUSR_ObjCCategory") 4621 4622 4623 /** 4624 * \brief Construct a USR for a specified Objective-C protocol. 4625 */ 4626 public func clang_constructUSR_ObjCProtocol(protocol_name: UnsafePointer<Int8>) -> CXString { 4627 return _clang_constructUSR_ObjCProtocol(protocol_name: protocol_name) 4628 } 4629 private let _clang_constructUSR_ObjCProtocol
created_Index.swift:4618 : @convention(c) (protocol_name: UnsafePointer<Int8>) -> CXString = library.loadSymbol("clang_constructUSR_ObjCProtocol") 4630 4631 4632 /** 4633 * \brief Construct a USR for a specified Objective-C instance variable and 4634 * the USR for its containing class. 4635 */ 4636 public func clang_constructUSR_ObjCIvar(name: UnsafePointer<Int8>, _ classUSR: CXString) -> CXString { 4637 return _clang_constructUSR_ObjCIvar(name: name, classUSR: classUSR) 4638 } 4639 private let _clang_constructUSR_ObjCIvar
created_Index.swift:4627 : @convention(c) (name: UnsafePointer<Int8>, classUSR: CXString) -> CXString = library.loadSymbol("clang_constructUSR_ObjCIvar") 4640 4641 4642 /** 4643 * \brief Construct a USR for a specified Objective-C method and 4644 * the USR for its containing class. 4645 */ 4646 public func clang_constructUSR_ObjCMethod(name: UnsafePointer<Int8>, _ isInstanceMethod: UInt32, _ classUSR: CXString) -> CXString { 4647 return _clang_constructUSR_ObjCMethod(name: name, isInstanceMethod: isInstanceMethod, classUSR: classUSR) 4648 } 4649 private let _clang_constructUSR_ObjCMethod
created_Index.swift:4637 : @convention(c) (name: UnsafePointer<Int8>, isInstanceMethod: UInt32, classUSR: CXString) -> CXString = library.loadSymbol("clang_constructUSR_ObjCMethod") 4650 4651 4652 /** 4653 * \brief Construct a USR for a specified Objective-C property and the USR 4654 * for its containing class. 4655 */ 4656 public func clang_constructUSR_ObjCProperty(property: UnsafePointer<Int8>, _ classUSR: CXString) -> CXString { 4657 return _clang_constructUSR_ObjCProperty(property: property, classUSR: classUSR) 4658 } 4659 private let _clang_constructUSR_ObjCProperty
created_Index.swift:4647 : @convention(c) (property: UnsafePointer<Int8>, classUSR: CXString) -> CXString = library.loadSymbol("clang_constructUSR_ObjCProperty") 4660 4661 4662 /** 4663 * \brief Retrieve a name for the entity referenced by this cursor. 4664 */ 4665 public func clang_getCursorSpelling
created_Index.swift:4657 (unnamed1: CXCursor) -> CXString { 4666 return _clang_getCursorSpelling(unnamed1) 4667 } 4668 private let _clang_getCursorSpelling
Clang+SourceKitten.swift:88 : @convention(c) (_: CXCursor) -> CXString = library.loadSymbol("clang_getCursorSpelling") 4669 4670 4671 /** 4672 * \brief Retrieve a range for a piece that forms the cursors spelling name. 4673 * Most of the times there is only one range for the complete spelling but for 4674 * Objective-C methods and Objective-C message expressions, there are multiple 4675 * pieces for each selector identifier. 4676 * 4677 * \param pieceIndex the index of the spelling name piece. If this is greater 4678 * than the actual number of pieces, it will return a NULL (invalid) range. 4679 * 4680 * \param options Reserved. 4681 */ 4682 public func clang_Cursor_getSpellingNameRange(unnamed1: CXCursor, _ pieceIndex: UInt32, _ options: UInt32) -> CXSourceRange { 4683 return _clang_Cursor_getSpellingNameRange(unnamed1, pieceIndex: pieceIndex, options: options) 4684 } 4685 private let _clang_Cursor_getSpellingNameRange
created_Index.swift:4666 : @convention(c) (_: CXCursor, pieceIndex: UInt32, options: UInt32) -> CXSourceRange = library.loadSymbol("clang_Cursor_getSpellingNameRange") 4686 4687 4688 /** 4689 * \brief Retrieve the display name for the entity referenced by this cursor. 4690 * 4691 * The display name contains extra information that helps identify the cursor, 4692 * such as the parameters of a function or template or the arguments of a 4693 * class template specialization. 4694 */ 4695 public func clang_getCursorDisplayName(unnamed1: CXCursor) -> CXString { 4696 return _clang_getCursorDisplayName(unnamed1) 4697 } 4698 private let _clang_getCursorDisplayName
created_Index.swift:4683 : @convention(c) (_: CXCursor) -> CXString = library.loadSymbol("clang_getCursorDisplayName") 4699 4700 4701 /** \brief For a cursor that is a reference, retrieve a cursor representing the 4702 * entity that it references. 4703 * 4704 * Reference cursors refer to other entities in the AST. For example, an 4705 * Objective-C superclass reference cursor refers to an Objective-C class. 4706 * This function produces the cursor for the Objective-C class from the 4707 * cursor for the superclass reference. If the input cursor is a declaration or 4708 * definition, it returns that declaration or definition unchanged. 4709 * Otherwise, returns the NULL cursor. 4710 */ 4711 public func clang_getCursorReferenced(unnamed1: CXCursor) -> CXCursor { 4712 return _clang_getCursorReferenced(unnamed1) 4713 } 4714 private let _clang_getCursorReferenced
created_Index.swift:4696 : @convention(c) (_: CXCursor) -> CXCursor = library.loadSymbol("clang_getCursorReferenced") 4715 4716 4717 /** 4718 * \brief For a cursor that is either a reference to or a declaration 4719 * of some entity, retrieve a cursor that describes the definition of 4720 * that entity. 4721 * 4722 * Some entities can be declared multiple times within a translation 4723 * unit, but only one of those declarations can also be a 4724 * definition. For example, given: 4725 * 4726 * \code 4727 * int f(int, int); 4728 * int g(int x, int y) { return f(x, y); } 4729 * int f(int a, int b) { return a + b; } 4730 * int f(int, int); 4731 * \endcode 4732 * 4733 * there are three declarations of the function "f", but only the 4734 * second one is a definition. The clang_getCursorDefinition() 4735 * function will take any cursor pointing to a declaration of "f" 4736 * (the first or fourth lines of the example) or a cursor referenced 4737 * that uses "f" (the call to "f' inside "g") and will return a 4738 * declaration cursor pointing to the definition (the second "f" 4739 * declaration). 4740 * 4741 * If given a cursor for which there is no corresponding definition, 4742 * e.g., because there is no definition of that entity within this 4743 * translation unit, returns a NULL cursor. 4744 */ 4745 public func clang_getCursorDefinition(unnamed1: CXCursor) -> CXCursor { 4746 return _clang_getCursorDefinition(unnamed1) 4747 } 4748 private let _clang_getCursorDefinition
created_Index.swift:4712 : @convention(c) (_: CXCursor) -> CXCursor = library.loadSymbol("clang_getCursorDefinition") 4749 4750 4751 /** 4752 * \brief Determine whether the declaration pointed to by this cursor 4753 * is also a definition of that entity. 4754 */ 4755 public func clang_isCursorDefinition(unnamed1: CXCursor) -> UInt32 { 4756 return _clang_isCursorDefinition(unnamed1) 4757 } 4758 private let _clang_isCursorDefinition
created_Index.swift:4746 : @convention(c) (_: CXCursor) -> UInt32 = library.loadSymbol("clang_isCursorDefinition") 4759 4760 4761 /** 4762 * \brief Retrieve the canonical cursor corresponding to the given cursor. 4763 * 4764 * In the C family of languages, many kinds of entities can be declared several 4765 * times within a single translation unit. For example, a structure type can 4766 * be forward-declared (possibly multiple times) and later defined: 4767 * 4768 * \code 4769 * struct X; 4770 * struct X; 4771 * struct X { 4772 * int member; 4773 * }; 4774 * \endcode 4775 * 4776 * The declarations and the definition of \c X are represented by three 4777 * different cursors, all of which are declarations of the same underlying 4778 * entity. One of these cursor is considered the "canonical" cursor, which 4779 * is effectively the representative for the underlying entity. One can 4780 * determine if two cursors are declarations of the same underlying entity by 4781 * comparing their canonical cursors. 4782 * 4783 * \returns The canonical cursor for the entity referred to by the given cursor. 4784 */ 4785 public func clang_getCanonicalCursor(unnamed1: CXCursor) -> CXCursor { 4786 return _clang_getCanonicalCursor(unnamed1) 4787 } 4788 private let _clang_getCanonicalCursor
created_Index.swift:4756 : @convention(c) (_: CXCursor) -> CXCursor = library.loadSymbol("clang_getCanonicalCursor") 4789 4790 4791 /** 4792 * \brief If the cursor points to a selector identifier in an Objective-C 4793 * method or message expression, this returns the selector index. 4794 * 4795 * After getting a cursor with #clang_getCursor, this can be called to 4796 * determine if the location points to a selector identifier. 4797 * 4798 * \returns The selector index if the cursor is an Objective-C method or message 4799 * expression and the cursor is pointing to a selector identifier, or -1 4800 * otherwise. 4801 */ 4802 public func clang_Cursor_getObjCSelectorIndex(unnamed1: CXCursor) -> Int32 { 4803 return _clang_Cursor_getObjCSelectorIndex(unnamed1) 4804 } 4805 private let _clang_Cursor_getObjCSelectorIndex
created_Index.swift:4786 : @convention(c) (_: CXCursor) -> Int32 = library.loadSymbol("clang_Cursor_getObjCSelectorIndex") 4806 4807 4808 /** 4809 * \brief Given a cursor pointing to a C++ method call or an Objective-C 4810 * message, returns non-zero if the method/message is "dynamic", meaning: 4811 * 4812 * For a C++ method: the call is virtual. 4813 * For an Objective-C message: the receiver is an object instance, not 'super' 4814 * or a specific class. 4815 * 4816 * If the method/message is "static" or the cursor does not point to a 4817 * method/message, it will return zero. 4818 */ 4819 public func clang_Cursor_isDynamicCall(C: CXCursor) -> Int32 { 4820 return _clang_Cursor_isDynamicCall(C: C) 4821 } 4822 private let _clang_Cursor_isDynamicCall
created_Index.swift:4803 : @convention(c) (C: CXCursor) -> Int32 = library.loadSymbol("clang_Cursor_isDynamicCall") 4823 4824 4825 /** 4826 * \brief Given a cursor pointing to an Objective-C message, returns the CXType 4827 * of the receiver. 4828 */ 4829 public func clang_Cursor_getReceiverType(C: CXCursor) -> CXType { 4830 return _clang_Cursor_getReceiverType(C: C) 4831 } 4832 private let _clang_Cursor_getReceiverType
created_Index.swift:4820 : @convention(c) (C: CXCursor) -> CXType = library.loadSymbol("clang_Cursor_getReceiverType") 4833 4834 4835 /** 4836 * \brief Property attributes for a \c CXCursor_ObjCPropertyDecl. 4837 */ 4838 /* 4839 public struct CXObjCPropertyAttrKind : RawRepresentable, Equatable { 4840 public init(_ rawValue: UInt32) 4841 public init(rawValue: UInt32) 4842 // public var rawValue: UInt32 4843 } 4844 */ 4845 // public var CXObjCPropertyAttr_noattr: CXObjCPropertyAttrKind { get } 4846 // public var CXObjCPropertyAttr_readonly: CXObjCPropertyAttrKind { get } 4847 // public var CXObjCPropertyAttr_getter: CXObjCPropertyAttrKind { get } 4848 // public var CXObjCPropertyAttr_assign: CXObjCPropertyAttrKind { get } 4849 // public var CXObjCPropertyAttr_readwrite: CXObjCPropertyAttrKind { get } 4850 // public var CXObjCPropertyAttr_retain: CXObjCPropertyAttrKind { get } 4851 // public var CXObjCPropertyAttr_copy: CXObjCPropertyAttrKind { get } 4852 // public var CXObjCPropertyAttr_nonatomic: CXObjCPropertyAttrKind { get } 4853 // public var CXObjCPropertyAttr_setter: CXObjCPropertyAttrKind { get } 4854 // public var CXObjCPropertyAttr_atomic: CXObjCPropertyAttrKind { get } 4855 // public var CXObjCPropertyAttr_weak: CXObjCPropertyAttrKind { get } 4856 // public var CXObjCPropertyAttr_strong: CXObjCPropertyAttrKind { get } 4857 // public var CXObjCPropertyAttr_unsafe_unretained: CXObjCPropertyAttrKind { get } 4858 4859 /** 4860 * \brief Given a cursor that represents a property declaration, return the 4861 * associated property attributes. The bits are formed from 4862 * \c CXObjCPropertyAttrKind. 4863 * 4864 * \param reserved Reserved for future use, pass 0. 4865 */ 4866 public func clang_Cursor_getObjCPropertyAttributes(C: CXCursor, _ reserved: UInt32) -> UInt32 { 4867 return _clang_Cursor_getObjCPropertyAttributes(C: C, reserved: reserved) 4868 } 4869 private let _clang_Cursor_getObjCPropertyAttributes
created_Index.swift:4830 : @convention(c) (C: CXCursor, reserved: UInt32) -> UInt32 = library.loadSymbol("clang_Cursor_getObjCPropertyAttributes") 4870 4871 4872 /** 4873 * \brief 'Qualifiers' written next to the return and parameter types in 4874 * Objective-C method declarations. 4875 */ 4876 /* 4877 public struct CXObjCDeclQualifierKind : RawRepresentable, Equatable { 4878 public init(_ rawValue: UInt32) 4879 public init(rawValue: UInt32) 4880 // public var rawValue: UInt32 4881 } 4882 */ 4883 // public var CXObjCDeclQualifier_None: CXObjCDeclQualifierKind { get } 4884 // public var CXObjCDeclQualifier_In: CXObjCDeclQualifierKind { get } 4885 // public var CXObjCDeclQualifier_Inout: CXObjCDeclQualifierKind { get } 4886 // public var CXObjCDeclQualifier_Out: CXObjCDeclQualifierKind { get } 4887 // public var CXObjCDeclQualifier_Bycopy: CXObjCDeclQualifierKind { get } 4888 // public var CXObjCDeclQualifier_Byref: CXObjCDeclQualifierKind { get } 4889 // public var CXObjCDeclQualifier_Oneway: CXObjCDeclQualifierKind { get } 4890 4891 /** 4892 * \brief Given a cursor that represents an Objective-C method or parameter 4893 * declaration, return the associated Objective-C qualifiers for the return 4894 * type or the parameter respectively. The bits are formed from 4895 * CXObjCDeclQualifierKind. 4896 */ 4897 public func clang_Cursor_getObjCDeclQualifiers(C: CXCursor) -> UInt32 { 4898 return _clang_Cursor_getObjCDeclQualifiers(C: C) 4899 } 4900 private let _clang_Cursor_getObjCDeclQualifiers
created_Index.swift:4867 : @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_Cursor_getObjCDeclQualifiers") 4901 4902 4903 /** 4904 * \brief Given a cursor that represents an Objective-C method or property 4905 * declaration, return non-zero if the declaration was affected by "@optional". 4906 * Returns zero if the cursor is not such a declaration or it is "@required". 4907 */ 4908 public func clang_Cursor_isObjCOptional(C: CXCursor) -> UInt32 { 4909 return _clang_Cursor_isObjCOptional(C: C) 4910 } 4911 private let _clang_Cursor_isObjCOptional
created_Index.swift:4898 : @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_Cursor_isObjCOptional") 4912 4913 4914 /** 4915 * \brief Returns non-zero if the given cursor is a variadic function or method. 4916 */ 4917 public func clang_Cursor_isVariadic(C: CXCursor) -> UInt32 { 4918 return _clang_Cursor_isVariadic(C: C) 4919 } 4920 private let _clang_Cursor_isVariadic
created_Index.swift:4909 : @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_Cursor_isVariadic") 4921 4922 4923 /** 4924 * \brief Given a cursor that represents a declaration, return the associated 4925 * comment's source range. The range may include multiple consecutive comments 4926 * with whitespace in between. 4927 */ 4928 public func clang_Cursor_getCommentRange(C: CXCursor) -> CXSourceRange { 4929 return _clang_Cursor_getCommentRange(C: C) 4930 } 4931 private let _clang_Cursor_getCommentRange
created_Index.swift:4918 : @convention(c) (C: CXCursor) -> CXSourceRange = library.loadSymbol("clang_Cursor_getCommentRange") 4932 4933 4934 /** 4935 * \brief Given a cursor that represents a declaration, return the associated 4936 * comment text, including comment markers. 4937 */ 4938 public func clang_Cursor_getRawCommentText
created_Index.swift:4929 (C: CXCursor) -> CXString { 4939 return _clang_Cursor_getRawCommentText(C: C) 4940 } 4941 private let _clang_Cursor_getRawCommentText
Clang+SourceKitten.swift:141 : @convention(c) (C: CXCursor) -> CXString = library.loadSymbol("clang_Cursor_getRawCommentText") 4942 4943 4944 /** 4945 * \brief Given a cursor that represents a documentable entity (e.g., 4946 * declaration), return the associated \\brief paragraph; otherwise return the 4947 * first paragraph. 4948 */ 4949 public func clang_Cursor_getBriefCommentText(C: CXCursor) -> CXString { 4950 return _clang_Cursor_getBriefCommentText(C: C) 4951 } 4952 private let _clang_Cursor_getBriefCommentText
created_Index.swift:4939 : @convention(c) (C: CXCursor) -> CXString = library.loadSymbol("clang_Cursor_getBriefCommentText") 4953 4954 4955 /** 4956 * @} 4957 */ 4958 4959 /** \defgroup CINDEX_MANGLE Name Mangling API Functions 4960 * 4961 * @{ 4962 */ 4963 4964 /** 4965 * \brief Retrieve the CXString representing the mangled name of the cursor. 4966 */ 4967 public func clang_Cursor_getMangling(unnamed1: CXCursor) -> CXString { 4968 return _clang_Cursor_getMangling(unnamed1) 4969 } 4970 private let _clang_Cursor_getMangling
created_Index.swift:4950 : @convention(c) (_: CXCursor) -> CXString = library.loadSymbol("clang_Cursor_getMangling") 4971 4972 4973 /** 4974 * @} 4975 */ 4976 4977 4978 /** 4979 * \defgroup CINDEX_MODULE Module introspection 4980 * 4981 * The functions in this group provide access to information about modules. 4982 * 4983 * @{ 4984 */ 4985 // public typealias CXModule = UnsafeMutablePointer<Void> 4986 4987 /** 4988 * \brief Given a CXCursor_ModuleImportDecl cursor, return the associated module. 4989 */ 4990 public func clang_Cursor_getModule(C: CXCursor) -> CXModule { 4991 return _clang_Cursor_getModule(C: C) 4992 } 4993 private let _clang_Cursor_getModule
created_Index.swift:4968 : @convention(c) (C: CXCursor) -> CXModule = library.loadSymbol("clang_Cursor_getModule") 4994 4995 4996 /** 4997 * \brief Given a CXFile header file, return the module that contains it, if one 4998 * exists. 4999 */ 5000 public func clang_getModuleForFile(unnamed1: CXTranslationUnit, _ unnamed2: CXFile) -> CXModule { 5001 return _clang_getModuleForFile(unnamed1, unnamed2) 5002 } 5003 private let _clang_getModuleForFile
created_Index.swift:4991 : @convention(c) (_: CXTranslationUnit, _: CXFile) -> CXModule = library.loadSymbol("clang_getModuleForFile") 5004 5005 5006 /** 5007 * \param Module a module object. 5008 * 5009 * \returns the module file where the provided module object came from. 5010 */ 5011 public func clang_Module_getASTFile(Module: CXModule) -> CXFile { 5012 return _clang_Module_getASTFile(Module: Module) 5013 } 5014 private let _clang_Module_getASTFile
created_Index.swift:5001 : @convention(c) (Module: CXModule) -> CXFile = library.loadSymbol("clang_Module_getASTFile") 5015 5016 5017 /** 5018 * \param Module a module object. 5019 * 5020 * \returns the parent of a sub-module or NULL if the given module is top-level, 5021 * e.g. for 'std.vector' it will return the 'std' module. 5022 */ 5023 public func clang_Module_getParent(Module: CXModule) -> CXModule { 5024 return _clang_Module_getParent(Module: Module) 5025 } 5026 private let _clang_Module_getParent
created_Index.swift:5012 : @convention(c) (Module: CXModule) -> CXModule = library.loadSymbol("clang_Module_getParent") 5027 5028 5029 /** 5030 * \param Module a module object. 5031 * 5032 * \returns the name of the module, e.g. for the 'std.vector' sub-module it 5033 * will return "vector". 5034 */ 5035 public func clang_Module_getName(Module: CXModule) -> CXString { 5036 return _clang_Module_getName(Module: Module) 5037 } 5038 private let _clang_Module_getName
created_Index.swift:5024 : @convention(c) (Module: CXModule) -> CXString = library.loadSymbol("clang_Module_getName") 5039 5040 5041 /** 5042 * \param Module a module object. 5043 * 5044 * \returns the full name of the module, e.g. "std.vector". 5045 */ 5046 public func clang_Module_getFullName(Module: CXModule) -> CXString { 5047 return _clang_Module_getFullName(Module: Module) 5048 } 5049 private let _clang_Module_getFullName
created_Index.swift:5036 : @convention(c) (Module: CXModule) -> CXString = library.loadSymbol("clang_Module_getFullName") 5050 5051 5052 /** 5053 * \param Module a module object. 5054 * 5055 * \returns non-zero if the module is a system one. 5056 */ 5057 public func clang_Module_isSystem(Module: CXModule) -> Int32 { 5058 return _clang_Module_isSystem(Module: Module) 5059 } 5060 private let _clang_Module_isSystem
created_Index.swift:5047 : @convention(c) (Module: CXModule) -> Int32 = library.loadSymbol("clang_Module_isSystem") 5061 5062 5063 /** 5064 * \param Module a module object. 5065 * 5066 * \returns the number of top level headers associated with this module. 5067 */ 5068 public func clang_Module_getNumTopLevelHeaders(unnamed1: CXTranslationUnit, _ Module: CXModule) -> UInt32 { 5069 return _clang_Module_getNumTopLevelHeaders(unnamed1, Module: Module) 5070 } 5071 private let _clang_Module_getNumTopLevelHeaders
created_Index.swift:5058 : @convention(c) (_: CXTranslationUnit, Module: CXModule) -> UInt32 = library.loadSymbol("clang_Module_getNumTopLevelHeaders") 5072 5073 5074 5075 /** 5076 * \param Module a module object. 5077 * 5078 * \param Index top level header index (zero-based). 5079 * 5080 * \returns the specified top level header associated with the module. 5081 */ 5082 public func clang_Module_getTopLevelHeader(unnamed1: CXTranslationUnit, _ Module: CXModule, _ Index: UInt32) -> CXFile { 5083 return _clang_Module_getTopLevelHeader(unnamed1, Module: Module, Index: Index) 5084 } 5085 private let _clang_Module_getTopLevelHeader
created_Index.swift:5069 : @convention(c) (_: CXTranslationUnit, Module: CXModule, Index: UInt32) -> CXFile = library.loadSymbol("clang_Module_getTopLevelHeader") 5086 5087 5088 /** 5089 * @} 5090 */ 5091 5092 /** 5093 * \defgroup CINDEX_CPP C++ AST introspection 5094 * 5095 * The routines in this group provide access information in the ASTs specific 5096 * to C++ language features. 5097 * 5098 * @{ 5099 */ 5100 5101 /** 5102 * \brief Determine if a C++ field is declared 'mutable'. 5103 */ 5104 public func clang_CXXField_isMutable(C: CXCursor) -> UInt32 { 5105 return _clang_CXXField_isMutable(C: C) 5106 } 5107 private let _clang_CXXField_isMutable
created_Index.swift:5083 : @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_CXXField_isMutable") 5108 5109 5110 /** 5111 * \brief Determine if a C++ member function or member function template is 5112 * pure virtual. 5113 */ 5114 public func clang_CXXMethod_isPureVirtual(C: CXCursor) -> UInt32 { 5115 return _clang_CXXMethod_isPureVirtual(C: C) 5116 } 5117 private let _clang_CXXMethod_isPureVirtual
created_Index.swift:5105 : @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_CXXMethod_isPureVirtual") 5118 5119 5120 /** 5121 * \brief Determine if a C++ member function or member function template is 5122 * declared 'static'. 5123 */ 5124 public func clang_CXXMethod_isStatic(C: CXCursor) -> UInt32 { 5125 return _clang_CXXMethod_isStatic(C: C) 5126 } 5127 private let _clang_CXXMethod_isStatic
created_Index.swift:5115 : @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_CXXMethod_isStatic") 5128 5129 5130 /** 5131 * \brief Determine if a C++ member function or member function template is 5132 * explicitly declared 'virtual' or if it overrides a virtual method from 5133 * one of the base classes. 5134 */ 5135 public func clang_CXXMethod_isVirtual(C: CXCursor) -> UInt32 { 5136 return _clang_CXXMethod_isVirtual(C: C) 5137 } 5138 private let _clang_CXXMethod_isVirtual
created_Index.swift:5125 : @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_CXXMethod_isVirtual") 5139 5140 5141 /** 5142 * \brief Determine if a C++ member function or member function template is 5143 * declared 'const'. 5144 */ 5145 public func clang_CXXMethod_isConst(C: CXCursor) -> UInt32 { 5146 return _clang_CXXMethod_isConst(C: C) 5147 } 5148 private let _clang_CXXMethod_isConst
created_Index.swift:5136 : @convention(c) (C: CXCursor) -> UInt32 = library.loadSymbol("clang_CXXMethod_isConst") 5149 5150 5151 /** 5152 * \brief Given a cursor that represents a template, determine 5153 * the cursor kind of the specializations would be generated by instantiating 5154 * the template. 5155 * 5156 * This routine can be used to determine what flavor of function template, 5157 * class template, or class template partial specialization is stored in the 5158 * cursor. For example, it can describe whether a class template cursor is 5159 * declared with "struct", "class" or "union". 5160 * 5161 * \param C The cursor to query. This cursor should represent a template 5162 * declaration. 5163 * 5164 * \returns The cursor kind of the specializations that would be generated 5165 * by instantiating the template \p C. If \p C is not a template, returns 5166 * \c CXCursor_NoDeclFound. 5167 */ 5168 public func clang_getTemplateCursorKind(C: CXCursor) -> CXCursorKind { 5169 return _clang_getTemplateCursorKind(C: C) 5170 } 5171 private let _clang_getTemplateCursorKind
created_Index.swift:5146 : @convention(c) (C: CXCursor) -> CXCursorKind = library.loadSymbol("clang_getTemplateCursorKind") 5172 5173 5174 /** 5175 * \brief Given a cursor that may represent a specialization or instantiation 5176 * of a template, retrieve the cursor that represents the template that it 5177 * specializes or from which it was instantiated. 5178 * 5179 * This routine determines the template involved both for explicit 5180 * specializations of templates and for implicit instantiations of the template, 5181 * both of which are referred to as "specializations". For a class template 5182 * specialization (e.g., \c std::vector<bool>), this routine will return 5183 * either the primary template (\c std::vector) or, if the specialization was 5184 * instantiated from a class template partial specialization, the class template 5185 * partial specialization. For a class template partial specialization and a 5186 * function template specialization (including instantiations), this 5187 * this routine will return the specialized template. 5188 * 5189 * For members of a class template (e.g., member functions, member classes, or 5190 * static data members), returns the specialized or instantiated member. 5191 * Although not strictly "templates" in the C++ language, members of class 5192 * templates have the same notions of specializations and instantiations that 5193 * templates do, so this routine treats them similarly. 5194 * 5195 * \param C A cursor that may be a specialization of a template or a member 5196 * of a template. 5197 * 5198 * \returns If the given cursor is a specialization or instantiation of a 5199 * template or a member thereof, the template or member that it specializes or 5200 * from which it was instantiated. Otherwise, returns a NULL cursor. 5201 */ 5202 public func clang_getSpecializedCursorTemplate(C: CXCursor) -> CXCursor { 5203 return _clang_getSpecializedCursorTemplate(C: C) 5204 } 5205 private let _clang_getSpecializedCursorTemplate
created_Index.swift:5169 : @convention(c) (C: CXCursor) -> CXCursor = library.loadSymbol("clang_getSpecializedCursorTemplate") 5206 5207 5208 /** 5209 * \brief Given a cursor that references something else, return the source range 5210 * covering that reference. 5211 * 5212 * \param C A cursor pointing to a member reference, a declaration reference, or 5213 * an operator call. 5214 * \param NameFlags A bitset with three independent flags: 5215 * CXNameRange_WantQualifier, CXNameRange_WantTemplateArgs, and 5216 * CXNameRange_WantSinglePiece. 5217 * \param PieceIndex For contiguous names or when passing the flag 5218 * CXNameRange_WantSinglePiece, only one piece with index 0 is 5219 * available. When the CXNameRange_WantSinglePiece flag is not passed for a 5220 * non-contiguous names, this index can be used to retrieve the individual 5221 * pieces of the name. See also CXNameRange_WantSinglePiece. 5222 * 5223 * \returns The piece of the name pointed to by the given cursor. If there is no 5224 * name, or if the PieceIndex is out-of-range, a null-cursor will be returned. 5225 */ 5226 public func clang_getCursorReferenceNameRange(C: CXCursor, _ NameFlags: UInt32, _ PieceIndex: UInt32) -> CXSourceRange { 5227 return _clang_getCursorReferenceNameRange(C: C, NameFlags: NameFlags, PieceIndex: PieceIndex) 5228 } 5229 private let _clang_getCursorReferenceNameRange
created_Index.swift:5203 : @convention(c) (C: CXCursor, NameFlags: UInt32, PieceIndex: UInt32) -> CXSourceRange = library.loadSymbol("clang_getCursorReferenceNameRange") 5230 5231 5232 /* 5233 public struct CXNameRefFlags : RawRepresentable, Equatable { 5234 public init(_ rawValue: UInt32) 5235 public init(rawValue: UInt32) 5236 // public var rawValue: UInt32 5237 } 5238 */ 5239 5240 /** 5241 * \brief Include the nested-name-specifier, e.g. Foo:: in x.Foo::y, in the 5242 * range. 5243 */ 5244 // public var CXNameRange_WantQualifier: CXNameRefFlags { get } 5245 5246 /** 5247 * \brief Include the explicit template arguments, e.g. \<int> in x.f<int>, 5248 * in the range. 5249 */ 5250 // public var CXNameRange_WantTemplateArgs: CXNameRefFlags { get } 5251 5252 /** 5253 * \brief If the name is non-contiguous, return the full spanning range. 5254 * 5255 * Non-contiguous names occur in Objective-C when a selector with two or more 5256 * parameters is used, or in C++ when using an operator: 5257 * \code 5258 * [object doSomething:here withValue:there]; // Objective-C 5259 * return some_vector[1]; // C++ 5260 * \endcode 5261 */ 5262 // public var CXNameRange_WantSinglePiece: CXNameRefFlags { get } 5263 5264 /** 5265 * @} 5266 */ 5267 5268 /** 5269 * \defgroup CINDEX_LEX Token extraction and manipulation 5270 * 5271 * The routines in this group provide access to the tokens within a 5272 * translation unit, along with a semantic mapping of those tokens to 5273 * their corresponding cursors. 5274 * 5275 * @{ 5276 */ 5277 5278 /** 5279 * \brief Describes a kind of token. 5280 */ 5281 /* 5282 public struct CXTokenKind : RawRepresentable, Equatable { 5283 public init(_ rawValue: UInt32) 5284 public init(rawValue: UInt32) 5285 // public var rawValue: UInt32 5286 } 5287 */ 5288 5289 /** 5290 * \brief A token that contains some kind of punctuation. 5291 */ 5292 // public var CXToken_Punctuation: CXTokenKind { get } 5293 5294 /** 5295 * \brief A language keyword. 5296 */ 5297 // public var CXToken_Keyword: CXTokenKind { get } 5298 5299 /** 5300 * \brief An identifier (that is not a keyword). 5301 */ 5302 // public var CXToken_Identifier: CXTokenKind { get } 5303 5304 /** 5305 * \brief A numeric, string, or character literal. 5306 */ 5307 // public var CXToken_Literal: CXTokenKind { get } 5308 5309 /** 5310 * \brief A comment. 5311 */ 5312 // public var CXToken_Comment: CXTokenKind { get } 5313 5314 /** 5315 * \brief Describes a single preprocessing token. 5316 */ 5317 /* 5318 public struct CXToken { 5319 // public var int_data: (UInt32, UInt32, UInt32, UInt32) 5320 // public var ptr_data: UnsafeMutablePointer<Void> 5321 public init() 5322 public init(int_data: (UInt32, UInt32, UInt32, UInt32), ptr_data: UnsafeMutablePointer<Void>) 5323 } 5324 */ 5325 5326 /** 5327 * \brief Determine the kind of the given token. 5328 */ 5329 public func clang_getTokenKind(unnamed1: CXToken) -> CXTokenKind { 5330 return _clang_getTokenKind(unnamed1) 5331 } 5332 private let _clang_getTokenKind
created_Index.swift:5227 : @convention(c) (_: CXToken) -> CXTokenKind = library.loadSymbol("clang_getTokenKind") 5333 5334 5335 /** 5336 * \brief Determine the spelling of the given token. 5337 * 5338 * The spelling of a token is the textual representation of that token, e.g., 5339 * the text of an identifier or keyword. 5340 */ 5341 public func clang_getTokenSpelling(unnamed1: CXTranslationUnit, _ unnamed2: CXToken) -> CXString { 5342 return _clang_getTokenSpelling(unnamed1, unnamed2) 5343 } 5344 private let _clang_getTokenSpelling
created_Index.swift:5330 : @convention(c) (_: CXTranslationUnit, _: CXToken) -> CXString = library.loadSymbol("clang_getTokenSpelling") 5345 5346 5347 /** 5348 * \brief Retrieve the source location of the given token. 5349 */ 5350 public func clang_getTokenLocation(unnamed1: CXTranslationUnit, _ unnamed2: CXToken) -> CXSourceLocation { 5351 return _clang_getTokenLocation(unnamed1, unnamed2) 5352 } 5353 private let _clang_getTokenLocation
created_Index.swift:5342 : @convention(c) (_: CXTranslationUnit, _: CXToken) -> CXSourceLocation = library.loadSymbol("clang_getTokenLocation") 5354 5355 5356 /** 5357 * \brief Retrieve a source range that covers the given token. 5358 */ 5359 public func clang_getTokenExtent(unnamed1: CXTranslationUnit, _ unnamed2: CXToken) -> CXSourceRange { 5360 return _clang_getTokenExtent(unnamed1, unnamed2) 5361 } 5362 private let _clang_getTokenExtent
created_Index.swift:5351 : @convention(c) (_: CXTranslationUnit, _: CXToken) -> CXSourceRange = library.loadSymbol("clang_getTokenExtent") 5363 5364 5365 /** 5366 * \brief Tokenize the source code described by the given range into raw 5367 * lexical tokens. 5368 * 5369 * \param TU the translation unit whose text is being tokenized. 5370 * 5371 * \param Range the source range in which text should be tokenized. All of the 5372 * tokens produced by tokenization will fall within this source range, 5373 * 5374 * \param Tokens this pointer will be set to point to the array of tokens 5375 * that occur within the given source range. The returned pointer must be 5376 * freed with clang_disposeTokens() before the translation unit is destroyed. 5377 * 5378 * \param NumTokens will be set to the number of tokens in the \c *Tokens 5379 * array. 5380 * 5381 */ 5382 public func clang_tokenize(TU: CXTranslationUnit, _ Range: CXSourceRange, _ Tokens: UnsafeMutablePointer<UnsafeMutablePointer<CXToken>>, _ NumTokens: UnsafeMutablePointer<UInt32>) { 5383 return _clang_tokenize(TU: TU, Range: Range, Tokens: Tokens, NumTokens: NumTokens) 5384 } 5385 private let _clang_tokenize
created_Index.swift:5360 : @convention(c) (TU: CXTranslationUnit, Range: CXSourceRange, Tokens: UnsafeMutablePointer<UnsafeMutablePointer<CXToken>>, NumTokens: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_tokenize") 5386 5387 5388 /** 5389 * \brief Annotate the given set of tokens by providing cursors for each token 5390 * that can be mapped to a specific entity within the abstract syntax tree. 5391 * 5392 * This token-annotation routine is equivalent to invoking 5393 * clang_getCursor() for the source locations of each of the 5394 * tokens. The cursors provided are filtered, so that only those 5395 * cursors that have a direct correspondence to the token are 5396 * accepted. For example, given a function call \c f(x), 5397 * clang_getCursor() would provide the following cursors: 5398 * 5399 * * when the cursor is over the 'f', a DeclRefExpr cursor referring to 'f'. 5400 * * when the cursor is over the '(' or the ')', a CallExpr referring to 'f'. 5401 * * when the cursor is over the 'x', a DeclRefExpr cursor referring to 'x'. 5402 * 5403 * Only the first and last of these cursors will occur within the 5404 * annotate, since the tokens "f" and "x' directly refer to a function 5405 * and a variable, respectively, but the parentheses are just a small 5406 * part of the full syntax of the function call expression, which is 5407 * not provided as an annotation. 5408 * 5409 * \param TU the translation unit that owns the given tokens. 5410 * 5411 * \param Tokens the set of tokens to annotate. 5412 * 5413 * \param NumTokens the number of tokens in \p Tokens. 5414 * 5415 * \param Cursors an array of \p NumTokens cursors, whose contents will be 5416 * replaced with the cursors corresponding to each token. 5417 */ 5418 public func clang_annotateTokens(TU: CXTranslationUnit, _ Tokens: UnsafeMutablePointer<CXToken>, _ NumTokens: UInt32, _ Cursors: UnsafeMutablePointer<CXCursor>) { 5419 return _clang_annotateTokens(TU: TU, Tokens: Tokens, NumTokens: NumTokens, Cursors: Cursors) 5420 } 5421 private let _clang_annotateTokens
created_Index.swift:5383 : @convention(c) (TU: CXTranslationUnit, Tokens: UnsafeMutablePointer<CXToken>, NumTokens: UInt32, Cursors: UnsafeMutablePointer<CXCursor>) -> () = library.loadSymbol("clang_annotateTokens") 5422 5423 5424 /** 5425 * \brief Free the given set of tokens. 5426 */ 5427 public func clang_disposeTokens(TU: CXTranslationUnit, _ Tokens: UnsafeMutablePointer<CXToken>, _ NumTokens: UInt32) { 5428 return _clang_disposeTokens(TU: TU, Tokens: Tokens, NumTokens: NumTokens) 5429 } 5430 private let _clang_disposeTokens
created_Index.swift:5419 : @convention(c) (TU: CXTranslationUnit, Tokens: UnsafeMutablePointer<CXToken>, NumTokens: UInt32) -> () = library.loadSymbol("clang_disposeTokens") 5431 5432 5433 /** 5434 * @} 5435 */ 5436 5437 5438 /* for debug/testing */ 5439 /** 5440 * \defgroup CINDEX_DEBUG Debugging facilities 5441 * 5442 * These routines are used for testing and debugging, only, and should not 5443 * be relied upon. 5444 * 5445 * @{ 5446 */ 5447 public func clang_getCursorKindSpelling
created_Index.swift:5428 (Kind: CXCursorKind) -> CXString { 5448 return _clang_getCursorKindSpelling(Kind: Kind) 5449 } 5450 private let _clang_getCursorKindSpelling
ObjCDeclarationKind.swift:71 default: fatalError("Unsupported CXCursorKind: \(clang_getCursorKindSpelling(kind))"): @convention(c) (Kind: CXCursorKind) -> CXString = library.loadSymbol("clang_getCursorKindSpelling") 5451 5452 public func clang_getDefinitionSpellingAndExtent(unnamed1: CXCursor, _ startBuf: UnsafeMutablePointer<UnsafePointer<Int8>>, _ endBuf: UnsafeMutablePointer<UnsafePointer<Int8>>, _ startLine: UnsafeMutablePointer<UInt32>, _ startColumn: UnsafeMutablePointer<UInt32>, _ endLine: UnsafeMutablePointer<UInt32>, _ endColumn: UnsafeMutablePointer<UInt32>) { 5453 return _clang_getDefinitionSpellingAndExtent(unnamed1, startBuf: startBuf, endBuf: endBuf, startLine: startLine, startColumn: startColumn, endLine: endLine, endColumn: endColumn) 5454 } 5455 private let _clang_getDefinitionSpellingAndExtent
created_Index.swift:5448 : @convention(c) (_: CXCursor, startBuf: UnsafeMutablePointer<UnsafePointer<Int8>>, endBuf: UnsafeMutablePointer<UnsafePointer<Int8>>, startLine: UnsafeMutablePointer<UInt32>, startColumn: UnsafeMutablePointer<UInt32>, endLine: UnsafeMutablePointer<UInt32>, endColumn: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_getDefinitionSpellingAndExtent") 5456 5457 public func clang_enableStackTraces() { 5458 return _clang_enableStackTraces() 5459 } 5460 private let _clang_enableStackTraces
created_Index.swift:5453 : @convention(c) () -> () = library.loadSymbol("clang_enableStackTraces") 5461 5462 public func clang_executeOnThread(fn: (@convention(c) (UnsafeMutablePointer<Void>) -> Void)!, _ user_data: UnsafeMutablePointer<Void>, _ stack_size: UInt32) { 5463 return _clang_executeOnThread(fn: fn, user_data: user_data, stack_size: stack_size) 5464 } 5465 private let _clang_executeOnThread
created_Index.swift:5458 : @convention(c) (fn: (@convention(c) (UnsafeMutablePointer<Void>) -> Void)!, user_data: UnsafeMutablePointer<Void>, stack_size: UInt32) -> () = library.loadSymbol("clang_executeOnThread") 5466 5467 5468 /** 5469 * @} 5470 */ 5471 5472 /** 5473 * \defgroup CINDEX_CODE_COMPLET Code completion 5474 * 5475 * Code completion involves taking an (incomplete) source file, along with 5476 * knowledge of where the user is actively editing that file, and suggesting 5477 * syntactically- and semantically-valid constructs that the user might want to 5478 * use at that particular point in the source code. These data structures and 5479 * routines provide support for code completion. 5480 * 5481 * @{ 5482 */ 5483 5484 /** 5485 * \brief A semantic string that describes a code-completion result. 5486 * 5487 * A semantic string that describes the formatting of a code-completion 5488 * result as a single "template" of text that should be inserted into the 5489 * source buffer when a particular code-completion result is selected. 5490 * Each semantic string is made up of some number of "chunks", each of which 5491 * contains some text along with a description of what that text means, e.g., 5492 * the name of the entity being referenced, whether the text chunk is part of 5493 * the template, or whether it is a "placeholder" that the user should replace 5494 * with actual code,of a specific kind. See \c CXCompletionChunkKind for a 5495 * description of the different kinds of chunks. 5496 */ 5497 // public typealias CXCompletionString = UnsafeMutablePointer<Void> 5498 5499 /** 5500 * \brief A single result of code completion. 5501 */ 5502 /* 5503 public struct CXCompletionResult { 5504 /** 5505 * \brief The kind of entity that this completion refers to. 5506 * 5507 * The cursor kind will be a macro, keyword, or a declaration (one of the 5508 * *Decl cursor kinds), describing the entity that the completion is 5509 * referring to. 5510 * 5511 * \todo In the future, we would like to provide a full cursor, to allow 5512 * the client to extract additional information from declaration. 5513 */ 5514 // public var CursorKind: CXCursorKind 5515 5516 /** 5517 * \brief The code-completion string that describes how to insert this 5518 * code-completion result into the editing buffer. 5519 */ 5520 // public var CompletionString: CXCompletionString 5521 public init() 5522 public init(CursorKind: CXCursorKind, CompletionString: CXCompletionString) 5523 } 5524 */ 5525 5526 /** 5527 * \brief Describes a single piece of text within a code-completion string. 5528 * 5529 * Each "chunk" within a code-completion string (\c CXCompletionString) is 5530 * either a piece of text with a specific "kind" that describes how that text 5531 * should be interpreted by the client or is another completion string. 5532 */ 5533 /* 5534 public struct CXCompletionChunkKind : RawRepresentable, Equatable { 5535 public init(_ rawValue: UInt32) 5536 public init(rawValue: UInt32) 5537 // public var rawValue: UInt32 5538 } 5539 */ 5540 5541 /** 5542 * \brief A code-completion string that describes "optional" text that 5543 * could be a part of the template (but is not required). 5544 * 5545 * The Optional chunk is the only kind of chunk that has a code-completion 5546 * string for its representation, which is accessible via 5547 * \c clang_getCompletionChunkCompletionString(). The code-completion string 5548 * describes an additional part of the template that is completely optional. 5549 * For example, optional chunks can be used to describe the placeholders for 5550 * arguments that match up with defaulted function parameters, e.g. given: 5551 * 5552 * \code 5553 * void f(int x, float y = 3.14, double z = 2.71828); 5554 * \endcode 5555 * 5556 * The code-completion string for this function would contain: 5557 * - a TypedText chunk for "f". 5558 * - a LeftParen chunk for "(". 5559 * - a Placeholder chunk for "int x" 5560 * - an Optional chunk containing the remaining defaulted arguments, e.g., 5561 * - a Comma chunk for "," 5562 * - a Placeholder chunk for "float y" 5563 * - an Optional chunk containing the last defaulted argument: 5564 * - a Comma chunk for "," 5565 * - a Placeholder chunk for "double z" 5566 * - a RightParen chunk for ")" 5567 * 5568 * There are many ways to handle Optional chunks. Two simple approaches are: 5569 * - Completely ignore optional chunks, in which case the template for the 5570 * function "f" would only include the first parameter ("int x"). 5571 * - Fully expand all optional chunks, in which case the template for the 5572 * function "f" would have all of the parameters. 5573 */ 5574 // public var CXCompletionChunk_Optional: CXCompletionChunkKind { get } 5575 /** 5576 * \brief Text that a user would be expected to type to get this 5577 * code-completion result. 5578 * 5579 * There will be exactly one "typed text" chunk in a semantic string, which 5580 * will typically provide the spelling of a keyword or the name of a 5581 * declaration that could be used at the current code point. Clients are 5582 * expected to filter the code-completion results based on the text in this 5583 * chunk. 5584 */ 5585 // public var CXCompletionChunk_TypedText: CXCompletionChunkKind { get } 5586 /** 5587 * \brief Text that should be inserted as part of a code-completion result. 5588 * 5589 * A "text" chunk represents text that is part of the template to be 5590 * inserted into user code should this particular code-completion result 5591 * be selected. 5592 */ 5593 // public var CXCompletionChunk_Text: CXCompletionChunkKind { get } 5594 /** 5595 * \brief Placeholder text that should be replaced by the user. 5596 * 5597 * A "placeholder" chunk marks a place where the user should insert text 5598 * into the code-completion template. For example, placeholders might mark 5599 * the function parameters for a function declaration, to indicate that the 5600 * user should provide arguments for each of those parameters. The actual 5601 * text in a placeholder is a suggestion for the text to display before 5602 * the user replaces the placeholder with real code. 5603 */ 5604 // public var CXCompletionChunk_Placeholder: CXCompletionChunkKind { get } 5605 /** 5606 * \brief Informative text that should be displayed but never inserted as 5607 * part of the template. 5608 * 5609 * An "informative" chunk contains annotations that can be displayed to 5610 * help the user decide whether a particular code-completion result is the 5611 * right option, but which is not part of the actual template to be inserted 5612 * by code completion. 5613 */ 5614 // public var CXCompletionChunk_Informative: CXCompletionChunkKind { get } 5615 /** 5616 * \brief Text that describes the current parameter when code-completion is 5617 * referring to function call, message send, or template specialization. 5618 * 5619 * A "current parameter" chunk occurs when code-completion is providing 5620 * information about a parameter corresponding to the argument at the 5621 * code-completion point. For example, given a function 5622 * 5623 * \code 5624 * int add(int x, int y); 5625 * \endcode 5626 * 5627 * and the source code \c add(, where the code-completion point is after the 5628 * "(", the code-completion string will contain a "current parameter" chunk 5629 * for "int x", indicating that the current argument will initialize that 5630 * parameter. After typing further, to \c add(17, (where the code-completion 5631 * point is after the ","), the code-completion string will contain a 5632 * "current paremeter" chunk to "int y". 5633 */ 5634 // public var CXCompletionChunk_CurrentParameter: CXCompletionChunkKind { get } 5635 /** 5636 * \brief A left parenthesis ('('), used to initiate a function call or 5637 * signal the beginning of a function parameter list. 5638 */ 5639 // public var CXCompletionChunk_LeftParen: CXCompletionChunkKind { get } 5640 /** 5641 * \brief A right parenthesis (')'), used to finish a function call or 5642 * signal the end of a function parameter list. 5643 */ 5644 // public var CXCompletionChunk_RightParen: CXCompletionChunkKind { get } 5645 /** 5646 * \brief A left bracket ('['). 5647 */ 5648 // public var CXCompletionChunk_LeftBracket: CXCompletionChunkKind { get } 5649 /** 5650 * \brief A right bracket (']'). 5651 */ 5652 // public var CXCompletionChunk_RightBracket: CXCompletionChunkKind { get } 5653 /** 5654 * \brief A left brace ('{'). 5655 */ 5656 // public var CXCompletionChunk_LeftBrace: CXCompletionChunkKind { get } 5657 /** 5658 * \brief A right brace ('}'). 5659 */ 5660 // public var CXCompletionChunk_RightBrace: CXCompletionChunkKind { get } 5661 /** 5662 * \brief A left angle bracket ('<'). 5663 */ 5664 // public var CXCompletionChunk_LeftAngle: CXCompletionChunkKind { get } 5665 /** 5666 * \brief A right angle bracket ('>'). 5667 */ 5668 // public var CXCompletionChunk_RightAngle: CXCompletionChunkKind { get } 5669 /** 5670 * \brief A comma separator (','). 5671 */ 5672 // public var CXCompletionChunk_Comma: CXCompletionChunkKind { get } 5673 /** 5674 * \brief Text that specifies the result type of a given result. 5675 * 5676 * This special kind of informative chunk is not meant to be inserted into 5677 * the text buffer. Rather, it is meant to illustrate the type that an 5678 * expression using the given completion string would have. 5679 */ 5680 // public var CXCompletionChunk_ResultType: CXCompletionChunkKind { get } 5681 /** 5682 * \brief A colon (':'). 5683 */ 5684 // public var CXCompletionChunk_Colon: CXCompletionChunkKind { get } 5685 /** 5686 * \brief A semicolon (';'). 5687 */ 5688 // public var CXCompletionChunk_SemiColon: CXCompletionChunkKind { get } 5689 /** 5690 * \brief An '=' sign. 5691 */ 5692 // public var CXCompletionChunk_Equal: CXCompletionChunkKind { get } 5693 /** 5694 * Horizontal space (' '). 5695 */ 5696 // public var CXCompletionChunk_HorizontalSpace: CXCompletionChunkKind { get } 5697 /** 5698 * Vertical space ('\n'), after which it is generally a good idea to 5699 * perform indentation. 5700 */ 5701 // public var CXCompletionChunk_VerticalSpace: CXCompletionChunkKind { get } 5702 5703 /** 5704 * \brief Determine the kind of a particular chunk within a completion string. 5705 * 5706 * \param completion_string the completion string to query. 5707 * 5708 * \param chunk_number the 0-based index of the chunk in the completion string. 5709 * 5710 * \returns the kind of the chunk at the index \c chunk_number. 5711 */ 5712 public func clang_getCompletionChunkKind(completion_string: CXCompletionString, _ chunk_number: UInt32) -> CXCompletionChunkKind { 5713 return _clang_getCompletionChunkKind(completion_string: completion_string, chunk_number: chunk_number) 5714 } 5715 private let _clang_getCompletionChunkKind
created_Index.swift:5463 : @convention(c) (completion_string: CXCompletionString, chunk_number: UInt32) -> CXCompletionChunkKind = library.loadSymbol("clang_getCompletionChunkKind") 5716 5717 5718 /** 5719 * \brief Retrieve the text associated with a particular chunk within a 5720 * completion string. 5721 * 5722 * \param completion_string the completion string to query. 5723 * 5724 * \param chunk_number the 0-based index of the chunk in the completion string. 5725 * 5726 * \returns the text associated with the chunk at index \c chunk_number. 5727 */ 5728 public func clang_getCompletionChunkText(completion_string: CXCompletionString, _ chunk_number: UInt32) -> CXString { 5729 return _clang_getCompletionChunkText(completion_string: completion_string, chunk_number: chunk_number) 5730 } 5731 private let _clang_getCompletionChunkText
created_Index.swift:5713 : @convention(c) (completion_string: CXCompletionString, chunk_number: UInt32) -> CXString = library.loadSymbol("clang_getCompletionChunkText") 5732 5733 5734 /** 5735 * \brief Retrieve the completion string associated with a particular chunk 5736 * within a completion string. 5737 * 5738 * \param completion_string the completion string to query. 5739 * 5740 * \param chunk_number the 0-based index of the chunk in the completion string. 5741 * 5742 * \returns the completion string associated with the chunk at index 5743 * \c chunk_number. 5744 */ 5745 public func clang_getCompletionChunkCompletionString(completion_string: CXCompletionString, _ chunk_number: UInt32) -> CXCompletionString { 5746 return _clang_getCompletionChunkCompletionString(completion_string: completion_string, chunk_number: chunk_number) 5747 } 5748 private let _clang_getCompletionChunkCompletionString
created_Index.swift:5729 : @convention(c) (completion_string: CXCompletionString, chunk_number: UInt32) -> CXCompletionString = library.loadSymbol("clang_getCompletionChunkCompletionString") 5749 5750 5751 /** 5752 * \brief Retrieve the number of chunks in the given code-completion string. 5753 */ 5754 public func clang_getNumCompletionChunks(completion_string: CXCompletionString) -> UInt32 { 5755 return _clang_getNumCompletionChunks(completion_string: completion_string) 5756 } 5757 private let _clang_getNumCompletionChunks
created_Index.swift:5746 : @convention(c) (completion_string: CXCompletionString) -> UInt32 = library.loadSymbol("clang_getNumCompletionChunks") 5758 5759 5760 /** 5761 * \brief Determine the priority of this code completion. 5762 * 5763 * The priority of a code completion indicates how likely it is that this 5764 * particular completion is the completion that the user will select. The 5765 * priority is selected by various internal heuristics. 5766 * 5767 * \param completion_string The completion string to query. 5768 * 5769 * \returns The priority of this completion string. Smaller values indicate 5770 * higher-priority (more likely) completions. 5771 */ 5772 public func clang_getCompletionPriority(completion_string: CXCompletionString) -> UInt32 { 5773 return _clang_getCompletionPriority(completion_string: completion_string) 5774 } 5775 private let _clang_getCompletionPriority
created_Index.swift:5755 : @convention(c) (completion_string: CXCompletionString) -> UInt32 = library.loadSymbol("clang_getCompletionPriority") 5776 5777 5778 /** 5779 * \brief Determine the availability of the entity that this code-completion 5780 * string refers to. 5781 * 5782 * \param completion_string The completion string to query. 5783 * 5784 * \returns The availability of the completion string. 5785 */ 5786 public func clang_getCompletionAvailability(completion_string: CXCompletionString) -> CXAvailabilityKind { 5787 return _clang_getCompletionAvailability(completion_string: completion_string) 5788 } 5789 private let _clang_getCompletionAvailability
created_Index.swift:5773 : @convention(c) (completion_string: CXCompletionString) -> CXAvailabilityKind = library.loadSymbol("clang_getCompletionAvailability") 5790 5791 5792 /** 5793 * \brief Retrieve the number of annotations associated with the given 5794 * completion string. 5795 * 5796 * \param completion_string the completion string to query. 5797 * 5798 * \returns the number of annotations associated with the given completion 5799 * string. 5800 */ 5801 public func clang_getCompletionNumAnnotations(completion_string: CXCompletionString) -> UInt32 { 5802 return _clang_getCompletionNumAnnotations(completion_string: completion_string) 5803 } 5804 private let _clang_getCompletionNumAnnotations
created_Index.swift:5787 : @convention(c) (completion_string: CXCompletionString) -> UInt32 = library.loadSymbol("clang_getCompletionNumAnnotations") 5805 5806 5807 /** 5808 * \brief Retrieve the annotation associated with the given completion string. 5809 * 5810 * \param completion_string the completion string to query. 5811 * 5812 * \param annotation_number the 0-based index of the annotation of the 5813 * completion string. 5814 * 5815 * \returns annotation string associated with the completion at index 5816 * \c annotation_number, or a NULL string if that annotation is not available. 5817 */ 5818 public func clang_getCompletionAnnotation(completion_string: CXCompletionString, _ annotation_number: UInt32) -> CXString { 5819 return _clang_getCompletionAnnotation(completion_string: completion_string, annotation_number: annotation_number) 5820 } 5821 private let _clang_getCompletionAnnotation
created_Index.swift:5802 : @convention(c) (completion_string: CXCompletionString, annotation_number: UInt32) -> CXString = library.loadSymbol("clang_getCompletionAnnotation") 5822 5823 5824 /** 5825 * \brief Retrieve the parent context of the given completion string. 5826 * 5827 * The parent context of a completion string is the semantic parent of 5828 * the declaration (if any) that the code completion represents. For example, 5829 * a code completion for an Objective-C method would have the method's class 5830 * or protocol as its context. 5831 * 5832 * \param completion_string The code completion string whose parent is 5833 * being queried. 5834 * 5835 * \param kind DEPRECATED: always set to CXCursor_NotImplemented if non-NULL. 5836 * 5837 * \returns The name of the completion parent, e.g., "NSObject" if 5838 * the completion string represents a method in the NSObject class. 5839 */ 5840 public func clang_getCompletionParent(completion_string: CXCompletionString, _ kind: UnsafeMutablePointer<CXCursorKind>) -> CXString { 5841 return _clang_getCompletionParent(completion_string: completion_string, kind: kind) 5842 } 5843 private let _clang_getCompletionParent
created_Index.swift:5819 : @convention(c) (completion_string: CXCompletionString, kind: UnsafeMutablePointer<CXCursorKind>) -> CXString = library.loadSymbol("clang_getCompletionParent") 5844 5845 5846 /** 5847 * \brief Retrieve the brief documentation comment attached to the declaration 5848 * that corresponds to the given completion string. 5849 */ 5850 public func clang_getCompletionBriefComment(completion_string: CXCompletionString) -> CXString { 5851 return _clang_getCompletionBriefComment(completion_string: completion_string) 5852 } 5853 private let _clang_getCompletionBriefComment
created_Index.swift:5841 : @convention(c) (completion_string: CXCompletionString) -> CXString = library.loadSymbol("clang_getCompletionBriefComment") 5854 5855 5856 /** 5857 * \brief Retrieve a completion string for an arbitrary declaration or macro 5858 * definition cursor. 5859 * 5860 * \param cursor The cursor to query. 5861 * 5862 * \returns A non-context-sensitive completion string for declaration and macro 5863 * definition cursors, or NULL for other kinds of cursors. 5864 */ 5865 public func clang_getCursorCompletionString(cursor: CXCursor) -> CXCompletionString { 5866 return _clang_getCursorCompletionString(cursor: cursor) 5867 } 5868 private let _clang_getCursorCompletionString
created_Index.swift:5851 : @convention(c) (cursor: CXCursor) -> CXCompletionString = library.loadSymbol("clang_getCursorCompletionString") 5869 5870 5871 /** 5872 * \brief Contains the results of code-completion. 5873 * 5874 * This data structure contains the results of code completion, as 5875 * produced by \c clang_codeCompleteAt(). Its contents must be freed by 5876 * \c clang_disposeCodeCompleteResults. 5877 */ 5878 /* 5879 public struct CXCodeCompleteResults { 5880 /** 5881 * \brief The code-completion results. 5882 */ 5883 // public var Results: UnsafeMutablePointer<CXCompletionResult> 5884 5885 /** 5886 * \brief The number of code-completion results stored in the 5887 * \c Results array. 5888 */ 5889 // public var NumResults: UInt32 5890 public init() 5891 public init(Results: UnsafeMutablePointer<CXCompletionResult>, NumResults: UInt32) 5892 } 5893 */ 5894 5895 /** 5896 * \brief Flags that can be passed to \c clang_codeCompleteAt() to 5897 * modify its behavior. 5898 * 5899 * The enumerators in this enumeration can be bitwise-OR'd together to 5900 * provide multiple options to \c clang_codeCompleteAt(). 5901 */ 5902 /* 5903 public struct CXCodeComplete_Flags : RawRepresentable, Equatable { 5904 public init(_ rawValue: UInt32) 5905 public init(rawValue: UInt32) 5906 // public var rawValue: UInt32 5907 } 5908 */ 5909 5910 /** 5911 * \brief Whether to include macros within the set of code 5912 * completions returned. 5913 */ 5914 // public var CXCodeComplete_IncludeMacros: CXCodeComplete_Flags { get } 5915 5916 /** 5917 * \brief Whether to include code patterns for language constructs 5918 * within the set of code completions, e.g., for loops. 5919 */ 5920 // public var CXCodeComplete_IncludeCodePatterns: CXCodeComplete_Flags { get } 5921 5922 /** 5923 * \brief Whether to include brief documentation within the set of code 5924 * completions returned. 5925 */ 5926 // public var CXCodeComplete_IncludeBriefComments: CXCodeComplete_Flags { get } 5927 5928 /** 5929 * \brief Bits that represent the context under which completion is occurring. 5930 * 5931 * The enumerators in this enumeration may be bitwise-OR'd together if multiple 5932 * contexts are occurring simultaneously. 5933 */ 5934 /* 5935 public struct CXCompletionContext : RawRepresentable, Equatable { 5936 public init(_ rawValue: UInt32) 5937 public init(rawValue: UInt32) 5938 // public var rawValue: UInt32 5939 } 5940 */ 5941 5942 /** 5943 * \brief The context for completions is unexposed, as only Clang results 5944 * should be included. (This is equivalent to having no context bits set.) 5945 */ 5946 // public var CXCompletionContext_Unexposed: CXCompletionContext { get } 5947 5948 /** 5949 * \brief Completions for any possible type should be included in the results. 5950 */ 5951 // public var CXCompletionContext_AnyType: CXCompletionContext { get } 5952 5953 /** 5954 * \brief Completions for any possible value (variables, function calls, etc.) 5955 * should be included in the results. 5956 */ 5957 // public var CXCompletionContext_AnyValue: CXCompletionContext { get } 5958 /** 5959 * \brief Completions for values that resolve to an Objective-C object should 5960 * be included in the results. 5961 */ 5962 // public var CXCompletionContext_ObjCObjectValue: CXCompletionContext { get } 5963 /** 5964 * \brief Completions for values that resolve to an Objective-C selector 5965 * should be included in the results. 5966 */ 5967 // public var CXCompletionContext_ObjCSelectorValue: CXCompletionContext { get } 5968 /** 5969 * \brief Completions for values that resolve to a C++ class type should be 5970 * included in the results. 5971 */ 5972 // public var CXCompletionContext_CXXClassTypeValue: CXCompletionContext { get } 5973 5974 /** 5975 * \brief Completions for fields of the member being accessed using the dot 5976 * operator should be included in the results. 5977 */ 5978 // public var CXCompletionContext_DotMemberAccess: CXCompletionContext { get } 5979 /** 5980 * \brief Completions for fields of the member being accessed using the arrow 5981 * operator should be included in the results. 5982 */ 5983 // public var CXCompletionContext_ArrowMemberAccess: CXCompletionContext { get } 5984 /** 5985 * \brief Completions for properties of the Objective-C object being accessed 5986 * using the dot operator should be included in the results. 5987 */ 5988 // public var CXCompletionContext_ObjCPropertyAccess: CXCompletionContext { get } 5989 5990 /** 5991 * \brief Completions for enum tags should be included in the results. 5992 */ 5993 // public var CXCompletionContext_EnumTag: CXCompletionContext { get } 5994 /** 5995 * \brief Completions for union tags should be included in the results. 5996 */ 5997 // public var CXCompletionContext_UnionTag: CXCompletionContext { get } 5998 /** 5999 * \brief Completions for struct tags should be included in the results. 6000 */ 6001 // public var CXCompletionContext_StructTag: CXCompletionContext { get } 6002 6003 /** 6004 * \brief Completions for C++ class names should be included in the results. 6005 */ 6006 // public var CXCompletionContext_ClassTag: CXCompletionContext { get } 6007 /** 6008 * \brief Completions for C++ namespaces and namespace aliases should be 6009 * included in the results. 6010 */ 6011 // public var CXCompletionContext_Namespace: CXCompletionContext { get } 6012 /** 6013 * \brief Completions for C++ nested name specifiers should be included in 6014 * the results. 6015 */ 6016 // public var CXCompletionContext_NestedNameSpecifier: CXCompletionContext { get } 6017 6018 /** 6019 * \brief Completions for Objective-C interfaces (classes) should be included 6020 * in the results. 6021 */ 6022 // public var CXCompletionContext_ObjCInterface: CXCompletionContext { get } 6023 /** 6024 * \brief Completions for Objective-C protocols should be included in 6025 * the results. 6026 */ 6027 // public var CXCompletionContext_ObjCProtocol: CXCompletionContext { get } 6028 /** 6029 * \brief Completions for Objective-C categories should be included in 6030 * the results. 6031 */ 6032 // public var CXCompletionContext_ObjCCategory: CXCompletionContext { get } 6033 /** 6034 * \brief Completions for Objective-C instance messages should be included 6035 * in the results. 6036 */ 6037 // public var CXCompletionContext_ObjCInstanceMessage: CXCompletionContext { get } 6038 /** 6039 * \brief Completions for Objective-C class messages should be included in 6040 * the results. 6041 */ 6042 // public var CXCompletionContext_ObjCClassMessage: CXCompletionContext { get } 6043 /** 6044 * \brief Completions for Objective-C selector names should be included in 6045 * the results. 6046 */ 6047 // public var CXCompletionContext_ObjCSelectorName: CXCompletionContext { get } 6048 6049 /** 6050 * \brief Completions for preprocessor macro names should be included in 6051 * the results. 6052 */ 6053 // public var CXCompletionContext_MacroName: CXCompletionContext { get } 6054 6055 /** 6056 * \brief Natural language completions should be included in the results. 6057 */ 6058 // public var CXCompletionContext_NaturalLanguage: CXCompletionContext { get } 6059 6060 /** 6061 * \brief The current context is unknown, so set all contexts. 6062 */ 6063 // public var CXCompletionContext_Unknown: CXCompletionContext { get } 6064 6065 /** 6066 * \brief Returns a default set of code-completion options that can be 6067 * passed to\c clang_codeCompleteAt(). 6068 */ 6069 public func clang_defaultCodeCompleteOptions() -> UInt32 { 6070 return _clang_defaultCodeCompleteOptions() 6071 } 6072 private let _clang_defaultCodeCompleteOptions
created_Index.swift:5866 : @convention(c) () -> UInt32 = library.loadSymbol("clang_defaultCodeCompleteOptions") 6073 6074 6075 6076 /** 6077 * \brief Perform code completion at a given location in a translation unit. 6078 * 6079 * This function performs code completion at a particular file, line, and 6080 * column within source code, providing results that suggest potential 6081 * code snippets based on the context of the completion. The basic model 6082 * for code completion is that Clang will parse a complete source file, 6083 * performing syntax checking up to the location where code-completion has 6084 * been requested. At that point, a special code-completion token is passed 6085 * to the parser, which recognizes this token and determines, based on the 6086 * current location in the C/Objective-C/C++ grammar and the state of 6087 * semantic analysis, what completions to provide. These completions are 6088 * returned via a new \c CXCodeCompleteResults structure. 6089 * 6090 * Code completion itself is meant to be triggered by the client when the 6091 * user types punctuation characters or whitespace, at which point the 6092 * code-completion location will coincide with the cursor. For example, if \c p 6093 * is a pointer, code-completion might be triggered after the "-" and then 6094 * after the ">" in \c p->. When the code-completion location is afer the ">", 6095 * the completion results will provide, e.g., the members of the struct that 6096 * "p" points to. The client is responsible for placing the cursor at the 6097 * beginning of the token currently being typed, then filtering the results 6098 * based on the contents of the token. For example, when code-completing for 6099 * the expression \c p->get, the client should provide the location just after 6100 * the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the 6101 * client can filter the results based on the current token text ("get"), only 6102 * showing those results that start with "get". The intent of this interface 6103 * is to separate the relatively high-latency acquisition of code-completion 6104 * results from the filtering of results on a per-character basis, which must 6105 * have a lower latency. 6106 * 6107 * \param TU The translation unit in which code-completion should 6108 * occur. The source files for this translation unit need not be 6109 * completely up-to-date (and the contents of those source files may 6110 * be overridden via \p unsaved_files). Cursors referring into the 6111 * translation unit may be invalidated by this invocation. 6112 * 6113 * \param complete_filename The name of the source file where code 6114 * completion should be performed. This filename may be any file 6115 * included in the translation unit. 6116 * 6117 * \param complete_line The line at which code-completion should occur. 6118 * 6119 * \param complete_column The column at which code-completion should occur. 6120 * Note that the column should point just after the syntactic construct that 6121 * initiated code completion, and not in the middle of a lexical token. 6122 * 6123 * \param unsaved_files the Tiles that have not yet been saved to disk 6124 * but may be required for parsing or code completion, including the 6125 * contents of those files. The contents and name of these files (as 6126 * specified by CXUnsavedFile) are copied when necessary, so the 6127 * client only needs to guarantee their validity until the call to 6128 * this function returns. 6129 * 6130 * \param num_unsaved_files The number of unsaved file entries in \p 6131 * unsaved_files. 6132 * 6133 * \param options Extra options that control the behavior of code 6134 * completion, expressed as a bitwise OR of the enumerators of the 6135 * CXCodeComplete_Flags enumeration. The 6136 * \c clang_defaultCodeCompleteOptions() function returns a default set 6137 * of code-completion options. 6138 * 6139 * \returns If successful, a new \c CXCodeCompleteResults structure 6140 * containing code-completion results, which should eventually be 6141 * freed with \c clang_disposeCodeCompleteResults(). If code 6142 * completion fails, returns NULL. 6143 */ 6144 public func clang_codeCompleteAt(TU: CXTranslationUnit, _ complete_filename: UnsafePointer<Int8>, _ complete_line: UInt32, _ complete_column: UInt32, _ unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, _ num_unsaved_files: UInt32, _ options: UInt32) -> UnsafeMutablePointer<CXCodeCompleteResults> { 6145 return _clang_codeCompleteAt(TU: TU, complete_filename: complete_filename, complete_line: complete_line, complete_column: complete_column, unsaved_files: unsaved_files, num_unsaved_files: num_unsaved_files, options: options) 6146 } 6147 private let _clang_codeCompleteAt
created_Index.swift:6070 : @convention(c) (TU: CXTranslationUnit, complete_filename: UnsafePointer<Int8>, complete_line: UInt32, complete_column: UInt32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, num_unsaved_files: UInt32, options: UInt32) -> UnsafeMutablePointer<CXCodeCompleteResults> = library.loadSymbol("clang_codeCompleteAt") 6148 6149 6150 6151 /** 6152 * \brief Sort the code-completion results in case-insensitive alphabetical 6153 * order. 6154 * 6155 * \param Results The set of results to sort. 6156 * \param NumResults The number of results in \p Results. 6157 */ 6158 public func clang_sortCodeCompletionResults(Results: UnsafeMutablePointer<CXCompletionResult>, _ NumResults: UInt32) { 6159 return _clang_sortCodeCompletionResults(Results: Results, NumResults: NumResults) 6160 } 6161 private let _clang_sortCodeCompletionResults
created_Index.swift:6145 : @convention(c) (Results: UnsafeMutablePointer<CXCompletionResult>, NumResults: UInt32) -> () = library.loadSymbol("clang_sortCodeCompletionResults") 6162 6163 6164 6165 /** 6166 * \brief Free the given set of code-completion results. 6167 */ 6168 public func clang_disposeCodeCompleteResults(Results: UnsafeMutablePointer<CXCodeCompleteResults>) { 6169 return _clang_disposeCodeCompleteResults(Results: Results) 6170 } 6171 private let _clang_disposeCodeCompleteResults
created_Index.swift:6159 : @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> () = library.loadSymbol("clang_disposeCodeCompleteResults") 6172 6173 6174 6175 /** 6176 * \brief Determine the number of diagnostics produced prior to the 6177 * location where code completion was performed. 6178 */ 6179 public func clang_codeCompleteGetNumDiagnostics(Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> UInt32 { 6180 return _clang_codeCompleteGetNumDiagnostics(Results: Results) 6181 } 6182 private let _clang_codeCompleteGetNumDiagnostics
created_Index.swift:6169 : @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> UInt32 = library.loadSymbol("clang_codeCompleteGetNumDiagnostics") 6183 6184 6185 6186 /** 6187 * \brief Retrieve a diagnostic associated with the given code completion. 6188 * 6189 * \param Results the code completion results to query. 6190 * \param Index the zero-based diagnostic number to retrieve. 6191 * 6192 * \returns the requested diagnostic. This diagnostic must be freed 6193 * via a call to \c clang_disposeDiagnostic(). 6194 */ 6195 public func clang_codeCompleteGetDiagnostic(Results: UnsafeMutablePointer<CXCodeCompleteResults>, _ Index: UInt32) -> CXDiagnostic { 6196 return _clang_codeCompleteGetDiagnostic(Results: Results, Index: Index) 6197 } 6198 private let _clang_codeCompleteGetDiagnostic
created_Index.swift:6180 : @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>, Index: UInt32) -> CXDiagnostic = library.loadSymbol("clang_codeCompleteGetDiagnostic") 6199 6200 6201 6202 /** 6203 * \brief Determines what completions are appropriate for the context 6204 * the given code completion. 6205 * 6206 * \param Results the code completion results to query 6207 * 6208 * \returns the kinds of completions that are appropriate for use 6209 * along with the given code completion results. 6210 */ 6211 public func clang_codeCompleteGetContexts(Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> UInt64 { 6212 return _clang_codeCompleteGetContexts(Results: Results) 6213 } 6214 private let _clang_codeCompleteGetContexts
created_Index.swift:6196 : @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> UInt64 = library.loadSymbol("clang_codeCompleteGetContexts") 6215 6216 6217 6218 /** 6219 * \brief Returns the cursor kind for the container for the current code 6220 * completion context. The container is only guaranteed to be set for 6221 * contexts where a container exists (i.e. member accesses or Objective-C 6222 * message sends); if there is not a container, this function will return 6223 * CXCursor_InvalidCode. 6224 * 6225 * \param Results the code completion results to query 6226 * 6227 * \param IsIncomplete on return, this value will be false if Clang has complete 6228 * information about the container. If Clang does not have complete 6229 * information, this value will be true. 6230 * 6231 * \returns the container kind, or CXCursor_InvalidCode if there is not a 6232 * container 6233 */ 6234 public func clang_codeCompleteGetContainerKind(Results: UnsafeMutablePointer<CXCodeCompleteResults>, _ IsIncomplete: UnsafeMutablePointer<UInt32>) -> CXCursorKind { 6235 return _clang_codeCompleteGetContainerKind(Results: Results, IsIncomplete: IsIncomplete) 6236 } 6237 private let _clang_codeCompleteGetContainerKind
created_Index.swift:6212 : @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>, IsIncomplete: UnsafeMutablePointer<UInt32>) -> CXCursorKind = library.loadSymbol("clang_codeCompleteGetContainerKind") 6238 6239 6240 6241 /** 6242 * \brief Returns the USR for the container for the current code completion 6243 * context. If there is not a container for the current context, this 6244 * function will return the empty string. 6245 * 6246 * \param Results the code completion results to query 6247 * 6248 * \returns the USR for the container 6249 */ 6250 public func clang_codeCompleteGetContainerUSR(Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> CXString { 6251 return _clang_codeCompleteGetContainerUSR(Results: Results) 6252 } 6253 private let _clang_codeCompleteGetContainerUSR
created_Index.swift:6235 : @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> CXString = library.loadSymbol("clang_codeCompleteGetContainerUSR") 6254 6255 6256 6257 /** 6258 * \brief Returns the currently-entered selector for an Objective-C message 6259 * send, formatted like "initWithFoo:bar:". Only guaranteed to return a 6260 * non-empty string for CXCompletionContext_ObjCInstanceMessage and 6261 * CXCompletionContext_ObjCClassMessage. 6262 * 6263 * \param Results the code completion results to query 6264 * 6265 * \returns the selector (or partial selector) that has been entered thus far 6266 * for an Objective-C message send. 6267 */ 6268 public func clang_codeCompleteGetObjCSelector(Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> CXString { 6269 return _clang_codeCompleteGetObjCSelector(Results: Results) 6270 } 6271 private let _clang_codeCompleteGetObjCSelector
created_Index.swift:6251 : @convention(c) (Results: UnsafeMutablePointer<CXCodeCompleteResults>) -> CXString = library.loadSymbol("clang_codeCompleteGetObjCSelector") 6272 6273 6274 /** 6275 * @} 6276 */ 6277 6278 /** 6279 * \defgroup CINDEX_MISC Miscellaneous utility functions 6280 * 6281 * @{ 6282 */ 6283 6284 /** 6285 * \brief Return a version string, suitable for showing to a user, but not 6286 * intended to be parsed (the format is not guaranteed to be stable). 6287 */ 6288 public func clang_getClangVersion() -> CXString { 6289 return _clang_getClangVersion() 6290 } 6291 private let _clang_getClangVersion
created_Index.swift:6269 : @convention(c) () -> CXString = library.loadSymbol("clang_getClangVersion") 6292 6293 6294 /** 6295 * \brief Enable/disable crash recovery. 6296 * 6297 * \param isEnabled Flag to indicate if crash recovery is enabled. A non-zero 6298 * value enables crash recovery, while 0 disables it. 6299 */ 6300 public func clang_toggleCrashRecovery(isEnabled: UInt32) { 6301 return _clang_toggleCrashRecovery(isEnabled: isEnabled) 6302 } 6303 private let _clang_toggleCrashRecovery
created_Index.swift:6289 : @convention(c) (isEnabled: UInt32) -> () = library.loadSymbol("clang_toggleCrashRecovery") 6304 6305 6306 /** 6307 * \brief Visitor invoked for each file in a translation unit 6308 * (used with clang_getInclusions()). 6309 * 6310 * This visitor function will be invoked by clang_getInclusions() for each 6311 * file included (either at the top-level or by \#include directives) within 6312 * a translation unit. The first argument is the file being included, and 6313 * the second and third arguments provide the inclusion stack. The 6314 * array is sorted in order of immediate inclusion. For example, 6315 * the first element refers to the location that included 'included_file'. 6316 */ 6317 // public typealias CXInclusionVisitor = @convention(c) (CXFile, UnsafeMutablePointer<CXSourceLocation>, UInt32, CXClientData) -> Void 6318 6319 /** 6320 * \brief Visit the set of preprocessor inclusions in a translation unit. 6321 * The visitor function is called with the provided data for every included 6322 * file. This does not include headers included by the PCH file (unless one 6323 * is inspecting the inclusions in the PCH file itself). 6324 */ 6325 public func clang_getInclusions(tu: CXTranslationUnit, _ visitor: CXInclusionVisitor!, _ client_data: CXClientData) { 6326 return _clang_getInclusions(tu: tu, visitor: visitor, client_data: client_data) 6327 } 6328 private let _clang_getInclusions
created_Index.swift:6301 : @convention(c) (tu: CXTranslationUnit, visitor: CXInclusionVisitor!, client_data: CXClientData) -> () = library.loadSymbol("clang_getInclusions") 6329 6330 6331 /** 6332 * @} 6333 */ 6334 6335 /** \defgroup CINDEX_REMAPPING Remapping functions 6336 * 6337 * @{ 6338 */ 6339 6340 /** 6341 * \brief A remapping of original source files and their translated files. 6342 */ 6343 // public typealias CXRemapping = UnsafeMutablePointer<Void> 6344 6345 /** 6346 * \brief Retrieve a remapping. 6347 * 6348 * \param path the path that contains metadata about remappings. 6349 * 6350 * \returns the requested remapping. This remapping must be freed 6351 * via a call to \c clang_remap_dispose(). Can return NULL if an error occurred. 6352 */ 6353 public func clang_getRemappings(path: UnsafePointer<Int8>) -> CXRemapping { 6354 return _clang_getRemappings(path: path) 6355 } 6356 private let _clang_getRemappings
created_Index.swift:6326 : @convention(c) (path: UnsafePointer<Int8>) -> CXRemapping = library.loadSymbol("clang_getRemappings") 6357 6358 6359 6360 /** 6361 * \brief Retrieve a remapping. 6362 * 6363 * \param filePaths pointer to an array of file paths containing remapping info. 6364 * 6365 * \param numFiles number of file paths. 6366 * 6367 * \returns the requested remapping. This remapping must be freed 6368 * via a call to \c clang_remap_dispose(). Can return NULL if an error occurred. 6369 */ 6370 public func clang_getRemappingsFromFileList(filePaths: UnsafeMutablePointer<UnsafePointer<Int8>>, _ numFiles: UInt32) -> CXRemapping { 6371 return _clang_getRemappingsFromFileList(filePaths: filePaths, numFiles: numFiles) 6372 } 6373 private let _clang_getRemappingsFromFileList
created_Index.swift:6354 : @convention(c) (filePaths: UnsafeMutablePointer<UnsafePointer<Int8>>, numFiles: UInt32) -> CXRemapping = library.loadSymbol("clang_getRemappingsFromFileList") 6374 6375 6376 /** 6377 * \brief Determine the number of remappings. 6378 */ 6379 public func clang_remap_getNumFiles(unnamed1: CXRemapping) -> UInt32 { 6380 return _clang_remap_getNumFiles(unnamed1) 6381 } 6382 private let _clang_remap_getNumFiles
created_Index.swift:6371 : @convention(c) (_: CXRemapping) -> UInt32 = library.loadSymbol("clang_remap_getNumFiles") 6383 6384 6385 /** 6386 * \brief Get the original and the associated filename from the remapping. 6387 * 6388 * \param original If non-NULL, will be set to the original filename. 6389 * 6390 * \param transformed If non-NULL, will be set to the filename that the original 6391 * is associated with. 6392 */ 6393 public func clang_remap_getFilenames(unnamed1: CXRemapping, _ index: UInt32, _ original: UnsafeMutablePointer<CXString>, _ transformed: UnsafeMutablePointer<CXString>) { 6394 return _clang_remap_getFilenames(unnamed1, index: index, original: original, transformed: transformed) 6395 } 6396 private let _clang_remap_getFilenames
created_Index.swift:6380 : @convention(c) (_: CXRemapping, index: UInt32, original: UnsafeMutablePointer<CXString>, transformed: UnsafeMutablePointer<CXString>) -> () = library.loadSymbol("clang_remap_getFilenames") 6397 6398 6399 /** 6400 * \brief Dispose the remapping. 6401 */ 6402 public func clang_remap_dispose(unnamed1: CXRemapping) { 6403 return _clang_remap_dispose(unnamed1) 6404 } 6405 private let _clang_remap_dispose
created_Index.swift:6394 : @convention(c) (_: CXRemapping) -> () = library.loadSymbol("clang_remap_dispose") 6406 6407 6408 /** 6409 * @} 6410 */ 6411 6412 6413 /** \defgroup CINDEX_HIGH Higher level API functions 6414 * 6415 * @{ 6416 */ 6417 /* 6418 public struct CXVisitorResult : RawRepresentable, Equatable { 6419 public init(_ rawValue: UInt32) 6420 public init(rawValue: UInt32) 6421 // public var rawValue: UInt32 6422 } 6423 */ 6424 // public var CXVisit_Break: CXVisitorResult { get } 6425 // public var CXVisit_Continue: CXVisitorResult { get } 6426 6427 /* 6428 public struct CXCursorAndRangeVisitor { 6429 // public var context: UnsafeMutablePointer<Void> 6430 // public var visit: (@convention(c) (UnsafeMutablePointer<Void>, CXCursor, CXSourceRange) -> CXVisitorResult)! 6431 public init() 6432 public init(context: UnsafeMutablePointer<Void>, visit: (@convention(c) (UnsafeMutablePointer<Void>, CXCursor, CXSourceRange) -> CXVisitorResult)!) 6433 } 6434 */ 6435 6436 /* 6437 public struct CXResult : RawRepresentable, Equatable { 6438 public init(_ rawValue: UInt32) 6439 public init(rawValue: UInt32) 6440 // public var rawValue: UInt32 6441 } 6442 */ 6443 6444 /** 6445 * \brief Function returned successfully. 6446 */ 6447 // public var CXResult_Success: CXResult { get } 6448 /** 6449 * \brief One of the parameters was invalid for the function. 6450 */ 6451 // public var CXResult_Invalid: CXResult { get } 6452 /** 6453 * \brief The function was terminated by a callback (e.g. it returned 6454 * CXVisit_Break) 6455 */ 6456 // public var CXResult_VisitBreak: CXResult { get } 6457 6458 /** 6459 * \brief Find references of a declaration in a specific file. 6460 * 6461 * \param cursor pointing to a declaration or a reference of one. 6462 * 6463 * \param file to search for references. 6464 * 6465 * \param visitor callback that will receive pairs of CXCursor/CXSourceRange for 6466 * each reference found. 6467 * The CXSourceRange will point inside the file; if the reference is inside 6468 * a macro (and not a macro argument) the CXSourceRange will be invalid. 6469 * 6470 * \returns one of the CXResult enumerators. 6471 */ 6472 public func clang_findReferencesInFile(cursor: CXCursor, _ file: CXFile, _ visitor: CXCursorAndRangeVisitor) -> CXResult { 6473 return _clang_findReferencesInFile(cursor: cursor, file: file, visitor: visitor) 6474 } 6475 private let _clang_findReferencesInFile
created_Index.swift:6403 : @convention(c) (cursor: CXCursor, file: CXFile, visitor: CXCursorAndRangeVisitor) -> CXResult = library.loadSymbol("clang_findReferencesInFile") 6476 6477 6478 /** 6479 * \brief Find #import/#include directives in a specific file. 6480 * 6481 * \param TU translation unit containing the file to query. 6482 * 6483 * \param file to search for #import/#include directives. 6484 * 6485 * \param visitor callback that will receive pairs of CXCursor/CXSourceRange for 6486 * each directive found. 6487 * 6488 * \returns one of the CXResult enumerators. 6489 */ 6490 public func clang_findIncludesInFile(TU: CXTranslationUnit, _ file: CXFile, _ visitor: CXCursorAndRangeVisitor) -> CXResult { 6491 return _clang_findIncludesInFile(TU: TU, file: file, visitor: visitor) 6492 } 6493 private let _clang_findIncludesInFile
created_Index.swift:6473 : @convention(c) (TU: CXTranslationUnit, file: CXFile, visitor: CXCursorAndRangeVisitor) -> CXResult = library.loadSymbol("clang_findIncludesInFile") 6494 6495 6496 // public typealias CXCursorAndRangeVisitorBlock = (CXCursor, CXSourceRange) -> CXVisitorResult 6497 6498 public func clang_findReferencesInFileWithBlock(unnamed1: CXCursor, _ unnamed3: CXFile, _ unnamed2: CXCursorAndRangeVisitorBlock!) -> CXResult { 6499 return _clang_findReferencesInFileWithBlock(unnamed1, unnamed3, unnamed2) 6500 } 6501 private let _clang_findReferencesInFileWithBlock
created_Index.swift:6491 : @convention(c) (_: CXCursor, _: CXFile, _: CXCursorAndRangeVisitorBlock!) -> CXResult = library.loadSymbol("clang_findReferencesInFileWithBlock") 6502 6503 6504 public func clang_findIncludesInFileWithBlock(unnamed1: CXTranslationUnit, _ unnamed3: CXFile, _ unnamed2: CXCursorAndRangeVisitorBlock!) -> CXResult { 6505 return _clang_findIncludesInFileWithBlock(unnamed1, unnamed3, unnamed2) 6506 } 6507 private let _clang_findIncludesInFileWithBlock
created_Index.swift:6499 : @convention(c) (_: CXTranslationUnit, _: CXFile, _: CXCursorAndRangeVisitorBlock!) -> CXResult = library.loadSymbol("clang_findIncludesInFileWithBlock") 6508 6509 6510 /** 6511 * \brief The client's data object that is associated with a CXFile. 6512 */ 6513 // public typealias CXIdxClientFile = UnsafeMutablePointer<Void> 6514 6515 /** 6516 * \brief The client's data object that is associated with a semantic entity. 6517 */ 6518 // public typealias CXIdxClientEntity = UnsafeMutablePointer<Void> 6519 6520 /** 6521 * \brief The client's data object that is associated with a semantic container 6522 * of entities. 6523 */ 6524 // public typealias CXIdxClientContainer = UnsafeMutablePointer<Void> 6525 6526 /** 6527 * \brief The client's data object that is associated with an AST file (PCH 6528 * or module). 6529 */ 6530 // public typealias CXIdxClientASTFile = UnsafeMutablePointer<Void> 6531 6532 /** 6533 * \brief Source location passed to index callbacks. 6534 */ 6535 /* 6536 public struct CXIdxLoc { 6537 // public var ptr_data: (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>) 6538 // public var int_data: UInt32 6539 public init() 6540 public init(ptr_data: (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>), int_data: UInt32) 6541 } 6542 */ 6543 6544 /** 6545 * \brief Data for ppIncludedFile callback. 6546 */ 6547 /* 6548 public struct CXIdxIncludedFileInfo { 6549 /** 6550 * \brief Location of '#' in the \#include/\#import directive. 6551 */ 6552 // public var hashLoc: CXIdxLoc 6553 /** 6554 * \brief Filename as written in the \#include/\#import directive. 6555 */ 6556 // public var filename: UnsafePointer<Int8> 6557 /** 6558 * \brief The actual file that the \#include/\#import directive resolved to. 6559 */ 6560 // public var file: CXFile 6561 // public var isImport: Int32 6562 // public var isAngled: Int32 6563 /** 6564 * \brief Non-zero if the directive was automatically turned into a module 6565 * import. 6566 */ 6567 // public var isModuleImport: Int32 6568 public init() 6569 public init(hashLoc: CXIdxLoc, filename: UnsafePointer<Int8>, file: CXFile, isImport: Int32, isAngled: Int32, isModuleImport: Int32) 6570 } 6571 */ 6572 6573 /** 6574 * \brief Data for IndexerCallbacks#importedASTFile. 6575 */ 6576 /* 6577 public struct CXIdxImportedASTFileInfo { 6578 /** 6579 * \brief Top level AST file containing the imported PCH, module or submodule. 6580 */ 6581 // public var file: CXFile 6582 /** 6583 * \brief The imported module or NULL if the AST file is a PCH. 6584 */ 6585 // public var module: CXModule 6586 /** 6587 * \brief Location where the file is imported. Applicable only for modules. 6588 */ 6589 // public var loc: CXIdxLoc 6590 /** 6591 * \brief Non-zero if an inclusion directive was automatically turned into 6592 * a module import. Applicable only for modules. 6593 */ 6594 // public var isImplicit: Int32 6595 public init() 6596 public init(file: CXFile, module: CXModule, loc: CXIdxLoc, isImplicit: Int32) 6597 } 6598 */ 6599 6600 /* 6601 public struct CXIdxEntityKind : RawRepresentable, Equatable { 6602 public init(_ rawValue: UInt32) 6603 public init(rawValue: UInt32) 6604 // public var rawValue: UInt32 6605 } 6606 */ 6607 // public var CXIdxEntity_Unexposed: CXIdxEntityKind { get } 6608 // public var CXIdxEntity_Typedef: CXIdxEntityKind { get } 6609 // public var CXIdxEntity_Function: CXIdxEntityKind { get } 6610 // public var CXIdxEntity_Variable: CXIdxEntityKind { get } 6611 // public var CXIdxEntity_Field: CXIdxEntityKind { get } 6612 // public var CXIdxEntity_EnumConstant: CXIdxEntityKind { get } 6613 // public var CXIdxEntity_ObjCClass: CXIdxEntityKind { get } 6614 // public var CXIdxEntity_ObjCProtocol: CXIdxEntityKind { get } 6615 // public var CXIdxEntity_ObjCCategory: CXIdxEntityKind { get } 6616 // public var CXIdxEntity_ObjCInstanceMethod: CXIdxEntityKind { get } 6617 // public var CXIdxEntity_ObjCClassMethod: CXIdxEntityKind { get } 6618 // public var CXIdxEntity_ObjCProperty: CXIdxEntityKind { get } 6619 // public var CXIdxEntity_ObjCIvar: CXIdxEntityKind { get } 6620 // public var CXIdxEntity_Enum: CXIdxEntityKind { get } 6621 // public var CXIdxEntity_Struct: CXIdxEntityKind { get } 6622 // public var CXIdxEntity_Union: CXIdxEntityKind { get } 6623 // public var CXIdxEntity_CXXClass: CXIdxEntityKind { get } 6624 // public var CXIdxEntity_CXXNamespace: CXIdxEntityKind { get } 6625 // public var CXIdxEntity_CXXNamespaceAlias: CXIdxEntityKind { get } 6626 // public var CXIdxEntity_CXXStaticVariable: CXIdxEntityKind { get } 6627 // public var CXIdxEntity_CXXStaticMethod: CXIdxEntityKind { get } 6628 // public var CXIdxEntity_CXXInstanceMethod: CXIdxEntityKind { get } 6629 // public var CXIdxEntity_CXXConstructor: CXIdxEntityKind { get } 6630 // public var CXIdxEntity_CXXDestructor: CXIdxEntityKind { get } 6631 // public var CXIdxEntity_CXXConversionFunction: CXIdxEntityKind { get } 6632 // public var CXIdxEntity_CXXTypeAlias: CXIdxEntityKind { get } 6633 // public var CXIdxEntity_CXXInterface: CXIdxEntityKind { get } 6634 6635 /* 6636 public struct CXIdxEntityLanguage : RawRepresentable, Equatable { 6637 public init(_ rawValue: UInt32) 6638 public init(rawValue: UInt32) 6639 // public var rawValue: UInt32 6640 } 6641 */ 6642 // public var CXIdxEntityLang_None: CXIdxEntityLanguage { get } 6643 // public var CXIdxEntityLang_C: CXIdxEntityLanguage { get } 6644 // public var CXIdxEntityLang_ObjC: CXIdxEntityLanguage { get } 6645 // public var CXIdxEntityLang_CXX: CXIdxEntityLanguage { get } 6646 6647 /** 6648 * \brief Extra C++ template information for an entity. This can apply to: 6649 * CXIdxEntity_Function 6650 * CXIdxEntity_CXXClass 6651 * CXIdxEntity_CXXStaticMethod 6652 * CXIdxEntity_CXXInstanceMethod 6653 * CXIdxEntity_CXXConstructor 6654 * CXIdxEntity_CXXConversionFunction 6655 * CXIdxEntity_CXXTypeAlias 6656 */ 6657 /* 6658 public struct CXIdxEntityCXXTemplateKind : RawRepresentable, Equatable { 6659 public init(_ rawValue: UInt32) 6660 public init(rawValue: UInt32) 6661 // public var rawValue: UInt32 6662 } 6663 */ 6664 // public var CXIdxEntity_NonTemplate: CXIdxEntityCXXTemplateKind { get } 6665 // public var CXIdxEntity_Template: CXIdxEntityCXXTemplateKind { get } 6666 // public var CXIdxEntity_TemplatePartialSpecialization: CXIdxEntityCXXTemplateKind { get } 6667 // public var CXIdxEntity_TemplateSpecialization: CXIdxEntityCXXTemplateKind { get } 6668 6669 /* 6670 public struct CXIdxAttrKind : RawRepresentable, Equatable { 6671 public init(_ rawValue: UInt32) 6672 public init(rawValue: UInt32) 6673 // public var rawValue: UInt32 6674 } 6675 */ 6676 // public var CXIdxAttr_Unexposed: CXIdxAttrKind { get } 6677 // public var CXIdxAttr_IBAction: CXIdxAttrKind { get } 6678 // public var CXIdxAttr_IBOutlet: CXIdxAttrKind { get } 6679 // public var CXIdxAttr_IBOutletCollection: CXIdxAttrKind { get } 6680 6681 /* 6682 public struct CXIdxAttrInfo { 6683 // public var kind: CXIdxAttrKind 6684 // public var cursor: CXCursor 6685 // public var loc: CXIdxLoc 6686 public init() 6687 public init(kind: CXIdxAttrKind, cursor: CXCursor, loc: CXIdxLoc) 6688 } 6689 */ 6690 6691 /* 6692 public struct CXIdxEntityInfo { 6693 // public var kind: CXIdxEntityKind 6694 // public var templateKind: CXIdxEntityCXXTemplateKind 6695 // public var lang: CXIdxEntityLanguage 6696 // public var name: UnsafePointer<Int8> 6697 // public var USR: UnsafePointer<Int8> 6698 // public var cursor: CXCursor 6699 // public var attributes: UnsafePointer<UnsafePointer<CXIdxAttrInfo>> 6700 // public var numAttributes: UInt32 6701 public init() 6702 public init(kind: CXIdxEntityKind, templateKind: CXIdxEntityCXXTemplateKind, lang: CXIdxEntityLanguage, name: UnsafePointer<Int8>, USR: UnsafePointer<Int8>, cursor: CXCursor, attributes: UnsafePointer<UnsafePointer<CXIdxAttrInfo>>, numAttributes: UInt32) 6703 } 6704 */ 6705 6706 /* 6707 public struct CXIdxContainerInfo { 6708 // public var cursor: CXCursor 6709 public init() 6710 public init(cursor: CXCursor) 6711 } 6712 */ 6713 6714 /* 6715 public struct CXIdxIBOutletCollectionAttrInfo { 6716 // public var attrInfo: UnsafePointer<CXIdxAttrInfo> 6717 // public var objcClass: UnsafePointer<CXIdxEntityInfo> 6718 // public var classCursor: CXCursor 6719 // public var classLoc: CXIdxLoc 6720 public init() 6721 public init(attrInfo: UnsafePointer<CXIdxAttrInfo>, objcClass: UnsafePointer<CXIdxEntityInfo>, classCursor: CXCursor, classLoc: CXIdxLoc) 6722 } 6723 */ 6724 6725 /* 6726 public struct CXIdxDeclInfoFlags : RawRepresentable, Equatable { 6727 public init(_ rawValue: UInt32) 6728 public init(rawValue: UInt32) 6729 // public var rawValue: UInt32 6730 } 6731 */ 6732 // public var CXIdxDeclFlag_Skipped: CXIdxDeclInfoFlags { get } 6733 6734 /* 6735 public struct CXIdxDeclInfo { 6736 // public var entityInfo: UnsafePointer<CXIdxEntityInfo> 6737 // public var cursor: CXCursor 6738 // public var loc: CXIdxLoc 6739 // public var semanticContainer: UnsafePointer<CXIdxContainerInfo> 6740 /** 6741 * \brief Generally same as #semanticContainer but can be different in 6742 * cases like out-of-line C++ member functions. 6743 */ 6744 // public var lexicalContainer: UnsafePointer<CXIdxContainerInfo> 6745 // public var isRedeclaration: Int32 6746 // public var isDefinition: Int32 6747 // public var isContainer: Int32 6748 // public var declAsContainer: UnsafePointer<CXIdxContainerInfo> 6749 /** 6750 * \brief Whether the declaration exists in code or was created implicitly 6751 * by the compiler, e.g. implicit Objective-C methods for properties. 6752 */ 6753 // public var isImplicit: Int32 6754 // public var attributes: UnsafePointer<UnsafePointer<CXIdxAttrInfo>> 6755 // public var numAttributes: UInt32 6756 6757 // public var flags: UInt32 6758 public init() 6759 public init(entityInfo: UnsafePointer<CXIdxEntityInfo>, cursor: CXCursor, loc: CXIdxLoc, semanticContainer: UnsafePointer<CXIdxContainerInfo>, lexicalContainer: UnsafePointer<CXIdxContainerInfo>, isRedeclaration: Int32, isDefinition: Int32, isContainer: Int32, declAsContainer: UnsafePointer<CXIdxContainerInfo>, isImplicit: Int32, attributes: UnsafePointer<UnsafePointer<CXIdxAttrInfo>>, numAttributes: UInt32, flags: UInt32) 6760 } 6761 */ 6762 6763 /* 6764 public struct CXIdxObjCContainerKind : RawRepresentable, Equatable { 6765 public init(_ rawValue: UInt32) 6766 public init(rawValue: UInt32) 6767 // public var rawValue: UInt32 6768 } 6769 */ 6770 // public var CXIdxObjCContainer_ForwardRef: CXIdxObjCContainerKind { get } 6771 // public var CXIdxObjCContainer_Interface: CXIdxObjCContainerKind { get } 6772 // public var CXIdxObjCContainer_Implementation: CXIdxObjCContainerKind { get } 6773 6774 /* 6775 public struct CXIdxObjCContainerDeclInfo { 6776 // public var declInfo: UnsafePointer<CXIdxDeclInfo> 6777 // public var kind: CXIdxObjCContainerKind 6778 public init() 6779 public init(declInfo: UnsafePointer<CXIdxDeclInfo>, kind: CXIdxObjCContainerKind) 6780 } 6781 */ 6782 6783 /* 6784 public struct CXIdxBaseClassInfo { 6785 // public var base: UnsafePointer<CXIdxEntityInfo> 6786 // public var cursor: CXCursor 6787 // public var loc: CXIdxLoc 6788 public init() 6789 public init(base: UnsafePointer<CXIdxEntityInfo>, cursor: CXCursor, loc: CXIdxLoc) 6790 } 6791 */ 6792 6793 /* 6794 public struct CXIdxObjCProtocolRefInfo { 6795 // public var `protocol`: UnsafePointer<CXIdxEntityInfo> 6796 // public var cursor: CXCursor 6797 // public var loc: CXIdxLoc 6798 public init() 6799 public init(`protocol`: UnsafePointer<CXIdxEntityInfo>, cursor: CXCursor, loc: CXIdxLoc) 6800 } 6801 */ 6802 6803 /* 6804 public struct CXIdxObjCProtocolRefListInfo { 6805 // public var protocols: UnsafePointer<UnsafePointer<CXIdxObjCProtocolRefInfo>> 6806 // public var numProtocols: UInt32 6807 public init() 6808 public init(protocols: UnsafePointer<UnsafePointer<CXIdxObjCProtocolRefInfo>>, numProtocols: UInt32) 6809 } 6810 */ 6811 6812 /* 6813 public struct CXIdxObjCInterfaceDeclInfo { 6814 // public var containerInfo: UnsafePointer<CXIdxObjCContainerDeclInfo> 6815 // public var superInfo: UnsafePointer<CXIdxBaseClassInfo> 6816 // public var protocols: UnsafePointer<CXIdxObjCProtocolRefListInfo> 6817 public init() 6818 public init(containerInfo: UnsafePointer<CXIdxObjCContainerDeclInfo>, superInfo: UnsafePointer<CXIdxBaseClassInfo>, protocols: UnsafePointer<CXIdxObjCProtocolRefListInfo>) 6819 } 6820 */ 6821 6822 /* 6823 public struct CXIdxObjCCategoryDeclInfo { 6824 // public var containerInfo: UnsafePointer<CXIdxObjCContainerDeclInfo> 6825 // public var objcClass: UnsafePointer<CXIdxEntityInfo> 6826 // public var classCursor: CXCursor 6827 // public var classLoc: CXIdxLoc 6828 // public var protocols: UnsafePointer<CXIdxObjCProtocolRefListInfo> 6829 public init() 6830 public init(containerInfo: UnsafePointer<CXIdxObjCContainerDeclInfo>, objcClass: UnsafePointer<CXIdxEntityInfo>, classCursor: CXCursor, classLoc: CXIdxLoc, protocols: UnsafePointer<CXIdxObjCProtocolRefListInfo>) 6831 } 6832 */ 6833 6834 /* 6835 public struct CXIdxObjCPropertyDeclInfo { 6836 // public var declInfo: UnsafePointer<CXIdxDeclInfo> 6837 // public var getter: UnsafePointer<CXIdxEntityInfo> 6838 // public var setter: UnsafePointer<CXIdxEntityInfo> 6839 public init() 6840 public init(declInfo: UnsafePointer<CXIdxDeclInfo>, getter: UnsafePointer<CXIdxEntityInfo>, setter: UnsafePointer<CXIdxEntityInfo>) 6841 } 6842 */ 6843 6844 /* 6845 public struct CXIdxCXXClassDeclInfo { 6846 // public var declInfo: UnsafePointer<CXIdxDeclInfo> 6847 // public var bases: UnsafePointer<UnsafePointer<CXIdxBaseClassInfo>> 6848 // public var numBases: UInt32 6849 public init() 6850 public init(declInfo: UnsafePointer<CXIdxDeclInfo>, bases: UnsafePointer<UnsafePointer<CXIdxBaseClassInfo>>, numBases: UInt32) 6851 } 6852 */ 6853 6854 /** 6855 * \brief Data for IndexerCallbacks#indexEntityReference. 6856 */ 6857 /* 6858 public struct CXIdxEntityRefKind : RawRepresentable, Equatable { 6859 public init(_ rawValue: UInt32) 6860 public init(rawValue: UInt32) 6861 // public var rawValue: UInt32 6862 } 6863 */ 6864 6865 /** 6866 * \brief The entity is referenced directly in user's code. 6867 */ 6868 // public var CXIdxEntityRef_Direct: CXIdxEntityRefKind { get } 6869 /** 6870 * \brief An implicit reference, e.g. a reference of an Objective-C method 6871 * via the dot syntax. 6872 */ 6873 // public var CXIdxEntityRef_Implicit: CXIdxEntityRefKind { get } 6874 6875 /** 6876 * \brief Data for IndexerCallbacks#indexEntityReference. 6877 */ 6878 /* 6879 public struct CXIdxEntityRefInfo { 6880 // public var kind: CXIdxEntityRefKind 6881 /** 6882 * \brief Reference cursor. 6883 */ 6884 // public var cursor: CXCursor 6885 // public var loc: CXIdxLoc 6886 /** 6887 * \brief The entity that gets referenced. 6888 */ 6889 // public var referencedEntity: UnsafePointer<CXIdxEntityInfo> 6890 /** 6891 * \brief Immediate "parent" of the reference. For example: 6892 * 6893 * \code 6894 * Foo *var; 6895 * \endcode 6896 * 6897 * The parent of reference of type 'Foo' is the variable 'var'. 6898 * For references inside statement bodies of functions/methods, 6899 * the parentEntity will be the function/method. 6900 */ 6901 // public var parentEntity: UnsafePointer<CXIdxEntityInfo> 6902 /** 6903 * \brief Lexical container context of the reference. 6904 */ 6905 // public var container: UnsafePointer<CXIdxContainerInfo> 6906 public init() 6907 public init(kind: CXIdxEntityRefKind, cursor: CXCursor, loc: CXIdxLoc, referencedEntity: UnsafePointer<CXIdxEntityInfo>, parentEntity: UnsafePointer<CXIdxEntityInfo>, container: UnsafePointer<CXIdxContainerInfo>) 6908 } 6909 */ 6910 6911 /** 6912 * \brief A group of callbacks used by #clang_indexSourceFile and 6913 * #clang_indexTranslationUnit. 6914 */ 6915 /* 6916 public struct IndexerCallbacks { 6917 /** 6918 * \brief Called periodically to check whether indexing should be aborted. 6919 * Should return 0 to continue, and non-zero to abort. 6920 */ 6921 // public var abortQuery: (@convention(c) (CXClientData, UnsafeMutablePointer<Void>) -> Int32)! 6922 6923 /** 6924 * \brief Called at the end of indexing; passes the complete diagnostic set. 6925 */ 6926 // public var diagnostic: (@convention(c) (CXClientData, CXDiagnosticSet, UnsafeMutablePointer<Void>) -> Void)! 6927 6928 // public var enteredMainFile: (@convention(c) (CXClientData, CXFile, UnsafeMutablePointer<Void>) -> CXIdxClientFile)! 6929 6930 /** 6931 * \brief Called when a file gets \#included/\#imported. 6932 */ 6933 // public var ppIncludedFile: (@convention(c) (CXClientData, UnsafePointer<CXIdxIncludedFileInfo>) -> CXIdxClientFile)! 6934 6935 /** 6936 * \brief Called when a AST file (PCH or module) gets imported. 6937 * 6938 * AST files will not get indexed (there will not be callbacks to index all 6939 * the entities in an AST file). The recommended action is that, if the AST 6940 * file is not already indexed, to initiate a new indexing job specific to 6941 * the AST file. 6942 */ 6943 // public var importedASTFile: (@convention(c) (CXClientData, UnsafePointer<CXIdxImportedASTFileInfo>) -> CXIdxClientASTFile)! 6944 6945 /** 6946 * \brief Called at the beginning of indexing a translation unit. 6947 */ 6948 // public var startedTranslationUnit: (@convention(c) (CXClientData, UnsafeMutablePointer<Void>) -> CXIdxClientContainer)! 6949 6950 // public var indexDeclaration: (@convention(c) (CXClientData, UnsafePointer<CXIdxDeclInfo>) -> Void)! 6951 6952 /** 6953 * \brief Called to index a reference of an entity. 6954 */ 6955 // public var indexEntityReference: (@convention(c) (CXClientData, UnsafePointer<CXIdxEntityRefInfo>) -> Void)! 6956 public init() 6957 public init(abortQuery: (@convention(c) (CXClientData, UnsafeMutablePointer<Void>) -> Int32)!, diagnostic: (@convention(c) (CXClientData, CXDiagnosticSet, UnsafeMutablePointer<Void>) -> Void)!, enteredMainFile: (@convention(c) (CXClientData, CXFile, UnsafeMutablePointer<Void>) -> CXIdxClientFile)!, ppIncludedFile: (@convention(c) (CXClientData, UnsafePointer<CXIdxIncludedFileInfo>) -> CXIdxClientFile)!, importedASTFile: (@convention(c) (CXClientData, UnsafePointer<CXIdxImportedASTFileInfo>) -> CXIdxClientASTFile)!, startedTranslationUnit: (@convention(c) (CXClientData, UnsafeMutablePointer<Void>) -> CXIdxClientContainer)!, indexDeclaration: (@convention(c) (CXClientData, UnsafePointer<CXIdxDeclInfo>) -> Void)!, indexEntityReference: (@convention(c) (CXClientData, UnsafePointer<CXIdxEntityRefInfo>) -> Void)!) 6958 } 6959 */ 6960 6961 public func clang_index_isEntityObjCContainerKind(unnamed1: CXIdxEntityKind) -> Int32 { 6962 return _clang_index_isEntityObjCContainerKind(unnamed1) 6963 } 6964 private let _clang_index_isEntityObjCContainerKind
created_Index.swift:6505 : @convention(c) (_: CXIdxEntityKind) -> Int32 = library.loadSymbol("clang_index_isEntityObjCContainerKind") 6965 6966 public func clang_index_getObjCContainerDeclInfo(unnamed1: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCContainerDeclInfo> { 6967 return _clang_index_getObjCContainerDeclInfo(unnamed1) 6968 } 6969 private let _clang_index_getObjCContainerDeclInfo
created_Index.swift:6962 : @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCContainerDeclInfo> = library.loadSymbol("clang_index_getObjCContainerDeclInfo") 6970 6971 6972 public func clang_index_getObjCInterfaceDeclInfo(unnamed1: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCInterfaceDeclInfo> { 6973 return _clang_index_getObjCInterfaceDeclInfo(unnamed1) 6974 } 6975 private let _clang_index_getObjCInterfaceDeclInfo
created_Index.swift:6967 : @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCInterfaceDeclInfo> = library.loadSymbol("clang_index_getObjCInterfaceDeclInfo") 6976 6977 6978 public func clang_index_getObjCCategoryDeclInfo(unnamed1: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCCategoryDeclInfo> { 6979 return _clang_index_getObjCCategoryDeclInfo(unnamed1) 6980 } 6981 private let _clang_index_getObjCCategoryDeclInfo
created_Index.swift:6973 : @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCCategoryDeclInfo> = library.loadSymbol("clang_index_getObjCCategoryDeclInfo") 6982 6983 6984 public func clang_index_getObjCProtocolRefListInfo(unnamed1: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCProtocolRefListInfo> { 6985 return _clang_index_getObjCProtocolRefListInfo(unnamed1) 6986 } 6987 private let _clang_index_getObjCProtocolRefListInfo
created_Index.swift:6979 : @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCProtocolRefListInfo> = library.loadSymbol("clang_index_getObjCProtocolRefListInfo") 6988 6989 6990 public func clang_index_getObjCPropertyDeclInfo(unnamed1: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCPropertyDeclInfo> { 6991 return _clang_index_getObjCPropertyDeclInfo(unnamed1) 6992 } 6993 private let _clang_index_getObjCPropertyDeclInfo
created_Index.swift:6985 : @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxObjCPropertyDeclInfo> = library.loadSymbol("clang_index_getObjCPropertyDeclInfo") 6994 6995 6996 public func clang_index_getIBOutletCollectionAttrInfo(unnamed1: UnsafePointer<CXIdxAttrInfo>) -> UnsafePointer<CXIdxIBOutletCollectionAttrInfo> { 6997 return _clang_index_getIBOutletCollectionAttrInfo(unnamed1) 6998 } 6999 private let _clang_index_getIBOutletCollectionAttrInfo
created_Index.swift:6991 : @convention(c) (_: UnsafePointer<CXIdxAttrInfo>) -> UnsafePointer<CXIdxIBOutletCollectionAttrInfo> = library.loadSymbol("clang_index_getIBOutletCollectionAttrInfo") 7000 7001 7002 public func clang_index_getCXXClassDeclInfo(unnamed1: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxCXXClassDeclInfo> { 7003 return _clang_index_getCXXClassDeclInfo(unnamed1) 7004 } 7005 private let _clang_index_getCXXClassDeclInfo
created_Index.swift:6997 : @convention(c) (_: UnsafePointer<CXIdxDeclInfo>) -> UnsafePointer<CXIdxCXXClassDeclInfo> = library.loadSymbol("clang_index_getCXXClassDeclInfo") 7006 7007 7008 /** 7009 * \brief For retrieving a custom CXIdxClientContainer attached to a 7010 * container. 7011 */ 7012 public func clang_index_getClientContainer(unnamed1: UnsafePointer<CXIdxContainerInfo>) -> CXIdxClientContainer { 7013 return _clang_index_getClientContainer(unnamed1) 7014 } 7015 private let _clang_index_getClientContainer
created_Index.swift:7003 : @convention(c) (_: UnsafePointer<CXIdxContainerInfo>) -> CXIdxClientContainer = library.loadSymbol("clang_index_getClientContainer") 7016 7017 7018 /** 7019 * \brief For setting a custom CXIdxClientContainer attached to a 7020 * container. 7021 */ 7022 public func clang_index_setClientContainer(unnamed1: UnsafePointer<CXIdxContainerInfo>, _ unnamed2: CXIdxClientContainer) { 7023 return _clang_index_setClientContainer(unnamed1, unnamed2) 7024 } 7025 private let _clang_index_setClientContainer
created_Index.swift:7013 : @convention(c) (_: UnsafePointer<CXIdxContainerInfo>, _: CXIdxClientContainer) -> () = library.loadSymbol("clang_index_setClientContainer") 7026 7027 7028 /** 7029 * \brief For retrieving a custom CXIdxClientEntity attached to an entity. 7030 */ 7031 public func clang_index_getClientEntity(unnamed1: UnsafePointer<CXIdxEntityInfo>) -> CXIdxClientEntity { 7032 return _clang_index_getClientEntity(unnamed1) 7033 } 7034 private let _clang_index_getClientEntity
created_Index.swift:7023 : @convention(c) (_: UnsafePointer<CXIdxEntityInfo>) -> CXIdxClientEntity = library.loadSymbol("clang_index_getClientEntity") 7035 7036 7037 /** 7038 * \brief For setting a custom CXIdxClientEntity attached to an entity. 7039 */ 7040 public func clang_index_setClientEntity(unnamed1: UnsafePointer<CXIdxEntityInfo>, _ unnamed2: CXIdxClientEntity) { 7041 return _clang_index_setClientEntity(unnamed1, unnamed2) 7042 } 7043 private let _clang_index_setClientEntity
created_Index.swift:7032 : @convention(c) (_: UnsafePointer<CXIdxEntityInfo>, _: CXIdxClientEntity) -> () = library.loadSymbol("clang_index_setClientEntity") 7044 7045 7046 /** 7047 * \brief An indexing action/session, to be applied to one or multiple 7048 * translation units. 7049 */ 7050 // public typealias CXIndexAction = UnsafeMutablePointer<Void> 7051 7052 /** 7053 * \brief An indexing action/session, to be applied to one or multiple 7054 * translation units. 7055 * 7056 * \param CIdx The index object with which the index action will be associated. 7057 */ 7058 public func clang_IndexAction_create(CIdx: CXIndex) -> CXIndexAction { 7059 return _clang_IndexAction_create(CIdx: CIdx) 7060 } 7061 private let _clang_IndexAction_create
created_Index.swift:7041 : @convention(c) (CIdx: CXIndex) -> CXIndexAction = library.loadSymbol("clang_IndexAction_create") 7062 7063 7064 /** 7065 * \brief Destroy the given index action. 7066 * 7067 * The index action must not be destroyed until all of the translation units 7068 * created within that index action have been destroyed. 7069 */ 7070 public func clang_IndexAction_dispose(unnamed1: CXIndexAction) { 7071 return _clang_IndexAction_dispose(unnamed1) 7072 } 7073 private let _clang_IndexAction_dispose
created_Index.swift:7059 : @convention(c) (_: CXIndexAction) -> () = library.loadSymbol("clang_IndexAction_dispose") 7074 7075 7076 /* 7077 public struct CXIndexOptFlags : RawRepresentable, Equatable { 7078 public init(_ rawValue: UInt32) 7079 public init(rawValue: UInt32) 7080 // public var rawValue: UInt32 7081 } 7082 */ 7083 7084 /** 7085 * \brief Used to indicate that no special indexing options are needed. 7086 */ 7087 // public var CXIndexOpt_None: CXIndexOptFlags { get } 7088 7089 /** 7090 * \brief Used to indicate that IndexerCallbacks#indexEntityReference should 7091 * be invoked for only one reference of an entity per source file that does 7092 * not also include a declaration/definition of the entity. 7093 */ 7094 // public var CXIndexOpt_SuppressRedundantRefs: CXIndexOptFlags { get } 7095 7096 /** 7097 * \brief Function-local symbols should be indexed. If this is not set 7098 * function-local symbols will be ignored. 7099 */ 7100 // public var CXIndexOpt_IndexFunctionLocalSymbols: CXIndexOptFlags { get } 7101 7102 /** 7103 * \brief Implicit function/class template instantiations should be indexed. 7104 * If this is not set, implicit instantiations will be ignored. 7105 */ 7106 // public var CXIndexOpt_IndexImplicitTemplateInstantiations: CXIndexOptFlags { get } 7107 7108 /** 7109 * \brief Suppress all compiler warnings when parsing for indexing. 7110 */ 7111 // public var CXIndexOpt_SuppressWarnings: CXIndexOptFlags { get } 7112 7113 /** 7114 * \brief Skip a function/method body that was already parsed during an 7115 * indexing session associated with a \c CXIndexAction object. 7116 * Bodies in system headers are always skipped. 7117 */ 7118 // public var CXIndexOpt_SkipParsedBodiesInSession: CXIndexOptFlags { get } 7119 7120 /** 7121 * \brief Index the given source file and the translation unit corresponding 7122 * to that file via callbacks implemented through #IndexerCallbacks. 7123 * 7124 * \param client_data pointer data supplied by the client, which will 7125 * be passed to the invoked callbacks. 7126 * 7127 * \param index_callbacks Pointer to indexing callbacks that the client 7128 * implements. 7129 * 7130 * \param index_callbacks_size Size of #IndexerCallbacks structure that gets 7131 * passed in index_callbacks. 7132 * 7133 * \param index_options A bitmask of options that affects how indexing is 7134 * performed. This should be a bitwise OR of the CXIndexOpt_XXX flags. 7135 * 7136 * \param[out] out_TU pointer to store a \c CXTranslationUnit that can be 7137 * reused after indexing is finished. Set to \c NULL if you do not require it. 7138 * 7139 * \returns 0 on success or if there were errors from which the compiler could 7140 * recover. If there is a failure from which there is no recovery, returns 7141 * a non-zero \c CXErrorCode. 7142 * 7143 * The rest of the parameters are the same as #clang_parseTranslationUnit. 7144 */ 7145 public func clang_indexSourceFile(unnamed1: CXIndexAction, _ client_data: CXClientData, _ index_callbacks: UnsafeMutablePointer<IndexerCallbacks>, _ index_callbacks_size: UInt32, _ index_options: UInt32, _ source_filename: UnsafePointer<Int8>, _ command_line_args: UnsafePointer<UnsafePointer<Int8>>, _ num_command_line_args: Int32, _ unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, _ num_unsaved_files: UInt32, _ out_TU: UnsafeMutablePointer<CXTranslationUnit>, _ TU_options: UInt32) -> Int32 { 7146 return _clang_indexSourceFile(unnamed1, client_data: client_data, index_callbacks: index_callbacks, index_callbacks_size: index_callbacks_size, index_options: index_options, source_filename: source_filename, command_line_args: command_line_args, num_command_line_args: num_command_line_args, unsaved_files: unsaved_files, num_unsaved_files: num_unsaved_files, out_TU: out_TU, TU_options: TU_options) 7147 } 7148 private let _clang_indexSourceFile
created_Index.swift:7071 : @convention(c) (_: CXIndexAction, client_data: CXClientData, index_callbacks: UnsafeMutablePointer<IndexerCallbacks>, index_callbacks_size: UInt32, index_options: UInt32, source_filename: UnsafePointer<Int8>, command_line_args: UnsafePointer<UnsafePointer<Int8>>, num_command_line_args: Int32, unsaved_files: UnsafeMutablePointer<CXUnsavedFile>, num_unsaved_files: UInt32, out_TU: UnsafeMutablePointer<CXTranslationUnit>, TU_options: UInt32) -> Int32 = library.loadSymbol("clang_indexSourceFile") 7149 7150 7151 /** 7152 * \brief Index the given translation unit via callbacks implemented through 7153 * #IndexerCallbacks. 7154 * 7155 * The order of callback invocations is not guaranteed to be the same as 7156 * when indexing a source file. The high level order will be: 7157 * 7158 * -Preprocessor callbacks invocations 7159 * -Declaration/reference callbacks invocations 7160 * -Diagnostic callback invocations 7161 * 7162 * The parameters are the same as #clang_indexSourceFile. 7163 * 7164 * \returns If there is a failure from which there is no recovery, returns 7165 * non-zero, otherwise returns 0. 7166 */ 7167 public func clang_indexTranslationUnit(unnamed1: CXIndexAction, _ client_data: CXClientData, _ index_callbacks: UnsafeMutablePointer<IndexerCallbacks>, _ index_callbacks_size: UInt32, _ index_options: UInt32, _ unnamed2: CXTranslationUnit) -> Int32 { 7168 return _clang_indexTranslationUnit(unnamed1, client_data: client_data, index_callbacks: index_callbacks, index_callbacks_size: index_callbacks_size, index_options: index_options, unnamed2) 7169 } 7170 private let _clang_indexTranslationUnit
created_Index.swift:7146 : @convention(c) (_: CXIndexAction, client_data: CXClientData, index_callbacks: UnsafeMutablePointer<IndexerCallbacks>, index_callbacks_size: UInt32, index_options: UInt32, _: CXTranslationUnit) -> Int32 = library.loadSymbol("clang_indexTranslationUnit") 7171 7172 7173 /** 7174 * \brief Retrieve the CXIdxFile, file, line, column, and offset represented by 7175 * the given CXIdxLoc. 7176 * 7177 * If the location refers into a macro expansion, retrieves the 7178 * location of the macro expansion and if it refers into a macro argument 7179 * retrieves the location of the argument. 7180 */ 7181 public func clang_indexLoc_getFileLocation(loc: CXIdxLoc, _ indexFile: UnsafeMutablePointer<CXIdxClientFile>, _ file: UnsafeMutablePointer<CXFile>, _ line: UnsafeMutablePointer<UInt32>, _ column: UnsafeMutablePointer<UInt32>, _ offset: UnsafeMutablePointer<UInt32>) { 7182 return _clang_indexLoc_getFileLocation(loc: loc, indexFile: indexFile, file: file, line: line, column: column, offset: offset) 7183 } 7184 private let _clang_indexLoc_getFileLocation
created_Index.swift:7168 : @convention(c) (loc: CXIdxLoc, indexFile: UnsafeMutablePointer<CXIdxClientFile>, file: UnsafeMutablePointer<CXFile>, line: UnsafeMutablePointer<UInt32>, column: UnsafeMutablePointer<UInt32>, offset: UnsafeMutablePointer<UInt32>) -> () = library.loadSymbol("clang_indexLoc_getFileLocation") 7185 7186 7187 7188 /** 7189 * \brief Retrieve the CXSourceLocation represented by the given CXIdxLoc. 7190 */ 7191 public func clang_indexLoc_getCXSourceLocation(loc: CXIdxLoc) -> CXSourceLocation { 7192 return _clang_indexLoc_getCXSourceLocation(loc: loc) 7193 } 7194 private let _clang_indexLoc_getCXSourceLocation
created_Index.swift:7182 : @convention(c) (loc: CXIdxLoc) -> CXSourceLocation = library.loadSymbol("clang_indexLoc_getCXSourceLocation") 7195 7196 7197 /** 7198 * \brief Visitor invoked for each field found by a traversal. 7199 * 7200 * This visitor function will be invoked for each field found by 7201 * \c clang_Type_visitFields. Its first argument is the cursor being 7202 * visited, its second argument is the client data provided to 7203 * \c clang_Type_visitFields. 7204 * 7205 * The visitor should return one of the \c CXVisitorResult values 7206 * to direct \c clang_Type_visitFields. 7207 */ 7208 // public typealias CXFieldVisitor = @convention(c) (CXCursor, CXClientData) -> CXVisitorResult 7209 7210 /** 7211 * \brief Visit the fields of a particular type. 7212 * 7213 * This function visits all the direct fields of the given cursor, 7214 * invoking the given \p visitor function with the cursors of each 7215 * visited field. The traversal may be ended prematurely, if 7216 * the visitor returns \c CXFieldVisit_Break. 7217 * 7218 * \param T the record type whose field may be visited. 7219 * 7220 * \param visitor the visitor function that will be invoked for each 7221 * field of \p T. 7222 * 7223 * \param client_data pointer data supplied by the client, which will 7224 * be passed to the visitor each time it is invoked. 7225 * 7226 * \returns a non-zero value if the traversal was terminated 7227 * prematurely by the visitor returning \c CXFieldVisit_Break. 7228 */ 7229 public func clang_Type_visitFields(T: CXType, _ visitor: CXFieldVisitor!, _ client_data: CXClientData) -> UInt32 { 7230 return _clang_Type_visitFields(T: T, visitor: visitor, client_data: client_data) 7231 } 7232 private let _clang_Type_visitFields
created_Index.swift:7192 : @convention(c) (T: CXType, visitor: CXFieldVisitor!, client_data: CXClientData) -> UInt32 = library.loadSymbol("clang_Type_visitFields") 7233 7234
created_Index.swift:7230