| /// AUTO GENERATED FILE, DO NOT EDIT. |
| /// |
| /// Generated by `package:ffigen`. |
| |
| import 'dart:ffi' as ffi; |
| |
| /// Holds the Dynamic library. |
| ffi.DynamicLibrary _dylib; |
| |
| /// Initialises the Dynamic library. |
| void init(ffi.DynamicLibrary dynamicLibrary) { |
| _dylib = dynamicLibrary; |
| } |
| |
| /// Contains the results of code-completion. |
| /// |
| /// This data structure contains the results of code completion, as |
| /// produced by \c clang_codeCompleteAt(). Its contents must be freed by |
| /// \c clang_disposeCodeCompleteResults. |
| class CXCodeCompleteResults extends ffi.Struct { |
| /// The code-completion results. |
| ffi.Pointer<CXCompletionResult> Results; |
| |
| /// The number of code-completion results stored in the |
| /// \c Results array. |
| @ffi.Uint32() |
| int NumResults; |
| } |
| |
| /// A single result of code completion. |
| class CXCompletionResult extends ffi.Struct { |
| /// The kind of entity that this completion refers to. |
| /// |
| /// The cursor kind will be a macro, keyword, or a declaration (one of the |
| /// *Decl cursor kinds), describing the entity that the completion is |
| /// referring to. |
| /// |
| /// \todo In the future, we would like to provide a full cursor, to allow |
| /// the client to extract additional information from declaration. |
| @ffi.Int32() |
| int CursorKind; |
| |
| /// The code-completion string that describes how to insert this |
| /// code-completion result into the editing buffer. |
| ffi.Pointer<ffi.Void> CompletionString; |
| } |
| |
| /// A cursor representing some element in the abstract syntax tree for |
| /// a translation unit. |
| /// |
| /// The cursor abstraction unifies the different kinds of entities in a |
| /// program--declaration, statements, expressions, references to declarations, |
| /// etc.--under a single "cursor" abstraction with a common set of operations. |
| /// Common operation for a cursor include: getting the physical location in |
| /// a source file where the cursor points, getting the name associated with a |
| /// cursor, and retrieving cursors for any child nodes of a particular cursor. |
| /// |
| /// Cursors can be produced in two specific ways. |
| /// clang_getTranslationUnitCursor() produces a cursor for a translation unit, |
| /// from which one can use clang_visitChildren() to explore the rest of the |
| /// translation unit. clang_getCursor() maps from a physical source location |
| /// to the entity that resides at that location, allowing one to map from the |
| /// source code into the AST. |
| class CXCursor extends ffi.Struct { |
| @ffi.Int32() |
| int kind; |
| |
| @ffi.Int32() |
| int xdata; |
| |
| ffi.Pointer<ffi.Void> _exp_workaround_data_item_0; |
| ffi.Pointer<ffi.Void> _exp_workaround_data_item_1; |
| ffi.Pointer<ffi.Void> _exp_workaround_data_item_2; |
| |
| /// Helper for array `data`. |
| ArrayHelper_CXCursor_data_level0 get data => |
| ArrayHelper_CXCursor_data_level0(this, [3], 0, 0); |
| } |
| |
| /// Helper for array `data` in struct `CXCursor`. |
| class ArrayHelper_CXCursor_data_level0 { |
| final CXCursor _struct; |
| final List<int> dimensions; |
| final int level; |
| final int _absoluteIndex; |
| int get length => dimensions[level]; |
| ArrayHelper_CXCursor_data_level0( |
| this._struct, this.dimensions, this.level, this._absoluteIndex); |
| void _checkBounds(int index) { |
| if (index >= length || index < 0) { |
| throw RangeError( |
| 'Dimension $level: index not in range 0..${length} exclusive.'); |
| } |
| } |
| |
| ffi.Pointer<ffi.Void> operator [](int index) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| return _struct._exp_workaround_data_item_0; |
| case 1: |
| return _struct._exp_workaround_data_item_1; |
| case 2: |
| return _struct._exp_workaround_data_item_2; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| |
| void operator []=(int index, ffi.Pointer<ffi.Void> value) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| _struct._exp_workaround_data_item_0 = value; |
| break; |
| case 1: |
| _struct._exp_workaround_data_item_1 = value; |
| break; |
| case 2: |
| _struct._exp_workaround_data_item_2 = value; |
| break; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| } |
| |
| class CXCursorAndRangeVisitor extends ffi.Struct {} |
| |
| class CXCursorSetImpl extends ffi.Struct {} |
| |
| /// Uniquely identifies a CXFile, that refers to the same underlying file, |
| /// across an indexing session. |
| class CXFileUniqueID extends ffi.Struct { |
| @ffi.Uint64() |
| int _exp_workaround_data_item_0; |
| @ffi.Uint64() |
| int _exp_workaround_data_item_1; |
| @ffi.Uint64() |
| int _exp_workaround_data_item_2; |
| |
| /// Helper for array `data`. |
| ArrayHelper_CXFileUniqueID_data_level0 get data => |
| ArrayHelper_CXFileUniqueID_data_level0(this, [3], 0, 0); |
| } |
| |
| /// Helper for array `data` in struct `CXFileUniqueID`. |
| class ArrayHelper_CXFileUniqueID_data_level0 { |
| final CXFileUniqueID _struct; |
| final List<int> dimensions; |
| final int level; |
| final int _absoluteIndex; |
| int get length => dimensions[level]; |
| ArrayHelper_CXFileUniqueID_data_level0( |
| this._struct, this.dimensions, this.level, this._absoluteIndex); |
| void _checkBounds(int index) { |
| if (index >= length || index < 0) { |
| throw RangeError( |
| 'Dimension $level: index not in range 0..${length} exclusive.'); |
| } |
| } |
| |
| int operator [](int index) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| return _struct._exp_workaround_data_item_0; |
| case 1: |
| return _struct._exp_workaround_data_item_1; |
| case 2: |
| return _struct._exp_workaround_data_item_2; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| |
| void operator []=(int index, int value) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| _struct._exp_workaround_data_item_0 = value; |
| break; |
| case 1: |
| _struct._exp_workaround_data_item_1 = value; |
| break; |
| case 2: |
| _struct._exp_workaround_data_item_2 = value; |
| break; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| } |
| |
| class CXGlobalOptFlags { |
| /// Used to indicate that no special CXIndex options are needed. |
| static const int CXGlobalOpt_None = 0; |
| |
| /// Used to indicate that threads that libclang creates for indexing |
| /// purposes should use background priority. |
| /// |
| /// Affects #clang_indexSourceFile, #clang_indexTranslationUnit, |
| /// #clang_parseTranslationUnit, #clang_saveTranslationUnit. |
| static const int CXGlobalOpt_ThreadBackgroundPriorityForIndexing = 1; |
| |
| /// Used to indicate that threads that libclang creates for editing |
| /// purposes should use background priority. |
| /// |
| /// Affects #clang_reparseTranslationUnit, #clang_codeCompleteAt, |
| /// #clang_annotateTokens |
| static const int CXGlobalOpt_ThreadBackgroundPriorityForEditing = 2; |
| |
| /// Used to indicate that all threads that libclang creates should use |
| /// background priority. |
| static const int CXGlobalOpt_ThreadBackgroundPriorityForAll = 3; |
| } |
| |
| class CXIdxAttrInfo extends ffi.Struct {} |
| |
| class CXIdxBaseClassInfo extends ffi.Struct {} |
| |
| class CXIdxCXXClassDeclInfo extends ffi.Struct { |
| ffi.Pointer<CXIdxDeclInfo> declInfo; |
| |
| ffi.Pointer<ffi.Pointer<CXIdxBaseClassInfo>> bases; |
| |
| @ffi.Uint32() |
| int numBases; |
| } |
| |
| class CXIdxContainerInfo extends ffi.Struct {} |
| |
| class CXIdxDeclInfo extends ffi.Struct {} |
| |
| class CXIdxEntityInfo extends ffi.Struct {} |
| |
| /// Data for IndexerCallbacks#indexEntityReference. |
| class CXIdxEntityRefInfo extends ffi.Struct {} |
| |
| class CXIdxIBOutletCollectionAttrInfo extends ffi.Struct {} |
| |
| /// Data for IndexerCallbacks#importedASTFile. |
| class CXIdxImportedASTFileInfo extends ffi.Struct {} |
| |
| /// Data for ppIncludedFile callback. |
| class CXIdxIncludedFileInfo extends ffi.Struct {} |
| |
| /// Source location passed to index callbacks. |
| class CXIdxLoc extends ffi.Struct { |
| ffi.Pointer<ffi.Void> _exp_workaround_ptr_data_item_0; |
| ffi.Pointer<ffi.Void> _exp_workaround_ptr_data_item_1; |
| |
| /// Helper for array `ptr_data`. |
| ArrayHelper_CXIdxLoc_ptr_data_level0 get ptr_data => |
| ArrayHelper_CXIdxLoc_ptr_data_level0(this, [2], 0, 0); |
| @ffi.Uint32() |
| int int_data; |
| } |
| |
| /// Helper for array `ptr_data` in struct `CXIdxLoc`. |
| class ArrayHelper_CXIdxLoc_ptr_data_level0 { |
| final CXIdxLoc _struct; |
| final List<int> dimensions; |
| final int level; |
| final int _absoluteIndex; |
| int get length => dimensions[level]; |
| ArrayHelper_CXIdxLoc_ptr_data_level0( |
| this._struct, this.dimensions, this.level, this._absoluteIndex); |
| void _checkBounds(int index) { |
| if (index >= length || index < 0) { |
| throw RangeError( |
| 'Dimension $level: index not in range 0..${length} exclusive.'); |
| } |
| } |
| |
| ffi.Pointer<ffi.Void> operator [](int index) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| return _struct._exp_workaround_ptr_data_item_0; |
| case 1: |
| return _struct._exp_workaround_ptr_data_item_1; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| |
| void operator []=(int index, ffi.Pointer<ffi.Void> value) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| _struct._exp_workaround_ptr_data_item_0 = value; |
| break; |
| case 1: |
| _struct._exp_workaround_ptr_data_item_1 = value; |
| break; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| } |
| |
| class CXIdxObjCCategoryDeclInfo extends ffi.Struct {} |
| |
| class CXIdxObjCContainerDeclInfo extends ffi.Struct { |
| ffi.Pointer<CXIdxDeclInfo> declInfo; |
| |
| @ffi.Int32() |
| int kind; |
| } |
| |
| class CXIdxObjCInterfaceDeclInfo extends ffi.Struct { |
| ffi.Pointer<CXIdxObjCContainerDeclInfo> containerInfo; |
| |
| ffi.Pointer<CXIdxBaseClassInfo> superInfo; |
| |
| ffi.Pointer<CXIdxObjCProtocolRefListInfo> protocols; |
| } |
| |
| class CXIdxObjCPropertyDeclInfo extends ffi.Struct { |
| ffi.Pointer<CXIdxDeclInfo> declInfo; |
| |
| ffi.Pointer<CXIdxEntityInfo> getter; |
| |
| ffi.Pointer<CXIdxEntityInfo> setter; |
| } |
| |
| class CXIdxObjCProtocolRefInfo extends ffi.Struct {} |
| |
| class CXIdxObjCProtocolRefListInfo extends ffi.Struct { |
| ffi.Pointer<ffi.Pointer<CXIdxObjCProtocolRefInfo>> protocols; |
| |
| @ffi.Uint32() |
| int numProtocols; |
| } |
| |
| /// Describes the availability of a given entity on a particular platform, e.g., |
| /// a particular class might only be available on Mac OS 10.7 or newer. |
| class CXPlatformAvailability extends ffi.Struct {} |
| |
| /// Identifies a specific source location within a translation |
| /// unit. |
| /// |
| /// Use clang_getExpansionLocation() or clang_getSpellingLocation() |
| /// to map a source location to a particular file, line, and column. |
| class CXSourceLocation extends ffi.Struct { |
| ffi.Pointer<ffi.Void> _exp_workaround_ptr_data_item_0; |
| ffi.Pointer<ffi.Void> _exp_workaround_ptr_data_item_1; |
| |
| /// Helper for array `ptr_data`. |
| ArrayHelper_CXSourceLocation_ptr_data_level0 get ptr_data => |
| ArrayHelper_CXSourceLocation_ptr_data_level0(this, [2], 0, 0); |
| @ffi.Uint32() |
| int int_data; |
| } |
| |
| /// Helper for array `ptr_data` in struct `CXSourceLocation`. |
| class ArrayHelper_CXSourceLocation_ptr_data_level0 { |
| final CXSourceLocation _struct; |
| final List<int> dimensions; |
| final int level; |
| final int _absoluteIndex; |
| int get length => dimensions[level]; |
| ArrayHelper_CXSourceLocation_ptr_data_level0( |
| this._struct, this.dimensions, this.level, this._absoluteIndex); |
| void _checkBounds(int index) { |
| if (index >= length || index < 0) { |
| throw RangeError( |
| 'Dimension $level: index not in range 0..${length} exclusive.'); |
| } |
| } |
| |
| ffi.Pointer<ffi.Void> operator [](int index) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| return _struct._exp_workaround_ptr_data_item_0; |
| case 1: |
| return _struct._exp_workaround_ptr_data_item_1; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| |
| void operator []=(int index, ffi.Pointer<ffi.Void> value) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| _struct._exp_workaround_ptr_data_item_0 = value; |
| break; |
| case 1: |
| _struct._exp_workaround_ptr_data_item_1 = value; |
| break; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| } |
| |
| /// Identifies a half-open character range in the source code. |
| /// |
| /// Use clang_getRangeStart() and clang_getRangeEnd() to retrieve the |
| /// starting and end locations from a source range, respectively. |
| class CXSourceRange extends ffi.Struct { |
| ffi.Pointer<ffi.Void> _exp_workaround_ptr_data_item_0; |
| ffi.Pointer<ffi.Void> _exp_workaround_ptr_data_item_1; |
| |
| /// Helper for array `ptr_data`. |
| ArrayHelper_CXSourceRange_ptr_data_level0 get ptr_data => |
| ArrayHelper_CXSourceRange_ptr_data_level0(this, [2], 0, 0); |
| @ffi.Uint32() |
| int begin_int_data; |
| |
| @ffi.Uint32() |
| int end_int_data; |
| } |
| |
| /// Helper for array `ptr_data` in struct `CXSourceRange`. |
| class ArrayHelper_CXSourceRange_ptr_data_level0 { |
| final CXSourceRange _struct; |
| final List<int> dimensions; |
| final int level; |
| final int _absoluteIndex; |
| int get length => dimensions[level]; |
| ArrayHelper_CXSourceRange_ptr_data_level0( |
| this._struct, this.dimensions, this.level, this._absoluteIndex); |
| void _checkBounds(int index) { |
| if (index >= length || index < 0) { |
| throw RangeError( |
| 'Dimension $level: index not in range 0..${length} exclusive.'); |
| } |
| } |
| |
| ffi.Pointer<ffi.Void> operator [](int index) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| return _struct._exp_workaround_ptr_data_item_0; |
| case 1: |
| return _struct._exp_workaround_ptr_data_item_1; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| |
| void operator []=(int index, ffi.Pointer<ffi.Void> value) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| _struct._exp_workaround_ptr_data_item_0 = value; |
| break; |
| case 1: |
| _struct._exp_workaround_ptr_data_item_1 = value; |
| break; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| } |
| |
| /// Identifies an array of ranges. |
| class CXSourceRangeList extends ffi.Struct { |
| /// The number of ranges in the \c ranges array. |
| @ffi.Uint32() |
| int count; |
| |
| /// An array of \c CXSourceRanges. |
| ffi.Pointer<CXSourceRange> ranges; |
| } |
| |
| /// A character string. |
| /// |
| /// The \c CXString type is used to return strings from the interface when |
| /// the ownership of that string might differ from one call to the next. |
| /// Use \c clang_getCString() to retrieve the string data and, once finished |
| /// with the string data, call \c clang_disposeString() to free the string. |
| class CXString extends ffi.Struct { |
| ffi.Pointer<ffi.Void> data; |
| |
| @ffi.Uint32() |
| int private_flags; |
| } |
| |
| class CXStringSet extends ffi.Struct { |
| ffi.Pointer<CXString> Strings; |
| |
| @ffi.Uint32() |
| int Count; |
| } |
| |
| /// The memory usage of a CXTranslationUnit, broken into categories. |
| class CXTUResourceUsage extends ffi.Struct { |
| ffi.Pointer<ffi.Void> data; |
| |
| @ffi.Uint32() |
| int numEntries; |
| |
| ffi.Pointer<CXTUResourceUsageEntry> entries; |
| } |
| |
| class CXTUResourceUsageEntry extends ffi.Struct { |
| @ffi.Int32() |
| int kind; |
| |
| @ffi.Uint64() |
| int amount; |
| } |
| |
| class CXTargetInfoImpl extends ffi.Struct {} |
| |
| /// Describes a single preprocessing token. |
| class CXToken extends ffi.Struct { |
| @ffi.Uint32() |
| int _exp_workaround_int_data_item_0; |
| @ffi.Uint32() |
| int _exp_workaround_int_data_item_1; |
| @ffi.Uint32() |
| int _exp_workaround_int_data_item_2; |
| @ffi.Uint32() |
| int _exp_workaround_int_data_item_3; |
| |
| /// Helper for array `int_data`. |
| ArrayHelper_CXToken_int_data_level0 get int_data => |
| ArrayHelper_CXToken_int_data_level0(this, [4], 0, 0); |
| ffi.Pointer<ffi.Void> ptr_data; |
| } |
| |
| /// Helper for array `int_data` in struct `CXToken`. |
| class ArrayHelper_CXToken_int_data_level0 { |
| final CXToken _struct; |
| final List<int> dimensions; |
| final int level; |
| final int _absoluteIndex; |
| int get length => dimensions[level]; |
| ArrayHelper_CXToken_int_data_level0( |
| this._struct, this.dimensions, this.level, this._absoluteIndex); |
| void _checkBounds(int index) { |
| if (index >= length || index < 0) { |
| throw RangeError( |
| 'Dimension $level: index not in range 0..${length} exclusive.'); |
| } |
| } |
| |
| int operator [](int index) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| return _struct._exp_workaround_int_data_item_0; |
| case 1: |
| return _struct._exp_workaround_int_data_item_1; |
| case 2: |
| return _struct._exp_workaround_int_data_item_2; |
| case 3: |
| return _struct._exp_workaround_int_data_item_3; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| |
| void operator []=(int index, int value) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| _struct._exp_workaround_int_data_item_0 = value; |
| break; |
| case 1: |
| _struct._exp_workaround_int_data_item_1 = value; |
| break; |
| case 2: |
| _struct._exp_workaround_int_data_item_2 = value; |
| break; |
| case 3: |
| _struct._exp_workaround_int_data_item_3 = value; |
| break; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| } |
| |
| class CXTranslationUnitImpl extends ffi.Struct {} |
| |
| /// The type of an element in the abstract syntax tree. |
| class CXType extends ffi.Struct { |
| @ffi.Int32() |
| int kind; |
| |
| ffi.Pointer<ffi.Void> _exp_workaround_data_item_0; |
| ffi.Pointer<ffi.Void> _exp_workaround_data_item_1; |
| |
| /// Helper for array `data`. |
| ArrayHelper_CXType_data_level0 get data => |
| ArrayHelper_CXType_data_level0(this, [2], 0, 0); |
| } |
| |
| /// Helper for array `data` in struct `CXType`. |
| class ArrayHelper_CXType_data_level0 { |
| final CXType _struct; |
| final List<int> dimensions; |
| final int level; |
| final int _absoluteIndex; |
| int get length => dimensions[level]; |
| ArrayHelper_CXType_data_level0( |
| this._struct, this.dimensions, this.level, this._absoluteIndex); |
| void _checkBounds(int index) { |
| if (index >= length || index < 0) { |
| throw RangeError( |
| 'Dimension $level: index not in range 0..${length} exclusive.'); |
| } |
| } |
| |
| ffi.Pointer<ffi.Void> operator [](int index) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| return _struct._exp_workaround_data_item_0; |
| case 1: |
| return _struct._exp_workaround_data_item_1; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| |
| void operator []=(int index, ffi.Pointer<ffi.Void> value) { |
| _checkBounds(index); |
| switch (_absoluteIndex + index) { |
| case 0: |
| _struct._exp_workaround_data_item_0 = value; |
| break; |
| case 1: |
| _struct._exp_workaround_data_item_1 = value; |
| break; |
| default: |
| throw Exception('Invalid Array Helper generated.'); |
| } |
| } |
| } |
| |
| /// Describes the kind of type |
| class CXTypeKind { |
| /// Represents an invalid type (e.g., where no type is available). |
| static const int CXType_Invalid = 0; |
| |
| /// A type whose specific kind is not exposed via this |
| /// interface. |
| static const int CXType_Unexposed = 1; |
| static const int CXType_Void = 2; |
| static const int CXType_Bool = 3; |
| static const int CXType_Char_U = 4; |
| static const int CXType_UChar = 5; |
| static const int CXType_Char16 = 6; |
| static const int CXType_Char32 = 7; |
| static const int CXType_UShort = 8; |
| static const int CXType_UInt = 9; |
| static const int CXType_ULong = 10; |
| static const int CXType_ULongLong = 11; |
| static const int CXType_UInt128 = 12; |
| static const int CXType_Char_S = 13; |
| static const int CXType_SChar = 14; |
| static const int CXType_WChar = 15; |
| static const int CXType_Short = 16; |
| static const int CXType_Int = 17; |
| static const int CXType_Long = 18; |
| static const int CXType_LongLong = 19; |
| static const int CXType_Int128 = 20; |
| static const int CXType_Float = 21; |
| static const int CXType_Double = 22; |
| static const int CXType_LongDouble = 23; |
| static const int CXType_NullPtr = 24; |
| static const int CXType_Overload = 25; |
| static const int CXType_Dependent = 26; |
| static const int CXType_ObjCId = 27; |
| static const int CXType_ObjCClass = 28; |
| static const int CXType_ObjCSel = 29; |
| static const int CXType_Float128 = 30; |
| static const int CXType_Half = 31; |
| static const int CXType_Float16 = 32; |
| static const int CXType_ShortAccum = 33; |
| static const int CXType_Accum = 34; |
| static const int CXType_LongAccum = 35; |
| static const int CXType_UShortAccum = 36; |
| static const int CXType_UAccum = 37; |
| static const int CXType_ULongAccum = 38; |
| static const int CXType_FirstBuiltin = 2; |
| static const int CXType_LastBuiltin = 38; |
| static const int CXType_Complex = 100; |
| static const int CXType_Pointer = 101; |
| static const int CXType_BlockPointer = 102; |
| static const int CXType_LValueReference = 103; |
| static const int CXType_RValueReference = 104; |
| static const int CXType_Record = 105; |
| static const int CXType_Enum = 106; |
| static const int CXType_Typedef = 107; |
| static const int CXType_ObjCInterface = 108; |
| static const int CXType_ObjCObjectPointer = 109; |
| static const int CXType_FunctionNoProto = 110; |
| static const int CXType_FunctionProto = 111; |
| static const int CXType_ConstantArray = 112; |
| static const int CXType_Vector = 113; |
| static const int CXType_IncompleteArray = 114; |
| static const int CXType_VariableArray = 115; |
| static const int CXType_DependentSizedArray = 116; |
| static const int CXType_MemberPointer = 117; |
| static const int CXType_Auto = 118; |
| |
| /// Represents a type that was referred to using an elaborated type keyword. |
| /// |
| /// E.g., struct S, or via a qualified name, e.g., N::M::type, or both. |
| static const int CXType_Elaborated = 119; |
| static const int CXType_Pipe = 120; |
| static const int CXType_OCLImage1dRO = 121; |
| static const int CXType_OCLImage1dArrayRO = 122; |
| static const int CXType_OCLImage1dBufferRO = 123; |
| static const int CXType_OCLImage2dRO = 124; |
| static const int CXType_OCLImage2dArrayRO = 125; |
| static const int CXType_OCLImage2dDepthRO = 126; |
| static const int CXType_OCLImage2dArrayDepthRO = 127; |
| static const int CXType_OCLImage2dMSAARO = 128; |
| static const int CXType_OCLImage2dArrayMSAARO = 129; |
| static const int CXType_OCLImage2dMSAADepthRO = 130; |
| static const int CXType_OCLImage2dArrayMSAADepthRO = 131; |
| static const int CXType_OCLImage3dRO = 132; |
| static const int CXType_OCLImage1dWO = 133; |
| static const int CXType_OCLImage1dArrayWO = 134; |
| static const int CXType_OCLImage1dBufferWO = 135; |
| static const int CXType_OCLImage2dWO = 136; |
| static const int CXType_OCLImage2dArrayWO = 137; |
| static const int CXType_OCLImage2dDepthWO = 138; |
| static const int CXType_OCLImage2dArrayDepthWO = 139; |
| static const int CXType_OCLImage2dMSAAWO = 140; |
| static const int CXType_OCLImage2dArrayMSAAWO = 141; |
| static const int CXType_OCLImage2dMSAADepthWO = 142; |
| static const int CXType_OCLImage2dArrayMSAADepthWO = 143; |
| static const int CXType_OCLImage3dWO = 144; |
| static const int CXType_OCLImage1dRW = 145; |
| static const int CXType_OCLImage1dArrayRW = 146; |
| static const int CXType_OCLImage1dBufferRW = 147; |
| static const int CXType_OCLImage2dRW = 148; |
| static const int CXType_OCLImage2dArrayRW = 149; |
| static const int CXType_OCLImage2dDepthRW = 150; |
| static const int CXType_OCLImage2dArrayDepthRW = 151; |
| static const int CXType_OCLImage2dMSAARW = 152; |
| static const int CXType_OCLImage2dArrayMSAARW = 153; |
| static const int CXType_OCLImage2dMSAADepthRW = 154; |
| static const int CXType_OCLImage2dArrayMSAADepthRW = 155; |
| static const int CXType_OCLImage3dRW = 156; |
| static const int CXType_OCLSampler = 157; |
| static const int CXType_OCLEvent = 158; |
| static const int CXType_OCLQueue = 159; |
| static const int CXType_OCLReserveID = 160; |
| static const int CXType_ObjCObject = 161; |
| static const int CXType_ObjCTypeParam = 162; |
| static const int CXType_Attributed = 163; |
| static const int CXType_OCLIntelSubgroupAVCMcePayload = 164; |
| static const int CXType_OCLIntelSubgroupAVCImePayload = 165; |
| static const int CXType_OCLIntelSubgroupAVCRefPayload = 166; |
| static const int CXType_OCLIntelSubgroupAVCSicPayload = 167; |
| static const int CXType_OCLIntelSubgroupAVCMceResult = 168; |
| static const int CXType_OCLIntelSubgroupAVCImeResult = 169; |
| static const int CXType_OCLIntelSubgroupAVCRefResult = 170; |
| static const int CXType_OCLIntelSubgroupAVCSicResult = 171; |
| static const int CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout = 172; |
| static const int CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout = 173; |
| static const int CXType_OCLIntelSubgroupAVCImeSingleRefStreamin = 174; |
| static const int CXType_OCLIntelSubgroupAVCImeDualRefStreamin = 175; |
| static const int CXType_ExtVector = 176; |
| } |
| |
| /// Provides the contents of a file that has not yet been saved to disk. |
| /// |
| /// Each CXUnsavedFile instance provides the name of a file on the |
| /// system along with the current contents of that file that have not |
| /// yet been saved to disk. |
| class CXUnsavedFile extends ffi.Struct { |
| /// The file whose contents have not yet been saved. |
| /// |
| /// This file must already exist in the file system. |
| ffi.Pointer<ffi.Int8> Filename; |
| |
| /// A buffer containing the unsaved contents of this file. |
| ffi.Pointer<ffi.Int8> Contents; |
| |
| /// The length of the unsaved contents of this buffer. |
| @ffi.Uint64() |
| int Length; |
| } |
| |
| /// Describes a version number of the form major.minor.subminor. |
| class CXVersion extends ffi.Struct { |
| /// The major version number, e.g., the '10' in '10.7.3'. A negative |
| /// value indicates that there is no version number at all. |
| @ffi.Int32() |
| int Major; |
| |
| /// The minor version number, e.g., the '7' in '10.7.3'. This value |
| /// will be negative if no minor version number was provided, e.g., for |
| /// version '10'. |
| @ffi.Int32() |
| int Minor; |
| |
| /// The subminor version number, e.g., the '3' in '10.7.3'. This value |
| /// will be negative if no minor or subminor version number was provided, |
| /// e.g., in version '10' or '10.7'. |
| @ffi.Int32() |
| int Subminor; |
| } |
| |
| /// A group of callbacks used by #clang_indexSourceFile and |
| /// #clang_indexTranslationUnit. |
| typedef _typedefC_3 = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<ffi.Void>, |
| ); |
| |
| typedef _typedefC_4 = ffi.Void Function( |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<ffi.Void>, |
| ); |
| |
| typedef _typedefC_5 = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<ffi.Void>, |
| ); |
| |
| typedef _typedefC_6 = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<CXIdxIncludedFileInfo>, |
| ); |
| |
| typedef _typedefC_7 = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<CXIdxImportedASTFileInfo>, |
| ); |
| |
| typedef _typedefC_8 = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<ffi.Void>, |
| ); |
| |
| typedef _typedefC_9 = ffi.Void Function( |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<CXIdxDeclInfo>, |
| ); |
| |
| typedef _typedefC_10 = ffi.Void Function( |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<CXIdxEntityRefInfo>, |
| ); |
| |
| class IndexerCallbacks extends ffi.Struct { |
| /// Called periodically to check whether indexing should be aborted. |
| /// Should return 0 to continue, and non-zero to abort. |
| ffi.Pointer<ffi.NativeFunction<_typedefC_3>> abortQuery; |
| |
| /// Called at the end of indexing; passes the complete diagnostic set. |
| ffi.Pointer<ffi.NativeFunction<_typedefC_4>> diagnostic; |
| |
| ffi.Pointer<ffi.NativeFunction<_typedefC_5>> enteredMainFile; |
| |
| /// Called when a file gets \#included/\#imported. |
| ffi.Pointer<ffi.NativeFunction<_typedefC_6>> ppIncludedFile; |
| |
| /// Called when a AST file (PCH or module) gets imported. |
| /// |
| /// AST files will not get indexed (there will not be callbacks to index all |
| /// the entities in an AST file). The recommended action is that, if the AST |
| /// file is not already indexed, to initiate a new indexing job specific to |
| /// the AST file. |
| ffi.Pointer<ffi.NativeFunction<_typedefC_7>> importedASTFile; |
| |
| /// Called at the beginning of indexing a translation unit. |
| ffi.Pointer<ffi.NativeFunction<_typedefC_8>> startedTranslationUnit; |
| |
| ffi.Pointer<ffi.NativeFunction<_typedefC_9>> indexDeclaration; |
| |
| /// Called to index a reference of an entity. |
| ffi.Pointer<ffi.NativeFunction<_typedefC_10>> indexEntityReference; |
| } |
| |
| /// Gets the general options associated with a CXIndex. |
| /// |
| /// \returns A bitmask of options, a bitwise OR of CXGlobalOpt_XXX flags that |
| /// are associated with the given CXIndex object. |
| int clang_CXIndex_getGlobalOptions( |
| ffi.Pointer<ffi.Void> arg0, |
| ) { |
| return _clang_CXIndex_getGlobalOptions( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_CXIndex_getGlobalOptions _clang_CXIndex_getGlobalOptions = |
| _dylib.lookupFunction<_c_clang_CXIndex_getGlobalOptions, |
| _dart_clang_CXIndex_getGlobalOptions>('clang_CXIndex_getGlobalOptions'); |
| |
| typedef _c_clang_CXIndex_getGlobalOptions = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| typedef _dart_clang_CXIndex_getGlobalOptions = int Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| /// Sets general options associated with a CXIndex. |
| /// |
| /// For example: |
| /// \code |
| /// CXIndex idx = ...; |
| /// clang_CXIndex_setGlobalOptions(idx, |
| /// clang_CXIndex_getGlobalOptions(idx) | |
| /// CXGlobalOpt_ThreadBackgroundPriorityForIndexing); |
| /// \endcode |
| /// |
| /// \param options A bitmask of options, a bitwise OR of CXGlobalOpt_XXX flags. |
| void clang_CXIndex_setGlobalOptions( |
| ffi.Pointer<ffi.Void> arg0, |
| int options, |
| ) { |
| return _clang_CXIndex_setGlobalOptions( |
| arg0, |
| options, |
| ); |
| } |
| |
| final _dart_clang_CXIndex_setGlobalOptions _clang_CXIndex_setGlobalOptions = |
| _dylib.lookupFunction<_c_clang_CXIndex_setGlobalOptions, |
| _dart_clang_CXIndex_setGlobalOptions>('clang_CXIndex_setGlobalOptions'); |
| |
| typedef _c_clang_CXIndex_setGlobalOptions = ffi.Void Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Uint32 options, |
| ); |
| |
| typedef _dart_clang_CXIndex_setGlobalOptions = void Function( |
| ffi.Pointer<ffi.Void> arg0, |
| int options, |
| ); |
| |
| /// Sets the invocation emission path option in a CXIndex. |
| /// |
| /// The invocation emission path specifies a path which will contain log |
| /// files for certain libclang invocations. A null value (default) implies that |
| /// libclang invocations are not logged.. |
| void clang_CXIndex_setInvocationEmissionPathOption( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Int8> Path, |
| ) { |
| return _clang_CXIndex_setInvocationEmissionPathOption( |
| arg0, |
| Path, |
| ); |
| } |
| |
| final _dart_clang_CXIndex_setInvocationEmissionPathOption |
| _clang_CXIndex_setInvocationEmissionPathOption = _dylib.lookupFunction< |
| _c_clang_CXIndex_setInvocationEmissionPathOption, |
| _dart_clang_CXIndex_setInvocationEmissionPathOption>( |
| 'clang_CXIndex_setInvocationEmissionPathOption'); |
| |
| typedef _c_clang_CXIndex_setInvocationEmissionPathOption = ffi.Void Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Int8> Path, |
| ); |
| |
| typedef _dart_clang_CXIndex_setInvocationEmissionPathOption = void Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Int8> Path, |
| ); |
| |
| ffi.Pointer<CXCursor> clang_Cursor_getArgument_wrap( |
| ffi.Pointer<CXCursor> cursor, |
| int i, |
| ) { |
| return _clang_Cursor_getArgument_wrap( |
| cursor, |
| i, |
| ); |
| } |
| |
| final _dart_clang_Cursor_getArgument_wrap _clang_Cursor_getArgument_wrap = |
| _dylib.lookupFunction<_c_clang_Cursor_getArgument_wrap, |
| _dart_clang_Cursor_getArgument_wrap>('clang_Cursor_getArgument_wrap'); |
| |
| typedef _c_clang_Cursor_getArgument_wrap = ffi.Pointer<CXCursor> Function( |
| ffi.Pointer<CXCursor> cursor, |
| ffi.Uint32 i, |
| ); |
| |
| typedef _dart_clang_Cursor_getArgument_wrap = ffi.Pointer<CXCursor> Function( |
| ffi.Pointer<CXCursor> cursor, |
| int i, |
| ); |
| |
| /// Returns the first paragraph of doxygen doc comment. |
| ffi.Pointer<CXString> clang_Cursor_getBriefCommentText_wrap( |
| ffi.Pointer<CXCursor> cursor, |
| ) { |
| return _clang_Cursor_getBriefCommentText_wrap( |
| cursor, |
| ); |
| } |
| |
| final _dart_clang_Cursor_getBriefCommentText_wrap |
| _clang_Cursor_getBriefCommentText_wrap = _dylib.lookupFunction< |
| _c_clang_Cursor_getBriefCommentText_wrap, |
| _dart_clang_Cursor_getBriefCommentText_wrap>( |
| 'clang_Cursor_getBriefCommentText_wrap'); |
| |
| typedef _c_clang_Cursor_getBriefCommentText_wrap = ffi.Pointer<CXString> |
| Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| typedef _dart_clang_Cursor_getBriefCommentText_wrap = ffi.Pointer<CXString> |
| Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| /// Returns the comment range. |
| ffi.Pointer<CXSourceRange> clang_Cursor_getCommentRange_wrap( |
| ffi.Pointer<CXCursor> cursor, |
| ) { |
| return _clang_Cursor_getCommentRange_wrap( |
| cursor, |
| ); |
| } |
| |
| final _dart_clang_Cursor_getCommentRange_wrap |
| _clang_Cursor_getCommentRange_wrap = _dylib.lookupFunction< |
| _c_clang_Cursor_getCommentRange_wrap, |
| _dart_clang_Cursor_getCommentRange_wrap>( |
| 'clang_Cursor_getCommentRange_wrap'); |
| |
| typedef _c_clang_Cursor_getCommentRange_wrap = ffi.Pointer<CXSourceRange> |
| Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| typedef _dart_clang_Cursor_getCommentRange_wrap = ffi.Pointer<CXSourceRange> |
| Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| int clang_Cursor_getNumArguments_wrap( |
| ffi.Pointer<CXCursor> cursor, |
| ) { |
| return _clang_Cursor_getNumArguments_wrap( |
| cursor, |
| ); |
| } |
| |
| final _dart_clang_Cursor_getNumArguments_wrap |
| _clang_Cursor_getNumArguments_wrap = _dylib.lookupFunction< |
| _c_clang_Cursor_getNumArguments_wrap, |
| _dart_clang_Cursor_getNumArguments_wrap>( |
| 'clang_Cursor_getNumArguments_wrap'); |
| |
| typedef _c_clang_Cursor_getNumArguments_wrap = ffi.Int32 Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| typedef _dart_clang_Cursor_getNumArguments_wrap = int Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| /// Returns the raw comment. |
| ffi.Pointer<CXString> clang_Cursor_getRawCommentText_wrap( |
| ffi.Pointer<CXCursor> cursor, |
| ) { |
| return _clang_Cursor_getRawCommentText_wrap( |
| cursor, |
| ); |
| } |
| |
| final _dart_clang_Cursor_getRawCommentText_wrap |
| _clang_Cursor_getRawCommentText_wrap = _dylib.lookupFunction< |
| _c_clang_Cursor_getRawCommentText_wrap, |
| _dart_clang_Cursor_getRawCommentText_wrap>( |
| 'clang_Cursor_getRawCommentText_wrap'); |
| |
| typedef _c_clang_Cursor_getRawCommentText_wrap = ffi.Pointer<CXString> Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| typedef _dart_clang_Cursor_getRawCommentText_wrap = ffi.Pointer<CXString> |
| Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| /// Disposes the created Eval memory. |
| void clang_EvalResult_dispose( |
| ffi.Pointer<ffi.Void> E, |
| ) { |
| return _clang_EvalResult_dispose( |
| E, |
| ); |
| } |
| |
| final _dart_clang_EvalResult_dispose _clang_EvalResult_dispose = |
| _dylib.lookupFunction<_c_clang_EvalResult_dispose, |
| _dart_clang_EvalResult_dispose>('clang_EvalResult_dispose'); |
| |
| typedef _c_clang_EvalResult_dispose = ffi.Void Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| typedef _dart_clang_EvalResult_dispose = void Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| /// Returns the evaluation result as double if the |
| /// kind is double. |
| double clang_EvalResult_getAsDouble( |
| ffi.Pointer<ffi.Void> E, |
| ) { |
| return _clang_EvalResult_getAsDouble( |
| E, |
| ); |
| } |
| |
| final _dart_clang_EvalResult_getAsDouble _clang_EvalResult_getAsDouble = |
| _dylib.lookupFunction<_c_clang_EvalResult_getAsDouble, |
| _dart_clang_EvalResult_getAsDouble>('clang_EvalResult_getAsDouble'); |
| |
| typedef _c_clang_EvalResult_getAsDouble = ffi.Double Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| typedef _dart_clang_EvalResult_getAsDouble = double Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| /// Returns the evaluation result as integer if the |
| /// kind is Int. |
| int clang_EvalResult_getAsInt( |
| ffi.Pointer<ffi.Void> E, |
| ) { |
| return _clang_EvalResult_getAsInt( |
| E, |
| ); |
| } |
| |
| final _dart_clang_EvalResult_getAsInt _clang_EvalResult_getAsInt = |
| _dylib.lookupFunction<_c_clang_EvalResult_getAsInt, |
| _dart_clang_EvalResult_getAsInt>('clang_EvalResult_getAsInt'); |
| |
| typedef _c_clang_EvalResult_getAsInt = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| typedef _dart_clang_EvalResult_getAsInt = int Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| /// Returns the evaluation result as a long long integer if the |
| /// kind is Int. This prevents overflows that may happen if the result is |
| /// returned with clang_EvalResult_getAsInt. |
| int clang_EvalResult_getAsLongLong( |
| ffi.Pointer<ffi.Void> E, |
| ) { |
| return _clang_EvalResult_getAsLongLong( |
| E, |
| ); |
| } |
| |
| final _dart_clang_EvalResult_getAsLongLong _clang_EvalResult_getAsLongLong = |
| _dylib.lookupFunction<_c_clang_EvalResult_getAsLongLong, |
| _dart_clang_EvalResult_getAsLongLong>('clang_EvalResult_getAsLongLong'); |
| |
| typedef _c_clang_EvalResult_getAsLongLong = ffi.Int64 Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| typedef _dart_clang_EvalResult_getAsLongLong = int Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| /// Returns the evaluation result as a constant string if the |
| /// kind is other than Int or float. User must not free this pointer, |
| /// instead call clang_EvalResult_dispose on the CXEvalResult returned |
| /// by clang_Cursor_Evaluate. |
| ffi.Pointer<ffi.Int8> clang_EvalResult_getAsStr( |
| ffi.Pointer<ffi.Void> E, |
| ) { |
| return _clang_EvalResult_getAsStr( |
| E, |
| ); |
| } |
| |
| final _dart_clang_EvalResult_getAsStr _clang_EvalResult_getAsStr = |
| _dylib.lookupFunction<_c_clang_EvalResult_getAsStr, |
| _dart_clang_EvalResult_getAsStr>('clang_EvalResult_getAsStr'); |
| |
| typedef _c_clang_EvalResult_getAsStr = ffi.Pointer<ffi.Int8> Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| typedef _dart_clang_EvalResult_getAsStr = ffi.Pointer<ffi.Int8> Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| /// Returns the evaluation result as an unsigned integer if |
| /// the kind is Int and clang_EvalResult_isUnsignedInt is non-zero. |
| int clang_EvalResult_getAsUnsigned( |
| ffi.Pointer<ffi.Void> E, |
| ) { |
| return _clang_EvalResult_getAsUnsigned( |
| E, |
| ); |
| } |
| |
| final _dart_clang_EvalResult_getAsUnsigned _clang_EvalResult_getAsUnsigned = |
| _dylib.lookupFunction<_c_clang_EvalResult_getAsUnsigned, |
| _dart_clang_EvalResult_getAsUnsigned>('clang_EvalResult_getAsUnsigned'); |
| |
| typedef _c_clang_EvalResult_getAsUnsigned = ffi.Uint64 Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| typedef _dart_clang_EvalResult_getAsUnsigned = int Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| /// Returns the kind of the evaluated result. |
| int clang_EvalResult_getKind( |
| ffi.Pointer<ffi.Void> E, |
| ) { |
| return _clang_EvalResult_getKind( |
| E, |
| ); |
| } |
| |
| final _dart_clang_EvalResult_getKind _clang_EvalResult_getKind = |
| _dylib.lookupFunction<_c_clang_EvalResult_getKind, |
| _dart_clang_EvalResult_getKind>('clang_EvalResult_getKind'); |
| |
| typedef _c_clang_EvalResult_getKind = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| typedef _dart_clang_EvalResult_getKind = int Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| /// Returns a non-zero value if the kind is Int and the evaluation |
| /// result resulted in an unsigned integer. |
| int clang_EvalResult_isUnsignedInt( |
| ffi.Pointer<ffi.Void> E, |
| ) { |
| return _clang_EvalResult_isUnsignedInt( |
| E, |
| ); |
| } |
| |
| final _dart_clang_EvalResult_isUnsignedInt _clang_EvalResult_isUnsignedInt = |
| _dylib.lookupFunction<_c_clang_EvalResult_isUnsignedInt, |
| _dart_clang_EvalResult_isUnsignedInt>('clang_EvalResult_isUnsignedInt'); |
| |
| typedef _c_clang_EvalResult_isUnsignedInt = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| typedef _dart_clang_EvalResult_isUnsignedInt = int Function( |
| ffi.Pointer<ffi.Void> E, |
| ); |
| |
| /// Returns non-zero if the \c file1 and \c file2 point to the same file, |
| /// or they are both NULL. |
| int clang_File_isEqual( |
| ffi.Pointer<ffi.Void> file1, |
| ffi.Pointer<ffi.Void> file2, |
| ) { |
| return _clang_File_isEqual( |
| file1, |
| file2, |
| ); |
| } |
| |
| final _dart_clang_File_isEqual _clang_File_isEqual = |
| _dylib.lookupFunction<_c_clang_File_isEqual, _dart_clang_File_isEqual>( |
| 'clang_File_isEqual'); |
| |
| typedef _c_clang_File_isEqual = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> file1, |
| ffi.Pointer<ffi.Void> file2, |
| ); |
| |
| typedef _dart_clang_File_isEqual = int Function( |
| ffi.Pointer<ffi.Void> file1, |
| ffi.Pointer<ffi.Void> file2, |
| ); |
| |
| /// An indexing action/session, to be applied to one or multiple |
| /// translation units. |
| /// |
| /// \param CIdx The index object with which the index action will be associated. |
| ffi.Pointer<ffi.Void> clang_IndexAction_create( |
| ffi.Pointer<ffi.Void> CIdx, |
| ) { |
| return _clang_IndexAction_create( |
| CIdx, |
| ); |
| } |
| |
| final _dart_clang_IndexAction_create _clang_IndexAction_create = |
| _dylib.lookupFunction<_c_clang_IndexAction_create, |
| _dart_clang_IndexAction_create>('clang_IndexAction_create'); |
| |
| typedef _c_clang_IndexAction_create = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ); |
| |
| typedef _dart_clang_IndexAction_create = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ); |
| |
| /// Destroy the given index action. |
| /// |
| /// The index action must not be destroyed until all of the translation units |
| /// created within that index action have been destroyed. |
| void clang_IndexAction_dispose( |
| ffi.Pointer<ffi.Void> arg0, |
| ) { |
| return _clang_IndexAction_dispose( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_IndexAction_dispose _clang_IndexAction_dispose = |
| _dylib.lookupFunction<_c_clang_IndexAction_dispose, |
| _dart_clang_IndexAction_dispose>('clang_IndexAction_dispose'); |
| |
| typedef _c_clang_IndexAction_dispose = ffi.Void Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| typedef _dart_clang_IndexAction_dispose = void Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| /// \param Module a module object. |
| /// |
| /// \returns the module file where the provided module object came from. |
| ffi.Pointer<ffi.Void> clang_Module_getASTFile( |
| ffi.Pointer<ffi.Void> Module, |
| ) { |
| return _clang_Module_getASTFile( |
| Module, |
| ); |
| } |
| |
| final _dart_clang_Module_getASTFile _clang_Module_getASTFile = _dylib |
| .lookupFunction<_c_clang_Module_getASTFile, _dart_clang_Module_getASTFile>( |
| 'clang_Module_getASTFile'); |
| |
| typedef _c_clang_Module_getASTFile = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void> Module, |
| ); |
| |
| typedef _dart_clang_Module_getASTFile = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void> Module, |
| ); |
| |
| /// \param Module a module object. |
| /// |
| /// \returns the number of top level headers associated with this module. |
| int clang_Module_getNumTopLevelHeaders( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ffi.Pointer<ffi.Void> Module, |
| ) { |
| return _clang_Module_getNumTopLevelHeaders( |
| arg0, |
| Module, |
| ); |
| } |
| |
| final _dart_clang_Module_getNumTopLevelHeaders |
| _clang_Module_getNumTopLevelHeaders = _dylib.lookupFunction< |
| _c_clang_Module_getNumTopLevelHeaders, |
| _dart_clang_Module_getNumTopLevelHeaders>( |
| 'clang_Module_getNumTopLevelHeaders'); |
| |
| typedef _c_clang_Module_getNumTopLevelHeaders = ffi.Uint32 Function( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ffi.Pointer<ffi.Void> Module, |
| ); |
| |
| typedef _dart_clang_Module_getNumTopLevelHeaders = int Function( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ffi.Pointer<ffi.Void> Module, |
| ); |
| |
| /// \param Module a module object. |
| /// |
| /// \returns the parent of a sub-module or NULL if the given module is top-level, |
| /// e.g. for 'std.vector' it will return the 'std' module. |
| ffi.Pointer<ffi.Void> clang_Module_getParent( |
| ffi.Pointer<ffi.Void> Module, |
| ) { |
| return _clang_Module_getParent( |
| Module, |
| ); |
| } |
| |
| final _dart_clang_Module_getParent _clang_Module_getParent = _dylib |
| .lookupFunction<_c_clang_Module_getParent, _dart_clang_Module_getParent>( |
| 'clang_Module_getParent'); |
| |
| typedef _c_clang_Module_getParent = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void> Module, |
| ); |
| |
| typedef _dart_clang_Module_getParent = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void> Module, |
| ); |
| |
| /// \param Module a module object. |
| /// |
| /// \param Index top level header index (zero-based). |
| /// |
| /// \returns the specified top level header associated with the module. |
| ffi.Pointer<ffi.Void> clang_Module_getTopLevelHeader( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ffi.Pointer<ffi.Void> Module, |
| int Index, |
| ) { |
| return _clang_Module_getTopLevelHeader( |
| arg0, |
| Module, |
| Index, |
| ); |
| } |
| |
| final _dart_clang_Module_getTopLevelHeader _clang_Module_getTopLevelHeader = |
| _dylib.lookupFunction<_c_clang_Module_getTopLevelHeader, |
| _dart_clang_Module_getTopLevelHeader>('clang_Module_getTopLevelHeader'); |
| |
| typedef _c_clang_Module_getTopLevelHeader = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ffi.Pointer<ffi.Void> Module, |
| ffi.Uint32 Index, |
| ); |
| |
| typedef _dart_clang_Module_getTopLevelHeader = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ffi.Pointer<ffi.Void> Module, |
| int Index, |
| ); |
| |
| /// \param Module a module object. |
| /// |
| /// \returns non-zero if the module is a system one. |
| int clang_Module_isSystem( |
| ffi.Pointer<ffi.Void> Module, |
| ) { |
| return _clang_Module_isSystem( |
| Module, |
| ); |
| } |
| |
| final _dart_clang_Module_isSystem _clang_Module_isSystem = _dylib |
| .lookupFunction<_c_clang_Module_isSystem, _dart_clang_Module_isSystem>( |
| 'clang_Module_isSystem'); |
| |
| typedef _c_clang_Module_isSystem = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> Module, |
| ); |
| |
| typedef _dart_clang_Module_isSystem = int Function( |
| ffi.Pointer<ffi.Void> Module, |
| ); |
| |
| /// Release a printing policy. |
| void clang_PrintingPolicy_dispose( |
| ffi.Pointer<ffi.Void> Policy, |
| ) { |
| return _clang_PrintingPolicy_dispose( |
| Policy, |
| ); |
| } |
| |
| final _dart_clang_PrintingPolicy_dispose _clang_PrintingPolicy_dispose = |
| _dylib.lookupFunction<_c_clang_PrintingPolicy_dispose, |
| _dart_clang_PrintingPolicy_dispose>('clang_PrintingPolicy_dispose'); |
| |
| typedef _c_clang_PrintingPolicy_dispose = ffi.Void Function( |
| ffi.Pointer<ffi.Void> Policy, |
| ); |
| |
| typedef _dart_clang_PrintingPolicy_dispose = void Function( |
| ffi.Pointer<ffi.Void> Policy, |
| ); |
| |
| /// Get a property value for the given printing policy. |
| int clang_PrintingPolicy_getProperty( |
| ffi.Pointer<ffi.Void> Policy, |
| int Property, |
| ) { |
| return _clang_PrintingPolicy_getProperty( |
| Policy, |
| Property, |
| ); |
| } |
| |
| final _dart_clang_PrintingPolicy_getProperty _clang_PrintingPolicy_getProperty = |
| _dylib.lookupFunction<_c_clang_PrintingPolicy_getProperty, |
| _dart_clang_PrintingPolicy_getProperty>( |
| 'clang_PrintingPolicy_getProperty'); |
| |
| typedef _c_clang_PrintingPolicy_getProperty = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> Policy, |
| ffi.Int32 Property, |
| ); |
| |
| typedef _dart_clang_PrintingPolicy_getProperty = int Function( |
| ffi.Pointer<ffi.Void> Policy, |
| int Property, |
| ); |
| |
| /// Set a property value for the given printing policy. |
| void clang_PrintingPolicy_setProperty( |
| ffi.Pointer<ffi.Void> Policy, |
| int Property, |
| int Value, |
| ) { |
| return _clang_PrintingPolicy_setProperty( |
| Policy, |
| Property, |
| Value, |
| ); |
| } |
| |
| final _dart_clang_PrintingPolicy_setProperty _clang_PrintingPolicy_setProperty = |
| _dylib.lookupFunction<_c_clang_PrintingPolicy_setProperty, |
| _dart_clang_PrintingPolicy_setProperty>( |
| 'clang_PrintingPolicy_setProperty'); |
| |
| typedef _c_clang_PrintingPolicy_setProperty = ffi.Void Function( |
| ffi.Pointer<ffi.Void> Policy, |
| ffi.Int32 Property, |
| ffi.Uint32 Value, |
| ); |
| |
| typedef _dart_clang_PrintingPolicy_setProperty = void Function( |
| ffi.Pointer<ffi.Void> Policy, |
| int Property, |
| int Value, |
| ); |
| |
| /// Destroy the CXTargetInfo object. |
| void clang_TargetInfo_dispose( |
| ffi.Pointer<CXTargetInfoImpl> Info, |
| ) { |
| return _clang_TargetInfo_dispose( |
| Info, |
| ); |
| } |
| |
| final _dart_clang_TargetInfo_dispose _clang_TargetInfo_dispose = |
| _dylib.lookupFunction<_c_clang_TargetInfo_dispose, |
| _dart_clang_TargetInfo_dispose>('clang_TargetInfo_dispose'); |
| |
| typedef _c_clang_TargetInfo_dispose = ffi.Void Function( |
| ffi.Pointer<CXTargetInfoImpl> Info, |
| ); |
| |
| typedef _dart_clang_TargetInfo_dispose = void Function( |
| ffi.Pointer<CXTargetInfoImpl> Info, |
| ); |
| |
| /// Get the pointer width of the target in bits. |
| /// |
| /// Returns -1 in case of error. |
| int clang_TargetInfo_getPointerWidth( |
| ffi.Pointer<CXTargetInfoImpl> Info, |
| ) { |
| return _clang_TargetInfo_getPointerWidth( |
| Info, |
| ); |
| } |
| |
| final _dart_clang_TargetInfo_getPointerWidth _clang_TargetInfo_getPointerWidth = |
| _dylib.lookupFunction<_c_clang_TargetInfo_getPointerWidth, |
| _dart_clang_TargetInfo_getPointerWidth>( |
| 'clang_TargetInfo_getPointerWidth'); |
| |
| typedef _c_clang_TargetInfo_getPointerWidth = ffi.Int32 Function( |
| ffi.Pointer<CXTargetInfoImpl> Info, |
| ); |
| |
| typedef _dart_clang_TargetInfo_getPointerWidth = int Function( |
| ffi.Pointer<CXTargetInfoImpl> Info, |
| ); |
| |
| ffi.Pointer<CXType> clang_Type_getNamedType_wrap( |
| ffi.Pointer<CXType> elaboratedType, |
| ) { |
| return _clang_Type_getNamedType_wrap( |
| elaboratedType, |
| ); |
| } |
| |
| final _dart_clang_Type_getNamedType_wrap _clang_Type_getNamedType_wrap = |
| _dylib.lookupFunction<_c_clang_Type_getNamedType_wrap, |
| _dart_clang_Type_getNamedType_wrap>('clang_Type_getNamedType_wrap'); |
| |
| typedef _c_clang_Type_getNamedType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> elaboratedType, |
| ); |
| |
| typedef _dart_clang_Type_getNamedType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> elaboratedType, |
| ); |
| |
| /// Annotate the given set of tokens by providing cursors for each token |
| /// that can be mapped to a specific entity within the abstract syntax tree. |
| /// |
| /// This token-annotation routine is equivalent to invoking |
| /// clang_getCursor() for the source locations of each of the |
| /// tokens. The cursors provided are filtered, so that only those |
| /// cursors that have a direct correspondence to the token are |
| /// accepted. For example, given a function call \c f(x), |
| /// clang_getCursor() would provide the following cursors: |
| /// |
| /// * when the cursor is over the 'f', a DeclRefExpr cursor referring to 'f'. |
| /// * when the cursor is over the '(' or the ')', a CallExpr referring to 'f'. |
| /// * when the cursor is over the 'x', a DeclRefExpr cursor referring to 'x'. |
| /// |
| /// Only the first and last of these cursors will occur within the |
| /// annotate, since the tokens "f" and "x' directly refer to a function |
| /// and a variable, respectively, but the parentheses are just a small |
| /// part of the full syntax of the function call expression, which is |
| /// not provided as an annotation. |
| /// |
| /// \param TU the translation unit that owns the given tokens. |
| /// |
| /// \param Tokens the set of tokens to annotate. |
| /// |
| /// \param NumTokens the number of tokens in \p Tokens. |
| /// |
| /// \param Cursors an array of \p NumTokens cursors, whose contents will be |
| /// replaced with the cursors corresponding to each token. |
| void clang_annotateTokens( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<CXToken> Tokens, |
| int NumTokens, |
| ffi.Pointer<CXCursor> Cursors, |
| ) { |
| return _clang_annotateTokens( |
| TU, |
| Tokens, |
| NumTokens, |
| Cursors, |
| ); |
| } |
| |
| final _dart_clang_annotateTokens _clang_annotateTokens = |
| _dylib.lookupFunction<_c_clang_annotateTokens, _dart_clang_annotateTokens>( |
| 'clang_annotateTokens'); |
| |
| typedef _c_clang_annotateTokens = ffi.Void Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<CXToken> Tokens, |
| ffi.Uint32 NumTokens, |
| ffi.Pointer<CXCursor> Cursors, |
| ); |
| |
| typedef _dart_clang_annotateTokens = void Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<CXToken> Tokens, |
| int NumTokens, |
| ffi.Pointer<CXCursor> Cursors, |
| ); |
| |
| /// Perform code completion at a given location in a translation unit. |
| /// |
| /// This function performs code completion at a particular file, line, and |
| /// column within source code, providing results that suggest potential |
| /// code snippets based on the context of the completion. The basic model |
| /// for code completion is that Clang will parse a complete source file, |
| /// performing syntax checking up to the location where code-completion has |
| /// been requested. At that point, a special code-completion token is passed |
| /// to the parser, which recognizes this token and determines, based on the |
| /// current location in the C/Objective-C/C++ grammar and the state of |
| /// semantic analysis, what completions to provide. These completions are |
| /// returned via a new \c CXCodeCompleteResults structure. |
| /// |
| /// Code completion itself is meant to be triggered by the client when the |
| /// user types punctuation characters or whitespace, at which point the |
| /// code-completion location will coincide with the cursor. For example, if \c p |
| /// is a pointer, code-completion might be triggered after the "-" and then |
| /// after the ">" in \c p->. When the code-completion location is after the ">", |
| /// the completion results will provide, e.g., the members of the struct that |
| /// "p" points to. The client is responsible for placing the cursor at the |
| /// beginning of the token currently being typed, then filtering the results |
| /// based on the contents of the token. For example, when code-completing for |
| /// the expression \c p->get, the client should provide the location just after |
| /// the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the |
| /// client can filter the results based on the current token text ("get"), only |
| /// showing those results that start with "get". The intent of this interface |
| /// is to separate the relatively high-latency acquisition of code-completion |
| /// results from the filtering of results on a per-character basis, which must |
| /// have a lower latency. |
| /// |
| /// \param TU The translation unit in which code-completion should |
| /// occur. The source files for this translation unit need not be |
| /// completely up-to-date (and the contents of those source files may |
| /// be overridden via \p unsaved_files). Cursors referring into the |
| /// translation unit may be invalidated by this invocation. |
| /// |
| /// \param complete_filename The name of the source file where code |
| /// completion should be performed. This filename may be any file |
| /// included in the translation unit. |
| /// |
| /// \param complete_line The line at which code-completion should occur. |
| /// |
| /// \param complete_column The column at which code-completion should occur. |
| /// Note that the column should point just after the syntactic construct that |
| /// initiated code completion, and not in the middle of a lexical token. |
| /// |
| /// \param unsaved_files the Files that have not yet been saved to disk |
| /// but may be required for parsing or code completion, including the |
| /// contents of those files. The contents and name of these files (as |
| /// specified by CXUnsavedFile) are copied when necessary, so the |
| /// client only needs to guarantee their validity until the call to |
| /// this function returns. |
| /// |
| /// \param num_unsaved_files The number of unsaved file entries in \p |
| /// unsaved_files. |
| /// |
| /// \param options Extra options that control the behavior of code |
| /// completion, expressed as a bitwise OR of the enumerators of the |
| /// CXCodeComplete_Flags enumeration. The |
| /// \c clang_defaultCodeCompleteOptions() function returns a default set |
| /// of code-completion options. |
| /// |
| /// \returns If successful, a new \c CXCodeCompleteResults structure |
| /// containing code-completion results, which should eventually be |
| /// freed with \c clang_disposeCodeCompleteResults(). If code |
| /// completion fails, returns NULL. |
| ffi.Pointer<CXCodeCompleteResults> clang_codeCompleteAt( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<ffi.Int8> complete_filename, |
| int complete_line, |
| int complete_column, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| int options, |
| ) { |
| return _clang_codeCompleteAt( |
| TU, |
| complete_filename, |
| complete_line, |
| complete_column, |
| unsaved_files, |
| num_unsaved_files, |
| options, |
| ); |
| } |
| |
| final _dart_clang_codeCompleteAt _clang_codeCompleteAt = |
| _dylib.lookupFunction<_c_clang_codeCompleteAt, _dart_clang_codeCompleteAt>( |
| 'clang_codeCompleteAt'); |
| |
| typedef _c_clang_codeCompleteAt = ffi.Pointer<CXCodeCompleteResults> Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<ffi.Int8> complete_filename, |
| ffi.Uint32 complete_line, |
| ffi.Uint32 complete_column, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| ffi.Uint32 num_unsaved_files, |
| ffi.Uint32 options, |
| ); |
| |
| typedef _dart_clang_codeCompleteAt = ffi.Pointer<CXCodeCompleteResults> |
| Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<ffi.Int8> complete_filename, |
| int complete_line, |
| int complete_column, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| int options, |
| ); |
| |
| /// Returns the cursor kind for the container for the current code |
| /// completion context. The container is only guaranteed to be set for |
| /// contexts where a container exists (i.e. member accesses or Objective-C |
| /// message sends); if there is not a container, this function will return |
| /// CXCursor_InvalidCode. |
| /// |
| /// \param Results the code completion results to query |
| /// |
| /// \param IsIncomplete on return, this value will be false if Clang has complete |
| /// information about the container. If Clang does not have complete |
| /// information, this value will be true. |
| /// |
| /// \returns the container kind, or CXCursor_InvalidCode if there is not a |
| /// container |
| int clang_codeCompleteGetContainerKind( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ffi.Pointer<ffi.Uint32> IsIncomplete, |
| ) { |
| return _clang_codeCompleteGetContainerKind( |
| Results, |
| IsIncomplete, |
| ); |
| } |
| |
| final _dart_clang_codeCompleteGetContainerKind |
| _clang_codeCompleteGetContainerKind = _dylib.lookupFunction< |
| _c_clang_codeCompleteGetContainerKind, |
| _dart_clang_codeCompleteGetContainerKind>( |
| 'clang_codeCompleteGetContainerKind'); |
| |
| typedef _c_clang_codeCompleteGetContainerKind = ffi.Int32 Function( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ffi.Pointer<ffi.Uint32> IsIncomplete, |
| ); |
| |
| typedef _dart_clang_codeCompleteGetContainerKind = int Function( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ffi.Pointer<ffi.Uint32> IsIncomplete, |
| ); |
| |
| /// Determines what completions are appropriate for the context |
| /// the given code completion. |
| /// |
| /// \param Results the code completion results to query |
| /// |
| /// \returns the kinds of completions that are appropriate for use |
| /// along with the given code completion results. |
| int clang_codeCompleteGetContexts( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ) { |
| return _clang_codeCompleteGetContexts( |
| Results, |
| ); |
| } |
| |
| final _dart_clang_codeCompleteGetContexts _clang_codeCompleteGetContexts = |
| _dylib.lookupFunction<_c_clang_codeCompleteGetContexts, |
| _dart_clang_codeCompleteGetContexts>('clang_codeCompleteGetContexts'); |
| |
| typedef _c_clang_codeCompleteGetContexts = ffi.Uint64 Function( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ); |
| |
| typedef _dart_clang_codeCompleteGetContexts = int Function( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ); |
| |
| /// Retrieve a diagnostic associated with the given code completion. |
| /// |
| /// \param Results the code completion results to query. |
| /// \param Index the zero-based diagnostic number to retrieve. |
| /// |
| /// \returns the requested diagnostic. This diagnostic must be freed |
| /// via a call to \c clang_disposeDiagnostic(). |
| ffi.Pointer<ffi.Void> clang_codeCompleteGetDiagnostic( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| int Index, |
| ) { |
| return _clang_codeCompleteGetDiagnostic( |
| Results, |
| Index, |
| ); |
| } |
| |
| final _dart_clang_codeCompleteGetDiagnostic _clang_codeCompleteGetDiagnostic = |
| _dylib.lookupFunction<_c_clang_codeCompleteGetDiagnostic, |
| _dart_clang_codeCompleteGetDiagnostic>( |
| 'clang_codeCompleteGetDiagnostic'); |
| |
| typedef _c_clang_codeCompleteGetDiagnostic = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ffi.Uint32 Index, |
| ); |
| |
| typedef _dart_clang_codeCompleteGetDiagnostic = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| int Index, |
| ); |
| |
| /// Determine the number of diagnostics produced prior to the |
| /// location where code completion was performed. |
| int clang_codeCompleteGetNumDiagnostics( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ) { |
| return _clang_codeCompleteGetNumDiagnostics( |
| Results, |
| ); |
| } |
| |
| final _dart_clang_codeCompleteGetNumDiagnostics |
| _clang_codeCompleteGetNumDiagnostics = _dylib.lookupFunction< |
| _c_clang_codeCompleteGetNumDiagnostics, |
| _dart_clang_codeCompleteGetNumDiagnostics>( |
| 'clang_codeCompleteGetNumDiagnostics'); |
| |
| typedef _c_clang_codeCompleteGetNumDiagnostics = ffi.Uint32 Function( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ); |
| |
| typedef _dart_clang_codeCompleteGetNumDiagnostics = int Function( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ); |
| |
| /// Creates an empty CXCursorSet. |
| ffi.Pointer<CXCursorSetImpl> clang_createCXCursorSet() { |
| return _clang_createCXCursorSet(); |
| } |
| |
| final _dart_clang_createCXCursorSet _clang_createCXCursorSet = _dylib |
| .lookupFunction<_c_clang_createCXCursorSet, _dart_clang_createCXCursorSet>( |
| 'clang_createCXCursorSet'); |
| |
| typedef _c_clang_createCXCursorSet = ffi.Pointer<CXCursorSetImpl> Function(); |
| |
| typedef _dart_clang_createCXCursorSet = ffi.Pointer<CXCursorSetImpl> Function(); |
| |
| /// Provides a shared context for creating translation units. |
| /// |
| /// It provides two options: |
| /// |
| /// - excludeDeclarationsFromPCH: When non-zero, allows enumeration of "local" |
| /// declarations (when loading any new translation units). A "local" declaration |
| /// is one that belongs in the translation unit itself and not in a precompiled |
| /// header that was used by the translation unit. If zero, all declarations |
| /// will be enumerated. |
| /// |
| /// Here is an example: |
| /// |
| /// \code |
| /// // excludeDeclsFromPCH = 1, displayDiagnostics=1 |
| /// Idx = clang_createIndex(1, 1); |
| /// |
| /// // IndexTest.pch was produced with the following command: |
| /// // "clang -x c IndexTest.h -emit-ast -o IndexTest.pch" |
| /// TU = clang_createTranslationUnit(Idx, "IndexTest.pch"); |
| /// |
| /// // This will load all the symbols from 'IndexTest.pch' |
| /// clang_visitChildren(clang_getTranslationUnitCursor(TU), |
| /// TranslationUnitVisitor, 0); |
| /// clang_disposeTranslationUnit(TU); |
| /// |
| /// // This will load all the symbols from 'IndexTest.c', excluding symbols |
| /// // from 'IndexTest.pch'. |
| /// char *args[] = { "-Xclang", "-include-pch=IndexTest.pch" }; |
| /// TU = clang_createTranslationUnitFromSourceFile(Idx, "IndexTest.c", 2, args, |
| /// 0, 0); |
| /// clang_visitChildren(clang_getTranslationUnitCursor(TU), |
| /// TranslationUnitVisitor, 0); |
| /// clang_disposeTranslationUnit(TU); |
| /// \endcode |
| /// |
| /// This process of creating the 'pch', loading it separately, and using it (via |
| /// -include-pch) allows 'excludeDeclsFromPCH' to remove redundant callbacks |
| /// (which gives the indexer the same performance benefit as the compiler). |
| ffi.Pointer<ffi.Void> clang_createIndex( |
| int excludeDeclarationsFromPCH, |
| int displayDiagnostics, |
| ) { |
| return _clang_createIndex( |
| excludeDeclarationsFromPCH, |
| displayDiagnostics, |
| ); |
| } |
| |
| final _dart_clang_createIndex _clang_createIndex = |
| _dylib.lookupFunction<_c_clang_createIndex, _dart_clang_createIndex>( |
| 'clang_createIndex'); |
| |
| typedef _c_clang_createIndex = ffi.Pointer<ffi.Void> Function( |
| ffi.Int32 excludeDeclarationsFromPCH, |
| ffi.Int32 displayDiagnostics, |
| ); |
| |
| typedef _dart_clang_createIndex = ffi.Pointer<ffi.Void> Function( |
| int excludeDeclarationsFromPCH, |
| int displayDiagnostics, |
| ); |
| |
| /// Same as \c clang_createTranslationUnit2, but returns |
| /// the \c CXTranslationUnit instead of an error code. In case of an error this |
| /// routine returns a \c NULL \c CXTranslationUnit, without further detailed |
| /// error codes. |
| ffi.Pointer<CXTranslationUnitImpl> clang_createTranslationUnit( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> ast_filename, |
| ) { |
| return _clang_createTranslationUnit( |
| CIdx, |
| ast_filename, |
| ); |
| } |
| |
| final _dart_clang_createTranslationUnit _clang_createTranslationUnit = |
| _dylib.lookupFunction<_c_clang_createTranslationUnit, |
| _dart_clang_createTranslationUnit>('clang_createTranslationUnit'); |
| |
| typedef _c_clang_createTranslationUnit = ffi.Pointer<CXTranslationUnitImpl> |
| Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> ast_filename, |
| ); |
| |
| typedef _dart_clang_createTranslationUnit = ffi.Pointer<CXTranslationUnitImpl> |
| Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> ast_filename, |
| ); |
| |
| /// Create a translation unit from an AST file (\c -emit-ast). |
| /// |
| /// \param[out] out_TU A non-NULL pointer to store the created |
| /// \c CXTranslationUnit. |
| /// |
| /// \returns Zero on success, otherwise returns an error code. |
| int clang_createTranslationUnit2( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> ast_filename, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ) { |
| return _clang_createTranslationUnit2( |
| CIdx, |
| ast_filename, |
| out_TU, |
| ); |
| } |
| |
| final _dart_clang_createTranslationUnit2 _clang_createTranslationUnit2 = |
| _dylib.lookupFunction<_c_clang_createTranslationUnit2, |
| _dart_clang_createTranslationUnit2>('clang_createTranslationUnit2'); |
| |
| typedef _c_clang_createTranslationUnit2 = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> ast_filename, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ); |
| |
| typedef _dart_clang_createTranslationUnit2 = int Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> ast_filename, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ); |
| |
| /// Return the CXTranslationUnit for a given source file and the provided |
| /// command line arguments one would pass to the compiler. |
| /// |
| /// Note: The 'source_filename' argument is optional. If the caller provides a |
| /// NULL pointer, the name of the source file is expected to reside in the |
| /// specified command line arguments. |
| /// |
| /// Note: When encountered in 'clang_command_line_args', the following options |
| /// are ignored: |
| /// |
| /// '-c' |
| /// '-emit-ast' |
| /// '-fsyntax-only' |
| /// '-o \<output file>' (both '-o' and '\<output file>' are ignored) |
| /// |
| /// \param CIdx The index object with which the translation unit will be |
| /// associated. |
| /// |
| /// \param source_filename The name of the source file to load, or NULL if the |
| /// source file is included in \p clang_command_line_args. |
| /// |
| /// \param num_clang_command_line_args The number of command-line arguments in |
| /// \p clang_command_line_args. |
| /// |
| /// \param clang_command_line_args The command-line arguments that would be |
| /// passed to the \c clang executable if it were being invoked out-of-process. |
| /// These command-line options will be parsed and will affect how the translation |
| /// unit is parsed. Note that the following options are ignored: '-c', |
| /// '-emit-ast', '-fsyntax-only' (which is the default), and '-o \<output file>'. |
| /// |
| /// \param num_unsaved_files the number of unsaved file entries in \p |
| /// unsaved_files. |
| /// |
| /// \param unsaved_files the files that have not yet been saved to disk |
| /// but may be required for code completion, including the contents of |
| /// those files. The contents and name of these files (as specified by |
| /// CXUnsavedFile) are copied when necessary, so the client only needs to |
| /// guarantee their validity until the call to this function returns. |
| ffi.Pointer<CXTranslationUnitImpl> clang_createTranslationUnitFromSourceFile( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| int num_clang_command_line_args, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> clang_command_line_args, |
| int num_unsaved_files, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| ) { |
| return _clang_createTranslationUnitFromSourceFile( |
| CIdx, |
| source_filename, |
| num_clang_command_line_args, |
| clang_command_line_args, |
| num_unsaved_files, |
| unsaved_files, |
| ); |
| } |
| |
| final _dart_clang_createTranslationUnitFromSourceFile |
| _clang_createTranslationUnitFromSourceFile = _dylib.lookupFunction< |
| _c_clang_createTranslationUnitFromSourceFile, |
| _dart_clang_createTranslationUnitFromSourceFile>( |
| 'clang_createTranslationUnitFromSourceFile'); |
| |
| typedef _c_clang_createTranslationUnitFromSourceFile |
| = ffi.Pointer<CXTranslationUnitImpl> Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Int32 num_clang_command_line_args, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> clang_command_line_args, |
| ffi.Uint32 num_unsaved_files, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| ); |
| |
| typedef _dart_clang_createTranslationUnitFromSourceFile |
| = ffi.Pointer<CXTranslationUnitImpl> Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| int num_clang_command_line_args, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> clang_command_line_args, |
| int num_unsaved_files, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| ); |
| |
| /// Returns a default set of code-completion options that can be |
| /// passed to\c clang_codeCompleteAt(). |
| int clang_defaultCodeCompleteOptions() { |
| return _clang_defaultCodeCompleteOptions(); |
| } |
| |
| final _dart_clang_defaultCodeCompleteOptions _clang_defaultCodeCompleteOptions = |
| _dylib.lookupFunction<_c_clang_defaultCodeCompleteOptions, |
| _dart_clang_defaultCodeCompleteOptions>( |
| 'clang_defaultCodeCompleteOptions'); |
| |
| typedef _c_clang_defaultCodeCompleteOptions = ffi.Uint32 Function(); |
| |
| typedef _dart_clang_defaultCodeCompleteOptions = int Function(); |
| |
| /// Retrieve the set of display options most similar to the |
| /// default behavior of the clang compiler. |
| /// |
| /// \returns A set of display options suitable for use with \c |
| /// clang_formatDiagnostic(). |
| int clang_defaultDiagnosticDisplayOptions() { |
| return _clang_defaultDiagnosticDisplayOptions(); |
| } |
| |
| final _dart_clang_defaultDiagnosticDisplayOptions |
| _clang_defaultDiagnosticDisplayOptions = _dylib.lookupFunction< |
| _c_clang_defaultDiagnosticDisplayOptions, |
| _dart_clang_defaultDiagnosticDisplayOptions>( |
| 'clang_defaultDiagnosticDisplayOptions'); |
| |
| typedef _c_clang_defaultDiagnosticDisplayOptions = ffi.Uint32 Function(); |
| |
| typedef _dart_clang_defaultDiagnosticDisplayOptions = int Function(); |
| |
| /// Returns the set of flags that is suitable for parsing a translation |
| /// unit that is being edited. |
| /// |
| /// The set of flags returned provide options for \c clang_parseTranslationUnit() |
| /// to indicate that the translation unit is likely to be reparsed many times, |
| /// either explicitly (via \c clang_reparseTranslationUnit()) or implicitly |
| /// (e.g., by code completion (\c clang_codeCompletionAt())). The returned flag |
| /// set contains an unspecified set of optimizations (e.g., the precompiled |
| /// preamble) geared toward improving the performance of these routines. The |
| /// set of optimizations enabled may change from one version to the next. |
| int clang_defaultEditingTranslationUnitOptions() { |
| return _clang_defaultEditingTranslationUnitOptions(); |
| } |
| |
| final _dart_clang_defaultEditingTranslationUnitOptions |
| _clang_defaultEditingTranslationUnitOptions = _dylib.lookupFunction< |
| _c_clang_defaultEditingTranslationUnitOptions, |
| _dart_clang_defaultEditingTranslationUnitOptions>( |
| 'clang_defaultEditingTranslationUnitOptions'); |
| |
| typedef _c_clang_defaultEditingTranslationUnitOptions = ffi.Uint32 Function(); |
| |
| typedef _dart_clang_defaultEditingTranslationUnitOptions = int Function(); |
| |
| /// Returns the set of flags that is suitable for reparsing a translation |
| /// unit. |
| /// |
| /// The set of flags returned provide options for |
| /// \c clang_reparseTranslationUnit() by default. The returned flag |
| /// set contains an unspecified set of optimizations geared toward common uses |
| /// of reparsing. The set of optimizations enabled may change from one version |
| /// to the next. |
| int clang_defaultReparseOptions( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ) { |
| return _clang_defaultReparseOptions( |
| TU, |
| ); |
| } |
| |
| final _dart_clang_defaultReparseOptions _clang_defaultReparseOptions = |
| _dylib.lookupFunction<_c_clang_defaultReparseOptions, |
| _dart_clang_defaultReparseOptions>('clang_defaultReparseOptions'); |
| |
| typedef _c_clang_defaultReparseOptions = ffi.Uint32 Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ); |
| |
| typedef _dart_clang_defaultReparseOptions = int Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ); |
| |
| /// Returns the set of flags that is suitable for saving a translation |
| /// unit. |
| /// |
| /// The set of flags returned provide options for |
| /// \c clang_saveTranslationUnit() by default. The returned flag |
| /// set contains an unspecified set of options that save translation units with |
| /// the most commonly-requested data. |
| int clang_defaultSaveOptions( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ) { |
| return _clang_defaultSaveOptions( |
| TU, |
| ); |
| } |
| |
| final _dart_clang_defaultSaveOptions _clang_defaultSaveOptions = |
| _dylib.lookupFunction<_c_clang_defaultSaveOptions, |
| _dart_clang_defaultSaveOptions>('clang_defaultSaveOptions'); |
| |
| typedef _c_clang_defaultSaveOptions = ffi.Uint32 Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ); |
| |
| typedef _dart_clang_defaultSaveOptions = int Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ); |
| |
| /// Disposes a CXCursorSet and releases its associated memory. |
| void clang_disposeCXCursorSet( |
| ffi.Pointer<CXCursorSetImpl> cset, |
| ) { |
| return _clang_disposeCXCursorSet( |
| cset, |
| ); |
| } |
| |
| final _dart_clang_disposeCXCursorSet _clang_disposeCXCursorSet = |
| _dylib.lookupFunction<_c_clang_disposeCXCursorSet, |
| _dart_clang_disposeCXCursorSet>('clang_disposeCXCursorSet'); |
| |
| typedef _c_clang_disposeCXCursorSet = ffi.Void Function( |
| ffi.Pointer<CXCursorSetImpl> cset, |
| ); |
| |
| typedef _dart_clang_disposeCXCursorSet = void Function( |
| ffi.Pointer<CXCursorSetImpl> cset, |
| ); |
| |
| /// Free the memory associated with a \c CXPlatformAvailability structure. |
| void clang_disposeCXPlatformAvailability( |
| ffi.Pointer<CXPlatformAvailability> availability, |
| ) { |
| return _clang_disposeCXPlatformAvailability( |
| availability, |
| ); |
| } |
| |
| final _dart_clang_disposeCXPlatformAvailability |
| _clang_disposeCXPlatformAvailability = _dylib.lookupFunction< |
| _c_clang_disposeCXPlatformAvailability, |
| _dart_clang_disposeCXPlatformAvailability>( |
| 'clang_disposeCXPlatformAvailability'); |
| |
| typedef _c_clang_disposeCXPlatformAvailability = ffi.Void Function( |
| ffi.Pointer<CXPlatformAvailability> availability, |
| ); |
| |
| typedef _dart_clang_disposeCXPlatformAvailability = void Function( |
| ffi.Pointer<CXPlatformAvailability> availability, |
| ); |
| |
| /// Free the given set of code-completion results. |
| void clang_disposeCodeCompleteResults( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ) { |
| return _clang_disposeCodeCompleteResults( |
| Results, |
| ); |
| } |
| |
| final _dart_clang_disposeCodeCompleteResults _clang_disposeCodeCompleteResults = |
| _dylib.lookupFunction<_c_clang_disposeCodeCompleteResults, |
| _dart_clang_disposeCodeCompleteResults>( |
| 'clang_disposeCodeCompleteResults'); |
| |
| typedef _c_clang_disposeCodeCompleteResults = ffi.Void Function( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ); |
| |
| typedef _dart_clang_disposeCodeCompleteResults = void Function( |
| ffi.Pointer<CXCodeCompleteResults> Results, |
| ); |
| |
| /// Destroy a diagnostic. |
| void clang_disposeDiagnostic( |
| ffi.Pointer<ffi.Void> Diagnostic, |
| ) { |
| return _clang_disposeDiagnostic( |
| Diagnostic, |
| ); |
| } |
| |
| final _dart_clang_disposeDiagnostic _clang_disposeDiagnostic = _dylib |
| .lookupFunction<_c_clang_disposeDiagnostic, _dart_clang_disposeDiagnostic>( |
| 'clang_disposeDiagnostic'); |
| |
| typedef _c_clang_disposeDiagnostic = ffi.Void Function( |
| ffi.Pointer<ffi.Void> Diagnostic, |
| ); |
| |
| typedef _dart_clang_disposeDiagnostic = void Function( |
| ffi.Pointer<ffi.Void> Diagnostic, |
| ); |
| |
| /// Release a CXDiagnosticSet and all of its contained diagnostics. |
| void clang_disposeDiagnosticSet( |
| ffi.Pointer<ffi.Void> Diags, |
| ) { |
| return _clang_disposeDiagnosticSet( |
| Diags, |
| ); |
| } |
| |
| final _dart_clang_disposeDiagnosticSet _clang_disposeDiagnosticSet = |
| _dylib.lookupFunction<_c_clang_disposeDiagnosticSet, |
| _dart_clang_disposeDiagnosticSet>('clang_disposeDiagnosticSet'); |
| |
| typedef _c_clang_disposeDiagnosticSet = ffi.Void Function( |
| ffi.Pointer<ffi.Void> Diags, |
| ); |
| |
| typedef _dart_clang_disposeDiagnosticSet = void Function( |
| ffi.Pointer<ffi.Void> Diags, |
| ); |
| |
| /// Destroy the given index. |
| /// |
| /// The index must not be destroyed until all of the translation units created |
| /// within that index have been destroyed. |
| void clang_disposeIndex( |
| ffi.Pointer<ffi.Void> index, |
| ) { |
| return _clang_disposeIndex( |
| index, |
| ); |
| } |
| |
| final _dart_clang_disposeIndex _clang_disposeIndex = |
| _dylib.lookupFunction<_c_clang_disposeIndex, _dart_clang_disposeIndex>( |
| 'clang_disposeIndex'); |
| |
| typedef _c_clang_disposeIndex = ffi.Void Function( |
| ffi.Pointer<ffi.Void> index, |
| ); |
| |
| typedef _dart_clang_disposeIndex = void Function( |
| ffi.Pointer<ffi.Void> index, |
| ); |
| |
| /// Free the set of overridden cursors returned by \c |
| /// clang_getOverriddenCursors(). |
| void clang_disposeOverriddenCursors( |
| ffi.Pointer<CXCursor> overridden, |
| ) { |
| return _clang_disposeOverriddenCursors( |
| overridden, |
| ); |
| } |
| |
| final _dart_clang_disposeOverriddenCursors _clang_disposeOverriddenCursors = |
| _dylib.lookupFunction<_c_clang_disposeOverriddenCursors, |
| _dart_clang_disposeOverriddenCursors>('clang_disposeOverriddenCursors'); |
| |
| typedef _c_clang_disposeOverriddenCursors = ffi.Void Function( |
| ffi.Pointer<CXCursor> overridden, |
| ); |
| |
| typedef _dart_clang_disposeOverriddenCursors = void Function( |
| ffi.Pointer<CXCursor> overridden, |
| ); |
| |
| /// Destroy the given \c CXSourceRangeList. |
| void clang_disposeSourceRangeList( |
| ffi.Pointer<CXSourceRangeList> ranges, |
| ) { |
| return _clang_disposeSourceRangeList( |
| ranges, |
| ); |
| } |
| |
| final _dart_clang_disposeSourceRangeList _clang_disposeSourceRangeList = |
| _dylib.lookupFunction<_c_clang_disposeSourceRangeList, |
| _dart_clang_disposeSourceRangeList>('clang_disposeSourceRangeList'); |
| |
| typedef _c_clang_disposeSourceRangeList = ffi.Void Function( |
| ffi.Pointer<CXSourceRangeList> ranges, |
| ); |
| |
| typedef _dart_clang_disposeSourceRangeList = void Function( |
| ffi.Pointer<CXSourceRangeList> ranges, |
| ); |
| |
| /// Free the given string set. |
| void clang_disposeStringSet( |
| ffi.Pointer<CXStringSet> set, |
| ) { |
| return _clang_disposeStringSet( |
| set, |
| ); |
| } |
| |
| final _dart_clang_disposeStringSet _clang_disposeStringSet = _dylib |
| .lookupFunction<_c_clang_disposeStringSet, _dart_clang_disposeStringSet>( |
| 'clang_disposeStringSet'); |
| |
| typedef _c_clang_disposeStringSet = ffi.Void Function( |
| ffi.Pointer<CXStringSet> set, |
| ); |
| |
| typedef _dart_clang_disposeStringSet = void Function( |
| ffi.Pointer<CXStringSet> set, |
| ); |
| |
| void clang_disposeString_wrap( |
| ffi.Pointer<CXString> string, |
| ) { |
| return _clang_disposeString_wrap( |
| string, |
| ); |
| } |
| |
| final _dart_clang_disposeString_wrap _clang_disposeString_wrap = |
| _dylib.lookupFunction<_c_clang_disposeString_wrap, |
| _dart_clang_disposeString_wrap>('clang_disposeString_wrap'); |
| |
| typedef _c_clang_disposeString_wrap = ffi.Void Function( |
| ffi.Pointer<CXString> string, |
| ); |
| |
| typedef _dart_clang_disposeString_wrap = void Function( |
| ffi.Pointer<CXString> string, |
| ); |
| |
| /// Free the given set of tokens. |
| void clang_disposeTokens( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<CXToken> Tokens, |
| int NumTokens, |
| ) { |
| return _clang_disposeTokens( |
| TU, |
| Tokens, |
| NumTokens, |
| ); |
| } |
| |
| final _dart_clang_disposeTokens _clang_disposeTokens = |
| _dylib.lookupFunction<_c_clang_disposeTokens, _dart_clang_disposeTokens>( |
| 'clang_disposeTokens'); |
| |
| typedef _c_clang_disposeTokens = ffi.Void Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<CXToken> Tokens, |
| ffi.Uint32 NumTokens, |
| ); |
| |
| typedef _dart_clang_disposeTokens = void Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<CXToken> Tokens, |
| int NumTokens, |
| ); |
| |
| /// Destroy the specified CXTranslationUnit object. |
| void clang_disposeTranslationUnit( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ) { |
| return _clang_disposeTranslationUnit( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_disposeTranslationUnit _clang_disposeTranslationUnit = |
| _dylib.lookupFunction<_c_clang_disposeTranslationUnit, |
| _dart_clang_disposeTranslationUnit>('clang_disposeTranslationUnit'); |
| |
| typedef _c_clang_disposeTranslationUnit = ffi.Void Function( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ); |
| |
| typedef _dart_clang_disposeTranslationUnit = void Function( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ); |
| |
| void clang_enableStackTraces() { |
| return _clang_enableStackTraces(); |
| } |
| |
| final _dart_clang_enableStackTraces _clang_enableStackTraces = _dylib |
| .lookupFunction<_c_clang_enableStackTraces, _dart_clang_enableStackTraces>( |
| 'clang_enableStackTraces'); |
| |
| typedef _c_clang_enableStackTraces = ffi.Void Function(); |
| |
| typedef _dart_clang_enableStackTraces = void Function(); |
| |
| /// Returns non-zero if the ranges are the same, zero if they differ. |
| int clang_equalRanges_wrap( |
| ffi.Pointer<CXSourceRange> c1, |
| ffi.Pointer<CXSourceRange> c2, |
| ) { |
| return _clang_equalRanges_wrap( |
| c1, |
| c2, |
| ); |
| } |
| |
| final _dart_clang_equalRanges_wrap _clang_equalRanges_wrap = _dylib |
| .lookupFunction<_c_clang_equalRanges_wrap, _dart_clang_equalRanges_wrap>( |
| 'clang_equalRanges_wrap'); |
| |
| typedef _c_clang_equalRanges_wrap = ffi.Uint32 Function( |
| ffi.Pointer<CXSourceRange> c1, |
| ffi.Pointer<CXSourceRange> c2, |
| ); |
| |
| typedef _dart_clang_equalRanges_wrap = int Function( |
| ffi.Pointer<CXSourceRange> c1, |
| ffi.Pointer<CXSourceRange> c2, |
| ); |
| |
| typedef _typedefC_1 = ffi.Void Function( |
| ffi.Pointer<ffi.Void>, |
| ); |
| |
| void clang_executeOnThread( |
| ffi.Pointer<ffi.NativeFunction<_typedefC_1>> fn, |
| ffi.Pointer<ffi.Void> user_data, |
| int stack_size, |
| ) { |
| return _clang_executeOnThread( |
| fn, |
| user_data, |
| stack_size, |
| ); |
| } |
| |
| final _dart_clang_executeOnThread _clang_executeOnThread = _dylib |
| .lookupFunction<_c_clang_executeOnThread, _dart_clang_executeOnThread>( |
| 'clang_executeOnThread'); |
| |
| typedef _c_clang_executeOnThread = ffi.Void Function( |
| ffi.Pointer<ffi.NativeFunction<_typedefC_1>> fn, |
| ffi.Pointer<ffi.Void> user_data, |
| ffi.Uint32 stack_size, |
| ); |
| |
| typedef _dart_clang_executeOnThread = void Function( |
| ffi.Pointer<ffi.NativeFunction<_typedefC_1>> fn, |
| ffi.Pointer<ffi.Void> user_data, |
| int stack_size, |
| ); |
| |
| ffi.Pointer<CXString> clang_formatDiagnostic_wrap( |
| ffi.Pointer<ffi.Void> diag, |
| int opts, |
| ) { |
| return _clang_formatDiagnostic_wrap( |
| diag, |
| opts, |
| ); |
| } |
| |
| final _dart_clang_formatDiagnostic_wrap _clang_formatDiagnostic_wrap = |
| _dylib.lookupFunction<_c_clang_formatDiagnostic_wrap, |
| _dart_clang_formatDiagnostic_wrap>('clang_formatDiagnostic_wrap'); |
| |
| typedef _c_clang_formatDiagnostic_wrap = ffi.Pointer<CXString> Function( |
| ffi.Pointer<ffi.Void> diag, |
| ffi.Int32 opts, |
| ); |
| |
| typedef _dart_clang_formatDiagnostic_wrap = ffi.Pointer<CXString> Function( |
| ffi.Pointer<ffi.Void> diag, |
| int opts, |
| ); |
| |
| /// Retrieve all ranges from all files that were skipped by the |
| /// preprocessor. |
| /// |
| /// The preprocessor will skip lines when they are surrounded by an |
| /// if/ifdef/ifndef directive whose condition does not evaluate to true. |
| ffi.Pointer<CXSourceRangeList> clang_getAllSkippedRanges( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ) { |
| return _clang_getAllSkippedRanges( |
| tu, |
| ); |
| } |
| |
| final _dart_clang_getAllSkippedRanges _clang_getAllSkippedRanges = |
| _dylib.lookupFunction<_c_clang_getAllSkippedRanges, |
| _dart_clang_getAllSkippedRanges>('clang_getAllSkippedRanges'); |
| |
| typedef _c_clang_getAllSkippedRanges = ffi.Pointer<CXSourceRangeList> Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ); |
| |
| typedef _dart_clang_getAllSkippedRanges = ffi.Pointer<CXSourceRangeList> |
| Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ); |
| |
| ffi.Pointer<CXType> clang_getArgType_wrap( |
| ffi.Pointer<CXType> cxtype, |
| int i, |
| ) { |
| return _clang_getArgType_wrap( |
| cxtype, |
| i, |
| ); |
| } |
| |
| final _dart_clang_getArgType_wrap _clang_getArgType_wrap = _dylib |
| .lookupFunction<_c_clang_getArgType_wrap, _dart_clang_getArgType_wrap>( |
| 'clang_getArgType_wrap'); |
| |
| typedef _c_clang_getArgType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> cxtype, |
| ffi.Uint32 i, |
| ); |
| |
| typedef _dart_clang_getArgType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> cxtype, |
| int i, |
| ); |
| |
| ffi.Pointer<CXType> clang_getArrayElementType_wrap( |
| ffi.Pointer<CXType> cxtype, |
| ) { |
| return _clang_getArrayElementType_wrap( |
| cxtype, |
| ); |
| } |
| |
| final _dart_clang_getArrayElementType_wrap _clang_getArrayElementType_wrap = |
| _dylib.lookupFunction<_c_clang_getArrayElementType_wrap, |
| _dart_clang_getArrayElementType_wrap>('clang_getArrayElementType_wrap'); |
| |
| typedef _c_clang_getArrayElementType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> cxtype, |
| ); |
| |
| typedef _dart_clang_getArrayElementType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> cxtype, |
| ); |
| |
| ffi.Pointer<ffi.Int8> clang_getCString_wrap( |
| ffi.Pointer<CXString> string, |
| ) { |
| return _clang_getCString_wrap( |
| string, |
| ); |
| } |
| |
| final _dart_clang_getCString_wrap _clang_getCString_wrap = _dylib |
| .lookupFunction<_c_clang_getCString_wrap, _dart_clang_getCString_wrap>( |
| 'clang_getCString_wrap'); |
| |
| typedef _c_clang_getCString_wrap = ffi.Pointer<ffi.Int8> Function( |
| ffi.Pointer<CXString> string, |
| ); |
| |
| typedef _dart_clang_getCString_wrap = ffi.Pointer<ffi.Int8> Function( |
| ffi.Pointer<CXString> string, |
| ); |
| |
| ffi.Pointer<CXType> clang_getCanonicalType_wrap( |
| ffi.Pointer<CXType> typerefType, |
| ) { |
| return _clang_getCanonicalType_wrap( |
| typerefType, |
| ); |
| } |
| |
| final _dart_clang_getCanonicalType_wrap _clang_getCanonicalType_wrap = |
| _dylib.lookupFunction<_c_clang_getCanonicalType_wrap, |
| _dart_clang_getCanonicalType_wrap>('clang_getCanonicalType_wrap'); |
| |
| typedef _c_clang_getCanonicalType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> typerefType, |
| ); |
| |
| typedef _dart_clang_getCanonicalType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> typerefType, |
| ); |
| |
| /// Retrieve the child diagnostics of a CXDiagnostic. |
| /// |
| /// This CXDiagnosticSet does not need to be released by |
| /// clang_disposeDiagnosticSet. |
| ffi.Pointer<ffi.Void> clang_getChildDiagnostics( |
| ffi.Pointer<ffi.Void> D, |
| ) { |
| return _clang_getChildDiagnostics( |
| D, |
| ); |
| } |
| |
| final _dart_clang_getChildDiagnostics _clang_getChildDiagnostics = |
| _dylib.lookupFunction<_c_clang_getChildDiagnostics, |
| _dart_clang_getChildDiagnostics>('clang_getChildDiagnostics'); |
| |
| typedef _c_clang_getChildDiagnostics = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void> D, |
| ); |
| |
| typedef _dart_clang_getChildDiagnostics = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void> D, |
| ); |
| |
| /// Determine the availability of the entity that this code-completion |
| /// string refers to. |
| /// |
| /// \param completion_string The completion string to query. |
| /// |
| /// \returns The availability of the completion string. |
| int clang_getCompletionAvailability( |
| ffi.Pointer<ffi.Void> completion_string, |
| ) { |
| return _clang_getCompletionAvailability( |
| completion_string, |
| ); |
| } |
| |
| final _dart_clang_getCompletionAvailability _clang_getCompletionAvailability = |
| _dylib.lookupFunction<_c_clang_getCompletionAvailability, |
| _dart_clang_getCompletionAvailability>( |
| 'clang_getCompletionAvailability'); |
| |
| typedef _c_clang_getCompletionAvailability = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| ); |
| |
| typedef _dart_clang_getCompletionAvailability = int Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| ); |
| |
| /// Retrieve the completion string associated with a particular chunk |
| /// within a completion string. |
| /// |
| /// \param completion_string the completion string to query. |
| /// |
| /// \param chunk_number the 0-based index of the chunk in the completion string. |
| /// |
| /// \returns the completion string associated with the chunk at index |
| /// \c chunk_number. |
| ffi.Pointer<ffi.Void> clang_getCompletionChunkCompletionString( |
| ffi.Pointer<ffi.Void> completion_string, |
| int chunk_number, |
| ) { |
| return _clang_getCompletionChunkCompletionString( |
| completion_string, |
| chunk_number, |
| ); |
| } |
| |
| final _dart_clang_getCompletionChunkCompletionString |
| _clang_getCompletionChunkCompletionString = _dylib.lookupFunction< |
| _c_clang_getCompletionChunkCompletionString, |
| _dart_clang_getCompletionChunkCompletionString>( |
| 'clang_getCompletionChunkCompletionString'); |
| |
| typedef _c_clang_getCompletionChunkCompletionString = ffi.Pointer<ffi.Void> |
| Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| ffi.Uint32 chunk_number, |
| ); |
| |
| typedef _dart_clang_getCompletionChunkCompletionString = ffi.Pointer<ffi.Void> |
| Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| int chunk_number, |
| ); |
| |
| /// Determine the kind of a particular chunk within a completion string. |
| /// |
| /// \param completion_string the completion string to query. |
| /// |
| /// \param chunk_number the 0-based index of the chunk in the completion string. |
| /// |
| /// \returns the kind of the chunk at the index \c chunk_number. |
| int clang_getCompletionChunkKind( |
| ffi.Pointer<ffi.Void> completion_string, |
| int chunk_number, |
| ) { |
| return _clang_getCompletionChunkKind( |
| completion_string, |
| chunk_number, |
| ); |
| } |
| |
| final _dart_clang_getCompletionChunkKind _clang_getCompletionChunkKind = |
| _dylib.lookupFunction<_c_clang_getCompletionChunkKind, |
| _dart_clang_getCompletionChunkKind>('clang_getCompletionChunkKind'); |
| |
| typedef _c_clang_getCompletionChunkKind = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| ffi.Uint32 chunk_number, |
| ); |
| |
| typedef _dart_clang_getCompletionChunkKind = int Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| int chunk_number, |
| ); |
| |
| /// Retrieve the number of annotations associated with the given |
| /// completion string. |
| /// |
| /// \param completion_string the completion string to query. |
| /// |
| /// \returns the number of annotations associated with the given completion |
| /// string. |
| int clang_getCompletionNumAnnotations( |
| ffi.Pointer<ffi.Void> completion_string, |
| ) { |
| return _clang_getCompletionNumAnnotations( |
| completion_string, |
| ); |
| } |
| |
| final _dart_clang_getCompletionNumAnnotations |
| _clang_getCompletionNumAnnotations = _dylib.lookupFunction< |
| _c_clang_getCompletionNumAnnotations, |
| _dart_clang_getCompletionNumAnnotations>( |
| 'clang_getCompletionNumAnnotations'); |
| |
| typedef _c_clang_getCompletionNumAnnotations = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| ); |
| |
| typedef _dart_clang_getCompletionNumAnnotations = int Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| ); |
| |
| /// Retrieve the number of fix-its for the given completion index. |
| /// |
| /// Calling this makes sense only if CXCodeComplete_IncludeCompletionsWithFixIts |
| /// option was set. |
| /// |
| /// \param results The structure keeping all completion results |
| /// |
| /// \param completion_index The index of the completion |
| /// |
| /// \return The number of fix-its which must be applied before the completion at |
| /// completion_index can be applied |
| int clang_getCompletionNumFixIts( |
| ffi.Pointer<CXCodeCompleteResults> results, |
| int completion_index, |
| ) { |
| return _clang_getCompletionNumFixIts( |
| results, |
| completion_index, |
| ); |
| } |
| |
| final _dart_clang_getCompletionNumFixIts _clang_getCompletionNumFixIts = |
| _dylib.lookupFunction<_c_clang_getCompletionNumFixIts, |
| _dart_clang_getCompletionNumFixIts>('clang_getCompletionNumFixIts'); |
| |
| typedef _c_clang_getCompletionNumFixIts = ffi.Uint32 Function( |
| ffi.Pointer<CXCodeCompleteResults> results, |
| ffi.Uint32 completion_index, |
| ); |
| |
| typedef _dart_clang_getCompletionNumFixIts = int Function( |
| ffi.Pointer<CXCodeCompleteResults> results, |
| int completion_index, |
| ); |
| |
| /// Determine the priority of this code completion. |
| /// |
| /// The priority of a code completion indicates how likely it is that this |
| /// particular completion is the completion that the user will select. The |
| /// priority is selected by various internal heuristics. |
| /// |
| /// \param completion_string The completion string to query. |
| /// |
| /// \returns The priority of this completion string. Smaller values indicate |
| /// higher-priority (more likely) completions. |
| int clang_getCompletionPriority( |
| ffi.Pointer<ffi.Void> completion_string, |
| ) { |
| return _clang_getCompletionPriority( |
| completion_string, |
| ); |
| } |
| |
| final _dart_clang_getCompletionPriority _clang_getCompletionPriority = |
| _dylib.lookupFunction<_c_clang_getCompletionPriority, |
| _dart_clang_getCompletionPriority>('clang_getCompletionPriority'); |
| |
| typedef _c_clang_getCompletionPriority = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| ); |
| |
| typedef _dart_clang_getCompletionPriority = int Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| ); |
| |
| ffi.Pointer<CXString> clang_getCursorKindSpelling_wrap( |
| int kind, |
| ) { |
| return _clang_getCursorKindSpelling_wrap( |
| kind, |
| ); |
| } |
| |
| final _dart_clang_getCursorKindSpelling_wrap _clang_getCursorKindSpelling_wrap = |
| _dylib.lookupFunction<_c_clang_getCursorKindSpelling_wrap, |
| _dart_clang_getCursorKindSpelling_wrap>( |
| 'clang_getCursorKindSpelling_wrap'); |
| |
| typedef _c_clang_getCursorKindSpelling_wrap = ffi.Pointer<CXString> Function( |
| ffi.Int32 kind, |
| ); |
| |
| typedef _dart_clang_getCursorKindSpelling_wrap = ffi.Pointer<CXString> Function( |
| int kind, |
| ); |
| |
| int clang_getCursorKind_wrap( |
| ffi.Pointer<CXCursor> cursor, |
| ) { |
| return _clang_getCursorKind_wrap( |
| cursor, |
| ); |
| } |
| |
| final _dart_clang_getCursorKind_wrap _clang_getCursorKind_wrap = |
| _dylib.lookupFunction<_c_clang_getCursorKind_wrap, |
| _dart_clang_getCursorKind_wrap>('clang_getCursorKind_wrap'); |
| |
| typedef _c_clang_getCursorKind_wrap = ffi.Int32 Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| typedef _dart_clang_getCursorKind_wrap = int Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| ffi.Pointer<CXSourceLocation> clang_getCursorLocation_wrap( |
| ffi.Pointer<CXCursor> cursor, |
| ) { |
| return _clang_getCursorLocation_wrap( |
| cursor, |
| ); |
| } |
| |
| final _dart_clang_getCursorLocation_wrap _clang_getCursorLocation_wrap = |
| _dylib.lookupFunction<_c_clang_getCursorLocation_wrap, |
| _dart_clang_getCursorLocation_wrap>('clang_getCursorLocation_wrap'); |
| |
| typedef _c_clang_getCursorLocation_wrap = ffi.Pointer<CXSourceLocation> |
| Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| typedef _dart_clang_getCursorLocation_wrap = ffi.Pointer<CXSourceLocation> |
| Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| /// The name of parameter, struct, typedef. |
| ffi.Pointer<CXString> clang_getCursorSpelling_wrap( |
| ffi.Pointer<CXCursor> cursor, |
| ) { |
| return _clang_getCursorSpelling_wrap( |
| cursor, |
| ); |
| } |
| |
| final _dart_clang_getCursorSpelling_wrap _clang_getCursorSpelling_wrap = |
| _dylib.lookupFunction<_c_clang_getCursorSpelling_wrap, |
| _dart_clang_getCursorSpelling_wrap>('clang_getCursorSpelling_wrap'); |
| |
| typedef _c_clang_getCursorSpelling_wrap = ffi.Pointer<CXString> Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| typedef _dart_clang_getCursorSpelling_wrap = ffi.Pointer<CXString> Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| ffi.Pointer<CXType> clang_getCursorType_wrap( |
| ffi.Pointer<CXCursor> cursor, |
| ) { |
| return _clang_getCursorType_wrap( |
| cursor, |
| ); |
| } |
| |
| final _dart_clang_getCursorType_wrap _clang_getCursorType_wrap = |
| _dylib.lookupFunction<_c_clang_getCursorType_wrap, |
| _dart_clang_getCursorType_wrap>('clang_getCursorType_wrap'); |
| |
| typedef _c_clang_getCursorType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| typedef _dart_clang_getCursorType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| /// Retrieve a diagnostic associated with the given translation unit. |
| /// |
| /// \param Unit the translation unit to query. |
| /// \param Index the zero-based diagnostic number to retrieve. |
| /// |
| /// \returns the requested diagnostic. This diagnostic must be freed |
| /// via a call to \c clang_disposeDiagnostic(). |
| ffi.Pointer<ffi.Void> clang_getDiagnostic( |
| ffi.Pointer<CXTranslationUnitImpl> Unit, |
| int Index, |
| ) { |
| return _clang_getDiagnostic( |
| Unit, |
| Index, |
| ); |
| } |
| |
| final _dart_clang_getDiagnostic _clang_getDiagnostic = |
| _dylib.lookupFunction<_c_clang_getDiagnostic, _dart_clang_getDiagnostic>( |
| 'clang_getDiagnostic'); |
| |
| typedef _c_clang_getDiagnostic = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXTranslationUnitImpl> Unit, |
| ffi.Uint32 Index, |
| ); |
| |
| typedef _dart_clang_getDiagnostic = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXTranslationUnitImpl> Unit, |
| int Index, |
| ); |
| |
| /// Retrieve the category number for this diagnostic. |
| /// |
| /// Diagnostics can be categorized into groups along with other, related |
| /// diagnostics (e.g., diagnostics under the same warning flag). This routine |
| /// retrieves the category number for the given diagnostic. |
| /// |
| /// \returns The number of the category that contains this diagnostic, or zero |
| /// if this diagnostic is uncategorized. |
| int clang_getDiagnosticCategory( |
| ffi.Pointer<ffi.Void> arg0, |
| ) { |
| return _clang_getDiagnosticCategory( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_getDiagnosticCategory _clang_getDiagnosticCategory = |
| _dylib.lookupFunction<_c_clang_getDiagnosticCategory, |
| _dart_clang_getDiagnosticCategory>('clang_getDiagnosticCategory'); |
| |
| typedef _c_clang_getDiagnosticCategory = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| typedef _dart_clang_getDiagnosticCategory = int Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| /// Retrieve a diagnostic associated with the given CXDiagnosticSet. |
| /// |
| /// \param Diags the CXDiagnosticSet to query. |
| /// \param Index the zero-based diagnostic number to retrieve. |
| /// |
| /// \returns the requested diagnostic. This diagnostic must be freed |
| /// via a call to \c clang_disposeDiagnostic(). |
| ffi.Pointer<ffi.Void> clang_getDiagnosticInSet( |
| ffi.Pointer<ffi.Void> Diags, |
| int Index, |
| ) { |
| return _clang_getDiagnosticInSet( |
| Diags, |
| Index, |
| ); |
| } |
| |
| final _dart_clang_getDiagnosticInSet _clang_getDiagnosticInSet = |
| _dylib.lookupFunction<_c_clang_getDiagnosticInSet, |
| _dart_clang_getDiagnosticInSet>('clang_getDiagnosticInSet'); |
| |
| typedef _c_clang_getDiagnosticInSet = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void> Diags, |
| ffi.Uint32 Index, |
| ); |
| |
| typedef _dart_clang_getDiagnosticInSet = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Void> Diags, |
| int Index, |
| ); |
| |
| /// Determine the number of fix-it hints associated with the |
| /// given diagnostic. |
| int clang_getDiagnosticNumFixIts( |
| ffi.Pointer<ffi.Void> Diagnostic, |
| ) { |
| return _clang_getDiagnosticNumFixIts( |
| Diagnostic, |
| ); |
| } |
| |
| final _dart_clang_getDiagnosticNumFixIts _clang_getDiagnosticNumFixIts = |
| _dylib.lookupFunction<_c_clang_getDiagnosticNumFixIts, |
| _dart_clang_getDiagnosticNumFixIts>('clang_getDiagnosticNumFixIts'); |
| |
| typedef _c_clang_getDiagnosticNumFixIts = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> Diagnostic, |
| ); |
| |
| typedef _dart_clang_getDiagnosticNumFixIts = int Function( |
| ffi.Pointer<ffi.Void> Diagnostic, |
| ); |
| |
| /// Determine the number of source ranges associated with the given |
| /// diagnostic. |
| int clang_getDiagnosticNumRanges( |
| ffi.Pointer<ffi.Void> arg0, |
| ) { |
| return _clang_getDiagnosticNumRanges( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_getDiagnosticNumRanges _clang_getDiagnosticNumRanges = |
| _dylib.lookupFunction<_c_clang_getDiagnosticNumRanges, |
| _dart_clang_getDiagnosticNumRanges>('clang_getDiagnosticNumRanges'); |
| |
| typedef _c_clang_getDiagnosticNumRanges = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| typedef _dart_clang_getDiagnosticNumRanges = int Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| /// Retrieve the complete set of diagnostics associated with a |
| /// translation unit. |
| /// |
| /// \param Unit the translation unit to query. |
| ffi.Pointer<ffi.Void> clang_getDiagnosticSetFromTU( |
| ffi.Pointer<CXTranslationUnitImpl> Unit, |
| ) { |
| return _clang_getDiagnosticSetFromTU( |
| Unit, |
| ); |
| } |
| |
| final _dart_clang_getDiagnosticSetFromTU _clang_getDiagnosticSetFromTU = |
| _dylib.lookupFunction<_c_clang_getDiagnosticSetFromTU, |
| _dart_clang_getDiagnosticSetFromTU>('clang_getDiagnosticSetFromTU'); |
| |
| typedef _c_clang_getDiagnosticSetFromTU = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXTranslationUnitImpl> Unit, |
| ); |
| |
| typedef _dart_clang_getDiagnosticSetFromTU = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXTranslationUnitImpl> Unit, |
| ); |
| |
| /// Determine the severity of the given diagnostic. |
| int clang_getDiagnosticSeverity( |
| ffi.Pointer<ffi.Void> arg0, |
| ) { |
| return _clang_getDiagnosticSeverity( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_getDiagnosticSeverity _clang_getDiagnosticSeverity = |
| _dylib.lookupFunction<_c_clang_getDiagnosticSeverity, |
| _dart_clang_getDiagnosticSeverity>('clang_getDiagnosticSeverity'); |
| |
| typedef _c_clang_getDiagnosticSeverity = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| typedef _dart_clang_getDiagnosticSeverity = int Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| int clang_getEnumConstantDeclValue_wrap( |
| ffi.Pointer<CXCursor> cursor, |
| ) { |
| return _clang_getEnumConstantDeclValue_wrap( |
| cursor, |
| ); |
| } |
| |
| final _dart_clang_getEnumConstantDeclValue_wrap |
| _clang_getEnumConstantDeclValue_wrap = _dylib.lookupFunction< |
| _c_clang_getEnumConstantDeclValue_wrap, |
| _dart_clang_getEnumConstantDeclValue_wrap>( |
| 'clang_getEnumConstantDeclValue_wrap'); |
| |
| typedef _c_clang_getEnumConstantDeclValue_wrap = ffi.Int64 Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| typedef _dart_clang_getEnumConstantDeclValue_wrap = int Function( |
| ffi.Pointer<CXCursor> cursor, |
| ); |
| |
| /// Retrieve a file handle within the given translation unit. |
| /// |
| /// \param tu the translation unit |
| /// |
| /// \param file_name the name of the file. |
| /// |
| /// \returns the file handle for the named file in the translation unit \p tu, |
| /// or a NULL file handle if the file was not a part of this translation unit. |
| ffi.Pointer<ffi.Void> clang_getFile( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Int8> file_name, |
| ) { |
| return _clang_getFile( |
| tu, |
| file_name, |
| ); |
| } |
| |
| final _dart_clang_getFile _clang_getFile = _dylib |
| .lookupFunction<_c_clang_getFile, _dart_clang_getFile>('clang_getFile'); |
| |
| typedef _c_clang_getFile = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Int8> file_name, |
| ); |
| |
| typedef _dart_clang_getFile = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Int8> file_name, |
| ); |
| |
| /// Retrieve the buffer associated with the given file. |
| /// |
| /// \param tu the translation unit |
| /// |
| /// \param file the file for which to retrieve the buffer. |
| /// |
| /// \param size [out] if non-NULL, will be set to the size of the buffer. |
| /// |
| /// \returns a pointer to the buffer in memory that holds the contents of |
| /// \p file, or a NULL pointer when the file is not loaded. |
| ffi.Pointer<ffi.Int8> clang_getFileContents( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Void> file, |
| ffi.Pointer<ffi.Uint64> size, |
| ) { |
| return _clang_getFileContents( |
| tu, |
| file, |
| size, |
| ); |
| } |
| |
| final _dart_clang_getFileContents _clang_getFileContents = _dylib |
| .lookupFunction<_c_clang_getFileContents, _dart_clang_getFileContents>( |
| 'clang_getFileContents'); |
| |
| typedef _c_clang_getFileContents = ffi.Pointer<ffi.Int8> Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Void> file, |
| ffi.Pointer<ffi.Uint64> size, |
| ); |
| |
| typedef _dart_clang_getFileContents = ffi.Pointer<ffi.Int8> Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Void> file, |
| ffi.Pointer<ffi.Uint64> size, |
| ); |
| |
| void clang_getFileLocation_wrap( |
| ffi.Pointer<CXSourceLocation> location, |
| ffi.Pointer<ffi.Pointer<ffi.Void>> file, |
| ffi.Pointer<ffi.Uint32> line, |
| ffi.Pointer<ffi.Uint32> column, |
| ffi.Pointer<ffi.Uint32> offset, |
| ) { |
| return _clang_getFileLocation_wrap( |
| location, |
| file, |
| line, |
| column, |
| offset, |
| ); |
| } |
| |
| final _dart_clang_getFileLocation_wrap _clang_getFileLocation_wrap = |
| _dylib.lookupFunction<_c_clang_getFileLocation_wrap, |
| _dart_clang_getFileLocation_wrap>('clang_getFileLocation_wrap'); |
| |
| typedef _c_clang_getFileLocation_wrap = ffi.Void Function( |
| ffi.Pointer<CXSourceLocation> location, |
| ffi.Pointer<ffi.Pointer<ffi.Void>> file, |
| ffi.Pointer<ffi.Uint32> line, |
| ffi.Pointer<ffi.Uint32> column, |
| ffi.Pointer<ffi.Uint32> offset, |
| ); |
| |
| typedef _dart_clang_getFileLocation_wrap = void Function( |
| ffi.Pointer<CXSourceLocation> location, |
| ffi.Pointer<ffi.Pointer<ffi.Void>> file, |
| ffi.Pointer<ffi.Uint32> line, |
| ffi.Pointer<ffi.Uint32> column, |
| ffi.Pointer<ffi.Uint32> offset, |
| ); |
| |
| ffi.Pointer<CXString> clang_getFileName_wrap( |
| ffi.Pointer<ffi.Void> SFile, |
| ) { |
| return _clang_getFileName_wrap( |
| SFile, |
| ); |
| } |
| |
| final _dart_clang_getFileName_wrap _clang_getFileName_wrap = _dylib |
| .lookupFunction<_c_clang_getFileName_wrap, _dart_clang_getFileName_wrap>( |
| 'clang_getFileName_wrap'); |
| |
| typedef _c_clang_getFileName_wrap = ffi.Pointer<CXString> Function( |
| ffi.Pointer<ffi.Void> SFile, |
| ); |
| |
| typedef _dart_clang_getFileName_wrap = ffi.Pointer<CXString> Function( |
| ffi.Pointer<ffi.Void> SFile, |
| ); |
| |
| /// Retrieve the last modification time of the given file. |
| int clang_getFileTime( |
| ffi.Pointer<ffi.Void> SFile, |
| ) { |
| return _clang_getFileTime( |
| SFile, |
| ); |
| } |
| |
| final _dart_clang_getFileTime _clang_getFileTime = |
| _dylib.lookupFunction<_c_clang_getFileTime, _dart_clang_getFileTime>( |
| 'clang_getFileTime'); |
| |
| typedef _c_clang_getFileTime = ffi.Int64 Function( |
| ffi.Pointer<ffi.Void> SFile, |
| ); |
| |
| typedef _dart_clang_getFileTime = int Function( |
| ffi.Pointer<ffi.Void> SFile, |
| ); |
| |
| /// Retrieve the unique ID for the given \c file. |
| /// |
| /// \param file the file to get the ID for. |
| /// \param outID stores the returned CXFileUniqueID. |
| /// \returns If there was a failure getting the unique ID, returns non-zero, |
| /// otherwise returns 0. |
| int clang_getFileUniqueID( |
| ffi.Pointer<ffi.Void> file, |
| ffi.Pointer<CXFileUniqueID> outID, |
| ) { |
| return _clang_getFileUniqueID( |
| file, |
| outID, |
| ); |
| } |
| |
| final _dart_clang_getFileUniqueID _clang_getFileUniqueID = _dylib |
| .lookupFunction<_c_clang_getFileUniqueID, _dart_clang_getFileUniqueID>( |
| 'clang_getFileUniqueID'); |
| |
| typedef _c_clang_getFileUniqueID = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> file, |
| ffi.Pointer<CXFileUniqueID> outID, |
| ); |
| |
| typedef _dart_clang_getFileUniqueID = int Function( |
| ffi.Pointer<ffi.Void> file, |
| ffi.Pointer<CXFileUniqueID> outID, |
| ); |
| |
| typedef CXInclusionVisitor_1 = ffi.Void Function( |
| ffi.Pointer<ffi.Void>, |
| ffi.Pointer<CXSourceLocation>, |
| ffi.Uint32, |
| ffi.Pointer<ffi.Void>, |
| ); |
| |
| /// Visit the set of preprocessor inclusions in a translation unit. |
| /// The visitor function is called with the provided data for every included |
| /// file. This does not include headers included by the PCH file (unless one |
| /// is inspecting the inclusions in the PCH file itself). |
| void clang_getInclusions( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.NativeFunction<CXInclusionVisitor_1>> visitor, |
| ffi.Pointer<ffi.Void> client_data, |
| ) { |
| return _clang_getInclusions( |
| tu, |
| visitor, |
| client_data, |
| ); |
| } |
| |
| final _dart_clang_getInclusions _clang_getInclusions = |
| _dylib.lookupFunction<_c_clang_getInclusions, _dart_clang_getInclusions>( |
| 'clang_getInclusions'); |
| |
| typedef _c_clang_getInclusions = ffi.Void Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.NativeFunction<CXInclusionVisitor_1>> visitor, |
| ffi.Pointer<ffi.Void> client_data, |
| ); |
| |
| typedef _dart_clang_getInclusions = void Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.NativeFunction<CXInclusionVisitor_1>> visitor, |
| ffi.Pointer<ffi.Void> client_data, |
| ); |
| |
| /// Given a CXFile header file, return the module that contains it, if one |
| /// exists. |
| ffi.Pointer<ffi.Void> clang_getModuleForFile( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ffi.Pointer<ffi.Void> arg1, |
| ) { |
| return _clang_getModuleForFile( |
| arg0, |
| arg1, |
| ); |
| } |
| |
| final _dart_clang_getModuleForFile _clang_getModuleForFile = _dylib |
| .lookupFunction<_c_clang_getModuleForFile, _dart_clang_getModuleForFile>( |
| 'clang_getModuleForFile'); |
| |
| typedef _c_clang_getModuleForFile = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ffi.Pointer<ffi.Void> arg1, |
| ); |
| |
| typedef _dart_clang_getModuleForFile = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ffi.Pointer<ffi.Void> arg1, |
| ); |
| |
| int clang_getNumArgTypes_wrap( |
| ffi.Pointer<CXType> cxtype, |
| ) { |
| return _clang_getNumArgTypes_wrap( |
| cxtype, |
| ); |
| } |
| |
| final _dart_clang_getNumArgTypes_wrap _clang_getNumArgTypes_wrap = |
| _dylib.lookupFunction<_c_clang_getNumArgTypes_wrap, |
| _dart_clang_getNumArgTypes_wrap>('clang_getNumArgTypes_wrap'); |
| |
| typedef _c_clang_getNumArgTypes_wrap = ffi.Int32 Function( |
| ffi.Pointer<CXType> cxtype, |
| ); |
| |
| typedef _dart_clang_getNumArgTypes_wrap = int Function( |
| ffi.Pointer<CXType> cxtype, |
| ); |
| |
| /// Retrieve the number of chunks in the given code-completion string. |
| int clang_getNumCompletionChunks( |
| ffi.Pointer<ffi.Void> completion_string, |
| ) { |
| return _clang_getNumCompletionChunks( |
| completion_string, |
| ); |
| } |
| |
| final _dart_clang_getNumCompletionChunks _clang_getNumCompletionChunks = |
| _dylib.lookupFunction<_c_clang_getNumCompletionChunks, |
| _dart_clang_getNumCompletionChunks>('clang_getNumCompletionChunks'); |
| |
| typedef _c_clang_getNumCompletionChunks = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| ); |
| |
| typedef _dart_clang_getNumCompletionChunks = int Function( |
| ffi.Pointer<ffi.Void> completion_string, |
| ); |
| |
| /// Determine the number of diagnostics produced for the given |
| /// translation unit. |
| int clang_getNumDiagnostics( |
| ffi.Pointer<CXTranslationUnitImpl> Unit, |
| ) { |
| return _clang_getNumDiagnostics( |
| Unit, |
| ); |
| } |
| |
| final _dart_clang_getNumDiagnostics _clang_getNumDiagnostics = _dylib |
| .lookupFunction<_c_clang_getNumDiagnostics, _dart_clang_getNumDiagnostics>( |
| 'clang_getNumDiagnostics'); |
| |
| typedef _c_clang_getNumDiagnostics = ffi.Uint32 Function( |
| ffi.Pointer<CXTranslationUnitImpl> Unit, |
| ); |
| |
| typedef _dart_clang_getNumDiagnostics = int Function( |
| ffi.Pointer<CXTranslationUnitImpl> Unit, |
| ); |
| |
| /// Determine the number of diagnostics in a CXDiagnosticSet. |
| int clang_getNumDiagnosticsInSet( |
| ffi.Pointer<ffi.Void> Diags, |
| ) { |
| return _clang_getNumDiagnosticsInSet( |
| Diags, |
| ); |
| } |
| |
| final _dart_clang_getNumDiagnosticsInSet _clang_getNumDiagnosticsInSet = |
| _dylib.lookupFunction<_c_clang_getNumDiagnosticsInSet, |
| _dart_clang_getNumDiagnosticsInSet>('clang_getNumDiagnosticsInSet'); |
| |
| typedef _c_clang_getNumDiagnosticsInSet = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> Diags, |
| ); |
| |
| typedef _dart_clang_getNumDiagnosticsInSet = int Function( |
| ffi.Pointer<ffi.Void> Diags, |
| ); |
| |
| int clang_getNumElements_wrap( |
| ffi.Pointer<CXType> cxtype, |
| ) { |
| return _clang_getNumElements_wrap( |
| cxtype, |
| ); |
| } |
| |
| final _dart_clang_getNumElements_wrap _clang_getNumElements_wrap = |
| _dylib.lookupFunction<_c_clang_getNumElements_wrap, |
| _dart_clang_getNumElements_wrap>('clang_getNumElements_wrap'); |
| |
| typedef _c_clang_getNumElements_wrap = ffi.Uint64 Function( |
| ffi.Pointer<CXType> cxtype, |
| ); |
| |
| typedef _dart_clang_getNumElements_wrap = int Function( |
| ffi.Pointer<CXType> cxtype, |
| ); |
| |
| ffi.Pointer<CXType> clang_getPointeeType_wrap( |
| ffi.Pointer<CXType> pointerType, |
| ) { |
| return _clang_getPointeeType_wrap( |
| pointerType, |
| ); |
| } |
| |
| final _dart_clang_getPointeeType_wrap _clang_getPointeeType_wrap = |
| _dylib.lookupFunction<_c_clang_getPointeeType_wrap, |
| _dart_clang_getPointeeType_wrap>('clang_getPointeeType_wrap'); |
| |
| typedef _c_clang_getPointeeType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> pointerType, |
| ); |
| |
| typedef _dart_clang_getPointeeType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> pointerType, |
| ); |
| |
| /// Retrieve a remapping. |
| /// |
| /// \param path the path that contains metadata about remappings. |
| /// |
| /// \returns the requested remapping. This remapping must be freed |
| /// via a call to \c clang_remap_dispose(). Can return NULL if an error occurred. |
| ffi.Pointer<ffi.Void> clang_getRemappings( |
| ffi.Pointer<ffi.Int8> path, |
| ) { |
| return _clang_getRemappings( |
| path, |
| ); |
| } |
| |
| final _dart_clang_getRemappings _clang_getRemappings = |
| _dylib.lookupFunction<_c_clang_getRemappings, _dart_clang_getRemappings>( |
| 'clang_getRemappings'); |
| |
| typedef _c_clang_getRemappings = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Int8> path, |
| ); |
| |
| typedef _dart_clang_getRemappings = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Int8> path, |
| ); |
| |
| /// Retrieve a remapping. |
| /// |
| /// \param filePaths pointer to an array of file paths containing remapping info. |
| /// |
| /// \param numFiles number of file paths. |
| /// |
| /// \returns the requested remapping. This remapping must be freed |
| /// via a call to \c clang_remap_dispose(). Can return NULL if an error occurred. |
| ffi.Pointer<ffi.Void> clang_getRemappingsFromFileList( |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> filePaths, |
| int numFiles, |
| ) { |
| return _clang_getRemappingsFromFileList( |
| filePaths, |
| numFiles, |
| ); |
| } |
| |
| final _dart_clang_getRemappingsFromFileList _clang_getRemappingsFromFileList = |
| _dylib.lookupFunction<_c_clang_getRemappingsFromFileList, |
| _dart_clang_getRemappingsFromFileList>( |
| 'clang_getRemappingsFromFileList'); |
| |
| typedef _c_clang_getRemappingsFromFileList = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> filePaths, |
| ffi.Uint32 numFiles, |
| ); |
| |
| typedef _dart_clang_getRemappingsFromFileList = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> filePaths, |
| int numFiles, |
| ); |
| |
| ffi.Pointer<CXType> clang_getResultType_wrap( |
| ffi.Pointer<CXType> functionType, |
| ) { |
| return _clang_getResultType_wrap( |
| functionType, |
| ); |
| } |
| |
| final _dart_clang_getResultType_wrap _clang_getResultType_wrap = |
| _dylib.lookupFunction<_c_clang_getResultType_wrap, |
| _dart_clang_getResultType_wrap>('clang_getResultType_wrap'); |
| |
| typedef _c_clang_getResultType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> functionType, |
| ); |
| |
| typedef _dart_clang_getResultType_wrap = ffi.Pointer<CXType> Function( |
| ffi.Pointer<CXType> functionType, |
| ); |
| |
| /// Retrieve all ranges that were skipped by the preprocessor. |
| /// |
| /// The preprocessor will skip lines when they are surrounded by an |
| /// if/ifdef/ifndef directive whose condition does not evaluate to true. |
| ffi.Pointer<CXSourceRangeList> clang_getSkippedRanges( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Void> file, |
| ) { |
| return _clang_getSkippedRanges( |
| tu, |
| file, |
| ); |
| } |
| |
| final _dart_clang_getSkippedRanges _clang_getSkippedRanges = _dylib |
| .lookupFunction<_c_clang_getSkippedRanges, _dart_clang_getSkippedRanges>( |
| 'clang_getSkippedRanges'); |
| |
| typedef _c_clang_getSkippedRanges = ffi.Pointer<CXSourceRangeList> Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Void> file, |
| ); |
| |
| typedef _dart_clang_getSkippedRanges = ffi.Pointer<CXSourceRangeList> Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Void> file, |
| ); |
| |
| /// Returns the human-readable null-terminated C string that represents |
| /// the name of the memory category. This string should never be freed. |
| ffi.Pointer<ffi.Int8> clang_getTUResourceUsageName( |
| int kind, |
| ) { |
| return _clang_getTUResourceUsageName( |
| kind, |
| ); |
| } |
| |
| final _dart_clang_getTUResourceUsageName _clang_getTUResourceUsageName = |
| _dylib.lookupFunction<_c_clang_getTUResourceUsageName, |
| _dart_clang_getTUResourceUsageName>('clang_getTUResourceUsageName'); |
| |
| typedef _c_clang_getTUResourceUsageName = ffi.Pointer<ffi.Int8> Function( |
| ffi.Int32 kind, |
| ); |
| |
| typedef _dart_clang_getTUResourceUsageName = ffi.Pointer<ffi.Int8> Function( |
| int kind, |
| ); |
| |
| ffi.Pointer<CXCursor> clang_getTranslationUnitCursor_wrap( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ) { |
| return _clang_getTranslationUnitCursor_wrap( |
| tu, |
| ); |
| } |
| |
| final _dart_clang_getTranslationUnitCursor_wrap |
| _clang_getTranslationUnitCursor_wrap = _dylib.lookupFunction< |
| _c_clang_getTranslationUnitCursor_wrap, |
| _dart_clang_getTranslationUnitCursor_wrap>( |
| 'clang_getTranslationUnitCursor_wrap'); |
| |
| typedef _c_clang_getTranslationUnitCursor_wrap = ffi.Pointer<CXCursor> Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ); |
| |
| typedef _dart_clang_getTranslationUnitCursor_wrap = ffi.Pointer<CXCursor> |
| Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ); |
| |
| /// Get target information for this translation unit. |
| /// |
| /// The CXTargetInfo object cannot outlive the CXTranslationUnit object. |
| ffi.Pointer<CXTargetInfoImpl> clang_getTranslationUnitTargetInfo( |
| ffi.Pointer<CXTranslationUnitImpl> CTUnit, |
| ) { |
| return _clang_getTranslationUnitTargetInfo( |
| CTUnit, |
| ); |
| } |
| |
| final _dart_clang_getTranslationUnitTargetInfo |
| _clang_getTranslationUnitTargetInfo = _dylib.lookupFunction< |
| _c_clang_getTranslationUnitTargetInfo, |
| _dart_clang_getTranslationUnitTargetInfo>( |
| 'clang_getTranslationUnitTargetInfo'); |
| |
| typedef _c_clang_getTranslationUnitTargetInfo = ffi.Pointer<CXTargetInfoImpl> |
| Function( |
| ffi.Pointer<CXTranslationUnitImpl> CTUnit, |
| ); |
| |
| typedef _dart_clang_getTranslationUnitTargetInfo = ffi.Pointer<CXTargetInfoImpl> |
| Function( |
| ffi.Pointer<CXTranslationUnitImpl> CTUnit, |
| ); |
| |
| ffi.Pointer<CXCursor> clang_getTypeDeclaration_wrap( |
| ffi.Pointer<CXType> cxtype, |
| ) { |
| return _clang_getTypeDeclaration_wrap( |
| cxtype, |
| ); |
| } |
| |
| final _dart_clang_getTypeDeclaration_wrap _clang_getTypeDeclaration_wrap = |
| _dylib.lookupFunction<_c_clang_getTypeDeclaration_wrap, |
| _dart_clang_getTypeDeclaration_wrap>('clang_getTypeDeclaration_wrap'); |
| |
| typedef _c_clang_getTypeDeclaration_wrap = ffi.Pointer<CXCursor> Function( |
| ffi.Pointer<CXType> cxtype, |
| ); |
| |
| typedef _dart_clang_getTypeDeclaration_wrap = ffi.Pointer<CXCursor> Function( |
| ffi.Pointer<CXType> cxtype, |
| ); |
| |
| ffi.Pointer<CXString> clang_getTypeKindSpelling_wrap( |
| int typeKind, |
| ) { |
| return _clang_getTypeKindSpelling_wrap( |
| typeKind, |
| ); |
| } |
| |
| final _dart_clang_getTypeKindSpelling_wrap _clang_getTypeKindSpelling_wrap = |
| _dylib.lookupFunction<_c_clang_getTypeKindSpelling_wrap, |
| _dart_clang_getTypeKindSpelling_wrap>('clang_getTypeKindSpelling_wrap'); |
| |
| typedef _c_clang_getTypeKindSpelling_wrap = ffi.Pointer<CXString> Function( |
| ffi.Int32 typeKind, |
| ); |
| |
| typedef _dart_clang_getTypeKindSpelling_wrap = ffi.Pointer<CXString> Function( |
| int typeKind, |
| ); |
| |
| ffi.Pointer<CXString> clang_getTypeSpelling_wrap( |
| ffi.Pointer<CXType> type, |
| ) { |
| return _clang_getTypeSpelling_wrap( |
| type, |
| ); |
| } |
| |
| final _dart_clang_getTypeSpelling_wrap _clang_getTypeSpelling_wrap = |
| _dylib.lookupFunction<_c_clang_getTypeSpelling_wrap, |
| _dart_clang_getTypeSpelling_wrap>('clang_getTypeSpelling_wrap'); |
| |
| typedef _c_clang_getTypeSpelling_wrap = ffi.Pointer<CXString> Function( |
| ffi.Pointer<CXType> type, |
| ); |
| |
| typedef _dart_clang_getTypeSpelling_wrap = ffi.Pointer<CXString> Function( |
| ffi.Pointer<CXType> type, |
| ); |
| |
| ffi.Pointer<CXType> clang_getTypedefDeclUnderlyingType_wrap( |
| ffi.Pointer<CXCursor> cxcursor, |
| ) { |
| return _clang_getTypedefDeclUnderlyingType_wrap( |
| cxcursor, |
| ); |
| } |
| |
| final _dart_clang_getTypedefDeclUnderlyingType_wrap |
| _clang_getTypedefDeclUnderlyingType_wrap = _dylib.lookupFunction< |
| _c_clang_getTypedefDeclUnderlyingType_wrap, |
| _dart_clang_getTypedefDeclUnderlyingType_wrap>( |
| 'clang_getTypedefDeclUnderlyingType_wrap'); |
| |
| typedef _c_clang_getTypedefDeclUnderlyingType_wrap = ffi.Pointer<CXType> |
| Function( |
| ffi.Pointer<CXCursor> cxcursor, |
| ); |
| |
| typedef _dart_clang_getTypedefDeclUnderlyingType_wrap = ffi.Pointer<CXType> |
| Function( |
| ffi.Pointer<CXCursor> cxcursor, |
| ); |
| |
| /// Index the given source file and the translation unit corresponding |
| /// to that file via callbacks implemented through #IndexerCallbacks. |
| /// |
| /// \param client_data pointer data supplied by the client, which will |
| /// be passed to the invoked callbacks. |
| /// |
| /// \param index_callbacks Pointer to indexing callbacks that the client |
| /// implements. |
| /// |
| /// \param index_callbacks_size Size of #IndexerCallbacks structure that gets |
| /// passed in index_callbacks. |
| /// |
| /// \param index_options A bitmask of options that affects how indexing is |
| /// performed. This should be a bitwise OR of the CXIndexOpt_XXX flags. |
| /// |
| /// \param[out] out_TU pointer to store a \c CXTranslationUnit that can be |
| /// reused after indexing is finished. Set to \c NULL if you do not require it. |
| /// |
| /// \returns 0 on success or if there were errors from which the compiler could |
| /// recover. If there is a failure from which there is no recovery, returns |
| /// a non-zero \c CXErrorCode. |
| /// |
| /// The rest of the parameters are the same as #clang_parseTranslationUnit. |
| int clang_indexSourceFile( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Void> client_data, |
| ffi.Pointer<IndexerCallbacks> index_callbacks, |
| int index_callbacks_size, |
| int index_options, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| int TU_options, |
| ) { |
| return _clang_indexSourceFile( |
| arg0, |
| client_data, |
| index_callbacks, |
| index_callbacks_size, |
| index_options, |
| source_filename, |
| command_line_args, |
| num_command_line_args, |
| unsaved_files, |
| num_unsaved_files, |
| out_TU, |
| TU_options, |
| ); |
| } |
| |
| final _dart_clang_indexSourceFile _clang_indexSourceFile = _dylib |
| .lookupFunction<_c_clang_indexSourceFile, _dart_clang_indexSourceFile>( |
| 'clang_indexSourceFile'); |
| |
| typedef _c_clang_indexSourceFile = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Void> client_data, |
| ffi.Pointer<IndexerCallbacks> index_callbacks, |
| ffi.Uint32 index_callbacks_size, |
| ffi.Uint32 index_options, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| ffi.Int32 num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| ffi.Uint32 num_unsaved_files, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ffi.Uint32 TU_options, |
| ); |
| |
| typedef _dart_clang_indexSourceFile = int Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Void> client_data, |
| ffi.Pointer<IndexerCallbacks> index_callbacks, |
| int index_callbacks_size, |
| int index_options, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| int TU_options, |
| ); |
| |
| /// Same as clang_indexSourceFile but requires a full command line |
| /// for \c command_line_args including argv[0]. This is useful if the standard |
| /// library paths are relative to the binary. |
| int clang_indexSourceFileFullArgv( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Void> client_data, |
| ffi.Pointer<IndexerCallbacks> index_callbacks, |
| int index_callbacks_size, |
| int index_options, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| int TU_options, |
| ) { |
| return _clang_indexSourceFileFullArgv( |
| arg0, |
| client_data, |
| index_callbacks, |
| index_callbacks_size, |
| index_options, |
| source_filename, |
| command_line_args, |
| num_command_line_args, |
| unsaved_files, |
| num_unsaved_files, |
| out_TU, |
| TU_options, |
| ); |
| } |
| |
| final _dart_clang_indexSourceFileFullArgv _clang_indexSourceFileFullArgv = |
| _dylib.lookupFunction<_c_clang_indexSourceFileFullArgv, |
| _dart_clang_indexSourceFileFullArgv>('clang_indexSourceFileFullArgv'); |
| |
| typedef _c_clang_indexSourceFileFullArgv = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Void> client_data, |
| ffi.Pointer<IndexerCallbacks> index_callbacks, |
| ffi.Uint32 index_callbacks_size, |
| ffi.Uint32 index_options, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| ffi.Int32 num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| ffi.Uint32 num_unsaved_files, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ffi.Uint32 TU_options, |
| ); |
| |
| typedef _dart_clang_indexSourceFileFullArgv = int Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Void> client_data, |
| ffi.Pointer<IndexerCallbacks> index_callbacks, |
| int index_callbacks_size, |
| int index_options, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| int TU_options, |
| ); |
| |
| /// Index the given translation unit via callbacks implemented through |
| /// #IndexerCallbacks. |
| /// |
| /// The order of callback invocations is not guaranteed to be the same as |
| /// when indexing a source file. The high level order will be: |
| /// |
| /// -Preprocessor callbacks invocations |
| /// -Declaration/reference callbacks invocations |
| /// -Diagnostic callback invocations |
| /// |
| /// The parameters are the same as #clang_indexSourceFile. |
| /// |
| /// \returns If there is a failure from which there is no recovery, returns |
| /// non-zero, otherwise returns 0. |
| int clang_indexTranslationUnit( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Void> client_data, |
| ffi.Pointer<IndexerCallbacks> index_callbacks, |
| int index_callbacks_size, |
| int index_options, |
| ffi.Pointer<CXTranslationUnitImpl> arg5, |
| ) { |
| return _clang_indexTranslationUnit( |
| arg0, |
| client_data, |
| index_callbacks, |
| index_callbacks_size, |
| index_options, |
| arg5, |
| ); |
| } |
| |
| final _dart_clang_indexTranslationUnit _clang_indexTranslationUnit = |
| _dylib.lookupFunction<_c_clang_indexTranslationUnit, |
| _dart_clang_indexTranslationUnit>('clang_indexTranslationUnit'); |
| |
| typedef _c_clang_indexTranslationUnit = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Void> client_data, |
| ffi.Pointer<IndexerCallbacks> index_callbacks, |
| ffi.Uint32 index_callbacks_size, |
| ffi.Uint32 index_options, |
| ffi.Pointer<CXTranslationUnitImpl> arg5, |
| ); |
| |
| typedef _dart_clang_indexTranslationUnit = int Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Pointer<ffi.Void> client_data, |
| ffi.Pointer<IndexerCallbacks> index_callbacks, |
| int index_callbacks_size, |
| int index_options, |
| ffi.Pointer<CXTranslationUnitImpl> arg5, |
| ); |
| |
| ffi.Pointer<CXIdxCXXClassDeclInfo> clang_index_getCXXClassDeclInfo( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ) { |
| return _clang_index_getCXXClassDeclInfo( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_index_getCXXClassDeclInfo _clang_index_getCXXClassDeclInfo = |
| _dylib.lookupFunction<_c_clang_index_getCXXClassDeclInfo, |
| _dart_clang_index_getCXXClassDeclInfo>( |
| 'clang_index_getCXXClassDeclInfo'); |
| |
| typedef _c_clang_index_getCXXClassDeclInfo = ffi.Pointer<CXIdxCXXClassDeclInfo> |
| Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| typedef _dart_clang_index_getCXXClassDeclInfo |
| = ffi.Pointer<CXIdxCXXClassDeclInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| /// For retrieving a custom CXIdxClientContainer attached to a |
| /// container. |
| ffi.Pointer<ffi.Void> clang_index_getClientContainer( |
| ffi.Pointer<CXIdxContainerInfo> arg0, |
| ) { |
| return _clang_index_getClientContainer( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_index_getClientContainer _clang_index_getClientContainer = |
| _dylib.lookupFunction<_c_clang_index_getClientContainer, |
| _dart_clang_index_getClientContainer>('clang_index_getClientContainer'); |
| |
| typedef _c_clang_index_getClientContainer = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXIdxContainerInfo> arg0, |
| ); |
| |
| typedef _dart_clang_index_getClientContainer = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXIdxContainerInfo> arg0, |
| ); |
| |
| /// For retrieving a custom CXIdxClientEntity attached to an entity. |
| ffi.Pointer<ffi.Void> clang_index_getClientEntity( |
| ffi.Pointer<CXIdxEntityInfo> arg0, |
| ) { |
| return _clang_index_getClientEntity( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_index_getClientEntity _clang_index_getClientEntity = |
| _dylib.lookupFunction<_c_clang_index_getClientEntity, |
| _dart_clang_index_getClientEntity>('clang_index_getClientEntity'); |
| |
| typedef _c_clang_index_getClientEntity = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXIdxEntityInfo> arg0, |
| ); |
| |
| typedef _dart_clang_index_getClientEntity = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<CXIdxEntityInfo> arg0, |
| ); |
| |
| ffi.Pointer<CXIdxIBOutletCollectionAttrInfo> |
| clang_index_getIBOutletCollectionAttrInfo( |
| ffi.Pointer<CXIdxAttrInfo> arg0, |
| ) { |
| return _clang_index_getIBOutletCollectionAttrInfo( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_index_getIBOutletCollectionAttrInfo |
| _clang_index_getIBOutletCollectionAttrInfo = _dylib.lookupFunction< |
| _c_clang_index_getIBOutletCollectionAttrInfo, |
| _dart_clang_index_getIBOutletCollectionAttrInfo>( |
| 'clang_index_getIBOutletCollectionAttrInfo'); |
| |
| typedef _c_clang_index_getIBOutletCollectionAttrInfo |
| = ffi.Pointer<CXIdxIBOutletCollectionAttrInfo> Function( |
| ffi.Pointer<CXIdxAttrInfo> arg0, |
| ); |
| |
| typedef _dart_clang_index_getIBOutletCollectionAttrInfo |
| = ffi.Pointer<CXIdxIBOutletCollectionAttrInfo> Function( |
| ffi.Pointer<CXIdxAttrInfo> arg0, |
| ); |
| |
| ffi.Pointer<CXIdxObjCCategoryDeclInfo> clang_index_getObjCCategoryDeclInfo( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ) { |
| return _clang_index_getObjCCategoryDeclInfo( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_index_getObjCCategoryDeclInfo |
| _clang_index_getObjCCategoryDeclInfo = _dylib.lookupFunction< |
| _c_clang_index_getObjCCategoryDeclInfo, |
| _dart_clang_index_getObjCCategoryDeclInfo>( |
| 'clang_index_getObjCCategoryDeclInfo'); |
| |
| typedef _c_clang_index_getObjCCategoryDeclInfo |
| = ffi.Pointer<CXIdxObjCCategoryDeclInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| typedef _dart_clang_index_getObjCCategoryDeclInfo |
| = ffi.Pointer<CXIdxObjCCategoryDeclInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| ffi.Pointer<CXIdxObjCContainerDeclInfo> clang_index_getObjCContainerDeclInfo( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ) { |
| return _clang_index_getObjCContainerDeclInfo( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_index_getObjCContainerDeclInfo |
| _clang_index_getObjCContainerDeclInfo = _dylib.lookupFunction< |
| _c_clang_index_getObjCContainerDeclInfo, |
| _dart_clang_index_getObjCContainerDeclInfo>( |
| 'clang_index_getObjCContainerDeclInfo'); |
| |
| typedef _c_clang_index_getObjCContainerDeclInfo |
| = ffi.Pointer<CXIdxObjCContainerDeclInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| typedef _dart_clang_index_getObjCContainerDeclInfo |
| = ffi.Pointer<CXIdxObjCContainerDeclInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| ffi.Pointer<CXIdxObjCInterfaceDeclInfo> clang_index_getObjCInterfaceDeclInfo( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ) { |
| return _clang_index_getObjCInterfaceDeclInfo( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_index_getObjCInterfaceDeclInfo |
| _clang_index_getObjCInterfaceDeclInfo = _dylib.lookupFunction< |
| _c_clang_index_getObjCInterfaceDeclInfo, |
| _dart_clang_index_getObjCInterfaceDeclInfo>( |
| 'clang_index_getObjCInterfaceDeclInfo'); |
| |
| typedef _c_clang_index_getObjCInterfaceDeclInfo |
| = ffi.Pointer<CXIdxObjCInterfaceDeclInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| typedef _dart_clang_index_getObjCInterfaceDeclInfo |
| = ffi.Pointer<CXIdxObjCInterfaceDeclInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| ffi.Pointer<CXIdxObjCPropertyDeclInfo> clang_index_getObjCPropertyDeclInfo( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ) { |
| return _clang_index_getObjCPropertyDeclInfo( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_index_getObjCPropertyDeclInfo |
| _clang_index_getObjCPropertyDeclInfo = _dylib.lookupFunction< |
| _c_clang_index_getObjCPropertyDeclInfo, |
| _dart_clang_index_getObjCPropertyDeclInfo>( |
| 'clang_index_getObjCPropertyDeclInfo'); |
| |
| typedef _c_clang_index_getObjCPropertyDeclInfo |
| = ffi.Pointer<CXIdxObjCPropertyDeclInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| typedef _dart_clang_index_getObjCPropertyDeclInfo |
| = ffi.Pointer<CXIdxObjCPropertyDeclInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| ffi.Pointer<CXIdxObjCProtocolRefListInfo> |
| clang_index_getObjCProtocolRefListInfo( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ) { |
| return _clang_index_getObjCProtocolRefListInfo( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_index_getObjCProtocolRefListInfo |
| _clang_index_getObjCProtocolRefListInfo = _dylib.lookupFunction< |
| _c_clang_index_getObjCProtocolRefListInfo, |
| _dart_clang_index_getObjCProtocolRefListInfo>( |
| 'clang_index_getObjCProtocolRefListInfo'); |
| |
| typedef _c_clang_index_getObjCProtocolRefListInfo |
| = ffi.Pointer<CXIdxObjCProtocolRefListInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| typedef _dart_clang_index_getObjCProtocolRefListInfo |
| = ffi.Pointer<CXIdxObjCProtocolRefListInfo> Function( |
| ffi.Pointer<CXIdxDeclInfo> arg0, |
| ); |
| |
| int clang_index_isEntityObjCContainerKind( |
| int arg0, |
| ) { |
| return _clang_index_isEntityObjCContainerKind( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_index_isEntityObjCContainerKind |
| _clang_index_isEntityObjCContainerKind = _dylib.lookupFunction< |
| _c_clang_index_isEntityObjCContainerKind, |
| _dart_clang_index_isEntityObjCContainerKind>( |
| 'clang_index_isEntityObjCContainerKind'); |
| |
| typedef _c_clang_index_isEntityObjCContainerKind = ffi.Int32 Function( |
| ffi.Int32 arg0, |
| ); |
| |
| typedef _dart_clang_index_isEntityObjCContainerKind = int Function( |
| int arg0, |
| ); |
| |
| /// For setting a custom CXIdxClientContainer attached to a |
| /// container. |
| void clang_index_setClientContainer( |
| ffi.Pointer<CXIdxContainerInfo> arg0, |
| ffi.Pointer<ffi.Void> arg1, |
| ) { |
| return _clang_index_setClientContainer( |
| arg0, |
| arg1, |
| ); |
| } |
| |
| final _dart_clang_index_setClientContainer _clang_index_setClientContainer = |
| _dylib.lookupFunction<_c_clang_index_setClientContainer, |
| _dart_clang_index_setClientContainer>('clang_index_setClientContainer'); |
| |
| typedef _c_clang_index_setClientContainer = ffi.Void Function( |
| ffi.Pointer<CXIdxContainerInfo> arg0, |
| ffi.Pointer<ffi.Void> arg1, |
| ); |
| |
| typedef _dart_clang_index_setClientContainer = void Function( |
| ffi.Pointer<CXIdxContainerInfo> arg0, |
| ffi.Pointer<ffi.Void> arg1, |
| ); |
| |
| /// For setting a custom CXIdxClientEntity attached to an entity. |
| void clang_index_setClientEntity( |
| ffi.Pointer<CXIdxEntityInfo> arg0, |
| ffi.Pointer<ffi.Void> arg1, |
| ) { |
| return _clang_index_setClientEntity( |
| arg0, |
| arg1, |
| ); |
| } |
| |
| final _dart_clang_index_setClientEntity _clang_index_setClientEntity = |
| _dylib.lookupFunction<_c_clang_index_setClientEntity, |
| _dart_clang_index_setClientEntity>('clang_index_setClientEntity'); |
| |
| typedef _c_clang_index_setClientEntity = ffi.Void Function( |
| ffi.Pointer<CXIdxEntityInfo> arg0, |
| ffi.Pointer<ffi.Void> arg1, |
| ); |
| |
| typedef _dart_clang_index_setClientEntity = void Function( |
| ffi.Pointer<CXIdxEntityInfo> arg0, |
| ffi.Pointer<ffi.Void> arg1, |
| ); |
| |
| /// Determine whether the given cursor kind represents an attribute. |
| int clang_isAttribute( |
| int arg0, |
| ) { |
| return _clang_isAttribute( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_isAttribute _clang_isAttribute = |
| _dylib.lookupFunction<_c_clang_isAttribute, _dart_clang_isAttribute>( |
| 'clang_isAttribute'); |
| |
| typedef _c_clang_isAttribute = ffi.Uint32 Function( |
| ffi.Int32 arg0, |
| ); |
| |
| typedef _dart_clang_isAttribute = int Function( |
| int arg0, |
| ); |
| |
| /// Determine whether the given cursor kind represents a declaration. |
| int clang_isDeclaration( |
| int arg0, |
| ) { |
| return _clang_isDeclaration( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_isDeclaration _clang_isDeclaration = |
| _dylib.lookupFunction<_c_clang_isDeclaration, _dart_clang_isDeclaration>( |
| 'clang_isDeclaration'); |
| |
| typedef _c_clang_isDeclaration = ffi.Uint32 Function( |
| ffi.Int32 arg0, |
| ); |
| |
| typedef _dart_clang_isDeclaration = int Function( |
| int arg0, |
| ); |
| |
| /// Determine whether the given cursor kind represents an expression. |
| int clang_isExpression( |
| int arg0, |
| ) { |
| return _clang_isExpression( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_isExpression _clang_isExpression = |
| _dylib.lookupFunction<_c_clang_isExpression, _dart_clang_isExpression>( |
| 'clang_isExpression'); |
| |
| typedef _c_clang_isExpression = ffi.Uint32 Function( |
| ffi.Int32 arg0, |
| ); |
| |
| typedef _dart_clang_isExpression = int Function( |
| int arg0, |
| ); |
| |
| /// Determine whether the given header is guarded against |
| /// multiple inclusions, either with the conventional |
| /// \#ifndef/\#define/\#endif macro guards or with \#pragma once. |
| int clang_isFileMultipleIncludeGuarded( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Void> file, |
| ) { |
| return _clang_isFileMultipleIncludeGuarded( |
| tu, |
| file, |
| ); |
| } |
| |
| final _dart_clang_isFileMultipleIncludeGuarded |
| _clang_isFileMultipleIncludeGuarded = _dylib.lookupFunction< |
| _c_clang_isFileMultipleIncludeGuarded, |
| _dart_clang_isFileMultipleIncludeGuarded>( |
| 'clang_isFileMultipleIncludeGuarded'); |
| |
| typedef _c_clang_isFileMultipleIncludeGuarded = ffi.Uint32 Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Void> file, |
| ); |
| |
| typedef _dart_clang_isFileMultipleIncludeGuarded = int Function( |
| ffi.Pointer<CXTranslationUnitImpl> tu, |
| ffi.Pointer<ffi.Void> file, |
| ); |
| |
| /// Determine whether the given cursor kind represents an invalid |
| /// cursor. |
| int clang_isInvalid( |
| int arg0, |
| ) { |
| return _clang_isInvalid( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_isInvalid _clang_isInvalid = |
| _dylib.lookupFunction<_c_clang_isInvalid, _dart_clang_isInvalid>( |
| 'clang_isInvalid'); |
| |
| typedef _c_clang_isInvalid = ffi.Uint32 Function( |
| ffi.Int32 arg0, |
| ); |
| |
| typedef _dart_clang_isInvalid = int Function( |
| int arg0, |
| ); |
| |
| /// Determine whether the given cursor represents a preprocessing |
| /// element, such as a preprocessor directive or macro instantiation. |
| int clang_isPreprocessing( |
| int arg0, |
| ) { |
| return _clang_isPreprocessing( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_isPreprocessing _clang_isPreprocessing = _dylib |
| .lookupFunction<_c_clang_isPreprocessing, _dart_clang_isPreprocessing>( |
| 'clang_isPreprocessing'); |
| |
| typedef _c_clang_isPreprocessing = ffi.Uint32 Function( |
| ffi.Int32 arg0, |
| ); |
| |
| typedef _dart_clang_isPreprocessing = int Function( |
| int arg0, |
| ); |
| |
| /// Determine whether the given cursor kind represents a simple |
| /// reference. |
| /// |
| /// Note that other kinds of cursors (such as expressions) can also refer to |
| /// other cursors. Use clang_getCursorReferenced() to determine whether a |
| /// particular cursor refers to another entity. |
| int clang_isReference( |
| int arg0, |
| ) { |
| return _clang_isReference( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_isReference _clang_isReference = |
| _dylib.lookupFunction<_c_clang_isReference, _dart_clang_isReference>( |
| 'clang_isReference'); |
| |
| typedef _c_clang_isReference = ffi.Uint32 Function( |
| ffi.Int32 arg0, |
| ); |
| |
| typedef _dart_clang_isReference = int Function( |
| int arg0, |
| ); |
| |
| /// Determine whether the given cursor kind represents a statement. |
| int clang_isStatement( |
| int arg0, |
| ) { |
| return _clang_isStatement( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_isStatement _clang_isStatement = |
| _dylib.lookupFunction<_c_clang_isStatement, _dart_clang_isStatement>( |
| 'clang_isStatement'); |
| |
| typedef _c_clang_isStatement = ffi.Uint32 Function( |
| ffi.Int32 arg0, |
| ); |
| |
| typedef _dart_clang_isStatement = int Function( |
| int arg0, |
| ); |
| |
| /// Determine whether the given cursor kind represents a translation |
| /// unit. |
| int clang_isTranslationUnit( |
| int arg0, |
| ) { |
| return _clang_isTranslationUnit( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_isTranslationUnit _clang_isTranslationUnit = _dylib |
| .lookupFunction<_c_clang_isTranslationUnit, _dart_clang_isTranslationUnit>( |
| 'clang_isTranslationUnit'); |
| |
| typedef _c_clang_isTranslationUnit = ffi.Uint32 Function( |
| ffi.Int32 arg0, |
| ); |
| |
| typedef _dart_clang_isTranslationUnit = int Function( |
| int arg0, |
| ); |
| |
| /// Determine whether the given cursor represents a currently |
| /// unexposed piece of the AST (e.g., CXCursor_UnexposedStmt). |
| int clang_isUnexposed( |
| int arg0, |
| ) { |
| return _clang_isUnexposed( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_isUnexposed _clang_isUnexposed = |
| _dylib.lookupFunction<_c_clang_isUnexposed, _dart_clang_isUnexposed>( |
| 'clang_isUnexposed'); |
| |
| typedef _c_clang_isUnexposed = ffi.Uint32 Function( |
| ffi.Int32 arg0, |
| ); |
| |
| typedef _dart_clang_isUnexposed = int Function( |
| int arg0, |
| ); |
| |
| /// Deserialize a set of diagnostics from a Clang diagnostics bitcode |
| /// file. |
| /// |
| /// \param file The name of the file to deserialize. |
| /// \param error A pointer to a enum value recording if there was a problem |
| /// deserializing the diagnostics. |
| /// \param errorString A pointer to a CXString for recording the error string |
| /// if the file was not successfully loaded. |
| /// |
| /// \returns A loaded CXDiagnosticSet if successful, and NULL otherwise. These |
| /// diagnostics should be released using clang_disposeDiagnosticSet(). |
| ffi.Pointer<ffi.Void> clang_loadDiagnostics( |
| ffi.Pointer<ffi.Int8> file, |
| ffi.Pointer<ffi.Int32> error, |
| ffi.Pointer<CXString> errorString, |
| ) { |
| return _clang_loadDiagnostics( |
| file, |
| error, |
| errorString, |
| ); |
| } |
| |
| final _dart_clang_loadDiagnostics _clang_loadDiagnostics = _dylib |
| .lookupFunction<_c_clang_loadDiagnostics, _dart_clang_loadDiagnostics>( |
| 'clang_loadDiagnostics'); |
| |
| typedef _c_clang_loadDiagnostics = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Int8> file, |
| ffi.Pointer<ffi.Int32> error, |
| ffi.Pointer<CXString> errorString, |
| ); |
| |
| typedef _dart_clang_loadDiagnostics = ffi.Pointer<ffi.Void> Function( |
| ffi.Pointer<ffi.Int8> file, |
| ffi.Pointer<ffi.Int32> error, |
| ffi.Pointer<CXString> errorString, |
| ); |
| |
| /// Same as \c clang_parseTranslationUnit2, but returns |
| /// the \c CXTranslationUnit instead of an error code. In case of an error this |
| /// routine returns a \c NULL \c CXTranslationUnit, without further detailed |
| /// error codes. |
| ffi.Pointer<CXTranslationUnitImpl> clang_parseTranslationUnit( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| int options, |
| ) { |
| return _clang_parseTranslationUnit( |
| CIdx, |
| source_filename, |
| command_line_args, |
| num_command_line_args, |
| unsaved_files, |
| num_unsaved_files, |
| options, |
| ); |
| } |
| |
| final _dart_clang_parseTranslationUnit _clang_parseTranslationUnit = |
| _dylib.lookupFunction<_c_clang_parseTranslationUnit, |
| _dart_clang_parseTranslationUnit>('clang_parseTranslationUnit'); |
| |
| typedef _c_clang_parseTranslationUnit = ffi.Pointer<CXTranslationUnitImpl> |
| Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| ffi.Int32 num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| ffi.Uint32 num_unsaved_files, |
| ffi.Uint32 options, |
| ); |
| |
| typedef _dart_clang_parseTranslationUnit = ffi.Pointer<CXTranslationUnitImpl> |
| Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| int options, |
| ); |
| |
| /// Parse the given source file and the translation unit corresponding |
| /// to that file. |
| /// |
| /// This routine is the main entry point for the Clang C API, providing the |
| /// ability to parse a source file into a translation unit that can then be |
| /// queried by other functions in the API. This routine accepts a set of |
| /// command-line arguments so that the compilation can be configured in the same |
| /// way that the compiler is configured on the command line. |
| /// |
| /// \param CIdx The index object with which the translation unit will be |
| /// associated. |
| /// |
| /// \param source_filename The name of the source file to load, or NULL if the |
| /// source file is included in \c command_line_args. |
| /// |
| /// \param command_line_args The command-line arguments that would be |
| /// passed to the \c clang executable if it were being invoked out-of-process. |
| /// These command-line options will be parsed and will affect how the translation |
| /// unit is parsed. Note that the following options are ignored: '-c', |
| /// '-emit-ast', '-fsyntax-only' (which is the default), and '-o \<output file>'. |
| /// |
| /// \param num_command_line_args The number of command-line arguments in |
| /// \c command_line_args. |
| /// |
| /// \param unsaved_files the files that have not yet been saved to disk |
| /// but may be required for parsing, including the contents of |
| /// those files. The contents and name of these files (as specified by |
| /// CXUnsavedFile) are copied when necessary, so the client only needs to |
| /// guarantee their validity until the call to this function returns. |
| /// |
| /// \param num_unsaved_files the number of unsaved file entries in \p |
| /// unsaved_files. |
| /// |
| /// \param options A bitmask of options that affects how the translation unit |
| /// is managed but not its compilation. This should be a bitwise OR of the |
| /// CXTranslationUnit_XXX flags. |
| /// |
| /// \param[out] out_TU A non-NULL pointer to store the created |
| /// \c CXTranslationUnit, describing the parsed code and containing any |
| /// diagnostics produced by the compiler. |
| /// |
| /// \returns Zero on success, otherwise returns an error code. |
| int clang_parseTranslationUnit2( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| int options, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ) { |
| return _clang_parseTranslationUnit2( |
| CIdx, |
| source_filename, |
| command_line_args, |
| num_command_line_args, |
| unsaved_files, |
| num_unsaved_files, |
| options, |
| out_TU, |
| ); |
| } |
| |
| final _dart_clang_parseTranslationUnit2 _clang_parseTranslationUnit2 = |
| _dylib.lookupFunction<_c_clang_parseTranslationUnit2, |
| _dart_clang_parseTranslationUnit2>('clang_parseTranslationUnit2'); |
| |
| typedef _c_clang_parseTranslationUnit2 = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| ffi.Int32 num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| ffi.Uint32 num_unsaved_files, |
| ffi.Uint32 options, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ); |
| |
| typedef _dart_clang_parseTranslationUnit2 = int Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| int options, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ); |
| |
| /// Same as clang_parseTranslationUnit2 but requires a full command line |
| /// for \c command_line_args including argv[0]. This is useful if the standard |
| /// library paths are relative to the binary. |
| int clang_parseTranslationUnit2FullArgv( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| int options, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ) { |
| return _clang_parseTranslationUnit2FullArgv( |
| CIdx, |
| source_filename, |
| command_line_args, |
| num_command_line_args, |
| unsaved_files, |
| num_unsaved_files, |
| options, |
| out_TU, |
| ); |
| } |
| |
| final _dart_clang_parseTranslationUnit2FullArgv |
| _clang_parseTranslationUnit2FullArgv = _dylib.lookupFunction< |
| _c_clang_parseTranslationUnit2FullArgv, |
| _dart_clang_parseTranslationUnit2FullArgv>( |
| 'clang_parseTranslationUnit2FullArgv'); |
| |
| typedef _c_clang_parseTranslationUnit2FullArgv = ffi.Int32 Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| ffi.Int32 num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| ffi.Uint32 num_unsaved_files, |
| ffi.Uint32 options, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ); |
| |
| typedef _dart_clang_parseTranslationUnit2FullArgv = int Function( |
| ffi.Pointer<ffi.Void> CIdx, |
| ffi.Pointer<ffi.Int8> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| int options, |
| ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU, |
| ); |
| |
| /// Dispose the remapping. |
| void clang_remap_dispose( |
| ffi.Pointer<ffi.Void> arg0, |
| ) { |
| return _clang_remap_dispose( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_remap_dispose _clang_remap_dispose = |
| _dylib.lookupFunction<_c_clang_remap_dispose, _dart_clang_remap_dispose>( |
| 'clang_remap_dispose'); |
| |
| typedef _c_clang_remap_dispose = ffi.Void Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| typedef _dart_clang_remap_dispose = void Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| /// Get the original and the associated filename from the remapping. |
| /// |
| /// \param original If non-NULL, will be set to the original filename. |
| /// |
| /// \param transformed If non-NULL, will be set to the filename that the original |
| /// is associated with. |
| void clang_remap_getFilenames( |
| ffi.Pointer<ffi.Void> arg0, |
| int index, |
| ffi.Pointer<CXString> original, |
| ffi.Pointer<CXString> transformed, |
| ) { |
| return _clang_remap_getFilenames( |
| arg0, |
| index, |
| original, |
| transformed, |
| ); |
| } |
| |
| final _dart_clang_remap_getFilenames _clang_remap_getFilenames = |
| _dylib.lookupFunction<_c_clang_remap_getFilenames, |
| _dart_clang_remap_getFilenames>('clang_remap_getFilenames'); |
| |
| typedef _c_clang_remap_getFilenames = ffi.Void Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ffi.Uint32 index, |
| ffi.Pointer<CXString> original, |
| ffi.Pointer<CXString> transformed, |
| ); |
| |
| typedef _dart_clang_remap_getFilenames = void Function( |
| ffi.Pointer<ffi.Void> arg0, |
| int index, |
| ffi.Pointer<CXString> original, |
| ffi.Pointer<CXString> transformed, |
| ); |
| |
| /// Determine the number of remappings. |
| int clang_remap_getNumFiles( |
| ffi.Pointer<ffi.Void> arg0, |
| ) { |
| return _clang_remap_getNumFiles( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_remap_getNumFiles _clang_remap_getNumFiles = _dylib |
| .lookupFunction<_c_clang_remap_getNumFiles, _dart_clang_remap_getNumFiles>( |
| 'clang_remap_getNumFiles'); |
| |
| typedef _c_clang_remap_getNumFiles = ffi.Uint32 Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| typedef _dart_clang_remap_getNumFiles = int Function( |
| ffi.Pointer<ffi.Void> arg0, |
| ); |
| |
| /// Reparse the source files that produced this translation unit. |
| /// |
| /// This routine can be used to re-parse the source files that originally |
| /// created the given translation unit, for example because those source files |
| /// have changed (either on disk or as passed via \p unsaved_files). The |
| /// source code will be reparsed with the same command-line options as it |
| /// was originally parsed. |
| /// |
| /// Reparsing a translation unit invalidates all cursors and source locations |
| /// that refer into that translation unit. This makes reparsing a translation |
| /// unit semantically equivalent to destroying the translation unit and then |
| /// creating a new translation unit with the same command-line arguments. |
| /// However, it may be more efficient to reparse a translation |
| /// unit using this routine. |
| /// |
| /// \param TU The translation unit whose contents will be re-parsed. The |
| /// translation unit must originally have been built with |
| /// \c clang_createTranslationUnitFromSourceFile(). |
| /// |
| /// \param num_unsaved_files The number of unsaved file entries in \p |
| /// unsaved_files. |
| /// |
| /// \param unsaved_files The files that have not yet been saved to disk |
| /// but may be required for parsing, including the contents of |
| /// those files. The contents and name of these files (as specified by |
| /// CXUnsavedFile) are copied when necessary, so the client only needs to |
| /// guarantee their validity until the call to this function returns. |
| /// |
| /// \param options A bitset of options composed of the flags in CXReparse_Flags. |
| /// The function \c clang_defaultReparseOptions() produces a default set of |
| /// options recommended for most uses, based on the translation unit. |
| /// |
| /// \returns 0 if the sources could be reparsed. A non-zero error code will be |
| /// returned if reparsing was impossible, such that the translation unit is |
| /// invalid. In such cases, the only valid call for \c TU is |
| /// \c clang_disposeTranslationUnit(TU). The error codes returned by this |
| /// routine are described by the \c CXErrorCode enum. |
| int clang_reparseTranslationUnit( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| int num_unsaved_files, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int options, |
| ) { |
| return _clang_reparseTranslationUnit( |
| TU, |
| num_unsaved_files, |
| unsaved_files, |
| options, |
| ); |
| } |
| |
| final _dart_clang_reparseTranslationUnit _clang_reparseTranslationUnit = |
| _dylib.lookupFunction<_c_clang_reparseTranslationUnit, |
| _dart_clang_reparseTranslationUnit>('clang_reparseTranslationUnit'); |
| |
| typedef _c_clang_reparseTranslationUnit = ffi.Int32 Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Uint32 num_unsaved_files, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| ffi.Uint32 options, |
| ); |
| |
| typedef _dart_clang_reparseTranslationUnit = int Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| int num_unsaved_files, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int options, |
| ); |
| |
| /// Saves a translation unit into a serialized representation of |
| /// that translation unit on disk. |
| /// |
| /// Any translation unit that was parsed without error can be saved |
| /// into a file. The translation unit can then be deserialized into a |
| /// new \c CXTranslationUnit with \c clang_createTranslationUnit() or, |
| /// if it is an incomplete translation unit that corresponds to a |
| /// header, used as a precompiled header when parsing other translation |
| /// units. |
| /// |
| /// \param TU The translation unit to save. |
| /// |
| /// \param FileName The file to which the translation unit will be saved. |
| /// |
| /// \param options A bitmask of options that affects how the translation unit |
| /// is saved. This should be a bitwise OR of the |
| /// CXSaveTranslationUnit_XXX flags. |
| /// |
| /// \returns A value that will match one of the enumerators of the CXSaveError |
| /// enumeration. Zero (CXSaveError_None) indicates that the translation unit was |
| /// saved successfully, while a non-zero value indicates that a problem occurred. |
| int clang_saveTranslationUnit( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<ffi.Int8> FileName, |
| int options, |
| ) { |
| return _clang_saveTranslationUnit( |
| TU, |
| FileName, |
| options, |
| ); |
| } |
| |
| final _dart_clang_saveTranslationUnit _clang_saveTranslationUnit = |
| _dylib.lookupFunction<_c_clang_saveTranslationUnit, |
| _dart_clang_saveTranslationUnit>('clang_saveTranslationUnit'); |
| |
| typedef _c_clang_saveTranslationUnit = ffi.Int32 Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<ffi.Int8> FileName, |
| ffi.Uint32 options, |
| ); |
| |
| typedef _dart_clang_saveTranslationUnit = int Function( |
| ffi.Pointer<CXTranslationUnitImpl> TU, |
| ffi.Pointer<ffi.Int8> FileName, |
| int options, |
| ); |
| |
| /// Sort the code-completion results in case-insensitive alphabetical |
| /// order. |
| /// |
| /// \param Results The set of results to sort. |
| /// \param NumResults The number of results in \p Results. |
| void clang_sortCodeCompletionResults( |
| ffi.Pointer<CXCompletionResult> Results, |
| int NumResults, |
| ) { |
| return _clang_sortCodeCompletionResults( |
| Results, |
| NumResults, |
| ); |
| } |
| |
| final _dart_clang_sortCodeCompletionResults _clang_sortCodeCompletionResults = |
| _dylib.lookupFunction<_c_clang_sortCodeCompletionResults, |
| _dart_clang_sortCodeCompletionResults>( |
| 'clang_sortCodeCompletionResults'); |
| |
| typedef _c_clang_sortCodeCompletionResults = ffi.Void Function( |
| ffi.Pointer<CXCompletionResult> Results, |
| ffi.Uint32 NumResults, |
| ); |
| |
| typedef _dart_clang_sortCodeCompletionResults = void Function( |
| ffi.Pointer<CXCompletionResult> Results, |
| int NumResults, |
| ); |
| |
| /// Suspend a translation unit in order to free memory associated with it. |
| /// |
| /// A suspended translation unit uses significantly less memory but on the other |
| /// side does not support any other calls than \c clang_reparseTranslationUnit |
| /// to resume it or \c clang_disposeTranslationUnit to dispose it completely. |
| int clang_suspendTranslationUnit( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ) { |
| return _clang_suspendTranslationUnit( |
| arg0, |
| ); |
| } |
| |
| final _dart_clang_suspendTranslationUnit _clang_suspendTranslationUnit = |
| _dylib.lookupFunction<_c_clang_suspendTranslationUnit, |
| _dart_clang_suspendTranslationUnit>('clang_suspendTranslationUnit'); |
| |
| typedef _c_clang_suspendTranslationUnit = ffi.Uint32 Function( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ); |
| |
| typedef _dart_clang_suspendTranslationUnit = int Function( |
| ffi.Pointer<CXTranslationUnitImpl> arg0, |
| ); |
| |
| /// Enable/disable crash recovery. |
| /// |
| /// \param isEnabled Flag to indicate if crash recovery is enabled. A non-zero |
| /// value enables crash recovery, while 0 disables it. |
| void clang_toggleCrashRecovery( |
| int isEnabled, |
| ) { |
| return _clang_toggleCrashRecovery( |
| isEnabled, |
| ); |
| } |
| |
| final _dart_clang_toggleCrashRecovery _clang_toggleCrashRecovery = |
| _dylib.lookupFunction<_c_clang_toggleCrashRecovery, |
| _dart_clang_toggleCrashRecovery>('clang_toggleCrashRecovery'); |
| |
| typedef _c_clang_toggleCrashRecovery = ffi.Void Function( |
| ffi.Uint32 isEnabled, |
| ); |
| |
| typedef _dart_clang_toggleCrashRecovery = void Function( |
| int isEnabled, |
| ); |
| |
| typedef ModifiedCXCursorVisitor_1 = ffi.Int32 Function( |
| ffi.Pointer<CXCursor>, |
| ffi.Pointer<CXCursor>, |
| ffi.Pointer<ffi.Void>, |
| ); |
| |
| /// Visitor is a function pointer with parameters having pointers to cxcursor |
| /// instead of cxcursor by default. |
| int clang_visitChildren_wrap( |
| ffi.Pointer<CXCursor> parent, |
| ffi.Pointer<ffi.NativeFunction<ModifiedCXCursorVisitor_1>> _modifiedVisitor, |
| ffi.Pointer<ffi.Void> clientData, |
| ) { |
| return _clang_visitChildren_wrap( |
| parent, |
| _modifiedVisitor, |
| clientData, |
| ); |
| } |
| |
| final _dart_clang_visitChildren_wrap _clang_visitChildren_wrap = |
| _dylib.lookupFunction<_c_clang_visitChildren_wrap, |
| _dart_clang_visitChildren_wrap>('clang_visitChildren_wrap'); |
| |
| typedef _c_clang_visitChildren_wrap = ffi.Uint32 Function( |
| ffi.Pointer<CXCursor> parent, |
| ffi.Pointer<ffi.NativeFunction<ModifiedCXCursorVisitor_1>> _modifiedVisitor, |
| ffi.Pointer<ffi.Void> clientData, |
| ); |
| |
| typedef _dart_clang_visitChildren_wrap = int Function( |
| ffi.Pointer<CXCursor> parent, |
| ffi.Pointer<ffi.NativeFunction<ModifiedCXCursorVisitor_1>> _modifiedVisitor, |
| ffi.Pointer<ffi.Void> clientData, |
| ); |