| // ignore_for_file: camel_case_types, non_constant_identifier_names |
| |
| // AUTO GENERATED FILE, DO NOT EDIT. |
| // |
| // Generated by `package:ffigen`. |
| // ignore_for_file: type=lint |
| import 'dart:ffi' as ffi; |
| |
| /// Bindings to LibClang. |
| class LibClang { |
| /// Holds the symbol lookup function. |
| final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName) |
| _lookup; |
| |
| /// The symbols are looked up in [dynamicLibrary]. |
| LibClang(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup; |
| |
| /// The symbols are looked up with [lookup]. |
| LibClang.fromLookup( |
| ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName) |
| lookup) |
| : _lookup = lookup; |
| |
| /// Retrieve the character data associated with the given string. |
| ffi.Pointer<ffi.Char> clang_getCString( |
| CXString string, |
| ) { |
| return _clang_getCString( |
| string, |
| ); |
| } |
| |
| late final _clang_getCStringPtr = |
| _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(CXString)>>( |
| 'clang_getCString'); |
| late final _clang_getCString = _clang_getCStringPtr |
| .asFunction<ffi.Pointer<ffi.Char> Function(CXString)>(); |
| |
| /// Free the given string. |
| void clang_disposeString( |
| CXString string, |
| ) { |
| return _clang_disposeString( |
| string, |
| ); |
| } |
| |
| late final _clang_disposeStringPtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXString)>>( |
| 'clang_disposeString'); |
| late final _clang_disposeString = |
| _clang_disposeStringPtr.asFunction<void Function(CXString)>(); |
| |
| /// Free the given string set. |
| void clang_disposeStringSet( |
| ffi.Pointer<CXStringSet> set1, |
| ) { |
| return _clang_disposeStringSet( |
| set1, |
| ); |
| } |
| |
| late final _clang_disposeStringSetPtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<CXStringSet>)>>( |
| 'clang_disposeStringSet'); |
| late final _clang_disposeStringSet = _clang_disposeStringSetPtr |
| .asFunction<void Function(ffi.Pointer<CXStringSet>)>(); |
| |
| /// Return the timestamp for use with Clang's -fbuild-session-timestamp= |
| /// option. |
| int clang_getBuildSessionTimestamp() { |
| return _clang_getBuildSessionTimestamp(); |
| } |
| |
| late final _clang_getBuildSessionTimestampPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedLongLong Function()>>( |
| 'clang_getBuildSessionTimestamp'); |
| late final _clang_getBuildSessionTimestamp = |
| _clang_getBuildSessionTimestampPtr.asFunction<int Function()>(); |
| |
| /// Create a CXVirtualFileOverlay object. Must be disposed with |
| /// clang_VirtualFileOverlay_dispose(). |
| CXVirtualFileOverlay clang_VirtualFileOverlay_create( |
| int options, |
| ) { |
| return _clang_VirtualFileOverlay_create( |
| options, |
| ); |
| } |
| |
| late final _clang_VirtualFileOverlay_createPtr = _lookup< |
| ffi.NativeFunction<CXVirtualFileOverlay Function(ffi.UnsignedInt)>>( |
| 'clang_VirtualFileOverlay_create'); |
| late final _clang_VirtualFileOverlay_create = |
| _clang_VirtualFileOverlay_createPtr |
| .asFunction<CXVirtualFileOverlay Function(int)>(); |
| |
| /// Map an absolute virtual file path to an absolute real one. The virtual |
| /// path must be canonicalized (not contain "."/".."). |
| int clang_VirtualFileOverlay_addFileMapping( |
| CXVirtualFileOverlay arg0, |
| ffi.Pointer<ffi.Char> virtualPath, |
| ffi.Pointer<ffi.Char> realPath, |
| ) { |
| return _clang_VirtualFileOverlay_addFileMapping( |
| arg0, |
| virtualPath, |
| realPath, |
| ); |
| } |
| |
| late final _clang_VirtualFileOverlay_addFileMappingPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int32 Function(CXVirtualFileOverlay, ffi.Pointer<ffi.Char>, |
| ffi.Pointer<ffi.Char>)>>( |
| 'clang_VirtualFileOverlay_addFileMapping'); |
| late final _clang_VirtualFileOverlay_addFileMapping = |
| _clang_VirtualFileOverlay_addFileMappingPtr.asFunction< |
| int Function(CXVirtualFileOverlay, ffi.Pointer<ffi.Char>, |
| ffi.Pointer<ffi.Char>)>(); |
| |
| /// Set the case sensitivity for the CXVirtualFileOverlay object. The |
| /// CXVirtualFileOverlay object is case-sensitive by default, this option can |
| /// be used to override the default. |
| int clang_VirtualFileOverlay_setCaseSensitivity( |
| CXVirtualFileOverlay arg0, |
| int caseSensitive, |
| ) { |
| return _clang_VirtualFileOverlay_setCaseSensitivity( |
| arg0, |
| caseSensitive, |
| ); |
| } |
| |
| late final _clang_VirtualFileOverlay_setCaseSensitivityPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int32 Function(CXVirtualFileOverlay, |
| ffi.Int)>>('clang_VirtualFileOverlay_setCaseSensitivity'); |
| late final _clang_VirtualFileOverlay_setCaseSensitivity = |
| _clang_VirtualFileOverlay_setCaseSensitivityPtr |
| .asFunction<int Function(CXVirtualFileOverlay, int)>(); |
| |
| /// Write out the CXVirtualFileOverlay object to a char buffer. |
| int clang_VirtualFileOverlay_writeToBuffer( |
| CXVirtualFileOverlay arg0, |
| int options, |
| ffi.Pointer<ffi.Pointer<ffi.Char>> out_buffer_ptr, |
| ffi.Pointer<ffi.UnsignedInt> out_buffer_size, |
| ) { |
| return _clang_VirtualFileOverlay_writeToBuffer( |
| arg0, |
| options, |
| out_buffer_ptr, |
| out_buffer_size, |
| ); |
| } |
| |
| late final _clang_VirtualFileOverlay_writeToBufferPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int32 Function( |
| CXVirtualFileOverlay, |
| ffi.UnsignedInt, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| ffi.Pointer<ffi.UnsignedInt>)>>( |
| 'clang_VirtualFileOverlay_writeToBuffer'); |
| late final _clang_VirtualFileOverlay_writeToBuffer = |
| _clang_VirtualFileOverlay_writeToBufferPtr.asFunction< |
| int Function( |
| CXVirtualFileOverlay, |
| int, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| ffi.Pointer<ffi.UnsignedInt>)>(); |
| |
| /// free memory allocated by libclang, such as the buffer returned by |
| /// CXVirtualFileOverlay() or clang_ModuleMapDescriptor_writeToBuffer(). |
| void clang_free( |
| ffi.Pointer<ffi.Void> buffer, |
| ) { |
| return _clang_free( |
| buffer, |
| ); |
| } |
| |
| late final _clang_freePtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>( |
| 'clang_free'); |
| late final _clang_free = |
| _clang_freePtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>(); |
| |
| /// Dispose a CXVirtualFileOverlay object. |
| void clang_VirtualFileOverlay_dispose( |
| CXVirtualFileOverlay arg0, |
| ) { |
| return _clang_VirtualFileOverlay_dispose( |
| arg0, |
| ); |
| } |
| |
| late final _clang_VirtualFileOverlay_disposePtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXVirtualFileOverlay)>>( |
| 'clang_VirtualFileOverlay_dispose'); |
| late final _clang_VirtualFileOverlay_dispose = |
| _clang_VirtualFileOverlay_disposePtr |
| .asFunction<void Function(CXVirtualFileOverlay)>(); |
| |
| /// Create a CXModuleMapDescriptor object. Must be disposed with |
| /// clang_ModuleMapDescriptor_dispose(). |
| CXModuleMapDescriptor clang_ModuleMapDescriptor_create( |
| int options, |
| ) { |
| return _clang_ModuleMapDescriptor_create( |
| options, |
| ); |
| } |
| |
| late final _clang_ModuleMapDescriptor_createPtr = _lookup< |
| ffi.NativeFunction<CXModuleMapDescriptor Function(ffi.UnsignedInt)>>( |
| 'clang_ModuleMapDescriptor_create'); |
| late final _clang_ModuleMapDescriptor_create = |
| _clang_ModuleMapDescriptor_createPtr |
| .asFunction<CXModuleMapDescriptor Function(int)>(); |
| |
| /// Sets the framework module name that the module.map describes. |
| int clang_ModuleMapDescriptor_setFrameworkModuleName( |
| CXModuleMapDescriptor arg0, |
| ffi.Pointer<ffi.Char> name, |
| ) { |
| return _clang_ModuleMapDescriptor_setFrameworkModuleName( |
| arg0, |
| name, |
| ); |
| } |
| |
| late final _clang_ModuleMapDescriptor_setFrameworkModuleNamePtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int32 Function( |
| CXModuleMapDescriptor, ffi.Pointer<ffi.Char>)>>( |
| 'clang_ModuleMapDescriptor_setFrameworkModuleName'); |
| late final _clang_ModuleMapDescriptor_setFrameworkModuleName = |
| _clang_ModuleMapDescriptor_setFrameworkModuleNamePtr.asFunction< |
| int Function(CXModuleMapDescriptor, ffi.Pointer<ffi.Char>)>(); |
| |
| /// Sets the umbrealla header name that the module.map describes. |
| int clang_ModuleMapDescriptor_setUmbrellaHeader( |
| CXModuleMapDescriptor arg0, |
| ffi.Pointer<ffi.Char> name, |
| ) { |
| return _clang_ModuleMapDescriptor_setUmbrellaHeader( |
| arg0, |
| name, |
| ); |
| } |
| |
| late final _clang_ModuleMapDescriptor_setUmbrellaHeaderPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int32 Function( |
| CXModuleMapDescriptor, ffi.Pointer<ffi.Char>)>>( |
| 'clang_ModuleMapDescriptor_setUmbrellaHeader'); |
| late final _clang_ModuleMapDescriptor_setUmbrellaHeader = |
| _clang_ModuleMapDescriptor_setUmbrellaHeaderPtr.asFunction< |
| int Function(CXModuleMapDescriptor, ffi.Pointer<ffi.Char>)>(); |
| |
| /// Write out the CXModuleMapDescriptor object to a char buffer. |
| int clang_ModuleMapDescriptor_writeToBuffer( |
| CXModuleMapDescriptor arg0, |
| int options, |
| ffi.Pointer<ffi.Pointer<ffi.Char>> out_buffer_ptr, |
| ffi.Pointer<ffi.UnsignedInt> out_buffer_size, |
| ) { |
| return _clang_ModuleMapDescriptor_writeToBuffer( |
| arg0, |
| options, |
| out_buffer_ptr, |
| out_buffer_size, |
| ); |
| } |
| |
| late final _clang_ModuleMapDescriptor_writeToBufferPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int32 Function( |
| CXModuleMapDescriptor, |
| ffi.UnsignedInt, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| ffi.Pointer<ffi.UnsignedInt>)>>( |
| 'clang_ModuleMapDescriptor_writeToBuffer'); |
| late final _clang_ModuleMapDescriptor_writeToBuffer = |
| _clang_ModuleMapDescriptor_writeToBufferPtr.asFunction< |
| int Function( |
| CXModuleMapDescriptor, |
| int, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| ffi.Pointer<ffi.UnsignedInt>)>(); |
| |
| /// Dispose a CXModuleMapDescriptor object. |
| void clang_ModuleMapDescriptor_dispose( |
| CXModuleMapDescriptor arg0, |
| ) { |
| return _clang_ModuleMapDescriptor_dispose( |
| arg0, |
| ); |
| } |
| |
| late final _clang_ModuleMapDescriptor_disposePtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXModuleMapDescriptor)>>( |
| 'clang_ModuleMapDescriptor_dispose'); |
| late final _clang_ModuleMapDescriptor_dispose = |
| _clang_ModuleMapDescriptor_disposePtr |
| .asFunction<void Function(CXModuleMapDescriptor)>(); |
| |
| /// Provides a shared context for creating translation units. |
| CXIndex clang_createIndex( |
| int excludeDeclarationsFromPCH, |
| int displayDiagnostics, |
| ) { |
| return _clang_createIndex( |
| excludeDeclarationsFromPCH, |
| displayDiagnostics, |
| ); |
| } |
| |
| late final _clang_createIndexPtr = |
| _lookup<ffi.NativeFunction<CXIndex Function(ffi.Int, ffi.Int)>>( |
| 'clang_createIndex'); |
| late final _clang_createIndex = |
| _clang_createIndexPtr.asFunction<CXIndex Function(int, int)>(); |
| |
| /// Destroy the given index. |
| void clang_disposeIndex( |
| CXIndex index, |
| ) { |
| return _clang_disposeIndex( |
| index, |
| ); |
| } |
| |
| late final _clang_disposeIndexPtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXIndex)>>( |
| 'clang_disposeIndex'); |
| late final _clang_disposeIndex = |
| _clang_disposeIndexPtr.asFunction<void Function(CXIndex)>(); |
| |
| /// Sets general options associated with a CXIndex. |
| void clang_CXIndex_setGlobalOptions( |
| CXIndex arg0, |
| int options, |
| ) { |
| return _clang_CXIndex_setGlobalOptions( |
| arg0, |
| options, |
| ); |
| } |
| |
| late final _clang_CXIndex_setGlobalOptionsPtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXIndex, ffi.UnsignedInt)>>( |
| 'clang_CXIndex_setGlobalOptions'); |
| late final _clang_CXIndex_setGlobalOptions = |
| _clang_CXIndex_setGlobalOptionsPtr |
| .asFunction<void Function(CXIndex, int)>(); |
| |
| /// Gets the general options associated with a CXIndex. |
| int clang_CXIndex_getGlobalOptions( |
| CXIndex arg0, |
| ) { |
| return _clang_CXIndex_getGlobalOptions( |
| arg0, |
| ); |
| } |
| |
| late final _clang_CXIndex_getGlobalOptionsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXIndex)>>( |
| 'clang_CXIndex_getGlobalOptions'); |
| late final _clang_CXIndex_getGlobalOptions = |
| _clang_CXIndex_getGlobalOptionsPtr.asFunction<int Function(CXIndex)>(); |
| |
| /// Sets the invocation emission path option in a CXIndex. |
| void clang_CXIndex_setInvocationEmissionPathOption( |
| CXIndex arg0, |
| ffi.Pointer<ffi.Char> Path, |
| ) { |
| return _clang_CXIndex_setInvocationEmissionPathOption( |
| arg0, |
| Path, |
| ); |
| } |
| |
| late final _clang_CXIndex_setInvocationEmissionPathOptionPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Void Function(CXIndex, ffi.Pointer<ffi.Char>)>>( |
| 'clang_CXIndex_setInvocationEmissionPathOption'); |
| late final _clang_CXIndex_setInvocationEmissionPathOption = |
| _clang_CXIndex_setInvocationEmissionPathOptionPtr |
| .asFunction<void Function(CXIndex, ffi.Pointer<ffi.Char>)>(); |
| |
| /// Retrieve the complete file and path name of the given file. |
| CXString clang_getFileName( |
| CXFile SFile, |
| ) { |
| return _clang_getFileName( |
| SFile, |
| ); |
| } |
| |
| late final _clang_getFileNamePtr = |
| _lookup<ffi.NativeFunction<CXString Function(CXFile)>>( |
| 'clang_getFileName'); |
| late final _clang_getFileName = |
| _clang_getFileNamePtr.asFunction<CXString Function(CXFile)>(); |
| |
| /// Retrieve the last modification time of the given file. |
| int clang_getFileTime( |
| CXFile SFile, |
| ) { |
| return _clang_getFileTime( |
| SFile, |
| ); |
| } |
| |
| late final _clang_getFileTimePtr = |
| _lookup<ffi.NativeFunction<ffi.Int64 Function(CXFile)>>( |
| 'clang_getFileTime'); |
| late final _clang_getFileTime = |
| _clang_getFileTimePtr.asFunction<int Function(CXFile)>(); |
| |
| /// Retrieve the unique ID for the given file. |
| int clang_getFileUniqueID( |
| CXFile file, |
| ffi.Pointer<CXFileUniqueID> outID, |
| ) { |
| return _clang_getFileUniqueID( |
| file, |
| outID, |
| ); |
| } |
| |
| late final _clang_getFileUniqueIDPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int Function( |
| CXFile, ffi.Pointer<CXFileUniqueID>)>>('clang_getFileUniqueID'); |
| late final _clang_getFileUniqueID = _clang_getFileUniqueIDPtr |
| .asFunction<int Function(CXFile, ffi.Pointer<CXFileUniqueID>)>(); |
| |
| /// 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( |
| CXTranslationUnit tu, |
| CXFile file, |
| ) { |
| return _clang_isFileMultipleIncludeGuarded( |
| tu, |
| file, |
| ); |
| } |
| |
| late final _clang_isFileMultipleIncludeGuardedPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.UnsignedInt Function(CXTranslationUnit, |
| CXFile)>>('clang_isFileMultipleIncludeGuarded'); |
| late final _clang_isFileMultipleIncludeGuarded = |
| _clang_isFileMultipleIncludeGuardedPtr |
| .asFunction<int Function(CXTranslationUnit, CXFile)>(); |
| |
| /// Retrieve a file handle within the given translation unit. |
| CXFile clang_getFile( |
| CXTranslationUnit tu, |
| ffi.Pointer<ffi.Char> file_name, |
| ) { |
| return _clang_getFile( |
| tu, |
| file_name, |
| ); |
| } |
| |
| late final _clang_getFilePtr = _lookup< |
| ffi.NativeFunction< |
| CXFile Function( |
| CXTranslationUnit, ffi.Pointer<ffi.Char>)>>('clang_getFile'); |
| late final _clang_getFile = _clang_getFilePtr |
| .asFunction<CXFile Function(CXTranslationUnit, ffi.Pointer<ffi.Char>)>(); |
| |
| /// Retrieve the buffer associated with the given file. |
| ffi.Pointer<ffi.Char> clang_getFileContents( |
| CXTranslationUnit tu, |
| CXFile file, |
| ffi.Pointer<ffi.Size> size, |
| ) { |
| return _clang_getFileContents( |
| tu, |
| file, |
| size, |
| ); |
| } |
| |
| late final _clang_getFileContentsPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Pointer<ffi.Char> Function(CXTranslationUnit, CXFile, |
| ffi.Pointer<ffi.Size>)>>('clang_getFileContents'); |
| late final _clang_getFileContents = _clang_getFileContentsPtr.asFunction< |
| ffi.Pointer<ffi.Char> Function( |
| CXTranslationUnit, CXFile, ffi.Pointer<ffi.Size>)>(); |
| |
| /// Returns non-zero if the file1 and file2 point to the same file, or they |
| /// are both NULL. |
| int clang_File_isEqual( |
| CXFile file1, |
| CXFile file2, |
| ) { |
| return _clang_File_isEqual( |
| file1, |
| file2, |
| ); |
| } |
| |
| late final _clang_File_isEqualPtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXFile, CXFile)>>( |
| 'clang_File_isEqual'); |
| late final _clang_File_isEqual = |
| _clang_File_isEqualPtr.asFunction<int Function(CXFile, CXFile)>(); |
| |
| /// Returns the real path name of file. |
| CXString clang_File_tryGetRealPathName( |
| CXFile file, |
| ) { |
| return _clang_File_tryGetRealPathName( |
| file, |
| ); |
| } |
| |
| late final _clang_File_tryGetRealPathNamePtr = |
| _lookup<ffi.NativeFunction<CXString Function(CXFile)>>( |
| 'clang_File_tryGetRealPathName'); |
| late final _clang_File_tryGetRealPathName = |
| _clang_File_tryGetRealPathNamePtr.asFunction<CXString Function(CXFile)>(); |
| |
| /// Retrieve a NULL (invalid) source location. |
| CXSourceLocation clang_getNullLocation() { |
| return _clang_getNullLocation(); |
| } |
| |
| late final _clang_getNullLocationPtr = |
| _lookup<ffi.NativeFunction<CXSourceLocation Function()>>( |
| 'clang_getNullLocation'); |
| late final _clang_getNullLocation = |
| _clang_getNullLocationPtr.asFunction<CXSourceLocation Function()>(); |
| |
| /// Determine whether two source locations, which must refer into the same |
| /// translation unit, refer to exactly the same point in the source code. |
| int clang_equalLocations( |
| CXSourceLocation loc1, |
| CXSourceLocation loc2, |
| ) { |
| return _clang_equalLocations( |
| loc1, |
| loc2, |
| ); |
| } |
| |
| late final _clang_equalLocationsPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.UnsignedInt Function( |
| CXSourceLocation, CXSourceLocation)>>('clang_equalLocations'); |
| late final _clang_equalLocations = _clang_equalLocationsPtr |
| .asFunction<int Function(CXSourceLocation, CXSourceLocation)>(); |
| |
| /// Retrieves the source location associated with a given file/line/column in |
| /// a particular translation unit. |
| CXSourceLocation clang_getLocation( |
| CXTranslationUnit tu, |
| CXFile file, |
| int line, |
| int column, |
| ) { |
| return _clang_getLocation( |
| tu, |
| file, |
| line, |
| column, |
| ); |
| } |
| |
| late final _clang_getLocationPtr = _lookup< |
| ffi.NativeFunction< |
| CXSourceLocation Function(CXTranslationUnit, CXFile, ffi.UnsignedInt, |
| ffi.UnsignedInt)>>('clang_getLocation'); |
| late final _clang_getLocation = _clang_getLocationPtr.asFunction< |
| CXSourceLocation Function(CXTranslationUnit, CXFile, int, int)>(); |
| |
| /// Retrieves the source location associated with a given character offset in |
| /// a particular translation unit. |
| CXSourceLocation clang_getLocationForOffset( |
| CXTranslationUnit tu, |
| CXFile file, |
| int offset, |
| ) { |
| return _clang_getLocationForOffset( |
| tu, |
| file, |
| offset, |
| ); |
| } |
| |
| late final _clang_getLocationForOffsetPtr = _lookup< |
| ffi.NativeFunction< |
| CXSourceLocation Function(CXTranslationUnit, CXFile, |
| ffi.UnsignedInt)>>('clang_getLocationForOffset'); |
| late final _clang_getLocationForOffset = _clang_getLocationForOffsetPtr |
| .asFunction<CXSourceLocation Function(CXTranslationUnit, CXFile, int)>(); |
| |
| /// Returns non-zero if the given source location is in a system header. |
| int clang_Location_isInSystemHeader( |
| CXSourceLocation location, |
| ) { |
| return _clang_Location_isInSystemHeader( |
| location, |
| ); |
| } |
| |
| late final _clang_Location_isInSystemHeaderPtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXSourceLocation)>>( |
| 'clang_Location_isInSystemHeader'); |
| late final _clang_Location_isInSystemHeader = |
| _clang_Location_isInSystemHeaderPtr |
| .asFunction<int Function(CXSourceLocation)>(); |
| |
| /// Returns non-zero if the given source location is in the main file of the |
| /// corresponding translation unit. |
| int clang_Location_isFromMainFile( |
| CXSourceLocation location, |
| ) { |
| return _clang_Location_isFromMainFile( |
| location, |
| ); |
| } |
| |
| late final _clang_Location_isFromMainFilePtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXSourceLocation)>>( |
| 'clang_Location_isFromMainFile'); |
| late final _clang_Location_isFromMainFile = _clang_Location_isFromMainFilePtr |
| .asFunction<int Function(CXSourceLocation)>(); |
| |
| /// Retrieve a NULL (invalid) source range. |
| CXSourceRange clang_getNullRange() { |
| return _clang_getNullRange(); |
| } |
| |
| late final _clang_getNullRangePtr = |
| _lookup<ffi.NativeFunction<CXSourceRange Function()>>( |
| 'clang_getNullRange'); |
| late final _clang_getNullRange = |
| _clang_getNullRangePtr.asFunction<CXSourceRange Function()>(); |
| |
| /// Retrieve a source range given the beginning and ending source locations. |
| CXSourceRange clang_getRange( |
| CXSourceLocation begin, |
| CXSourceLocation end, |
| ) { |
| return _clang_getRange( |
| begin, |
| end, |
| ); |
| } |
| |
| late final _clang_getRangePtr = _lookup< |
| ffi.NativeFunction< |
| CXSourceRange Function( |
| CXSourceLocation, CXSourceLocation)>>('clang_getRange'); |
| late final _clang_getRange = _clang_getRangePtr |
| .asFunction<CXSourceRange Function(CXSourceLocation, CXSourceLocation)>(); |
| |
| /// Determine whether two ranges are equivalent. |
| int clang_equalRanges( |
| CXSourceRange range1, |
| CXSourceRange range2, |
| ) { |
| return _clang_equalRanges( |
| range1, |
| range2, |
| ); |
| } |
| |
| late final _clang_equalRangesPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.UnsignedInt Function( |
| CXSourceRange, CXSourceRange)>>('clang_equalRanges'); |
| late final _clang_equalRanges = _clang_equalRangesPtr |
| .asFunction<int Function(CXSourceRange, CXSourceRange)>(); |
| |
| /// Returns non-zero if range is null. |
| int clang_Range_isNull( |
| CXSourceRange range, |
| ) { |
| return _clang_Range_isNull( |
| range, |
| ); |
| } |
| |
| late final _clang_Range_isNullPtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXSourceRange)>>( |
| 'clang_Range_isNull'); |
| late final _clang_Range_isNull = |
| _clang_Range_isNullPtr.asFunction<int Function(CXSourceRange)>(); |
| |
| /// Retrieve the file, line, column, and offset represented by the given |
| /// source location. |
| void clang_getExpansionLocation( |
| CXSourceLocation location, |
| ffi.Pointer<CXFile> file, |
| ffi.Pointer<ffi.UnsignedInt> line, |
| ffi.Pointer<ffi.UnsignedInt> column, |
| ffi.Pointer<ffi.UnsignedInt> offset, |
| ) { |
| return _clang_getExpansionLocation( |
| location, |
| file, |
| line, |
| column, |
| offset, |
| ); |
| } |
| |
| late final _clang_getExpansionLocationPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Void Function( |
| CXSourceLocation, |
| ffi.Pointer<CXFile>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>)>>('clang_getExpansionLocation'); |
| late final _clang_getExpansionLocation = |
| _clang_getExpansionLocationPtr.asFunction< |
| void Function( |
| CXSourceLocation, |
| ffi.Pointer<CXFile>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>)>(); |
| |
| /// Retrieve the file, line and column represented by the given source |
| /// location, as specified in a # line directive. |
| void clang_getPresumedLocation( |
| CXSourceLocation location, |
| ffi.Pointer<CXString> filename, |
| ffi.Pointer<ffi.UnsignedInt> line, |
| ffi.Pointer<ffi.UnsignedInt> column, |
| ) { |
| return _clang_getPresumedLocation( |
| location, |
| filename, |
| line, |
| column, |
| ); |
| } |
| |
| late final _clang_getPresumedLocationPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Void Function( |
| CXSourceLocation, |
| ffi.Pointer<CXString>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>)>>('clang_getPresumedLocation'); |
| late final _clang_getPresumedLocation = |
| _clang_getPresumedLocationPtr.asFunction< |
| void Function(CXSourceLocation, ffi.Pointer<CXString>, |
| ffi.Pointer<ffi.UnsignedInt>, ffi.Pointer<ffi.UnsignedInt>)>(); |
| |
| /// Legacy API to retrieve the file, line, column, and offset represented by |
| /// the given source location. |
| void clang_getInstantiationLocation( |
| CXSourceLocation location, |
| ffi.Pointer<CXFile> file, |
| ffi.Pointer<ffi.UnsignedInt> line, |
| ffi.Pointer<ffi.UnsignedInt> column, |
| ffi.Pointer<ffi.UnsignedInt> offset, |
| ) { |
| return _clang_getInstantiationLocation( |
| location, |
| file, |
| line, |
| column, |
| offset, |
| ); |
| } |
| |
| late final _clang_getInstantiationLocationPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Void Function( |
| CXSourceLocation, |
| ffi.Pointer<CXFile>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>)>>('clang_getInstantiationLocation'); |
| late final _clang_getInstantiationLocation = |
| _clang_getInstantiationLocationPtr.asFunction< |
| void Function( |
| CXSourceLocation, |
| ffi.Pointer<CXFile>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>)>(); |
| |
| /// Retrieve the file, line, column, and offset represented by the given |
| /// source location. |
| void clang_getSpellingLocation( |
| CXSourceLocation location, |
| ffi.Pointer<CXFile> file, |
| ffi.Pointer<ffi.UnsignedInt> line, |
| ffi.Pointer<ffi.UnsignedInt> column, |
| ffi.Pointer<ffi.UnsignedInt> offset, |
| ) { |
| return _clang_getSpellingLocation( |
| location, |
| file, |
| line, |
| column, |
| offset, |
| ); |
| } |
| |
| late final _clang_getSpellingLocationPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Void Function( |
| CXSourceLocation, |
| ffi.Pointer<CXFile>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>)>>('clang_getSpellingLocation'); |
| late final _clang_getSpellingLocation = |
| _clang_getSpellingLocationPtr.asFunction< |
| void Function( |
| CXSourceLocation, |
| ffi.Pointer<CXFile>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>)>(); |
| |
| /// Retrieve the file, line, column, and offset represented by the given |
| /// source location. |
| void clang_getFileLocation( |
| CXSourceLocation location, |
| ffi.Pointer<CXFile> file, |
| ffi.Pointer<ffi.UnsignedInt> line, |
| ffi.Pointer<ffi.UnsignedInt> column, |
| ffi.Pointer<ffi.UnsignedInt> offset, |
| ) { |
| return _clang_getFileLocation( |
| location, |
| file, |
| line, |
| column, |
| offset, |
| ); |
| } |
| |
| late final _clang_getFileLocationPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Void Function( |
| CXSourceLocation, |
| ffi.Pointer<CXFile>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>)>>('clang_getFileLocation'); |
| late final _clang_getFileLocation = _clang_getFileLocationPtr.asFunction< |
| void Function( |
| CXSourceLocation, |
| ffi.Pointer<CXFile>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>, |
| ffi.Pointer<ffi.UnsignedInt>)>(); |
| |
| /// Retrieve a source location representing the first character within a |
| /// source range. |
| CXSourceLocation clang_getRangeStart( |
| CXSourceRange range, |
| ) { |
| return _clang_getRangeStart( |
| range, |
| ); |
| } |
| |
| late final _clang_getRangeStartPtr = |
| _lookup<ffi.NativeFunction<CXSourceLocation Function(CXSourceRange)>>( |
| 'clang_getRangeStart'); |
| late final _clang_getRangeStart = _clang_getRangeStartPtr |
| .asFunction<CXSourceLocation Function(CXSourceRange)>(); |
| |
| /// Retrieve a source location representing the last character within a source |
| /// range. |
| CXSourceLocation clang_getRangeEnd( |
| CXSourceRange range, |
| ) { |
| return _clang_getRangeEnd( |
| range, |
| ); |
| } |
| |
| late final _clang_getRangeEndPtr = |
| _lookup<ffi.NativeFunction<CXSourceLocation Function(CXSourceRange)>>( |
| 'clang_getRangeEnd'); |
| late final _clang_getRangeEnd = _clang_getRangeEndPtr |
| .asFunction<CXSourceLocation Function(CXSourceRange)>(); |
| |
| /// Retrieve all ranges that were skipped by the preprocessor. |
| ffi.Pointer<CXSourceRangeList> clang_getSkippedRanges( |
| CXTranslationUnit tu, |
| CXFile file, |
| ) { |
| return _clang_getSkippedRanges( |
| tu, |
| file, |
| ); |
| } |
| |
| late final _clang_getSkippedRangesPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Pointer<CXSourceRangeList> Function( |
| CXTranslationUnit, CXFile)>>('clang_getSkippedRanges'); |
| late final _clang_getSkippedRanges = _clang_getSkippedRangesPtr.asFunction< |
| ffi.Pointer<CXSourceRangeList> Function(CXTranslationUnit, CXFile)>(); |
| |
| /// Retrieve all ranges from all files that were skipped by the preprocessor. |
| ffi.Pointer<CXSourceRangeList> clang_getAllSkippedRanges( |
| CXTranslationUnit tu, |
| ) { |
| return _clang_getAllSkippedRanges( |
| tu, |
| ); |
| } |
| |
| late final _clang_getAllSkippedRangesPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Pointer<CXSourceRangeList> Function( |
| CXTranslationUnit)>>('clang_getAllSkippedRanges'); |
| late final _clang_getAllSkippedRanges = _clang_getAllSkippedRangesPtr |
| .asFunction<ffi.Pointer<CXSourceRangeList> Function(CXTranslationUnit)>(); |
| |
| /// Destroy the given CXSourceRangeList. |
| void clang_disposeSourceRangeList( |
| ffi.Pointer<CXSourceRangeList> ranges, |
| ) { |
| return _clang_disposeSourceRangeList( |
| ranges, |
| ); |
| } |
| |
| late final _clang_disposeSourceRangeListPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Void Function( |
| ffi.Pointer<CXSourceRangeList>)>>('clang_disposeSourceRangeList'); |
| late final _clang_disposeSourceRangeList = _clang_disposeSourceRangeListPtr |
| .asFunction<void Function(ffi.Pointer<CXSourceRangeList>)>(); |
| |
| /// Determine the number of diagnostics in a CXDiagnosticSet. |
| int clang_getNumDiagnosticsInSet( |
| CXDiagnosticSet Diags, |
| ) { |
| return _clang_getNumDiagnosticsInSet( |
| Diags, |
| ); |
| } |
| |
| late final _clang_getNumDiagnosticsInSetPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXDiagnosticSet)>>( |
| 'clang_getNumDiagnosticsInSet'); |
| late final _clang_getNumDiagnosticsInSet = _clang_getNumDiagnosticsInSetPtr |
| .asFunction<int Function(CXDiagnosticSet)>(); |
| |
| /// Retrieve a diagnostic associated with the given CXDiagnosticSet. |
| CXDiagnostic clang_getDiagnosticInSet( |
| CXDiagnosticSet Diags, |
| int Index, |
| ) { |
| return _clang_getDiagnosticInSet( |
| Diags, |
| Index, |
| ); |
| } |
| |
| late final _clang_getDiagnosticInSetPtr = _lookup< |
| ffi.NativeFunction< |
| CXDiagnostic Function( |
| CXDiagnosticSet, ffi.UnsignedInt)>>('clang_getDiagnosticInSet'); |
| late final _clang_getDiagnosticInSet = _clang_getDiagnosticInSetPtr |
| .asFunction<CXDiagnostic Function(CXDiagnosticSet, int)>(); |
| |
| /// Deserialize a set of diagnostics from a Clang diagnostics bitcode file. |
| CXDiagnosticSet clang_loadDiagnostics( |
| ffi.Pointer<ffi.Char> file, |
| ffi.Pointer<ffi.Int32> error, |
| ffi.Pointer<CXString> errorString, |
| ) { |
| return _clang_loadDiagnostics( |
| file, |
| error, |
| errorString, |
| ); |
| } |
| |
| late final _clang_loadDiagnosticsPtr = _lookup< |
| ffi.NativeFunction< |
| CXDiagnosticSet Function( |
| ffi.Pointer<ffi.Char>, |
| ffi.Pointer<ffi.Int32>, |
| ffi.Pointer<CXString>)>>('clang_loadDiagnostics'); |
| late final _clang_loadDiagnostics = _clang_loadDiagnosticsPtr.asFunction< |
| CXDiagnosticSet Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Int32>, |
| ffi.Pointer<CXString>)>(); |
| |
| /// Release a CXDiagnosticSet and all of its contained diagnostics. |
| void clang_disposeDiagnosticSet( |
| CXDiagnosticSet Diags, |
| ) { |
| return _clang_disposeDiagnosticSet( |
| Diags, |
| ); |
| } |
| |
| late final _clang_disposeDiagnosticSetPtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXDiagnosticSet)>>( |
| 'clang_disposeDiagnosticSet'); |
| late final _clang_disposeDiagnosticSet = _clang_disposeDiagnosticSetPtr |
| .asFunction<void Function(CXDiagnosticSet)>(); |
| |
| /// Retrieve the child diagnostics of a CXDiagnostic. |
| CXDiagnosticSet clang_getChildDiagnostics( |
| CXDiagnostic D, |
| ) { |
| return _clang_getChildDiagnostics( |
| D, |
| ); |
| } |
| |
| late final _clang_getChildDiagnosticsPtr = |
| _lookup<ffi.NativeFunction<CXDiagnosticSet Function(CXDiagnostic)>>( |
| 'clang_getChildDiagnostics'); |
| late final _clang_getChildDiagnostics = _clang_getChildDiagnosticsPtr |
| .asFunction<CXDiagnosticSet Function(CXDiagnostic)>(); |
| |
| /// Determine the number of diagnostics produced for the given translation |
| /// unit. |
| int clang_getNumDiagnostics( |
| CXTranslationUnit Unit, |
| ) { |
| return _clang_getNumDiagnostics( |
| Unit, |
| ); |
| } |
| |
| late final _clang_getNumDiagnosticsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXTranslationUnit)>>( |
| 'clang_getNumDiagnostics'); |
| late final _clang_getNumDiagnostics = |
| _clang_getNumDiagnosticsPtr.asFunction<int Function(CXTranslationUnit)>(); |
| |
| /// Retrieve a diagnostic associated with the given translation unit. |
| CXDiagnostic clang_getDiagnostic( |
| CXTranslationUnit Unit, |
| int Index, |
| ) { |
| return _clang_getDiagnostic( |
| Unit, |
| Index, |
| ); |
| } |
| |
| late final _clang_getDiagnosticPtr = _lookup< |
| ffi.NativeFunction< |
| CXDiagnostic Function( |
| CXTranslationUnit, ffi.UnsignedInt)>>('clang_getDiagnostic'); |
| late final _clang_getDiagnostic = _clang_getDiagnosticPtr |
| .asFunction<CXDiagnostic Function(CXTranslationUnit, int)>(); |
| |
| /// Retrieve the complete set of diagnostics associated with a translation |
| /// unit. |
| CXDiagnosticSet clang_getDiagnosticSetFromTU( |
| CXTranslationUnit Unit, |
| ) { |
| return _clang_getDiagnosticSetFromTU( |
| Unit, |
| ); |
| } |
| |
| late final _clang_getDiagnosticSetFromTUPtr = |
| _lookup<ffi.NativeFunction<CXDiagnosticSet Function(CXTranslationUnit)>>( |
| 'clang_getDiagnosticSetFromTU'); |
| late final _clang_getDiagnosticSetFromTU = _clang_getDiagnosticSetFromTUPtr |
| .asFunction<CXDiagnosticSet Function(CXTranslationUnit)>(); |
| |
| /// Destroy a diagnostic. |
| void clang_disposeDiagnostic( |
| CXDiagnostic Diagnostic, |
| ) { |
| return _clang_disposeDiagnostic( |
| Diagnostic, |
| ); |
| } |
| |
| late final _clang_disposeDiagnosticPtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXDiagnostic)>>( |
| 'clang_disposeDiagnostic'); |
| late final _clang_disposeDiagnostic = |
| _clang_disposeDiagnosticPtr.asFunction<void Function(CXDiagnostic)>(); |
| |
| /// Format the given diagnostic in a manner that is suitable for display. |
| CXString clang_formatDiagnostic( |
| CXDiagnostic Diagnostic, |
| int Options, |
| ) { |
| return _clang_formatDiagnostic( |
| Diagnostic, |
| Options, |
| ); |
| } |
| |
| late final _clang_formatDiagnosticPtr = _lookup< |
| ffi.NativeFunction<CXString Function(CXDiagnostic, ffi.UnsignedInt)>>( |
| 'clang_formatDiagnostic'); |
| late final _clang_formatDiagnostic = _clang_formatDiagnosticPtr |
| .asFunction<CXString Function(CXDiagnostic, int)>(); |
| |
| /// Retrieve the set of display options most similar to the default behavior |
| /// of the clang compiler. |
| int clang_defaultDiagnosticDisplayOptions() { |
| return _clang_defaultDiagnosticDisplayOptions(); |
| } |
| |
| late final _clang_defaultDiagnosticDisplayOptionsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function()>>( |
| 'clang_defaultDiagnosticDisplayOptions'); |
| late final _clang_defaultDiagnosticDisplayOptions = |
| _clang_defaultDiagnosticDisplayOptionsPtr.asFunction<int Function()>(); |
| |
| /// Determine the severity of the given diagnostic. |
| int clang_getDiagnosticSeverity( |
| CXDiagnostic arg0, |
| ) { |
| return _clang_getDiagnosticSeverity( |
| arg0, |
| ); |
| } |
| |
| late final _clang_getDiagnosticSeverityPtr = |
| _lookup<ffi.NativeFunction<ffi.Int32 Function(CXDiagnostic)>>( |
| 'clang_getDiagnosticSeverity'); |
| late final _clang_getDiagnosticSeverity = |
| _clang_getDiagnosticSeverityPtr.asFunction<int Function(CXDiagnostic)>(); |
| |
| /// Retrieve the source location of the given diagnostic. |
| CXSourceLocation clang_getDiagnosticLocation( |
| CXDiagnostic arg0, |
| ) { |
| return _clang_getDiagnosticLocation( |
| arg0, |
| ); |
| } |
| |
| late final _clang_getDiagnosticLocationPtr = |
| _lookup<ffi.NativeFunction<CXSourceLocation Function(CXDiagnostic)>>( |
| 'clang_getDiagnosticLocation'); |
| late final _clang_getDiagnosticLocation = _clang_getDiagnosticLocationPtr |
| .asFunction<CXSourceLocation Function(CXDiagnostic)>(); |
| |
| /// Retrieve the text of the given diagnostic. |
| CXString clang_getDiagnosticSpelling( |
| CXDiagnostic arg0, |
| ) { |
| return _clang_getDiagnosticSpelling( |
| arg0, |
| ); |
| } |
| |
| late final _clang_getDiagnosticSpellingPtr = |
| _lookup<ffi.NativeFunction<CXString Function(CXDiagnostic)>>( |
| 'clang_getDiagnosticSpelling'); |
| late final _clang_getDiagnosticSpelling = _clang_getDiagnosticSpellingPtr |
| .asFunction<CXString Function(CXDiagnostic)>(); |
| |
| /// Retrieve the name of the command-line option that enabled this diagnostic. |
| CXString clang_getDiagnosticOption( |
| CXDiagnostic Diag, |
| ffi.Pointer<CXString> Disable, |
| ) { |
| return _clang_getDiagnosticOption( |
| Diag, |
| Disable, |
| ); |
| } |
| |
| late final _clang_getDiagnosticOptionPtr = _lookup< |
| ffi.NativeFunction< |
| CXString Function(CXDiagnostic, |
| ffi.Pointer<CXString>)>>('clang_getDiagnosticOption'); |
| late final _clang_getDiagnosticOption = _clang_getDiagnosticOptionPtr |
| .asFunction<CXString Function(CXDiagnostic, ffi.Pointer<CXString>)>(); |
| |
| /// Retrieve the category number for this diagnostic. |
| int clang_getDiagnosticCategory( |
| CXDiagnostic arg0, |
| ) { |
| return _clang_getDiagnosticCategory( |
| arg0, |
| ); |
| } |
| |
| late final _clang_getDiagnosticCategoryPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXDiagnostic)>>( |
| 'clang_getDiagnosticCategory'); |
| late final _clang_getDiagnosticCategory = |
| _clang_getDiagnosticCategoryPtr.asFunction<int Function(CXDiagnostic)>(); |
| |
| /// Retrieve the name of a particular diagnostic category. This is now |
| /// deprecated. Use clang_getDiagnosticCategoryText() instead. |
| CXString clang_getDiagnosticCategoryName( |
| int Category, |
| ) { |
| return _clang_getDiagnosticCategoryName( |
| Category, |
| ); |
| } |
| |
| late final _clang_getDiagnosticCategoryNamePtr = |
| _lookup<ffi.NativeFunction<CXString Function(ffi.UnsignedInt)>>( |
| 'clang_getDiagnosticCategoryName'); |
| late final _clang_getDiagnosticCategoryName = |
| _clang_getDiagnosticCategoryNamePtr.asFunction<CXString Function(int)>(); |
| |
| /// Retrieve the diagnostic category text for a given diagnostic. |
| CXString clang_getDiagnosticCategoryText( |
| CXDiagnostic arg0, |
| ) { |
| return _clang_getDiagnosticCategoryText( |
| arg0, |
| ); |
| } |
| |
| late final _clang_getDiagnosticCategoryTextPtr = |
| _lookup<ffi.NativeFunction<CXString Function(CXDiagnostic)>>( |
| 'clang_getDiagnosticCategoryText'); |
| late final _clang_getDiagnosticCategoryText = |
| _clang_getDiagnosticCategoryTextPtr |
| .asFunction<CXString Function(CXDiagnostic)>(); |
| |
| /// Determine the number of source ranges associated with the given |
| /// diagnostic. |
| int clang_getDiagnosticNumRanges( |
| CXDiagnostic arg0, |
| ) { |
| return _clang_getDiagnosticNumRanges( |
| arg0, |
| ); |
| } |
| |
| late final _clang_getDiagnosticNumRangesPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXDiagnostic)>>( |
| 'clang_getDiagnosticNumRanges'); |
| late final _clang_getDiagnosticNumRanges = |
| _clang_getDiagnosticNumRangesPtr.asFunction<int Function(CXDiagnostic)>(); |
| |
| /// Retrieve a source range associated with the diagnostic. |
| CXSourceRange clang_getDiagnosticRange( |
| CXDiagnostic Diagnostic, |
| int Range, |
| ) { |
| return _clang_getDiagnosticRange( |
| Diagnostic, |
| Range, |
| ); |
| } |
| |
| late final _clang_getDiagnosticRangePtr = _lookup< |
| ffi.NativeFunction< |
| CXSourceRange Function( |
| CXDiagnostic, ffi.UnsignedInt)>>('clang_getDiagnosticRange'); |
| late final _clang_getDiagnosticRange = _clang_getDiagnosticRangePtr |
| .asFunction<CXSourceRange Function(CXDiagnostic, int)>(); |
| |
| /// Determine the number of fix-it hints associated with the given diagnostic. |
| int clang_getDiagnosticNumFixIts( |
| CXDiagnostic Diagnostic, |
| ) { |
| return _clang_getDiagnosticNumFixIts( |
| Diagnostic, |
| ); |
| } |
| |
| late final _clang_getDiagnosticNumFixItsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXDiagnostic)>>( |
| 'clang_getDiagnosticNumFixIts'); |
| late final _clang_getDiagnosticNumFixIts = |
| _clang_getDiagnosticNumFixItsPtr.asFunction<int Function(CXDiagnostic)>(); |
| |
| /// Retrieve the replacement information for a given fix-it. |
| CXString clang_getDiagnosticFixIt( |
| CXDiagnostic Diagnostic, |
| int FixIt, |
| ffi.Pointer<CXSourceRange> ReplacementRange, |
| ) { |
| return _clang_getDiagnosticFixIt( |
| Diagnostic, |
| FixIt, |
| ReplacementRange, |
| ); |
| } |
| |
| late final _clang_getDiagnosticFixItPtr = _lookup< |
| ffi.NativeFunction< |
| CXString Function(CXDiagnostic, ffi.UnsignedInt, |
| ffi.Pointer<CXSourceRange>)>>('clang_getDiagnosticFixIt'); |
| late final _clang_getDiagnosticFixIt = |
| _clang_getDiagnosticFixItPtr.asFunction< |
| CXString Function(CXDiagnostic, int, ffi.Pointer<CXSourceRange>)>(); |
| |
| /// Get the original translation unit source file name. |
| CXString clang_getTranslationUnitSpelling( |
| CXTranslationUnit CTUnit, |
| ) { |
| return _clang_getTranslationUnitSpelling( |
| CTUnit, |
| ); |
| } |
| |
| late final _clang_getTranslationUnitSpellingPtr = |
| _lookup<ffi.NativeFunction<CXString Function(CXTranslationUnit)>>( |
| 'clang_getTranslationUnitSpelling'); |
| late final _clang_getTranslationUnitSpelling = |
| _clang_getTranslationUnitSpellingPtr |
| .asFunction<CXString Function(CXTranslationUnit)>(); |
| |
| /// Return the CXTranslationUnit for a given source file and the provided |
| /// command line arguments one would pass to the compiler. |
| CXTranslationUnit clang_createTranslationUnitFromSourceFile( |
| CXIndex CIdx, |
| ffi.Pointer<ffi.Char> source_filename, |
| int num_clang_command_line_args, |
| ffi.Pointer<ffi.Pointer<ffi.Char>> 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, |
| ); |
| } |
| |
| late final _clang_createTranslationUnitFromSourceFilePtr = _lookup< |
| ffi.NativeFunction< |
| CXTranslationUnit Function( |
| CXIndex, |
| ffi.Pointer<ffi.Char>, |
| ffi.Int, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| ffi.UnsignedInt, |
| ffi.Pointer<CXUnsavedFile>)>>( |
| 'clang_createTranslationUnitFromSourceFile'); |
| late final _clang_createTranslationUnitFromSourceFile = |
| _clang_createTranslationUnitFromSourceFilePtr.asFunction< |
| CXTranslationUnit Function( |
| CXIndex, |
| ffi.Pointer<ffi.Char>, |
| int, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| int, |
| ffi.Pointer<CXUnsavedFile>)>(); |
| |
| /// Same as clang_createTranslationUnit2, but returns the CXTranslationUnit |
| /// instead of an error code. In case of an error this routine returns a NULL |
| /// CXTranslationUnit, without further detailed error codes. |
| CXTranslationUnit clang_createTranslationUnit( |
| CXIndex CIdx, |
| ffi.Pointer<ffi.Char> ast_filename, |
| ) { |
| return _clang_createTranslationUnit( |
| CIdx, |
| ast_filename, |
| ); |
| } |
| |
| late final _clang_createTranslationUnitPtr = _lookup< |
| ffi.NativeFunction< |
| CXTranslationUnit Function( |
| CXIndex, ffi.Pointer<ffi.Char>)>>('clang_createTranslationUnit'); |
| late final _clang_createTranslationUnit = _clang_createTranslationUnitPtr |
| .asFunction<CXTranslationUnit Function(CXIndex, ffi.Pointer<ffi.Char>)>(); |
| |
| /// Create a translation unit from an AST file ( -emit-ast). |
| int clang_createTranslationUnit2( |
| CXIndex CIdx, |
| ffi.Pointer<ffi.Char> ast_filename, |
| ffi.Pointer<CXTranslationUnit> out_TU, |
| ) { |
| return _clang_createTranslationUnit2( |
| CIdx, |
| ast_filename, |
| out_TU, |
| ); |
| } |
| |
| late final _clang_createTranslationUnit2Ptr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int32 Function(CXIndex, ffi.Pointer<ffi.Char>, |
| ffi.Pointer<CXTranslationUnit>)>>('clang_createTranslationUnit2'); |
| late final _clang_createTranslationUnit2 = |
| _clang_createTranslationUnit2Ptr.asFunction< |
| int Function(CXIndex, ffi.Pointer<ffi.Char>, |
| ffi.Pointer<CXTranslationUnit>)>(); |
| |
| /// Returns the set of flags that is suitable for parsing a translation unit |
| /// that is being edited. |
| int clang_defaultEditingTranslationUnitOptions() { |
| return _clang_defaultEditingTranslationUnitOptions(); |
| } |
| |
| late final _clang_defaultEditingTranslationUnitOptionsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function()>>( |
| 'clang_defaultEditingTranslationUnitOptions'); |
| late final _clang_defaultEditingTranslationUnitOptions = |
| _clang_defaultEditingTranslationUnitOptionsPtr |
| .asFunction<int Function()>(); |
| |
| /// Same as clang_parseTranslationUnit2, but returns the CXTranslationUnit |
| /// instead of an error code. In case of an error this routine returns a NULL |
| /// CXTranslationUnit, without further detailed error codes. |
| CXTranslationUnit clang_parseTranslationUnit( |
| CXIndex CIdx, |
| ffi.Pointer<ffi.Char> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Char>> 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, |
| ); |
| } |
| |
| late final _clang_parseTranslationUnitPtr = _lookup< |
| ffi.NativeFunction< |
| CXTranslationUnit Function( |
| CXIndex, |
| ffi.Pointer<ffi.Char>, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| ffi.Int, |
| ffi.Pointer<CXUnsavedFile>, |
| ffi.UnsignedInt, |
| ffi.UnsignedInt)>>('clang_parseTranslationUnit'); |
| late final _clang_parseTranslationUnit = |
| _clang_parseTranslationUnitPtr.asFunction< |
| CXTranslationUnit Function( |
| CXIndex, |
| ffi.Pointer<ffi.Char>, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| int, |
| ffi.Pointer<CXUnsavedFile>, |
| int, |
| int)>(); |
| |
| /// Parse the given source file and the translation unit corresponding to that |
| /// file. |
| int clang_parseTranslationUnit2( |
| CXIndex CIdx, |
| ffi.Pointer<ffi.Char> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Char>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| int options, |
| ffi.Pointer<CXTranslationUnit> out_TU, |
| ) { |
| return _clang_parseTranslationUnit2( |
| CIdx, |
| source_filename, |
| command_line_args, |
| num_command_line_args, |
| unsaved_files, |
| num_unsaved_files, |
| options, |
| out_TU, |
| ); |
| } |
| |
| late final _clang_parseTranslationUnit2Ptr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int32 Function( |
| CXIndex, |
| ffi.Pointer<ffi.Char>, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| ffi.Int, |
| ffi.Pointer<CXUnsavedFile>, |
| ffi.UnsignedInt, |
| ffi.UnsignedInt, |
| ffi.Pointer<CXTranslationUnit>)>>('clang_parseTranslationUnit2'); |
| late final _clang_parseTranslationUnit2 = |
| _clang_parseTranslationUnit2Ptr.asFunction< |
| int Function( |
| CXIndex, |
| ffi.Pointer<ffi.Char>, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| int, |
| ffi.Pointer<CXUnsavedFile>, |
| int, |
| int, |
| ffi.Pointer<CXTranslationUnit>)>(); |
| |
| /// Same as clang_parseTranslationUnit2 but requires a full command line for |
| /// command_line_args including argv[0]. This is useful if the standard |
| /// library paths are relative to the binary. |
| int clang_parseTranslationUnit2FullArgv( |
| CXIndex CIdx, |
| ffi.Pointer<ffi.Char> source_filename, |
| ffi.Pointer<ffi.Pointer<ffi.Char>> command_line_args, |
| int num_command_line_args, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int num_unsaved_files, |
| int options, |
| ffi.Pointer<CXTranslationUnit> out_TU, |
| ) { |
| return _clang_parseTranslationUnit2FullArgv( |
| CIdx, |
| source_filename, |
| command_line_args, |
| num_command_line_args, |
| unsaved_files, |
| num_unsaved_files, |
| options, |
| out_TU, |
| ); |
| } |
| |
| late final _clang_parseTranslationUnit2FullArgvPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int32 Function( |
| CXIndex, |
| ffi.Pointer<ffi.Char>, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| ffi.Int, |
| ffi.Pointer<CXUnsavedFile>, |
| ffi.UnsignedInt, |
| ffi.UnsignedInt, |
| ffi.Pointer<CXTranslationUnit>)>>( |
| 'clang_parseTranslationUnit2FullArgv'); |
| late final _clang_parseTranslationUnit2FullArgv = |
| _clang_parseTranslationUnit2FullArgvPtr.asFunction< |
| int Function( |
| CXIndex, |
| ffi.Pointer<ffi.Char>, |
| ffi.Pointer<ffi.Pointer<ffi.Char>>, |
| int, |
| ffi.Pointer<CXUnsavedFile>, |
| int, |
| int, |
| ffi.Pointer<CXTranslationUnit>)>(); |
| |
| /// Returns the set of flags that is suitable for saving a translation unit. |
| int clang_defaultSaveOptions( |
| CXTranslationUnit TU, |
| ) { |
| return _clang_defaultSaveOptions( |
| TU, |
| ); |
| } |
| |
| late final _clang_defaultSaveOptionsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXTranslationUnit)>>( |
| 'clang_defaultSaveOptions'); |
| late final _clang_defaultSaveOptions = _clang_defaultSaveOptionsPtr |
| .asFunction<int Function(CXTranslationUnit)>(); |
| |
| /// Saves a translation unit into a serialized representation of that |
| /// translation unit on disk. |
| int clang_saveTranslationUnit( |
| CXTranslationUnit TU, |
| ffi.Pointer<ffi.Char> FileName, |
| int options, |
| ) { |
| return _clang_saveTranslationUnit( |
| TU, |
| FileName, |
| options, |
| ); |
| } |
| |
| late final _clang_saveTranslationUnitPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int Function(CXTranslationUnit, ffi.Pointer<ffi.Char>, |
| ffi.UnsignedInt)>>('clang_saveTranslationUnit'); |
| late final _clang_saveTranslationUnit = |
| _clang_saveTranslationUnitPtr.asFunction< |
| int Function(CXTranslationUnit, ffi.Pointer<ffi.Char>, int)>(); |
| |
| /// Suspend a translation unit in order to free memory associated with it. |
| int clang_suspendTranslationUnit( |
| CXTranslationUnit arg0, |
| ) { |
| return _clang_suspendTranslationUnit( |
| arg0, |
| ); |
| } |
| |
| late final _clang_suspendTranslationUnitPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXTranslationUnit)>>( |
| 'clang_suspendTranslationUnit'); |
| late final _clang_suspendTranslationUnit = _clang_suspendTranslationUnitPtr |
| .asFunction<int Function(CXTranslationUnit)>(); |
| |
| /// Destroy the specified CXTranslationUnit object. |
| void clang_disposeTranslationUnit( |
| CXTranslationUnit arg0, |
| ) { |
| return _clang_disposeTranslationUnit( |
| arg0, |
| ); |
| } |
| |
| late final _clang_disposeTranslationUnitPtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXTranslationUnit)>>( |
| 'clang_disposeTranslationUnit'); |
| late final _clang_disposeTranslationUnit = _clang_disposeTranslationUnitPtr |
| .asFunction<void Function(CXTranslationUnit)>(); |
| |
| /// Returns the set of flags that is suitable for reparsing a translation |
| /// unit. |
| int clang_defaultReparseOptions( |
| CXTranslationUnit TU, |
| ) { |
| return _clang_defaultReparseOptions( |
| TU, |
| ); |
| } |
| |
| late final _clang_defaultReparseOptionsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXTranslationUnit)>>( |
| 'clang_defaultReparseOptions'); |
| late final _clang_defaultReparseOptions = _clang_defaultReparseOptionsPtr |
| .asFunction<int Function(CXTranslationUnit)>(); |
| |
| /// Reparse the source files that produced this translation unit. |
| int clang_reparseTranslationUnit( |
| CXTranslationUnit TU, |
| int num_unsaved_files, |
| ffi.Pointer<CXUnsavedFile> unsaved_files, |
| int options, |
| ) { |
| return _clang_reparseTranslationUnit( |
| TU, |
| num_unsaved_files, |
| unsaved_files, |
| options, |
| ); |
| } |
| |
| late final _clang_reparseTranslationUnitPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int Function( |
| CXTranslationUnit, |
| ffi.UnsignedInt, |
| ffi.Pointer<CXUnsavedFile>, |
| ffi.UnsignedInt)>>('clang_reparseTranslationUnit'); |
| late final _clang_reparseTranslationUnit = |
| _clang_reparseTranslationUnitPtr.asFunction< |
| int Function( |
| CXTranslationUnit, int, ffi.Pointer<CXUnsavedFile>, int)>(); |
| |
| /// 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.Char> clang_getTUResourceUsageName( |
| int kind, |
| ) { |
| return _clang_getTUResourceUsageName( |
| kind, |
| ); |
| } |
| |
| late final _clang_getTUResourceUsageNamePtr = |
| _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Int32)>>( |
| 'clang_getTUResourceUsageName'); |
| late final _clang_getTUResourceUsageName = _clang_getTUResourceUsageNamePtr |
| .asFunction<ffi.Pointer<ffi.Char> Function(int)>(); |
| |
| /// Return the memory usage of a translation unit. This object should be |
| /// released with clang_disposeCXTUResourceUsage(). |
| CXTUResourceUsage clang_getCXTUResourceUsage( |
| CXTranslationUnit TU, |
| ) { |
| return _clang_getCXTUResourceUsage( |
| TU, |
| ); |
| } |
| |
| late final _clang_getCXTUResourceUsagePtr = _lookup< |
| ffi.NativeFunction<CXTUResourceUsage Function(CXTranslationUnit)>>( |
| 'clang_getCXTUResourceUsage'); |
| late final _clang_getCXTUResourceUsage = _clang_getCXTUResourceUsagePtr |
| .asFunction<CXTUResourceUsage Function(CXTranslationUnit)>(); |
| |
| void clang_disposeCXTUResourceUsage( |
| CXTUResourceUsage usage, |
| ) { |
| return _clang_disposeCXTUResourceUsage( |
| usage, |
| ); |
| } |
| |
| late final _clang_disposeCXTUResourceUsagePtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXTUResourceUsage)>>( |
| 'clang_disposeCXTUResourceUsage'); |
| late final _clang_disposeCXTUResourceUsage = |
| _clang_disposeCXTUResourceUsagePtr |
| .asFunction<void Function(CXTUResourceUsage)>(); |
| |
| /// Get target information for this translation unit. |
| CXTargetInfo clang_getTranslationUnitTargetInfo( |
| CXTranslationUnit CTUnit, |
| ) { |
| return _clang_getTranslationUnitTargetInfo( |
| CTUnit, |
| ); |
| } |
| |
| late final _clang_getTranslationUnitTargetInfoPtr = |
| _lookup<ffi.NativeFunction<CXTargetInfo Function(CXTranslationUnit)>>( |
| 'clang_getTranslationUnitTargetInfo'); |
| late final _clang_getTranslationUnitTargetInfo = |
| _clang_getTranslationUnitTargetInfoPtr |
| .asFunction<CXTargetInfo Function(CXTranslationUnit)>(); |
| |
| /// Destroy the CXTargetInfo object. |
| void clang_TargetInfo_dispose( |
| CXTargetInfo Info, |
| ) { |
| return _clang_TargetInfo_dispose( |
| Info, |
| ); |
| } |
| |
| late final _clang_TargetInfo_disposePtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXTargetInfo)>>( |
| 'clang_TargetInfo_dispose'); |
| late final _clang_TargetInfo_dispose = |
| _clang_TargetInfo_disposePtr.asFunction<void Function(CXTargetInfo)>(); |
| |
| /// Get the normalized target triple as a string. |
| CXString clang_TargetInfo_getTriple( |
| CXTargetInfo Info, |
| ) { |
| return _clang_TargetInfo_getTriple( |
| Info, |
| ); |
| } |
| |
| late final _clang_TargetInfo_getTriplePtr = |
| _lookup<ffi.NativeFunction<CXString Function(CXTargetInfo)>>( |
| 'clang_TargetInfo_getTriple'); |
| late final _clang_TargetInfo_getTriple = _clang_TargetInfo_getTriplePtr |
| .asFunction<CXString Function(CXTargetInfo)>(); |
| |
| /// Get the pointer width of the target in bits. |
| int clang_TargetInfo_getPointerWidth( |
| CXTargetInfo Info, |
| ) { |
| return _clang_TargetInfo_getPointerWidth( |
| Info, |
| ); |
| } |
| |
| late final _clang_TargetInfo_getPointerWidthPtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXTargetInfo)>>( |
| 'clang_TargetInfo_getPointerWidth'); |
| late final _clang_TargetInfo_getPointerWidth = |
| _clang_TargetInfo_getPointerWidthPtr |
| .asFunction<int Function(CXTargetInfo)>(); |
| |
| /// Retrieve the NULL cursor, which represents no entity. |
| CXCursor clang_getNullCursor() { |
| return _clang_getNullCursor(); |
| } |
| |
| late final _clang_getNullCursorPtr = |
| _lookup<ffi.NativeFunction<CXCursor Function()>>('clang_getNullCursor'); |
| late final _clang_getNullCursor = |
| _clang_getNullCursorPtr.asFunction<CXCursor Function()>(); |
| |
| /// Retrieve the cursor that represents the given translation unit. |
| CXCursor clang_getTranslationUnitCursor( |
| CXTranslationUnit arg0, |
| ) { |
| return _clang_getTranslationUnitCursor( |
| arg0, |
| ); |
| } |
| |
| late final _clang_getTranslationUnitCursorPtr = |
| _lookup<ffi.NativeFunction<CXCursor Function(CXTranslationUnit)>>( |
| 'clang_getTranslationUnitCursor'); |
| late final _clang_getTranslationUnitCursor = |
| _clang_getTranslationUnitCursorPtr |
| .asFunction<CXCursor Function(CXTranslationUnit)>(); |
| |
| /// Determine whether two cursors are equivalent. |
| int clang_equalCursors( |
| CXCursor arg0, |
| CXCursor arg1, |
| ) { |
| return _clang_equalCursors( |
| arg0, |
| arg1, |
| ); |
| } |
| |
| late final _clang_equalCursorsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXCursor, CXCursor)>>( |
| 'clang_equalCursors'); |
| late final _clang_equalCursors = |
| _clang_equalCursorsPtr.asFunction<int Function(CXCursor, CXCursor)>(); |
| |
| /// Returns non-zero if cursor is null. |
| int clang_Cursor_isNull( |
| CXCursor cursor, |
| ) { |
| return _clang_Cursor_isNull( |
| cursor, |
| ); |
| } |
| |
| late final _clang_Cursor_isNullPtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXCursor)>>( |
| 'clang_Cursor_isNull'); |
| late final _clang_Cursor_isNull = |
| _clang_Cursor_isNullPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Compute a hash value for the given cursor. |
| int clang_hashCursor( |
| CXCursor arg0, |
| ) { |
| return _clang_hashCursor( |
| arg0, |
| ); |
| } |
| |
| late final _clang_hashCursorPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXCursor)>>( |
| 'clang_hashCursor'); |
| late final _clang_hashCursor = |
| _clang_hashCursorPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Retrieve the kind of the given cursor. |
| int clang_getCursorKind( |
| CXCursor arg0, |
| ) { |
| return _clang_getCursorKind( |
| arg0, |
| ); |
| } |
| |
| late final _clang_getCursorKindPtr = |
| _lookup<ffi.NativeFunction<ffi.Int32 Function(CXCursor)>>( |
| 'clang_getCursorKind'); |
| late final _clang_getCursorKind = |
| _clang_getCursorKindPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine whether the given cursor kind represents a declaration. |
| int clang_isDeclaration( |
| int arg0, |
| ) { |
| return _clang_isDeclaration( |
| arg0, |
| ); |
| } |
| |
| late final _clang_isDeclarationPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(ffi.Int32)>>( |
| 'clang_isDeclaration'); |
| late final _clang_isDeclaration = |
| _clang_isDeclarationPtr.asFunction<int Function(int)>(); |
| |
| /// Determine whether the given declaration is invalid. |
| int clang_isInvalidDeclaration( |
| CXCursor arg0, |
| ) { |
| return _clang_isInvalidDeclaration( |
| arg0, |
| ); |
| } |
| |
| late final _clang_isInvalidDeclarationPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXCursor)>>( |
| 'clang_isInvalidDeclaration'); |
| late final _clang_isInvalidDeclaration = |
| _clang_isInvalidDeclarationPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine whether the given cursor kind represents a simple reference. |
| int clang_isReference( |
| int arg0, |
| ) { |
| return _clang_isReference( |
| arg0, |
| ); |
| } |
| |
| late final _clang_isReferencePtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(ffi.Int32)>>( |
| 'clang_isReference'); |
| late final _clang_isReference = |
| _clang_isReferencePtr.asFunction<int Function(int)>(); |
| |
| /// Determine whether the given cursor kind represents an expression. |
| int clang_isExpression( |
| int arg0, |
| ) { |
| return _clang_isExpression( |
| arg0, |
| ); |
| } |
| |
| late final _clang_isExpressionPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(ffi.Int32)>>( |
| 'clang_isExpression'); |
| late final _clang_isExpression = |
| _clang_isExpressionPtr.asFunction<int Function(int)>(); |
| |
| /// Determine whether the given cursor kind represents a statement. |
| int clang_isStatement( |
| int arg0, |
| ) { |
| return _clang_isStatement( |
| arg0, |
| ); |
| } |
| |
| late final _clang_isStatementPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(ffi.Int32)>>( |
| 'clang_isStatement'); |
| late final _clang_isStatement = |
| _clang_isStatementPtr.asFunction<int Function(int)>(); |
| |
| /// Determine whether the given cursor kind represents an attribute. |
| int clang_isAttribute( |
| int arg0, |
| ) { |
| return _clang_isAttribute( |
| arg0, |
| ); |
| } |
| |
| late final _clang_isAttributePtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(ffi.Int32)>>( |
| 'clang_isAttribute'); |
| late final _clang_isAttribute = |
| _clang_isAttributePtr.asFunction<int Function(int)>(); |
| |
| /// Determine whether the given cursor has any attributes. |
| int clang_Cursor_hasAttrs( |
| CXCursor C, |
| ) { |
| return _clang_Cursor_hasAttrs( |
| C, |
| ); |
| } |
| |
| late final _clang_Cursor_hasAttrsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXCursor)>>( |
| 'clang_Cursor_hasAttrs'); |
| late final _clang_Cursor_hasAttrs = |
| _clang_Cursor_hasAttrsPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine whether the given cursor kind represents an invalid cursor. |
| int clang_isInvalid( |
| int arg0, |
| ) { |
| return _clang_isInvalid( |
| arg0, |
| ); |
| } |
| |
| late final _clang_isInvalidPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(ffi.Int32)>>( |
| 'clang_isInvalid'); |
| late final _clang_isInvalid = |
| _clang_isInvalidPtr.asFunction<int Function(int)>(); |
| |
| /// Determine whether the given cursor kind represents a translation unit. |
| int clang_isTranslationUnit( |
| int arg0, |
| ) { |
| return _clang_isTranslationUnit( |
| arg0, |
| ); |
| } |
| |
| late final _clang_isTranslationUnitPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(ffi.Int32)>>( |
| 'clang_isTranslationUnit'); |
| late final _clang_isTranslationUnit = |
| _clang_isTranslationUnitPtr.asFunction<int Function(int)>(); |
| |
| /// * 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, |
| ); |
| } |
| |
| late final _clang_isPreprocessingPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(ffi.Int32)>>( |
| 'clang_isPreprocessing'); |
| late final _clang_isPreprocessing = |
| _clang_isPreprocessingPtr.asFunction<int Function(int)>(); |
| |
| /// * 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, |
| ); |
| } |
| |
| late final _clang_isUnexposedPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(ffi.Int32)>>( |
| 'clang_isUnexposed'); |
| late final _clang_isUnexposed = |
| _clang_isUnexposedPtr.asFunction<int Function(int)>(); |
| |
| /// Determine the linkage of the entity referred to by a given cursor. |
| int clang_getCursorLinkage( |
| CXCursor cursor, |
| ) { |
| return _clang_getCursorLinkage( |
| cursor, |
| ); |
| } |
| |
| late final _clang_getCursorLinkagePtr = |
| _lookup<ffi.NativeFunction<ffi.Int32 Function(CXCursor)>>( |
| 'clang_getCursorLinkage'); |
| late final _clang_getCursorLinkage = |
| _clang_getCursorLinkagePtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Describe the visibility of the entity referred to by a cursor. |
| int clang_getCursorVisibility( |
| CXCursor cursor, |
| ) { |
| return _clang_getCursorVisibility( |
| cursor, |
| ); |
| } |
| |
| late final _clang_getCursorVisibilityPtr = |
| _lookup<ffi.NativeFunction<ffi.Int32 Function(CXCursor)>>( |
| 'clang_getCursorVisibility'); |
| late final _clang_getCursorVisibility = |
| _clang_getCursorVisibilityPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine the availability of the entity that this cursor refers to, |
| /// taking the current target platform into account. |
| int clang_getCursorAvailability( |
| CXCursor cursor, |
| ) { |
| return _clang_getCursorAvailability( |
| cursor, |
| ); |
| } |
| |
| late final _clang_getCursorAvailabilityPtr = |
| _lookup<ffi.NativeFunction<ffi.Int32 Function(CXCursor)>>( |
| 'clang_getCursorAvailability'); |
| late final _clang_getCursorAvailability = |
| _clang_getCursorAvailabilityPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine the availability of the entity that this cursor refers to on any |
| /// platforms for which availability information is known. |
| int clang_getCursorPlatformAvailability( |
| CXCursor cursor, |
| ffi.Pointer<ffi.Int> always_deprecated, |
| ffi.Pointer<CXString> deprecated_message, |
| ffi.Pointer<ffi.Int> always_unavailable, |
| ffi.Pointer<CXString> unavailable_message, |
| ffi.Pointer<CXPlatformAvailability> availability, |
| int availability_size, |
| ) { |
| return _clang_getCursorPlatformAvailability( |
| cursor, |
| always_deprecated, |
| deprecated_message, |
| always_unavailable, |
| unavailable_message, |
| availability, |
| availability_size, |
| ); |
| } |
| |
| late final _clang_getCursorPlatformAvailabilityPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Int Function( |
| CXCursor, |
| ffi.Pointer<ffi.Int>, |
| ffi.Pointer<CXString>, |
| ffi.Pointer<ffi.Int>, |
| ffi.Pointer<CXString>, |
| ffi.Pointer<CXPlatformAvailability>, |
| ffi.Int)>>('clang_getCursorPlatformAvailability'); |
| late final _clang_getCursorPlatformAvailability = |
| _clang_getCursorPlatformAvailabilityPtr.asFunction< |
| int Function( |
| CXCursor, |
| ffi.Pointer<ffi.Int>, |
| ffi.Pointer<CXString>, |
| ffi.Pointer<ffi.Int>, |
| ffi.Pointer<CXString>, |
| ffi.Pointer<CXPlatformAvailability>, |
| int)>(); |
| |
| /// Free the memory associated with a CXPlatformAvailability structure. |
| void clang_disposeCXPlatformAvailability( |
| ffi.Pointer<CXPlatformAvailability> availability, |
| ) { |
| return _clang_disposeCXPlatformAvailability( |
| availability, |
| ); |
| } |
| |
| late final _clang_disposeCXPlatformAvailabilityPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Void Function(ffi.Pointer<CXPlatformAvailability>)>>( |
| 'clang_disposeCXPlatformAvailability'); |
| late final _clang_disposeCXPlatformAvailability = |
| _clang_disposeCXPlatformAvailabilityPtr |
| .asFunction<void Function(ffi.Pointer<CXPlatformAvailability>)>(); |
| |
| /// Determine the "language" of the entity referred to by a given cursor. |
| int clang_getCursorLanguage( |
| CXCursor cursor, |
| ) { |
| return _clang_getCursorLanguage( |
| cursor, |
| ); |
| } |
| |
| late final _clang_getCursorLanguagePtr = |
| _lookup<ffi.NativeFunction<ffi.Int32 Function(CXCursor)>>( |
| 'clang_getCursorLanguage'); |
| late final _clang_getCursorLanguage = |
| _clang_getCursorLanguagePtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine the "thread-local storage (TLS) kind" of the declaration |
| /// referred to by a cursor. |
| int clang_getCursorTLSKind( |
| CXCursor cursor, |
| ) { |
| return _clang_getCursorTLSKind( |
| cursor, |
| ); |
| } |
| |
| late final _clang_getCursorTLSKindPtr = |
| _lookup<ffi.NativeFunction<ffi.Int32 Function(CXCursor)>>( |
| 'clang_getCursorTLSKind'); |
| late final _clang_getCursorTLSKind = |
| _clang_getCursorTLSKindPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Returns the translation unit that a cursor originated from. |
| CXTranslationUnit clang_Cursor_getTranslationUnit( |
| CXCursor arg0, |
| ) { |
| return _clang_Cursor_getTranslationUnit( |
| arg0, |
| ); |
| } |
| |
| late final _clang_Cursor_getTranslationUnitPtr = |
| _lookup<ffi.NativeFunction<CXTranslationUnit Function(CXCursor)>>( |
| 'clang_Cursor_getTranslationUnit'); |
| late final _clang_Cursor_getTranslationUnit = |
| _clang_Cursor_getTranslationUnitPtr |
| .asFunction<CXTranslationUnit Function(CXCursor)>(); |
| |
| /// Creates an empty CXCursorSet. |
| CXCursorSet clang_createCXCursorSet() { |
| return _clang_createCXCursorSet(); |
| } |
| |
| late final _clang_createCXCursorSetPtr = |
| _lookup<ffi.NativeFunction<CXCursorSet Function()>>( |
| 'clang_createCXCursorSet'); |
| late final _clang_createCXCursorSet = |
| _clang_createCXCursorSetPtr.asFunction<CXCursorSet Function()>(); |
| |
| /// Disposes a CXCursorSet and releases its associated memory. |
| void clang_disposeCXCursorSet( |
| CXCursorSet cset, |
| ) { |
| return _clang_disposeCXCursorSet( |
| cset, |
| ); |
| } |
| |
| late final _clang_disposeCXCursorSetPtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(CXCursorSet)>>( |
| 'clang_disposeCXCursorSet'); |
| late final _clang_disposeCXCursorSet = |
| _clang_disposeCXCursorSetPtr.asFunction<void Function(CXCursorSet)>(); |
| |
| /// Queries a CXCursorSet to see if it contains a specific CXCursor. |
| int clang_CXCursorSet_contains( |
| CXCursorSet cset, |
| CXCursor cursor, |
| ) { |
| return _clang_CXCursorSet_contains( |
| cset, |
| cursor, |
| ); |
| } |
| |
| late final _clang_CXCursorSet_containsPtr = _lookup< |
| ffi.NativeFunction<ffi.UnsignedInt Function(CXCursorSet, CXCursor)>>( |
| 'clang_CXCursorSet_contains'); |
| late final _clang_CXCursorSet_contains = _clang_CXCursorSet_containsPtr |
| .asFunction<int Function(CXCursorSet, CXCursor)>(); |
| |
| /// Inserts a CXCursor into a CXCursorSet. |
| int clang_CXCursorSet_insert( |
| CXCursorSet cset, |
| CXCursor cursor, |
| ) { |
| return _clang_CXCursorSet_insert( |
| cset, |
| cursor, |
| ); |
| } |
| |
| late final _clang_CXCursorSet_insertPtr = _lookup< |
| ffi.NativeFunction<ffi.UnsignedInt Function(CXCursorSet, CXCursor)>>( |
| 'clang_CXCursorSet_insert'); |
| late final _clang_CXCursorSet_insert = _clang_CXCursorSet_insertPtr |
| .asFunction<int Function(CXCursorSet, CXCursor)>(); |
| |
| /// Determine the semantic parent of the given cursor. |
| CXCursor clang_getCursorSemanticParent( |
| CXCursor cursor, |
| ) { |
| return _clang_getCursorSemanticParent( |
| cursor, |
| ); |
| } |
| |
| late final _clang_getCursorSemanticParentPtr = |
| _lookup<ffi.NativeFunction<CXCursor Function(CXCursor)>>( |
| 'clang_getCursorSemanticParent'); |
| late final _clang_getCursorSemanticParent = _clang_getCursorSemanticParentPtr |
| .asFunction<CXCursor Function(CXCursor)>(); |
| |
| /// Determine the lexical parent of the given cursor. |
| CXCursor clang_getCursorLexicalParent( |
| CXCursor cursor, |
| ) { |
| return _clang_getCursorLexicalParent( |
| cursor, |
| ); |
| } |
| |
| late final _clang_getCursorLexicalParentPtr = |
| _lookup<ffi.NativeFunction<CXCursor Function(CXCursor)>>( |
| 'clang_getCursorLexicalParent'); |
| late final _clang_getCursorLexicalParent = _clang_getCursorLexicalParentPtr |
| .asFunction<CXCursor Function(CXCursor)>(); |
| |
| /// Determine the set of methods that are overridden by the given method. |
| void clang_getOverriddenCursors( |
| CXCursor cursor, |
| ffi.Pointer<ffi.Pointer<CXCursor>> overridden, |
| ffi.Pointer<ffi.UnsignedInt> num_overridden, |
| ) { |
| return _clang_getOverriddenCursors( |
| cursor, |
| overridden, |
| num_overridden, |
| ); |
| } |
| |
| late final _clang_getOverriddenCursorsPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.Void Function(CXCursor, ffi.Pointer<ffi.Pointer<CXCursor>>, |
| ffi.Pointer<ffi.UnsignedInt>)>>('clang_getOverriddenCursors'); |
| late final _clang_getOverriddenCursors = |
| _clang_getOverriddenCursorsPtr.asFunction< |
| void Function(CXCursor, ffi.Pointer<ffi.Pointer<CXCursor>>, |
| ffi.Pointer<ffi.UnsignedInt>)>(); |
| |
| /// Free the set of overridden cursors returned by |
| /// clang_getOverriddenCursors(). |
| void clang_disposeOverriddenCursors( |
| ffi.Pointer<CXCursor> overridden, |
| ) { |
| return _clang_disposeOverriddenCursors( |
| overridden, |
| ); |
| } |
| |
| late final _clang_disposeOverriddenCursorsPtr = |
| _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<CXCursor>)>>( |
| 'clang_disposeOverriddenCursors'); |
| late final _clang_disposeOverriddenCursors = |
| _clang_disposeOverriddenCursorsPtr |
| .asFunction<void Function(ffi.Pointer<CXCursor>)>(); |
| |
| /// Retrieve the file that is included by the given inclusion directive |
| /// cursor. |
| CXFile clang_getIncludedFile( |
| CXCursor cursor, |
| ) { |
| return _clang_getIncludedFile( |
| cursor, |
| ); |
| } |
| |
| late final _clang_getIncludedFilePtr = |
| _lookup<ffi.NativeFunction<CXFile Function(CXCursor)>>( |
| 'clang_getIncludedFile'); |
| late final _clang_getIncludedFile = |
| _clang_getIncludedFilePtr.asFunction<CXFile Function(CXCursor)>(); |
| |
| /// Map a source location to the cursor that describes the entity at that |
| /// location in the source code. |
| CXCursor clang_getCursor( |
| CXTranslationUnit arg0, |
| CXSourceLocation arg1, |
| ) { |
| return _clang_getCursor( |
| arg0, |
| arg1, |
| ); |
| } |
| |
| late final _clang_getCursorPtr = _lookup< |
| ffi.NativeFunction< |
| CXCursor Function( |
| CXTranslationUnit, CXSourceLocation)>>('clang_getCursor'); |
| late final _clang_getCursor = _clang_getCursorPtr |
| .asFunction<CXCursor Function(CXTranslationUnit, CXSourceLocation)>(); |
| |
| /// Retrieve the physical location of the source constructor referenced by the |
| /// given cursor. |
| CXSourceLocation clang_getCursorLocation( |
| CXCursor arg0, |
| ) { |
| return _clang_getCursorLocation( |
| arg0, |
| ); |
| } |
| |
| late final _clang_getCursorLocationPtr = |
| _lookup<ffi.NativeFunction<CXSourceLocation Function(CXCursor)>>( |
| 'clang_getCursorLocation'); |
| late final _clang_getCursorLocation = _clang_getCursorLocationPtr |
| .asFunction<CXSourceLocation Function(CXCursor)>(); |
| |
| /// Retrieve the physical extent of the source construct referenced by the |
| /// given cursor. |
| CXSourceRange clang_getCursorExtent( |
| CXCursor arg0, |
| ) { |
| return _clang_getCursorExtent( |
| arg0, |
| ); |
| } |
| |
| late final _clang_getCursorExtentPtr = |
| _lookup<ffi.NativeFunction<CXSourceRange Function(CXCursor)>>( |
| 'clang_getCursorExtent'); |
| late final _clang_getCursorExtent = |
| _clang_getCursorExtentPtr.asFunction<CXSourceRange Function(CXCursor)>(); |
| |
| /// Retrieve the type of a CXCursor (if any). |
| CXType clang_getCursorType( |
| CXCursor C, |
| ) { |
| return _clang_getCursorType( |
| C, |
| ); |
| } |
| |
| late final _clang_getCursorTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXCursor)>>( |
| 'clang_getCursorType'); |
| late final _clang_getCursorType = |
| _clang_getCursorTypePtr.asFunction<CXType Function(CXCursor)>(); |
| |
| /// Pretty-print the underlying type using the rules of the language of the |
| /// translation unit from which it came. |
| CXString clang_getTypeSpelling( |
| CXType CT, |
| ) { |
| return _clang_getTypeSpelling( |
| CT, |
| ); |
| } |
| |
| late final _clang_getTypeSpellingPtr = |
| _lookup<ffi.NativeFunction<CXString Function(CXType)>>( |
| 'clang_getTypeSpelling'); |
| late final _clang_getTypeSpelling = |
| _clang_getTypeSpellingPtr.asFunction<CXString Function(CXType)>(); |
| |
| /// Retrieve the underlying type of a typedef declaration. |
| CXType clang_getTypedefDeclUnderlyingType( |
| CXCursor C, |
| ) { |
| return _clang_getTypedefDeclUnderlyingType( |
| C, |
| ); |
| } |
| |
| late final _clang_getTypedefDeclUnderlyingTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXCursor)>>( |
| 'clang_getTypedefDeclUnderlyingType'); |
| late final _clang_getTypedefDeclUnderlyingType = |
| _clang_getTypedefDeclUnderlyingTypePtr |
| .asFunction<CXType Function(CXCursor)>(); |
| |
| /// Retrieve the integer type of an enum declaration. |
| CXType clang_getEnumDeclIntegerType( |
| CXCursor C, |
| ) { |
| return _clang_getEnumDeclIntegerType( |
| C, |
| ); |
| } |
| |
| late final _clang_getEnumDeclIntegerTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXCursor)>>( |
| 'clang_getEnumDeclIntegerType'); |
| late final _clang_getEnumDeclIntegerType = |
| _clang_getEnumDeclIntegerTypePtr.asFunction<CXType Function(CXCursor)>(); |
| |
| /// Retrieve the integer value of an enum constant declaration as a signed |
| /// long long. |
| int clang_getEnumConstantDeclValue( |
| CXCursor C, |
| ) { |
| return _clang_getEnumConstantDeclValue( |
| C, |
| ); |
| } |
| |
| late final _clang_getEnumConstantDeclValuePtr = |
| _lookup<ffi.NativeFunction<ffi.LongLong Function(CXCursor)>>( |
| 'clang_getEnumConstantDeclValue'); |
| late final _clang_getEnumConstantDeclValue = |
| _clang_getEnumConstantDeclValuePtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Retrieve the integer value of an enum constant declaration as an unsigned |
| /// long long. |
| int clang_getEnumConstantDeclUnsignedValue( |
| CXCursor C, |
| ) { |
| return _clang_getEnumConstantDeclUnsignedValue( |
| C, |
| ); |
| } |
| |
| late final _clang_getEnumConstantDeclUnsignedValuePtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedLongLong Function(CXCursor)>>( |
| 'clang_getEnumConstantDeclUnsignedValue'); |
| late final _clang_getEnumConstantDeclUnsignedValue = |
| _clang_getEnumConstantDeclUnsignedValuePtr |
| .asFunction<int Function(CXCursor)>(); |
| |
| /// Retrieve the bit width of a bit field declaration as an integer. |
| int clang_getFieldDeclBitWidth( |
| CXCursor C, |
| ) { |
| return _clang_getFieldDeclBitWidth( |
| C, |
| ); |
| } |
| |
| late final _clang_getFieldDeclBitWidthPtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXCursor)>>( |
| 'clang_getFieldDeclBitWidth'); |
| late final _clang_getFieldDeclBitWidth = |
| _clang_getFieldDeclBitWidthPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Retrieve the number of non-variadic arguments associated with a given |
| /// cursor. |
| int clang_Cursor_getNumArguments( |
| CXCursor C, |
| ) { |
| return _clang_Cursor_getNumArguments( |
| C, |
| ); |
| } |
| |
| late final _clang_Cursor_getNumArgumentsPtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXCursor)>>( |
| 'clang_Cursor_getNumArguments'); |
| late final _clang_Cursor_getNumArguments = |
| _clang_Cursor_getNumArgumentsPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Retrieve the argument cursor of a function or method. |
| CXCursor clang_Cursor_getArgument( |
| CXCursor C, |
| int i, |
| ) { |
| return _clang_Cursor_getArgument( |
| C, |
| i, |
| ); |
| } |
| |
| late final _clang_Cursor_getArgumentPtr = |
| _lookup<ffi.NativeFunction<CXCursor Function(CXCursor, ffi.UnsignedInt)>>( |
| 'clang_Cursor_getArgument'); |
| late final _clang_Cursor_getArgument = _clang_Cursor_getArgumentPtr |
| .asFunction<CXCursor Function(CXCursor, int)>(); |
| |
| /// Returns the number of template args of a function decl representing a |
| /// template specialization. |
| int clang_Cursor_getNumTemplateArguments( |
| CXCursor C, |
| ) { |
| return _clang_Cursor_getNumTemplateArguments( |
| C, |
| ); |
| } |
| |
| late final _clang_Cursor_getNumTemplateArgumentsPtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXCursor)>>( |
| 'clang_Cursor_getNumTemplateArguments'); |
| late final _clang_Cursor_getNumTemplateArguments = |
| _clang_Cursor_getNumTemplateArgumentsPtr |
| .asFunction<int Function(CXCursor)>(); |
| |
| /// Retrieve the kind of the I'th template argument of the CXCursor C. |
| int clang_Cursor_getTemplateArgumentKind( |
| CXCursor C, |
| int I, |
| ) { |
| return _clang_Cursor_getTemplateArgumentKind( |
| C, |
| I, |
| ); |
| } |
| |
| late final _clang_Cursor_getTemplateArgumentKindPtr = _lookup< |
| ffi.NativeFunction<ffi.Int32 Function(CXCursor, ffi.UnsignedInt)>>( |
| 'clang_Cursor_getTemplateArgumentKind'); |
| late final _clang_Cursor_getTemplateArgumentKind = |
| _clang_Cursor_getTemplateArgumentKindPtr |
| .asFunction<int Function(CXCursor, int)>(); |
| |
| /// Retrieve a CXType representing the type of a TemplateArgument of a |
| /// function decl representing a template specialization. |
| CXType clang_Cursor_getTemplateArgumentType( |
| CXCursor C, |
| int I, |
| ) { |
| return _clang_Cursor_getTemplateArgumentType( |
| C, |
| I, |
| ); |
| } |
| |
| late final _clang_Cursor_getTemplateArgumentTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXCursor, ffi.UnsignedInt)>>( |
| 'clang_Cursor_getTemplateArgumentType'); |
| late final _clang_Cursor_getTemplateArgumentType = |
| _clang_Cursor_getTemplateArgumentTypePtr |
| .asFunction<CXType Function(CXCursor, int)>(); |
| |
| /// Retrieve the value of an Integral TemplateArgument (of a function decl |
| /// representing a template specialization) as a signed long long. |
| int clang_Cursor_getTemplateArgumentValue( |
| CXCursor C, |
| int I, |
| ) { |
| return _clang_Cursor_getTemplateArgumentValue( |
| C, |
| I, |
| ); |
| } |
| |
| late final _clang_Cursor_getTemplateArgumentValuePtr = _lookup< |
| ffi.NativeFunction<ffi.LongLong Function(CXCursor, ffi.UnsignedInt)>>( |
| 'clang_Cursor_getTemplateArgumentValue'); |
| late final _clang_Cursor_getTemplateArgumentValue = |
| _clang_Cursor_getTemplateArgumentValuePtr |
| .asFunction<int Function(CXCursor, int)>(); |
| |
| /// Retrieve the value of an Integral TemplateArgument (of a function decl |
| /// representing a template specialization) as an unsigned long long. |
| int clang_Cursor_getTemplateArgumentUnsignedValue( |
| CXCursor C, |
| int I, |
| ) { |
| return _clang_Cursor_getTemplateArgumentUnsignedValue( |
| C, |
| I, |
| ); |
| } |
| |
| late final _clang_Cursor_getTemplateArgumentUnsignedValuePtr = _lookup< |
| ffi.NativeFunction< |
| ffi.UnsignedLongLong Function(CXCursor, ffi.UnsignedInt)>>( |
| 'clang_Cursor_getTemplateArgumentUnsignedValue'); |
| late final _clang_Cursor_getTemplateArgumentUnsignedValue = |
| _clang_Cursor_getTemplateArgumentUnsignedValuePtr |
| .asFunction<int Function(CXCursor, int)>(); |
| |
| /// Determine whether two CXTypes represent the same type. |
| int clang_equalTypes( |
| CXType A, |
| CXType B, |
| ) { |
| return _clang_equalTypes( |
| A, |
| B, |
| ); |
| } |
| |
| late final _clang_equalTypesPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXType, CXType)>>( |
| 'clang_equalTypes'); |
| late final _clang_equalTypes = |
| _clang_equalTypesPtr.asFunction<int Function(CXType, CXType)>(); |
| |
| /// Return the canonical type for a CXType. |
| CXType clang_getCanonicalType( |
| CXType T, |
| ) { |
| return _clang_getCanonicalType( |
| T, |
| ); |
| } |
| |
| late final _clang_getCanonicalTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType)>>( |
| 'clang_getCanonicalType'); |
| late final _clang_getCanonicalType = |
| _clang_getCanonicalTypePtr.asFunction<CXType Function(CXType)>(); |
| |
| /// Determine whether a CXType has the "const" qualifier set, without looking |
| /// through typedefs that may have added "const" at a different level. |
| int clang_isConstQualifiedType( |
| CXType T, |
| ) { |
| return _clang_isConstQualifiedType( |
| T, |
| ); |
| } |
| |
| late final _clang_isConstQualifiedTypePtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXType)>>( |
| 'clang_isConstQualifiedType'); |
| late final _clang_isConstQualifiedType = |
| _clang_isConstQualifiedTypePtr.asFunction<int Function(CXType)>(); |
| |
| /// Determine whether a CXCursor that is a macro, is function like. |
| int clang_Cursor_isMacroFunctionLike( |
| CXCursor C, |
| ) { |
| return _clang_Cursor_isMacroFunctionLike( |
| C, |
| ); |
| } |
| |
| late final _clang_Cursor_isMacroFunctionLikePtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXCursor)>>( |
| 'clang_Cursor_isMacroFunctionLike'); |
| late final _clang_Cursor_isMacroFunctionLike = |
| _clang_Cursor_isMacroFunctionLikePtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine whether a CXCursor that is a macro, is a builtin one. |
| int clang_Cursor_isMacroBuiltin( |
| CXCursor C, |
| ) { |
| return _clang_Cursor_isMacroBuiltin( |
| C, |
| ); |
| } |
| |
| late final _clang_Cursor_isMacroBuiltinPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXCursor)>>( |
| 'clang_Cursor_isMacroBuiltin'); |
| late final _clang_Cursor_isMacroBuiltin = |
| _clang_Cursor_isMacroBuiltinPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine whether a CXCursor that is a function declaration, is an inline |
| /// declaration. |
| int clang_Cursor_isFunctionInlined( |
| CXCursor C, |
| ) { |
| return _clang_Cursor_isFunctionInlined( |
| C, |
| ); |
| } |
| |
| late final _clang_Cursor_isFunctionInlinedPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXCursor)>>( |
| 'clang_Cursor_isFunctionInlined'); |
| late final _clang_Cursor_isFunctionInlined = |
| _clang_Cursor_isFunctionInlinedPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine whether a CXType has the "volatile" qualifier set, without |
| /// looking through typedefs that may have added "volatile" at a different |
| /// level. |
| int clang_isVolatileQualifiedType( |
| CXType T, |
| ) { |
| return _clang_isVolatileQualifiedType( |
| T, |
| ); |
| } |
| |
| late final _clang_isVolatileQualifiedTypePtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXType)>>( |
| 'clang_isVolatileQualifiedType'); |
| late final _clang_isVolatileQualifiedType = |
| _clang_isVolatileQualifiedTypePtr.asFunction<int Function(CXType)>(); |
| |
| /// Determine whether a CXType has the "restrict" qualifier set, without |
| /// looking through typedefs that may have added "restrict" at a different |
| /// level. |
| int clang_isRestrictQualifiedType( |
| CXType T, |
| ) { |
| return _clang_isRestrictQualifiedType( |
| T, |
| ); |
| } |
| |
| late final _clang_isRestrictQualifiedTypePtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXType)>>( |
| 'clang_isRestrictQualifiedType'); |
| late final _clang_isRestrictQualifiedType = |
| _clang_isRestrictQualifiedTypePtr.asFunction<int Function(CXType)>(); |
| |
| /// Returns the address space of the given type. |
| int clang_getAddressSpace( |
| CXType T, |
| ) { |
| return _clang_getAddressSpace( |
| T, |
| ); |
| } |
| |
| late final _clang_getAddressSpacePtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXType)>>( |
| 'clang_getAddressSpace'); |
| late final _clang_getAddressSpace = |
| _clang_getAddressSpacePtr.asFunction<int Function(CXType)>(); |
| |
| /// Returns the typedef name of the given type. |
| CXString clang_getTypedefName( |
| CXType CT, |
| ) { |
| return _clang_getTypedefName( |
| CT, |
| ); |
| } |
| |
| late final _clang_getTypedefNamePtr = |
| _lookup<ffi.NativeFunction<CXString Function(CXType)>>( |
| 'clang_getTypedefName'); |
| late final _clang_getTypedefName = |
| _clang_getTypedefNamePtr.asFunction<CXString Function(CXType)>(); |
| |
| /// For pointer types, returns the type of the pointee. |
| CXType clang_getPointeeType( |
| CXType T, |
| ) { |
| return _clang_getPointeeType( |
| T, |
| ); |
| } |
| |
| late final _clang_getPointeeTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType)>>( |
| 'clang_getPointeeType'); |
| late final _clang_getPointeeType = |
| _clang_getPointeeTypePtr.asFunction<CXType Function(CXType)>(); |
| |
| /// Return the cursor for the declaration of the given type. |
| CXCursor clang_getTypeDeclaration( |
| CXType T, |
| ) { |
| return _clang_getTypeDeclaration( |
| T, |
| ); |
| } |
| |
| late final _clang_getTypeDeclarationPtr = |
| _lookup<ffi.NativeFunction<CXCursor Function(CXType)>>( |
| 'clang_getTypeDeclaration'); |
| late final _clang_getTypeDeclaration = |
| _clang_getTypeDeclarationPtr.asFunction<CXCursor Function(CXType)>(); |
| |
| /// Returns the Objective-C type encoding for the specified declaration. |
| CXString clang_getDeclObjCTypeEncoding( |
| CXCursor C, |
| ) { |
| return _clang_getDeclObjCTypeEncoding( |
| C, |
| ); |
| } |
| |
| late final _clang_getDeclObjCTypeEncodingPtr = |
| _lookup<ffi.NativeFunction<CXString Function(CXCursor)>>( |
| 'clang_getDeclObjCTypeEncoding'); |
| late final _clang_getDeclObjCTypeEncoding = _clang_getDeclObjCTypeEncodingPtr |
| .asFunction<CXString Function(CXCursor)>(); |
| |
| /// Returns the Objective-C type encoding for the specified CXType. |
| CXString clang_Type_getObjCEncoding( |
| CXType type, |
| ) { |
| return _clang_Type_getObjCEncoding( |
| type, |
| ); |
| } |
| |
| late final _clang_Type_getObjCEncodingPtr = |
| _lookup<ffi.NativeFunction<CXString Function(CXType)>>( |
| 'clang_Type_getObjCEncoding'); |
| late final _clang_Type_getObjCEncoding = |
| _clang_Type_getObjCEncodingPtr.asFunction<CXString Function(CXType)>(); |
| |
| /// Retrieve the spelling of a given CXTypeKind. |
| CXString clang_getTypeKindSpelling( |
| int K, |
| ) { |
| return _clang_getTypeKindSpelling( |
| K, |
| ); |
| } |
| |
| late final _clang_getTypeKindSpellingPtr = |
| _lookup<ffi.NativeFunction<CXString Function(ffi.Int32)>>( |
| 'clang_getTypeKindSpelling'); |
| late final _clang_getTypeKindSpelling = |
| _clang_getTypeKindSpellingPtr.asFunction<CXString Function(int)>(); |
| |
| /// Retrieve the calling convention associated with a function type. |
| int clang_getFunctionTypeCallingConv( |
| CXType T, |
| ) { |
| return _clang_getFunctionTypeCallingConv( |
| T, |
| ); |
| } |
| |
| late final _clang_getFunctionTypeCallingConvPtr = |
| _lookup<ffi.NativeFunction<ffi.Int32 Function(CXType)>>( |
| 'clang_getFunctionTypeCallingConv'); |
| late final _clang_getFunctionTypeCallingConv = |
| _clang_getFunctionTypeCallingConvPtr.asFunction<int Function(CXType)>(); |
| |
| /// Retrieve the return type associated with a function type. |
| CXType clang_getResultType( |
| CXType T, |
| ) { |
| return _clang_getResultType( |
| T, |
| ); |
| } |
| |
| late final _clang_getResultTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType)>>( |
| 'clang_getResultType'); |
| late final _clang_getResultType = |
| _clang_getResultTypePtr.asFunction<CXType Function(CXType)>(); |
| |
| /// Retrieve the exception specification type associated with a function type. |
| /// This is a value of type CXCursor_ExceptionSpecificationKind. |
| int clang_getExceptionSpecificationType( |
| CXType T, |
| ) { |
| return _clang_getExceptionSpecificationType( |
| T, |
| ); |
| } |
| |
| late final _clang_getExceptionSpecificationTypePtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXType)>>( |
| 'clang_getExceptionSpecificationType'); |
| late final _clang_getExceptionSpecificationType = |
| _clang_getExceptionSpecificationTypePtr |
| .asFunction<int Function(CXType)>(); |
| |
| /// Retrieve the number of non-variadic parameters associated with a function |
| /// type. |
| int clang_getNumArgTypes( |
| CXType T, |
| ) { |
| return _clang_getNumArgTypes( |
| T, |
| ); |
| } |
| |
| late final _clang_getNumArgTypesPtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXType)>>( |
| 'clang_getNumArgTypes'); |
| late final _clang_getNumArgTypes = |
| _clang_getNumArgTypesPtr.asFunction<int Function(CXType)>(); |
| |
| /// Retrieve the type of a parameter of a function type. |
| CXType clang_getArgType( |
| CXType T, |
| int i, |
| ) { |
| return _clang_getArgType( |
| T, |
| i, |
| ); |
| } |
| |
| late final _clang_getArgTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType, ffi.UnsignedInt)>>( |
| 'clang_getArgType'); |
| late final _clang_getArgType = |
| _clang_getArgTypePtr.asFunction<CXType Function(CXType, int)>(); |
| |
| /// Retrieves the base type of the ObjCObjectType. |
| CXType clang_Type_getObjCObjectBaseType( |
| CXType T, |
| ) { |
| return _clang_Type_getObjCObjectBaseType( |
| T, |
| ); |
| } |
| |
| late final _clang_Type_getObjCObjectBaseTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType)>>( |
| 'clang_Type_getObjCObjectBaseType'); |
| late final _clang_Type_getObjCObjectBaseType = |
| _clang_Type_getObjCObjectBaseTypePtr |
| .asFunction<CXType Function(CXType)>(); |
| |
| /// Retrieve the number of protocol references associated with an ObjC |
| /// object/id. |
| int clang_Type_getNumObjCProtocolRefs( |
| CXType T, |
| ) { |
| return _clang_Type_getNumObjCProtocolRefs( |
| T, |
| ); |
| } |
| |
| late final _clang_Type_getNumObjCProtocolRefsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXType)>>( |
| 'clang_Type_getNumObjCProtocolRefs'); |
| late final _clang_Type_getNumObjCProtocolRefs = |
| _clang_Type_getNumObjCProtocolRefsPtr.asFunction<int Function(CXType)>(); |
| |
| /// Retrieve the decl for a protocol reference for an ObjC object/id. |
| CXCursor clang_Type_getObjCProtocolDecl( |
| CXType T, |
| int i, |
| ) { |
| return _clang_Type_getObjCProtocolDecl( |
| T, |
| i, |
| ); |
| } |
| |
| late final _clang_Type_getObjCProtocolDeclPtr = |
| _lookup<ffi.NativeFunction<CXCursor Function(CXType, ffi.UnsignedInt)>>( |
| 'clang_Type_getObjCProtocolDecl'); |
| late final _clang_Type_getObjCProtocolDecl = |
| _clang_Type_getObjCProtocolDeclPtr |
| .asFunction<CXCursor Function(CXType, int)>(); |
| |
| /// Retreive the number of type arguments associated with an ObjC object. |
| int clang_Type_getNumObjCTypeArgs( |
| CXType T, |
| ) { |
| return _clang_Type_getNumObjCTypeArgs( |
| T, |
| ); |
| } |
| |
| late final _clang_Type_getNumObjCTypeArgsPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXType)>>( |
| 'clang_Type_getNumObjCTypeArgs'); |
| late final _clang_Type_getNumObjCTypeArgs = |
| _clang_Type_getNumObjCTypeArgsPtr.asFunction<int Function(CXType)>(); |
| |
| /// Retrieve a type argument associated with an ObjC object. |
| CXType clang_Type_getObjCTypeArg( |
| CXType T, |
| int i, |
| ) { |
| return _clang_Type_getObjCTypeArg( |
| T, |
| i, |
| ); |
| } |
| |
| late final _clang_Type_getObjCTypeArgPtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType, ffi.UnsignedInt)>>( |
| 'clang_Type_getObjCTypeArg'); |
| late final _clang_Type_getObjCTypeArg = |
| _clang_Type_getObjCTypeArgPtr.asFunction<CXType Function(CXType, int)>(); |
| |
| /// Return 1 if the CXType is a variadic function type, and 0 otherwise. |
| int clang_isFunctionTypeVariadic( |
| CXType T, |
| ) { |
| return _clang_isFunctionTypeVariadic( |
| T, |
| ); |
| } |
| |
| late final _clang_isFunctionTypeVariadicPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXType)>>( |
| 'clang_isFunctionTypeVariadic'); |
| late final _clang_isFunctionTypeVariadic = |
| _clang_isFunctionTypeVariadicPtr.asFunction<int Function(CXType)>(); |
| |
| /// Retrieve the return type associated with a given cursor. |
| CXType clang_getCursorResultType( |
| CXCursor C, |
| ) { |
| return _clang_getCursorResultType( |
| C, |
| ); |
| } |
| |
| late final _clang_getCursorResultTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXCursor)>>( |
| 'clang_getCursorResultType'); |
| late final _clang_getCursorResultType = |
| _clang_getCursorResultTypePtr.asFunction<CXType Function(CXCursor)>(); |
| |
| /// Retrieve the exception specification type associated with a given cursor. |
| /// This is a value of type CXCursor_ExceptionSpecificationKind. |
| int clang_getCursorExceptionSpecificationType( |
| CXCursor C, |
| ) { |
| return _clang_getCursorExceptionSpecificationType( |
| C, |
| ); |
| } |
| |
| late final _clang_getCursorExceptionSpecificationTypePtr = |
| _lookup<ffi.NativeFunction<ffi.Int Function(CXCursor)>>( |
| 'clang_getCursorExceptionSpecificationType'); |
| late final _clang_getCursorExceptionSpecificationType = |
| _clang_getCursorExceptionSpecificationTypePtr |
| .asFunction<int Function(CXCursor)>(); |
| |
| /// Return 1 if the CXType is a POD (plain old data) type, and 0 otherwise. |
| int clang_isPODType( |
| CXType T, |
| ) { |
| return _clang_isPODType( |
| T, |
| ); |
| } |
| |
| late final _clang_isPODTypePtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXType)>>( |
| 'clang_isPODType'); |
| late final _clang_isPODType = |
| _clang_isPODTypePtr.asFunction<int Function(CXType)>(); |
| |
| /// Return the element type of an array, complex, or vector type. |
| CXType clang_getElementType( |
| CXType T, |
| ) { |
| return _clang_getElementType( |
| T, |
| ); |
| } |
| |
| late final _clang_getElementTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType)>>( |
| 'clang_getElementType'); |
| late final _clang_getElementType = |
| _clang_getElementTypePtr.asFunction<CXType Function(CXType)>(); |
| |
| /// Return the number of elements of an array or vector type. |
| int clang_getNumElements( |
| CXType T, |
| ) { |
| return _clang_getNumElements( |
| T, |
| ); |
| } |
| |
| late final _clang_getNumElementsPtr = |
| _lookup<ffi.NativeFunction<ffi.LongLong Function(CXType)>>( |
| 'clang_getNumElements'); |
| late final _clang_getNumElements = |
| _clang_getNumElementsPtr.asFunction<int Function(CXType)>(); |
| |
| /// Return the element type of an array type. |
| CXType clang_getArrayElementType( |
| CXType T, |
| ) { |
| return _clang_getArrayElementType( |
| T, |
| ); |
| } |
| |
| late final _clang_getArrayElementTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType)>>( |
| 'clang_getArrayElementType'); |
| late final _clang_getArrayElementType = |
| _clang_getArrayElementTypePtr.asFunction<CXType Function(CXType)>(); |
| |
| /// Return the array size of a constant array. |
| int clang_getArraySize( |
| CXType T, |
| ) { |
| return _clang_getArraySize( |
| T, |
| ); |
| } |
| |
| late final _clang_getArraySizePtr = |
| _lookup<ffi.NativeFunction<ffi.LongLong Function(CXType)>>( |
| 'clang_getArraySize'); |
| late final _clang_getArraySize = |
| _clang_getArraySizePtr.asFunction<int Function(CXType)>(); |
| |
| /// Retrieve the type named by the qualified-id. |
| CXType clang_Type_getNamedType( |
| CXType T, |
| ) { |
| return _clang_Type_getNamedType( |
| T, |
| ); |
| } |
| |
| late final _clang_Type_getNamedTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType)>>( |
| 'clang_Type_getNamedType'); |
| late final _clang_Type_getNamedType = |
| _clang_Type_getNamedTypePtr.asFunction<CXType Function(CXType)>(); |
| |
| /// Determine if a typedef is 'transparent' tag. |
| int clang_Type_isTransparentTagTypedef( |
| CXType T, |
| ) { |
| return _clang_Type_isTransparentTagTypedef( |
| T, |
| ); |
| } |
| |
| late final _clang_Type_isTransparentTagTypedefPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXType)>>( |
| 'clang_Type_isTransparentTagTypedef'); |
| late final _clang_Type_isTransparentTagTypedef = |
| _clang_Type_isTransparentTagTypedefPtr.asFunction<int Function(CXType)>(); |
| |
| /// Retrieve the nullability kind of a pointer type. |
| int clang_Type_getNullability( |
| CXType T, |
| ) { |
| return _clang_Type_getNullability( |
| T, |
| ); |
| } |
| |
| late final _clang_Type_getNullabilityPtr = |
| _lookup<ffi.NativeFunction<ffi.Int32 Function(CXType)>>( |
| 'clang_Type_getNullability'); |
| late final _clang_Type_getNullability = |
| _clang_Type_getNullabilityPtr.asFunction<int Function(CXType)>(); |
| |
| /// Return the alignment of a type in bytes as per C++[expr.alignof] standard. |
| int clang_Type_getAlignOf( |
| CXType T, |
| ) { |
| return _clang_Type_getAlignOf( |
| T, |
| ); |
| } |
| |
| late final _clang_Type_getAlignOfPtr = |
| _lookup<ffi.NativeFunction<ffi.LongLong Function(CXType)>>( |
| 'clang_Type_getAlignOf'); |
| late final _clang_Type_getAlignOf = |
| _clang_Type_getAlignOfPtr.asFunction<int Function(CXType)>(); |
| |
| /// Return the class type of an member pointer type. |
| CXType clang_Type_getClassType( |
| CXType T, |
| ) { |
| return _clang_Type_getClassType( |
| T, |
| ); |
| } |
| |
| late final _clang_Type_getClassTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType)>>( |
| 'clang_Type_getClassType'); |
| late final _clang_Type_getClassType = |
| _clang_Type_getClassTypePtr.asFunction<CXType Function(CXType)>(); |
| |
| /// Return the size of a type in bytes as per C++[expr.sizeof] standard. |
| int clang_Type_getSizeOf( |
| CXType T, |
| ) { |
| return _clang_Type_getSizeOf( |
| T, |
| ); |
| } |
| |
| late final _clang_Type_getSizeOfPtr = |
| _lookup<ffi.NativeFunction<ffi.LongLong Function(CXType)>>( |
| 'clang_Type_getSizeOf'); |
| late final _clang_Type_getSizeOf = |
| _clang_Type_getSizeOfPtr.asFunction<int Function(CXType)>(); |
| |
| /// Return the offset of a field named S in a record of type T in bits as it |
| /// would be returned by __offsetof__ as per C++11[18.2p4] |
| int clang_Type_getOffsetOf( |
| CXType T, |
| ffi.Pointer<ffi.Char> S, |
| ) { |
| return _clang_Type_getOffsetOf( |
| T, |
| S, |
| ); |
| } |
| |
| late final _clang_Type_getOffsetOfPtr = _lookup< |
| ffi.NativeFunction< |
| ffi.LongLong Function( |
| CXType, ffi.Pointer<ffi.Char>)>>('clang_Type_getOffsetOf'); |
| late final _clang_Type_getOffsetOf = _clang_Type_getOffsetOfPtr |
| .asFunction<int Function(CXType, ffi.Pointer<ffi.Char>)>(); |
| |
| /// Return the type that was modified by this attributed type. |
| CXType clang_Type_getModifiedType( |
| CXType T, |
| ) { |
| return _clang_Type_getModifiedType( |
| T, |
| ); |
| } |
| |
| late final _clang_Type_getModifiedTypePtr = |
| _lookup<ffi.NativeFunction<CXType Function(CXType)>>( |
| 'clang_Type_getModifiedType'); |
| late final _clang_Type_getModifiedType = |
| _clang_Type_getModifiedTypePtr.asFunction<CXType Function(CXType)>(); |
| |
| /// Return the offset of the field represented by the Cursor. |
| int clang_Cursor_getOffsetOfField( |
| CXCursor C, |
| ) { |
| return _clang_Cursor_getOffsetOfField( |
| C, |
| ); |
| } |
| |
| late final _clang_Cursor_getOffsetOfFieldPtr = |
| _lookup<ffi.NativeFunction<ffi.LongLong Function(CXCursor)>>( |
| 'clang_Cursor_getOffsetOfField'); |
| late final _clang_Cursor_getOffsetOfField = |
| _clang_Cursor_getOffsetOfFieldPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine whether the given cursor represents an anonymous tag or |
| /// namespace |
| int clang_Cursor_isAnonymous( |
| CXCursor C, |
| ) { |
| return _clang_Cursor_isAnonymous( |
| C, |
| ); |
| } |
| |
| late final _clang_Cursor_isAnonymousPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXCursor)>>( |
| 'clang_Cursor_isAnonymous'); |
| late final _clang_Cursor_isAnonymous = |
| _clang_Cursor_isAnonymousPtr.asFunction<int Function(CXCursor)>(); |
| |
| /// Determine whether the given cursor represents an anonymous record |
| /// declaration. |
| int clang_Cursor_isAnonymousRecordDecl( |
| CXCursor C, |
| ) { |
| return _clang_Cursor_isAnonymousRecordDecl( |
| C, |
| ); |
| } |
| |
| late final _clang_Cursor_isAnonymousRecordDeclPtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function(CXCursor)>>( |
| 'clang_Cursor_isAnonymousRecordDecl'); |
| late final _clang_Cursor_isAnonymousRecordDecl = |
| _clang_Cursor_isAnonymousRecordDeclPtr |
| .asFunction<int Function(CXCursor)>(); |
| |
| /// Determine whether the given cursor represents an inline namespace |
| /// declaration. |
| int clang_Cursor_isInlineNamespace( |
| CXCursor C, |
| ) { |
| return _clang_Cursor_isInlineNamespace( |
| C, |
| ); |
| } |
| |
| late final _clang_Cursor_isInlineNamespacePtr = |
| _lookup<ffi.NativeFunction<ffi.UnsignedInt Function<
|